Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
12,500
|
SyntaxHighlighter (Project project, VirtualFile virtualFile) { return new LombokConfigSyntaxHighlighter(); }
|
getSyntaxHighlighter
|
12,501
|
Icon () { return LombokIcons.Config; }
|
getIcon
|
12,502
|
SyntaxHighlighter () { return new LombokConfigSyntaxHighlighter(); }
|
getHighlighter
|
12,503
|
String () { return """ ## ## Key : lombok.log.fieldName ## Type: string ## ## Use this name for the generated logger fields (default: 'log') ## ## Examples: # clear lombok.log.fieldName lombok.log.fieldName = LOGGER """; }
|
getDemoText
|
12,504
|
String () { return LombokBundle.message("configurable.name.lombok.config"); }
|
getDisplayName
|
12,505
|
String () { return "LOMBOK_CONFIG"; }
|
getName
|
12,506
|
String () { return LombokBundle.message("filetype.lombok.config.description"); }
|
getDescription
|
12,507
|
String () { return "config"; }
|
getDefaultExtension
|
12,508
|
Icon () { return LombokIcons.Config; }
|
getIcon
|
12,509
|
String () { return "LombokConfigTokenType." + super.toString(); }
|
toString
|
12,510
|
String (@NotNull LombokConfigCleaner element) { return getNodeText(element.getNode(), LombokConfigTypes.KEY); }
|
getKey
|
12,511
|
String (@NotNull LombokConfigProperty element) { return getNodeText(element.getNode(), LombokConfigTypes.KEY); }
|
getKey
|
12,512
|
String (@NotNull LombokConfigProperty element) { return getNodeText(element.getNode(), LombokConfigTypes.VALUE); }
|
getValue
|
12,513
|
String (@NotNull LombokConfigProperty element) { return StringUtil.trim(getNodeText(element.getOperation().getNode(), LombokConfigTypes.SIGN)); }
|
getSign
|
12,514
|
String (@NotNull LombokConfigOperation element) { return StringUtil.trim(getNodeText(element.getNode(), LombokConfigTypes.SIGN)); }
|
getSign
|
12,515
|
String (@NotNull ASTNode node, @NotNull IElementType type) { final ASTNode valueNode = node.findChildByType(type); if (valueNode != null) { return valueNode.getText(); } else { return null; } }
|
getNodeText
|
12,516
|
FileType () { return LombokConfigFileType.INSTANCE; }
|
getFileType
|
12,517
|
String () { return "LombokConfigFile"; }
|
toString
|
12,518
|
Icon (int flags) { return super.getIcon(flags); }
|
getIcon
|
12,519
|
boolean (@NotNull Project project, final String propertyName) { return PropertiesComponent.getInstance(project).getBoolean(propertyName, true); }
|
isEnabled
|
12,520
|
boolean (@NotNull Project project, final String propertyName, boolean defaultValue) { return PropertiesComponent.getInstance(project).getBoolean(propertyName, defaultValue); }
|
isEnabled
|
12,521
|
void (@NotNull Project project, final String propertyName, boolean value) { PropertiesComponent.getInstance(project).setValue(propertyName, String.valueOf(value), ""); }
|
setEnabled
|
12,522
|
String () { return LombokBundle.message("plugin.settings.title"); }
|
getDisplayName
|
12,523
|
JComponent () { initFromSettings(); return myGeneralPanel; }
|
createComponent
|
12,524
|
void () { myEnableJSPFix.setSelected(isEnabled(myProject, ProjectSettings.IS_LOMBOK_JPS_FIX_ENABLED)); }
|
initFromSettings
|
12,525
|
boolean () { return myEnableJSPFix.isSelected() != isEnabled(myProject, ProjectSettings.IS_LOMBOK_JPS_FIX_ENABLED); }
|
isModified
|
12,526
|
void () { setEnabled(myProject, ProjectSettings.IS_LOMBOK_JPS_FIX_ENABLED, myEnableJSPFix.isSelected()); }
|
apply
|
12,527
|
void () { initFromSettings(); }
|
reset
|
12,528
|
String () { return getDisplayName(); }
|
getId
|
12,529
|
void (Supplier<LocalQuickFix>... quickFixSuppliers) { this.quickFixes = ContainerUtil.map2Array(quickFixSuppliers, LocalQuickFix.class, Supplier<LocalQuickFix>::get); }
|
withLocalQuickFixes
|
12,530
|
ProblemHighlightType () { return highlightType; }
|
getHighlightType
|
12,531
|
LocalQuickFix[] () { return quickFixes; }
|
getQuickFixes
|
12,532
|
String () { return message; }
|
getMessage
|
12,533
|
boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } LombokProblemInstance that = (LombokProblemInstance)o; return Objects.equals(message, that.message); }
|
equals
|
12,534
|
int () { return Objects.hashCode(message); }
|
hashCode
|
12,535
|
boolean () { return false; }
|
deepValidation
|
12,536
|
boolean () { return !validationFailed; }
|
success
|
12,537
|
void () { validationFailed = true; }
|
markFailed
|
12,538
|
LombokProblem (@NotNull String key, Object @NotNull ... params) { return LombokProblem.BLACKHOLE; }
|
addWarningMessage
|
12,539
|
LombokProblem (@NotNull String key, Object @NotNull ... params) { return LombokProblem.BLACKHOLE; }
|
addErrorMessage
|
12,540
|
boolean () { return true; }
|
deepValidation
|
12,541
|
boolean () { return !validationFailed; }
|
success
|
12,542
|
void () { validationFailed = true; }
|
markFailed
|
12,543
|
Set<LombokProblem> () { return problems; }
|
getProblems
|
12,544
|
LombokProblemInstance (@NotNull String key, Object @NotNull ... params) { return addProblem(LombokBundle.message(key, params), ProblemHighlightType.GENERIC_ERROR_OR_WARNING); }
|
addWarningMessage
|
12,545
|
LombokProblemInstance (@NotNull String key, Object @NotNull ... params) { return addProblem(LombokBundle.message(key, params), ProblemHighlightType.GENERIC_ERROR); }
|
addErrorMessage
|
12,546
|
LombokProblemInstance (@InspectionMessage String message, ProblemHighlightType highlightType) { final LombokProblemInstance lombokProblem = new LombokProblemInstance(message, highlightType); problems.add(lombokProblem); return lombokProblem; }
|
addProblem
|
12,547
|
void (Supplier<LocalQuickFix>... quickFixSuppliers) { }
|
withLocalQuickFixes
|
12,548
|
ProblemHighlightType () { return ProblemHighlightType.INFORMATION; }
|
getHighlightType
|
12,549
|
LocalQuickFix[] () { return LocalQuickFix.EMPTY_ARRAY; }
|
getQuickFixes
|
12,550
|
String () { return null; }
|
getMessage
|
12,551
|
boolean (@NotNull PsiMember member) { if (member instanceof PsiField) { if (PsiAnnotationSearchUtil.isAnnotatedWith(member, LombokClassNames.SETTER)) { return false; } final PsiClass psiClass = PsiTreeUtil.getParentOfType(member, PsiClass.class); return null == psiClass || !PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.SETTER, LombokClassNames.DATA, LombokClassNames.VALUE); } return true; }
|
canBeFinal
|
12,552
|
boolean (@NotNull PsiVariable variable) { return PsiAnnotationSearchUtil.isAnnotatedWith(variable, LombokClassNames.CLEANUP); }
|
isSafelyClosed
|
12,553
|
List<PsiAnnotation> (@NotNull PsiModifierListOwner listOwner) { return ContainerUtil.createMaybeSingletonList( findInferredAnnotation(listOwner, JavaMethodContractUtil.ORG_JETBRAINS_ANNOTATIONS_CONTRACT)); }
|
findInferredAnnotations
|
12,554
|
StructureViewTreeElement[] (PsiElement parent) { final PsiClass parentClass = (PsiClass) parent; final Stream<PsiFieldTreeElement> lombokFields = Arrays.stream(parentClass.getFields()) .filter(LombokLightFieldBuilder.class::isInstance) .map(psiField -> new PsiFieldTreeElement(psiField, false)); final Stream<PsiMethodTreeElement> lombokMethods = Arrays.stream(parentClass.getMethods()) .filter(LombokLightMethodBuilder.class::isInstance) .map(psiMethod -> new PsiMethodTreeElement(psiMethod, false)); final Stream<JavaClassTreeElement> lombokInnerClasses = Arrays.stream(parentClass.getInnerClasses()) .filter(LombokLightClassBuilder.class::isInstance) .map(psiClass -> new JavaClassTreeElement(psiClass, false)); return Stream.concat(Stream.concat(lombokFields, lombokMethods), lombokInnerClasses) .toArray(StructureViewTreeElement[]::new); }
|
getChildren
|
12,555
|
Object (Editor editor, PsiElement parent) { return null; }
|
getCurrentEditorElement
|
12,556
|
void (@NotNull ReferencesSearch.SearchParameters queryParameters, @NotNull Processor consumer) { PsiElement refElement = queryParameters.getElementToSearch(); if (refElement instanceof PsiField) { DumbService.getInstance(queryParameters.getProject()).runReadActionInSmartMode(() -> processPsiField((PsiField) refElement, queryParameters.getOptimizer())); } }
|
processQuery
|
12,557
|
void (final PsiField refPsiField, final SearchRequestCollector collector) { final PsiClass containingClass = refPsiField.getContainingClass(); if (null != containingClass) { processClassMethods(refPsiField, collector, containingClass); final PsiClass[] innerClasses = containingClass.getInnerClasses(); Arrays.stream(innerClasses) .forEach(psiClass -> processClassMethods(refPsiField, collector, psiClass)); Arrays.stream(innerClasses) .forEach(psiClass -> processClassFields(refPsiField, collector, psiClass)); } }
|
processPsiField
|
12,558
|
void (PsiField refPsiField, SearchRequestCollector collector, PsiClass containingClass) { Arrays.stream(containingClass.getMethods()) .filter(LombokLightMethodBuilder.class::isInstance) .filter(psiMethod -> psiMethod.getNavigationElement() == refPsiField) .forEach(psiMethod -> { collector.searchWord(psiMethod.getName(), psiMethod.getUseScope(), UsageSearchContext.IN_CODE, true, psiMethod); }); }
|
processClassMethods
|
12,559
|
void (PsiField refPsiField, SearchRequestCollector collector, PsiClass containingClass) { Arrays.stream(containingClass.getFields()) .filter(LombokLightFieldBuilder.class::isInstance) .filter(psiField -> psiField.getNavigationElement() == refPsiField) .forEach(psiField -> { collector.searchWord(psiField.getName(), psiField.getUseScope(), UsageSearchContext.IN_CODE, true, psiField); }); }
|
processClassFields
|
12,560
|
boolean (@NotNull HighlightInfo highlightInfo, @Nullable PsiFile file) { if (null == file) { return true; } Project project = file.getProject(); if (!LombokLibraryUtil.hasLombokLibrary(project)) { return true; } PsiElement highlightedElement = file.findElementAt(highlightInfo.getStartOffset()); if (null == highlightedElement) { return true; } // check exceptions for highlights boolean acceptHighlight = Holder.registeredFilters .getOrDefault(highlightInfo.getSeverity(), Collections.emptyMap()) .getOrDefault(highlightInfo.type.getAttributesKey(), Collections.emptyList()) .stream() .filter(filter -> filter.descriptionCheck(highlightInfo.getDescription(), highlightedElement)) .allMatch(filter -> filter.accept(highlightedElement)); // check if highlight was filtered if (!acceptHighlight) { return false; } // handle rest cases String description = highlightInfo.getDescription(); if (HighlightSeverity.ERROR.equals(highlightInfo.getSeverity())) { //Handling onX parameters if (OnXAnnotationHandler.isOnXParameterAnnotation(highlightInfo, file) || OnXAnnotationHandler.isOnXParameterValue(highlightInfo, file) || (description != null && Holder.LOMBOK_ANY_ANNOTATION_REQUIRED.matcher(description).matches())) { return false; } } // register different quick fix for highlight Holder.registeredHooks .getOrDefault(highlightInfo.getSeverity(), Collections.emptyMap()) .getOrDefault(highlightInfo.type.getAttributesKey(), Collections.emptyList()) .stream() .filter(filter -> filter.descriptionCheck(highlightInfo.getDescription())) .forEach(filter -> filter.processHook(highlightedElement, highlightInfo)); return true; }
|
accept
|
12,561
|
Pattern (int count) { return Pattern.compile(JavaErrorBundle.message("unhandled.exceptions", ".*", count)); }
|
preparePattern
|
12,562
|
boolean (@Nullable String description) { return description != null && (pattern.matcher(description).matches() || pattern2.matcher(description).matches()); }
|
descriptionCheck
|
12,563
|
void (@NotNull PsiElement highlightedElement, @NotNull HighlightInfo highlightInfo) { PsiElement importantParent = PsiTreeUtil.getParentOfType(highlightedElement, PsiMethod.class, PsiLambdaExpression.class, PsiMethodReferenceExpression.class, PsiClassInitializer.class ); // applicable only for methods if (importantParent instanceof PsiMethod) { AddAnnotationFix fix = new AddAnnotationFix(LombokClassNames.SNEAKY_THROWS, (PsiModifierListOwner) importantParent); highlightInfo.registerFix(fix, null, null, null, null); } }
|
processHook
|
12,564
|
boolean (@Nullable String description, PsiElement highlightedElement) { return JavaErrorBundle.message("variable.not.initialized", highlightedElement.getText()).equals(description); }
|
descriptionCheck
|
12,565
|
boolean (@NotNull PsiElement highlightedElement) { return !LazyGetterHandler.isLazyGetterHandled(highlightedElement); }
|
accept
|
12,566
|
boolean (@Nullable String description, PsiElement highlightedElement) { return JavaErrorBundle.message("constant.expression.required").equals(description); }
|
descriptionCheck
|
12,567
|
boolean (@NotNull PsiElement highlightedElement) { return !FieldNameConstantsHandler.isFiledNameConstants(highlightedElement); }
|
accept
|
12,568
|
boolean (@Nullable String description, PsiElement highlightedElement) { return description != null && pattern.matcher(description).matches(); }
|
descriptionCheck
|
12,569
|
boolean (@NotNull PsiElement highlightedElement) { return !BuilderHandler.isDefaultBuilderValue(highlightedElement); }
|
accept
|
12,570
|
String () { return JavaAnalysisBundle.message("dataflow.message.npe.method.invocation.sure"); }
|
getDescriptionTemplate
|
12,571
|
boolean (@Nullable String description, PsiElement highlightedElement) { return ProblemDescriptorUtil.renderDescriptionMessage(descriptor, highlightedElement).equals(description); }
|
descriptionCheck
|
12,572
|
boolean (@NotNull PsiElement highlightedElement) { return !LazyGetterHandler.isLazyGetterHandled(highlightedElement) || !LazyGetterHandler.isInitializedInConstructors(highlightedElement); }
|
accept
|
12,573
|
boolean (LombokLightMethodBuilder method, PsiField originalField, AccessorsInfo accessorsInfo) { return !method.hasParameters() && method.getName().equals(LombokUtils.getGetterName(originalField, accessorsInfo)); }
|
isLombokPropertyGetter
|
12,574
|
boolean (LombokLightMethodBuilder method, PsiField originalField, AccessorsInfo accessorsInfo) { return method.getParameterList().getParameters().length == 1 && (method.getName().equals(LombokUtils.getSetterName(originalField, accessorsInfo)) || method.getName().equals(LombokUtils.getWitherName(originalField, accessorsInfo))); }
|
isLombokPropertySetterOrWither
|
12,575
|
boolean (@NotNull PsiElement element) { if (element instanceof PsiField && !(element instanceof LombokLightFieldBuilder)) { final PsiClass containingClass = ((PsiField)element).getContainingClass(); if (null != containingClass) { return ContainerUtil.exists(containingClass.getMethods(), LombokLightMethodBuilder.class::isInstance) || ContainerUtil.exists(containingClass.getInnerClasses(), LombokLightClassBuilder.class::isInstance); } } return false; }
|
canProcessElement
|
12,576
|
void (@NotNull PsiElement element, @NotNull String newFieldName, @NotNull Map<PsiElement, String> allRenames) { final PsiField psiField = (PsiField)element; final PsiClass containingClass = psiField.getContainingClass(); final String currentFieldName = psiField.getName(); if (null != containingClass) { final boolean isBoolean = PsiTypes.booleanType().equals(psiField.getType()); final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String getterName = LombokUtils.toGetterName(accessorsInfo, currentFieldName, isBoolean); final PsiMethod[] psiGetterMethods = containingClass.findMethodsByName(getterName, false); for (PsiMethod psiMethod : psiGetterMethods) { allRenames.put(psiMethod, LombokUtils.toGetterName(accessorsInfo, newFieldName, isBoolean)); } final String setterName = LombokUtils.toSetterName(accessorsInfo, currentFieldName, isBoolean); final PsiMethod[] psiSetterMethods = containingClass.findMethodsByName(setterName, false); for (PsiMethod psiMethod : psiSetterMethods) { allRenames.put(psiMethod, LombokUtils.toSetterName(accessorsInfo, newFieldName, isBoolean)); } if (!accessorsInfo.isFluent()) { final String witherName = LombokUtils.toWitherName(accessorsInfo, currentFieldName, isBoolean); final PsiMethod[] psiWitherMethods = containingClass.findMethodsByName(witherName, false); for (PsiMethod psiMethod : psiWitherMethods) { allRenames.put(psiMethod, LombokUtils.toWitherName(accessorsInfo, newFieldName, isBoolean)); } } final PsiAnnotation builderAnnotation = PsiAnnotationSearchUtil.findAnnotation(containingClass, LombokClassNames.BUILDER, LombokClassNames.SUPER_BUILDER); if (null != builderAnnotation) { final PsiAnnotation singularAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, LombokClassNames.SINGULAR); final BuilderElementHandler handler = SingularHandlerFactory.getHandlerFor(psiField, null != singularAnnotation); final String setterPrefix = PsiAnnotationUtil.getStringAnnotationValue(builderAnnotation, BuilderHandler.ANNOTATION_SETTER_PREFIX, ""); final List<String> currentBuilderMethodNames = handler.getBuilderMethodNames(accessorsInfo.removePrefix(currentFieldName), setterPrefix, singularAnnotation, accessorsInfo.getCapitalizationStrategy()); final List<String> newBuilderMethodNames = handler.getBuilderMethodNames(accessorsInfo.removePrefix(newFieldName), setterPrefix, singularAnnotation, accessorsInfo.getCapitalizationStrategy()); if (currentBuilderMethodNames.size() == newBuilderMethodNames.size()) { Arrays.stream(containingClass.getInnerClasses()) .map(PsiClass::getMethods) .flatMap(Arrays::stream) .filter(LombokLightMethodBuilder.class::isInstance) .filter(psiMethod -> psiMethod.getNavigationElement() == psiField) .forEach(psiMethod -> { final int methodIndex = currentBuilderMethodNames.indexOf(psiMethod.getName()); if (methodIndex >= 0) { allRenames.put(psiMethod, newBuilderMethodNames.get(methodIndex)); } }); } } final boolean hasFieldNameConstantAnnotation = PsiAnnotationSearchUtil.isAnnotatedWith(containingClass, LombokClassNames.FIELD_NAME_CONSTANTS); if (hasFieldNameConstantAnnotation) { Arrays.stream(containingClass.getInnerClasses()) .map(PsiClass::getFields) .flatMap(Arrays::stream) .filter(LombokLightFieldBuilder.class::isInstance) .filter(myField -> myField.getNavigationElement() == psiField) .forEach(myField -> allRenames.put(myField, newFieldName)); } } }
|
prepareRenaming
|
12,577
|
TreeElement (PsiElement original, CharTable table, PsiManager manager) { TreeElement result = null; if (original instanceof LombokLightMethodBuilder) { result = ChangeUtil.copyElement((TreeElement) SourceTreeToPsiMap.psiElementToTree(original), table); } return result; }
|
generateTreeFor
|
12,578
|
boolean (@NotNull PsiElement elem) { return (elem instanceof LombokLightMethodBuilder || elem instanceof LombokLightFieldBuilder) && !(elem.getNavigationElement() instanceof PsiAnnotation); }
|
canProcessElement
|
12,579
|
PsiElement (@NotNull PsiElement elem, @Nullable Editor editor) { return elem.getNavigationElement(); }
|
substituteElementToRename
|
12,580
|
PsiClass (@NotNull String qualifiedName, @NotNull GlobalSearchScope scope) { if (!LombokLibraryUtil.hasLombokLibrary(myProject)) { return null; } final int lastDot = qualifiedName.lastIndexOf('.'); if (lastDot < 0) { return null; } final String parentName = qualifiedName.substring(0, lastDot); final String shortName = qualifiedName.substring(lastDot + 1); if (shortName.isEmpty() || parentName.isEmpty()) { return null; } final PsiClass parentClass = myFileManager.findClass(parentName, scope); if (null != parentClass) { return parentClass.findInnerClassByName(shortName, false); } return null; }
|
findClass
|
12,581
|
boolean (@NotNull PsiElement element) { if ((element instanceof PsiField || element instanceof PsiRecordComponent) && !DumbService.isDumb(element.getProject())) { final PsiMember psiMember = (PsiMember) element; final PsiClass containingClass = psiMember.getContainingClass(); if (containingClass != null) { return Arrays.stream(containingClass.getMethods()).anyMatch(LombokLightMethodBuilder.class::isInstance) || Arrays.stream(containingClass.getInnerClasses()).anyMatch(LombokLightClassBuilder.class::isInstance); } } return false; }
|
canFindUsages
|
12,582
|
FindUsagesHandler (@NotNull PsiElement element, boolean forHighlightUsages) { return new FindUsagesHandler(element) { @Override public PsiElement @NotNull [] getSecondaryElements() { final PsiMember psiMember = (PsiMember) getPsiElement(); final PsiClass containingClass = psiMember.getContainingClass(); if (containingClass != null) { final Collection<PsiElement> elements = new ArrayList<>(); processClass(containingClass, psiMember, elements); Arrays.stream(containingClass.getInnerClasses()) .forEach(psiClass -> processClass(psiClass, psiMember, elements)); return PsiUtilCore.toPsiElementArray(elements); } return PsiElement.EMPTY_ARRAY; } private static void processClass(PsiClass containingClass, PsiMember refPsiField, Collection<PsiElement> collector) { processClassMethods(containingClass, refPsiField, collector); processClassFields(containingClass, refPsiField, collector); } private static void processClassFields(PsiClass containingClass, PsiMember refPsiField, Collection<PsiElement> collector) { Arrays.stream(containingClass.getFields()) .filter(LombokLightFieldBuilder.class::isInstance) .filter(psiField -> psiField.getNavigationElement() == refPsiField) .forEach(collector::add); } private static void processClassMethods(PsiClass containingClass, PsiMember refPsiField, Collection<PsiElement> collector) { Arrays.stream(containingClass.getMethods()) .filter(LombokLightMethodBuilder.class::isInstance) .filter(psiMethod -> psiMethod.getNavigationElement() == refPsiField) .forEach(collector::add); } }; }
|
createFindUsagesHandler
|
12,583
|
void (PsiClass containingClass, PsiMember refPsiField, Collection<PsiElement> collector) { processClassMethods(containingClass, refPsiField, collector); processClassFields(containingClass, refPsiField, collector); }
|
processClass
|
12,584
|
void (PsiClass containingClass, PsiMember refPsiField, Collection<PsiElement> collector) { Arrays.stream(containingClass.getFields()) .filter(LombokLightFieldBuilder.class::isInstance) .filter(psiField -> psiField.getNavigationElement() == refPsiField) .forEach(collector::add); }
|
processClassFields
|
12,585
|
void (PsiClass containingClass, PsiMember refPsiField, Collection<PsiElement> collector) { Arrays.stream(containingClass.getMethods()) .filter(LombokLightMethodBuilder.class::isInstance) .filter(psiMethod -> psiMethod.getNavigationElement() == refPsiField) .forEach(collector::add); }
|
processClassMethods
|
12,586
|
boolean (PsiElement element, Editor editor, PsiFile file) { return super.isAvailable(element, editor, file) && ((element instanceof LombokLightMethodBuilder || element instanceof LombokLightFieldBuilder) && !(element.getNavigationElement() instanceof PsiAnnotation)); }
|
isAvailable
|
12,587
|
void (@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) { PsiElement element = PsiElementRenameHandler.getElement(dataContext); if (null == element) { element = BaseRefactoringAction.getElementAtCaret(editor, file); } if (null != element) { RenamePsiElementProcessor processor = RenamePsiElementProcessor.forElement(element); element = processor.substituteElementToRename(element, editor); } if (null != element) { editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); PsiElement nameSuggestionContext = file.getViewProvider().findElementAt(editor.getCaretModel().getOffset()); PsiElementRenameHandler.invoke(element, project, nameSuggestionContext, editor); } }
|
invoke
|
12,588
|
InplaceRefactoring (@NotNull PsiElement elementToRename, @NotNull Editor editor, @Nullable DataContext dataContext) { RenamePsiElementProcessor processor = RenamePsiElementProcessor.forElement(elementToRename); PsiElement actualElem = processor.substituteElementToRename(elementToRename, editor); return super.doRename(actualElem, editor, dataContext); }
|
doRename
|
12,589
|
boolean (DataContext dataContext) { final PsiElement element = PsiElementRenameHandler.getElement(dataContext); return element instanceof LombokLightClassBuilder || ((element instanceof LombokLightMethodBuilder || element instanceof LombokLightFieldBuilder) && element.getNavigationElement() instanceof PsiAnnotation); }
|
isAvailableOnDataContext
|
12,590
|
boolean (DataContext dataContext) { return isAvailableOnDataContext(dataContext); }
|
isRenaming
|
12,591
|
void (@NotNull Project project, Editor editor, PsiFile file, @Nullable DataContext dataContext) { invokeInner(project, editor); }
|
invoke
|
12,592
|
void (@NotNull Project project, PsiElement @NotNull [] elements, @Nullable DataContext dataContext) { Editor editor = dataContext == null ? null : CommonDataKeys.EDITOR.getData(dataContext); invokeInner(project, editor); }
|
invoke
|
12,593
|
void (Project project, Editor editor) { CommonRefactoringUtil.showErrorHint(project, editor, RefactoringBundle.getCannotRefactorMessage(LombokBundle.message("dialog.message.this.element.cannot.be.renamed")), RefactoringBundle.message("rename.title"), null); }
|
invokeInner
|
12,594
|
Set<PostfixTemplate> () { return lombokTemplates; }
|
getTemplates
|
12,595
|
boolean (char currentChar) { return currentChar == '.' || currentChar == '!'; }
|
isTerminalSymbol
|
12,596
|
void (@NotNull PsiFile file, @NotNull Editor editor) { }
|
preExpand
|
12,597
|
void (@NotNull PsiFile file, @NotNull Editor editor) { }
|
afterExpand
|
12,598
|
PsiFile (@NotNull PsiFile copyFile, @NotNull Editor realEditor, int currentOffset) { Document document = copyFile.getViewProvider().getDocument(); assert document != null; CharSequence sequence = document.getCharsSequence(); StringBuilder fileContentWithSemicolon = new StringBuilder(sequence); if (isSemicolonNeeded(copyFile, realEditor)) { fileContentWithSemicolon.insert(currentOffset, ';'); return PostfixLiveTemplate.copyFile(copyFile, fileContentWithSemicolon); } return copyFile; }
|
preCheck
|
12,599
|
boolean (@NotNull PsiFile file, @NotNull Editor editor) { int startOffset = CompletionInitializationContext.calcStartOffset(editor.getCaretModel().getCurrentCaret()); return JavaCompletionContributor.semicolonNeeded(file, startOffset); }
|
isSemicolonNeeded
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.