Use invokedynamic for structural calls, symbol literals, lamba ser.

The previous encodings created static fields in the enclosing class
to host caches. However, this isn't an option once emit code in default
methods of interfaces, as Java interfaces don't allow private static
fields.

We could continue to emit fields, and make them public when added to
traits.

Or, as chosen in this commit, we can emulate a call-site specific
static field by using invokedynamic: when the call site is linked,
our bootstrap methid can perform one-time computation, and we can
capture the result in the CallSite.

To implement this, I've allowed encoding of arbitrary invokedynamic
calls in ApplyDynamic.

The encoding is:

    ApplyDynamic(
       NoSymbol.newTermSymbol(TermName("methodName")).setInfo(invokedType)
       Literal(Constant(bootstrapMethodSymbol)) :: (
          Literal(Constant(staticArg0)) :: Literal(Constant(staticArgN)) :: Nil
       ) :::
       (dynArg0 :: dynArgN :: Nil)
    )

So far, static args may be `MethodType`, numeric or string literals, or
method symbols, all of which can be converted to constant pool entries.
`MethodTypes` are transformed to the erased JVM type and are converted
to descriptors as String constants.

I've taken advantage of this for symbol literal caching and
for the structural call site cache.

I've also included a test case that shows how a macro could target this
(albeit using private APIs) to cache compiled regexes.

I haven't managed to use this for LambdaMetafactory yet, not sure
if the facility is general enough.

3 files changed, 92 insertions, 0 deletions

diff --git a/src/library/scala/runtime/LambdaDeserialize.java b/src/library/scala/runtime/LambdaDeserialize.java
new file mode 100644
index 0000000000..e239debf25
--- /dev/null
+++ b/src/library/scala/runtime/LambdaDeserialize.java
@@ -0,0 +1,29 @@
+package scala.runtime;
+
+
+import java.lang.invoke.*;
+import java.util.Arrays;
+import java.util.HashMap;
+
+public final class LambdaDeserialize {
+
+    private MethodHandles.Lookup lookup;
+    private final HashMap<String, MethodHandle> cache = new HashMap<>();
+    private final LambdaDeserializer$ l = LambdaDeserializer$.MODULE$;
+
+    private LambdaDeserialize(MethodHandles.Lookup lookup) {
+        this.lookup = lookup;
+    }
+
+    public Object deserializeLambda(SerializedLambda serialized) {
+        return l.deserializeLambda(lookup, cache, serialized);
+    }
+
+    public static CallSite bootstrap(MethodHandles.Lookup lookup, String invokedName,
+                                     MethodType invokedType) throws Throwable {
+        MethodType type = MethodType.fromMethodDescriptorString("(Ljava/lang/invoke/SerializedLambda;)Ljava/lang/Object;", lookup.getClass().getClassLoader());
+        MethodHandle deserializeLambda = lookup.findVirtual(LambdaDeserialize.class, "deserializeLambda", type);
+        MethodHandle exact = deserializeLambda.bindTo(new LambdaDeserialize(lookup)).asType(invokedType);
+        return new ConstantCallSite(exact);
+    }
+}
diff --git a/src/library/scala/runtime/StructuralCallSite.java b/src/library/scala/runtime/StructuralCallSite.java
new file mode 100644
index 0000000000..f73b4f08e6
--- /dev/null
+++ b/src/library/scala/runtime/StructuralCallSite.java
@@ -0,0 +1,43 @@
+package scala.runtime;
+
+
+import java.lang.invoke.*;
+import java.lang.ref.SoftReference;
+import java.lang.reflect.Method;
+
+public final class StructuralCallSite {
+
+    private Class<?>[] parameterTypes;
+    private SoftReference<MethodCache> cache = new SoftReference<>(new EmptyMethodCache());
+
+    private StructuralCallSite(MethodType callType) {
+        parameterTypes = callType.parameterArray();
+    }
+
+    public MethodCache get() {
+        MethodCache cache = this.cache.get();
+        if (cache == null) {
+            cache = new EmptyMethodCache();
+            this.cache = new SoftReference<>(cache);
+        }
+        return cache;
+    }
+
+    public Method find(Class<?> receiver) {
+        return get().find(receiver);
+    }
+
+    public Method add(Class<?> receiver, Method m) {
+        cache = new SoftReference<MethodCache>(get().add(receiver, m));
+        return m;
+    }
+    public Class<?>[] parameterTypes() {
+        return parameterTypes;
+    }
+
+    public static CallSite bootstrap(MethodHandles.Lookup lookup, String invokedName,
+                                     MethodType invokedType, MethodType reflectiveCallType) throws Throwable {
+        StructuralCallSite structuralCallSite = new StructuralCallSite(reflectiveCallType);
+        return new ConstantCallSite(MethodHandles.constant(StructuralCallSite.class, structuralCallSite));
+    }
+}
diff --git a/src/library/scala/runtime/SymbolLiteral.java b/src/library/scala/runtime/SymbolLiteral.java
new file mode 100644
index 0000000000..09a66c83d5
--- /dev/null
+++ b/src/library/scala/runtime/SymbolLiteral.java
@@ -0,0 +1,20 @@
+package scala.runtime;
+
+import java.lang.invoke.*;
+import java.util.regex.Pattern;
+
+public final class SymbolLiteral {
+    private SymbolLiteral() {
+    }
+
+    public static CallSite bootstrap(MethodHandles.Lookup lookup, String invokedName,
+                                     MethodType invokedType,
+                                     String value) throws Throwable {
+        ClassLoader classLoader = lookup.lookupClass().getClassLoader();
+        MethodType type = MethodType.fromMethodDescriptorString("(Ljava/lang/Object;)Ljava/lang/Object;", classLoader);
+        Class<?> symbolClass = Class.forName("scala.Symbol", false, classLoader);
+        MethodHandle factoryMethod = lookup.findStatic(symbolClass, "apply", type);
+        Object symbolValue = factoryMethod.invokeWithArguments(value);
+        return new ConstantCallSite(MethodHandles.constant(symbolClass, symbolValue));
+    }
+}