@Override public boolean visitModifiers(Modifiers node) { JCModifiers mods = treeMaker.Modifiers(node.getExplicitModifierFlags(), toList(JCAnnotation.class, node.astAnnotations())); Comment javadoc = null; if (node.getParent() instanceof JavadocContainer) { javadoc = ((JavadocContainer)node.getParent()).astJavadoc(); } else if (node.getParent() instanceof VariableDefinition && node.getParent().getParent() instanceof VariableDeclaration) { javadoc = ((VariableDeclaration)node.getParent().getParent()).astJavadoc(); } if (javadoc != null && javadoc.isMarkedDeprecated()) mods.flags |= Flags.DEPRECATED; if (node.isEmpty() && !hasConversionStructureInfo(node, "converted")) { //Workaround for a javac bug; start (but not end!) gets set of an empty modifiers object, //but only if these represent the modifiers of a constructor or method that has type variables. if ( (node.getParent() instanceof MethodDeclaration && ((MethodDeclaration)node.getParent()).astTypeVariables().size() > 0) || (node.getParent() instanceof ConstructorDeclaration && ((ConstructorDeclaration)node.getParent()).astTypeVariables().size() > 0)) { mods.pos = node.getParent().getPosition().getStart(); } return set(node, mods); } else { return posSet(node, mods); } }
private static boolean isStaticClass(@Nullable ClassDeclaration node) { if (node == null) { // A null class declaration means anonymous inner class, and these can't be static return false; } int flags = node.astModifiers().getEffectiveModifierFlags(); return (flags & Modifier.STATIC) != 0; }
private lombok.ast.Modifiers toModifiers(int modifiers, Annotation[] annotations, int start, int end) { lombok.ast.Modifiers m = new lombok.ast.Modifiers(); for (KeywordModifier mod : KeywordModifier.fromReflectModifiers(modifiers)) m.astKeywords().addToEnd(mod); fillList(annotations, m.rawAnnotations()); m.setPosition(new Position(start, end)); return m; }
@Override public void visitModifiers(JCModifiers node) { Modifiers m = new Modifiers(); fillList(node.annotations, m.rawAnnotations()); for (KeywordModifier mod : KeywordModifier.fromReflectModifiers((int) node.flags)) m.astKeywords().addToEnd(mod); setConversionStructureInfo(m, "converted"); set(node, m); }
public Node createModifiers(List<Node> values) { Modifiers result = new Modifiers(); if (values != null) for (Node n : values) { if (n instanceof Annotation) result.rawAnnotations().addToEnd(n); if (n instanceof KeywordModifier) result.rawKeywords().addToEnd(n); } return posify(result); }
@Override public boolean visitAnnotationDeclaration(lombok.ast.AnnotationDeclaration node) { TypeDeclaration decl = createTypeBody(node.astBody().astMembers(), node, false, ClassFileConstants.AccAnnotation | ClassFileConstants.AccInterface); decl.annotations = toArray(Annotation.class, node.astModifiers().astAnnotations()); decl.name = toName(node.astName()); updateTypeBits(node.getParent(), decl, false); setupJavadoc(decl, node); return set(node, decl); }
private int modifiersCheck(Modifiers modifiers, int[] exclusivity, int legality, String desc) { int flags = modifiers.getEffectiveModifierFlags(); int implicits = flags & ~modifiers.getExplicitModifierFlags(); for (Node n : modifiers.rawKeywords()) { if (n instanceof KeywordModifier) { String k = ((KeywordModifier)n).astName();
public void emptyDeclarationMustHaveNoModifiers(EmptyDeclaration node) { Modifiers modifiers = node.astModifiers(); if (!modifiers.astKeywords().isEmpty() || !modifiers.astAnnotations().isEmpty()) { node.addMessage(error(MODIFIERS_MODIFIER_NOT_ALLOWED, "Empty Declarations cannot have modifiers.")); } }
public void fieldModifiersCheck(VariableDeclaration vd) { TypeDeclaration td = vd.upUpToTypeDeclaration(); if (td == null) return; //not a field. VariableDefinition def = vd.astDefinition(); if (def != null) { Modifiers m = def.astModifiers(); modifiersCheck(m, FIELD_MODIFIERS_EXCLUSIVITY, FIELD_MODIFIERS_LEGAL, "field declarations"); boolean allFieldsHaveInitializers = true; for (VariableDefinitionEntry entry : def.astVariables()) { if (entry.rawInitializer() == null) { allFieldsHaveInitializers = false; break; } } if (m.isStatic() && !m.isFinal() && !allFieldsHaveInitializers) { // Initialized static final fields, assuming the initializer expression is a compile time constant, are 'special' and // do not need to adhere to the static chain rule. However, we can't determine CTC nature without resolution. checkStaticChain(m); } } }
private static boolean isExplicitlyAbstract(Modifiers m) { for (KeywordModifier keyword : m.astKeywords()) { if ("abstract".equals(keyword.astName())) return true; } return false; }
Modifiers createModifiersIfNeeded(Node modifiers, int pos) { if (modifiers instanceof Modifiers) return (Modifiers)modifiers; Modifiers m = new Modifiers(); m.setPosition(new Position(pos, pos)); DanglingNodes.addDanglingNode(m, modifiers); return m; }
private void checkStaticChain(Modifiers modifiers) { if (!modifiers.isStatic()) return; Node p = modifiers.getParent(); while (p != null) { if (p instanceof CompilationUnit) return; if (p instanceof TypeDeclaration) { Modifiers pMods = ((TypeDeclaration)p).astModifiers(); if (!pMods.isStatic()) { modifiers.getParent().addMessage(error(MODIFIERS_STATIC_CHAIN, "This declaration is (effectively) static; static declarations or only legal in top-level and static declarations.")); } } p = p.getParent(); } }
for (Node n : modifiers.rawKeywords()) { if (n instanceof KeywordModifier) { String k = ((KeywordModifier)n).astName(); if ((f & exclusive) == 0) continue; modifiers.addMessage(error(MODIFIERS_MODIFIER_CONFLICT, String.format( "Modifier %s cannot be used here; it is already implicitly %s.", k, nameOfResponsibleImplicit))); for (Node n : modifiers.rawKeywords()) { if (n instanceof KeywordModifier) { String k = ((KeywordModifier)n).astName(); modifiers.addMessage(error(MODIFIERS_MODIFIER_CONFLICT, String.format( "Modifier %s cannot be used together with %s here.", k, hit)));
private int toModifiers(lombok.ast.Modifiers modifiers) { return modifiers.getExplicitModifierFlags(); }
@CopyMethod static Modifiers astModifiers(EmptyDeclaration self) { return new Modifiers(); }
public void checkAbstractMembersOnlyInAbstractTypes(MethodDeclaration md) { Modifiers modifiers = md.astModifiers(); if (modifiers == null) return; if (!modifiers.isAbstract()) return; TypeDeclaration parent = md.upUpToTypeDeclaration(); if (parent != null) { Modifiers modifiersOfParent = parent.astModifiers(); if (modifiersOfParent != null && modifiersOfParent.isAbstract()) return; md.addMessage(error(MODIFIERS_ABSTRACT_NOT_ALLOWED, "Abstract methods are only allowed in interfaces and abstract classes")); } }
int flags = node.astModifiers().getEffectiveModifierFlags(); if ((flags & Modifier.ABSTRACT) != 0) { return; if (constructor.astParameters().isEmpty()) { if (constructor.astModifiers().isPublic()) { hasDefaultConstructor = true; } else {
VariableDeclaration declaration = (VariableDeclaration) astNode; VariableDefinition definition = declaration.astDefinition(); if (definition != null && definition.astModifiers().isFinal()) { StrictListAccessor<VariableDefinitionEntry, VariableDefinition> variables = definition.astVariables();
int explicit = getExplicitModifierFlags(m); int out = explicit; Node declaration = m.getParent();
decl.declarationSourceStart = jstart(type); decl.declarationSourceEnd = end(type); if (!(type instanceof AnnotationDeclaration) || !type.astModifiers().isEmpty() || type.rawJavadoc() != null) { decl.modifiersSourceStart = jstart(type.astModifiers()); } else {