public void varDefOfZero(VariableDefinition node) { if (node.astVariables().isEmpty()) { node.addMessage(error(VARIABLEDEFINITION_EMPTY, "Empty variable declaration.")); } }
@Override public boolean visitVariableDefinition(VariableDefinition node) { formatter.buildInline(node); formatter.property("varargs", node.astVarargs()); visit(node.astModifiers()); if (!node.astModifiers().rawKeywords().isEmpty()) { formatter.space(); } formatter.nameNextElement("type"); visit(node.rawTypeReference()); if (node.astVarargs()) { formatter.append("..."); } formatter.space(); visitAll(node.rawVariables(), ", ", "", ""); formatter.closeInline(); return true; }
@CopyMethod static String getDescription(Catch self) { try { return self.astExceptionDeclaration().astTypeReference().getDescription(); } catch (NullPointerException e) { return null; } } }
public void localVariableModifiersCheck(VariableDefinition vd) { boolean applies = vd.upUpIfLocalVariableToBlock() != null; if (!applies) applies = vd.upToForEach() != null; if (!applies) applies = vd.upToFor() != null; if (!applies) return; modifiersCheck(vd.astModifiers(), new int[0], K_FINAL, "local variable declarations"); }
public Node createVariableDefinition(Node type, Node head, List<Node> tail) { VariableDefinition result = new VariableDefinition().rawTypeReference(type); if (head != null) result.rawVariables().addToEnd(head); if (tail != null) for (Node n : tail) if (n != null) result.rawVariables().addToEnd(n); return posify(result); }
@Override public boolean visitVariableDefinition(VariableDefinition node) { JCModifiers mods = (JCModifiers) toTree(node.astModifiers()); JCExpression vartype = toExpression(node.astTypeReference()); if (node.astVarargs()) { mods.flags |= Flags.VARARGS; vartype = addDimensions(node, vartype, 1); for (VariableDefinitionEntry e : node.astVariables()) { defs = defs.append(setPos( e,
VariableDefinition def = new VariableDefinition(); return createDeclaration ? new VariableDeclaration().astDefinition(def) : def; VariableDefinition def = new VariableDefinition(); def.astModifiers((Modifiers) toTree(first.mods)); setPos(decls.get(decls.size()-1), def); if (decls.size() > 1) def.setPosition(new Position(startPosFirst, def.getPosition().getEnd())); int baseDims = countDims(baseType); if ((first.mods.flags & Flags.VARARGS) != 0) { def.astVarargs(true); setConversionPositionInfo(def, "...", getPosition(baseType)); if (baseType instanceof JCArrayTypeTree) baseType = ((JCArrayTypeTree) baseType).elemtype; def.rawTypeReference(toTree(baseType, FlagKey.TYPE_REFERENCE)); def.astVarargs((first.mods.flags & Flags.VARARGS) != 0); def.astVariables().addToEnd(entry); decl.setPosition(def.getPosition()); addJavadoc(decl, first.mods); return decl;
@Override public boolean visitVariableDefinition(lombok.ast.VariableDefinition node) { List<AbstractVariableDeclaration> values = Lists.newArrayList(); Annotation[] annotations = toArray(Annotation.class, node.astModifiers().astAnnotations()); int modifiers = toModifiers(node.astModifiers()); TypeReference base = (TypeReference) toTree(node.astTypeReference()); AbstractVariableDeclaration prevDecl = null, firstDecl = null; for (lombok.ast.VariableDefinitionEntry entry : node.astVariables()) { VariableKind kind = VariableKind.kind(node); AbstractVariableDeclaration decl = kind.create(); decl.modifiers = modifiers; decl.name = toName(entry.astName()); if (entry.astArrayDimensions() == 0 && !node.astVarargs()) { decl.type = base; } else if (entry.astArrayDimensions() > 0 || node.astVarargs()) { decl.type = (TypeReference) toTree(entry.getEffectiveTypeReference()); decl.type.sourceStart = base.sourceStart; if (firstDecl == null && (base.dimensions() > 0 || node.getParent() instanceof lombok.ast.ForEach)) { decl.type.sourceEnd = posOfStructure(entry, "]", false) - 1; } else if (firstDecl != null) { if (node.astVarargs()) { if (decl.type instanceof ArrayTypeReference) { ((ArrayTypeReference)decl.type).originalSourceEnd = decl.type.sourceEnd; if (node.astVarargs()) { decl.type.bits |= ASTNode.IsVarArgs;
public Node createCatch(Node modifiers, Node type, Node varName, Node body) { VariableDefinitionEntry varNameEntry = new VariableDefinitionEntry().astName(createIdentifierIfNeeded(varName, currentPos())); if (varName != null) varNameEntry.setPosition(varName.getPosition()); VariableDefinition decl = new VariableDefinition().rawTypeReference(type).rawVariables().addToEnd( varNameEntry); if (type != null && varName != null) decl.setPosition(new Position(type.getPosition().getStart(), varName.getPosition().getEnd())); if (modifiers != null) decl.astModifiers(createModifiersIfNeeded(modifiers, currentPos())); return posify(new Catch().rawExceptionDeclaration(decl).rawBody(body)); }
public Node createEnhancedFor( org.parboiled.Node<Node> modifiers, Node type, org.parboiled.Node<Node> varDefEntry, Node iterable, Node statement) { VariableDefinition decl = new VariableDefinition().rawTypeReference(type).rawVariables() .addToEnd(varDefEntry.getValue()); positionSpan(decl, modifiers, varDefEntry); decl.astModifiers(createModifiersIfNeeded(modifiers.getValue(), decl.getPosition().getStart())); return posify(new ForEach().rawVariable(decl).rawIterable(iterable).rawStatement(statement)); }
try { if (node instanceof VariableDeclaration) { addToMap(((VariableDeclaration)node).astDefinition().astModifiers(), node); addToMap(((VariableDeclaration)node).astDefinition().astModifiers().astAnnotations(), node); addToMap(((VariableDeclaration)node).astDefinition().astTypeReference(), node); addToMap(((VariableDeclaration)node).astDefinition().astVariables().first().astName(), node); } else if (node instanceof TypeDeclaration) { addToMap(((TypeDeclaration)node).astModifiers(), node);
public void varargsOnlyLegalOnMethods(VariableDefinition node) { if (!node.astVarargs()) return; if (node.getParent() == null) return; MethodDeclaration md = node.upIfParameterToMethodDeclaration(); ConstructorDeclaration cd = node.upIfParameterToConstructorDeclaration(); Node last; if (md != null) last = md.astParameters().last(); else if (cd != null) last = cd.astParameters().last(); else last = null; if (node != last) { node.addMessage(error(VARIABLEDEFINITION_VARARGS_NOT_LEGAL_HERE, "Varargs are only legal on the last parameter of a constructor or method.")); } }
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); } } }
@CopyMethod static Modifiers getModifiersOfParent(VariableDefinitionEntry self) { VariableDefinition parent = self.upToVariableDefinition(); return parent == null ? new Modifiers() : parent.astModifiers(); }
static void checkVarDefIsSimple(Node node, Node rawVarDef, String descriptionOfOuter, String descriptionOfRelation) { if (!(rawVarDef instanceof VariableDefinition)) return; switch (((VariableDefinition)rawVarDef).rawVariables().size()) { case 0: return; case 1: break; default: rawVarDef.addMessage(error(VARIABLEDEFINITION_ONLY_ONE, String.format("%s can only declare one %s variable", descriptionOfOuter, descriptionOfRelation))); } for (VariableDefinitionEntry entry : ((VariableDefinition)rawVarDef).astVariables()) { if (entry.rawInitializer() != null) entry.addMessage(error(VARIABLEDEFINITIONENTRY_INITIALIZER_NOT_ALLOWED, String.format( "%s can only declare %s variables without an initializer", descriptionOfOuter, descriptionOfRelation))); } } }
VariableDefinition definition = declaration.astDefinition(); for (VariableDefinitionEntry entry : definition .astVariables()) { if (entry.astInitializer() != null && entry.astName().astValue().equals(targetName)) {
@CopyMethod static TypeReference getEffectiveTypeReference(VariableDefinitionEntry self) { VariableDefinition parent = self.upToVariableDefinition(); if (parent == null) throw new AstException( self, "Cannot calculate type reference of a VariableDefinitionEntry without a VariableDefinition as parent"); TypeReference typeRef = parent.astTypeReference().copy(); return typeRef.astArrayDimensions(typeRef.astArrayDimensions() + self.astArrayDimensions() + (parent.astVarargs() ? 1 : 0)); }
public void varargsAndExtendedDimsDontMix(VariableDefinitionEntry node) { VariableDefinition vd = node.upToVariableDefinition(); if (vd == null) return; if (node.astArrayDimensions() > 0 && vd.astVarargs()) { node.addMessage(error(VARIABLEDEFINITIONENTRY_EXTENDED_DIMENSIONS_NOT_LEGAL, "Extended dimensions are not legal on a varargs declaration.")); } }
static VariableKind kind(lombok.ast.VariableDefinition node) { //TODO rewrite this whole thing. lombok.ast.Node parent = node.getParent(); if (parent instanceof lombok.ast.VariableDeclaration) { if (parent.getParent() instanceof lombok.ast.TypeBody || parent.getParent() instanceof lombok.ast.EnumTypeBody) { return FIELD; } else { return LOCAL; } } if (parent instanceof lombok.ast.For || parent instanceof lombok.ast.ForEach){ return LOCAL; } if (parent instanceof lombok.ast.Catch || parent instanceof lombok.ast.MethodDeclaration || parent instanceof lombok.ast.ConstructorDeclaration){ return ARGUMENT; } return UNSUPPORTED; } }
@Override public boolean visitVariableDefinition(VariableDefinition node) { JCModifiers mods = (JCModifiers) toTree(node.astModifiers()); JCExpression vartype = toExpression(node.astTypeReference()); if (node.astVarargs()) { mods.flags |= Flags.VARARGS; vartype = addDimensions(node, vartype, 1); for (VariableDefinitionEntry e : node.astVariables()) { defs = defs.append(setPos( e,