Java BoundKind类代码示例

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
public WildcardTree Wildcard(Kind kind, Tree type) {
    final BoundKind boundKind;
    switch (kind) {
        case UNBOUNDED_WILDCARD:
            boundKind = BoundKind.UNBOUND;
            break;
        case EXTENDS_WILDCARD:
            boundKind = BoundKind.EXTENDS;
            break;
        case SUPER_WILDCARD:
            boundKind = BoundKind.SUPER;
            break;
        default:
            throw new IllegalArgumentException("Unknown wildcard bound " + kind);
    }
    TypeBoundKind tbk = make.at(NOPOS).TypeBoundKind(boundKind);
    return make.at(NOPOS).Wildcard(tbk, (JCExpression)type);
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
protected Type makeWildcard(Type upper, Type lower) {
    BoundKind bk;
    Type bound;
    if (upper.hasTag(BOT)) {
        upper = syms.objectType;
    }
    boolean isUpperObject = types.isSameType(upper, syms.objectType);
    if (!lower.hasTag(BOT) && isUpperObject) {
        bound = lower;
        bk = SUPER;
    } else {
        bound = upper;
        bk = isUpperObject ? UNBOUND : EXTENDS;
    }
    return new WildcardType(bound, bk, syms.boundClass);
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的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.code.BoundKind; //导入依赖的package包/类
@Override
public void visitWildcard(JCWildcard tree) {
    if (tree.kind.kind == BoundKind.UNBOUND)
        result = tree.kind.toString();
    else
        result = tree.kind + " " + print(tree.inner);
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
@Test
public void genericMethodInvocation() {
  compile(
      "import java.util.Collections;",
      "import java.util.List;",
      "class GenericTemplateExample {",
      "  public <E> List<E> example(List<E> list) {",
      "    return Collections.unmodifiableList(list);",
      "  }",
      "}");
  UTypeVar tVar = UTypeVar.create("T");
  UTypeVar eVar = UTypeVar.create("E");
  assertEquals(
      ExpressionTemplate.create(
          ImmutableClassToInstanceMap.<Annotation>builder().build(),
          ImmutableList.of(eVar),
          ImmutableMap.of("list", UClassType.create("java.util.List", eVar)),
          UMethodInvocation.create(
              UStaticIdent.create(
                  "java.util.Collections", 
                  "unmodifiableList", 
                  UForAll.create(
                      ImmutableList.of(tVar), 
                      UMethodType.create(
                          UClassType.create("java.util.List", tVar),
                          UClassType.create(
                              "java.util.List", 
                              UWildcardType.create(BoundKind.EXTENDS, tVar))))),
              UFreeIdent.create("list")),
          UClassType.create("java.util.List", eVar)),
      UTemplater.createTemplate(context, getMethodDeclaration("example")));
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
@Test
public void equality() {
  UType objectType = UClassType.create("java.lang.Object", ImmutableList.<UType>of());
  UType setType = UClassType.create("java.util.Set", ImmutableList.<UType>of(objectType));
  
  new EqualsTester()
      .addEqualityGroup(UWildcardType.create(BoundKind.UNBOUND, objectType)) // ?
      .addEqualityGroup(UWildcardType.create(BoundKind.EXTENDS, objectType)) // ? extends Object
      .addEqualityGroup(UWildcardType.create(BoundKind.EXTENDS, setType)) // ? extends Set<Object>
      .addEqualityGroup(UWildcardType.create(BoundKind.SUPER, setType)) // ? super Set<Object>
      .testEquals();
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
@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);
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
private JCExpression addWildcards(Node node, JCExpression type, WildcardKind wildcardKind) {
	TypeBoundKind typeBoundKind;
	switch (wildcardKind) {
	case NONE:
		return type;
	case EXTENDS:
		typeBoundKind = treeMaker.TypeBoundKind(BoundKind.EXTENDS);
		Position jcExtendsPos = getConversionPositionInfo(node, "extends");
		if (jcExtendsPos == null) {
			setPos(posOfStructure(node, "extends", true), posOfStructure(node, "extends", false), typeBoundKind);
		} else {
			setPos(jcExtendsPos.getStart(), jcExtendsPos.getEnd(), typeBoundKind);
		}
		return setPos(type.pos, endPosTable.get(type), treeMaker.Wildcard(typeBoundKind, type));
	case SUPER:
		typeBoundKind = treeMaker.TypeBoundKind(BoundKind.SUPER);
		Position jcSuperPos = getConversionPositionInfo(node, "super");
		if (jcSuperPos == null) {
			setPos(posOfStructure(node, "super", true), posOfStructure(node, "super", false), typeBoundKind);
		} else {
			setPos(jcSuperPos.getStart(), jcSuperPos.getEnd(), typeBoundKind);
		}
		return setPos(type.pos, endPosTable.get(type), treeMaker.Wildcard(typeBoundKind, type));
	default:
		throw new IllegalStateException("Unexpected unbound wildcard: " + wildcardKind);
	}
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
@Override
public String visitWildcardType(Type.WildcardType t, Void aVoid) {
  StringBuilder sb = new StringBuilder();
  sb.append(t.kind);
  if (t.kind != BoundKind.UNBOUND) {
    sb.append(t.type.accept(this, null));
  }
  return sb.toString();
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
@Test
public void genericMethodInvocation() {
  compile(
      "import java.util.Collections;",
      "import java.util.List;",
      "class GenericTemplateExample {",
      "  public <E> List<E> example(List<E> list) {",
      "    return Collections.unmodifiableList(list);",
      "  }",
      "}");
  UTypeVar tVar = UTypeVar.create("T");
  UTypeVar eVar = UTypeVar.create("E");
  assertEquals(
      ExpressionTemplate.create(
          ImmutableClassToInstanceMap.<Annotation>builder().build(),
          ImmutableList.of(eVar),
          ImmutableMap.of("list", UClassType.create("java.util.List", eVar)),
          UMethodInvocation.create(
              UStaticIdent.create(
                  "java.util.Collections",
                  "unmodifiableList",
                  UForAll.create(
                      ImmutableList.of(tVar),
                      UMethodType.create(
                          UClassType.create("java.util.List", tVar),
                          UClassType.create(
                              "java.util.List", UWildcardType.create(BoundKind.EXTENDS, tVar))))),
              UFreeIdent.create("list")),
          UClassType.create("java.util.List", eVar)),
      UTemplater.createTemplate(context, getMethodDeclaration("example")));
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
@Test
public void equality() {
  UType objectType = UClassType.create("java.lang.Object", ImmutableList.<UType>of());
  UType setType = UClassType.create("java.util.Set", ImmutableList.<UType>of(objectType));

  new EqualsTester()
      .addEqualityGroup(UWildcardType.create(BoundKind.UNBOUND, objectType)) // ?
      .addEqualityGroup(UWildcardType.create(BoundKind.EXTENDS, objectType)) // ? extends Object
      .addEqualityGroup(UWildcardType.create(BoundKind.EXTENDS, setType)) // ? extends Set<Object>
      .addEqualityGroup(UWildcardType.create(BoundKind.SUPER, setType)) // ? super Set<Object>
      .testEquals();
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的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.code.BoundKind; //导入依赖的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.code.BoundKind; //导入依赖的package包/类
protected TypeBoundKind(BoundKind kind) {
    this.kind = kind;
}
 

import com.sun.tools.javac.code.BoundKind; //导入依赖的package包/类
public WildcardType Wildcard(BoundKind bk, Type bound) {
    return new WildcardType(bound, bk, predef.boundClass);
}