ClassValueCompat to support systems without java.lang.ClassValue

scala · Sep 17, 2021 · 272907f · 272907f
1 parent 7d7daa6
commit 272907f
Show file tree

Hide file tree

Showing 6 changed files with 115 additions and 7 deletions.
diff --git a/project/MimaFilters.scala b/project/MimaFilters.scala
@@ -78,6 +78,15 @@ object MimaFilters extends AutoPlugin {
 
     // #9741
     ProblemFilters.exclude[MissingClassProblem]("scala.collection.immutable.SeqMap$SeqMapBuilderImpl"), // private[SeqMap]
+
+    // #9752
+    ProblemFilters.exclude[MissingTypesProblem]("scala.reflect.ClassTag$cache$"),
+    ProblemFilters.exclude[MissingTypesProblem]("scala.reflect.runtime.JavaMirrors$JavaMirror$typeTagCache$"),
+    ProblemFilters.exclude[MissingTypesProblem]("scala.reflect.runtime.JavaMirrors$JavaMirror$typeTagCache$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.compat.ClassValueCompat"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.compat.ClassValueCompat$ClassValueInterface"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.compat.ClassValueCompat$JavaClassValue"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.compat.ClassValueCompat$FallbackClassValue"),
   )
 
   override val buildSettings = Seq(

diff --git a/src/library/scala/compat/ClassValueCompat.scala b/src/library/scala/compat/ClassValueCompat.scala
@@ -0,0 +1,47 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.compat
+
+import scala.util.Try
+
+private[scala] abstract class ClassValueCompat[T] {
+
+  private def checkClassValueAvailability(): Boolean = Try {
+    Class.forName("java.lang.ClassValue", false, getClass.getClassLoader)
+    true
+  }.getOrElse(false)
+
+  private val instance = if (checkClassValueAvailability()) new JavaClassValue() else new FallbackClassValue()
+
+  private class JavaClassValue extends ClassValue[T] with ClassValueInterface {
+    override def computeValue(`type`: Class[_]): T = ClassValueCompat.this.computeValue(`type`)
+  }
+
+  private class FallbackClassValue extends ClassValueInterface {
+    override def get(param1Class: Class[_]): T = ClassValueCompat.this.get(param1Class)
+
+    override def remove(param1Class: Class[_]): Unit = {}
+  }
+
+  private trait ClassValueInterface {
+    def get(param1Class: Class[_]): T
+    def remove(param1Class: Class[_]): Unit
+  }
+
+  def get(`type`: Class[_]): T = instance.get(`type`)
+
+  def remove(`type`: Class[_]): Unit = instance.remove(`type`)
+
+  protected def computeValue(`type`: Class[_]): T
+
+}
diff --git a/src/library/scala/reflect/ClassTag.scala b/src/library/scala/reflect/ClassTag.scala
@@ -15,8 +15,8 @@ package reflect
 
 import java.lang.{Class => jClass}
 import java.lang.ref.{WeakReference => jWeakReference}
-
 import scala.annotation.{implicitNotFound, nowarn}
+import scala.compat.ClassValueCompat
 
 /**
  *
@@ -116,7 +116,7 @@ object ClassTag {
   val Null    : ClassTag[scala.Null]       = Manifest.Null
 
   private val cacheDisabled = java.lang.Boolean.getBoolean("scala.reflect.classtag.cache.disable")
-  private[this] object cache extends ClassValue[jWeakReference[ClassTag[_]]] {
+  private[this] object cache extends ClassValueCompat[jWeakReference[ClassTag[_]]] {
     override def computeValue(runtimeClass: jClass[_]): jWeakReference[ClassTag[_]] =
       new jWeakReference(computeTag(runtimeClass))
 

diff --git a/src/library/scala/runtime/ModuleSerializationProxy.java b/src/library/scala/runtime/ModuleSerializationProxy.java
@@ -15,14 +15,12 @@
 import java.io.Serializable;
 import java.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
-import java.util.HashSet;
-import java.util.Set;
 
 /** A serialization proxy for singleton objects */
 public final class ModuleSerializationProxy implements Serializable {
     private static final long serialVersionUID = 1L;
     private final Class<?> moduleClass;
-    private static final ClassValue<Object> instances = new ClassValue<Object>() {
+    private static final ClassValueCompat<Object> instances = new ClassValueCompat<Object>() {
         @Override
         @SuppressWarnings("removal")  // JDK 17 deprecates AccessController
         protected Object computeValue(Class<?> type) {
@@ -48,4 +46,56 @@ public ModuleSerializationProxy(Class<?> moduleClass) {
     private Object readResolve() {
         return instances.get(moduleClass);
     }
+
+    private static boolean checkClassValueAvailability() {
+        try {
+            Class.forName("java.lang.ClassValue", false, Object.class.getClassLoader());
+            return true;
+        } catch (ClassNotFoundException e) {
+            return false;
+        }
+    }
+
+    private interface ClassValueInterface<T> {
+        T get(Class<?> param1Class);
+
+        void remove(Class<?> param1Class);
+    }
+
+    private abstract static class ClassValueCompat<T> {
+
+        private final ClassValueInterface<T> instance;
+
+        protected ClassValueCompat() {
+            instance = checkClassValueAvailability() ? new JavaClassValue() : new FallbackClassValue();
+        }
+
+        private class JavaClassValue extends ClassValue<T> implements ClassValueInterface<T> {
+            @Override
+            protected T computeValue(Class<?> aClass) {
+                return ClassValueCompat.this.computeValue(aClass);
+            }
+        }
+
+        private class FallbackClassValue implements ClassValueInterface<T> {
+            @Override
+            public T get(Class<?> type) {
+                return ClassValueCompat.this.computeValue(type);
+            }
+
+            @Override
+            public void remove(Class<?> type) {}
+        }
+
+        protected abstract T computeValue(Class<?> type);
+
+        public T get(Class<?> type) {
+            return instance.get(type);
+        }
+
+        public void remove(Class<?> type) {
+            instance.remove(type);
+        }
+
+    }
 }
diff --git a/src/reflect/scala/reflect/macros/Attachments.scala b/src/reflect/scala/reflect/macros/Attachments.scala
@@ -15,6 +15,7 @@ package reflect
 package macros
 
 import reflect.internal.util.Position
+import scala.compat.ClassValueCompat
 
 /**
  * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
@@ -109,7 +110,7 @@ abstract class Attachments { self =>
 }
 
 private object Attachments {
-  private val matchesTagCache = new ClassValue[Function1[Any, Boolean]] {
+  private val matchesTagCache = new ClassValueCompat[Function1[Any, Boolean]] {
     override def computeValue(cls: Class[_]): Function[Any, Boolean] = cls.isInstance(_)
   }
 }

diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -37,6 +37,7 @@ import scala.collection.mutable.ListBuffer
 import internal.Flags._
 import ReflectionUtils._
 import scala.annotation.nowarn
+import scala.compat.ClassValueCompat
 import scala.reflect.api.TypeCreator
 import scala.runtime.{ BoxesRunTime, ScalaRunTime }
 
@@ -120,7 +121,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
     private[this] val fieldCache       = new TwoWayCache[jField, TermSymbol]
     private[this] val tparamCache      = new TwoWayCache[jTypeVariable[_ <: GenericDeclaration], TypeSymbol]
 
-    private[this] object typeTagCache extends ClassValue[jWeakReference[TypeTag[_]]]() {
+    private[this] object typeTagCache extends ClassValueCompat[jWeakReference[TypeTag[_]]]() {
       val typeCreator = new ThreadLocal[TypeCreator]()
 
       override protected def computeValue(cls: jClass[_]): jWeakReference[TypeTag[_]] = {