Don't recompute symbols per run

Author: odersky

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

@@ -335,16 +335,10 @@ object Denotations {
       val name = pname.toTypeName
       info.member(name).requiredSymbol("class", name, this)(_.isClass).asClass
     }
-    def requiredClassRef(pname: PreName)(implicit ctx: Context): TypeRef =
-      requiredClass(pname).typeRef
-
     def requiredType(pname: PreName)(implicit ctx: Context): TypeSymbol = {
       val name = pname.toTypeName
       info.member(name).requiredSymbol("type", name, this)(_.isType).asType
     }
-    def requiredTypeRef(pname: PreName)(implicit ctx: Context): TypeRef =
-      requiredType(pname).typeRef
-
 
     /** The alternative of this denotation that has a type matching `targetType` when seen
      *  as a member of type `site`, `NoDenotation` if none exists.

compiler/src/dotty/tools/dotc/core/Denotations.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

@@ -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

@@ -35,9 +35,9 @@ trait QuotesAndSplices { self: Typer =>
    *  while tracking the quotation level in the context.
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = track("typedQuote") {
-    val qctx = inferImplicitArg(defn.QuoteContextType, tree.span)
+    val qctx = inferImplicitArg(defn.QuoteContextClass.typeRef, tree.span)
     if (level == 0 && qctx.tpe.isInstanceOf[SearchFailureType])
-      ctx.error(missingArgMsg(qctx, defn.QuoteContextType, ""), ctx.source.atSpan(tree.span))
+      ctx.error(missingArgMsg(qctx, defn.QuoteContextClass.typeRef, ""), ctx.source.atSpan(tree.span))
 
     tree.quoted match {
       case untpd.Splice(innerExpr) if tree.isTerm =>
@@ -49,9 +49,9 @@ trait QuotesAndSplices { self: Typer =>
       case quoted =>
         ctx.compilationUnit.needsStaging = true
         val tree1 =
-          if (quoted.isType) typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuoteR), quoted :: Nil), pt)(quoteContext)
+          if (quoted.isType) typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuote.termRef), quoted :: Nil), pt)(quoteContext)
           else if (ctx.mode.is(Mode.Pattern) && level == 0) typedQuotePattern(quoted, pt, qctx)
-          else typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuoteR), quoted), pt)(quoteContext)
+          else typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuote.termRef), quoted), pt)(quoteContext)
         tree1.withSpan(tree.span)
     }
   }
@@ -69,7 +69,7 @@ trait QuotesAndSplices { self: Typer =>
           if (isFullyDefined(pt, ForceDegree.all)) {
             def spliceOwner(ctx: Context): Symbol =
               if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
-            val pat = typedPattern(expr, defn.QuotedExprType.appliedTo(pt))(
+            val pat = typedPattern(expr, defn.QuotedExprClass.typeRef.appliedTo(pt))(
               spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
             Splice(pat)
           } else {
@@ -86,7 +86,7 @@ trait QuotesAndSplices { self: Typer =>
               else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
             markAsMacro(ctx)
           }
-          typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSpliceR), tree.expr), pt)(spliceContext).withSpan(tree.span)
+          typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSplice.termRef), tree.expr), pt)(spliceContext).withSpan(tree.span)
         }
     }
   }
@@ -115,7 +115,7 @@ trait QuotesAndSplices { self: Typer =>
             }
             val typeSym = ctx.newSymbol(spliceOwner(ctx), name, EmptyFlags, TypeBounds.empty, NoSymbol, expr.span)
             typeSym.addAnnotation(Annotation(New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(expr.span)))
-            val pat = typedPattern(expr, defn.QuotedTypeType.appliedTo(typeSym.typeRef))(
+            val pat = typedPattern(expr, defn.QuotedTypeClass.typeRef.appliedTo(typeSym.typeRef))(
                 spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
             pat.select(tpnme.splice)
           }
@@ -175,10 +175,10 @@ trait QuotesAndSplices { self: Typer =>
       override def transform(tree: Tree)(implicit ctx: Context) = tree match {
         case Typed(Splice(pat), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
           val tpt1 = transform(tpt) // Transform type bindings
-          val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprType), tpt1 :: Nil)
+          val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprClass.typeRef), tpt1 :: Nil)
           transform(Splice(Typed(pat, exprTpt)))
         case Splice(pat) =>
-          try ref(defn.InternalQuoted_patternHoleR).appliedToType(tree.tpe).withSpan(tree.span)
+          try ref(defn.InternalQuoted_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
             val patType1 = patType.underlyingIfRepeated(isJava = false)
@@ -202,7 +202,7 @@ trait QuotesAndSplices { self: Typer =>
                     x => t.resType.subst(t, x).toFunctionType())
               case t => t
             }
-            val bindingExprTpe = AppliedType(defn.QuotedMatchingBindingType, bindingType :: Nil)
+            val bindingExprTpe = AppliedType(defn.QuotedMatchingBindingClass.typeRef, bindingType :: Nil)
             assert(ddef.name.startsWith("$"))
             val bindName = ddef.name.toString.stripPrefix("$").toTermName
             val sym = ctx0.newPatternBoundSymbol(bindName, bindingExprTpe, ddef.span)
@@ -217,7 +217,7 @@ trait QuotesAndSplices { self: Typer =>
 
       def transformTypeBindingTypeDef(tdef: TypeDef, buff: mutable.Builder[Tree, List[Tree]]): Tree = {
         val bindingType = getBinding(tdef.symbol).symbol.typeRef
-        val bindingTypeTpe = AppliedType(defn.QuotedTypeType, bindingType :: Nil)
+        val bindingTypeTpe = AppliedType(defn.QuotedTypeClass.typeRef, bindingType :: Nil)
         assert(tdef.name.startsWith("$"))
         val bindName = tdef.name.toString.stripPrefix("$").toTermName
         val sym = ctx0.newPatternBoundSymbol(bindName, bindingTypeTpe, tdef.span, flags = ImplicitTerm)
@@ -347,13 +347,13 @@ trait QuotesAndSplices { self: Typer =>
     val splicePat = typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
 
     UnApply(
-      fun = ref(defn.InternalQuotedMatcher_unapplyR).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
+      fun = ref(defn.InternalQuotedMatcher_unapply.termRef).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
       implicits =
-        ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) ::
+        ref(defn.InternalQuoted_exprQuote.termRef).appliedToType(shape.tpe).appliedTo(shape) ::
           Literal(Constant(typeBindings.nonEmpty)) ::
           qctx :: Nil,
       patterns = splicePat :: Nil,
-      proto = defn.QuotedExprType.appliedTo(replaceBindings(quoted1.tpe) & quotedPt))
+      proto = defn.QuotedExprClass.typeRef.appliedTo(replaceBindings(quoted1.tpe) & quotedPt))
   }
 
 }