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.