com.sun.tools.javac.code.Type.ArrayType Java Examples

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuffer buf = new StringBuffer();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.tag == ARRAY) {
            buf.append(visit(((ArrayType) args.head).elemtype, locale));
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

/** Check that type is a valid qualifier for a constructor reference expression
 */
Type checkConstructorRefType(DiagnosticPosition pos, Type t) {
    t = checkClassOrArrayType(pos, t);
    if (t.hasTag(CLASS)) {
        if ((t.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {
            log.error(pos, Errors.AbstractCantBeInstantiated(t.tsym));
            t = types.createErrorType(t);
        } else if ((t.tsym.flags() & ENUM) != 0) {
            log.error(pos, Errors.EnumCantBeInstantiated);
            t = types.createErrorType(t);
        } else {
            t = checkClassType(pos, t, true);
        }
    } else if (t.hasTag(ARRAY)) {
        if (!types.isReifiable(((ArrayType)t).elemtype)) {
            log.error(pos, Errors.GenericArrayCreation);
            t = types.createErrorType(t);
        }
    }
    return t;
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuffer buf = new StringBuffer();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.tag == ARRAY) {
            buf.append(visit(((ArrayType) args.head).elemtype, locale));
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

EnumMapping(DiagnosticPosition pos, TypeSymbol forEnum) {
    this.forEnum = forEnum;
    this.values = new LinkedHashMap<>();
    this.pos = pos;
    Name varName = names
        .fromString(target.syntheticNameChar() +
                    "SwitchMap" +
                    target.syntheticNameChar() +
                    writer.xClassName(forEnum.type).toString()
                    .replace('/', '.')
                    .replace('.', target.syntheticNameChar()));
    ClassSymbol outerCacheClass = outerCacheClass();
    this.mapVar = new VarSymbol(STATIC | SYNTHETIC | FINAL,
                                varName,
                                new ArrayType(syms.intType, syms.arrayClass),
                                outerCacheClass);
    enterSynthetic(pos, mapVar, outerCacheClass.members());
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.unannotatedType().hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head.unannotatedType()).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

/**
 * Converts a set of method argument types into their corresponding
 * localized string representation.
 *
 * @param args arguments to be rendered
 * @param varArgs if true, the last method argument is regarded as a vararg
 * @param locale the locale in which the string is to be rendered
 * @return localized string representation
 */
protected String printMethodArgs(List<Type> args, boolean varArgs, Locale locale) {
    if (!varArgs) {
        return visitTypes(args, locale);
    } else {
        StringBuilder buf = new StringBuilder();
        while (args.tail.nonEmpty()) {
            buf.append(visit(args.head, locale));
            args = args.tail;
            buf.append(',');
        }
        if (args.head.hasTag(TypeTag.ARRAY)) {
            buf.append(visit(((ArrayType) args.head).elemtype, locale));
            if (args.head.getAnnotationMirrors().nonEmpty()) {
                buf.append(' ');
                buf.append(args.head.getAnnotationMirrors());
                buf.append(' ');
            }
            buf.append("...");
        } else {
            buf.append(visit(args.head, locale));
        }
        return buf.toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

public static String getTypeName(Type t, boolean full) {
    switch (t.getTag()) {
    case ARRAY:
        StringBuilder s = new StringBuilder();
        while (t.hasTag(ARRAY)) {
            s.append("[]");
            t = ((ArrayType)t).elemtype;
        }
        s.insert(0, getTypeName(t, full));
        return s.toString();
    case CLASS:
        return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
    default:
        return t.tsym.getQualifiedName().toString();
    }
}
 

void printBaseElementType(Type t, StringBuilder sb, Locale locale) {
    Type arrel = t;
    while (arrel.hasTag(TypeTag.ARRAY)) {
        arrel = arrel.unannotatedType();
        arrel = ((ArrayType) arrel).elemtype;
    }
    sb.append(visit(arrel, locale));
}
 

private void printBaseElementType(Type t, StringBuilder sb, Locale locale) {
    Type arrel = t;
    while (arrel.hasTag(TypeTag.ARRAY)) {
        arrel = ((ArrayType) arrel).elemtype;
    }
    sb.append(visit(arrel, locale));
}
 

@Override
public String visitArrayType(ArrayType t, Locale locale) {
    StringBuilder res = new StringBuilder();
    printBaseElementType(t, res, locale);
    printBrackets(t, res, locale);
    return res.toString();
}
 

@Override
public String visitArrayType(ArrayType t, Locale locale) {
    StringBuilder res = new StringBuilder();
    printBaseElementType(t, res, locale);
    printBrackets(t, res, locale);
    return res.toString();
}
 

public void visitArray(Attribute.Array a) {
    Name elemName = ((ArrayType) a.type).elemtype.tsym.getQualifiedName();

    if (elemName.equals(elemName.table.names.java_lang_Class)) {   // Class[]
        // Construct a proxy for a MirroredTypesException
        ListBuffer<TypeMirror> elems = new ListBuffer<>();
        for (Attribute value : a.values) {
            Type elem = ((Attribute.Class) value).classType;
            elems.append(elem);
        }
        value = new MirroredTypesExceptionProxy(elems.toList());

    } else {
        int len = a.values.length;
        Class<?> returnClassSaved = returnClass;
        returnClass = returnClass.getComponentType();
        try {
            Object res = Array.newInstance(returnClass, len);
            for (int i = 0; i < len; i++) {
                a.values[i].accept(this);
                if (value == null || value instanceof ExceptionProxy) {
                    return;
                }
                try {
                    Array.set(res, i, value);
                } catch (IllegalArgumentException e) {
                    value = null;       // indicates a type mismatch
                    return;
                }
            }
            value = res;
        } finally {
            returnClass = returnClassSaved;
        }
    }
}
 

@Override
public Boolean visitArrayType(ArrayType t, Type s) {
    if (t == s)
        return true;

    if (s.isPartial())
        return visit(s, t);

    return s.hasTag(ARRAY)
        && visit(t.elemtype, types.elemtype(s));
}
 

void printBrackets(Type t, StringBuilder sb, Locale locale) {
    Type arrel = t;
    while (arrel.hasTag(TypeTag.ARRAY)) {
        if (arrel.isAnnotated()) {
            sb.append(' ');
            sb.append(arrel.getAnnotationMirrors());
            sb.append(' ');
        }
        sb.append("[]");
        arrel = arrel.unannotatedType();
        arrel = ((ArrayType) arrel).elemtype;
    }
}
 

void printBaseElementType(Type t, StringBuilder sb, Locale locale) {
    Type arrel = t;
    while (arrel.hasTag(TypeTag.ARRAY)) {
        arrel = arrel.unannotatedType();
        arrel = ((ArrayType) arrel).elemtype;
    }
    sb.append(visit(arrel, locale));
}
 

@Override
public Boolean visitArrayType(ArrayType t, Type s) {
    if (t == s)
        return true;

    if (s.isPartial())
        return visit(s, t);

    return s.hasTag(ARRAY)
        && visit(t.elemtype, types.elemtype(s));
}