Java MethodType类代码示例

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
/** Enter a unary operation into symbol table.
 *  @param name     The name of the operator.
 *  @param arg      The type of the operand.
 *  @param res      The operation's result type.
 *  @param opcode   The operation's bytecode instruction.
 */
private OperatorSymbol enterUnop(String name,
                                 Type arg,
                                 Type res,
                                 int opcode) {
    OperatorSymbol sym =
        new OperatorSymbol(names.fromString(name),
                           new MethodType(List.of(arg),
                                          res,
                                          List.<Type>nil(),
                                          methodClass),
                           opcode,
                           predefClass);
    predefClass.members().enter(sym);
    return sym;
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private Type bsmStaticArgToType(Object arg) {
    Assert.checkNonNull(arg);
    if (arg instanceof ClassSymbol) {
        return syms.classType;
    } else if (arg instanceof Integer) {
        return syms.intType;
    } else if (arg instanceof Long) {
        return syms.longType;
    } else if (arg instanceof Float) {
        return syms.floatType;
    } else if (arg instanceof Double) {
        return syms.doubleType;
    } else if (arg instanceof String) {
        return syms.stringType;
    } else if (arg instanceof Pool.MethodHandle) {
        return syms.methodHandleType;
    } else if (arg instanceof MethodType) {
        return syms.methodTypeType;
    } else {
        Assert.error("bad static arg " + arg.getClass());
        return null;
    }
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
/**
 * Returns the inferred method type of the template based on the given actual argument types.
 *
 * @throws NoInstanceException if no instances of the specified type variables would allow the
 *         {@code actualArgTypes} to match the {@code expectedArgTypes}
 */
private Type infer(Warner warner,
    Inliner inliner,
    List<Type> freeTypeVariables,
    List<Type> expectedArgTypes,
    Type returnType,
    List<Type> actualArgTypes) throws NoInstanceException {
  Symtab symtab = inliner.symtab();
  MethodType methodType =
      new MethodType(expectedArgTypes, returnType, List.<Type>nil(), symtab.methodClass);
  Enter enter = inliner.enter();
  MethodSymbol methodSymbol =
      new MethodSymbol(0, inliner.asName("__m__"), methodType, symtab.unknownSymbol);
  return inliner.infer().instantiateMethod(enter.getEnv(methodType.tsym),
      freeTypeVariables,
      methodType,
      methodSymbol,
      actualArgTypes,
      autoboxing(),
      false,
      warner);
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
/** Enter a binary operation into symbol table.
 *  @param name     The name of the operator.
 *  @param left     The type of the left operand.
 *  @param right    The type of the left operand.
 *  @param res      The operation's result type.
 *  @param opcode   The operation's bytecode instruction.
 */
private void enterBinop(String name,
                        Type left, Type right, Type res,
                        int opcode) {
    predefClass.members().enter(
        new OperatorSymbol(
            names.fromString(name),
            new MethodType(List.of(left, right), res,
                           List.<Type>nil(), methodClass),
            opcode,
            predefClass));
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private KlassInfo(JCClassDecl clazz) {
    this.clazz = clazz;
    appendedMethodList = new ListBuffer<>();
    deserializeCases = new HashMap<String, ListBuffer<JCStatement>>();
    MethodType type = new MethodType(List.of(syms.serializedLambdaType), syms.objectType,
            List.<Type>nil(), syms.methodClass);
    deserMethodSym = makePrivateSyntheticMethod(STATIC, names.deserializeLambda, type, clazz.sym);
    deserParamSym = new VarSymbol(FINAL, names.fromString("lambda"),
            syms.serializedLambdaType, deserMethodSym);
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private JCExpression deserTest(JCExpression prev, String func, String lit) {
    MethodType eqmt = new MethodType(List.of(syms.objectType), syms.booleanType, List.<Type>nil(), syms.methodClass);
    Symbol eqsym = rs.resolveQualifiedMethod(null, attrEnv, syms.objectType, names.equals, List.of(syms.objectType), List.<Type>nil());
    JCMethodInvocation eqtest = make.Apply(
            List.<JCExpression>nil(),
            make.Select(deserGetter(func, syms.stringType), eqsym).setType(eqmt),
            List.<JCExpression>of(make.Literal(lit)));
    eqtest.setType(syms.booleanType);
    JCBinary compound = make.Binary(JCTree.Tag.AND, prev, eqtest);
    compound.operator = rs.resolveBinaryOperator(null, JCTree.Tag.AND, attrEnv, syms.booleanType, syms.booleanType);
    compound.setType(syms.booleanType);
    return compound;
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private JCExpression deserGetter(String func, Type type, List<Type> argTypes, List<JCExpression> args) {
    MethodType getmt = new MethodType(argTypes, type, List.<Type>nil(), syms.methodClass);
    Symbol getsym = rs.resolveQualifiedMethod(null, attrEnv, syms.serializedLambdaType, names.fromString(func), argTypes, List.<Type>nil());
    return make.Apply(
                List.<JCExpression>nil(),
                make.Select(make.Ident(kInfo.deserParamSym).setType(syms.serializedLambdaType), getsym).setType(getmt),
                args).setType(type);
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private MethodType typeToMethodType(Type mt) {
    Type type = types.erasure(mt);
    return new MethodType(type.getParameterTypes(),
                    type.getReturnType(),
                    type.getThrownTypes(),
                    syms.methodClass);
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
/**
 * Generate an indy method call with given name, type and static bootstrap
 * arguments types
 */
private JCExpression makeIndyCall(DiagnosticPosition pos, Type site, Name bsmName,
        List<Object> staticArgs, MethodType indyType, List<JCExpression> indyArgs,
        Name methName) {
    int prevPos = make.pos;
    try {
        make.at(pos);
        List<Type> bsm_staticArgs = List.of(syms.methodHandleLookupType,
                syms.stringType,
                syms.methodTypeType).appendList(bsmStaticArgToTypes(staticArgs));

        Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site,
                bsmName, bsm_staticArgs, List.<Type>nil());

        DynamicMethodSymbol dynSym =
                new DynamicMethodSymbol(methName,
                                        syms.noSymbol,
                                        bsm.isStatic() ?
                                            ClassFile.REF_invokeStatic :
                                            ClassFile.REF_invokeVirtual,
                                        (MethodSymbol)bsm,
                                        indyType,
                                        staticArgs.toArray());

        JCFieldAccess qualifier = make.Select(make.QualIdent(site.tsym), bsmName);
        qualifier.sym = dynSym;
        qualifier.type = indyType.getReturnType();

        JCMethodInvocation proxyCall = make.Apply(List.<JCExpression>nil(), qualifier, indyArgs);
        proxyCall.type = indyType.getReturnType();
        return proxyCall;
    } finally {
        make.at(prevPos);
    }
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private KlassInfo(JCClassDecl clazz) {
    this.clazz = clazz;
    appendedMethodList = new ListBuffer<>();
    deserializeCases = new HashMap<>();
    MethodType type = new MethodType(List.of(syms.serializedLambdaType), syms.objectType,
            List.nil(), syms.methodClass);
    deserMethodSym = makePrivateSyntheticMethod(STATIC, names.deserializeLambda, type, clazz.sym);
    deserParamSym = new VarSymbol(FINAL, names.fromString("lambda"),
            syms.serializedLambdaType, deserMethodSym);
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private JCExpression deserTest(JCExpression prev, String func, String lit) {
    MethodType eqmt = new MethodType(List.of(syms.objectType), syms.booleanType, List.nil(), syms.methodClass);
    Symbol eqsym = rs.resolveQualifiedMethod(null, attrEnv, syms.objectType, names.equals, List.of(syms.objectType), List.nil());
    JCMethodInvocation eqtest = make.Apply(
            List.nil(),
            make.Select(deserGetter(func, syms.stringType), eqsym).setType(eqmt),
            List.of(make.Literal(lit)));
    eqtest.setType(syms.booleanType);
    JCBinary compound = make.Binary(JCTree.Tag.AND, prev, eqtest);
    compound.operator = operators.resolveBinary(compound, JCTree.Tag.AND, syms.booleanType, syms.booleanType);
    compound.setType(syms.booleanType);
    return compound;
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
private JCExpression deserGetter(String func, Type type, List<Type> argTypes, List<JCExpression> args) {
    MethodType getmt = new MethodType(argTypes, type, List.nil(), syms.methodClass);
    Symbol getsym = rs.resolveQualifiedMethod(null, attrEnv, syms.serializedLambdaType, names.fromString(func), argTypes, List.nil());
    return make.Apply(
                List.nil(),
                make.Select(make.Ident(kInfo.deserParamSym).setType(syms.serializedLambdaType), getsym).setType(getmt),
                args).setType(type);
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
/**
 * Generate an indy method call with given name, type and static bootstrap
 * arguments types
 */
private JCExpression makeIndyCall(DiagnosticPosition pos, Type site, Name bsmName,
        List<Object> staticArgs, MethodType indyType, List<JCExpression> indyArgs,
        Name methName) {
    int prevPos = make.pos;
    try {
        make.at(pos);
        List<Type> bsm_staticArgs = List.of(syms.methodHandleLookupType,
                syms.stringType,
                syms.methodTypeType).appendList(bsmStaticArgToTypes(staticArgs));

        Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site,
                bsmName, bsm_staticArgs, List.nil());

        DynamicMethodSymbol dynSym =
                new DynamicMethodSymbol(methName,
                                        syms.noSymbol,
                                        bsm.isStatic() ?
                                            ClassFile.REF_invokeStatic :
                                            ClassFile.REF_invokeVirtual,
                                        (MethodSymbol)bsm,
                                        indyType,
                                        staticArgs.toArray());

        JCFieldAccess qualifier = make.Select(make.QualIdent(site.tsym), bsmName);
        qualifier.sym = dynSym;
        qualifier.type = indyType.getReturnType();

        JCMethodInvocation proxyCall = make.Apply(List.nil(), qualifier, indyArgs);
        proxyCall.type = indyType.getReturnType();
        return proxyCall;
    } finally {
        make.at(prevPos);
    }
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
/**
 * Creates an operator symbol.
 */
private OperatorSymbol makeOperator(Name name, List<OperatorType> formals, OperatorType res, int... opcodes) {
    MethodType opType = new MethodType(
            formals.stream()
                    .map(o -> o.asType(syms))
                    .collect(List.collector()),
            res.asType(syms), List.nil(), syms.methodClass);
    return new OperatorSymbol(name, opType, mergeOpcodes(opcodes), syms.noSymbol);
}
 

import com.sun.tools.javac.code.Type.MethodType; //导入依赖的package包/类
String typeOfMethod(MethodSnippet msn) {
    Tree unitTree = method(msn);
    if (unitTree instanceof JCMethodDecl) {
        JCMethodDecl mtree = (JCMethodDecl) unitTree;
        Type mt = types().erasure(mtree.type);
        if (mt instanceof MethodType) {
            return signature(types(), (MethodType) mt);
        }
    }
    return null;
}