Java Type.getKind方法代码示例

import com.sun.tools.javac.code.Type; //导入方法依赖的package包/类
/**
 * Erasure destroys the implementation parameter subtype
 * relationship for intersection types
 */
boolean interfaceParameterIsIntersectionType() {
    List<Type> tl = tree.getDescriptorType(types).getParameterTypes();
    if (tree.kind == ReferenceKind.UNBOUND) {
        tl = tl.tail;
    }
    for (; tl.nonEmpty(); tl = tl.tail) {
        Type pt = tl.head;
        if (pt.getKind() == TypeKind.TYPEVAR) {
            TypeVar tv = (TypeVar) pt;
            if (tv.bound.getKind() == TypeKind.INTERSECTION) {
                return true;
            }
        }
    }
    return false;
}
 

import com.sun.tools.javac.code.Type; //导入方法依赖的package包/类
private String getJvmPrimitiveSignature(Type t) {
    switch (t.getKind()) {
        case VOID:      return SIG_VOID;
        case BOOLEAN:   return SIG_BOOLEAN;
        case BYTE:      return SIG_BYTE;
        case CHAR:      return SIG_CHAR;
        case SHORT:     return SIG_SHORT;
        case INT:       return SIG_INT;
        case LONG:      return SIG_LONG;
        case FLOAT:     return SIG_FLOAT;
        case DOUBLE:    return SIG_DOUBLE;
        default:
            Assert.error("unknown type: should not happen");
    }
    return null;
}
 

import com.sun.tools.javac.code.Type; //导入方法依赖的package包/类
/**
 * Find the type of the method descriptor associated to the functional interface.
 * 
 * @param origin functional interface type
 * @return associated method descriptor type or <code>null</code> if the <code>origin</code> is not a functional interface.
 * @since 0.112
 */
public ExecutableType getDescriptorType(DeclaredType origin) {
    Types types = Types.instance(info.impl.getJavacTask().getContext());
    if (types.isFunctionalInterface(((Type)origin).tsym)) {
        Type dt = types.findDescriptorType((Type)origin);
        if (dt != null && dt.getKind() == TypeKind.EXECUTABLE) {
            return (ExecutableType)dt;
        }
    }
    return null;
}
 

import com.sun.tools.javac.code.Type; //导入方法依赖的package包/类
/**
 * Erasure destroys the implementation parameter subtype
 * relationship for intersection types
 */
boolean interfaceParameterIsIntersectionType() {
    List<Type> tl = tree.getDescriptorType(types).getParameterTypes();
    for (; tl.nonEmpty(); tl = tl.tail) {
        Type pt = tl.head;
        if (pt.getKind() == TypeKind.TYPEVAR) {
            TypeVar tv = (TypeVar) pt;
            if (tv.bound.getKind() == TypeKind.INTERSECTION) {
                return true;
            }
        }
    }
    return false;
}
 

import com.sun.tools.javac.code.Type; //导入方法依赖的package包/类
private ExpressionInfo treeToInfo(TreePath tp) {
    if (tp != null) {
        Tree tree = tp.getLeaf();
        if (tree instanceof ExpressionTree) {
            ExpressionInfo ei = new ExpressionInfo();
            ei.tree = (ExpressionTree) tree;
            Type type = pathToType(tp, tree);
            if (type != null) {
                switch (type.getKind()) {
                    case VOID:
                    case NONE:
                    case ERROR:
                    case OTHER:
                        break;
                    case NULL:
                        ei.isNonVoid = true;
                        ei.typeName = OBJECT_TYPE_NAME;
                        break;
                    default: {
                        ei.isNonVoid = true;
                        ei.typeName = varTypeName(type);
                        if (ei.typeName == null) {
                            ei.typeName = OBJECT_TYPE_NAME;
                        }
                        break;
                    }
                }
            }
            return ei;
        }
    }
    return null;
}
 

import com.sun.tools.javac.code.Type; //导入方法依赖的package包/类
@NonNull
protected MethodSpec.Builder createMethod(final Symbol.MethodSymbol ms) throws Exception {
    final String methodName = ms.getSimpleName().toString();
    final MethodSpec.Builder builder = MethodSpec.methodBuilder(methodName);

    builder.addModifiers(Modifier.FINAL, Modifier.PUBLIC);

    // extract annotations of return type / method. copy all, except @Yield & @AfterCall
    mimicMethodAnnotations(builder, ms);

    // extract our own annotations
    final Attribute.Compound yield = findYieldMethodAnnotation(ms);
    final Attribute.Compound after = findAfterMethodAnnotation(ms);

    // extract return type
    final Type returnType = ms.getReturnType();
    final boolean hasReturn = returnType.getKind() != TypeKind.VOID;
    builder.returns(TypeName.get(returnType));

    // extract parameters
    final StringBuilder arguments = mimicParameters(builder, ms);

    // extract throws
    mimicThrows(builder, ms);

    builder.beginControlFlow("if (!$L( $S$L ))", PREDICATE, methodName,
            (arguments.length() == 0 ? "" : ", ") + arguments);

    // generate default return value
    if (hasReturn || null != yield) {
        if (null != yield) builder.addComment("" + yield);
        createYieldPart(builder, returnType, yield);
    } else {
        builder.addStatement("return");
    }

    builder.endControlFlow();

    // generate return
    if (null == after) {
        builder.addStatement((hasReturn ? "return " : "") + "this.inner.$N($L)", methodName, arguments);
    } else {
        afterCalls.set(true);

        if (hasReturn) {
            builder.addStatement("return $L($S, this.inner.$N($L))", AFTERCALL, methodName, methodName, arguments);
        } else {
            builder.addStatement("this.inner.$N($L)", methodName, arguments);
            builder.addStatement("$L($S, null)", AFTERCALL, methodName);
        }
    }

    return builder;
}
 

import com.sun.tools.javac.code.Type; //导入方法依赖的package包/类
@SuppressWarnings("fallthrough")
protected final String jniType(Type t) {
    switch (t.getKind()) {
        case ARRAY: {
            Type ct = ((Type.ArrayType)t).getComponentType();
            switch (ct.getKind()) {
                case BOOLEAN:  return "jbooleanArray";
                case BYTE:     return "jbyteArray";
                case CHAR:     return "jcharArray";
                case SHORT:    return "jshortArray";
                case INT:      return "jintArray";
                case LONG:     return "jlongArray";
                case FLOAT:    return "jfloatArray";
                case DOUBLE:   return "jdoubleArray";
                case ARRAY:
                case DECLARED: return "jobjectArray";
                default: throw new Error(ct.toString());
            }
        }

        case VOID:     return "void";
        case BOOLEAN:  return "jboolean";
        case BYTE:     return "jbyte";
        case CHAR:     return "jchar";
        case SHORT:    return "jshort";
        case INT:      return "jint";
        case LONG:     return "jlong";
        case FLOAT:    return "jfloat";
        case DOUBLE:   return "jdouble";
        case DECLARED: {
            if (t.tsym.type == syms.stringType) {
                return "jstring";
            } else if (types.isAssignable(t, syms.throwableType)) {
                return "jthrowable";
            } else if (types.isAssignable(t, syms.classType)) {
                return "jclass";
            } else {
                return "jobject";
            }
        }
    }

    Assert.check(false, "jni unknown type");
    return null; /* dead code. */
}