Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
13,000
|
boolean (Collection<String> alreadyExistingFieldNames) { return !alreadyExistingFieldNames.contains(fieldInBuilderName); }
|
notAlreadyExistingField
|
13,001
|
boolean (Collection<String> alreadyExistedMethodNames) { return !alreadyExistedMethodNames.contains(calcBuilderMethodName()); }
|
notAlreadyExistingMethod
|
13,002
|
Project () { return variableInClass.getProject(); }
|
getProject
|
13,003
|
PsiManager () { return variableInClass.getManager(); }
|
getManager
|
13,004
|
String () { return fieldInBuilderName; }
|
getFieldName
|
13,005
|
CapitalizationStrategy () { return capitalizationStrategy; }
|
getCapitalizationStrategy
|
13,006
|
LombokNullAnnotationLibrary () { return nullAnnotationLibrary; }
|
getNullAnnotationLibrary
|
13,007
|
PsiType () { return fieldInBuilderType; }
|
getFieldType
|
13,008
|
PsiVariable () { return variableInClass; }
|
getVariable
|
13,009
|
boolean () { return deprecated; }
|
isDeprecated
|
13,010
|
String () { return visibilityModifier; }
|
getVisibilityModifier
|
13,011
|
String () { return setterPrefix; }
|
getSetterPrefix
|
13,012
|
PsiClass () { return builderClass; }
|
getBuilderClass
|
13,013
|
PsiType () { return builderClassType; }
|
getBuilderType
|
13,014
|
String () { return builderChainResult; }
|
getBuilderChainResult
|
13,015
|
PsiAnnotation () { return singularAnnotation; }
|
getSingularAnnotation
|
13,016
|
boolean () { return null != singularAnnotation; }
|
hasSingularAnnotation
|
13,017
|
boolean () { return hasBuilderDefaultAnnotation; }
|
hasBuilderDefaultAnnotation
|
13,018
|
boolean () { return null == fieldInitializer; }
|
hasNoInitializer
|
13,019
|
boolean () { return null != obtainViaAnnotation; }
|
hasObtainViaAnnotation
|
13,020
|
PsiExpression () { return fieldInitializer; }
|
getFieldInitializer
|
13,021
|
String () { return viaFieldName; }
|
getViaFieldName
|
13,022
|
String () { return viaMethodName; }
|
getViaMethodName
|
13,023
|
boolean () { return viaStaticCall; }
|
isViaStaticCall
|
13,024
|
String () { return instanceVariableName; }
|
getInstanceVariableName
|
13,025
|
Collection<String> () { if (deprecated) { return Collections.singleton(CommonClassNames.JAVA_LANG_DEPRECATED); } return Collections.emptyList(); }
|
getAnnotations
|
13,026
|
Collection<PsiField> () { return builderElementHandler.renderBuilderFields(this); }
|
renderBuilderFields
|
13,027
|
String () { return builderElementHandler.calcBuilderMethodName(this); }
|
calcBuilderMethodName
|
13,028
|
Collection<PsiMethod> () { return builderElementHandler.renderBuilderMethod(this); }
|
renderBuilderMethods
|
13,029
|
String () { return builderElementHandler.renderBuildPrepare(this); }
|
renderBuildPrepare
|
13,030
|
String () { return builderElementHandler.renderBuildCall(this); }
|
renderBuildCall
|
13,031
|
String () { return builderElementHandler.renderSuperBuilderConstruction(variableInClass, fieldInBuilderName); }
|
renderSuperBuilderConstruction
|
13,032
|
String () { return hasBuilderDefaultAnnotation ? fieldInBuilderName + "$value" : fieldInBuilderName; }
|
renderFieldName
|
13,033
|
String () { return hasBuilderDefaultAnnotation ? fieldInBuilderName + "$set" : null; }
|
renderFieldDefaultSetName
|
13,034
|
String () { return hasBuilderDefaultAnnotation ? "$default$" + fieldInBuilderName : null; }
|
renderFieldDefaultProviderName
|
13,035
|
CharSequence () { if (hasObtainViaAnnotation() && StringUtil.isNotEmpty(viaMethodName)) { final StringBuilder result = new StringBuilder(); result.append(PsiModifier.FINAL); result.append(' '); result.append(fieldInBuilderType.getCanonicalText(false)); result.append(' '); result.append(fieldInBuilderName); result.append(" = "); result.append(viaStaticCall ? getPsiClass().getQualifiedName() : instanceVariableName); result.append('.'); //TODO should generate '<T>' here for generic methods result.append(viaMethodName); result.append(viaStaticCall ? "(" + instanceVariableName + ")" : "()"); result.append(';'); return result; } return ""; }
|
renderToBuilderPrependStatement
|
13,036
|
CharSequence () { return renderToBuilderCall(true); }
|
renderToBuilderCallWithPrependLogic
|
13,037
|
CharSequence () { return renderToBuilderCall(false); }
|
renderToBuilderCallWithoutPrependLogic
|
13,038
|
CharSequence (boolean usePrependLogic) { if (hasObtainViaAnnotation()) { final StringBuilder result = new StringBuilder(); result.append(fieldInBuilderName); result.append('('); if (StringUtil.isNotEmpty(viaFieldName)) { result.append(instanceVariableName).append(".").append(viaFieldName); } else if (StringUtil.isNotEmpty(viaMethodName)) { if(usePrependLogic) {//call to 'viaMethodName' is rendered as prepend statement result.append(fieldInBuilderName); } else { result.append(viaStaticCall ? getPsiClass().getQualifiedName() : instanceVariableName); result.append('.'); result.append(viaMethodName); result.append(viaStaticCall ? "(" + instanceVariableName + ")" : "()"); } } else { result.append(instanceVariableName).append(".").append(variableInClass.getName()); } result.append(')'); return result; } else { if(!usePrependLogic || !hasSingularAnnotation()) { return builderElementHandler.renderToBuilderCall(this); } else { return ""; } } }
|
renderToBuilderCall
|
13,039
|
CharSequence () { return builderElementHandler.renderToBuilderAppendCall(this); }
|
renderToBuilderAppendStatement
|
13,040
|
PsiClass () { return builderClass.getContainingClass(); }
|
getPsiClass
|
13,041
|
Optional<PsiType> () { PsiVariable psiVariable = variableInClass; if (StringUtil.isNotEmpty(viaFieldName)) { final PsiField fieldByName = getPsiClass().findFieldByName(viaFieldName, false); if (fieldByName != null) { psiVariable = fieldByName; } } final PsiType psiVariableType = psiVariable.getType(); if (psiVariableType instanceof PsiClassReferenceType) { final PsiClass resolvedPsiVariableClass = ((PsiClassReferenceType) psiVariableType).resolve(); if (resolvedPsiVariableClass instanceof PsiTypeParameter) { return Optional.of(psiVariableType); } } return Optional.empty(); }
|
getObtainViaFieldVariableType
|
13,042
|
void (String instanceVariableName) { this.instanceVariableName = instanceVariableName; }
|
withInstanceVariableName
|
13,043
|
PsiField () { return psiField; }
|
getField
|
13,044
|
boolean () { return psiField != null; }
|
isField
|
13,045
|
PsiMethod () { return psiMethod; }
|
getMethod
|
13,046
|
String () { return memberName; }
|
getName
|
13,047
|
PsiType () { if (null != psiField) { return psiField.getType(); } return psiMethod.getReturnType(); }
|
getType
|
13,048
|
boolean (String fieldName) { if (null != psiField && defaultInclude) { return fieldName.equals(psiField.getName()); } return false; }
|
matchDefaultIncludedFieldName
|
13,049
|
int (@NotNull MemberInfo other) { return Integer.compare(other.rankValue, rankValue); }
|
compareTo
|
13,050
|
Collection<MemberInfo> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, boolean filterTransient, String includeAnnotationProperty, @Nullable ConfigKey onlyExplicitlyIncludedConfigKey, @NotNull String annotationIncludeFQN, @NotNull String annotationExcludeFQN) { final boolean explicitOf = PsiAnnotationUtil.hasDeclaredProperty(psiAnnotation, "of"); final boolean onlyExplicitlyIncluded = checkOnlyExplicitlyIncluded(psiClass, psiAnnotation, onlyExplicitlyIncludedConfigKey); //Having both exclude and of generates a warning; the exclude parameter will be ignored in that case. final Collection<String> ofProperty; final Collection<String> excludeProperty; if (!explicitOf) { ofProperty = Collections.emptyList(); excludeProperty = makeSet(PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "exclude", String.class)); } else { ofProperty = makeSet(PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "of", String.class)); excludeProperty = Collections.emptyList(); } final Collection<PsiMember> psiMembers = PsiClassUtil.collectClassMemberIntern(psiClass); final Collection<String> fieldNames2BeReplaced = new ArrayList<>(); final List<MemberInfo> result = new ArrayList<>(psiMembers.size()); for (PsiMember psiMember : psiMembers) { final PsiAnnotation includeAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiMember, annotationIncludeFQN); if (null == includeAnnotation) { if (onlyExplicitlyIncluded) { continue; } if (!(psiMember instanceof PsiField psiField)) { continue; } final String fieldName = psiField.getName(); if (ofProperty.contains(fieldName)) { result.add(new MemberInfo(psiField)); continue; } else if (explicitOf) { continue; } if (excludeProperty.contains(fieldName)) { continue; } if (psiField.hasModifierProperty(PsiModifier.STATIC)) { continue; } if ((filterTransient && psiField.hasModifierProperty(PsiModifier.TRANSIENT))) { continue; } if (fieldName.startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER)) { continue; } if (PsiAnnotationSearchUtil.isAnnotatedWith(psiField, annotationExcludeFQN)) { continue; } result.add(new MemberInfo(psiField, fieldName, true)); } else { final String includeNameValue = PsiAnnotationUtil.getStringAnnotationValue(includeAnnotation, includeAnnotationProperty, ""); final String newMemberName; if (StringUtil.isEmptyOrSpaces(includeNameValue)) { newMemberName = psiMember.getName(); } else { newMemberName = includeNameValue; } if ((psiMember instanceof PsiMethod psiMethod)) { if (!psiMethod.hasParameters()) { fieldNames2BeReplaced.add(newMemberName); int memberRank = calcMemberRank(includeAnnotation); result.add(new MemberInfo(psiMethod, psiMethod.getName(), memberRank)); } } else { int memberRank = calcMemberRank(includeAnnotation); result.add(new MemberInfo((PsiField)psiMember, newMemberName, memberRank)); } } } for (String fieldName : fieldNames2BeReplaced) { // delete default-included fields with the same name as an explicit inclusion result.removeIf(memberInfo -> memberInfo.matchDefaultIncludedFieldName(fieldName)); } result.sort(MemberInfo::compareTo); return result; }
|
filterMembers
|
13,051
|
boolean (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @Nullable ConfigKey onlyExplicitlyIncludedConfigKey) { final boolean onlyExplicitlyIncluded; final Boolean declaredAnnotationValue = PsiAnnotationUtil.getDeclaredBooleanAnnotationValue(psiAnnotation, "onlyExplicitlyIncluded"); if (null == declaredAnnotationValue) { if (null != onlyExplicitlyIncludedConfigKey) { onlyExplicitlyIncluded = ConfigDiscovery.getInstance().getBooleanLombokConfigProperty(onlyExplicitlyIncludedConfigKey, psiClass); } else { onlyExplicitlyIncluded = false; } } else { onlyExplicitlyIncluded = declaredAnnotationValue; } return onlyExplicitlyIncluded; }
|
checkOnlyExplicitlyIncluded
|
13,052
|
int (@NotNull PsiAnnotation includeAnnotation) { return PsiAnnotationUtil.getIntAnnotationValue(includeAnnotation, TO_STRING_RANK_ANNOTATION_PARAMETER, 0); }
|
calcMemberRank
|
13,053
|
String (@NotNull MemberInfo memberInfo, boolean doNotUseGetters, @NotNull PsiClass psiClass) { final String memberAccessor; if (null == memberInfo.getMethod()) { memberAccessor = buildAttributeNameString(doNotUseGetters, memberInfo.getField(), psiClass); } else { memberAccessor = memberInfo.getName() + "()"; } return memberAccessor; }
|
getMemberAccessorName
|
13,054
|
String (boolean doNotUseGetters, @NotNull PsiField classField, @NotNull PsiClass psiClass) { final String fieldName = classField.getName(); if (doNotUseGetters) { return fieldName; } else { final String getterName = LombokUtils.getGetterName(classField); final boolean hasGetter; final boolean annotatedWith = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.DATA, LombokClassNames.VALUE, LombokClassNames.GETTER); if (annotatedWith) { final PsiAnnotation getterLombokAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, LombokClassNames.GETTER); hasGetter = null == getterLombokAnnotation || null != LombokProcessorUtil.getMethodModifier(getterLombokAnnotation); } else { hasGetter = PsiMethodUtil.hasMethodByName(PsiClassUtil.collectClassMethodsIntern(psiClass), getterName, 0); } return hasGetter ? getterName + "()" : fieldName; } }
|
buildAttributeNameString
|
13,055
|
Collection<String> (@NotNull Collection<String> exclude) { if (exclude.isEmpty()) { return Collections.emptySet(); } else { return new HashSet<>(exclude); } }
|
makeSet
|
13,056
|
String (@NotNull PsiClass containingClass, @NotNull PsiAnnotation fieldNameConstants) { String typeName = PsiAnnotationUtil.getStringAnnotationValue(fieldNameConstants, "innerTypeName", ""); if (StringUtil.isEmptyOrSpaces(typeName)) { final ConfigDiscovery configDiscovery = ConfigDiscovery.getInstance(); typeName = configDiscovery.getStringLombokConfigProperty(ConfigKey.FIELD_NAME_CONSTANTS_TYPENAME, containingClass); } return typeName; }
|
getTypeName
|
13,057
|
LombokLightClassBuilder (@NotNull String name, @NotNull PsiClass containingClass, @NotNull PsiAnnotation psiAnnotation) { final String accessLevel = LombokProcessorUtil.getLevelVisibility(psiAnnotation); if (accessLevel == null) { return null; } final boolean asEnum = PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "asEnum", false); if (asEnum) { return createEnum(name, containingClass, accessLevel, psiAnnotation); } else { return createInnerClass(name, containingClass, accessLevel, psiAnnotation); } }
|
createInnerClassOrEnum
|
13,058
|
boolean (@NotNull PsiClass containingClass) { final ConfigDiscovery configDiscovery = ConfigDiscovery.getInstance(); return configDiscovery.getBooleanLombokConfigProperty(ConfigKey.FIELD_NAME_CONSTANTS_UPPERCASE, containingClass); }
|
useUppercasedConstants
|
13,059
|
List<PsiField> (@NotNull PsiClass containingClass, @NotNull Collection<PsiMember> psiMembers) { final Set<String> existingFieldNames = PsiClassUtil.collectClassFieldsIntern(containingClass).stream().map(PsiField::getName).collect(Collectors.toSet()); final PsiElementFactory psiElementFactory = JavaPsiFacade.getElementFactory(containingClass.getProject()); final PsiClassType classType = psiElementFactory.createType(containingClass); boolean makeUppercased = useUppercasedConstants(containingClass); return psiMembers.stream() .filter(psiMember -> !existingFieldNames.contains(makeFieldNameConstant(psiMember, makeUppercased))) .map(psiField -> { if (containingClass.isEnum()) { return createEnumConstant(psiField, makeUppercased, containingClass, classType); } return createFieldNameConstant(psiField, makeUppercased, containingClass); }).collect(Collectors.toList()); }
|
createFields
|
13,060
|
LombokLightClassBuilder (@NotNull String name, @NotNull PsiClass containingClass, @NotNull String accessLevel, @NotNull PsiElement navigationElement) { final String innerClassQualifiedName = containingClass.getQualifiedName() + "." + name; final LombokLightClassBuilder lazyClassBuilder = new LombokLightClassBuilder(containingClass, name, innerClassQualifiedName); lazyClassBuilder.withContainingClass(containingClass) .withNavigationElement(navigationElement) .withEnum(true) .withModifier(accessLevel) .withImplicitModifier(PsiModifier.STATIC) .withImplicitModifier(PsiModifier.FINAL); lazyClassBuilder.withMethodSupplier((thisPsiClass)-> { //add enum methods like here: ClassInnerStuffCache.calcMethods final PsiManager psiManager = containingClass.getManager(); final PsiClassType enumClassType = PsiClassUtil.getTypeWithGenerics(thisPsiClass); // "public static " + myClass.getName() + "[] values() { }" final LombokLightMethodBuilder valuesEnumMethod = new LombokLightMethodBuilder(psiManager, "values") .withModifier(PsiModifier.PUBLIC) .withModifier(PsiModifier.STATIC) .withContainingClass(containingClass) .withNavigationElement(navigationElement) .withMethodReturnType(new PsiArrayType(enumClassType)) .withBodyText(""); // "public static " + myClass.getName() + " valueOf(java.lang.String name) throws java.lang.IllegalArgumentException { }" final LombokLightMethodBuilder valueOfEnumMethod = new LombokLightMethodBuilder(psiManager, "valueOf") .withModifier(PsiModifier.PUBLIC) .withModifier(PsiModifier.STATIC) .withContainingClass(containingClass) .withNavigationElement(navigationElement) .withParameter("name", PsiType.getJavaLangString(psiManager, containingClass.getResolveScope())) .withException(PsiType.getTypeByName("java.lang.IllegalArgumentException", containingClass.getProject(), containingClass.getResolveScope())) .withMethodReturnType(enumClassType) .withBodyText(""); return List.of(valuesEnumMethod, valueOfEnumMethod); }); return lazyClassBuilder; }
|
createEnum
|
13,061
|
PsiField (@NotNull PsiMember psiMember, boolean makeUppercased, @NotNull PsiClass containingClass, PsiClassType classType) { return new LombokEnumConstantBuilder(containingClass.getManager(), makeFieldNameConstant(psiMember, makeUppercased), classType) .withContainingClass(containingClass) .withModifier(PsiModifier.PUBLIC) .withImplicitModifier(PsiModifier.STATIC) .withImplicitModifier(PsiModifier.FINAL) .withNavigationElement(psiMember); }
|
createEnumConstant
|
13,062
|
String (@NotNull PsiMember psiMember, boolean makeUppercased) { final String fieldName = psiMember.getName(); return makeUppercased ? LombokUtils.camelCaseToConstant(fieldName) : fieldName; }
|
makeFieldNameConstant
|
13,063
|
LombokLightClassBuilder (@NotNull String name, @NotNull PsiClass containingClass, @NotNull String accessLevel, @NotNull PsiElement navigationElement) { final String innerClassQualifiedName = containingClass.getQualifiedName() + "." + name; final LombokLightClassBuilder lazyClassBuilder = new LombokLightClassBuilder(containingClass, name, innerClassQualifiedName); lazyClassBuilder.withContainingClass(containingClass) .withNavigationElement(navigationElement) .withModifier(accessLevel) .withModifier(PsiModifier.STATIC) .withModifier(PsiModifier.FINAL); return lazyClassBuilder; }
|
createInnerClass
|
13,064
|
PsiField (@NotNull PsiMember psiMember, boolean makeUppercased, @NotNull PsiClass containingClass) { final PsiManager manager = containingClass.getContainingFile().getManager(); final PsiType fieldNameConstType = PsiType.getJavaLangString(manager, GlobalSearchScope.allScope(containingClass.getProject())); LombokLightFieldBuilder fieldNameConstant = new LombokLightFieldBuilder(manager, makeFieldNameConstant(psiMember, makeUppercased), fieldNameConstType) .withContainingClass(containingClass) .withNavigationElement(psiMember) .withModifier(PsiModifier.PUBLIC) .withModifier(PsiModifier.STATIC) .withModifier(PsiModifier.FINAL); final PsiElementFactory psiElementFactory = JavaPsiFacade.getElementFactory(containingClass.getProject()); final PsiExpression initializer = psiElementFactory.createExpressionFromText("\"" + psiMember.getName() + "\"", containingClass); fieldNameConstant.setInitializer(initializer); return fieldNameConstant; }
|
createFieldNameConstant
|
13,065
|
boolean (@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull PsiType psiType, @NotNull PsiAnnotation psiAnnotation, @NotNull ProblemSink problemSink) { boolean result = true; if (psiModifierListOwner.hasModifierProperty(PsiModifier.STATIC)) { problemSink.addErrorMessage("inspection.message.delegate.legal.only.on.instance.fields"); result = false; } final Collection<PsiType> types = collectDelegateTypes(psiAnnotation, psiType); result &= validateTypes(types, problemSink); final Collection<PsiType> excludes = collectExcludeTypes(psiAnnotation); result &= validateTypes(excludes, problemSink); return result; }
|
validate
|
13,066
|
Collection<PsiType> (PsiAnnotation psiAnnotation, PsiType psiType) { Collection<PsiType> types = PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "types", PsiType.class); if (types.isEmpty()) { types = Collections.singletonList(psiType); } return types; }
|
collectDelegateTypes
|
13,067
|
boolean (Collection<PsiType> psiTypes, ProblemSink problemSink) { boolean result = true; for (PsiType psiType : psiTypes) { if (!checkConcreteClass(psiType)) { problemSink.addErrorMessage("inspection.message.delegate.can.only.use.concrete.class.types", psiType.getCanonicalText()); result = false; } else { result &= validateRecursion(psiType, problemSink); } } return result; }
|
validateTypes
|
13,068
|
boolean (PsiType psiType, ProblemSink problemSink) { final PsiClass psiClass = PsiTypesUtil.getPsiClass(psiType); if (null != psiClass) { final DelegateAnnotationElementVisitor delegateAnnotationElementVisitor = new DelegateAnnotationElementVisitor(psiType, problemSink); psiClass.acceptChildren(delegateAnnotationElementVisitor); return delegateAnnotationElementVisitor.isValid(); } return true; }
|
validateRecursion
|
13,069
|
boolean (@NotNull PsiType psiType) { if (psiType instanceof PsiClassType) { PsiClass psiClass = ((PsiClassType)psiType).resolve(); return !(psiClass instanceof PsiTypeParameter); } return false; }
|
checkConcreteClass
|
13,070
|
Collection<PsiType> (PsiAnnotation psiAnnotation) { return PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "excludes", PsiType.class); }
|
collectExcludeTypes
|
13,071
|
void (Collection<PsiType> types, Collection<Pair<PsiMethod, PsiSubstitutor>> results) { for (PsiType type : types) { addMethodsOfType(type, results); } }
|
addMethodsOfTypes
|
13,072
|
void (PsiType psiType, Collection<Pair<PsiMethod, PsiSubstitutor>> results) { final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(psiType); final PsiClass psiClass = resolveResult.getElement(); if (null != psiClass && psiType instanceof PsiClassType psiClassType) { final PsiTypeParameter[] classTypeParameters = psiClass.getTypeParameters(); final PsiType[] parameters = psiClassType.getParameters(); PsiSubstitutor enrichedSubstitutor = PsiSubstitutor.EMPTY; if (classTypeParameters.length == parameters.length) { for (int i = 0; i < parameters.length; i++) { enrichedSubstitutor = enrichedSubstitutor.put(classTypeParameters[i], parameters[i]); } } for (Pair<PsiMethod, PsiSubstitutor> pair : psiClass.getAllMethodsAndTheirSubstitutors()) { final PsiMethod psiMethod = pair.getFirst(); if (isAcceptableMethod(psiMethod)) { final PsiSubstitutor psiSubstitutor = pair.getSecond().putAll(enrichedSubstitutor); if (!isAlreadyPresent(psiMethod, psiSubstitutor, results)) { results.add(Pair.pair(psiMethod, psiSubstitutor)); } } } } }
|
addMethodsOfType
|
13,073
|
void (@NotNull PsiExtensibleClass psiStartClass, Collection<Pair<PsiMethod, PsiSubstitutor>> results) { PsiExtensibleClass psiClass = psiStartClass; do { for (PsiMethod psiMethod : psiClass.getOwnMethods()) { if (isAcceptableMethod(psiMethod)) { if (!isAlreadyPresent(psiMethod, PsiSubstitutor.EMPTY, results)) { results.add(Pair.pair(psiMethod, PsiSubstitutor.EMPTY)); } } } if (psiClass.getSuperClass() instanceof PsiExtensibleClass psiExtensibleSuperClass) { psiClass = psiExtensibleSuperClass; } else { psiClass = null; } } while (null != psiClass); }
|
collectAllOwnMethods
|
13,074
|
boolean (PsiMethod psiMethod) { return !psiMethod.isConstructor() && psiMethod.hasModifierProperty(PsiModifier.PUBLIC) && !psiMethod.hasModifierProperty(PsiModifier.STATIC); }
|
isAcceptableMethod
|
13,075
|
boolean (PsiMethod psiMethod, PsiSubstitutor psiSubstitutor, Collection<Pair<PsiMethod, PsiSubstitutor>> searchedPairs) { boolean acceptMethod = true; for (Pair<PsiMethod, PsiSubstitutor> someMethodPair : searchedPairs) { if (methodMatches(psiMethod, psiSubstitutor, someMethodPair.getFirst(), someMethodPair.getSecond())) { acceptMethod = false; break; } } return !acceptMethod; }
|
isAlreadyPresent
|
13,076
|
boolean (@NotNull PsiMethod firstMethod, @NotNull PsiSubstitutor firstSubstitutor, @NotNull PsiMethod secondMethod, @NotNull PsiSubstitutor secondSubstitutor) { if (!firstMethod.getName().equals(secondMethod.getName())) { return false; } PsiParameterList firstMethodParameterList = firstMethod.getParameterList(); PsiParameterList secondMethodParameterList = secondMethod.getParameterList(); if (firstMethodParameterList.getParametersCount() != secondMethodParameterList.getParametersCount()) { return false; } PsiParameter[] firstMethodParameterListParameters = firstMethodParameterList.getParameters(); PsiParameter[] secondMethodParameterListParameters = secondMethodParameterList.getParameters(); for (int i = 0; i < firstMethodParameterListParameters.length; i++) { PsiType firstMethodParameterListParameterType = firstSubstitutor.substitute(firstMethodParameterListParameters[i].getType()); PsiType secondMethodParameterListParameterType = secondSubstitutor.substitute(secondMethodParameterListParameters[i].getType()); if (PsiTypes.nullType().equals(firstMethodParameterListParameterType)) { continue; } if (!PsiElementUtil.typesAreEquivalent(firstMethodParameterListParameterType, secondMethodParameterListParameterType)) { return false; } } return true; }
|
methodMatches
|
13,077
|
void (@NotNull PsiField psiField) { checkModifierListOwner(psiField); }
|
visitField
|
13,078
|
void (@NotNull PsiMethod psiMethod) { checkModifierListOwner(psiMethod); }
|
visitMethod
|
13,079
|
void (PsiModifierListOwner modifierListOwner) { if (PsiAnnotationSearchUtil.isAnnotatedWith(modifierListOwner, LombokClassNames.DELEGATE, LombokClassNames.EXPERIMENTAL_DELEGATE)) { builder.addErrorMessage("inspection.message.delegate.does.not.support.recursion.delegating", ((PsiMember)modifierListOwner).getName(), psiType.getPresentableText()); valid = false; } }
|
checkModifierListOwner
|
13,080
|
boolean () { return valid; }
|
isValid
|
13,081
|
boolean (@NotNull PsiClass psiClass, Collection<BuilderInfo> builderInfos, @NotNull ProblemSink problemSink) { return true; }
|
validateBuilderConstructor
|
13,082
|
boolean (@NotNull String builderClassName, @NotNull PsiClass psiClass, @NotNull ProblemSink problemSink) { final Optional<PsiClass> existingInnerBuilderClassOptional = PsiClassUtil.getInnerClassInternByName(psiClass, builderClassName); if (existingInnerBuilderClassOptional.isPresent()) { final PsiClass existingInnerBuilderClass = existingInnerBuilderClassOptional.get(); if (!validateInvalidAnnotationsOnBuilderClass(existingInnerBuilderClass, problemSink)) { return false; } final boolean isStatic = existingInnerBuilderClass.hasModifierProperty(PsiModifier.STATIC); final boolean isAbstract = existingInnerBuilderClass.hasModifierProperty(PsiModifier.ABSTRACT); if (!isStatic || !isAbstract) { final LombokProblem problem = problemSink.addErrorMessage("inspection.message.existing.builder.must.be.abstract.static.inner.class"); if (!isAbstract && !isStatic) { problem.withLocalQuickFixes(() -> LocalQuickFix.from(new AddAbstractAndStaticModifiersFix(existingInnerBuilderClass))); } else if (!isAbstract) { problem.withLocalQuickFixes( () -> PsiQuickFixFactory.createModifierListFix(existingInnerBuilderClass, PsiModifier.ABSTRACT, true, false)); } else { problem.withLocalQuickFixes( () -> PsiQuickFixFactory.createModifierListFix(existingInnerBuilderClass, PsiModifier.STATIC, true, false)); } return false; } } return true; }
|
validateExistingBuilderClass
|
13,083
|
String (@NotNull PsiClass psiClass) { return getBuilderClassName(psiClass, psiClass.getName()); }
|
getBuilderClassName
|
13,084
|
String (@NotNull PsiClass psiClass) { return getBuilderClassName(psiClass) + "Impl"; }
|
getBuilderImplClassName
|
13,085
|
Optional<PsiMethod> (@NotNull PsiClass psiClass, @NotNull PsiClass builderClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClassType psiTypeBaseWithGenerics) { final String className = psiClass.getName(); if (null == className) { return Optional.empty(); } final Collection<PsiMethod> existedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass); if (ContainerUtil.exists(existedConstructors, psiMethod -> psiMethod.getParameterList().getParametersCount() == 1)) { return Optional.empty(); } LombokLightMethodBuilder constructorBuilderBased = new LombokLightMethodBuilder(psiClass.getManager(), className) .withConstructor(true) .withContainingClass(psiClass) .withNavigationElement(psiAnnotation) .withModifier(PsiModifier.PROTECTED) .withParameter(BUILDER_VARIABLE_NAME, psiTypeBaseWithGenerics); final List<BuilderInfo> builderInfos = createBuilderInfos(psiClass, psiAnnotation, builderClass); //dont need initBuilderInfosBuilderClassType here final String buildMethodPrepare = builderInfos.stream() .map(BuilderInfo::renderSuperBuilderConstruction) .collect(Collectors.joining()); final String codeBlock; final PsiClass superClass = psiClass.getSuperClass(); if (null != superClass && !"Object".equals(superClass.getName())) { codeBlock = "super(b);\n" + buildMethodPrepare; } else { codeBlock = buildMethodPrepare; } constructorBuilderBased.withBodyText(codeBlock); return Optional.of(constructorBuilderBased); }
|
createBuilderBasedConstructor
|
13,086
|
Optional<PsiMethod> (@NotNull PsiClass containingClass, @NotNull PsiClass builderBaseClass, @NotNull PsiClass builderImplClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClassType psiTypeBaseWithGenerics) { final String builderMethodName = getBuilderMethodName(psiAnnotation); if (builderMethodName.isEmpty() || hasMethod(containingClass, builderMethodName)) { return Optional.empty(); } final LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(containingClass.getManager(), builderMethodName) .withMethodReturnType(psiTypeBaseWithGenerics) .withContainingClass(containingClass) .withNavigationElement(psiAnnotation) .withModifier(PsiModifier.PUBLIC) .withModifier(PsiModifier.STATIC); addTypeParameters(containingClass, null, methodBuilder); final String blockText = String.format("return new %s();", PsiClassUtil.getTypeWithGenerics(builderImplClass).getCanonicalText(false)); methodBuilder.withBodyText(blockText); createRelevantNonNullAnnotation(containingClass, methodBuilder); return Optional.of(methodBuilder); }
|
createBuilderMethodIfNecessary
|
13,087
|
Optional<PsiMethod> (@NotNull PsiClass containingClass, @NotNull PsiClass builderBaseClass, @NotNull PsiClass builderImplClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClassType psiTypeBaseWithGenerics) { if (!shouldGenerateToBuilderMethods(psiAnnotation)) { return Optional.empty(); } final LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(containingClass.getManager(), TO_BUILDER_METHOD_NAME) .withMethodReturnType(psiTypeBaseWithGenerics) .withContainingClass(containingClass) .withNavigationElement(psiAnnotation) .withModifier(PsiModifier.PUBLIC); final String blockText = String.format("return new %s().%s(this);", PsiClassUtil.getTypeWithGenerics(builderImplClass).getCanonicalText(false), FILL_VALUES_METHOD_NAME); methodBuilder.withBodyText(blockText); createRelevantNonNullAnnotation(containingClass, methodBuilder); return Optional.of(methodBuilder); }
|
createToBuilderMethodIfNecessary
|
13,088
|
boolean (@NotNull PsiAnnotation psiAnnotation) { return PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, TO_BUILDER_ANNOTATION_KEY, false); }
|
shouldGenerateToBuilderMethods
|
13,089
|
String (String classGenericName, Collection<String> typeParamStrings) { String result = classGenericName; if (typeParamStrings.contains(classGenericName)) { int counter = 2; do { result = classGenericName + counter++; } while (typeParamStrings.contains(result)); } return result; }
|
selectNonClashingNameFor
|
13,090
|
PsiClass (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation) { String builderClassName = getBuilderClassName(psiClass); String builderClassQualifiedName = psiClass.getQualifiedName() + "." + builderClassName; final LombokLightClassBuilder baseClassBuilder = new LombokLightClassBuilder(psiClass, builderClassName, builderClassQualifiedName) .withContainingClass(psiClass) .withNavigationElement(psiAnnotation) .withParameterTypes(psiClass.getTypeParameterList()) .withModifier(PsiModifier.PUBLIC) .withModifier(PsiModifier.STATIC) .withModifier(PsiModifier.ABSTRACT); final List<String> typeParamNames = ContainerUtil.map(psiClass.getTypeParameters(), PsiTypeParameter::getName); final LightTypeParameterBuilder c = new LightTypeParameterBuilder(selectNonClashingNameFor("C", typeParamNames), baseClassBuilder, 0); c.getExtendsList().addReference(PsiClassUtil.getTypeWithGenerics(psiClass)); baseClassBuilder.withParameterType(c); final LightTypeParameterBuilder b = new LightTypeParameterBuilder(selectNonClashingNameFor("B", typeParamNames), baseClassBuilder, 1); baseClassBuilder.withParameterType(b); b.getExtendsList().addReference(PsiClassUtil.getTypeWithGenerics(baseClassBuilder)); final PsiElementFactory factory = JavaPsiFacade.getElementFactory(psiClass.getProject()); final PsiClassType bType = factory.createType(b); final PsiClassType cType = factory.createType(c); final PsiClass superClass = psiClass.getSuperClass(); if (null != superClass && !"Object".equals(superClass.getName())) { final PsiClass parentBuilderClass = superClass.findInnerClassByName(getBuilderClassName(superClass), false); if (null != parentBuilderClass) { final PsiType[] explicitTypes = Stream.concat( Stream.of(psiClass.getExtendsListTypes()).map(PsiClassType::getParameters).flatMap(Stream::of), Stream.of(cType, bType)) .toArray(PsiType[]::new); final PsiClassType extendsType = getTypeWithSpecificTypeParameters(parentBuilderClass, explicitTypes); baseClassBuilder.withExtends(extendsType); } } baseClassBuilder.withFieldSupplier((thisPsiClass) -> { final List<BuilderInfo> builderInfos = createBuilderInfos(psiClass, psiAnnotation, thisPsiClass); initBuilderInfosBuilderClassType(builderInfos, bType); // create builder Fields return builderInfos.stream() .map(BuilderInfo::renderBuilderFields) .flatMap(Collection::stream) .collect(Collectors.toList()); }); baseClassBuilder.withMethodSupplier((thisPsiClass) -> { final List<BuilderInfo> builderInfos = createBuilderInfos(psiClass, psiAnnotation, thisPsiClass); initBuilderInfosBuilderClassType(builderInfos, bType); // create all methods return addAllMethodsForBaseBuilderClass(psiClass, psiAnnotation, thisPsiClass, builderInfos, bType, cType); }); return baseClassBuilder; }
|
createBuilderBaseClass
|
13,091
|
List<BuilderInfo> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass baseClassBuilder) { final List<BuilderInfo> builderInfos = createBuilderInfos(psiAnnotation, psiClass, null, baseClassBuilder); for (BuilderInfo builderInfo : builderInfos) { builderInfo.withBuilderChainResult("self()") .withInstanceVariableName(INSTANCE_VARIABLE_NAME); } return builderInfos; }
|
createBuilderInfos
|
13,092
|
void (@NotNull List<BuilderInfo> builderInfos, @NotNull PsiClassType bType) { for (BuilderInfo builderInfo : builderInfos) { builderInfo.withBuilderClassType(bType); } }
|
initBuilderInfosBuilderClassType
|
13,093
|
Collection<PsiMethod> (@NotNull PsiClass psiParentClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiBuilderClass) { final PsiTypeParameter[] typeParameters = psiBuilderClass.getTypeParameters(); final PsiClass bTypeClass, cTypeClass; if (typeParameters.length >= 2) { bTypeClass = typeParameters[typeParameters.length - 1]; cTypeClass = typeParameters[typeParameters.length - 2]; } else { //Fallback only bTypeClass = new LightTypeParameterBuilder("B", psiBuilderClass, 1); cTypeClass = new LightTypeParameterBuilder("C", psiBuilderClass, 0); } final PsiElementFactory factory = JavaPsiFacade.getElementFactory(psiParentClass.getProject()); final PsiClassType bType = factory.createType(bTypeClass); final PsiClassType cType = factory.createType(cTypeClass); final List<BuilderInfo> builderInfos = createBuilderInfos(psiParentClass, psiAnnotation, psiBuilderClass); initBuilderInfosBuilderClassType(builderInfos, bType); // create all methods return addAllMethodsForBaseBuilderClass(psiParentClass, psiAnnotation, psiBuilderClass, builderInfos, bType, cType); }
|
createAllMethodsOfBaseBuilder
|
13,094
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass baseClassBuilder, List<BuilderInfo> builderInfos, @NotNull PsiClassType bType, @NotNull PsiClassType cType) { final Collection<PsiMethod> result = new ArrayList<>(); final Collection<String> existedMethodNames = PsiClassUtil.collectClassMethodsIntern(baseClassBuilder).stream() .filter(psiMethod -> PsiAnnotationSearchUtil.isNotAnnotatedWith(psiMethod, LombokClassNames.TOLERATE)) .map(PsiMethod::getName).collect(Collectors.toSet()); // create builder methods builderInfos.stream() .filter(info -> info.notAlreadyExistingMethod(existedMethodNames)) .map(BuilderInfo::renderBuilderMethods) .forEach(result::addAll); final PsiManager psiManager = psiClass.getManager(); final boolean forceCallSuper = PsiClassUtil.hasSuperClass(psiClass); if (shouldGenerateToBuilderMethods(psiAnnotation)) { // precalculate obtainVia builderInfos.forEach(BuilderInfo::withObtainVia); if (!existedMethodNames.contains(STATIC_FILL_VALUES_METHOD_NAME)) { // create '$fillValuesFromInstanceIntoBuilder' method final LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(psiManager, STATIC_FILL_VALUES_METHOD_NAME) .withMethodReturnType(PsiTypes.voidType()) .withParameter(INSTANCE_VARIABLE_NAME, PsiClassUtil.getTypeWithGenerics(psiClass)) .withParameter(BUILDER_VARIABLE_NAME, getTypeWithWildcardsForSuperBuilderTypeParameters(baseClassBuilder)) .withContainingClass(baseClassBuilder) .withNavigationElement(psiClass) .withModifier(PsiModifier.PRIVATE) .withModifier(PsiModifier.STATIC); addTypeParameters(psiClass, null, methodBuilder); final String toBuilderMethodCalls = builderInfos.stream() .map(BuilderInfo::renderToBuilderCallWithoutPrependLogic) .collect(Collectors.joining(';' + BUILDER_VARIABLE_NAME + '.', BUILDER_VARIABLE_NAME + '.', ";\n")); methodBuilder.withBodyText(toBuilderMethodCalls); result.add(methodBuilder); } if (!existedMethodNames.contains(FILL_VALUES_METHOD_NAME)) { // create '$fillValuesFrom' method final LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(psiManager, FILL_VALUES_METHOD_NAME) .withMethodReturnType(bType) .withParameter(INSTANCE_VARIABLE_NAME, cType) .withContainingClass(baseClassBuilder) .withNavigationElement(psiClass) .withModifier(PsiModifier.PROTECTED); final String callSuperCode = "super." + FILL_VALUES_METHOD_NAME + "(" + INSTANCE_VARIABLE_NAME + ");\n"; final String codeBlockText = String.format("%s%s.%s(%s, this);\nreturn self();", forceCallSuper ? callSuperCode : "", baseClassBuilder.getQualifiedName(), STATIC_FILL_VALUES_METHOD_NAME, INSTANCE_VARIABLE_NAME); methodBuilder.withBodyText(codeBlockText); result.add(methodBuilder); } } if (!existedMethodNames.contains(SELF_METHOD)) { // create 'self' method final LombokLightMethodBuilder selfMethod = new LombokLightMethodBuilder(psiManager, SELF_METHOD) .withMethodReturnType(bType) .withContainingClass(baseClassBuilder) .withNavigationElement(psiClass) .withModifier(PsiModifier.ABSTRACT) .withModifier(PsiModifier.PROTECTED); result.add(selfMethod); } final String buildMethodName = getBuildMethodName(psiAnnotation); if (!existedMethodNames.contains(buildMethodName)) { // create 'build' method final LombokLightMethodBuilder buildMethod = new LombokLightMethodBuilder(psiManager, buildMethodName) .withMethodReturnType(cType) .withContainingClass(baseClassBuilder) .withNavigationElement(psiClass) .withModifier(PsiModifier.ABSTRACT) .withModifier(PsiModifier.PUBLIC); createRelevantNonNullAnnotation(psiClass, buildMethod); result.add(buildMethod); } if (!existedMethodNames.contains(ToStringProcessor.TO_STRING_METHOD_NAME)) { // create 'toString' method result.add(createToStringMethod(psiAnnotation, baseClassBuilder, forceCallSuper)); } return result; }
|
addAllMethodsForBaseBuilderClass
|
13,095
|
PsiClass (@NotNull PsiClass psiClass, @NotNull PsiClass psiBaseBuilderClass, PsiAnnotation psiAnnotation) { String builderClassName = getBuilderImplClassName(psiClass); String builderClassQualifiedName = psiClass.getQualifiedName() + "." + builderClassName; final LombokLightClassBuilder implClassBuilder = new LombokLightClassBuilder(psiClass, builderClassName, builderClassQualifiedName) .withContainingClass(psiClass) .withNavigationElement(psiAnnotation) .withParameterTypes(psiClass.getTypeParameterList()) .withModifier(PsiModifier.STATIC) .withModifier(PsiModifier.FINAL); final PsiClassType extendsType = getTypeWithSpecificTypeParameters(psiBaseBuilderClass, PsiClassUtil.getTypeWithGenerics(psiClass), PsiClassUtil.getTypeWithGenerics(implClassBuilder)); implClassBuilder.withExtends(extendsType); if (hasValidJacksonizedAnnotation(psiClass, null)) { handleJacksonized(psiClass, null, psiAnnotation, implClassBuilder); } else { implClassBuilder.withModifier(PsiModifier.PRIVATE); } implClassBuilder.withMethodSupplier((thisPsiClass) -> createAllMethodsOfImplBuilder(psiClass, psiAnnotation, thisPsiClass)); return implClassBuilder; }
|
createBuilderImplClass
|
13,096
|
Collection<PsiMethod> (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass implBuilderClass) { Collection<PsiMethod> result = new ArrayList<>(); final Collection<String> existedMethodNames = ContainerUtil.map2Set(PsiClassUtil.collectClassMethodsIntern(implBuilderClass), PsiMethod::getName); final String builderImplClassName = StringUtil.notNullize(implBuilderClass.getName()); final PsiManager psiManager = psiClass.getManager(); if (!existedMethodNames.contains(builderImplClassName)) { //create private no args constructor final LombokLightMethodBuilder privateConstructor = new LombokLightMethodBuilder(psiManager, builderImplClassName) .withConstructor(true) .withContainingClass(implBuilderClass) .withNavigationElement(psiClass) .withModifier(PsiModifier.PRIVATE) .withBodyText(""); result.add(privateConstructor); } if (!existedMethodNames.contains(SELF_METHOD)) { // create 'self' method final LombokLightMethodBuilder selfMethod = new LombokLightMethodBuilder(psiManager, SELF_METHOD) .withMethodReturnType(PsiClassUtil.getTypeWithGenerics(implBuilderClass)) .withContainingClass(implBuilderClass) .withNavigationElement(psiClass) .withModifier(PsiModifier.PROTECTED) .withBodyText("return this;"); result.add(selfMethod); } final String buildMethodName = getBuildMethodName(psiAnnotation); if (!existedMethodNames.contains(buildMethodName)) { // create 'build' method final PsiType builderType = getReturnTypeOfBuildMethod(psiClass, null); final PsiSubstitutor builderSubstitutor = getBuilderSubstitutor(psiClass, implBuilderClass); final PsiType returnType = builderSubstitutor.substitute(builderType); final LombokLightMethodBuilder buildMethod = new LombokLightMethodBuilder(psiManager, buildMethodName) .withMethodReturnType(returnType) .withContainingClass(implBuilderClass) .withNavigationElement(psiClass) .withModifier(PsiModifier.PUBLIC); final String buildCodeBlockText = String.format("return new %s(this);", PsiClassUtil.getTypeWithGenerics(psiClass).getCanonicalText(false)); buildMethod.withBodyText(buildCodeBlockText); createRelevantNonNullAnnotation(psiClass, buildMethod); result.add(buildMethod); } return result; }
|
createAllMethodsOfImplBuilder
|
13,097
|
PsiClassType (@NotNull PsiClass psiClass) { final PsiWildcardType wildcardType = PsiWildcardType.createUnbounded(psiClass.getManager()); return getTypeWithSpecificTypeParameters(psiClass, wildcardType, wildcardType); }
|
getTypeWithWildcardsForSuperBuilderTypeParameters
|
13,098
|
PsiClassType (@NotNull PsiClass psiClass, PsiType @NotNull ... psiTypes) { final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiClass.getProject()); final PsiTypeParameter[] classTypeParameters = psiClass.getTypeParameters(); final int substituteTypesCount = psiTypes.length; if (classTypeParameters.length >= substituteTypesCount) { PsiSubstitutor newSubstitutor = PsiSubstitutor.EMPTY; final int fromIndex = classTypeParameters.length - substituteTypesCount; for (int i = 0; i < fromIndex; i++) { newSubstitutor = newSubstitutor.put(classTypeParameters[i], elementFactory.createType(classTypeParameters[i])); } for (int i = fromIndex; i < classTypeParameters.length; i++) { newSubstitutor = newSubstitutor.put(classTypeParameters[i], psiTypes[i - fromIndex]); } return elementFactory.createType(psiClass, newSubstitutor); } return elementFactory.createType(psiClass); }
|
getTypeWithSpecificTypeParameters
|
13,099
|
boolean (@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull PsiMethod psiMethod) { return BUILDER_ANNOTATION_SHORT_NAME.equals(getBuilderClassName(psiClass, psiAnnotation, psiMethod)) || PsiAnnotationSearchUtil.checkAnnotationHasOneOfFQNs(psiAnnotation, LombokClassNames.BUILDER); }
|
checkAnnotationFQN
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.