@Override public void visitArrayQualifiedTypeReference(ArrayQualifiedTypeReference node) { lombok.ast.TypeReference ref = new lombok.ast.TypeReference(); fillTypeReferenceParts(node.tokens, node.sourcePositions, ref.astParts()); ref.astArrayDimensions(node.dimensions()); set(node, setPosition(node, ref)); }
@CopyMethod static String getDescription(TypeReference self) { try { return self.getTypeName(); } catch (Exception e) { return null; } }
public void checkVoidNotLegalJustAboutEverywhere(TypeReference node) { if (!node.isVoid()) return; if (node.astArrayDimensions() > 0) { node.addMessage(error(TYPEREFERENCE_VOID_NOT_ALLOWED, "Array of void type is not legal.")); return; } if (node.upIfReturnTypeToMethodDeclaration() != null) return; if (node.upToClassLiteral() != null) return; node.addMessage(error(TYPEREFERENCE_VOID_NOT_ALLOWED, "The void type is not legal here.")); } }
@Override public void visitWildcard(Wildcard node) { lombok.ast.TypeReference ref = (lombok.ast.TypeReference) toTree(node.bound); if (ref == null) ref = new lombok.ast.TypeReference(); switch (node.kind) { case Wildcard.UNBOUND: ref.astWildcard(lombok.ast.WildcardKind.UNBOUND); break; case Wildcard.EXTENDS: ref.astWildcard(lombok.ast.WildcardKind.EXTENDS); break; case Wildcard.SUPER: ref.astWildcard(lombok.ast.WildcardKind.SUPER); } setPosition(node, ref); set(node, ref); }
public Node setArrayDimensionsOfType(Node value, List<String> bracketPairs) { //TODO test a public int foo() [] {} method declaration. int arrayDims = bracketPairs == null ? 0 : bracketPairs.size(); if (arrayDims == 0) return value; TypeReference ref = new TypeReference().astArrayDimensions(arrayDims); if (value instanceof TypeReference) { TypeReference orig = (TypeReference)value; ref.astWildcard(orig.astWildcard()); ref.rawParts().migrateAllFrom(orig.rawParts()); } return posify(ref); }
private JCExpression plainTypeReference(TypeReference node) { if (node.isPrimitive() || node.isVoid() || node.astParts().size() == 1) { int end = node.getPosition().getEnd(); if (node.astArrayDimensions() > 0) { end = node.astParts().last().getPosition().getEnd(); if (end == node.getPosition().getStart()) end = node.getPosition().getEnd(); Identifier identifier = node.astParts().first().astIdentifier(); int typeTag = primitiveTypeTag(identifier.astValue()); if (typeTag > 0) return setPos(node.getPosition().getStart(), end, treeMaker.TypeIdent(typeTag)); for (TypeReferencePart part : node.astParts()) { JCExpression expr = (JCExpression) toTree(part); if (current == null) {
@Override public void visitQualifiedNameReference(QualifiedNameReference node) { if (hasFlag(FlagKey.NAMEREFERENCE_IS_TYPE)) { lombok.ast.TypeReference ref = new lombok.ast.TypeReference(); fillTypeReferenceParts(node.tokens, node.sourcePositions, ref.astParts()); set(node, setPosition(node, ref)); return; } lombok.ast.Expression select = toSelect(node.tokens, node.sourcePositions); set(node, setPosition(node, select)); }
private static boolean isPrimitive(TypeReference ref, String primitiveName) { if (ref.astArrayDimensions() > 0 || ref.rawParts().size() != 1) return false; try { String name = ref.astParts().first().astIdentifier().astValue(); return name.equals(primitiveName); } catch (NullPointerException e) { return false; } }
public void checkNoPrimitivesInGenerics(TypeReference node) { if (!node.isPrimitive()) return; if (node.upIfTypeArgumentToTypeReferencePart() != null) { node.addMessage(error(TYPEARGUMENT_PRIMITIVE_NOT_ALLOWED, "Primitive types aren't allowed in type arguments.")); return; } if (node.upIfTypeVariableBoundToTypeVariable() != null) { node.addMessage(error(TYPEVARIABLE_PRIMITIVE_NOT_ALLOWED, "Primitive types aren't allowed in type variable bounds.")); return; } }
switch (node.astWildcard()) { case UNBOUND: wildcard = new Wildcard(Wildcard.UNBOUND); boolean qualified = node.astParts().size() != 1; int dims = node.astArrayDimensions(); TypeReference[][] params = new TypeReference[node.astParts().size()][]; boolean hasGenerics = false; singleName = toName(node.astParts().first().astIdentifier()); } else { List<lombok.ast.Identifier> identifiers = Lists.newArrayList(); for (lombok.ast.TypeReferencePart part : node.astParts()) identifiers.add(part.astIdentifier()); qualifiedName = chain(identifiers, identifiers.size()); for (lombok.ast.TypeReferencePart part : node.astParts()) { params[ctr] = new TypeReference[part.astTypeArguments().size()]; int ctr2 = 0; if (!hasGenerics) { if (dims == 0) { ref = new SingleTypeReference(singleName, partsToPosArray(node.rawParts())[0]); } else { ref = new ArrayTypeReference(singleName, dims, 0L); ref.sourceStart = start(node); ref.sourceEnd = end(node); ((ArrayTypeReference)ref).originalSourceEnd = end(node.rawParts().last()); ref = new ParameterizedSingleTypeReference(singleName, params[0], dims, partsToPosArray(node.rawParts())[0]);
String name = stripGenerics(typeReference.getTypeName()); wanted = stripGenerics(wanted); int dims1 = typeReference.astArrayDimensions(); int dims2 = 0; while (wanted.endsWith("[]")) { Node n = typeReference.getParent(); Node prevN = null; CompilationUnit cu = null;
@Override public boolean visitTypeReference(TypeReference node) { WildcardKind kind = node.astWildcard(); formatter.buildInline(node); formatter.property("WildcardKind", kind); formatter.property("arrayDimensions", node.astArrayDimensions()); if (kind == WildcardKind.UNBOUND) { formatter.append("?"); visitAll(node.rawParts(), ".", "", ""); for (int i = 0 ; i < node.astArrayDimensions(); i++) formatter.append("[]");
if (!first) out.append(", "); first = false; switch (t.astWildcard()) { case EXTENDS: out.append("? extends "); out.append(t.getTypeName()); break; case SUPER: out.append("? super "); out.append(t.getTypeName()); break; default: case NONE: out.append(t.getTypeName()); break; case UNBOUND:
@CopyMethod static String getTypeName(TypeReference self) { StringBuilder out = new StringBuilder(); for (TypeReferencePart p : self.astParts()) { if (out.length() > 0) out.append("."); out.append(p.getTypeName()); } for (int i = 0; i < self.astArrayDimensions(); i++) out.append("[]"); return out.toString(); }
@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)); }
@Override public boolean visitTypeReference(TypeReference node) { WildcardKind wildcard = node.astWildcard(); if (wildcard == WildcardKind.UNBOUND) { return posSet(node, treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null)); } JCExpression result = plainTypeReference(node); result = addWildcards(node, result, wildcard); result = addDimensions(node, result, node.astArrayDimensions()); return set(node, result); }
@CopyMethod static String getDescription(Annotation self) { try { return self.astAnnotationTypeReference().getDescription(); } catch (NullPointerException e) { return null; } }
public Node createReferenceType(Node head, List<Node> tail) { TypeReference t = new TypeReference(); if (head != null) t.rawParts().addToEnd(head); if (tail != null) for (Node n : tail) { if (n != null) t.rawParts().addToEnd(n); } return posify(t); }
if (operandValue instanceof Number) { Number number = (Number)operandValue; String typeName = cast.astTypeReference().getTypeName(); if (typeName.equals("float")) { return number.floatValue(); String type = creation.astComponentTypeReference().toString();
private void checkSparseArray(ConstructorInvocation node, TypeReference reference) { // reference.hasTypeArguments returns false where it should not StrictListAccessor<TypeReference, TypeReference> types = reference.getTypeArguments(); if (types != null && types.size() == 1) { TypeReference first = types.first(); String valueType = first.getTypeName(); if (valueType.equals(INTEGER)) { mContext.report(USE_SPARSE_ARRAY, node, mContext.getLocation(node), "Use `new SparseIntArray(...)` instead for better performance"); } else if (valueType.equals(BOOLEAN)) { mContext.report(USE_SPARSE_ARRAY, node, mContext.getLocation(node), "Use `new SparseBooleanArray(...)` instead for better performance"); } } } }