Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
13,500 | boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { boolean result = true; if (psiClass.isInterface() || psiClass.isAnnotationType()) { builder.addErrorMessage("inspection.message.s.legal.only.on.classes.enums", getSupportedAnnotationClasses()[0]); result = false; ... | validate |
13,501 | void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { target.add(createLoggerField(psiClass, psiAnnotation)); } | generatePsiElements |
13,502 | LombokLightFieldBuilder (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { // called only after validation succeeded final Project project = psiClass.getProject(); final PsiManager manager = psiClass.getContainingFile().getManager(); final PsiElementFactory psiElementFactory = JavaPsiFacade.getElement... | createLoggerField |
13,503 | String (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { final StringBuilder parametersBuilder = new StringBuilder(); final String topic = PsiAnnotationUtil.getStringAnnotationValue(psiAnnotation, "topic", ""); final boolean topicPresent = !StringUtil.isEmptyOrSpaces(topic); final List<LoggerInitiali... | createLoggerInitializeParameters |
13,504 | boolean (@NotNull PsiClass psiClass, @NotNull String fieldName) { final Collection<PsiField> psiFields = PsiClassUtil.collectClassFieldsIntern(psiClass); for (PsiField psiField : psiFields) { if (fieldName.equals(psiField.getName())) { return true; } } return false; } | hasFieldByName |
13,505 | String (@NotNull PsiClass psiClass) { return ConfigDiscovery.getInstance().getStringLombokConfigProperty(ConfigKey.LOG_CUSTOM_DECLARATION, psiClass); } | getCustomDeclaration |
13,506 | String (@NotNull PsiClass psiClass) { return CustomLogParser.parseLoggerType(getCustomDeclaration(psiClass)); } | getLoggerType |
13,507 | boolean ( @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder ) { if (!super.validate(psiAnnotation, psiClass, builder)) { return false; } final LoggerInitializerDeclaration declaration = CustomLogParser.parseInitializerParameters(getCustomDeclaration(psiClass)); if (declarati... | validate |
13,508 | String (@NotNull PsiClass psiClass) { return loggerType; } | getLoggerType |
13,509 | String (@NotNull PsiClass psiClass) { return loggerInitializer; } | getLoggerInitializer |
13,510 | List<LoggerInitializerParameter> (@NotNull PsiClass psiClass, boolean topicPresent) { return Collections.singletonList(topicPresent ? LoggerInitializerParameter.TOPIC : defaultParameter); } | getLoggerInitializerParameters |
13,511 | boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } LoggerInitializerDeclaration that = (LoggerInitializerDeclaration) o; return Objects.equals(withTopic, that.withTopic) && Objects.equals(withoutTopic, that.withoutTopic); } | equals |
13,512 | int () { return Objects.hash(withTopic, withoutTopic); } | hashCode |
13,513 | String (@NotNull String customDeclaration) { final Matcher declarationMatcher = DECLARATION_PATTERN.matcher(customDeclaration); if (!declarationMatcher.matches()) { return null; } String loggerType = declarationMatcher.group(1); if (loggerType == null) { loggerType = declarationMatcher.group(2); } return loggerType; } | parseLoggerType |
13,514 | String (@NotNull String customDeclaration) { final Matcher declarationMatcher = DECLARATION_PATTERN.matcher(customDeclaration); if (!declarationMatcher.matches()) { return null; } return declarationMatcher.group(2) + "." + declarationMatcher.group(3) + "(%s)"; } | parseLoggerInitializer |
13,515 | LoggerInitializerDeclaration (@NotNull String customDeclaration) { final Matcher declarationMatcher = DECLARATION_PATTERN.matcher(customDeclaration); if (!declarationMatcher.matches()) { return null; } List<LoggerInitializerParameter> withTopic = null; List<LoggerInitializerParameter> withoutTopic = null; final Matcher... | parseInitializerParameters |
13,516 | List<LoggerInitializerParameter> (@NotNull String parameters) { if (parameters.isEmpty()) { return Collections.emptyList(); } return Arrays.stream(parameters.split(",")).map(LoggerInitializerParameter::find).collect(Collectors.toList()); } | splitParameters |
13,517 | ConfigDiscovery () { return ConfigDiscovery.getInstance(); } | getConfigDiscovery |
13,518 | boolean (@NotNull PsiModifierList modifierList) { // FieldDefaults only change modifiers of class fields // but not for enum constants or lombok generated fields final PsiElement psiElement = modifierList.getParent(); if (!(psiElement instanceof PsiField) || psiElement instanceof PsiEnumConstant || psiElement instanceo... | isSupported |
13,519 | void (@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) { if (modifiers.contains(PsiModifier.STATIC) || UtilityClassModifierProcessor.isModifierListSupported(modifierList)) { return; // skip static fields } final PsiClass searchableClass = PsiTreeUtil.getParentOfType(modifierList, PsiClass.cl... | transformModifiers |
13,520 | boolean (PsiClass searchableClass) { return PsiAnnotationSearchUtil.isAnnotatedWith(searchableClass, LombokClassNames.FIELD_DEFAULTS) || isConfigDefaultFinal(searchableClass) || isConfigDefaultPrivate(searchableClass); } | canBeAffected |
13,521 | boolean (PsiClass searchableClass) { return getConfigDiscovery().getBooleanLombokConfigProperty(ConfigKey.FIELDDEFAULTS_FINAL, searchableClass); } | isConfigDefaultFinal |
13,522 | boolean (PsiClass searchableClass) { return getConfigDiscovery().getBooleanLombokConfigProperty(ConfigKey.FIELDDEFAULTS_PRIVATE, searchableClass); } | isConfigDefaultPrivate |
13,523 | boolean (@NotNull PsiField parentField, @Nullable PsiAnnotation fieldDefaultsAnnotation, boolean isConfigDefaultFinal) { return shouldMakeFinalByDefault(fieldDefaultsAnnotation, isConfigDefaultFinal) && !PsiAnnotationSearchUtil.isAnnotatedWith(parentField, LombokClassNames.NON_FINAL); } | shouldMakeFinal |
13,524 | boolean (@Nullable PsiAnnotation fieldDefaultsAnnotation, boolean isConfigDefaultFinal) { if (fieldDefaultsAnnotation != null) { // Is @FieldDefaults(makeFinal = true)? return PsiAnnotationUtil.getBooleanAnnotationValue(fieldDefaultsAnnotation, "makeFinal", false); } return isConfigDefaultFinal; } | shouldMakeFinalByDefault |
13,525 | boolean (@NotNull PsiField parentField, @NotNull PsiModifierList modifierList) { return !hasExplicitAccessModifier(modifierList) && !PsiAnnotationSearchUtil.isAnnotatedWith(parentField, LombokClassNames.PACKAGE_PRIVATE); } | canChangeVisibility |
13,526 | String (@Nullable PsiAnnotation fieldDefaultsAnnotation, boolean isConfigDefaultPrivate) { final String accessLevelFromAnnotation = fieldDefaultsAnnotation != null ? LombokProcessorUtil.getAccessLevel(fieldDefaultsAnnotation, "level") : null; if (accessLevelFromAnnotation == null && isConfigDefaultPrivate) { return Psi... | detectDefaultAccessLevel |
13,527 | boolean (@NotNull PsiModifierList modifierList) { return modifierList.hasExplicitModifier(PsiModifier.PUBLIC) || modifierList.hasExplicitModifier(PsiModifier.PRIVATE) || modifierList.hasExplicitModifier(PsiModifier.PROTECTED); } | hasExplicitAccessModifier |
13,528 | boolean (@NotNull PsiModifierList modifierList) { final PsiElement parent = modifierList.getParent(); return (parent instanceof PsiLocalVariable && ValProcessor.isVal((PsiLocalVariable) parent)); } | isSupported |
13,529 | void (@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) { modifiers.add(PsiModifier.FINAL); } | transformModifiers |
13,530 | boolean (@NotNull PsiModifierList modifierList) { PsiElement modifierListParent = modifierList.getParent(); if (modifierListParent instanceof PsiClass parentClass) { if (PsiAnnotationSearchUtil.isAnnotatedWith(parentClass, LombokClassNames.UTILITY_CLASS)) { return UtilityClassProcessor.validateOnRightType(parentClass, ... | isModifierListSupported |
13,531 | boolean (@NotNull PsiModifierList modifierList) { return isModifierListSupported(modifierList); } | isSupported |
13,532 | void (@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) { final PsiElement parent = modifierList.getParent(); // FINAL if (parent instanceof PsiClass psiClass) { if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.UTILITY_CLASS)) { modifiers.add(PsiModifier.FINAL); } } // S... | transformModifiers |
13,533 | boolean (PsiElement element) { return element instanceof PsiField || element instanceof PsiMethod || (element instanceof PsiClass && element.getParent() instanceof PsiClass && !((PsiClass) element.getParent()).isInterface()); } | isElementFieldOrMethodOrInnerClass |
13,534 | boolean (@NotNull PsiModifierList modifierList) { final PsiElement modifierListParent = modifierList.getParent(); if (!(modifierListParent instanceof PsiField || modifierListParent instanceof PsiClass)) { return false; } PsiClass searchableClass = PsiTreeUtil.getParentOfType(modifierList, PsiClass.class, true); return ... | isSupported |
13,535 | void (@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) { if (modifiers.contains(PsiModifier.STATIC) && modifierList.getParent() instanceof PsiField) { return; // skip static fields } final PsiModifierListOwner parentElement = PsiTreeUtil.getParentOfType(modifierList, PsiModifierListOwner.cla... | transformModifiers |
13,536 | boolean (@NotNull PsiModifierList modifierList) { return !(modifierList.hasExplicitModifier(PsiModifier.PUBLIC) || modifierList.hasExplicitModifier(PsiModifier.PRIVATE) || modifierList.hasExplicitModifier(PsiModifier.PROTECTED)); } | hasPackagePrivateModifier |
13,537 | boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod, @NotNull ProblemSink problemSink) { boolean result = true; if (psiMethod.hasParameters()) { problemSink.addErrorMessage("inspection.message.delegate.legal.only.on.no.argument.methods"); result = false; } final PsiType returnType = psiMethod.ge... | validate |
13,538 | void (@NotNull PsiMethod psiMethod, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) { final PsiType returnType = psiMethod.getReturnType(); if (null != returnType) { DelegateHandler.generateElements(psiMethod, returnType, psiAnnotation, target); } } | processIntern |
13,539 | boolean (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod) { return BuilderHandler.checkAnnotationFQN(psiClass, psiAnnotation, psiMethod); } | checkAnnotationFQN |
13,540 | boolean (@Nullable String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod) { if (null == nameHint) { return true; } final String innerBuilderClassName = BuilderHandler.getBuilderClassName(psiClass, psiAnnotation, psiMethod); return Objects.equals(nameHint, innerB... | possibleToGenerateElementNamed |
13,541 | boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod, @NotNull ProblemSink problemSink) { return getHandler().validate(psiMethod, psiAnnotation, problemSink); } | validate |
13,542 | void (@NotNull PsiMethod psiMethod, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) { final PsiClass psiClass = psiMethod.getContainingClass(); if (null != psiClass) { final BuilderHandler builderHandler = getHandler(); builderHandler.createBuilderClassIfNotExist(psiClass, psiMethod, psi... | processIntern |
13,543 | BuilderHandler () { return new BuilderHandler(); } | getHandler |
13,544 | List<PsiExtensionMethod> (final @NotNull PsiClass targetClass, final @NotNull String nameHint, final @NotNull PsiElement place) { if (!(place instanceof PsiMethodCallExpression)) { return Collections.emptyList(); } PsiReferenceExpression methodExpression = ((PsiMethodCallExpression)place).getMethodExpression(); PsiExpr... | getExtensionMethods |
13,545 | List<PsiExtensionMethod> (final Set<PsiClass> providers, final PsiMethodCallExpression callExpression, final PsiClass targetClass) { List<PsiExtensionMethod> psiMethods = new ArrayList<>(); providers.forEach(providerClass -> providerData(providerClass).forEach(function -> ContainerUtil.addIfNotNull(psiMethods, function... | collectExtensionMethods |
13,546 | PsiExtensionMethod (PsiMethod staticMethod, PsiClass targetClass, PsiMethodCallExpression callExpression) { if (!staticMethod.getName().equals(callExpression.getMethodExpression().getReferenceName())) return null; PsiClass providerClass = Objects.requireNonNull(staticMethod.getContainingClass()); PsiMethodCallExpressio... | createLightMethodBySignature |
13,547 | boolean (final PsiElement another) { return myStaticMethod.isEquivalentTo(another); } | isEquivalentTo |
13,548 | PsiMethod () { return myStaticMethod; } | getTargetMethod |
13,549 | boolean (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod) { return PsiAnnotationSearchUtil.checkAnnotationHasOneOfFQNs(psiAnnotation, getSupportedAnnotationClasses()); } | checkAnnotationFQN |
13,550 | boolean (@Nullable String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod) { return true; } | possibleToGenerateElementNamed |
13,551 | Collection<PsiAnnotation> (@NotNull PsiClass psiClass) { List<PsiAnnotation> result = new ArrayList<>(); for (PsiMethod psiMethod : PsiClassUtil.collectClassMethodsIntern(psiClass)) { PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiMethod, getSupportedAnnotationClasses()); if (null != psiAnnotat... | collectProcessedAnnotations |
13,552 | Collection<LombokProblem> (@NotNull PsiAnnotation psiAnnotation) { Collection<LombokProblem> result = Collections.emptyList(); PsiMethod psiMethod = PsiTreeUtil.getParentOfType(psiAnnotation, PsiMethod.class); if (null != psiMethod) { ProblemValidationSink problemNewBuilder = new ProblemValidationSink(); validate(psiAn... | verifyAnnotation |
13,553 | boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod, @NotNull ProblemSink problemSink) { // we skip validation here, because it will be validated by other BuilderClassProcessor return true;//builderHandler.validate(psiMethod, psiAnnotation, builder); } | validate |
13,554 | boolean (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod) { return BuilderHandler.checkAnnotationFQN(psiClass, psiAnnotation, psiMethod); } | checkAnnotationFQN |
13,555 | void (@NotNull PsiMethod psiMethod, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) { final PsiClass psiClass = psiMethod.getContainingClass(); final BuilderHandler builderHandler = getHandler(); if (null != psiClass) { PsiClass builderClass = builderHandler.getExistInnerBuilderClass(psi... | processIntern |
13,556 | BuilderHandler () { return new BuilderHandler(); } | getHandler |
13,557 | void (@NotNull ActionContext context, @NotNull PsiElement element, @NotNull ModPsiUpdater updater) { PsiElement parent = PsiTreeUtil.getParentOfType(element, PsiVariable.class, PsiClass.class, PsiMethod.class); if (parent instanceof PsiField) { handleField((PsiField)parent); } else if (parent instanceof PsiMethod) { ha... | invoke |
13,558 | void (@NotNull PsiMethod psiMethod) { findAnchorFieldForGetter(psiMethod) .map(PsiField::getModifierList) .ifPresent(modifierList -> replaceWithAnnotation(modifierList, psiMethod, LombokClassNames.GETTER)); findAnchorFieldForSetter(psiMethod) .map(PsiField::getModifierList) .ifPresent(modifierList -> replaceWithAnnotat... | handleMethod |
13,559 | Optional<PsiMethod> (@NotNull PsiField psiField) { final PsiMethod getterForField = PropertyUtilBase.findGetterForField(psiField); if (null != getterForField && !(getterForField instanceof LombokLightMethodBuilder)) { if (findAnchorFieldForGetter(getterForField).filter(psiField::equals).isPresent()) { return Optional.o... | findGetterMethodToReplace |
13,560 | Optional<PsiMethod> (@NotNull PsiField psiField) { final PsiMethod setterForField = PropertyUtilBase.findSetterForField(psiField); if (null != setterForField && !(setterForField instanceof LombokLightMethodBuilder)) { if (findAnchorFieldForSetter(setterForField).filter(psiField::equals).isPresent()) { return Optional.o... | findSetterMethodToReplace |
13,561 | void (@NotNull PsiField psiField) { PsiModifierList psiFieldModifierList = psiField.getModifierList(); if (null == psiFieldModifierList) { return; } // replace getter if it matches the requirements findGetterMethodToReplace(psiField).ifPresent( psiMethod -> replaceWithAnnotation(psiFieldModifierList, psiMethod, LombokC... | handleField |
13,562 | Optional<PsiField> (@NotNull PsiMethod method) { // it seems wrong to replace abstract possible getters // abstract methods maybe the part of interface so let them live if (!PropertyUtilBase.isSimplePropertySetter(method) || method.hasModifierProperty(PsiModifier.ABSTRACT)) { return Optional.empty(); } // check the par... | findAnchorFieldForSetter |
13,563 | Optional<PsiField> (@NotNull PsiMethod method) { // it seems wrong to replace abstract possible getters // abstract methods maybe the part of interface so let them live if (!PropertyUtilBase.isSimplePropertyGetter(method) || method.hasModifierProperty(PsiModifier.ABSTRACT)) { return Optional.empty(); } PsiCodeBlock bod... | findAnchorFieldForGetter |
13,564 | void (@NotNull PsiModifierList modifierList, @NotNull PsiMethod method, @NotNull String annotationName) { final Optional<String> accessLevelFQN = LombokProcessorUtil.convertModifierToLombokAccessLevel(method); method.delete(); PsiAnnotation addedAnnotation = modifierList.addAnnotation(annotationName); if (accessLevelFQ... | replaceWithAnnotation |
13,565 | String () { return LombokBundle.message("replace.with.annotations.lombok"); } | getFamilyName |
13,566 | void (@NotNull ActionContext context, @NotNull PsiElement element, @NotNull ModPsiUpdater updater) { final PsiDeclarationStatement declarationStatement = PsiTreeUtil.getParentOfType(element, PsiDeclarationStatement.class); if (declarationStatement != null) { invokeOnDeclarationStatement(declarationStatement); return; }... | invoke |
13,567 | String () { return LombokBundle.message("replace.explicit.type.with.0.lombok", StringUtil.getShortName(variableClassName)); } | getFamilyName |
13,568 | boolean (PsiDeclarationStatement context) { if (PsiUtil.isLanguageLevel10OrHigher(context)) { return false; } PsiElement[] declaredElements = context.getDeclaredElements(); if (declaredElements.length != 1) { return false; } PsiElement declaredElement = declaredElements[0]; if (!(declaredElement instanceof PsiLocalVari... | isAvailableOnDeclarationStatement |
13,569 | void (PsiDeclarationStatement declarationStatement) { if (declarationStatement.getDeclaredElements().length == 1) { PsiLocalVariable localVariable = (PsiLocalVariable) declarationStatement.getDeclaredElements()[0]; invokeOnVariable(localVariable); } } | invokeOnDeclarationStatement |
13,570 | void (PsiVariable psiVariable) { Project project = psiVariable.getProject(); psiVariable.normalizeDeclaration(); PsiTypeElement typeElement = psiVariable.getTypeElement(); if (typeElement == null || typeElement.isInferredType()) { return; } PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project); Ps... | invokeOnVariable |
13,571 | boolean (@NotNull PsiDeclarationStatement declarationStatement, @NotNull PsiLocalVariable localVariable) { return !(declarationStatement.getParent() instanceof PsiForStatement); } | isAvailableOnDeclarationCustom |
13,572 | void (PsiVariable psiVariable) { PsiModifierList modifierList = psiVariable.getModifierList(); if (modifierList != null) { modifierList.setModifierProperty(FINAL, false); } } | executeAfterReplacing |
13,573 | boolean (PsiVariable psiVariable) { if (!(psiVariable instanceof PsiParameter parameter)) { return false; } if (!(parameter.getDeclarationScope() instanceof PsiForeachStatement)) { return false; } PsiTypeElement typeElement = parameter.getTypeElement(); return typeElement == null || !typeElement.isInferredType(); } | isAvailableOnVariable |
13,574 | boolean (@NotNull PsiDeclarationStatement declarationStatement, @NotNull PsiLocalVariable localVariable) { return isNotFinal(localVariable); } | isAvailableOnDeclarationCustom |
13,575 | void (PsiVariable psiVariable) { } | executeAfterReplacing |
13,576 | boolean (@NotNull PsiVariable psiVariable) { if (!(psiVariable instanceof PsiParameter psiParameter)) { return false; } PsiElement declarationScope = psiParameter.getDeclarationScope(); if (!(declarationScope instanceof PsiForStatement) && !(declarationScope instanceof PsiForeachStatement)) { return false; } PsiTypeEle... | isAvailableOnVariable |
13,577 | boolean (@NotNull PsiVariable variable) { PsiModifierList modifierList = variable.getModifierList(); return modifierList == null || !modifierList.hasExplicitModifier(FINAL); } | isNotFinal |
13,578 | void (PsiVariable psiVariable) { } | executeAfterReplacing |
13,579 | String () { return LombokBundle.message("replace.0.with.explicit.type.lombok", StringUtil.getShortName(variableClassName)); } | getFamilyName |
13,580 | boolean (PsiVariable psiVariable) { if (LombokClassNames.VAL.equals(variableClassName)) { return ValProcessor.isVal(psiVariable); } if (LombokClassNames.VAR.equals(variableClassName)) { return ValProcessor.isVar(psiVariable); } return false; } | isAvailableOnVariable |
13,581 | boolean (PsiDeclarationStatement context) { if (context.getDeclaredElements().length <= 0) { return false; } PsiElement declaredElement = context.getDeclaredElements()[0]; if (!(declaredElement instanceof PsiLocalVariable)) { return false; } return isAvailableOnVariable((PsiLocalVariable) declaredElement); } | isAvailableOnDeclarationStatement |
13,582 | void (PsiDeclarationStatement declarationStatement) { if (declarationStatement.getDeclaredElements().length > 0) { PsiElement declaredElement = declarationStatement.getDeclaredElements()[0]; if (declaredElement instanceof PsiLocalVariable) { invokeOnVariable((PsiLocalVariable) declaredElement); } } } | invokeOnDeclarationStatement |
13,583 | void (PsiVariable psiVariable) { PsiTypeElement psiTypeElement = psiVariable.getTypeElement(); if (psiTypeElement == null) { return; } PsiTypesUtil.replaceWithExplicitType(psiTypeElement); RemoveRedundantTypeArgumentsUtil.removeRedundantTypeArguments(psiVariable); executeAfterReplacing(psiVariable); CodeStyleManager.ge... | invokeOnVariable |
13,584 | void (PsiVariable psiVariable) { PsiModifierList psiModifierList = psiVariable.getModifierList(); if (psiModifierList != null) { psiModifierList.setModifierProperty(PsiModifier.FINAL, true); } } | executeAfterReplacing |
13,585 | ExternalClassResolveResult (@NotNull String shortClassName, @NotNull ThreeState isAnnotation, @NotNull Module contextModule) { if (isAnnotation == ThreeState.YES && simpleNameToFQNameMap.containsKey(shortClassName)) { return new ExternalClassResolveResult(simpleNameToFQNameMap.get(shortClassName), LOMBOK_DESCRIPTOR); }... | resolveClass |
13,586 | ExternalLibraryDescriptor (@NotNull String packageName) { if (allLombokPackages.contains(packageName)) { return LOMBOK_DESCRIPTOR; } return null; } | resolvePackage |
13,587 | String (final @NotNull PsiField psiField) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); return getGetterName(psiField, accessorsInfo); } | getGetterName |
13,588 | String (@NotNull PsiField psiField, @NotNull AccessorsInfo accessorsInfo) { final String psiFieldName = psiField.getName(); final boolean isBoolean = PsiTypes.booleanType().equals(psiField.getType()); return toGetterName(accessorsInfo, psiFieldName, isBoolean); } | getGetterName |
13,589 | String (@NotNull PsiField psiField) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); return getSetterName(psiField, accessorsInfo); } | getSetterName |
13,590 | String (@NotNull PsiField psiField, @NotNull AccessorsInfo accessorsInfo) { return toSetterName(accessorsInfo, psiField.getName(), PsiTypes.booleanType().equals(psiField.getType())); } | getSetterName |
13,591 | String (@NotNull PsiVariable psiVariable, @NotNull AccessorsInfo accessorsInfo) { return toWitherName(accessorsInfo.withFluent(false), psiVariable.getName(), PsiTypes.booleanType().equals(psiVariable.getType())); } | getWitherName |
13,592 | String (@NotNull AccessorsInfo accessors, String fieldName, boolean isBoolean) { return toAccessorName(accessors, fieldName, isBoolean, "is", "get"); } | toGetterName |
13,593 | String (@NotNull AccessorsInfo accessors, String fieldName, boolean isBoolean) { return toAccessorName(accessors, fieldName, isBoolean, "set", "set"); } | toSetterName |
13,594 | String (@NotNull AccessorsInfo accessors, String fieldName, boolean isBoolean) { if (accessors.isFluent()) { throw new IllegalArgumentException("@Wither does not support @Accessors(fluent=true)"); } return toAccessorName(accessors, fieldName, isBoolean, "with", "with"); } | toWitherName |
13,595 | String (@NotNull AccessorsInfo accessorsInfo, String fieldName, boolean isBoolean, String booleanPrefix, String normalPrefix) { final String result; fieldName = accessorsInfo.removePrefix(fieldName); if (accessorsInfo.isFluent()) { return fieldName; } final boolean useBooleanPrefix = isBoolean && !accessorsInfo.isDoNot... | toAccessorName |
13,596 | Collection<String> (@NotNull AccessorsInfo accessorsInfo, String fieldName, boolean isBoolean) { return toAllAccessorNames(accessorsInfo, fieldName, isBoolean, "is", "get"); } | toAllGetterNames |
13,597 | Collection<String> (@NotNull AccessorsInfo accessorsInfo, String fieldName, boolean isBoolean) { return toAllAccessorNames(accessorsInfo, fieldName, isBoolean, "set", "set"); } | toAllSetterNames |
13,598 | Collection<String> (@NotNull AccessorsInfo accessorsInfo, String fieldName, boolean isBoolean) { if (accessorsInfo.isFluent()) { throw new IllegalArgumentException("@Wither does not support @Accessors(fluent=true)"); } return toAllAccessorNames(accessorsInfo, fieldName, isBoolean, "with", "with"); } | toAllWitherNames |
13,599 | Collection<String> (@NotNull AccessorsInfo accessorsInfo, String fieldName, boolean isBoolean, String booleanPrefix, String normalPrefix) { Collection<String> result = new HashSet<>(); fieldName = accessorsInfo.removePrefix(fieldName); if (accessorsInfo.isFluent()) { result.add(StringUtil.decapitalize(fieldName)); retu... | toAllAccessorNames |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.