use ClassValue for caching class-based TypeInfo (mozilla#2255)

Rewrite TypeInfoFactory to provide 2(concurrent/weak) * 2(ClassValue/Map) = 4 factory choices

Improve caching behavior to use ClassValue when available, and fall back on old environments
(like Android < 34) when it is not, and add tests to ensure that.

Author: ZZZank

.github/workflows/android.yml

@@ -14,7 +14,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        api-level: [ 26, 28, 30, 33 ]
+        # oldest supported API level: API 26 (Android 8)
+        # current latest API level: API 34 (Android 14)
+        api-level: [ 26, 28, 30, 34 ]
     name: Rhino Android Tests
     steps:
     - name: Enable KVM

it-android/src/main/assets/tests/live-connect.js

@@ -0,0 +1,23 @@
+/*
+Basic test for several LiveConnect features
+*/
+
+let l = new java.util.ArrayList()
+
+// method
+assertEquals(0, l.size())
+// beaning (.isEmpty())
+assertTrue(l.empty)
+
+// method overload
+l.add("0")
+l.add(0, "1")
+assertEquals(2, l.size())
+assertEquals("1", l.get(0) + '')
+
+let arr = java.lang.reflect.Array.newInstance(java.lang.Byte, 10)
+
+// field
+assertEquals(10, arr.length)
+
+"success"

it-android/src/main/java/org/mozilla/javascript/android/TestCase.java

@@ -22,11 +22,10 @@
  *
  * @author Roland Praml
  */
-public class TestCase {
+public abstract class TestCase {
 
-    private final String name;
-    private final Scriptable global;
-    private final AssetManager assetManager;
+    protected final String name;
+    protected final Scriptable global;
 
     private static final ContextFactory factory =
             new ContextFactory() {
@@ -48,34 +47,49 @@ protected Context makeContext() {
                 }
             };
 
-    public TestCase(String name, Scriptable global, AssetManager assetManager) {
+    public TestCase(String name, Scriptable global) {
         this.name = name;
         this.global = global;
-        this.assetManager = assetManager;
     }
 
     public String run() {
         Context cx = factory.enterContext();
-        try (InputStream in = assetManager.open("tests/" + name);
-                Reader rdr = new InputStreamReader(in, StandardCharsets.UTF_8)) {
-
+        try {
             Scriptable scope = cx.newObject(global);
             scope.setPrototype(global);
             scope.setParentScope(null);
-            Object result = cx.evaluateReader(scope, rdr, name, 1, null);
-            return ScriptRuntime.toString(result);
-        } catch (IOException e) {
-            throw new UncheckedIOException(e);
+            return ScriptRuntime.toString(runTest(cx, scope));
         } finally {
             Context.exit();
         }
     }
 
+    protected abstract Object runTest(Context cx, Scriptable scope);
+
     @Override
     public String toString() {
         return name;
     }
 
+    public static class AssetScript extends TestCase {
+        protected final AssetManager assetManager;
+
+        public AssetScript(String name, Scriptable global, AssetManager assetManager) {
+            super(name, global);
+            this.assetManager = assetManager;
+        }
+
+        @Override
+        protected Object runTest(Context cx, Scriptable scope) {
+            try (InputStream in = assetManager.open("tests/" + name);
+                    Reader rdr = new InputStreamReader(in, StandardCharsets.UTF_8)) {
+                return cx.evaluateReader(scope, rdr, name, 1, null);
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+    }
+
     public static List<TestCase> getTestCases(android.content.Context context) throws IOException {
 
         AssetManager assetManager = context.getAssets();
@@ -95,9 +109,10 @@ public static List<TestCase> getTestCases(android.content.Context context) throw
         List<TestCase> tests = new ArrayList<>();
         if (files != null) {
             for (String file : files) {
-                tests.add(new TestCase(file, global, assetManager));
+                tests.add(new TestCase.AssetScript(file, global, assetManager));
             }
         }
+        tests.add(new TypeInfoFactoryTestCase("TypeInfoFactory", global));
         return tests;
     }
 }

it-android/src/main/java/org/mozilla/javascript/android/TypeInfoFactoryTestCase.java

@@ -0,0 +1,28 @@
+package org.mozilla.javascript.android;
+
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.lc.type.TypeInfoFactory;
+import org.mozilla.javascript.lc.type.impl.factory.ClassValueCacheFactory;
+
+/**
+ * @author ZZZank
+ */
+public class TypeInfoFactoryTestCase extends TestCase {
+    public TypeInfoFactoryTestCase(String name, Scriptable global) {
+        super(name, global);
+    }
+
+    @Override
+    protected Object runTest(Context cx, Scriptable scope) {
+        TypeInfoFactory typeInfoFactory = TypeInfoFactory.get(scope);
+        int apiLevel = android.os.Build.VERSION.SDK_INT;
+        if (apiLevel >= 34 != typeInfoFactory instanceof ClassValueCacheFactory) {
+            throw new IllegalStateException(
+                    String.format(
+                            "ClassValueCacheFactory should be used for modern Android, but got %s on API level %s",
+                            typeInfoFactory, apiLevel));
+        }
+        return "success";
+    }
+}

rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java

@@ -25,7 +25,8 @@
 import org.mozilla.javascript.ast.FunctionNode;
 import org.mozilla.javascript.dtoa.DoubleFormatter;
 import org.mozilla.javascript.lc.type.TypeInfo;
-import org.mozilla.javascript.lc.type.impl.factory.ConcurrentFactory;
+import org.mozilla.javascript.lc.type.impl.factory.ClassValueCacheFactory;
+import org.mozilla.javascript.lc.type.impl.factory.LegacyCacheFactory;
 import org.mozilla.javascript.typedarrays.NativeArrayBuffer;
 import org.mozilla.javascript.typedarrays.NativeBigInt64Array;
 import org.mozilla.javascript.typedarrays.NativeBigUint64Array;
@@ -199,7 +200,11 @@ public static ScriptableObject initSafeStandardObjects(
 
         scope.associateValue(LIBRARY_SCOPE_KEY, scope);
         new ClassCache().associate(scope);
-        new ConcurrentFactory().associate(scope);
+        var typeFactory =
+                (androidApi >= 34 || androidApi < 0)
+                        ? new ClassValueCacheFactory.Concurrent()
+                        : new LegacyCacheFactory.Concurrent();
+        typeFactory.associate(scope);
 
         LambdaConstructor function = BaseFunction.init(cx, scope, sealed);
         JSFunction obj = NativeObject.init(cx, scope, sealed);

rhino/src/main/java/org/mozilla/javascript/lc/type/TypeInfoFactory.java

@@ -23,7 +23,8 @@
 import java.util.function.Supplier;
 import org.mozilla.javascript.Scriptable;
 import org.mozilla.javascript.ScriptableObject;
-import org.mozilla.javascript.lc.type.impl.factory.WeakReferenceFactory;
+import org.mozilla.javascript.lc.type.impl.factory.ClassValueCacheFactory;
+import org.mozilla.javascript.lc.type.impl.factory.LegacyCacheFactory;
 
 /**
  * Factory for {@link TypeInfo}
@@ -54,12 +55,7 @@ public interface TypeInfoFactory extends Serializable {
      * <p>For actions with scope available, the TypeInfoFactory can be obtained via {@link
      * #get(Scriptable)}.
      */
-    TypeInfoFactory GLOBAL =
-            new WeakReferenceFactory() {
-                private Object readResolve() {
-                    return GLOBAL;
-                }
-            };
+    TypeInfoFactory GLOBAL = createGlobalFactory();
 
     TypeInfo[] EMPTY_ARRAY = new TypeInfo[0];
 
@@ -392,4 +388,35 @@ static TypeInfoFactory getOrElse(Scriptable scope, TypeInfoFactory fallback) {
         }
         return got;
     }
+
+    /**
+     * the {@code androidApi} field from {@link org.mozilla.javascript.ScriptRuntime} is not
+     * accessible here, so we detect Android version manually
+     */
+    private static TypeInfoFactory createGlobalFactory() {
+        int androidAPI;
+        try {
+            androidAPI = Class.forName("android.os.Build$VERSION").getField("SDK_INT").getInt(null);
+        } catch (Exception e) {
+            if ("Dalvik".equals(System.getProperty("java.vm.name"))) {
+                androidAPI = 1;
+            } else {
+                androidAPI = -1;
+            }
+        }
+
+        if (androidAPI >= 34 || androidAPI < 0) {
+            // modern Android or not Android
+            return new ClassValueCacheFactory.WeakReference() {
+                private Object readResolve() {
+                    return GLOBAL;
+                }
+            };
+        }
+        return new LegacyCacheFactory.WeakReference() {
+            private Object readResolve() {
+                return GLOBAL;
+            }
+        };
+    }
 }

rhino/src/main/java/org/mozilla/javascript/lc/type/impl/factory/AbstractCacheFactory.java

@@ -0,0 +1,65 @@
+package org.mozilla.javascript.lc.type.impl.factory;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.lang.reflect.TypeVariable;
+import java.util.Map;
+import org.mozilla.javascript.lc.type.TypeInfo;
+import org.mozilla.javascript.lc.type.TypeInfoFactory;
+import org.mozilla.javascript.lc.type.VariableTypeInfo;
+import org.mozilla.javascript.lc.type.impl.VariableTypeInfoImpl;
+
+/**
+ * {@link TypeInfoFactory} implementation with cache. The exact characteristic if the factory
+ * depends on the characteristic of map backend created via {@link #initCache()}
+ *
+ * <p>This factory is serializable, but none of its cached objects will be serialized.
+ *
+ * @author ZZZank
+ */
+public abstract class AbstractCacheFactory implements FactoryBase, CachedFactory {
+    private static final long serialVersionUID = 4533445095188189419L;
+
+    private transient Map<TypeVariable<?>, VariableTypeInfoImpl> variableCache;
+    private transient Map<Class<?>, Map<VariableTypeInfo, TypeInfo>> consolidationMappingCache;
+
+    public AbstractCacheFactory() {
+        initCache();
+    }
+
+    protected void initCache() {
+        variableCache = createCache();
+        consolidationMappingCache = createCache();
+    }
+
+    @Override
+    public TypeInfo create(TypeVariable<?> typeVariable) {
+        return variableCache.computeIfAbsent(
+                typeVariable, raw -> new VariableTypeInfoImpl(raw, this));
+    }
+
+    @Override
+    public Map<VariableTypeInfo, TypeInfo> getConsolidationMapping(Class<?> from) {
+        if (from == null || from == Object.class || from.isPrimitive()) {
+            return Map.of();
+        }
+        // no computeIfAbsent because `computeTypeReplacement(...)` will recursively call this
+        // method again
+        var got = consolidationMappingCache.get(from);
+        if (got == null) {
+            got = computeConsolidationMapping(from);
+            consolidationMappingCache.put(from, got);
+        }
+        return got;
+    }
+
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        out.defaultWriteObject();
+    }
+
+    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+        in.defaultReadObject();
+        initCache();
+    }
+}

rhino/src/main/java/org/mozilla/javascript/lc/type/impl/factory/CachedFactory.java

@@ -0,0 +1,38 @@
+package org.mozilla.javascript.lc.type.impl.factory;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import org.mozilla.javascript.lc.type.TypeInfoFactory;
+
+/**
+ * {@link Concurrent}: provides strong reference, thread-safe, performant cache
+ *
+ * <p>{@link WeakReference}: provides weak reference, thread-safe, less performant cache
+ *
+ * <p>{@link ClassValueCacheFactory} uses {@link ClassValue}, which provides weak reference,
+ * thread-safe, most performant cache. But it's not available on some Android devices, and should
+ * not be created once per instance
+ *
+ * @author ZZZank
+ */
+interface CachedFactory extends TypeInfoFactory {
+    <K, V> Map<K, V> createCache();
+
+    interface Concurrent extends CachedFactory {
+
+        @Override
+        default <K, V> Map<K, V> createCache() {
+            return new ConcurrentHashMap<>();
+        }
+    }
+
+    interface WeakReference extends CachedFactory {
+
+        @Override
+        default <K, V> Map<K, V> createCache() {
+            return Collections.synchronizedMap(new WeakHashMap<>());
+        }
+    }
+}

rhino/src/main/java/org/mozilla/javascript/lc/type/impl/factory/ClassValueCacheFactory.java

@@ -0,0 +1,47 @@
+package org.mozilla.javascript.lc.type.impl.factory;
+
+import org.mozilla.javascript.lc.type.TypeInfo;
+import org.mozilla.javascript.lc.type.TypeInfoFactory;
+import org.mozilla.javascript.lc.type.impl.BasicClassTypeInfo;
+import org.mozilla.javascript.lc.type.impl.EnumTypeInfo;
+import org.mozilla.javascript.lc.type.impl.InterfaceTypeInfo;
+
+/**
+ * {@link ClassValue} is really performant for caching per-class data. However, it's not always
+ * available on Android. When {@link ClassValue} is not available, {@link LegacyCacheFactory} should
+ * be used instead.
+ *
+ * @see LegacyCacheFactory
+ * @author ZZZank
+ */
+public abstract class ClassValueCacheFactory extends AbstractCacheFactory {
+    private static final ClassValue<TypeInfo> CLASS_TYPE =
+            new ClassValue<>() {
+                @Override
+                protected TypeInfo computeValue(Class<?> type) {
+                    if (type.isEnum()) {
+                        return new EnumTypeInfo(type);
+                    } else if (type.isInterface()) {
+                        return new InterfaceTypeInfo(type);
+                    }
+                    return new BasicClassTypeInfo(type);
+                }
+            };
+
+    @Override
+    public TypeInfo create(Class<?> clazz) {
+        final var predefined = TypeInfoFactory.matchPredefined(clazz);
+        if (predefined != null) {
+            return predefined;
+        } else if (clazz.isArray()) {
+            return toArray(create(clazz.getComponentType()));
+        }
+        return CLASS_TYPE.get(clazz);
+    }
+
+    public static class Concurrent extends ClassValueCacheFactory
+            implements CachedFactory.Concurrent {}
+
+    public static class WeakReference extends ClassValueCacheFactory
+            implements CachedFactory.WeakReference {}
+}