Java TypeCompound类代码示例

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
private List<Attribute.TypeCompound> getAndRemoveNonFieldTAs(VarSymbol sym) {
    List<TypeCompound> tas = sym.getRawTypeAttributes();
    ListBuffer<Attribute.TypeCompound> fieldTAs = new ListBuffer<Attribute.TypeCompound>();
    ListBuffer<Attribute.TypeCompound> nonfieldTAs = new ListBuffer<Attribute.TypeCompound>();
    for (TypeCompound ta : tas) {
        if (ta.getPosition().type == TargetType.FIELD) {
            fieldTAs.add(ta);
        } else {
            if (typeAnnoAsserts) {
                Assert.error("Type annotation does not have a valid positior");
            }

            nonfieldTAs.add(ta);
        }
    }
    sym.setTypeAttributes(fieldTAs.toList());
    return nonfieldTAs.toList();
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
List<Pair<List<Attribute.TypeCompound>, JCExpression>> catchTypesWithAnnotationsFromMulticatch(JCTypeUnion tree, List<TypeCompound> first) {
    List<JCExpression> alts = tree.alternatives;
    List<Pair<List<TypeCompound>, JCExpression>> res = List.of(new Pair<>(first, alts.head));
    alts = alts.tail;

    while(alts != null && alts.head != null) {
        JCExpression alt = alts.head;
        if (alt instanceof JCAnnotatedType) {
            JCAnnotatedType a = (JCAnnotatedType)alt;
            res = res.prepend(new Pair<>(annotate.fromAnnotations(a.annotations), alt));
        } else {
            res = res.prepend(new Pair<>(List.nil(), alt));
        }
        alts = alts.tail;
    }
    return res.reverse();
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
public void setAttributes(SymbolMetadata other) {
    if (other == null) {
        throw new NullPointerException();
    }
    setDeclarationAttributes(other.getDeclarationAttributes());
    if ((sym.flags() & Flags.BRIDGE) != 0) {
        Assert.check(other.sym.kind == Kind.MTH);
        ListBuffer<TypeCompound> typeAttributes = new ListBuffer<>();
        for (TypeCompound tc : other.getTypeAttributes()) {
            // Carry over only contractual type annotations: i.e nothing interior to method body.
            if (!tc.position.type.isLocal())
                typeAttributes.append(tc);
        }
        setTypeAttributes(typeAttributes.toList());
    } else {
        setTypeAttributes(other.getTypeAttributes());
    }
    if (sym.kind == Kind.TYP) {
        setInitTypeAttributes(other.getInitTypeAttributes());
        setClassInitTypeAttributes(other.getClassInitTypeAttributes());
    }
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
/** Attribute and store a semantic representation of the type annotation tree {@code tree} into
 * the tree.attribute field.
 *
 * @param a the tree representing an annotation
 * @param expectedAnnotationType the expected (super)type of the annotation
 * @param env the the current env in where the annotation instance is found
 */
public Attribute.TypeCompound attributeTypeAnnotation(JCAnnotation a, Type expectedAnnotationType,
                                                      Env<AttrContext> env)
{
    // The attribute might have been entered if it is Target or Repetable
    // Because TreeCopier does not copy type, redo this if type is null
    if (a.attribute == null || a.type == null || !(a.attribute instanceof Attribute.TypeCompound)) {
        // Create a new TypeCompound
        List<Pair<MethodSymbol,Attribute>> elems =
                attributeAnnotationValues(a, expectedAnnotationType, env);

        Attribute.TypeCompound tc =
                new Attribute.TypeCompound(a.type, elems, TypeAnnotationPosition.unknown);
        a.attribute = tc;
        return tc;
    } else {
        // Use an existing TypeCompound
        return (Attribute.TypeCompound)a.attribute;
    }
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
public void setAttributes(SymbolMetadata other) {
    if (other == null) {
        throw new NullPointerException();
    }
    setDeclarationAttributes(other.getDeclarationAttributes());
    if ((sym.flags() & Flags.BRIDGE) != 0) {
        Assert.check(other.sym.kind == MTH);
        ListBuffer<TypeCompound> typeAttributes = new ListBuffer<>();
        for (TypeCompound tc : other.getTypeAttributes()) {
            // Carry over only contractual type annotations: i.e nothing interior to method body.
            if (!tc.position.type.isLocal())
                typeAttributes.append(tc);
        }
        setTypeAttributes(typeAttributes.toList());
    } else {
        setTypeAttributes(other.getTypeAttributes());
    }
    if (sym.kind == TYP) {
        setInitTypeAttributes(other.getInitTypeAttributes());
        setClassInitTypeAttributes(other.getClassInitTypeAttributes());
    }
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
/**
 * Check whether a TypeCompound is contained in a list of TypeCompounds.
 *
 * @param list The input list of TypeCompounds.
 * @param tc The TypeCompound to find.
 * @return true, iff a TypeCompound equal to tc is contained in list.
 */
public static boolean isTypeCompoundContained(Types types, List<TypeCompound> list, TypeCompound tc) {
    for (Attribute.TypeCompound rawat : list) {
        if (rawat.type.tsym.name.contentEquals(tc.type.tsym.name) &&
                // TODO: in previous line, it would be nicer to use reference equality:
                //   rawat.type == tc.type &&
                // or at least "isSameType":
                //   types.isSameType(rawat.type, tc.type) &&
                // but each fails in some cases.
                rawat.values.equals(tc.values) &&
                isSameTAPosition(rawat.position, tc.position)) {
            return true;
        }
    }
    return false;
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
private static void storeVariable(ProcessingEnvironment processingEnv, Types types,
        AnnotatedTypeFactory atypeFactory, VariableTree var){
    VarSymbol sym = (VarSymbol) TreeUtils.elementFromDeclaration(var);
    AnnotatedTypeMirror type;
    if (atypeFactory instanceof GenericAnnotatedTypeFactory) {
        // TODO: this is rather ugly: we do not want refinement from the
        // initializer of the field. We need a general way to get
        // the "defaulted" type of a variable.
        type = ((GenericAnnotatedTypeFactory<?, ?, ?, ?>)atypeFactory).getDefaultedAnnotatedType(var, var.getInitializer());
    } else {
        type = atypeFactory.getAnnotatedType(var);
    }

    TypeAnnotationPosition tapos = TypeAnnotationUtils.fieldTAPosition(processingEnv.getSourceVersion(), ((JCTree)var).pos);

    List<Attribute.TypeCompound> tcs;
    tcs = generateTypeCompounds(processingEnv, type, tapos);
    addUniqueTypeCompounds(types, sym, tcs);
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
@SuppressWarnings("unused") // TODO: use from store().
private static void storeClassExtends(ProcessingEnvironment processingEnv, Types types,
        AnnotatedTypeFactory atypeFactory, Tree ext, Symbol.ClassSymbol csym,
        int implidx){

    AnnotatedTypeMirror type;
    int pos;
    if (ext == null) {
        // The implicit superclass is always java.lang.Object.
        // TODO: is this a good way to get the type?
        type = atypeFactory.fromElement(csym.getSuperclass().asElement());
        pos = -1;
    } else {
        type = atypeFactory.getAnnotatedType(ext);
        pos = ((JCTree) ext).pos;
    }

    TypeAnnotationPosition tapos = TypeAnnotationUtils.classExtendsTAPosition(processingEnv.getSourceVersion(), implidx, pos);

    List<Attribute.TypeCompound> tcs;
    tcs = generateTypeCompounds(processingEnv, type, tapos);
    addUniqueTypeCompounds(types, csym, tcs);
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
/**
 * Check whether a TypeCompound is contained in a list of TypeCompounds.
 *
 * @param list the input list of TypeCompounds
 * @param tc the TypeCompound to find
 * @return true, iff a TypeCompound equal to tc is contained in list
 */
public static boolean isTypeCompoundContained(
        Types types, List<TypeCompound> list, TypeCompound tc) {
    for (Attribute.TypeCompound rawat : list) {
        if (contentEquals(rawat.type.tsym.name, tc.type.tsym.name)
                // TODO: in previous line, it would be nicer to use reference equality:
                //   rawat.type == tc.type &&
                // or at least "isSameType":
                //   types.isSameType(rawat.type, tc.type) &&
                // but each fails in some cases.
                && rawat.values.equals(tc.values)
                && isSameTAPositionExceptTreePos(rawat.position, tc.position)) {
            return true;
        }
    }
    return false;
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
/**
 * Get the annotations of this program element.
 * Return an empty array if there are none.
 */
@Override
public AnnotationDesc[] annotations() {
    List<? extends TypeCompound> tas = type.getAnnotationMirrors();
    if (tas == null ||
            tas.isEmpty()) {
        return new AnnotationDesc[0];
    }
    AnnotationDesc res[] = new AnnotationDesc[tas.length()];
    int i = 0;
    for (Attribute.Compound a : tas) {
        res[i++] = new AnnotationDescImpl(env, a);
    }
    return res;
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
/**
 * Get the annotations of this program element.
 * Return an empty array if there are none.
 */
public AnnotationDesc[] annotations() {
    if (!type.isAnnotated()) {
        return new AnnotationDesc[0];
    }
    List<? extends TypeCompound> tas = type.getAnnotationMirrors();
    AnnotationDesc res[] = new AnnotationDesc[tas.length()];
    int i = 0;
    for (Attribute.Compound a : tas) {
        res[i++] = new AnnotationDescImpl(env, a);
    }
    return res;
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
/** Insert instance initializer code into initial constructor.
 *  @param md        The tree potentially representing a
 *                   constructor's definition.
 *  @param initCode  The list of instance initializer statements.
 *  @param initTAs  Type annotations from the initializer expression.
 */
void normalizeMethod(JCMethodDecl md, List<JCStatement> initCode, List<TypeCompound> initTAs) {
    if (md.name == names.init && TreeInfo.isInitialConstructor(md)) {
        // We are seeing a constructor that does not call another
        // constructor of the same class.
        List<JCStatement> stats = md.body.stats;
        ListBuffer<JCStatement> newstats = new ListBuffer<JCStatement>();

        if (stats.nonEmpty()) {
            // Copy initializers of synthetic variables generated in
            // the translation of inner classes.
            while (TreeInfo.isSyntheticInit(stats.head)) {
                newstats.append(stats.head);
                stats = stats.tail;
            }
            // Copy superclass constructor call
            newstats.append(stats.head);
            stats = stats.tail;
            // Copy remaining synthetic initializers.
            while (stats.nonEmpty() &&
                   TreeInfo.isSyntheticInit(stats.head)) {
                newstats.append(stats.head);
                stats = stats.tail;
            }
            // Now insert the initializer code.
            newstats.appendList(initCode);
            // And copy all remaining statements.
            while (stats.nonEmpty()) {
                newstats.append(stats.head);
                stats = stats.tail;
            }
        }
        md.body.stats = newstats.toList();
        if (md.body.endpos == Position.NOPOS)
            md.body.endpos = TreeInfo.endPos(md.body.stats.last());

        md.sym.appendUniqueTypeAttributes(initTAs);
    }
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
private void copyNewClassAnnotationsToOwner(JCNewClass tree) {
    Symbol sym = tree.def.sym;
    TypeAnnotationPosition pos = new TypeAnnotationPosition();
    ListBuffer<Attribute.TypeCompound> newattrs =
        new ListBuffer<Attribute.TypeCompound>();

    for (Attribute.TypeCompound old : sym.getRawTypeAttributes()) {
        newattrs.append(new Attribute.TypeCompound(old.type, old.values,
                                                   pos));
    }

    pos.type = TargetType.NEW;
    pos.pos = tree.pos;
    sym.owner.appendUniqueTypeAttributes(newattrs.toList());
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
private void setTypeAnnotationPos(List<JCAnnotation> annotations,
        TypeAnnotationPosition position) {
    for (JCAnnotation anno : annotations) {
        // attribute might be null during DeferredAttr;
        // we will be back later.
        if (anno.attribute != null) {
            ((Attribute.TypeCompound) anno.attribute).position = position;
        }
    }
}
 

import com.sun.tools.javac.code.Attribute.TypeCompound; //导入依赖的package包/类
private List<Attribute.TypeCompound> getAndRemoveNonFieldTAs(VarSymbol sym) {
    List<TypeCompound> tas = sym.getRawTypeAttributes();
    ListBuffer<Attribute.TypeCompound> fieldTAs = new ListBuffer<>();
    ListBuffer<Attribute.TypeCompound> nonfieldTAs = new ListBuffer<>();
    for (TypeCompound ta : tas) {
        Assert.check(ta.getPosition().type != TargetType.UNKNOWN);
        if (ta.getPosition().type == TargetType.FIELD) {
            fieldTAs.add(ta);
        } else {
            nonfieldTAs.add(ta);
        }
    }
    sym.setTypeAttributes(fieldTAs.toList());
    return nonfieldTAs.toList();
}