Add MethodOrPoly#isSignature(isJava) overload

This makes it possible to compute the Java or Scala signature of a
method, regardless of whether it was defined as a JavaMethod or not.
Because there's nothing left that is shareable, this required removing
SignatureCachingType and duplicating the signature caching logic between
MethodOrPoly and NamedType.

This commit itself does not change any semantics, but this new method
will be useful for the next commit.

Author: smarter

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1999,7 +1999,7 @@ object Types {
 
 // --- NamedTypes ------------------------------------------------------------------
 
-  abstract class NamedType extends CachedProxyType with ValueType with SignatureCachingType { self =>
+  abstract class NamedType extends CachedProxyType with ValueType { self =>
 
     type ThisType >: this.type <: NamedType
     type ThisName <: Name
@@ -2015,11 +2015,13 @@ object Types {
     private var lastSymbol: Symbol = null
     private var checkedPeriod: Period = Nowhere
     private var myStableHash: Byte = 0
+    private var mySignature: Signature = _
+    private var mySignatureRunId: Int = NoRunId
 
     // Invariants:
-    // (1) checkedPeriod != Nowhere  =>  lastDenotation != null
-    // (2) lastDenotation != null    =>  lastSymbol != null
-    // (3) mySigRunId != NoRunId     =>  mySig != null
+    // (1) checkedPeriod != Nowhere     =>  lastDenotation != null
+    // (2) lastDenotation != null       =>  lastSymbol != null
+    // (3) mySignatureRunId != NoRunId  =>  mySignature != null
 
     def isType: Boolean = isInstanceOf[TypeRef]
     def isTerm: Boolean = isInstanceOf[TermRef]
@@ -2037,15 +2039,22 @@ object Types {
       case sym: Symbol => sym.originDenotation.name
     }
 
-    /** The signature computed from the last known denotation with `sigFromDenot`,
-     *  or if there is none, the signature of the symbol. Signatures are always
-     *  computed before erasure, since some symbols change their signature at erasure.
-     */
-    protected[dotc] def computeSignature(using Context): Signature =
-      val lastd = lastDenotation
-      if lastd != null then sigFromDenot(lastd)
-      else if ctx.erasedTypes then atPhase(erasurePhase)(computeSignature)
-      else symbol.asSeenFrom(prefix).signature
+    final override def signature(using Context): Signature =
+      /** The signature computed from the last known denotation with `sigFromDenot`,
+       *  or if there is none, the signature of the symbol. Signatures are always
+       *  computed before erasure, since some symbols change their signature at erasure.
+       */
+      def computeSignature(using Context): Signature =
+        val lastd = lastDenotation
+        if lastd != null then sigFromDenot(lastd)
+        else if ctx.erasedTypes then atPhase(erasurePhase)(computeSignature)
+        else symbol.asSeenFrom(prefix).signature
+
+      if ctx.runId != mySignatureRunId then
+        mySignature = computeSignature
+        if !mySignature.isUnderDefined then mySignatureRunId = ctx.runId
+      mySignature
+    end signature
 
     /** The signature computed from the current denotation with `sigFromDenot` if it is
      *  known without forcing.
@@ -3219,39 +3228,11 @@ object Types {
   // is that most poly types are cyclic via poly params,
   // and therefore two different poly types would never be equal.
 
-  /** A trait that mixes in functionality for signature caching */
-  trait SignatureCachingType extends TermType {
-    protected var mySignature: Signature = _
-    protected var mySignatureRunId: Int = NoRunId
-
-    protected[dotc] def computeSignature(using Context): Signature
-
-    final override def signature(using Context): Signature = {
-      if (ctx.runId != mySignatureRunId) {
-        mySignature = computeSignature
-        if (!mySignature.isUnderDefined) mySignatureRunId = ctx.runId
-      }
-      mySignature
-    }
-  }
-
-  trait MethodicType extends TermType {
-    protected def resultSignature(using Context): Signature = try resultType match {
-      case rtp: MethodicType => rtp.signature
-      case tp =>
-        if (tp.isRef(defn.UnitClass)) Signature(Nil, defn.UnitClass.fullName.asTypeName)
-        else Signature(tp, isJava = false)
-    }
-    catch {
-      case ex: AssertionError =>
-        println(i"failure while taking result signature of $this: $resultType")
-        throw ex
-    }
-  }
+  trait MethodicType extends TermType
 
   /** A by-name parameter type of the form `=> T`, or the type of a method with no parameter list. */
   abstract case class ExprType(resType: Type)
-  extends CachedProxyType with TermType with MethodicType {
+  extends CachedProxyType with MethodicType {
     override def resultType(using Context): Type = resType
     override def underlying(using Context): Type = resType
 
@@ -3371,7 +3352,58 @@ object Types {
     final override def equals(that: Any): Boolean = equals(that, null)
   }
 
-  abstract class MethodOrPoly extends UncachedGroundType with LambdaType with MethodicType with SignatureCachingType {
+  /** The superclass of MethodType and PolyType. */
+  sealed abstract class MethodOrPoly extends UncachedGroundType with LambdaType with MethodicType {
+
+    // Invariants:
+    // (1) mySignatureRunId != NoRunId      =>  mySignature != null
+    // (2) myJavaSignatureRunId != NoRunId  =>  myJavaSignature != null
+
+    private var mySignature: Signature = _
+    private var mySignatureRunId: Int = NoRunId
+    private var myJavaSignature: Signature = _
+    private var myJavaSignatureRunId: Int = NoRunId
+
+    /** If `isJava` is false, the Scala signature of this method.
+     *  Otherwise, the signature of this method assuming it is part
+     *  of a Java class. This distinction is needed because
+     *  the same method type might be part of both a Java and Scala
+     *  class and each language has different type erasure rules.
+     */
+    def signature(isJava: Boolean)(using Context): Signature =
+      def computeSignature(isJava: Boolean)(using Context): Signature =
+        val resultSignature = resultType match
+          case tp: MethodOrPoly => tp.signature(isJava)
+          case tp: ExprType => tp.signature
+          case tp =>
+            if tp.isRef(defn.UnitClass) then Signature(Nil, defn.UnitClass.fullName.asTypeName)
+            else Signature(tp, isJava = false)
+        this match
+          case tp: MethodType =>
+            val params = if (isErasedMethod) Nil else tp.paramInfos
+            resultSignature.prependTermParams(params, isJava)
+          case tp: PolyType =>
+            resultSignature.prependTypeParams(tp.paramNames.length)
+
+      if isJava then
+        if ctx.runId != myJavaSignatureRunId then
+          myJavaSignature = computeSignature(isJava)
+          if !myJavaSignature.isUnderDefined then myJavaSignatureRunId = ctx.runId
+        myJavaSignature
+      else
+        if ctx.runId != mySignatureRunId then
+          mySignature = computeSignature(isJava)
+          if !mySignature.isUnderDefined then mySignatureRunId = ctx.runId
+        mySignature
+    end signature
+
+    final override def signature(using Context): Signature =
+      def isJava(tp: Type): Boolean = tp match
+        case tp: PolyType => isJava(tp.resultType)
+        case tp: MethodType => tp.isJavaMethod
+        case _ => false
+      signature(isJava = isJava(this))
+
     final override def hashCode: Int = System.identityHashCode(this)
 
     final override def equals(that: Any): Boolean = equals(that, null)
@@ -3531,11 +3563,6 @@ object Types {
       companion.eq(ContextualMethodType) ||
       companion.eq(ErasedContextualMethodType)
 
-    protected[dotc] def computeSignature(using Context): Signature = {
-      val params = if (isErasedMethod) Nil else paramInfos
-      resultSignature.prependTermParams(params, isJavaMethod)
-    }
-
     protected def prefixString: String = companion.prefixString
   }
 
@@ -3766,9 +3793,6 @@ object Types {
     assert(resType.isInstanceOf[TermType], this)
     assert(paramNames.nonEmpty)
 
-    protected[dotc] def computeSignature(using Context): Signature =
-      resultSignature.prependTypeParams(paramNames.length)
-
     override def isContextualMethod = resType.isContextualMethod
     override def isImplicitMethod = resType.isImplicitMethod
 

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -90,22 +90,14 @@ class TreeChecker extends Phase with SymTransformer {
     // Signatures are used to disambiguate overloads and need to stay stable
     // until erasure, see the comment above `Compiler#phases`.
     if (ctx.phaseId <= erasurePhase.id) {
-      val cur = symd.info
-      val initial = symd.initial.info
-      val curSig = cur match {
-        case cur: SignatureCachingType =>
-          // Bypass the signature cache, it might hide a signature change
-          cur.computeSignature
-        case _ =>
-          cur.signature
-      }
-      assert(curSig == initial.signature,
+      val initial = symd.initial
+      assert(symd.signature == initial.signature,
         i"""Signature of ${sym.showLocated} changed at phase ${ctx.base.fusedContaining(ctx.phase.prev)}
-           |Initial info: ${initial}
+           |Initial info: ${initial.info}
+           |Init pre: ${initial.prefix.toString}
            |Initial sig : ${initial.signature}
-           |Current info: ${cur}
-           |Current sig : ${curSig}
-           |Current cached sig: ${cur.signature}""")
+           |Current info: ${symd.info}
+           |Current sig : ${symd.signature}""")
     }
 
     symd