jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/classfile/Type.java

-:d1e62f78c48b
+:6ba399eff2cb
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 /*
+*  Family of classes used to represent the parsed form of a {@link Descriptor}
+*  or {@link Signature}.
+*
 *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
 *  you write code that depends on this, you do so at your own risk.
 *  This code and its internal interfaces are subject to change or
 *  deletion without notice.</b>
 */
 R visitSimpleType(SimpleType type, P p);
 R visitArrayType(ArrayType type, P p);
 R visitMethodType(MethodType type, P p);
 R visitClassSigType(ClassSigType type, P p);
 R visitClassType(ClassType type, P p);
-R visitInnerClassType(InnerClassType type, P p);
+R visitTypeParamType(TypeParamType type, P p);
-R visitTypeArgType(TypeArgType type, P p);
 R visitWildcardType(WildcardType type, P p);
 }
+/**
+* Represents a type signature with a simple name. The name may be that of a
+* primitive type, such "{@code int}, {@code float}, etc
+* or that of a type argument, such as {@code T}, {@code K}, {@code V}, etc.
+*
+* See:
+* JVMS 4.3.2
+*      BaseType:
+*          {@code B}, {@code C}, {@code D}, {@code F}, {@code I},
+*          {@code J}, {@code S}, {@code Z};
+*      VoidDescriptor:
+*          {@code V};
+* JVMS 4.3.4
+*      TypeVariableSignature:
+*          {@code T} Identifier {@code ;}
+*/
 public static class SimpleType extends Type {
 public SimpleType(String name) {
 this.name = name;
 }
 }
 public final String name;
 }
+/**
+* Represents an array type signature.
+*
+* See:
+* JVMS 4.3.4
+*      ArrayTypeSignature:
+*          {@code [} TypeSignature {@code ]}
+*/
 public static class ArrayType extends Type {
 public ArrayType(Type elemType) {
 this.elemType = elemType;
 }
 }
 public final Type elemType;
 }
+/**
+* Represents a method type signature.
+*
+* See;
+* JVMS 4.3.4
+*      MethodTypeSignature:
+*          FormalTypeParameters_opt {@code (} TypeSignature* {@code)} ReturnType
+*              ThrowsSignature*
+*/
 public static class MethodType extends Type {
-public MethodType(List<? extends Type> argTypes, Type resultType) {
+public MethodType(List<? extends Type> paramTypes, Type resultType) {
-this(null, argTypes, resultType, null);
+this(null, paramTypes, resultType, null);
 }
-public MethodType(List<? extends Type> typeArgTypes,
+public MethodType(List<? extends TypeParamType> typeParamTypes,
-List<? extends Type> argTypes,
+List<? extends Type> paramTypes,
 Type returnType,
 List<? extends Type> throwsTypes) {
-this.typeArgTypes = typeArgTypes;
+this.typeParamTypes = typeParamTypes;
-this.argTypes = argTypes;
+this.paramTypes = paramTypes;
 this.returnType = returnType;
 this.throwsTypes = throwsTypes;
 }
 public <R, D> R accept(Visitor<R, D> visitor, D data) {
 }
 @Override
 public String toString() {
 StringBuilder sb = new StringBuilder();
-appendIfNotEmpty(sb, "<", typeArgTypes, "> ");
+appendIfNotEmpty(sb, "<", typeParamTypes, "> ");
 sb.append(returnType);
-append(sb, " (", argTypes, ")");
+append(sb, " (", paramTypes, ")");
 appendIfNotEmpty(sb, " throws ", throwsTypes, "");
 return sb.toString();
 }
-public final List<? extends Type> typeArgTypes;
+public final List<? extends TypeParamType> typeParamTypes;
-public final List<? extends Type> argTypes;
+public final List<? extends Type> paramTypes;
 public final Type returnType;
 public final List<? extends Type> throwsTypes;
 }
+/**
+* Represents a class signature. These describe the signature of
+* a class that has type arguments.
+*
+* See:
+* JVMS 4.3.4
+*      ClassSignature:
+*          FormalTypeParameters_opt SuperclassSignature SuperinterfaceSignature*
+*/
 public static class ClassSigType extends Type {
-public ClassSigType(List<Type> typeArgTypes, Type superclassType, List<Type> superinterfaceTypes) {
+public ClassSigType(List<TypeParamType> typeParamTypes, Type superclassType,
-this.typeArgTypes = typeArgTypes;
+List<Type> superinterfaceTypes) {
+this.typeParamTypes = typeParamTypes;
 this.superclassType = superclassType;
 this.superinterfaceTypes = superinterfaceTypes;
 }
 public <R, D> R accept(Visitor<R, D> visitor, D data) {
 }
 @Override
 public String toString() {
 StringBuilder sb = new StringBuilder();
-appendIfNotEmpty(sb, "<", typeArgTypes, ">");
+appendIfNotEmpty(sb, "<", typeParamTypes, ">");
 if (superclassType != null) {
 sb.append(" extends ");
 sb.append(superclassType);
 }
 appendIfNotEmpty(sb, " implements ", superinterfaceTypes, "");
 return sb.toString();
 }
-public final List<Type> typeArgTypes;
+public final List<TypeParamType> typeParamTypes;
 public final Type superclassType;
 public final List<Type> superinterfaceTypes;
 }
+/**
+* Represents a class type signature. This is used to represent a
+* reference to a class, such as in a field, parameter, return type, etc.
+*
+* See:
+* JVMS 4.3.4
+*      ClassTypeSignature:
+*          {@code L} PackageSpecifier_opt SimpleClassTypeSignature
+*                  ClassTypeSignatureSuffix* {@code ;}
+*      PackageSpecifier:
+*          Identifier {@code /} PackageSpecifier*
+*      SimpleClassTypeSignature:
+*          Identifier TypeArguments_opt }
+*      ClassTypeSignatureSuffix:
+*          {@code .} SimpleClassTypeSignature
+*/
 public static class ClassType extends Type {
-public ClassType(String name, List<Type> typeArgs) {
+public ClassType(ClassType outerType, String name, List<Type> typeArgs) {
+this.outerType = outerType;
 this.name = name;
 this.typeArgs = typeArgs;
 }
 public <R, D> R accept(Visitor<R, D> visitor, D data) {
 return visitor.visitClassType(this, data);
 }
+public String getBinaryName() {
+if (outerType == null)
+return name;
+else
+return (outerType.getBinaryName() + "$" + name);
+}
 @Override
 public String toString() {
 StringBuilder sb = new StringBuilder();
+if (outerType != null) {
+sb.append(outerType);
+sb.append(".");
+}
 sb.append(name);
 appendIfNotEmpty(sb, "<", typeArgs, ">");
 return sb.toString();
 }
+public final ClassType outerType;
 public final String name;
 public final List<Type> typeArgs;
 }
+/**
-public static class InnerClassType extends Type {
+* Represents a FormalTypeParameter. These are used to declare the type
-public InnerClassType(Type outerType, Type innerType) {
+* parameters for generic classes and methods.
-this.outerType = outerType;
+*
-this.innerType = innerType;
+* See:
-}
+* JVMS 4.3.4
+*     FormalTypeParameters:
-public <R, D> R accept(Visitor<R, D> visitor, D data) {
+*          {@code <} FormalTypeParameter+ {@code >}
-return visitor.visitInnerClassType(this, data);
+*     FormalTypeParameter:
-}
+*          Identifier ClassBound InterfaceBound*
+*     ClassBound:
-@Override
+*          {@code :} FieldTypeSignature_opt
-public String toString() {
+*     InterfaceBound:
-return outerType + "." + innerType;
+*          {@code :} FieldTypeSignature
-}
+*/
+public static class TypeParamType extends Type {
-public final Type outerType;
+public TypeParamType(String name, Type classBound, List<Type> interfaceBounds) {
-public final Type innerType;
-}
-public static class TypeArgType extends Type {
-public TypeArgType(String name, Type classBound, List<Type> interfaceBounds) {
 this.name = name;
 this.classBound = classBound;
 this.interfaceBounds = interfaceBounds;
 }
 public <R, D> R accept(Visitor<R, D> visitor, D data) {
-return visitor.visitTypeArgType(this, data);
+return visitor.visitTypeParamType(this, data);
 }
 @Override
 public String toString() {
 StringBuilder sb = new StringBuilder();
 public final String name;
 public final Type classBound;
 public final List<Type> interfaceBounds;
 }
+/**
+* Represents a wildcard type argument.  A type argument that is not a
+* wildcard type argument will be represented by a ClassType, ArrayType, etc.
+*
+* See:
+* JVMS 4.3.4
+*      TypeArgument:
+*          WildcardIndicator_opt FieldTypeSignature
+*          {@code *}
+*      WildcardIndicator:
+*          {@code +}
+*          {@code -}
+*/
 public static class WildcardType extends Type {
+public enum Kind { UNBOUNDED, EXTENDS, SUPER };
 public WildcardType() {
-this(null, null);
+this(Kind.UNBOUNDED, null);
 }
+public WildcardType(Kind kind, Type boundType) {
-public WildcardType(String kind, Type boundType) {
 this.kind = kind;
 this.boundType = boundType;
 }
 public <R, D> R accept(Visitor<R, D> visitor, D data) {
 return visitor.visitWildcardType(this, data);
 }
 @Override
 public String toString() {
-if (kind == null)
+switch (kind) {
-return "?";
+case UNBOUNDED:
-else
+return "?";
-return "? " + kind + " " + boundType;
+case EXTENDS:
-}
+return "? extends " + boundType;
+case SUPER:
-public final String kind;
+return "? super " + boundType;
+default:
+throw new AssertionError();
+}
+}
+public final Kind kind;
 public final Type boundType;
 }
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/classfile/Type.java

src/share/classes/com/sun/tools/classfile/Type.java