diff options
Diffstat (limited to 'src/core')
17 files changed, 104 insertions, 36 deletions
diff --git a/src/core/lombok/AllArgsConstructor.java b/src/core/lombok/AllArgsConstructor.java index c059c65d..28d9c209 100644 --- a/src/core/lombok/AllArgsConstructor.java +++ b/src/core/lombok/AllArgsConstructor.java @@ -30,7 +30,7 @@ import java.lang.annotation.Target; * Generates an all-args constructor. * An all-args constructor requires one argument for every field in the class. * <p> - * Complete documentation is found at <a href="https://projectlombok.org/features/Constructor">the project lombok features page for @Constructor</a>. + * Complete documentation is found at <a href="https://projectlombok.org/features/constructor">the project lombok features page for @Constructor</a>. * <p> * Even though it is not listed, this annotation also has the {@code onConstructor} parameter. See the full documentation for more details. * diff --git a/src/core/lombok/Builder.java b/src/core/lombok/Builder.java index 64294e4b..06ca3853 100644 --- a/src/core/lombok/Builder.java +++ b/src/core/lombok/Builder.java @@ -160,7 +160,7 @@ public @interface Builder { * For example, a method normally generated as {@code someField(String someField)} would instead be * generated as {@code withSomeField(String someField)} if using {@code @Builder(setterPrefix = "with")}. * - * Note that using "with" to prefix builder setter methods is strongly discouraged as as "with" normally + * Note that using "with" to prefix builder setter methods is strongly discouraged as "with" normally * suggests immutable data structures, and builders by definition are mutable objects. * * For {@code @Singular} fields, the generated methods are called {@code withName}, {@code withNames}, and {@code clearNames}, instead of diff --git a/src/core/lombok/NoArgsConstructor.java b/src/core/lombok/NoArgsConstructor.java index 672cd1c2..2ba69e48 100644 --- a/src/core/lombok/NoArgsConstructor.java +++ b/src/core/lombok/NoArgsConstructor.java @@ -30,7 +30,7 @@ import java.lang.annotation.Target; * Generates a no-args constructor. * Will generate an error message if such a constructor cannot be written due to the existence of final fields. * <p> - * Complete documentation is found at <a href="https://projectlombok.org/features/Constructor">the project lombok features page for @Constructor</a>. + * Complete documentation is found at <a href="https://projectlombok.org/features/constructor">the project lombok features page for @Constructor</a>. * <p> * Even though it is not listed, this annotation also has the {@code onConstructor} parameter. See the full documentation for more details. * <p> @@ -75,7 +75,7 @@ public @interface NoArgsConstructor { * If {@code true}, initializes all final fields to 0 / null / false. * Otherwise, a compile time error occurs. * - * @return Return {@code} true to force generation of a no-args constructor, picking defaults if necessary to assign required fields. + * @return {@code} true to force generation of a no-args constructor, picking defaults if necessary to assign required fields. */ boolean force() default false; diff --git a/src/core/lombok/RequiredArgsConstructor.java b/src/core/lombok/RequiredArgsConstructor.java index f21bd647..8f2f365a 100644 --- a/src/core/lombok/RequiredArgsConstructor.java +++ b/src/core/lombok/RequiredArgsConstructor.java @@ -30,7 +30,7 @@ import java.lang.annotation.Target; * Generates a constructor with required arguments. * Required arguments are final fields and fields with constraints such as {@code @NonNull}. * <p> - * Complete documentation is found at <a href="https://projectlombok.org/features/Constructor">the project lombok features page for @Constructor</a>. + * Complete documentation is found at <a href="https://projectlombok.org/features/constructor">the project lombok features page for @Constructor</a>. * <p> * Even though it is not listed, this annotation also has the {@code onConstructor} parameter. See the full documentation for more details. * diff --git a/src/core/lombok/core/handlers/HandlerUtil.java b/src/core/lombok/core/handlers/HandlerUtil.java index 312d34d3..5e68f619 100644 --- a/src/core/lombok/core/handlers/HandlerUtil.java +++ b/src/core/lombok/core/handlers/HandlerUtil.java @@ -140,7 +140,7 @@ public class HandlerUtil { "androidx.annotation.RecentlyNullable", "com.android.annotations.NonNull", "com.android.annotations.Nullable", - // "com.google.api.server.spi.config.Nullable", - let's think about this one a litte, as it is targeted solely at parameters, so you can't even put it on fields. If we choose to support it, we should REMOVE it from the field, then - that's not something we currently support. + // "com.google.api.server.spi.config.Nullable", - let's think about this one a little, as it is targeted solely at parameters, so you can't even put it on fields. If we choose to support it, we should REMOVE it from the field, then - that's not something we currently support. "com.google.firebase.database.annotations.NotNull", "com.google.firebase.database.annotations.Nullable", "com.mongodb.lang.NonNull", @@ -197,7 +197,7 @@ public class HandlerUtil { // Checker Framework annotations. // To update Checker Framework annotations, run: // grep --recursive --files-with-matches -e '^@Target\b.*TYPE_USE' $CHECKERFRAMEWORK/checker/src/main/java $CHECKERFRAMEWORK/checker-qual/src/main/java $CHECKERFRAMEWORK/checker-util/src/main/java $CHECKERFRAMEWORK/framework/src/main/java | grep '\.java$' | sed 's/.*\/java\//\t\t\t"/' | sed 's/\.java$/",/' | sed 's/\//./g' | sort - // Only add new annotations, do not remove annotations that have been removed from the lastest version of the Checker Framework. + // Only add new annotations, do not remove annotations that have been removed from the latest version of the Checker Framework. "org.checkerframework.checker.builder.qual.CalledMethods", "org.checkerframework.checker.builder.qual.NotCalledMethods", "org.checkerframework.checker.calledmethods.qual.CalledMethods", diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java index a2dd5057..57c3afde 100755 --- a/src/core/lombok/eclipse/handlers/HandleBuilder.java +++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java @@ -36,6 +36,7 @@ import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration; import org.eclipse.jdt.internal.compiler.ast.AllocationExpression; import org.eclipse.jdt.internal.compiler.ast.Annotation; import org.eclipse.jdt.internal.compiler.ast.Argument; +import org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression; import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer; import org.eclipse.jdt.internal.compiler.ast.Assignment; import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration; @@ -918,7 +919,20 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> { out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG; FieldDeclaration fd = (FieldDeclaration) fieldNode.get(); out.returnType = copyType(fd.type, source); - out.statements = new Statement[] {new ReturnStatement(fd.initialization, pS, pE)}; + + // Convert short array initializers from `{1,2}` to `new int[]{1,2}` + Expression initialization; + if (fd.initialization instanceof ArrayInitializer) { + ArrayAllocationExpression arrayAllocationExpression = new ArrayAllocationExpression(); + arrayAllocationExpression.initializer = (ArrayInitializer) fd.initialization; + arrayAllocationExpression.type = generateQualifiedTypeRef(fd, fd.type.getTypeName()); + arrayAllocationExpression.dimensions = new Expression[fd.type.dimensions()]; + initialization = arrayAllocationExpression; + } else { + initialization = fd.initialization; + } + + out.statements = new Statement[] {new ReturnStatement(initialization, pS, pE)}; fd.initialization = null; out.traverse(new SetGeneratedByVisitor(source), ((TypeDeclaration) fieldNode.up().get()).scope); @@ -983,7 +997,7 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> { } if (field == null) { - FieldDeclaration fd = new FieldDeclaration(bfd.builderFieldName, 0, 0); + FieldDeclaration fd = new FieldDeclaration(bfd.builderFieldName.clone(), 0, 0); fd.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG; fd.modifiers = ClassFileConstants.AccPrivate; fd.type = copyType(bfd.type); diff --git a/src/core/lombok/eclipse/handlers/HandleExtensionMethod.java b/src/core/lombok/eclipse/handlers/HandleExtensionMethod.java index 5857780c..b84018c6 100644 --- a/src/core/lombok/eclipse/handlers/HandleExtensionMethod.java +++ b/src/core/lombok/eclipse/handlers/HandleExtensionMethod.java @@ -50,10 +50,10 @@ public class HandleExtensionMethod extends EclipseAnnotationHandler<ExtensionMet int modifiers = typeDecl == null ? 0 : typeDecl.modifiers; boolean notAClass = (modifiers & - (ClassFileConstants.AccInterface | ClassFileConstants.AccAnnotation)) != 0; + (ClassFileConstants.AccAnnotation)) != 0; if (typeDecl == null || notAClass) { - annotationNode.addError("@ExtensionMethod is legal only on classes and enums."); + annotationNode.addError("@ExtensionMethod is legal only on classes and enums and interfaces."); return; } diff --git a/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java b/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java index 3297ba06..fd36454d 100644 --- a/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java +++ b/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java @@ -160,7 +160,7 @@ public class HandleFieldDefaults extends EclipseASTAdapter { boolean defaultToFinal = makeFinalIsExplicit ? false : Boolean.TRUE.equals(typeNode.getAst().readConfiguration(ConfigurationKeys.FIELD_DEFAULTS_FINAL_EVERYWHERE)); if (!defaultToPrivate && !defaultToFinal && fieldDefaults == null) return; - // Do not apply field defaults to records if set using the the config system + // Do not apply field defaults to records if set using the config system if (fieldDefaults == null && !isClassOrEnum(typeNode)) return; AccessLevel fdAccessLevel = (fieldDefaults != null && levelIsExplicit) ? fd.level() : defaultToPrivate ? AccessLevel.PRIVATE : null; boolean fdToFinal = (fieldDefaults != null && makeFinalIsExplicit) ? fd.makeFinal() : defaultToFinal; diff --git a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java index 558c6ec2..e91478e0 100644 --- a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java +++ b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java @@ -51,7 +51,6 @@ import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration; import org.eclipse.jdt.internal.compiler.ast.FieldReference; import org.eclipse.jdt.internal.compiler.ast.IfStatement; import org.eclipse.jdt.internal.compiler.ast.Initializer; -import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation; import org.eclipse.jdt.internal.compiler.ast.MessageSend; import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration; import org.eclipse.jdt.internal.compiler.ast.NullLiteral; @@ -387,16 +386,16 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> { injectMethod(job.builderType, generateStaticFillValuesMethod(job, annInstance.setterPrefix())); } - // Generate abstract self() and build() methods in the abstract builder. - injectMethod(job.builderType, generateAbstractSelfMethod(job, superclassBuilderClass != null, builderGenericName)); - job.setBuilderToAbstract(); - injectMethod(job.builderType, generateAbstractBuildMethod(job, superclassBuilderClass != null, classGenericName)); - // Create the setter methods in the abstract builder. for (BuilderFieldData bfd : job.builderFields) { generateSetterMethodsForBuilder(job, bfd, builderGenericName, annInstance.setterPrefix()); } + // Generate abstract self() and build() methods in the abstract builder. + injectMethod(job.builderType, generateAbstractSelfMethod(job, superclassBuilderClass != null, builderGenericName)); + job.setBuilderToAbstract(); + injectMethod(job.builderType, generateAbstractBuildMethod(job, superclassBuilderClass != null, classGenericName)); + // Create the toString() method for the abstract builder. if (methodExists("toString", job.builderType, 0) == MemberExistsResult.NOT_EXISTS) { List<Included<EclipseNode, ToString.Include>> fieldNodes = new ArrayList<Included<EclipseNode, ToString.Include>>(); @@ -948,7 +947,7 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> { } if (field == null) { - FieldDeclaration fd = new FieldDeclaration(bfd.builderFieldName, 0, 0); + FieldDeclaration fd = new FieldDeclaration(bfd.builderFieldName.clone(), 0, 0); fd.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG; fd.modifiers = ClassFileConstants.AccPrivate; fd.type = copyType(bfd.type); @@ -1100,14 +1099,29 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> { if (td.fields != null) { for (FieldDeclaration field : td.fields) { if (field instanceof Initializer) continue; - char[][] typeName = field.type.getTypeName(); - if (typeName.length >= 1) // Add the first token, because only that can collide. - usedNames.add(String.valueOf(typeName[0])); + addFirstToken(usedNames, field.type); + } + } + + // 4. Add extends and implements clauses. + addFirstToken(usedNames, td.superclass); + if (td.superInterfaces != null) { + for (TypeReference typeReference : td.superInterfaces) { + addFirstToken(usedNames, typeReference); } } return usedNames; } + + private void addFirstToken(java.util.Set<String> usedNames, TypeReference type) { + if (type == null) + return; + // Add the first token, because only that can collide. + char[][] typeName = type.getTypeName(); + if (typeName != null && typeName.length >= 1) + usedNames.add(String.valueOf(typeName[0])); + } private String generateNonclashingNameFor(String classGenericName, java.util.Set<String> typeParamStrings) { if (!typeParamStrings.contains(classGenericName)) return classGenericName; diff --git a/src/core/lombok/experimental/SuperBuilder.java b/src/core/lombok/experimental/SuperBuilder.java index 0733a616..193bda0f 100644 --- a/src/core/lombok/experimental/SuperBuilder.java +++ b/src/core/lombok/experimental/SuperBuilder.java @@ -69,7 +69,7 @@ public @interface SuperBuilder { * For example, a method normally generated as {@code someField(String someField)} would instead be * generated as {@code withSomeField(String someField)} if using {@code @SuperBuilder(setterPrefix = "with")}. * - * Note that using "with" to prefix builder setter methods is strongly discouraged as as "with" normally + * Note that using "with" to prefix builder setter methods is strongly discouraged as "with" normally * suggests immutable data structures, and builders by definition are mutable objects. * * For {@code @Singular} fields, the generated methods are called {@code withName}, {@code withNames}, and {@code clearNames}, instead of diff --git a/src/core/lombok/extern/jackson/Jacksonized.java b/src/core/lombok/extern/jackson/Jacksonized.java index cf6678da..801ddbcb 100644 --- a/src/core/lombok/extern/jackson/Jacksonized.java +++ b/src/core/lombok/extern/jackson/Jacksonized.java @@ -49,7 +49,7 @@ import lombok.experimental.SuperBuilder; * <li>Insert {@code @JsonPOJOBuilder(withPrefix="")} on the generated builder * class to override Jackson's default prefix "with". If you configured a * different prefix in lombok using {@code setterPrefix}, this value is used. If - * you changed the name of the {@code build()} method using using + * you changed the name of the {@code build()} method using * {@code buildMethodName}, this is also made known to Jackson.</li> * <li>For {@code @SuperBuilder}, make the builder implementation class * package-private.</li> diff --git a/src/core/lombok/javac/JavacResolution.java b/src/core/lombok/javac/JavacResolution.java index f1109f4e..6ff6efe7 100644 --- a/src/core/lombok/javac/JavacResolution.java +++ b/src/core/lombok/javac/JavacResolution.java @@ -244,8 +244,15 @@ public class JavacResolution { } private void attrib(JCTree tree, Env<AttrContext> env) { - if (env.enclClass.type == null) try { - env.enclClass.type = Type.noType; + try { + if (env.enclClass.type == null) { + if (env.enclClass.sym != null) { + env.enclClass.type = env.enclClass.sym.type; + } + } + if (env.enclClass.type == null) { + env.enclClass.type = Type.noType; + } } catch (Throwable ignore) { // This addresses issue #1553 which involves JDK9; if it doesn't exist, we probably don't need to set it. } diff --git a/src/core/lombok/javac/handlers/HandleBuilder.java b/src/core/lombok/javac/handlers/HandleBuilder.java index 854c8524..ed7d2844 100644 --- a/src/core/lombok/javac/handlers/HandleBuilder.java +++ b/src/core/lombok/javac/handlers/HandleBuilder.java @@ -45,6 +45,7 @@ import com.sun.tools.javac.tree.JCTree.JCLiteral; import com.sun.tools.javac.tree.JCTree.JCMethodDecl; import com.sun.tools.javac.tree.JCTree.JCMethodInvocation; import com.sun.tools.javac.tree.JCTree.JCModifiers; +import com.sun.tools.javac.tree.JCTree.JCNewArray; import com.sun.tools.javac.tree.JCTree.JCNewClass; import com.sun.tools.javac.tree.JCTree.JCPrimitiveTypeTree; import com.sun.tools.javac.tree.JCTree.JCReturn; @@ -817,6 +818,14 @@ public class HandleBuilder extends JavacAnnotationHandler<Builder> { JCBlock body = maker.Block(0, List.<JCStatement>of(statement)); int modifiers = Flags.PRIVATE | Flags.STATIC; JCMethodDecl defaultProvider = maker.MethodDef(maker.Modifiers(modifiers), methodName, cloneType(maker, field.vartype, fieldNode), copyTypeParams(fieldNode, params), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null); + // ... then we convert short array initializers from `{1,2}` to `new int[]{1,2}` ... + if (init instanceof JCNewArray && field.vartype instanceof JCArrayTypeTree) { + JCNewArray arrayInitializer = (JCNewArray) init; + JCArrayTypeTree fieldType = (JCArrayTypeTree) field.vartype; + if (arrayInitializer.elemtype == null) { + arrayInitializer.elemtype = cloneType(maker, fieldType.elemtype, fieldNode); + } + } // ... then we set positions for everything else ... recursiveSetGeneratedBy(defaultProvider, job.sourceNode); // ... and finally add back the original expression diff --git a/src/core/lombok/javac/handlers/HandleExtensionMethod.java b/src/core/lombok/javac/handlers/HandleExtensionMethod.java index dd565f72..af03d000 100644 --- a/src/core/lombok/javac/handlers/HandleExtensionMethod.java +++ b/src/core/lombok/javac/handlers/HandleExtensionMethod.java @@ -73,10 +73,10 @@ public class HandleExtensionMethod extends JavacAnnotationHandler<ExtensionMetho deleteAnnotationIfNeccessary(annotationNode, ExtensionMethod.class); JavacNode typeNode = annotationNode.up(); - boolean isClassOrEnum = isClassOrEnum(typeNode); + boolean isClassOrEnumOrInterface = isClassOrEnumOrInterface(typeNode); - if (!isClassOrEnum) { - annotationNode.addError("@ExtensionMethod can only be used on a class or an enum"); + if (!isClassOrEnumOrInterface) { + annotationNode.addError("@ExtensionMethod can only be used on a class or an enum or an interface"); return; } @@ -117,7 +117,8 @@ public class HandleExtensionMethod extends JavacAnnotationHandler<ExtensionMetho if (tsym != null) for (Symbol member : tsym.getEnclosedElements()) { if (member.getKind() != ElementKind.METHOD) continue; MethodSymbol method = (MethodSymbol) member; - if ((method.flags() & (STATIC | PUBLIC)) == 0) continue; + if ((method.flags() & STATIC) == 0) continue; + if ((method.flags() & PUBLIC) == 0) continue; if (method.params().isEmpty()) continue; extensionMethods.add(method); } diff --git a/src/core/lombok/javac/handlers/HandleFieldDefaults.java b/src/core/lombok/javac/handlers/HandleFieldDefaults.java index 9a6632dd..b373d1df 100644 --- a/src/core/lombok/javac/handlers/HandleFieldDefaults.java +++ b/src/core/lombok/javac/handlers/HandleFieldDefaults.java @@ -140,7 +140,7 @@ public class HandleFieldDefaults extends JavacASTAdapter { boolean defaultToFinal = makeFinalIsExplicit ? false : Boolean.TRUE.equals(typeNode.getAst().readConfiguration(ConfigurationKeys.FIELD_DEFAULTS_FINAL_EVERYWHERE)); if (!defaultToPrivate && !defaultToFinal && fieldDefaults == null) return; - // Do not apply field defaults to records if set using the the config system + // Do not apply field defaults to records if set using the config system if (fieldDefaults == null && !isClassOrEnum(typeNode)) return; AccessLevel fdAccessLevel = (fieldDefaults != null && levelIsExplicit) ? fd.level() : defaultToPrivate ? AccessLevel.PRIVATE : null; boolean fdToFinal = (fieldDefaults != null && makeFinalIsExplicit) ? fd.makeFinal() : defaultToFinal; diff --git a/src/core/lombok/javac/handlers/HandleSuperBuilder.java b/src/core/lombok/javac/handlers/HandleSuperBuilder.java index 7418ac87..913f838c 100644 --- a/src/core/lombok/javac/handlers/HandleSuperBuilder.java +++ b/src/core/lombok/javac/handlers/HandleSuperBuilder.java @@ -336,6 +336,11 @@ public class HandleSuperBuilder extends JavacAnnotationHandler<SuperBuilder> { injectMethod(job.builderType, sfvm); } + // Create the setter methods in the abstract builder. + for (BuilderFieldData bfd : job.builderFields) { + generateSetterMethodsForBuilder(job, bfd, builderGenericName, annInstance.setterPrefix()); + } + // Generate abstract self() and build() methods in the abstract builder. JCMethodDecl asm = generateAbstractSelfMethod(job, superclassBuilderClass != null, builderGenericName); recursiveSetGeneratedBy(asm, annotationNode); @@ -344,11 +349,6 @@ public class HandleSuperBuilder extends JavacAnnotationHandler<SuperBuilder> { recursiveSetGeneratedBy(abm, annotationNode); injectMethod(job.builderType, abm); - // Create the setter methods in the abstract builder. - for (BuilderFieldData bfd : job.builderFields) { - generateSetterMethodsForBuilder(job, bfd, builderGenericName, annInstance.setterPrefix()); - } - // Create the toString() method for the abstract builder. java.util.List<Included<JavacNode, ToString.Include>> fieldNodes = new ArrayList<Included<JavacNode, ToString.Include>>(); for (BuilderFieldData bfd : job.builderFields) { @@ -1051,9 +1051,28 @@ public class HandleSuperBuilder extends JavacAnnotationHandler<SuperBuilder> { } } + // 4. Add extends and implements clauses. + addFirstToken(usedNames, Javac.getExtendsClause(td)); + for (JCExpression impl : td.getImplementsClause()) { + addFirstToken(usedNames, impl); + } + return usedNames; } + private void addFirstToken(java.util.Set<String> usedNames, JCTree type) { + if (type == null) + return; + if (type instanceof JCTypeApply) { + type = ((JCTypeApply)type).clazz; + } + while (type instanceof JCFieldAccess && ((JCFieldAccess)type).selected != null) { + // Add the first token, because only that can collide. + type = ((JCFieldAccess)type).selected; + } + usedNames.add(type.toString()); + } + private String generateNonclashingNameFor(String classGenericName, java.util.HashSet<String> typeParamStrings) { if (!typeParamStrings.contains(classGenericName)) return classGenericName; int counter = 2; diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java index b17e34d8..9d153a72 100644 --- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java +++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java @@ -2069,6 +2069,10 @@ public class JavacHandlerUtil { return isClassAndDoesNotHaveFlags(typeNode, Flags.INTERFACE | Flags.ANNOTATION | RECORD); } + public static boolean isClassOrEnumOrInterface(JavacNode typeNode) { + return isClassAndDoesNotHaveFlags(typeNode, Flags.ANNOTATION | RECORD); + } + /** * Returns {@code true} if the provided node is an actual class, an enum or a record and not some other type declaration (so, not an annotation definition or interface). */ |