Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
13,400
|
void (PsiClass psiClass, ProblemSink builder, PsiAnnotation psiAnnotation, Collection<String> ofProperty) { for (String fieldName : ofProperty) { if (!StringUtil.isEmptyOrSpaces(fieldName)) { PsiField fieldByName = psiClass.findFieldByName(fieldName, false); if (null == fieldByName) { final String newPropertyValue = calcNewPropertyValue(ofProperty, fieldName); builder.addWarningMessage("inspection.message.field.s.does.not.exist.field", fieldName) .withLocalQuickFixes(() -> PsiQuickFixFactory.createChangeAnnotationParameterFix(psiAnnotation, "of", newPropertyValue)); } } } }
|
validateOfParam
|
13,401
|
void (PsiClass psiClass, ProblemSink builder, PsiAnnotation psiAnnotation, Collection<String> excludeProperty) { for (String fieldName : excludeProperty) { if (!StringUtil.isEmptyOrSpaces(fieldName)) { PsiField fieldByName = psiClass.findFieldByName(fieldName, false); if (null == fieldByName) { final String newPropertyValue = calcNewPropertyValue(excludeProperty, fieldName); builder.addWarningMessage("inspection.message.field.s.does.not.exist.exclude", fieldName) .withLocalQuickFixes(() -> PsiQuickFixFactory.createChangeAnnotationParameterFix(psiAnnotation, "exclude", newPropertyValue)); } else { if (fieldName.startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER) || fieldByName.hasModifierProperty(PsiModifier.STATIC)) { final String newPropertyValue = calcNewPropertyValue(excludeProperty, fieldName); builder.addWarningMessage("inspection.message.field.s.would.have.been.excluded.anyway", fieldName) .withLocalQuickFixes(() -> PsiQuickFixFactory.createChangeAnnotationParameterFix(psiAnnotation, "exclude", newPropertyValue)); } } } } }
|
validateExcludeParam
|
13,402
|
String (Collection<String> allProperties, String fieldName) { String result = null; if (!allProperties.isEmpty() && (allProperties.size() > 1 || !allProperties.contains(fieldName))) { result = allProperties.stream().filter(((Predicate<String>) fieldName::equals).negate()) .collect(Collectors.joining("\",\"", "{\"", "\"}")); } return result; }
|
calcNewPropertyValue
|
13,403
|
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return Collections.singleton(FieldNameConstantsHandler.getTypeName(psiClass, psiAnnotation)); }
|
getNamesOfPossibleGeneratedElements
|
13,404
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final Collection<PsiMember> psiMembers = filterMembers(psiClass, psiAnnotation); if (!psiMembers.isEmpty()) { final String typeName = FieldNameConstantsHandler.getTypeName(psiClass, psiAnnotation); Optional<PsiClass> existingClass = PsiClassUtil.getInnerClassInternByName(psiClass, typeName); if (existingClass.isEmpty()) { LombokLightClassBuilder innerClassOrEnum = FieldNameConstantsHandler.createInnerClassOrEnum(typeName, psiClass, psiAnnotation); if (innerClassOrEnum != null) { innerClassOrEnum.withFieldSupplier((thisPsiClass) -> FieldNameConstantsHandler.createFields(thisPsiClass, psiMembers)); target.add(innerClassOrEnum); } } } }
|
generatePsiElements
|
13,405
|
boolean (@NotNull PsiAnnotation psiAnnotation) { // new version of @FieldNameConstants has an attribute "asEnum", the old one not return null != psiAnnotation.findAttributeValue("asEnum"); }
|
supportAnnotationVariant
|
13,406
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { return validateAnnotationOnRightType(psiClass, builder) && LombokProcessorUtil.isLevelVisible(psiAnnotation); }
|
validate
|
13,407
|
boolean (@NotNull PsiClass psiClass, @NotNull ProblemSink builder) { if (psiClass.isAnnotationType() || psiClass.isInterface()) { builder.addErrorMessage("inspection.message.field.name.constants.only.supported.on.class.or.enum"); return false; } return true; }
|
validateAnnotationOnRightType
|
13,408
|
Collection<PsiAnnotation> (@NotNull PsiClass psiClass) { final Collection<PsiAnnotation> result = super.collectProcessedAnnotations(psiClass); addFieldsAnnotation(result, psiClass, FIELD_NAME_CONSTANTS_INCLUDE, FIELD_NAME_CONSTANTS_EXCLUDE); return result; }
|
collectProcessedAnnotations
|
13,409
|
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { if (PsiClassUtil.getNames(filterMembers(containingClass, psiAnnotation)).contains(psiField.getName())) { return LombokPsiElementUsage.USAGE; } } return LombokPsiElementUsage.NONE; }
|
checkFieldUsage
|
13,410
|
FieldNameConstantsFieldProcessor () { return LombokProcessorManager.getInstance().getFieldNameConstantsFieldProcessor(); }
|
getFieldNameConstantsFieldProcessor
|
13,411
|
boolean (@NotNull PsiAnnotation psiAnnotation) { // old version of @FieldNameConstants has attributes "prefix" and "suffix", the new one not return null != psiAnnotation.findAttributeValue("prefix"); }
|
supportAnnotationVariant
|
13,412
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { final boolean result = validateAnnotationOnRightType(psiClass, builder) && LombokProcessorUtil.isLevelVisible(psiAnnotation); if (result) { final Collection<PsiField> psiFields = filterFields(psiClass); for (PsiField psiField : psiFields) { FieldNameConstantsFieldProcessor.checkIfFieldNameIsValidAndWarn(psiAnnotation, psiField, builder); } } return result; }
|
validate
|
13,413
|
boolean (@NotNull PsiClass psiClass, @NotNull ProblemSink builder) { boolean result = true; if (psiClass.isAnnotationType() || psiClass.isInterface()) { builder.addErrorMessage("inspection.message.field.name.constants.only.supported.on.class.enum.or.field.type"); result = false; } return result; }
|
validateAnnotationOnRightType
|
13,414
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final Collection<PsiField> psiFields = filterFields(psiClass); for (PsiField psiField : psiFields) { if (FieldNameConstantsFieldProcessor.checkIfFieldNameIsValidAndWarn(psiAnnotation, psiField, new ProblemProcessingSink())) { target.add(FieldNameConstantsFieldProcessor.createFieldNameConstant(psiField, psiClass, psiAnnotation)); } } }
|
generatePsiElements
|
13,415
|
Collection<PsiField> (@NotNull PsiClass psiClass) { final Collection<PsiField> psiFields = new ArrayList<>(); FieldNameConstantsFieldProcessor fieldProcessor = getFieldNameConstantsFieldProcessor(); for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) { boolean useField = true; PsiModifierList modifierList = psiField.getModifierList(); if (null != modifierList) { //Skip static fields. useField = !modifierList.hasModifierProperty(PsiModifier.STATIC); //Skip fields having same annotation already useField &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClasses()); //Skip fields that start with $ useField &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); } if (useField) { psiFields.add(psiField); } } return psiFields; }
|
filterFields
|
13,416
|
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { if (PsiClassUtil.getNames(filterFields(containingClass)).contains(psiField.getName())) { return LombokPsiElementUsage.USAGE; } } return LombokPsiElementUsage.NONE; }
|
checkFieldUsage
|
13,417
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { final String typeName = FieldNameConstantsHandler.getTypeName(psiClass, psiAnnotation); Optional<PsiClass> innerClass = PsiClassUtil.getInnerClassInternByName(psiClass, typeName); if (innerClass.isPresent()) { final boolean asEnum = PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "asEnum", false); if (innerClass.get().isEnum() != asEnum) { builder.addErrorMessage("inspection.message.field.name.constants.inner.type", asEnum); return false; } } return true; }
|
validate
|
13,418
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { //do nothing }
|
generatePsiElements
|
13,419
|
void (@NotNull PsiClass psiClass, @NotNull PsiClass existingInnerClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) { final Collection<PsiMember> psiMembers = filterMembers(psiClass, psiAnnotation); if (!psiMembers.isEmpty()) { List<PsiField> newFields = FieldNameConstantsHandler.createFields(existingInnerClass, psiMembers); target.addAll(newFields); } }
|
generatePsiElements
|
13,420
|
SuperBuilderHandler () { return new SuperBuilderHandler(); }
|
getBuilderHandler
|
13,421
|
Collection<LombokProblem> (@NotNull PsiAnnotation psiAnnotation) { //do nothing return Collections.emptySet(); }
|
verifyAnnotation
|
13,422
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { return getBuilderHandler().validate(psiClass, psiAnnotation, builder); }
|
validate
|
13,423
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { //do nothing }
|
generatePsiElements
|
13,424
|
BuilderHandler () { return new BuilderHandler(); }
|
getBuilderHandler
|
13,425
|
Collection<LombokProblem> (@NotNull PsiAnnotation psiAnnotation) { //do nothing return Collections.emptySet(); }
|
verifyAnnotation
|
13,426
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { return getBuilderHandler().validate(psiClass, psiAnnotation, builder); }
|
validate
|
13,427
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { //do nothing }
|
generatePsiElements
|
13,428
|
SuperBuilderHandler () { return new SuperBuilderHandler(); }
|
getBuilderHandler
|
13,429
|
boolean (@NotNull String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return nameHint.equals(BuilderHandler.TO_BUILDER_METHOD_NAME) || nameHint.equals(psiClass.getName()) || nameHint.equals(getBuilderHandler().getBuilderMethodName(psiAnnotation)); }
|
possibleToGenerateElementNamed
|
13,430
|
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { final BuilderHandler builderHandler = getBuilderHandler(); final String builderMethodName = builderHandler.getBuilderMethodName(psiAnnotation); final String constructorName = StringUtil.notNullize(psiClass.getName()); return List.of(builderMethodName, BuilderHandler.TO_BUILDER_METHOD_NAME, constructorName); }
|
getNamesOfPossibleGeneratedElements
|
13,431
|
Collection<PsiAnnotation> (@NotNull PsiClass psiClass) { final Collection<PsiAnnotation> result = super.collectProcessedAnnotations(psiClass); addJacksonizedAnnotation(psiClass, result); addFieldsAnnotation(result, psiClass, BuilderProcessor.SINGULAR_CLASS, BuilderProcessor.BUILDER_DEFAULT_CLASS); return result; }
|
collectProcessedAnnotations
|
13,432
|
void (@NotNull PsiClass psiClass, Collection<PsiAnnotation> result) { final PsiAnnotation jacksonizedAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, LombokClassNames.JACKSONIZED); if(null!=jacksonizedAnnotation) { result.add(jacksonizedAnnotation); } }
|
addJacksonizedAnnotation
|
13,433
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { // we skip validation here, because it will be validated by other BuilderClassProcessor return true;//builderHandler.validate(psiClass, psiAnnotation, builder); }
|
validate
|
13,434
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { SuperBuilderHandler builderHandler = getBuilderHandler(); final String builderClassName = builderHandler.getBuilderClassName(psiClass); final PsiClass builderBaseClass = psiClass.findInnerClassByName(builderClassName, false); if (null != builderBaseClass) { final PsiClassType psiTypeBaseWithGenerics = SuperBuilderHandler.getTypeWithWildcardsForSuperBuilderTypeParameters(builderBaseClass); builderHandler.createBuilderBasedConstructor(psiClass, builderBaseClass, psiAnnotation, psiTypeBaseWithGenerics) .ifPresent(target::add); // skip generation of builder methods, if class is abstract if (!psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) { final String builderImplClassName = builderHandler.getBuilderImplClassName(psiClass); final PsiClass builderImplClass = psiClass.findInnerClassByName(builderImplClassName, false); if (null != builderImplClass) { builderHandler.createBuilderMethodIfNecessary(psiClass, builderBaseClass, builderImplClass, psiAnnotation, psiTypeBaseWithGenerics) .ifPresent(target::add); SuperBuilderHandler.createToBuilderMethodIfNecessary(psiClass, builderBaseClass, builderImplClass, psiAnnotation, psiTypeBaseWithGenerics) .ifPresent(target::add); } } } }
|
generatePsiElements
|
13,435
|
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { return LombokPsiElementUsage.READ_WRITE; }
|
checkFieldUsage
|
13,436
|
SuperBuilderHandler () { return new SuperBuilderHandler(); }
|
getBuilderHandler
|
13,437
|
boolean (@NotNull String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { final SuperBuilderHandler builderHandler = getBuilderHandler(); final String builderClassName = builderHandler.getBuilderClassName(psiClass); return nameHint.equals(builderClassName) || !psiClass.hasModifierProperty(PsiModifier.ABSTRACT) && nameHint.equals(builderHandler.getBuilderImplClassName(psiClass)); }
|
possibleToGenerateElementNamed
|
13,438
|
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { final SuperBuilderHandler builderHandler = getBuilderHandler(); final String builderClassName = builderHandler.getBuilderClassName(psiClass); if (!psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) { final String builderImplClassName = builderHandler.getBuilderImplClassName(psiClass); return List.of(builderClassName, builderImplClassName); } return Collections.singleton(builderClassName); }
|
getNamesOfPossibleGeneratedElements
|
13,439
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { return getBuilderHandler().validate(psiClass, psiAnnotation, builder); }
|
validate
|
13,440
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { SuperBuilderHandler builderHandler = getBuilderHandler(); final String builderClassName = builderHandler.getBuilderClassName(psiClass); Optional<PsiClass> builderClass = PsiClassUtil.getInnerClassInternByName(psiClass, builderClassName); if (builderClass.isEmpty()) { final PsiClass createdBuilderClass = builderHandler.createBuilderBaseClass(psiClass, psiAnnotation); target.add(createdBuilderClass); builderClass = Optional.of(createdBuilderClass); } // skip generation of BuilderImpl class, if class is abstract if (!psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) { final String builderImplClassName = builderHandler.getBuilderImplClassName(psiClass); if (PsiClassUtil.getInnerClassInternByName(psiClass, builderImplClassName).isEmpty()) { target.add(builderHandler.createBuilderImplClass(psiClass, builderClass.get(), psiAnnotation)); } } }
|
generatePsiElements
|
13,441
|
BuilderHandler () { return new BuilderHandler(); }
|
getBuilderHandler
|
13,442
|
AllArgsConstructorProcessor () { return LombokProcessorManager.getInstance().getAllArgsConstructorProcessor(); }
|
getAllArgsConstructorProcessor
|
13,443
|
boolean (@NotNull String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return nameHint.equals(BuilderHandler.TO_BUILDER_METHOD_NAME) || nameHint.equals(psiClass.getName()) || nameHint.equals(getBuilderHandler().getBuilderMethodName(psiAnnotation)); }
|
possibleToGenerateElementNamed
|
13,444
|
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { final BuilderHandler builderHandler = getBuilderHandler(); final String builderMethodName = builderHandler.getBuilderMethodName(psiAnnotation); final String constructorName = StringUtil.notNullize(psiClass.getName()); return List.of(builderMethodName, BuilderHandler.TO_BUILDER_METHOD_NAME, constructorName); }
|
getNamesOfPossibleGeneratedElements
|
13,445
|
Collection<PsiAnnotation> (@NotNull PsiClass psiClass) { final Collection<PsiAnnotation> result = super.collectProcessedAnnotations(psiClass); addJacksonizedAnnotation(psiClass, result); addFieldsAnnotation(result, psiClass, SINGULAR_CLASS, BUILDER_DEFAULT_CLASS); return result; }
|
collectProcessedAnnotations
|
13,446
|
void (@NotNull PsiClass psiClass, Collection<PsiAnnotation> result) { final PsiAnnotation jacksonizedAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, LombokClassNames.JACKSONIZED); if(null!=jacksonizedAnnotation) { result.add(jacksonizedAnnotation); } }
|
addJacksonizedAnnotation
|
13,447
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { // we skip validation here, because it will be validated by other BuilderClassProcessor return true;//builderHandler.validate(psiClass, psiAnnotation, builder); }
|
validate
|
13,448
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { if (!psiClass.isRecord()) { if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, LombokClassNames.ALL_ARGS_CONSTRUCTOR, LombokClassNames.REQUIRED_ARGS_CONSTRUCTOR, LombokClassNames.NO_ARGS_CONSTRUCTOR)) { // Create all args constructor only if there is no declared constructors and no lombok constructor annotations final Collection<PsiMethod> definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass); if (definedConstructors.isEmpty()) { target.addAll(getAllArgsConstructorProcessor().createAllArgsConstructor(psiClass, PsiModifier.PACKAGE_LOCAL, psiAnnotation)); } } } final BuilderHandler builderHandler = getBuilderHandler(); final String builderClassName = BuilderHandler.getBuilderClassName(psiClass, psiAnnotation, null); final PsiClass builderClass = psiClass.findInnerClassByName(builderClassName, false); if (null != builderClass) { target.addAll( builderHandler.createBuilderDefaultProviderMethodsIfNecessary(psiClass, null, builderClass, psiAnnotation)); builderHandler.createBuilderMethodIfNecessary(psiClass, null, builderClass, psiAnnotation) .ifPresent(target::add); builderHandler.createToBuilderMethodIfNecessary(psiClass, null, builderClass, psiAnnotation) .ifPresent(target::add); } }
|
generatePsiElements
|
13,449
|
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { return LombokPsiElementUsage.READ_WRITE; }
|
checkFieldUsage
|
13,450
|
BuilderHandler () { return new BuilderHandler(); }
|
getBuilderHandler
|
13,451
|
boolean (@NotNull String nameHint, @NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return nameHint.equals(BuilderHandler.getBuilderClassName(psiClass, psiAnnotation, null)); }
|
possibleToGenerateElementNamed
|
13,452
|
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { final String innerBuilderClassName = BuilderHandler.getBuilderClassName(psiClass, psiAnnotation, null); return Collections.singleton(innerBuilderClassName); }
|
getNamesOfPossibleGeneratedElements
|
13,453
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { return getBuilderHandler().validate(psiClass, psiAnnotation, builder); }
|
validate
|
13,454
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { getBuilderHandler().createBuilderClassIfNotExist(psiClass, null, psiAnnotation).ifPresent(target::add); }
|
generatePsiElements
|
13,455
|
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return List.of(getConstructorName(psiClass), getStaticConstructorName(psiAnnotation)); }
|
getNamesOfPossibleGeneratedElements
|
13,456
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { boolean result = true; if (!validateAnnotationOnRightType(psiClass, builder)) { result = false; } if (!validateVisibility(psiAnnotation)) { result = false; } if (!validateBaseClassConstructor(psiClass, builder)) { result = false; } return result; }
|
validate
|
13,457
|
boolean (@NotNull PsiAnnotation psiAnnotation) { final String visibility = LombokProcessorUtil.getAccessVisibility(psiAnnotation); return null != visibility; }
|
validateVisibility
|
13,458
|
boolean (@NotNull PsiClass psiClass, @NotNull ProblemSink builder) { boolean result = true; if (psiClass.isAnnotationType() || psiClass.isInterface()) { builder.addErrorMessage("inspection.message.annotation.only.supported.on.class.or.enum.type"); result = false; } return result; }
|
validateAnnotationOnRightType
|
13,459
|
boolean (@NotNull PsiClass psiClass, @NotNull ProblemSink builder) { if (psiClass instanceof PsiAnonymousClass || psiClass.isEnum()) { return true; } PsiClass baseClass = psiClass.getSuperClass(); if (baseClass == null || psiClass.getManager().areElementsEquivalent(psiClass, baseClass)) { return true; } PsiMethod[] constructors = baseClass.getConstructors(); if (constructors.length == 0) { return true; } for (PsiMethod constructor : constructors) { final int parametersCount = constructor.getParameterList().getParametersCount(); if (parametersCount == 0 || parametersCount == 1 && constructor.isVarArgs()) { return true; } } builder.addErrorMessage("inspection.message.lombok.needs.default.constructor.in.base.class"); return false; }
|
validateBaseClassConstructor
|
13,460
|
boolean (@NotNull PsiClass psiClass, @Nullable String staticConstructorName, @NotNull Collection<PsiField> params, @NotNull ProblemSink builder) { boolean result = true; final List<PsiType> paramTypes = new ArrayList<>(params.size()); for (PsiField param : params) { paramTypes.add(param.getType()); } if (isStaticConstructor(staticConstructorName)) { final Collection<PsiMethod> definedMethods = PsiClassUtil.collectClassStaticMethodsIntern(psiClass); final PsiMethod existedStaticMethod = findExistedMethod(definedMethods, staticConstructorName, paramTypes); if (null != existedStaticMethod) { if (paramTypes.isEmpty()) { builder.addErrorMessage("inspection.message.method.s.matched.static.constructor.name.already.defined", staticConstructorName) .withLocalQuickFixes(() -> new SafeDeleteFix(existedStaticMethod)); } else { builder.addErrorMessage("inspection.message.method.s.with.d.parameters.matched.static.constructor.name.already.defined", staticConstructorName, paramTypes.size()) .withLocalQuickFixes(() -> new SafeDeleteFix(existedStaticMethod)); } result = false; } } return result; }
|
validateIsStaticConstructorNotDefined
|
13,461
|
boolean (@NotNull PsiClass psiClass, @Nullable String staticConstructorName, @NotNull Collection<PsiField> params, @NotNull ProblemSink builder) { // Constructor not defined or static constructor not defined return validateIsConstructorNotDefined(psiClass, params, builder) || validateIsStaticConstructorNotDefined(psiClass, staticConstructorName, params, builder); }
|
validateIsConstructorNotDefined
|
13,462
|
boolean (@NotNull PsiClass psiClass, @NotNull Collection<PsiField> params, @NotNull ProblemSink builder) { boolean result = true; final List<PsiType> paramTypes = ContainerUtil.map(params, PsiField::getType); final Collection<PsiMethod> definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass); final String constructorName = getConstructorName(psiClass); final PsiMethod existedMethod = findExistedMethod(definedConstructors, constructorName, paramTypes); if (null != existedMethod) { if (paramTypes.isEmpty()) { builder.addErrorMessage("inspection.message.constructor.without.parameters.already.defined") .withLocalQuickFixes(() -> new SafeDeleteFix(existedMethod)); } else { builder.addErrorMessage("inspection.message.constructor.with.d.parameters.already.defined", paramTypes.size()) .withLocalQuickFixes(() -> new SafeDeleteFix(existedMethod)); } result = false; } return result; }
|
validateIsConstructorNotDefined
|
13,463
|
String (@NotNull PsiClass psiClass) { return StringUtil.notNullize(psiClass.getName()); }
|
getConstructorName
|
13,464
|
PsiMethod (final Collection<PsiMethod> definedMethods, final String methodName, final List<PsiType> paramTypes) { for (PsiMethod method : definedMethods) { if (PsiElementUtil.methodMatches(method, null, null, methodName, paramTypes)) { return method; } } return null; }
|
findExistedMethod
|
13,465
|
Collection<PsiField> (@NotNull PsiClass psiClass) { Collection<PsiField> allNotInitializedNotStaticFields = new ArrayList<>(); final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.VALUE); Collection<PsiField> fields = psiClass.isRecord() ? RecordAugmentProvider.getFieldAugments(psiClass) : PsiClassUtil.collectClassFieldsIntern(psiClass); for (PsiField psiField : fields) { // skip fields named $ boolean addField = !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); final PsiModifierList modifierList = psiField.getModifierList(); if (null != modifierList) { // skip static fields addField &= !modifierList.hasModifierProperty(PsiModifier.STATIC); boolean isFinal = isFieldFinal(psiField, modifierList, classAnnotatedWithValue); // skip initialized final fields addField &= (!isFinal || !psiField.hasInitializer() || PsiAnnotationSearchUtil.findAnnotation(psiField, BUILDER_DEFAULT_ANNOTATION) != null); } if (addField) { allNotInitializedNotStaticFields.add(psiField); } } return allNotInitializedNotStaticFields; }
|
getAllNotInitializedAndNotStaticFields
|
13,466
|
Collection<PsiField> (@NotNull PsiClass psiClass) { return getAllNotInitializedAndNotStaticFields(psiClass); }
|
getAllFields
|
13,467
|
Collection<PsiField> (@NotNull PsiClass psiClass) { return getRequiredFields(psiClass, false); }
|
getRequiredFields
|
13,468
|
boolean (@NotNull PsiField psiField, @NotNull PsiModifierList modifierList, boolean classAnnotatedWithValue) { boolean isFinal = modifierList.hasModifierProperty(PsiModifier.FINAL); if (!isFinal && classAnnotatedWithValue) { isFinal = PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, LombokClassNames.NON_FINAL); } return isFinal; }
|
isFieldFinal
|
13,469
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @PsiModifier.ModifierConstant @NotNull String methodModifier, @NotNull PsiAnnotation psiAnnotation, boolean useJavaDefaults, @NotNull Collection<PsiField> params) { final String staticName = getStaticConstructorName(psiAnnotation); return createConstructorMethod(psiClass, methodModifier, psiAnnotation, useJavaDefaults, params, staticName, false); }
|
createConstructorMethod
|
13,470
|
String (@NotNull PsiAnnotation psiAnnotation) { return PsiAnnotationUtil.getStringAnnotationValue(psiAnnotation, "staticName", ""); }
|
getStaticConstructorName
|
13,471
|
boolean (@Nullable String staticName) { return !StringUtil.isEmptyOrSpaces(staticName); }
|
isStaticConstructor
|
13,472
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @PsiModifier.ModifierConstant @NotNull String methodModifier, @NotNull PsiAnnotation psiAnnotation, boolean useJavaDefaults, @NotNull Collection<PsiField> params, @Nullable String staticName, boolean skipConstructorIfAnyConstructorExists) { List<PsiMethod> methods = new ArrayList<>(); boolean hasStaticConstructor = !validateIsStaticConstructorNotDefined(psiClass, staticName, params, new ProblemProcessingSink()); final boolean staticConstructorRequired = isStaticConstructor(staticName); final String constructorVisibility = staticConstructorRequired || psiClass.isEnum() ? PsiModifier.PRIVATE : methodModifier; // check, if we should skip verification for presence of any (not Tolerated) constructors if (!skipConstructorIfAnyConstructorExists || !isAnyConstructorDefined(psiClass)) { boolean hasConstructor = !validateIsConstructorNotDefined(psiClass, useJavaDefaults ? Collections.emptyList() : params, new ProblemProcessingSink()); if (!hasConstructor) { final PsiMethod constructor = createConstructor(psiClass, constructorVisibility, useJavaDefaults, params, psiAnnotation); methods.add(constructor); } } if (staticConstructorRequired && !hasStaticConstructor) { PsiMethod staticConstructor = createStaticConstructor(psiClass, methodModifier, staticName, useJavaDefaults, params, psiAnnotation); methods.add(staticConstructor); } return methods; }
|
createConstructorMethod
|
13,473
|
boolean (@NotNull PsiClass psiClass) { Collection<PsiMethod> constructors = PsiClassUtil.collectClassConstructorIntern(psiClass); return ContainerUtil.exists(constructors, psiMethod -> PsiAnnotationSearchUtil.isNotAnnotatedWith(psiMethod, LombokClassNames.TOLERATE)); }
|
isAnyConstructorDefined
|
13,474
|
PsiMethod (@NotNull PsiClass psiClass, @PsiModifier.ModifierConstant @NotNull String modifier, boolean useJavaDefaults, @NotNull Collection<PsiField> params, @NotNull PsiAnnotation psiAnnotation) { LombokLightMethodBuilder constructorBuilder = new LombokLightMethodBuilder(psiClass.getManager(), getConstructorName(psiClass)) .withConstructor(true) .withContainingClass(psiClass) .withNavigationElement(psiAnnotation) .withModifier(modifier); LombokCopyableAnnotations.copyOnXAnnotations(psiAnnotation, constructorBuilder.getModifierList(), "onConstructor"); if (useJavaDefaults) { final StringBuilder blockText = new StringBuilder(); for (PsiField param : params) { final String fieldInitializer = PsiTypesUtil.getDefaultValueOfType(param.getType()); blockText.append(String.format("this.%s = %s;\n", param.getName(), fieldInitializer)); } constructorBuilder.withBodyText(blockText.toString()); } else { final List<String> fieldNames = new ArrayList<>(); final AccessorsInfo.AccessorsValues classAccessorsValues = AccessorsInfo.getAccessorsValues(psiClass); for (PsiField psiField : params) { final AccessorsInfo paramAccessorsInfo = AccessorsInfo.buildFor(psiField, classAccessorsValues); fieldNames.add(paramAccessorsInfo.removePrefix(psiField.getName())); } if (!fieldNames.isEmpty()) { boolean addConstructorProperties = configDiscovery.getBooleanLombokConfigProperty(ConfigKey.ANYCONSTRUCTOR_ADD_CONSTRUCTOR_PROPERTIES, psiClass); if (addConstructorProperties || !configDiscovery.getBooleanLombokConfigProperty(ConfigKey.ANYCONSTRUCTOR_SUPPRESS_CONSTRUCTOR_PROPERTIES, psiClass)) { final String constructorPropertiesAnnotation = "java.beans.ConstructorProperties( {" + fieldNames.stream().collect(Collectors.joining("\", \"", "\"", "\"")) + "} ) "; constructorBuilder.withAnnotation(constructorPropertiesAnnotation); } } final StringBuilder blockText = new StringBuilder(); final Iterator<String> fieldNameIterator = fieldNames.iterator(); final Iterator<PsiField> fieldIterator = params.iterator(); while (fieldNameIterator.hasNext() && fieldIterator.hasNext()) { final String parameterName = fieldNameIterator.next(); final PsiField parameterField = fieldIterator.next(); final LombokLightParameter parameter = new LombokLightParameter(parameterName, parameterField.getType(), constructorBuilder); parameter.setNavigationElement(parameterField); constructorBuilder.withParameter(parameter); LombokCopyableAnnotations.copyCopyableAnnotations(parameterField, parameter.getModifierList(), LombokCopyableAnnotations.BASE_COPYABLE); blockText.append(String.format("this.%s = %s;\n", parameterField.getName(), parameterName)); } constructorBuilder.withBodyText(blockText.toString()); } return constructorBuilder; }
|
createConstructor
|
13,475
|
PsiMethod (PsiClass psiClass, @PsiModifier.ModifierConstant String methodModifier, String staticName, boolean useJavaDefaults, Collection<PsiField> params, PsiAnnotation psiAnnotation) { LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(psiClass.getManager(), staticName) .withContainingClass(psiClass) .withNavigationElement(psiAnnotation) .withModifier(methodModifier) .withModifier(PsiModifier.STATIC); PsiSubstitutor substitutor = PsiSubstitutor.EMPTY; if (psiClass.hasTypeParameters()) { final PsiTypeParameter[] classTypeParameters = psiClass.getTypeParameters(); // need to create new type parameters for (int index = 0; index < classTypeParameters.length; index++) { final PsiTypeParameter classTypeParameter = classTypeParameters[index]; final LightTypeParameterBuilder methodTypeParameter = createTypeParameter(methodBuilder, index, classTypeParameter); methodBuilder.withTypeParameter(methodTypeParameter); substitutor = substitutor.put(classTypeParameter, PsiSubstitutor.EMPTY.substitute(methodTypeParameter)); } } final PsiElementFactory factory = JavaPsiFacade.getElementFactory(psiClass.getProject()); final PsiType returnType = factory.createType(psiClass, substitutor); methodBuilder.withMethodReturnType(returnType); if (!useJavaDefaults) { for (PsiField psiField : params) { final String parameterName = psiField.getName(); final PsiType parameterType = substitutor.substitute(psiField.getType()); final LombokLightParameter parameter = new LombokLightParameter(parameterName, parameterType, methodBuilder); parameter.setNavigationElement(psiField); methodBuilder.withParameter(parameter); LombokCopyableAnnotations.copyCopyableAnnotations(psiField, parameter.getModifierList(), LombokCopyableAnnotations.BASE_COPYABLE); } } final String codeBlockText = createStaticCodeBlockText(returnType, useJavaDefaults, methodBuilder.getParameterList()); methodBuilder.withBodyText(codeBlockText); LombokAddNullAnnotations.createRelevantNonNullAnnotation(psiClass, methodBuilder); return methodBuilder; }
|
createStaticConstructor
|
13,476
|
LightTypeParameterBuilder (LombokLightMethodBuilder method, int index, PsiTypeParameter psiClassTypeParameter) { final String nameOfTypeParameter = StringUtil.notNullize(psiClassTypeParameter.getName()); final LightTypeParameterBuilder result = new LightTypeParameterBuilder(nameOfTypeParameter, method, index); final LightReferenceListBuilder resultExtendsList = result.getExtendsList(); for (PsiClassType referencedType : psiClassTypeParameter.getExtendsList().getReferencedTypes()) { resultExtendsList.addReference(referencedType); } return result; }
|
createTypeParameter
|
13,477
|
String (@NotNull PsiType psiType, boolean useJavaDefaults, @NotNull final PsiParameterList parameterList) { final String psiClassName = psiType.getPresentableText(); final String paramsText = useJavaDefaults ? "" : joinParameters(parameterList); return String.format("return new %s(%s);", psiClassName, paramsText); }
|
createStaticCodeBlockText
|
13,478
|
String (PsiParameterList parameterList) { return Arrays.stream(parameterList.getParameters()).map(PsiParameter::getName).collect(Collectors.joining(",")); }
|
joinParameters
|
13,479
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { boolean result; result = super.validate(psiAnnotation, psiClass, builder); final Collection<PsiField> allReqFields = getRequiredFields(psiClass); final String staticConstructorName = getStaticConstructorName(psiAnnotation); result &= validateIsConstructorNotDefined(psiClass, staticConstructorName, allReqFields, builder); return result; }
|
validate
|
13,480
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final String methodVisibility = LombokProcessorUtil.getAccessVisibility(psiAnnotation); if (null != methodVisibility) { target.addAll( createRequiredArgsConstructor(psiClass, methodVisibility, psiAnnotation, getStaticConstructorName(psiAnnotation), false)); } }
|
generatePsiElements
|
13,481
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @PsiModifier.ModifierConstant @NotNull String methodModifier, @NotNull PsiAnnotation psiAnnotation, @Nullable String staticName, boolean skipConstructorIfAnyConstructorExists) { final Collection<PsiField> allReqFields = getRequiredFields(psiClass); return createConstructorMethod(psiClass, methodModifier, psiAnnotation, false, allReqFields, staticName, skipConstructorIfAnyConstructorExists); }
|
createRequiredArgsConstructor
|
13,482
|
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { if (PsiClassUtil.getNames(getRequiredFields(containingClass)).contains(psiField.getName())) { return LombokPsiElementUsage.WRITE; } } return LombokPsiElementUsage.NONE; }
|
checkFieldUsage
|
13,483
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink builder) { boolean result; result = super.validate(psiAnnotation, psiClass, builder); final Collection<PsiField> allNotInitializedNotStaticFields = getAllFields(psiClass); final String staticConstructorName = getStaticConstructorName(psiAnnotation); result &= validateIsConstructorNotDefined(psiClass, staticConstructorName, allNotInitializedNotStaticFields, builder); return result; }
|
validate
|
13,484
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @NotNull String methodVisibility, @NotNull PsiAnnotation psiAnnotation) { final Collection<PsiField> allNotInitializedNotStaticFields = getAllNotInitializedAndNotStaticFields(psiClass); return createConstructorMethod(psiClass, methodVisibility, psiAnnotation, false, allNotInitializedNotStaticFields); }
|
createAllArgsConstructor
|
13,485
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final String methodVisibility = LombokProcessorUtil.getAccessVisibility(psiAnnotation); if (null != methodVisibility) { final String staticConstructorName = getStaticConstructorName(psiAnnotation); target.addAll(createAllArgsConstructor(psiClass, methodVisibility, psiAnnotation, staticConstructorName)); } }
|
generatePsiElements
|
13,486
|
Collection<PsiMethod> (PsiClass psiClass, String methodVisibility, PsiAnnotation psiAnnotation, String staticName) { final Collection<PsiField> allNotInitializedNotStaticFields = getAllFields(psiClass); return createAllArgsConstructor(psiClass, methodVisibility, psiAnnotation, staticName, allNotInitializedNotStaticFields, false); }
|
createAllArgsConstructor
|
13,487
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @PsiModifier.ModifierConstant @NotNull String methodModifier, @NotNull PsiAnnotation psiAnnotation, String staticName, Collection<PsiField> allNotInitializedNotStaticFields, boolean skipConstructorIfAnyConstructorExists) { return createConstructorMethod(psiClass, methodModifier, psiAnnotation, false, allNotInitializedNotStaticFields, staticName, skipConstructorIfAnyConstructorExists); }
|
createAllArgsConstructor
|
13,488
|
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { if (PsiClassUtil.getNames(getAllNotInitializedAndNotStaticFields(containingClass)).contains(psiField.getName())) { return LombokPsiElementUsage.WRITE; } } return LombokPsiElementUsage.NONE; }
|
checkFieldUsage
|
13,489
|
boolean (@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemSink problemSink) { boolean result; result = super.validate(psiAnnotation, psiClass, problemSink); if (!isForceConstructor(psiAnnotation)) { final String staticConstructorName = getStaticConstructorName(psiAnnotation); result &= validateIsConstructorNotDefined(psiClass, staticConstructorName, Collections.emptyList(), problemSink); if (problemSink.deepValidation()) { final Collection<PsiField> requiredFields = getRequiredFields(psiClass, true); if (!requiredFields.isEmpty()) { problemSink.addErrorMessage("inspection.message.constructor.noargs.needs.to.be.forced") .withLocalQuickFixes(() -> PsiQuickFixFactory.createChangeAnnotationParameterFix(psiAnnotation, "force", "true")); } } } return result; }
|
validate
|
13,490
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @NotNull String methodVisibility, @NotNull PsiAnnotation psiAnnotation) { final boolean forceConstructorWithJavaDefaults = isForceConstructor(psiAnnotation); return createNoArgsConstructor(psiClass, methodVisibility, psiAnnotation, forceConstructorWithJavaDefaults); }
|
createNoArgsConstructor
|
13,491
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @NotNull String methodVisibility, @NotNull PsiAnnotation psiAnnotation, boolean withJavaDefaults) { final Collection<PsiField> params = getConstructorFields(psiClass, withJavaDefaults); return createConstructorMethod(psiClass, methodVisibility, psiAnnotation, withJavaDefaults, params); }
|
createNoArgsConstructor
|
13,492
|
boolean (@NotNull PsiAnnotation psiAnnotation) { return PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "force", false); }
|
isForceConstructor
|
13,493
|
void (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target, @Nullable String nameHint) { final String methodVisibility = LombokProcessorUtil.getAccessVisibility(psiAnnotation); if (null != methodVisibility) { target.addAll(createNoArgsConstructor(psiClass, methodVisibility, psiAnnotation)); } }
|
generatePsiElements
|
13,494
|
LombokPsiElementUsage (@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { final boolean forceConstructorWithJavaDefaults = isForceConstructor(psiAnnotation); final Collection<PsiField> params = getConstructorFields(containingClass, forceConstructorWithJavaDefaults); if (PsiClassUtil.getNames(params).contains(psiField.getName())) { return LombokPsiElementUsage.WRITE; } } return LombokPsiElementUsage.NONE; }
|
checkFieldUsage
|
13,495
|
Collection<PsiField> (PsiClass containingClass, boolean forceConstructorWithJavaDefaults) { Collection<PsiField> params; if (forceConstructorWithJavaDefaults) { params = getRequiredFields(containingClass); } else { params = Collections.emptyList(); } return params; }
|
getConstructorFields
|
13,496
|
LoggerInitializerParameter (@NotNull String parameter) { return switch (parameter) { case "TYPE" -> TYPE; case "NAME" -> NAME; case "TOPIC" -> TOPIC; case "NULL" -> NULL; default -> UNKNOWN; }; }
|
find
|
13,497
|
Collection<String> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { return Collections.singleton(getLoggerName(psiClass)); }
|
getNamesOfPossibleGeneratedElements
|
13,498
|
String (@NotNull PsiClass psiClass) { return ConfigDiscovery.getInstance().getStringLombokConfigProperty(ConfigKey.LOG_FIELDNAME, psiClass); }
|
getLoggerName
|
13,499
|
boolean (@NotNull PsiClass psiClass) { return ConfigDiscovery.getInstance().getBooleanLombokConfigProperty(ConfigKey.LOG_FIELD_IS_STATIC, psiClass); }
|
isLoggerStatic
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.