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.