private static String getBindingKey(ArrayType type) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < type.dimensions(); i++) { sb.append('['); } sb.append(getGeneralTypeBindingKey(type.component())); return null; }
Type copyType(Type component, int dimensions) { return new ArrayType(component, dimensions, annotationArray()); } }
private void appendArraySyntax(StringBuilder builder) { if (annotationArray().length > 0) { builder.append(' '); appendAnnotations(builder); } for (int i = 0; i < dimensions; i++) { builder.append("[]"); } if (component.kind() == Kind.ARRAY) { component.asArrayType().appendArraySyntax(builder); } }
public String toString() { StringBuilder builder = new StringBuilder(); appendRootComponent(builder); appendArraySyntax(builder); return builder.toString(); }
case ARRAY: { ArrayType arrayType = type.asArrayType(); int dimensions = arrayType.dimensions(); while (--dimensions > 0 && elements.size() > 0 && elements.peek().kind == PathElement.Kind.ARRAY) { elements.pop(); Type nested = dimensions > 0 ? new ArrayType(arrayType.component(), dimensions) : arrayType.component(); nested = resolveTypePath(nested, typeAnnotationState); return intern(arrayType.copyType(nested, arrayType.dimensions() - dimensions));
@Override public IJavaType component() { return wrap(getType().component()); }
@Override Type copyType(AnnotationInstance[] newAnnotations) { return new ArrayType(component, dimensions, newAnnotations); }
@Override public int dimensions() { return getType().dimensions(); }
private void appendRootComponent(StringBuilder builder) { if (component.kind() == Kind.ARRAY) { component.asArrayType().appendRootComponent(builder); } else { builder.append(component); } }
@Override public String name() { return getType().name().toString(); }
return "[" + toString( ( (ArrayType) p ).component()); //$NON-NLS-1$
/** * Create a new mock array type instance with the specified component * and dimensions. * * @param component the array component * @param dimensions the number of dimensions of this array * @return the new mock array type instance * @since 2.1 */ public static ArrayType create(Type component, int dimensions) { return new ArrayType(component, dimensions); }
private Type searchTypePath(Type type, TypeAnnotationState typeAnnotationState) { PathElementStack elements = typeAnnotationState.pathElements; PathElement element = elements.pop(); if (element == null) { return type; } switch (element.kind) { case ARRAY: { ArrayType arrayType = type.asArrayType(); int dimensions = arrayType.dimensions(); while (--dimensions > 0 && elements.size() > 0 && elements.peek().kind == PathElement.Kind.ARRAY) { elements.pop(); } assert dimensions == 0; return searchTypePath(arrayType.component(), typeAnnotationState); } case PARAMETERIZED: { ParameterizedType parameterizedType = type.asParameterizedType(); return searchTypePath(parameterizedType.argumentsArray()[element.pos], typeAnnotationState); } case WILDCARD_BOUND: { return searchTypePath(type.asWildcardType().bound(), typeAnnotationState); } case NESTED: { int depth = popNestedDepth(elements); return searchNestedType(type, depth, typeAnnotationState); } } throw new IllegalStateException("Unknown path element"); }
break; case ARRAY: addType(type.asArrayType().component()); break; case TYPE_VARIABLE: {
private Type parseArrayType() { int mark = this.pos; int last = advanceNot('['); return new ArrayType(parseJavaType(), last - mark); }
case ARRAY: ArrayType arrayType = type.asArrayType(); stream.writePackedU32(arrayType.dimensions()); writeReference(stream, arrayType.component(), false); // TODO - full should not be necessary break; case PRIMITIVE:
private Type parseType(String descriptor, IntegerHolder pos) { int start = pos.i; char c = descriptor.charAt(start); Type type = PrimitiveType.decode(c); if (type != null) { return type; } DotName name; switch (c) { case 'V': return VoidType.VOID; case 'L': { int end = start; while (descriptor.charAt(++end) != ';'); name = names.convertToName(descriptor.substring(start + 1, end), '/'); pos.i = end; return names.intern(new ClassType(name)); } case '[': { int end = start; while (descriptor.charAt(++end) == '['); int depth = end - start; pos.i = end; type = parseType(descriptor, pos); return names.intern(new ArrayType(type, depth)); } default: throw new IllegalArgumentException("Invalid descriptor: " + descriptor + " pos " + start); } }
Type component = typeTable[stream.readPackedU32()]; AnnotationInstance[] annotations = readAnnotations(stream, null); return new ArrayType(component, dimensions, annotations);