Don't recompute symbols per run

Author: odersky

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

@@ -260,7 +260,7 @@ object Erasure {
         case (JavaArrayType(treeElem), JavaArrayType(ptElem))
         if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType =>
           // See SI-2386 for one example of when this might be necessary.
-          cast(ref(defn.runtimeMethodRef(nme.toObjectArray)).appliedTo(tree), pt)
+          cast(ref(defn.runtimeMethod(nme.toObjectArray)).appliedTo(tree), pt)
 
         // When casting between two EVTs, we need to check which one underlies the other to determine
         // whether u2evt or evt2u should be used.
@@ -507,9 +507,9 @@ object Erasure {
       }
 
     private def runtimeCallWithProtoArgs(name: Name, pt: Type, args: Tree*)(implicit ctx: Context): Tree = {
-      val meth = defn.runtimeMethodRef(name)
-      val followingParams = meth.symbol.info.firstParamTypes.drop(args.length)
-      val followingArgs = protoArgs(pt, meth.widen).zipWithConserve(followingParams)(typedExpr).asInstanceOf[List[tpd.Tree]]
+      val meth = defn.runtimeMethod(name)
+      val followingParams = meth.info.firstParamTypes.drop(args.length)
+      val followingArgs = protoArgs(pt, meth.info).zipWithConserve(followingParams)(typedExpr).asInstanceOf[List[tpd.Tree]]
       ref(meth).appliedToArgs(args.toList ++ followingArgs)
     }
 

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

@@ -208,7 +208,7 @@ object GenericSignatures {
           else if (sym == defn.NothingClass)
             jsig(defn.RuntimeNothingModuleRef)
           else if (sym == defn.NullClass)
-            jsig(defn.RuntimeNullModuleRef)
+            jsig(defn.RuntimeNullModule.termRef)
           else if (sym.isPrimitiveValueClass) {
             if (!primitiveOK) jsig(defn.ObjectType)
             else if (sym == defn.UnitClass) jsig(defn.BoxedUnitClass.typeRef)

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

@@ -53,7 +53,7 @@ class InterceptedMethods extends MiniPhase {
     val s = tree.tpe.widen.typeSymbol
 
     def staticsCall(methodName: TermName): Tree =
-      ref(defn.staticsMethodRef(methodName)).appliedTo(tree)
+      ref(defn.staticsMethod(methodName)).appliedTo(tree)
 
     if (s == defn.NullClass) Literal(Constant(0))
     else if (s == defn.DoubleClass) staticsCall(nme.doubleHash)

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

@@ -112,7 +112,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
         coord = clazz.coord).enteredAfter(thisPhase).asTerm
 
       def forwardToRuntime(vrefs: List[Tree]): Tree =
-        ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefs)
+        ref(defn.runtimeMethod("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefs)
 
       def ownName: Tree =
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString))

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

@@ -286,7 +286,7 @@ object TypeTestsCasts {
             }
           case defn.MultiArrayOf(elem, ndims) if isUnboundedGeneric(elem) =>
             def isArrayTest(arg: Tree) =
-              ref(defn.runtimeMethodRef(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
+              ref(defn.runtimeMethod(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
             if (ndims == 1) isArrayTest(expr)
             else evalOnce(expr) { e =>
               derivedTree(e, defn.Any_isInstanceOf, e.tpe)

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

@@ -21,3 +21,6 @@ matchtype.scala
 
 # Opaque type
 i5720.scala
+
+# Redefines types in the Scala package
+seqtype-cycle