Rename ImplicitDef -> ImplicitRef

Author: odersky

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

@@ -201,7 +201,7 @@ object Contexts {
     def implicits: ContextualImplicits = {
       if (implicitsCache == null )
         implicitsCache = {
-          val implicitRefs: List[ImplicitDef] =
+          val implicitRefs: List[ImplicitRef] =
             if (isClassDefContext)
               try owner.thisType.implicitMembers
               catch {

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

@@ -1964,15 +1964,15 @@ object Types {
   }
 
   /** A reference to an implicit definition. This can be either a TermRef or a
-   *  Implicits.RenamedImplicitDef.
+   *  Implicits.RenamedImplicitRef.
    */
-  trait ImplicitDef {
+  trait ImplicitRef {
     def implicitName(implicit ctx: Context): TermName
-    def implicitRef: TermRef
+    def underlyingRef: TermRef
   }
 
   abstract case class TermRef(override val prefix: Type, var designator: Designator)
-  extends NamedType with SingletonType with ImplicitDef {
+  extends NamedType with SingletonType with ImplicitRef {
 
     type ThisType = TermRef
     type ThisName = TermName
@@ -1992,7 +1992,7 @@ object Types {
       denot.altsWith(p).map(withDenot(_))
 
     def implicitName(implicit ctx: Context): TermName = name
-    def implicitRef = this
+    def underlyingRef = this
   }
 
   abstract case class TypeRef(override val prefix: Type, var designator: Designator) extends NamedType {

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -48,13 +48,13 @@ object Implicits {
   /** An implicit definition `implicitRef` that is visible under a different name, `alias`.
    *  Gets generated if an implicit ref is imported via a renaming import.
    */
-  class RenamedImplicitDef(val implicitRef: TermRef, val alias: TermName) extends ImplicitDef {
+  class RenamedImplicitRef(val underlyingRef: TermRef, val alias: TermName) extends ImplicitRef {
     def implicitName(implicit ctx: Context): TermName = alias
   }
 
   /** An eligible implicit candidate, consisting of an implicit reference and a nesting level */
-  case class Candidate(implicitDef: ImplicitDef, level: Int) {
-    def ref: TermRef = implicitDef.implicitRef
+  case class Candidate(implicitRef: ImplicitRef, level: Int) {
+    def ref: TermRef = implicitRef.underlyingRef
   }
 
   /** A common base class of contextual implicits and of-type implicits which
@@ -68,7 +68,7 @@ object Implicits {
     def level: Int = 0
 
     /** The implicit references */
-    def refs: List[ImplicitDef]
+    def refs: List[ImplicitRef]
 
     /** Return those references in `refs` that are compatible with type `pt`. */
     protected def filterMatching(pt: Type)(implicit ctx: Context): List[Candidate] = track("filterMatching") {
@@ -147,7 +147,7 @@ object Implicits {
       else {
         val nestedCtx = ctx.fresh.addMode(Mode.TypevarsMissContext)
         refs
-          .filter(ref => nestedCtx.typerState.test(refMatches(ref.implicitRef)(nestedCtx)))
+          .filter(ref => nestedCtx.typerState.test(refMatches(ref.underlyingRef)(nestedCtx)))
           .map(Candidate(_, level))
       }
     }
@@ -159,7 +159,7 @@ object Implicits {
    */
   class OfTypeImplicits(tp: Type, val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
     assert(initctx.typer != null)
-    lazy val refs: List[ImplicitDef] = {
+    lazy val refs: List[ImplicitRef] = {
       val buf = new mutable.ListBuffer[TermRef]
       for (companion <- companionRefs) buf ++= companion.implicitMembers
       buf.toList
@@ -185,7 +185,7 @@ object Implicits {
    *                   name, b, whereas the name of the symbol is the original name, a.
    *  @param outerCtx  the next outer context that makes visible further implicits
    */
-  class ContextualImplicits(val refs: List[ImplicitDef], val outerImplicits: ContextualImplicits)(initctx: Context) extends ImplicitRefs(initctx) {
+  class ContextualImplicits(val refs: List[ImplicitRef], val outerImplicits: ContextualImplicits)(initctx: Context) extends ImplicitRefs(initctx) {
     private val eligibleCache = new mutable.AnyRefMap[Type, List[Candidate]]
 
     /** The level increases if current context has a different owner or scope than
@@ -827,7 +827,7 @@ trait Implicits { self: Typer =>
             pt)
         val generated1 = adapt(generated, pt)
         lazy val shadowing =
-          typed(untpd.Ident(cand.implicitDef.implicitName) withPos pos.toSynthetic, funProto)(
+          typed(untpd.Ident(cand.implicitRef.implicitName) withPos pos.toSynthetic, funProto)(
             nestedContext().addMode(Mode.ImplicitShadowing).setExploreTyperState())
         def refSameAs(shadowing: Tree): Boolean =
           ref.symbol == closureBody(shadowing).symbol || {

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -9,7 +9,7 @@ import printing.{Printer, Showable}
 import util.SimpleIdentityMap
 import Symbols._, Names._, Denotations._, Types._, Contexts._, StdNames._, Flags._
 import Decorators.StringInterpolators
-import Implicits.RenamedImplicitDef
+import Implicits.RenamedImplicitRef
 
 object ImportInfo {
   /** The import info for a root import from given symbol `sym` */
@@ -93,7 +93,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
   }
 
   /** The implicit references imported by this import clause */
-  def importedImplicits(implicit ctx: Context): List[ImplicitDef] = {
+  def importedImplicits(implicit ctx: Context): List[ImplicitRef] = {
     val pre = site
     if (isWildcardImport) {
       val refs = pre.implicitMembers
@@ -107,7 +107,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
         val original = reverseMapping(renamed)
         val ref = TermRef(pre, original, denot)
         if (renamed == original) ref
-        else new RenamedImplicitDef(ref, renamed)
+        else new RenamedImplicitRef(ref, renamed)
       }
   }