Java JCWildcard类代码示例

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
protected int diffWildcard(JCWildcard oldT, JCWildcard newT, int[] bounds) {
    int localPointer = bounds[0];
    if (oldT.kind != newT.kind) {
        copyTo(localPointer, oldT.pos);
        printer.print(newT.kind.toString());
        localPointer = oldT.pos + oldT.kind.toString().length();
    }
    JCTree oldBound = oldT.kind.kind != BoundKind.UNBOUND ? oldT.inner : null;
    JCTree newBound = newT.kind.kind != BoundKind.UNBOUND ? newT.inner : null;
    if (oldBound == newBound && oldBound == null) return localPointer;
    int[] innerBounds = getBounds(oldBound);
    copyTo(localPointer, innerBounds[0]);
    localPointer = diffTree(oldBound, newBound, innerBounds);
    copyTo(localPointer, bounds[1]);

    return bounds[1];
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
@Override public void visitWildcard(JCWildcard tree) {
	switch (tree.getKind()) {
	default:
	case UNBOUNDED_WILDCARD:
		print("?");
		return;
	case EXTENDS_WILDCARD:
		print("? extends ");
		print(tree.inner);
		return;
	case SUPER_WILDCARD:
		print("? super ");
		print(tree.inner);
		return;
	}
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
protected JCExpression cloneParamType(int index, JavacTreeMaker maker, List<JCExpression> typeArgs, JavacNode builderType, JCTree source) {
	if (typeArgs == null || typeArgs.size() <= index) {
		return genJavaLangTypeRef(builderType, "Object");
	} else {
		JCExpression originalType = typeArgs.get(index);
		if (originalType.getKind() == Kind.UNBOUNDED_WILDCARD || originalType.getKind() == Kind.SUPER_WILDCARD) {
			return genJavaLangTypeRef(builderType, "Object");
		} else if (originalType.getKind() == Kind.EXTENDS_WILDCARD) {
			try {
				return cloneType(maker, (JCExpression) ((JCWildcard) originalType).inner, source, builderType.getContext());
			} catch (Exception e) {
				return genJavaLangTypeRef(builderType, "Object");
			}
		} else {
			return cloneType(maker, originalType, source, builderType.getContext());
		}
	}
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
@Override public void visitWildcard(JCWildcard tree) {
	printNode(tree);
	Object o;
	
	// In some javacs (older ones), JCWildcard.kind is a BoundKind, which is an enum. In newer ones its a TypeBoundKind which is a JCTree, i.e. has positions.
	try {
		o = tree.getClass().getField("kind").get(tree);
	} catch (Exception e) {
		throw new RuntimeException("There's no field at all named 'kind' in JCWildcard? This is not a javac I understand.", e);
	}
	
	if (o instanceof JCTree) {
		child("kind", (JCTree)o);
	} else if (o instanceof BoundKind) {
		property("kind", String.valueOf(o));
	}
	child("inner", tree.inner);
	indent--;
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
public void visitWildcard(JCWildcard that) {
    try {
        print("JCWildcard:");
    } catch (Exception e) {
    }
    super.visitWildcard(that);
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
private void printBaseElementType(JCArrayTypeTree tree) throws IOException {
	JCTree elem = tree.elemtype;
	while (elem instanceof JCWildcard)
		elem = ((JCWildcard) elem).inner;
	if (elem instanceof JCArrayTypeTree)
		printBaseElementType((JCArrayTypeTree) elem);
	else
		printExpr(elem);
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
private Position getTypeBoundKindPosition(JCWildcard node) {
	try {
		Object o = JCWILDCARD_KIND.get(node);
		if (o instanceof TypeBoundKind) {
			return getPosition((TypeBoundKind) o);
		}
	} catch (Exception e) {}
	return Position.UNPLACED;
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
@Override
public JCWildcard inline(Inliner inliner) throws CouldNotResolveImportException {
  return inliner
      .maker()
      .Wildcard(
          inliner.maker().TypeBoundKind(BOUND_KINDS.get(getKind())),
          (getBound() == null) ? null : getBound().inline(inliner));
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
@Override
public void visitWildcard(JCWildcard tree) {
    try {
        print(tree.kind);
        if (tree.kind.kind != BoundKind.UNBOUND)
            printExpr(tree.inner);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
public void visitWildcard(JCWildcard tree) {
    //- System.err.println("visitWildcard("+tree+");");//DEBUG
    Type type = (tree.kind.kind == BoundKind.UNBOUND)
        ? syms.objectType
        : attribType(tree.inner, env);
    result = check(tree, new WildcardType(chk.checkRefType(tree.pos(), type),
                                          tree.kind.kind,
                                          syms.boundClass),
                   TYP, pkind, pt);
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
private void printBaseElementType(JCArrayTypeTree tree) throws IOException {
    JCTree elem = tree.elemtype;
    while (elem instanceof JCWildcard)
        elem = ((JCWildcard) elem).inner;
    if (elem instanceof JCArrayTypeTree)
        printBaseElementType((JCArrayTypeTree) elem);
    else
        printExpr(elem);
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
private boolean matchWildcard(JCWildcard t1, JCWildcard t2) {
    return t1.kind == t2.kind && treesMatch(t1.inner, t2.inner);
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
public JCWildcard Wildcard(TypeBoundKind kind, JCTree type) {
	return invoke(Wildcard, kind, type);
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
@Override public void visitTypeArray(JCArrayTypeTree tree) {
	JCTree elem = tree.elemtype;
	while (elem instanceof JCWildcard) elem = ((JCWildcard) elem).inner;
	print(elem);
	print("[]");
}
 

import com.sun.tools.javac.tree.JCTree.JCWildcard; //导入依赖的package包/类
private static JCExpression cloneType0(JavacTreeMaker maker, JCTree in) {
	if (in == null) return null;
	
	if (in instanceof JCPrimitiveTypeTree) return (JCExpression) in;
	
	if (in instanceof JCIdent) {
		return maker.Ident(((JCIdent) in).name);
	}
	
	if (in instanceof JCFieldAccess) {
		JCFieldAccess fa = (JCFieldAccess) in;
		return maker.Select(cloneType0(maker, fa.selected), fa.name);
	}
	
	if (in instanceof JCArrayTypeTree) {
		JCArrayTypeTree att = (JCArrayTypeTree) in;
		return maker.TypeArray(cloneType0(maker, att.elemtype));
	}
	
	if (in instanceof JCTypeApply) {
		JCTypeApply ta = (JCTypeApply) in;
		ListBuffer<JCExpression> lb = new ListBuffer<JCExpression>();
		for (JCExpression typeArg : ta.arguments) {
			lb.append(cloneType0(maker, typeArg));
		}
		return maker.TypeApply(cloneType0(maker, ta.clazz), lb.toList());
	}
	
	if (in instanceof JCWildcard) {
		JCWildcard w = (JCWildcard) in;
		JCExpression newInner = cloneType0(maker, w.inner);
		TypeBoundKind newKind;
		switch (w.getKind()) {
		case SUPER_WILDCARD:
			newKind = maker.TypeBoundKind(BoundKind.SUPER);
			break;
		case EXTENDS_WILDCARD:
			newKind = maker.TypeBoundKind(BoundKind.EXTENDS);
			break;
		default:
		case UNBOUNDED_WILDCARD:
			newKind = maker.TypeBoundKind(BoundKind.UNBOUND);
			break;
		}
		return maker.Wildcard(newKind, newInner);
	}
	
	// This is somewhat unsafe, but it's better than outright throwing an exception here. Returning null will just cause an exception down the pipeline.
	return (JCExpression) in;
}