jdk-sandbox: comparison src/jdk.compiler/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java

equal deleted inserted replaced

-:224515275cf9
+:b2ed96c35687
 * questions.
 */
 package com.sun.tools.javac.comp;
+import com.sun.tools.javac.code.Symbol.MethodHandleSymbol;
 import com.sun.tools.javac.code.Types.SignatureGenerator.InvalidSignatureException;
+import com.sun.tools.javac.jvm.PoolConstant.LoadableConstant;
 import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.tree.JCTree.JCMemberReference.ReferenceKind;
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import static com.sun.tools.javac.comp.LambdaToMethod.LambdaSymbolKind.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Kinds.Kind.*;
 import static com.sun.tools.javac.code.TypeTag.*;
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
-import static com.sun.tools.javac.jvm.Pool.DynamicMethod;
 import javax.lang.model.element.ElementKind;
 import javax.lang.model.type.TypeKind;
-import com.sun.tools.javac.code.Type.IntersectionClassType;
-import com.sun.tools.javac.code.Types.FunctionDescriptorLookupError;
 import com.sun.tools.javac.main.Option;
 /**
 * This pass desugars lambda expressions into static methods
 *
 */
 private ListBuffer<JCTree> appendedMethodList;
 private Map<DedupedLambda, DedupedLambda> dedupedLambdas;
-private Map<DynamicMethod, DynamicMethodSymbol> dynMethSyms = new HashMap<>();
+private Map<Object, DynamicMethodSymbol> dynMethSyms = new HashMap<>();
 /**
 * list of deserialization cases
 */
 private final Map<String, ListBuffer<JCStatement>> deserializeCases;
 }
 //then, determine the arguments to the indy call
 List<JCExpression> indy_args = translate(syntheticInits.toList(), localContext.prev);
-//build a sam instance using an indy call to the meta-factory
-int refKind = referenceKind(sym);
 //convert to an invokedynamic call
-result = makeMetafactoryIndyCall(context, refKind, sym, indy_args);
+result = makeMetafactoryIndyCall(context, sym.asHandle(), indy_args);
 }
 // where
 // Reassign type annotations from the source that should really belong to the lambda
 private void apportionTypeAnnotations(JCLambda tree,
 public void visitReference(JCMemberReference tree) {
 ReferenceTranslationContext localContext = (ReferenceTranslationContext)context;
 //first determine the method symbol to be used to generate the sam instance
 //this is either the method reference symbol, or the bridged reference symbol
-Symbol refSym = tree.sym;
+MethodSymbol refSym = (MethodSymbol)tree.sym;
 //the qualifying expression is treated as a special captured arg
 JCExpression init;
 switch(tree.kind) {
 List<JCExpression> indy_args = init==null? List.nil() : translate(List.of(init), localContext.prev);
 //build a sam instance using an indy call to the meta-factory
-result = makeMetafactoryIndyCall(localContext, localContext.referenceKind(), refSym, indy_args);
+result = makeMetafactoryIndyCall(localContext, refSym.asHandle(), indy_args);
 }
 /**
 * Translate identifiers within a lambda to the mapped identifier
 * @param tree
 JCNewClass makeNewClass(Type ctype, List<JCExpression> args) {
 return makeNewClass(ctype, args,
 rs.resolveConstructor(null, attrEnv, ctype, TreeInfo.types(args), List.nil()));
 }
-private void addDeserializationCase(int implMethodKind, Symbol refSym, Type targetType, MethodSymbol samSym,
+private void addDeserializationCase(MethodHandleSymbol refSym, Type targetType, MethodSymbol samSym,
-DiagnosticPosition pos, List<Object> staticArgs, MethodType indyType) {
+DiagnosticPosition pos, List<LoadableConstant> staticArgs, MethodType indyType) {
 String functionalInterfaceClass = classSig(targetType);
 String functionalInterfaceMethodName = samSym.getSimpleName().toString();
 String functionalInterfaceMethodSignature = typeSig(types.erasure(samSym.type));
 String implClass = classSig(types.erasure(refSym.owner.type));
 String implMethodName = refSym.getQualifiedName().toString();
 String implMethodSignature = typeSig(types.erasure(refSym.type));
-JCExpression kindTest = eqTest(syms.intType, deserGetter("getImplMethodKind", syms.intType), make.Literal(implMethodKind));
+JCExpression kindTest = eqTest(syms.intType, deserGetter("getImplMethodKind", syms.intType),
+make.Literal(refSym.referenceKind()));
 ListBuffer<JCExpression> serArgs = new ListBuffer<>();
 int i = 0;
 for (Type t : indyType.getParameterTypes()) {
 List<JCExpression> indexAsArg = new ListBuffer<JCExpression>().append(make.Literal(i)).toList();
 List<Type> argTypes = new ListBuffer<Type>().append(syms.intType).toList();
 /**
 * Generate an indy method call to the meta factory
 */
 private JCExpression makeMetafactoryIndyCall(TranslationContext<?> context,
-int refKind, Symbol refSym, List<JCExpression> indy_args) {
+MethodHandleSymbol refSym, List<JCExpression> indy_args) {
 JCFunctionalExpression tree = context.tree;
 //determine the static bsm args
 MethodSymbol samSym = (MethodSymbol) types.findDescriptorSymbol(tree.target.tsym);
-List<Object> staticArgs = List.of(
+List<LoadableConstant> staticArgs = List.of(
 typeToMethodType(samSym.type),
-new Pool.MethodHandle(refKind, refSym, types),
+((MethodSymbol)refSym).asHandle(),
 typeToMethodType(tree.getDescriptorType(types)));
 //computed indy arg types
 ListBuffer<Type> indy_args_types = new ListBuffer<>();
 for (JCExpression arg : indy_args) {
 Name metafactoryName = context.needsAltMetafactory() ?
 names.altMetafactory : names.metafactory;
 if (context.needsAltMetafactory()) {
-ListBuffer<Object> markers = new ListBuffer<>();
+ListBuffer<Type> markers = new ListBuffer<>();
 List<Type> targets = tree.target.isIntersection() ?
 types.directSupertypes(tree.target) :
 List.nil();
 for (Type t : targets) {
 t = types.erasure(t);
 if (t.tsym != syms.serializableType.tsym &&
 t.tsym != tree.type.tsym &&
 t.tsym != syms.objectType.tsym) {
-markers.append(t.tsym);
+markers.append(t);
 }
 }
 int flags = context.isSerializable() ? FLAG_SERIALIZABLE : 0;
 boolean hasMarkers = markers.nonEmpty();
 boolean hasBridges = context.bridges.nonEmpty();
 flags |= FLAG_MARKERS;
 }
 if (hasBridges) {
 flags |= FLAG_BRIDGES;
 }
-staticArgs = staticArgs.append(flags);
+staticArgs = staticArgs.append(LoadableConstant.Int(flags));
 if (hasMarkers) {
-staticArgs = staticArgs.append(markers.length());
+staticArgs = staticArgs.append(LoadableConstant.Int(markers.length()));
-staticArgs = staticArgs.appendList(markers.toList());
+staticArgs = staticArgs.appendList(List.convert(LoadableConstant.class, markers.toList()));
 }
 if (hasBridges) {
-staticArgs = staticArgs.append(context.bridges.length() - 1);
+staticArgs = staticArgs.append(LoadableConstant.Int(context.bridges.length() - 1));
 for (Symbol s : context.bridges) {
 Type s_erasure = s.erasure(types);
 if (!types.isSameType(s_erasure, samSym.erasure(types))) {
-staticArgs = staticArgs.append(s.erasure(types));
+staticArgs = staticArgs.append(((MethodType)s.erasure(types)));
 }
 }
 }
 if (context.isSerializable()) {
 int prevPos = make.pos;
 try {
 make.at(kInfo.clazz);
-addDeserializationCase(refKind, refSym, tree.type, samSym,
+addDeserializationCase(refSym, tree.type, samSym,
 tree, staticArgs, indyType);
 } finally {
 make.at(prevPos);
 }
 }
 /**
 * 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,
+List<LoadableConstant> 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));
+syms.methodTypeType).appendList(staticArgs.map(types::constantType));
 Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site,
 bsmName, bsm_staticArgs, List.nil());
 DynamicMethodSymbol dynSym =
 new DynamicMethodSymbol(methName,
 syms.noSymbol,
-bsm.isStatic() ?
+((MethodSymbol)bsm).asHandle(),
-ClassFile.REF_invokeStatic :
-ClassFile.REF_invokeVirtual,
-(MethodSymbol)bsm,
 indyType,
-staticArgs.toArray());
+staticArgs.toArray(new LoadableConstant[staticArgs.length()]));
 JCFieldAccess qualifier = make.Select(make.QualIdent(site.tsym), bsmName);
 DynamicMethodSymbol existing = kInfo.dynMethSyms.putIfAbsent(
-new DynamicMethod(dynSym, types), dynSym);
+dynSym.poolKey(types), dynSym);
 qualifier.sym = existing != null ? existing : dynSym;
 qualifier.type = indyType.getReturnType();
 JCMethodInvocation proxyCall = make.Apply(List.nil(), qualifier, indyArgs);
 proxyCall.type = indyType.getReturnType();
 return proxyCall;
 } finally {
 make.at(prevPos);
-}
-}
-//where
-private List<Type> bsmStaticArgToTypes(List<Object> args) {
-ListBuffer<Type> argtypes = new ListBuffer<>();
-for (Object arg : args) {
-argtypes.append(bsmStaticArgToType(arg));
-}
-return argtypes.toList();
-}
-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;
-}
-}
-/**
-* Get the opcode associated with this method reference
-*/
-private int referenceKind(Symbol refSym) {
-if (refSym.isConstructor()) {
-return ClassFile.REF_newInvokeSpecial;
-} else {
-if (refSym.isStatic()) {
-return ClassFile.REF_invokeStatic;
-} else if ((refSym.flags() & PRIVATE) != 0) {
-return ClassFile.REF_invokeSpecial;
-} else if (refSym.enclClass().isInterface()) {
-return ClassFile.REF_invokeInterface;
-} else {
-return ClassFile.REF_invokeVirtual;
-}
 }
 }
 // <editor-fold defaultstate="collapsed" desc="Lambda/reference analyzer">
 /**
 ReferenceTranslationContext(JCMemberReference tree) {
 super(tree);
 this.isSuper = tree.hasKind(ReferenceKind.SUPER);
 }
-/**
-* Get the opcode associated with this method reference
-*/
-int referenceKind() {
-return LambdaToMethod.this.referenceKind(tree.sym);
-}
 boolean needsVarArgsConversion() {
 return tree.varargsElement != null;
 }
 /**

changeset 54568	b2ed96c35687
parent 53515	a772e65727c5
child 54846	e4049522b074