Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
13,200
void (@NotNull LombokLightMethodBuilder methodBuilder, @NotNull PsiType psiFieldType, @NotNull String singularName) { final PsiManager psiManager = methodBuilder.getManager(); final PsiType elementType = PsiTypeUtil.extractAllElementType(psiFieldType, psiManager); final PsiType collectionType = PsiTypeUtil.createCollectionType(psiManager, CommonClassNames.JAVA_LANG_ITERABLE, elementType); methodBuilder.withParameter(singularName, collectionType); }
addAllMethodParameter
13,201
String (@NotNull BuilderInfo info) { final String codeBlockFormat = "this.{0} = null;\n" + "return {1};"; return MessageFormat.format(codeBlockFormat, info.getFieldName(), info.getBuilderChainResult()); }
getClearMethodBody
13,202
String (@NotNull String singularName, @NotNull BuilderInfo info) { final String codeBlockTemplate = """ if (this.{0} == null) this.{0} = {2}.{3};\s this.{0}.add({1}); return {4};"""; return MessageFormat.format(codeBlockTemplate, info.getFieldName(), singularName, typeCollectionQualifiedName, sortedCollection ? "naturalOrder()" : "builder()", info.getBuilderChainResult()); }
getOneMethodBody
13,203
String (@NotNull String singularName, @NotNull BuilderInfo info) { final String codeBlockTemplate = """ if({0}==null)'{'throw new NullPointerException("{0} cannot be null");'}' if (this.{0} == null) this.{0} = {1}.{2};\s this.{0}.addAll({0}); return {3};"""; return MessageFormat.format(codeBlockTemplate, singularName, typeCollectionQualifiedName, sortedCollection ? "naturalOrder()" : "builder()", info.getBuilderChainResult()); }
getAllMethodBody
13,204
String (@NotNull PsiVariable psiVariable, @NotNull String fieldName, @NotNull String builderVariable) { final PsiManager psiManager = psiVariable.getManager(); final PsiType psiFieldType = psiVariable.getType(); final PsiType elementType = PsiTypeUtil.extractOneElementType(psiFieldType, psiManager); return MessageFormat.format( "{2}<{1}> {0} = " + "{4}.{0} == null ? " + "{3}.<{1}>of() : " + "{4}.{0}.build();\n", fieldName, elementType.getCanonicalText(false), collectionQualifiedName, typeCollectionQualifiedName, builderVariable); }
renderBuildCode
13,205
String (@NotNull BuilderInfo info) { return typeCollectionQualifiedName + '.' + "builder()"; }
getEmptyCollectionCall
13,206
Collection<PsiField> (@NotNull BuilderInfo info) { Collection<PsiField> result = new ArrayList<>(); result.add(new LombokLightFieldBuilder(info.getManager(), info.renderFieldName(), info.getFieldType()) .withContainingClass(info.getBuilderClass()) .withModifier(PsiModifier.PRIVATE) .withNavigationElement(info.getVariable())); if (info.hasBuilderDefaultAnnotation()) { result.add(new LombokLightFieldBuilder(info.getManager(), info.renderFieldDefaultSetName(), PsiTypes.booleanType()) .withContainingClass(info.getBuilderClass()) .withModifier(PsiModifier.PRIVATE) .withNavigationElement(info.getVariable())); } return result; }
renderBuilderFields
13,207
Collection<PsiMethod> (@NotNull BuilderInfo info) { final String blockText = getAllMethodBody(info); final String methodName = calcBuilderMethodName(info); final LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(info.getManager(), methodName) .withContainingClass(info.getBuilderClass()) .withMethodReturnType(info.getBuilderType()) .withParameter(info.getFieldName(), info.getFieldType()) .withNavigationElement(info.getVariable()) .withModifier(info.getVisibilityModifier()) .withAnnotations(info.getAnnotations()) .withBodyText(blockText); if(info.getVariable() instanceof PsiField psiField) { LombokCopyableAnnotations.copyCopyableAnnotations(psiField, methodBuilder.getModifierList(), LombokCopyableAnnotations.COPY_TO_SETTER); } createRelevantNonNullAnnotation(info.getNullAnnotationLibrary(), methodBuilder); return Collections.singleton(methodBuilder); }
renderBuilderMethod
13,208
List<String> (@NotNull String fieldName, @NotNull String prefix, @Nullable PsiAnnotation singularAnnotation, CapitalizationStrategy capitalizationStrategy) { return Collections.singletonList(LombokUtils.buildAccessorName(prefix, fieldName, capitalizationStrategy)); }
getBuilderMethodNames
13,209
String (PsiAnnotation singularAnnotation, String psiFieldName) { return psiFieldName; }
createSingularName
13,210
String (@NotNull BuilderInfo info) { StringBuilder codeBlockTemplate = new StringBuilder("this.{0} = {1};\n"); if (info.hasBuilderDefaultAnnotation()) { codeBlockTemplate.append("this.{2} = true;\n"); } codeBlockTemplate.append("return {3};"); return MessageFormat.format(codeBlockTemplate.toString(), info.renderFieldName(), info.getFieldName(), info.renderFieldDefaultSetName(), info.getBuilderChainResult()); }
getAllMethodBody
13,211
String (@NotNull BuilderInfo info) { if (info.hasBuilderDefaultAnnotation()) { return MessageFormat.format( """ {0} {1} = this.{1}; if (!this.{2}) '{' {1} = {4}.{3}(); '}'""", info.getFieldType().getCanonicalText(false), info.renderFieldName(), info.renderFieldDefaultSetName(), info.renderFieldDefaultProviderName(), info.getBuilderClass().getContainingClass().getName()); } return ""; }
renderBuildPrepare
13,212
String (@NotNull BuilderInfo info) { if (info.hasBuilderDefaultAnnotation()) { return info.renderFieldName(); } else { return "this." + info.renderFieldName(); } }
renderBuildCall
13,213
AccessorsInfo (boolean fluentValue, boolean chainValue, boolean makeFinal, boolean doNotUseIsPrefix, CapitalizationStrategy capitalizationStrategy, String... prefixes) { return new AccessorsInfo(fluentValue, chainValue, makeFinal, doNotUseIsPrefix, capitalizationStrategy, prefixes); }
build
13,214
AccessorsInfo (@Nullable PsiClass psiClass, @Nullable Boolean chainDeclaredValue, @Nullable Boolean fluentDeclaredValue, @Nullable Boolean makeFinalDeclaredValue, @NotNull Collection<String> prefixDeclared) { final boolean isFluent; final boolean isChained; final boolean makeFinal; final boolean doNotUseIsPrefix; final CapitalizationStrategy capitalizationStrategy; final String[] prefixes; if (null != psiClass) { final ConfigDiscovery configDiscovery = ConfigDiscovery.getInstance(); if (null == fluentDeclaredValue) { isFluent = configDiscovery.getBooleanLombokConfigProperty(ConfigKey.ACCESSORS_FLUENT, psiClass); } else { isFluent = fluentDeclaredValue; } if (null == chainDeclaredValue) { isChained = configDiscovery.getBooleanLombokConfigProperty(ConfigKey.ACCESSORS_CHAIN, psiClass); } else { isChained = chainDeclaredValue; } if (null == makeFinalDeclaredValue) { makeFinal = configDiscovery.getBooleanLombokConfigProperty(ConfigKey.ACCESSORS_MAKE_FINAL, psiClass); } else { makeFinal = makeFinalDeclaredValue; } if (prefixDeclared.isEmpty()) { prefixes = ArrayUtil.toStringArray(configDiscovery.getMultipleValueLombokConfigProperty(ConfigKey.ACCESSORS_PREFIX, psiClass)); } else { prefixes = ArrayUtil.toStringArray(prefixDeclared); } doNotUseIsPrefix = configDiscovery.getBooleanLombokConfigProperty(ConfigKey.GETTER_NO_IS_PREFIX, psiClass); final String capitalizationStrategyValue = configDiscovery.getStringLombokConfigProperty(ConfigKey.ACCESSORS_JAVA_BEANS_SPEC_CAPITALIZATION, psiClass); capitalizationStrategy = CapitalizationStrategy.convertValue(capitalizationStrategyValue); } else { isFluent = null != fluentDeclaredValue && fluentDeclaredValue; isChained = null != chainDeclaredValue && chainDeclaredValue; makeFinal = null != makeFinalDeclaredValue && makeFinalDeclaredValue; prefixes = ArrayUtil.toStringArray(prefixDeclared); doNotUseIsPrefix = false; capitalizationStrategy = CapitalizationStrategy.defaultValue(); } boolean isChainDeclaredOrImplicit = isChained || (isFluent && null == chainDeclaredValue); return build(isFluent, isChainDeclaredOrImplicit, makeFinal, doNotUseIsPrefix, capitalizationStrategy, prefixes); }
buildAccessorsInfo
13,215
record (Boolean chainDeclaredValue, Boolean fluentDeclaredValue, Boolean makeFinalDeclaredValue, Collection<String> prefixes) { private AccessorsValues() { this(null, null, null, Collections.emptyList()); } private AccessorsValues combine(AccessorsValues defaults) { Boolean combinedChain = chainDeclaredValue; Boolean combinedFluent = fluentDeclaredValue; Boolean combinedMakeFinal = makeFinalDeclaredValue; Collection<String> combinedPrefixes = prefixes; if (combinedChain == null && null != defaults.chainDeclaredValue) { combinedChain = defaults.chainDeclaredValue; } if (combinedFluent == null && null != defaults.fluentDeclaredValue) { combinedFluent = defaults.fluentDeclaredValue; } if (combinedMakeFinal == null && null != defaults.makeFinalDeclaredValue) { combinedMakeFinal = defaults.makeFinalDeclaredValue; } if (combinedPrefixes.isEmpty() && !defaults.prefixes.isEmpty()) { combinedPrefixes = defaults.prefixes; } return new AccessorsValues(combinedChain, combinedFluent, combinedMakeFinal, combinedPrefixes); } }
AccessorsValues
13,216
AccessorsValues (AccessorsValues defaults) { Boolean combinedChain = chainDeclaredValue; Boolean combinedFluent = fluentDeclaredValue; Boolean combinedMakeFinal = makeFinalDeclaredValue; Collection<String> combinedPrefixes = prefixes; if (combinedChain == null && null != defaults.chainDeclaredValue) { combinedChain = defaults.chainDeclaredValue; } if (combinedFluent == null && null != defaults.fluentDeclaredValue) { combinedFluent = defaults.fluentDeclaredValue; } if (combinedMakeFinal == null && null != defaults.makeFinalDeclaredValue) { combinedMakeFinal = defaults.makeFinalDeclaredValue; } if (combinedPrefixes.isEmpty() && !defaults.prefixes.isEmpty()) { combinedPrefixes = defaults.prefixes; } return new AccessorsValues(combinedChain, combinedFluent, combinedMakeFinal, combinedPrefixes); }
combine
13,217
AccessorsValues (@NotNull PsiAnnotation accessorsAnnotation) { Boolean chainDeclaredValue = PsiAnnotationUtil.getDeclaredBooleanAnnotationValue(accessorsAnnotation, CHAIN_VALUE); Boolean fluentDeclaredValue = PsiAnnotationUtil.getDeclaredBooleanAnnotationValue(accessorsAnnotation, FLUENT_VALUE); Boolean makeFinalDeclaredValue = PsiAnnotationUtil.getDeclaredBooleanAnnotationValue(accessorsAnnotation, MAKE_FINAL_VALUE); Collection<String> prefixes = PsiAnnotationUtil.getAnnotationValues(accessorsAnnotation, PREFIX_VALUE, String.class); return new AccessorsValues(chainDeclaredValue, fluentDeclaredValue, makeFinalDeclaredValue, prefixes); }
collectValues
13,218
AccessorsInfo (@Nullable PsiClass psiClass, AccessorsValues values) { return buildAccessorsInfo(psiClass, values.chainDeclaredValue, values.fluentDeclaredValue, values.makeFinalDeclaredValue, values.prefixes); }
buildFrom
13,219
AccessorsInfo (@NotNull PsiField psiField) { final AccessorsValues fieldAccessorsValues = getAccessorsValues(psiField); final AccessorsValues classAccessorsValues = getAccessorsValues(psiField.getContainingClass()); final AccessorsValues combinedAccessorValues = fieldAccessorsValues.combine(classAccessorsValues); final PsiClass containingClass = psiField.getContainingClass(); return buildFrom(containingClass, combinedAccessorValues); }
buildFor
13,220
AccessorsInfo (@NotNull PsiClass psiClass) { AccessorsValues resultAccessorsValues = getAccessorsValues(psiClass); return buildFrom(psiClass, resultAccessorsValues); }
buildFor
13,221
AccessorsValues (@NotNull PsiField psiField) { AccessorsValues accessorsValues = new AccessorsValues(); final PsiAnnotation accessorsFieldAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, LombokClassNames.ACCESSORS); if (null != accessorsFieldAnnotation) { accessorsValues = collectValues(accessorsFieldAnnotation); } return accessorsValues; }
getAccessorsValues
13,222
AccessorsValues (@Nullable PsiClass psiClass) { AccessorsValues resultAccessorsValues = new AccessorsValues(); PsiClass containingClass = psiClass; while (null != containingClass) { final PsiAnnotation accessorsClassAnnotation = PsiAnnotationSearchUtil.findAnnotation(containingClass, LombokClassNames.ACCESSORS); if (null != accessorsClassAnnotation) { final AccessorsValues classAccessorsValues = collectValues(accessorsClassAnnotation); resultAccessorsValues = resultAccessorsValues.combine(classAccessorsValues); } containingClass = containingClass.getContainingClass(); } return resultAccessorsValues; }
getAccessorsValues
13,223
AccessorsInfo (@NotNull PsiField psiField, AccessorsValues classAccessorsValues) { final AccessorsValues fieldAccessorsValues = getAccessorsValues(psiField); final AccessorsValues combinedAccessorValues = fieldAccessorsValues.combine(classAccessorsValues); final PsiClass containingClass = psiField.getContainingClass(); return buildFrom(containingClass, combinedAccessorValues); }
buildFor
13,224
boolean () { return fluent; }
isFluent
13,225
AccessorsInfo (boolean fluentValue) { if (fluent == fluentValue) { return this; } return build(fluentValue, chain, makeFinal, doNotUseIsPrefix, capitalizationStrategy, prefixes); }
withFluent
13,226
boolean () { return chain; }
isChain
13,227
boolean () { return makeFinal; }
isMakeFinal
13,228
boolean () { return doNotUseIsPrefix; }
isDoNotUseIsPrefix
13,229
CapitalizationStrategy () { return capitalizationStrategy; }
getCapitalizationStrategy
13,230
String[] () { return prefixes; }
getPrefixes
13,231
boolean (String fieldName) { if (prefixes.length == 0) { return false; } for (String prefix : prefixes) { if (canPrefixApply(fieldName, prefix)) { return false; } } return true; }
isPrefixUnDefinedOrNotStartsWith
13,232
String (String fieldName) { for (String prefix : prefixes) { if (canPrefixApply(fieldName, prefix)) { return prefix.isEmpty() ? fieldName : decapitalizeLikeLombok(fieldName.substring(prefix.length())); } } return fieldName; }
removePrefix
13,233
boolean (String fieldName, String prefix) { final int prefixLength = prefix.length(); // we can use digits and upper case letters after a prefix, but not lower case letters return prefixLength == 0 || fieldName.startsWith(prefix) && fieldName.length() > prefixLength && (!Character.isLetter(prefix.charAt(prefix.length() - 1)) || !Character.isLowerCase(fieldName.charAt(prefixLength))); }
canPrefixApply
13,234
String (String name) { if (name == null || name.isEmpty()) { return name; } char[] chars = name.toCharArray(); chars[0] = Character.toLowerCase(chars[0]); return new String(chars); }
decapitalizeLikeLombok
13,235
RequiredArgsConstructorProcessor () { return LombokProcessorManager.getInstance().getRequiredArgsConstructorProcessor(); }
getRequiredArgsConstructorProcessor
13,236
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String generatedElementName = LombokUtils.getWitherName(psiField, accessorsInfo); return Collections.singletonList(generatedElementName); }
getNamesOfPossibleGeneratedElements
13,237
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink builder) { validateOnXAnnotations(psiAnnotation, psiField, builder, "onParam"); boolean valid = validateVisibility(psiAnnotation); valid &= validName(psiField, builder); valid &= validNonStatic(psiField, builder); valid &= validNonFinalInitialized(psiField, builder); valid &= validIsWitherUnique(psiField, builder); final PsiClass containingClass = psiField.getContainingClass(); valid &= null != containingClass && (containingClass.hasModifierProperty(PsiModifier.ABSTRACT) || validConstructor(containingClass, builder)); return valid; }
validate
13,238
boolean (@NotNull PsiAnnotation psiAnnotation) { final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation); return null != methodVisibility; }
validateVisibility
13,239
void (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { String methodModifier = LombokProcessorUtil.getMethodModifier(psiAnnotation); if (methodModifier != null) { AccessorsInfo accessorsInfo = buildAccessorsInfo(psiField); PsiMethod method = createWitherMethod(psiField, methodModifier, accessorsInfo); if (method != null) { target.add(method); } } }
generatePsiElements
13,240
boolean (@NotNull PsiField psiField, @NotNull ProblemSink builder) { if (psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER)) { builder.addWarningMessage("inspection.message.not.generating.wither.for.this.field.withers"); return false; } return true; }
validName
13,241
boolean (@NotNull PsiField psiField, @NotNull final ProblemSink builder) { if (psiField.hasModifierProperty(PsiModifier.STATIC)) { builder.addWarningMessage("inspection.message.not.generating.wither") .withLocalQuickFixes(()->PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.STATIC, false, false)); return false; } return true; }
validNonStatic
13,242
boolean (@NotNull PsiField psiField, @NotNull ProblemSink builder) { final PsiClass psiClass = psiField.getContainingClass(); if (null != psiClass && psiField.hasModifierProperty(PsiModifier.FINAL) && !PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.VALUE) && psiField.hasInitializer() && !PsiAnnotationSearchUtil.isAnnotatedWith(psiField, LombokClassNames.BUILDER_DEFAULT)) { builder.addWarningMessage("inspection.message.not.generating.wither.for.this.field.withers.cannot.be.generated") .withLocalQuickFixes(()->PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, false, false)); return false; } return true; }
validNonFinalInitialized
13,243
boolean (@NotNull PsiField psiField, @NotNull final ProblemSink builder) { final PsiClass fieldContainingClass = psiField.getContainingClass(); if (fieldContainingClass != null) { final Collection<PsiMethod> classMethods = PsiClassUtil.collectClassMethodsIntern(fieldContainingClass); filterToleratedElements(classMethods); final AccessorsInfo accessorsInfo = buildAccessorsInfo(psiField); final String psiFieldName = psiField.getName(); final Collection<String> possibleWitherNames = LombokUtils.toAllWitherNames(accessorsInfo, psiFieldName, PsiTypes.booleanType().equals(psiField.getType())); for (String witherName : possibleWitherNames) { if (PsiMethodUtil.hasSimilarMethod(classMethods, witherName, 1)) { builder.addWarningMessage("inspection.message.not.generating.s.method.with.that.name.already.exists", witherName); return false; } } } return true; }
validIsWitherUnique
13,244
boolean (@NotNull PsiClass psiClass, @NotNull ProblemSink builder) { if (psiClass.isRecord() || PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.ALL_ARGS_CONSTRUCTOR, LombokClassNames.VALUE, LombokClassNames.BUILDER)) { return true; } final Collection<PsiField> constructorParameters = filterFields(psiClass); if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.REQUIRED_ARGS_CONSTRUCTOR, LombokClassNames.DATA)) { final Collection<PsiField> requiredConstructorParameters = getRequiredArgsConstructorProcessor().getRequiredFields(psiClass); if (constructorParameters.size() == requiredConstructorParameters.size()) { return true; } } final Collection<PsiMethod> classConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass); boolean constructorExists = false; for (PsiMethod classConstructor : classConstructors) { if (classConstructor.getParameterList().getParametersCount() == constructorParameters.size()) { constructorExists = true; break; } } if (!constructorExists) { builder.addWarningMessage("inspection.message.wither.needs.constructor.for.all.fields.d.parameters", constructorParameters.size()); builder.markFailed(); } return constructorExists; }
validConstructor
13,245
Collection<PsiField> (@NotNull PsiClass psiClass) { final Collection<PsiField> psiFields = PsiClassUtil.collectClassFieldsIntern(psiClass); Collection<PsiField> result = new ArrayList<>(psiFields.size()); for (PsiField classField : psiFields) { final String classFieldName = classField.getName(); if (classFieldName.startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER)) { continue; } if (classField.hasModifierProperty(PsiModifier.STATIC)) { continue; } if (classField.hasModifierProperty(PsiModifier.FINAL) && classField.hasInitializer()) { continue; } result.add(classField); } return result; }
filterFields
13,246
PsiMethod (@NotNull PsiField psiField, @NotNull String methodModifier, @NotNull AccessorsInfo accessorsInfo) { LombokLightMethodBuilder methodBuilder = null; final PsiClass psiFieldContainingClass = psiField.getContainingClass(); if (psiFieldContainingClass != null) { final PsiType returnType = PsiClassUtil.getTypeWithGenerics(psiFieldContainingClass); methodBuilder = new LombokLightMethodBuilder(psiField.getManager(), LombokUtils.getWitherName(psiField, accessorsInfo)) .withMethodReturnType(returnType) .withContainingClass(psiFieldContainingClass) .withNavigationElement(psiField) .withModifier(methodModifier) .withPureContract(); if (accessorsInfo.isMakeFinal()) { methodBuilder.withModifier(PsiModifier.FINAL); } PsiAnnotation witherAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, LombokClassNames.WITHER, LombokClassNames.WITH); LombokCopyableAnnotations.copyOnXAnnotations(witherAnnotation, methodBuilder.getModifierList(), "onMethod"); final String psiFieldName = psiField.getName(); final PsiType psiFieldType = psiField.getType(); final LombokLightParameter methodParameter = new LombokLightParameter(psiFieldName, psiFieldType, methodBuilder); methodBuilder.withParameter(methodParameter); LombokLightModifierList methodParameterModifierList = methodParameter.getModifierList(); LombokCopyableAnnotations.copyCopyableAnnotations(psiField, methodParameterModifierList, LombokCopyableAnnotations.BASE_COPYABLE); LombokCopyableAnnotations.copyOnXAnnotations(witherAnnotation, methodParameterModifierList, "onParam"); if (psiFieldContainingClass.hasModifierProperty(PsiModifier.ABSTRACT)) { methodBuilder.withModifier(PsiModifier.ABSTRACT); } else { final String paramString = getConstructorCall(psiField, psiFieldContainingClass); final String blockText = String.format("return this.%s == %s ? this : new %s(%s);", psiFieldName, psiFieldName, returnType.getCanonicalText(), paramString); methodBuilder.withBodyText(blockText); } LombokAddNullAnnotations.createRelevantNonNullAnnotation(psiFieldContainingClass, methodBuilder); } return methodBuilder; }
createWitherMethod
13,247
AccessorsInfo (@NotNull PsiField psiField) { return AccessorsInfo.buildFor(psiField).withFluent(false); }
buildAccessorsInfo
13,248
String (@NotNull PsiField psiField, @NotNull PsiClass psiClass) { final StringBuilder paramString = new StringBuilder(); final Collection<PsiField> psiFields = filterFields(psiClass); for (PsiField classField : psiFields) { final String classFieldName = classField.getName(); if (classField.equals(psiField)) { paramString.append(classFieldName); } else { paramString.append("this.").append(classFieldName); } paramString.append(','); } if (paramString.length() > 1) { paramString.deleteCharAt(paramString.length() - 1); } return paramString.toString(); }
getConstructorCall
13,249
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { return LombokPsiElementUsage.READ_WRITE; }
checkFieldUsage
13,250
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField) { return Collections.emptyList(); }
getNamesOfPossibleGeneratedElements
13,251
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink builder) { final PsiType psiFieldType = psiField.getType(); return DelegateHandler.validate(psiField, psiFieldType, psiAnnotation, builder); }
validate
13,252
void (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { DelegateHandler.generateElements(psiField, psiField.getType(), psiAnnotation, target); }
generatePsiElements
13,253
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { return LombokPsiElementUsage.READ; }
checkFieldUsage
13,254
boolean (@Nullable String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField) { if (null == nameHint) { return true; } final Collection<String> namesOfGeneratedElements = getNamesOfPossibleGeneratedElements(psiClass, psiAnnotation, psiField); return namesOfGeneratedElements.isEmpty() || namesOfGeneratedElements.contains(nameHint); }
possibleToGenerateElementNamed
13,255
Collection<PsiAnnotation> (@NotNull PsiClass psiClass) { List<PsiAnnotation> result = new ArrayList<>(); for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) { PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, getSupportedAnnotationClasses()); if (null != psiAnnotation) { result.add(psiAnnotation); } } return result; }
collectProcessedAnnotations
13,256
Collection<LombokProblem> (@NotNull PsiAnnotation psiAnnotation) { Collection<LombokProblem> result = Collections.emptyList(); PsiField psiField = PsiTreeUtil.getParentOfType(psiAnnotation, PsiField.class); if (null != psiField) { ProblemValidationSink problemNewBuilder = new ProblemValidationSink(); validate(psiAnnotation, psiField, problemNewBuilder); result = problemNewBuilder.getProblems(); } return result; }
verifyAnnotation
13,257
void (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink problemSink, @NotNull String parameterName) { if (problemSink.deepValidation()) { final @NotNull List<PsiAnnotation> copyableAnnotations = LombokCopyableAnnotations.BASE_COPYABLE.collectCopyableAnnotations(psiField); if (!copyableAnnotations.isEmpty()) { final Iterable<String> onXAnnotations = LombokProcessorUtil.getOnX(psiAnnotation, parameterName); List<String> copyableAnnotationsFQNs = ContainerUtil.map(copyableAnnotations, PsiAnnotation::getQualifiedName); for (String copyableAnnotationFQN : copyableAnnotationsFQNs) { for (String onXAnnotation : onXAnnotations) { if (onXAnnotation.startsWith(copyableAnnotationFQN)) { problemSink.addErrorMessage("inspection.message.annotation.copy.duplicate", copyableAnnotationFQN); } } } } if (psiField.isDeprecated()) { final Iterable<String> onMethodAnnotations = LombokProcessorUtil.getOnX(psiAnnotation, "onMethod"); if (ContainerUtil.exists(onMethodAnnotations, CommonClassNames.JAVA_LANG_DEPRECATED::equals)) { problemSink.addErrorMessage("inspection.message.annotation.copy.duplicate", CommonClassNames.JAVA_LANG_DEPRECATED); } } } }
validateOnXAnnotations
13,258
boolean (@NotNull PsiField psiField, @NotNull ProblemSink builder, boolean isGetter) { final PsiClass psiClass = psiField.getContainingClass(); if (null != psiClass) { //cache signatures to speed up editing of big files, where getName goes in psi tree List<MethodSignatureBackedByPsiMethod> ownSignatures = CachedValuesManager.getCachedValue(psiClass, () -> { List<MethodSignatureBackedByPsiMethod> signatures = ContainerUtil.map(PsiClassUtil.collectClassMethodsIntern(psiClass), m -> MethodSignatureBackedByPsiMethod.create(m, PsiSubstitutor.EMPTY)); return new CachedValueProvider.Result<>(signatures, PsiModificationTracker.MODIFICATION_COUNT); }); final List<MethodSignatureBackedByPsiMethod> classMethods = new ArrayList<>(ownSignatures); final boolean isBoolean = PsiTypes.booleanType().equals(psiField.getType()); final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String fieldName = psiField.getName(); String accessorName = isGetter ? LombokUtils.toGetterName(accessorsInfo, fieldName, isBoolean) : LombokUtils.toSetterName(accessorsInfo, fieldName, isBoolean); int paramCount = isGetter ? 0 : 1; classMethods.removeIf(m -> m.getParameterTypes().length != paramCount || !accessorName.equals(m.getName())); classMethods.removeIf(definedMethod -> PsiAnnotationSearchUtil.isAnnotatedWith(definedMethod.getMethod(), LombokClassNames.TOLERATE)); if (!classMethods.isEmpty()) { builder.addWarningMessage("inspection.message.not.generated.s.method.with.similar.name.s.already.exists", accessorName, accessorName); return false; } } return true; }
validateExistingMethods
13,259
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String generatedElementName = LombokUtils.getSetterName(psiField, accessorsInfo); return Collections.singletonList(generatedElementName); }
getNamesOfPossibleGeneratedElements
13,260
void (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation); final PsiClass psiClass = psiField.getContainingClass(); if (methodVisibility != null && psiClass != null) { ContainerUtil.addIfNotNull(target, createSetterMethod(psiField, psiClass, methodVisibility, nameHint)); } }
generatePsiElements
13,261
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink builder) { boolean result; validateOnXAnnotations(psiAnnotation, psiField, builder, "onParam"); result = validateFinalModifier(psiAnnotation, psiField, builder); if (result) { result = validateVisibility(psiAnnotation); if (result) { result = validateExistingMethods(psiField, builder, false); if (result) { result = validateAccessorPrefix(psiField, builder); } } } return result; }
validate
13,262
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink builder) { boolean result = true; if (psiField.hasModifierProperty(PsiModifier.FINAL) && null != LombokProcessorUtil.getMethodModifier(psiAnnotation)) { builder.addWarningMessage("inspection.message.not.generating.setter.for.this.field.setters") .withLocalQuickFixes(() -> PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, false, false)); result = false; } return result; }
validateFinalModifier
13,263
boolean (@NotNull PsiAnnotation psiAnnotation) { final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation); return null != methodVisibility; }
validateVisibility
13,264
boolean (@NotNull PsiField psiField, @NotNull ProblemSink builder) { boolean result = true; if (AccessorsInfo.buildFor(psiField).isPrefixUnDefinedOrNotStartsWith(psiField.getName())) { builder.addWarningMessage("inspection.message.not.generating.setter.for.this.field.it"); result = false; } return result; }
validateAccessorPrefix
13,265
Collection<String> (@NotNull PsiField psiField, boolean isBoolean) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); return LombokUtils.toAllSetterNames(accessorsInfo, psiField.getName(), isBoolean); }
getAllSetterNames
13,266
PsiMethod (@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull String methodModifier, @Nullable String nameHint) { final String fieldName = psiField.getName(); final PsiType psiFieldType = psiField.getType(); final PsiAnnotation setterAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, LombokClassNames.SETTER); final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String methodName = LombokUtils.getSetterName(psiField, accessorsInfo); if (nameHint != null && !nameHint.equals(methodName)) return null; PsiType returnType = getReturnType(psiField, accessorsInfo.isChain()); LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(psiField.getManager(), methodName) .withMethodReturnType(returnType) .withContainingClass(psiClass) .withParameter(fieldName, psiFieldType) .withNavigationElement(psiField) .withMutatesThisContract(); if (StringUtil.isNotEmpty(methodModifier)) { methodBuilder.withModifier(methodModifier); } boolean isStatic = psiField.hasModifierProperty(PsiModifier.STATIC); if (isStatic) { methodBuilder.withModifier(PsiModifier.STATIC); } if (accessorsInfo.isMakeFinal()) { methodBuilder.withModifier(PsiModifier.FINAL); } LombokLightParameter setterParameter = methodBuilder.getParameterList().getParameter(0); if (null != setterParameter) { LombokLightModifierList methodParameterModifierList = setterParameter.getModifierList(); LombokCopyableAnnotations.copyCopyableAnnotations(psiField, methodParameterModifierList, LombokCopyableAnnotations.BASE_COPYABLE); LombokCopyableAnnotations.copyOnXAnnotations(setterAnnotation, methodParameterModifierList, "onParam"); } final LombokLightModifierList modifierList = methodBuilder.getModifierList(); LombokCopyableAnnotations.copyCopyableAnnotations(psiField, modifierList, LombokCopyableAnnotations.COPY_TO_SETTER); LombokCopyableAnnotations.copyOnXAnnotations(setterAnnotation, modifierList, "onMethod"); if (psiField.isDeprecated()) { modifierList.addAnnotation(CommonClassNames.JAVA_LANG_DEPRECATED); } final String codeBlockText = createCodeBlockText(psiField, psiClass, returnType, isStatic, setterParameter); methodBuilder.withBodyText(codeBlockText); if (!PsiTypes.voidType().equals(returnType)) { LombokAddNullAnnotations.createRelevantNonNullAnnotation(psiClass, methodBuilder); } return methodBuilder; }
createSetterMethod
13,267
String (@NotNull PsiField psiField, @NotNull PsiClass psiClass, PsiType returnType, boolean isStatic, PsiParameter methodParameter) { final String blockText; final String thisOrClass = isStatic ? psiClass.getName() : "this"; blockText = String.format("%s.%s = %s; ", thisOrClass, psiField.getName(), methodParameter.getName()); String codeBlockText = blockText; if (!isStatic && !PsiTypes.voidType().equals(returnType)) { codeBlockText += "return this;"; } return codeBlockText; }
createCodeBlockText
13,268
PsiType (@NotNull PsiField psiField, boolean isChained) { PsiType result = PsiTypes.voidType(); if (!psiField.hasModifierProperty(PsiModifier.STATIC) && isChained) { final PsiClass fieldClass = psiField.getContainingClass(); if (null != fieldClass) { result = PsiClassUtil.getTypeWithGenerics(fieldClass); } } return result; }
getReturnType
13,269
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { return LombokPsiElementUsage.WRITE; }
checkFieldUsage
13,270
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String generatedElementName = LombokUtils.getGetterName(psiField, accessorsInfo); return Collections.singletonList(generatedElementName); }
getNamesOfPossibleGeneratedElements
13,271
void (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation); final PsiClass psiClass = psiField.getContainingClass(); if (null != methodVisibility && null != psiClass) { ContainerUtil.addIfNotNull(target, createGetterMethod(psiField, psiClass, methodVisibility, nameHint)); } }
generatePsiElements
13,272
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink builder) { boolean result; final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation); result = null != methodVisibility; final boolean lazy = isLazyGetter(psiAnnotation); if (null == methodVisibility && lazy) { builder.addWarningMessage("inspection.message.lazy.does.not.work.with.access.level.none"); } if (result && lazy) { if (!psiField.hasModifierProperty(PsiModifier.FINAL) || !psiField.hasModifierProperty(PsiModifier.PRIVATE)) { builder.addErrorMessage("inspection.message.lazy.requires.field.to.be.private.final") .withLocalQuickFixes(()->PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.PRIVATE, true, false), ()->PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, true, false)); result = false; } if (!psiField.hasInitializer()) { builder.addErrorMessage("inspection.message.lazy.requires.field.initialization"); result = false; } } validateOnXAnnotations(psiAnnotation, psiField, builder, "onMethod"); if (result) { result = validateExistingMethods(psiField, builder, true); } if (result) { result = validateAccessorPrefix(psiField, builder); } return result; }
validate
13,273
boolean (@NotNull PsiAnnotation psiAnnotation) { return PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "lazy", false); }
isLazyGetter
13,274
boolean (@NotNull PsiField psiField, @NotNull ProblemSink builder) { boolean result = true; if (AccessorsInfo.buildFor(psiField).isPrefixUnDefinedOrNotStartsWith(psiField.getName())) { builder.addWarningMessage("inspection.message.not.generating.getter.for.this.field"); result = false; } return result; }
validateAccessorPrefix
13,275
PsiMethod (@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull String methodModifier, @Nullable String nameHint) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String methodName = LombokUtils.getGetterName(psiField, accessorsInfo); if (nameHint != null && !nameHint.equals(methodName)) return null; LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(psiField.getManager(), methodName) .withMethodReturnType(psiField.getType()) .withContainingClass(psiClass) .withNavigationElement(psiField) .withPureContract(); if (StringUtil.isNotEmpty(methodModifier)) { methodBuilder.withModifier(methodModifier); } boolean isStatic = psiField.hasModifierProperty(PsiModifier.STATIC); if (isStatic) { methodBuilder.withModifier(PsiModifier.STATIC); } if (accessorsInfo.isMakeFinal()) { methodBuilder.withModifier(PsiModifier.FINAL); } final String blockText = String.format("return %s.%s;", isStatic ? psiClass.getName() : "this", psiField.getName()); methodBuilder.withBodyText(blockText); final LombokLightModifierList modifierList = methodBuilder.getModifierList(); LombokCopyableAnnotations.copyCopyableAnnotations(psiField, modifierList, LombokCopyableAnnotations.BASE_COPYABLE); PsiAnnotation fieldGetterAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, LombokClassNames.GETTER); LombokCopyableAnnotations.copyOnXAnnotations(fieldGetterAnnotation, modifierList, "onMethod"); if (psiField.isDeprecated()) { modifierList.addAnnotation(CommonClassNames.JAVA_LANG_DEPRECATED); } return methodBuilder; }
createGetterMethod
13,276
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { return LombokPsiElementUsage.READ; }
checkFieldUsage
13,277
boolean (@NotNull PsiAnnotation psiAnnotation) { // old version of @FieldNameConstants has attributes "prefix" and "suffix", the new one not return null != psiAnnotation.findAttributeValue("prefix"); }
supportAnnotationVariant
13,278
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField) { final String generatedElementName = calcFieldConstantName(psiField, psiAnnotation, psiClass); return List.of(generatedElementName); }
getNamesOfPossibleGeneratedElements
13,279
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink builder) { return LombokProcessorUtil.isLevelVisible(psiAnnotation) && checkIfFieldNameIsValidAndWarn(psiAnnotation, psiField, builder); }
validate
13,280
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemSink builder) { final boolean isValid = isValidFieldNameConstant(psiAnnotation, psiField); if (!isValid) { builder.addWarningMessage("inspection.message.not.generating.constant"); } return isValid; }
checkIfFieldNameIsValidAndWarn
13,281
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField) { final PsiClass psiClass = psiField.getContainingClass(); if (null != psiClass) { final String fieldName = calcFieldConstantName(psiField, psiAnnotation, psiClass); return !fieldName.equals(psiField.getName()); } return false; }
isValidFieldNameConstant
13,282
void (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final PsiClass psiClass = psiField.getContainingClass(); if (null != psiClass) { target.add(createFieldNameConstant(psiField, psiClass, psiAnnotation)); } }
generatePsiElements
13,283
PsiField (@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { final PsiManager manager = psiClass.getContainingFile().getManager(); final PsiType psiFieldType = PsiType.getJavaLangString(manager, GlobalSearchScope.allScope(psiClass.getProject())); final String fieldModifier = LombokProcessorUtil.getLevelVisibility(psiAnnotation); final String fieldName = calcFieldConstantName(psiField, psiAnnotation, psiClass); LombokLightFieldBuilder fieldNameConstant = new LombokLightFieldBuilder(manager, fieldName, psiFieldType) .withContainingClass(psiClass) .withNavigationElement(psiField) .withModifier(PsiModifier.STATIC) .withModifier(PsiModifier.FINAL); if (!PsiModifier.PACKAGE_LOCAL.equals(fieldModifier)) { fieldNameConstant.withModifier(fieldModifier); } final PsiElementFactory psiElementFactory = JavaPsiFacade.getElementFactory(psiClass.getProject()); final PsiExpression initializer = psiElementFactory.createExpressionFromText("\"" + psiField.getName() + "\"", psiClass); fieldNameConstant.setInitializer(initializer); return fieldNameConstant; }
createFieldNameConstant
13,284
String (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass) { String prefix = PsiAnnotationUtil.getStringAnnotationValue(psiAnnotation, "prefix", CONFIG_DEFAULT); String suffix = PsiAnnotationUtil.getStringAnnotationValue(psiAnnotation, "suffix", CONFIG_DEFAULT); final ConfigDiscovery configDiscovery = ConfigDiscovery.getInstance(); if (CONFIG_DEFAULT.equals(prefix)) { prefix = configDiscovery.getStringLombokConfigProperty(ConfigKey.FIELD_NAME_CONSTANTS_PREFIX, psiClass); } if (CONFIG_DEFAULT.equals(suffix)) { suffix = configDiscovery.getStringLombokConfigProperty(ConfigKey.FIELD_NAME_CONSTANTS_SUFFIX, psiClass); } return prefix + LombokUtils.camelCaseToConstant(psiField.getName()) + suffix; }
calcFieldConstantName
13,285
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { return LombokPsiElementUsage.USAGE; }
checkFieldUsage
13,286
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return METHOD_LIST; }
getNamesOfPossibleGeneratedElements
13,287
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink problemSink) { validateAnnotationOnRightType(psiClass, problemSink); if (problemSink.success()) { validateExistingMethods(psiClass, problemSink); } if (problemSink.deepValidation()) { final Collection<String> excludeProperty = PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "exclude", String.class); final Collection<String> ofProperty = PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "of", String.class); if (!excludeProperty.isEmpty() && !ofProperty.isEmpty()) { problemSink.addWarningMessage("inspection.message.exclude.are.mutually.exclusive.exclude.parameter.will.be.ignored") .withLocalQuickFixes(() -> PsiQuickFixFactory.createChangeAnnotationParameterFix(psiAnnotation, "exclude", null)); } else { validateExcludeParam(psiClass, problemSink, psiAnnotation, excludeProperty); } validateOfParam(psiClass, problemSink, psiAnnotation, ofProperty); } return problemSink.success(); }
validate
13,288
void (@NotNull PsiClass psiClass, @NotNull ProblemSink builder) { if (psiClass.isAnnotationType() || psiClass.isInterface()) { builder.addErrorMessage("inspection.message.to.string.only.supported.on.class.or.enum.type"); builder.markFailed(); } }
validateAnnotationOnRightType
13,289
void (@NotNull PsiClass psiClass, @NotNull ProblemSink builder) { final boolean methodAlreadyExists = hasToStringMethodDefined(psiClass); if (methodAlreadyExists) { builder.addWarningMessage("inspection.message.not.generated.s.method.with.same.name.already.exists", TO_STRING_METHOD_NAME); builder.markFailed(); } }
validateExistingMethods
13,290
boolean (@NotNull PsiClass psiClass) { final Collection<PsiMethod> classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass); return PsiMethodUtil.hasMethodByName(classMethods, TO_STRING_METHOD_NAME, 0); }
hasToStringMethodDefined
13,291
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { target.addAll(createToStringMethod(psiClass, psiAnnotation)); }
generatePsiElements
13,292
PsiMethod (@NotNull PsiClass psiClass, @NotNull Collection<MemberInfo> memberInfos, @NotNull PsiAnnotation psiAnnotation, boolean forceCallSuper) { final PsiManager psiManager = psiClass.getManager(); final String paramString = createParamString(psiClass, memberInfos, psiAnnotation, forceCallSuper); final String blockText = String.format("return \"%s(%s)\";", getSimpleClassName(psiClass), paramString); final LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(psiManager, TO_STRING_METHOD_NAME) .withMethodReturnType(PsiType.getJavaLangString(psiManager, GlobalSearchScope.allScope(psiClass.getProject()))) .withContainingClass(psiClass) .withNavigationElement(psiAnnotation) .withModifier(PsiModifier.PUBLIC) .withBodyText(blockText); LombokAddNullAnnotations.createRelevantNonNullAnnotation(psiClass, methodBuilder); return methodBuilder; }
createToStringMethod
13,293
String (@NotNull PsiClass psiClass) { final StringBuilder psiClassName = new StringBuilder(); PsiClass containingClass = psiClass; do { if (!psiClassName.isEmpty()) { psiClassName.insert(0, '.'); } psiClassName.insert(0, containingClass.getName()); containingClass = containingClass.getContainingClass(); } while (null != containingClass); return psiClassName.toString(); }
getSimpleClassName
13,294
String (@NotNull PsiClass psiClass, @NotNull Collection<MemberInfo> memberInfos, @NotNull PsiAnnotation psiAnnotation, boolean forceCallSuper) { final boolean callSuper = forceCallSuper || readCallSuperAnnotationOrConfigProperty(psiAnnotation, psiClass, ConfigKey.TOSTRING_CALL_SUPER); final boolean doNotUseGetters = readAnnotationOrConfigProperty(psiAnnotation, psiClass, "doNotUseGetters", ConfigKey.TOSTRING_DO_NOT_USE_GETTERS); final boolean includeFieldNames = readAnnotationOrConfigProperty(psiAnnotation, psiClass, "includeFieldNames", ConfigKey.TOSTRING_INCLUDE_FIELD_NAMES); final StringBuilder paramString = new StringBuilder(); if (callSuper) { paramString.append("super=\" + super.toString() + \", "); } for (MemberInfo memberInfo : memberInfos) { if (includeFieldNames) { paramString.append(memberInfo.getName()).append('='); } paramString.append("\"+"); final PsiType classFieldType = memberInfo.getType(); if (classFieldType instanceof PsiArrayType) { final PsiType componentType = ((PsiArrayType)classFieldType).getComponentType(); if (componentType instanceof PsiPrimitiveType) { paramString.append("java.util.Arrays.toString("); } else { paramString.append("java.util.Arrays.deepToString("); } } final String memberAccessor = EqualsAndHashCodeToStringHandler.getMemberAccessorName(memberInfo, doNotUseGetters, psiClass); paramString.append("this.").append(memberAccessor); if (classFieldType instanceof PsiArrayType) { paramString.append(")"); } paramString.append("+\", "); } if (paramString.length() > 2) { paramString.delete(paramString.length() - 2, paramString.length()); } return paramString.toString(); }
createParamString
13,295
Collection<PsiAnnotation> (@NotNull PsiClass psiClass) { final Collection<PsiAnnotation> result = super.collectProcessedAnnotations(psiClass); addFieldsAnnotation(result, psiClass, TO_STRING_INCLUDE, TO_STRING_EXCLUDE); return result; }
collectProcessedAnnotations
13,296
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { final String psiFieldName = psiField.getName(); final Collection<MemberInfo> memberInfos = EqualsAndHashCodeToStringHandler.filterMembers(containingClass, psiAnnotation, false, INCLUDE_ANNOTATION_METHOD, ConfigKey.TOSTRING_ONLY_EXPLICITLY_INCLUDED, TO_STRING_INCLUDE, TO_STRING_EXCLUDE); if (memberInfos.stream().filter(MemberInfo::isField).map(MemberInfo::getName).anyMatch(psiFieldName::equals)) { return LombokPsiElementUsage.READ; } } return LombokPsiElementUsage.NONE; }
checkFieldUsage
13,297
boolean (@NotNull String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return nameHint.equals(psiClass.getName()); }
possibleToGenerateElementNamed
13,298
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return Collections.singleton(getConstructorName(psiClass)); }
getNamesOfPossibleGeneratedElements
13,299
String (@NotNull PsiClass psiClass) { return Strings.notNullize(psiClass.getName()); }
getConstructorName