Rename Implied -> Delegate

Todo: Should do the same in Tasty reflect

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -174,7 +174,7 @@ object desugar {
         vparamss = (setterParam :: Nil) :: Nil,
         tpt      = TypeTree(defn.UnitType),
         rhs      = setterRhs
-      ).withMods((mods | Accessor) &~ (CaseAccessor | ImplicitOrGiven | Lazy))
+      ).withMods((mods | Accessor) &~ (CaseAccessor | GivenOrImplicit | Lazy))
       Thicket(vdef, setter)
     }
     else vdef
@@ -323,7 +323,7 @@ object desugar {
         meth
       case evidenceParams =>
         val vparamss1 = meth.vparamss.reverse match {
-          case (vparams @ (vparam :: _)) :: rvparamss if vparam.mods.isOneOf(ImplicitOrGiven) =>
+          case (vparams @ (vparam :: _)) :: rvparamss if vparam.mods.isOneOf(GivenOrImplicit) =>
             ((evidenceParams ++ vparams) :: rvparamss).reverse
           case _ =>
             meth.vparamss :+ evidenceParams
@@ -334,7 +334,7 @@ object desugar {
   /** The implicit evidence parameters of `meth`, as generated by `desugar.defDef` */
   private def evidenceParams(meth: DefDef)(implicit ctx: Context): List[ValDef] =
     meth.vparamss.reverse match {
-      case (vparams @ (vparam :: _)) :: _ if vparam.mods.isOneOf(ImplicitOrGiven) =>
+      case (vparams @ (vparam :: _)) :: _ if vparam.mods.isOneOf(GivenOrImplicit) =>
         vparams.dropWhile(!_.name.is(EvidenceParamName))
       case _ =>
         Nil
@@ -345,7 +345,7 @@ object desugar {
   private def toDefParam(tparam: TypeDef): TypeDef =
     tparam.withMods(tparam.rawMods & EmptyFlags | Param)
   private def toDefParam(vparam: ValDef): ValDef =
-    vparam.withMods(vparam.rawMods & (ImplicitOrGiven | Erased) | Param)
+    vparam.withMods(vparam.rawMods & (GivenOrImplicit | Erased) | Param)
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
@@ -413,7 +413,7 @@ object desugar {
         if (isCaseClass && originalTparams.isEmpty)
           ctx.error(CaseClassMissingParamList(cdef), namePos)
         ListOfNil
-      } else if (isCaseClass && originalVparamss.head.exists(_.mods.isOneOf(ImplicitOrGiven))) {
+      } else if (isCaseClass && originalVparamss.head.exists(_.mods.isOneOf(GivenOrImplicit))) {
           ctx.error("Case classes should have a non-implicit parameter list", namePos)
         ListOfNil
       }
@@ -444,7 +444,7 @@ object desugar {
         if (enumCases.isEmpty)
           ctx.error("Enumerations must constain at least one case", namePos)
         val enumCompanionRef = new TermRefTree()
-        val enumImport = Import(importImplied = false, enumCompanionRef, enumCases.flatMap(caseIds))
+        val enumImport = Import(importDelegate = false, enumCompanionRef, enumCases.flatMap(caseIds))
         (enumImport :: enumStats, enumCases, enumCompanionRef)
       }
       else (stats, Nil, EmptyTree)
@@ -508,7 +508,7 @@ object desugar {
     // new C[Ts](paramss)
     lazy val creatorExpr = {
       val vparamss = constrVparamss match {
-        case (vparam :: _) :: _ if vparam.mods.isOneOf(ImplicitOrGiven) => // add a leading () to match class parameters
+        case (vparam :: _) :: _ if vparam.mods.isOneOf(GivenOrImplicit) => // add a leading () to match class parameters
           Nil :: constrVparamss
         case _ =>
           constrVparamss
@@ -703,7 +703,7 @@ object desugar {
     //     synthetic implicit C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, ..., pMN: TMN): C[Ts] =
     //       new C[Ts](p11, ..., p1N) ... (pM1, ..., pMN) =
     val implicitWrappers =
-      if (!mods.isOneOf(ImplicitOrImplied))
+      if (!mods.isOneOf(DelegateOrImplicit))
         Nil
       else if (ctx.owner.is(Package)) {
         ctx.error(TopLevelImplicitClass(cdef), cdef.sourcePos)
@@ -717,7 +717,7 @@ object desugar {
         ctx.error(ImplicitCaseClass(cdef), cdef.sourcePos)
         Nil
       }
-      else if (arity != 1 && !mods.is(Implied)) {
+      else if (arity != 1 && !mods.is(Delegate)) {
         ctx.error(ImplicitClassPrimaryConstructorArity(), cdef.sourcePos)
         Nil
       }
@@ -731,7 +731,7 @@ object desugar {
         // implicit wrapper is typechecked in same scope as constructor, so
         // we can reuse the constructor parameters; no derived params are needed.
         DefDef(className.toTermName, constrTparams, defParamss, classTypeRef, creatorExpr)
-          .withMods(companionMods | mods.flags.toTermFlags & ImplicitOrImplied | Synthetic | Final)
+          .withMods(companionMods | mods.flags.toTermFlags & DelegateOrImplicit | Synthetic | Final)
           .withSpan(cdef.span) :: Nil
       }
 
@@ -1109,8 +1109,8 @@ object desugar {
     def needsObject(stat: Tree) = stat match {
       case _: ValDef | _: PatDef | _: DefDef | _: Export => true
       case stat: ModuleDef =>
-        stat.mods.isOneOf(ImplicitOrImplied) || opaqueNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
-      case stat: TypeDef => !stat.isClassDef || stat.mods.isOneOf(ImplicitOrImplied)
+        stat.mods.isOneOf(DelegateOrImplicit) || opaqueNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
+      case stat: TypeDef => !stat.isClassDef || stat.mods.isOneOf(DelegateOrImplicit)
       case _ => false
     }
     val (nestedStats, topStats) = pdef.stats.partition(needsObject)

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -872,7 +872,7 @@ object TreeInfo {
   /** The expression has no side effects */
   val Pure: PurityLevel = new PurityLevel(3)
 
-  /** Running the expression a second time has no side effects. Implied by `Pure`. */
+  /** Running the expression a second time has no side effects. Delegate by `Pure`. */
   val Idempotent: PurityLevel = new PurityLevel(1)
 
   val Impure: PurityLevel = new PurityLevel(0)

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -750,7 +750,7 @@ object Trees {
     def unforced: LazyTree = preRhs
     protected def force(x: AnyRef): Unit = preRhs = x
 
-    override def disableOverlapChecks = rawMods.is(Implied)
+    override def disableOverlapChecks = rawMods.is(Delegate)
       // disable order checks for implicit aliases since their given clause follows
       // their for clause, but the two appear swapped in the DefDef.
   }
@@ -801,7 +801,7 @@ object Trees {
    *  where a selector is either an untyped `Ident`, `name` or
    *  an untyped thicket consisting of `name` and `rename`.
    */
-  case class Import[-T >: Untyped] private[ast] (importImplied: Boolean, expr: Tree[T], selectors: List[Tree[Untyped]])(implicit @constructorOnly src: SourceFile)
+  case class Import[-T >: Untyped] private[ast] (importDelegate: Boolean, expr: Tree[T], selectors: List[Tree[Untyped]])(implicit @constructorOnly src: SourceFile)
     extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] = Import[T]
   }
@@ -1200,9 +1200,9 @@ object Trees {
         case tree: Template if (constr eq tree.constr) && (parents eq tree.parents) && (derived eq tree.derived) && (self eq tree.self) && (body eq tree.unforcedBody) => tree
         case tree => finalize(tree, untpd.Template(constr, parents, derived, self, body)(sourceFile(tree)))
       }
-      def Import(tree: Tree)(importImplied: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = tree match {
-        case tree: Import if (importImplied == tree.importImplied) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
-        case _ => finalize(tree, untpd.Import(importImplied, expr, selectors)(sourceFile(tree)))
+      def Import(tree: Tree)(importDelegate: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = tree match {
+        case tree: Import if (importDelegate == tree.importDelegate) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
+        case _ => finalize(tree, untpd.Import(importDelegate, expr, selectors)(sourceFile(tree)))
       }
       def PackageDef(tree: Tree)(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef = tree match {
         case tree: PackageDef if (pid eq tree.pid) && (stats eq tree.stats) => tree
@@ -1343,8 +1343,8 @@ object Trees {
               cpy.TypeDef(tree)(name, transform(rhs))
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
               cpy.Template(tree)(transformSub(constr), transform(tree.parents), Nil, transformSub(self), transformStats(tree.body))
-            case Import(importImplied, expr, selectors) =>
-              cpy.Import(tree)(importImplied, transform(expr), selectors)
+            case Import(importDelegate, expr, selectors) =>
+              cpy.Import(tree)(importDelegate, transform(expr), selectors)
             case PackageDef(pid, stats) =>
               cpy.PackageDef(tree)(transformSub(pid), transformStats(stats)(localCtx))
             case Annotated(arg, annot) =>

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -333,8 +333,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Block(cdef :: Nil, New(cls.typeRef, Nil))
   }
 
-  def Import(importImplied: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
-    ta.assignType(untpd.Import(importImplied, expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
+  def Import(importDelegate: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
+    ta.assignType(untpd.Import(importDelegate, expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
 
   def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef =
     ta.assignType(untpd.PackageDef(pid, stats), pid)

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -167,7 +167,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Inline()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Inline)
 
-    case class Implied()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implied)
+    case class Delegate()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Delegate)
   }
 
   /** Modifiers and annotations for definitions
@@ -345,7 +345,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Template(constr: DefDef, parents: List[Tree], derived: List[Tree], self: ValDef, body: LazyTreeList)(implicit src: SourceFile): Template =
     if (derived.isEmpty) new Template(constr, parents, self, body)
     else new DerivingTemplate(constr, parents ++ derived, self, body, derived.length)
-  def Import(importImplied: Boolean, expr: Tree, selectors: List[Tree])(implicit src: SourceFile): Import = new Import(importImplied, expr, selectors)
+  def Import(importDelegate: Boolean, expr: Tree, selectors: List[Tree])(implicit src: SourceFile): Import = new Import(importDelegate, expr, selectors)
   def PackageDef(pid: RefTree, stats: List[Tree])(implicit src: SourceFile): PackageDef = new PackageDef(pid, stats)
   def Annotated(arg: Tree, annot: Tree)(implicit src: SourceFile): Annotated = new Annotated(arg, annot)
 

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

@@ -13,7 +13,7 @@ import Scopes._
 import Uniques._
 import ast.Trees._
 import ast.untpd
-import Flags.ImplicitOrImpliedOrGiven
+import Flags.DelegateOrGivenOrImplicit
 import util.{FreshNameCreator, NoSource, SimpleIdentityMap, SourceFile}
 import typer.{Implicits, ImportInfo, Inliner, NamerContextOps, SearchHistory, SearchRoot, TypeAssigner, Typer}
 import Implicits.ContextualImplicits
@@ -214,7 +214,7 @@ object Contexts {
         implicitsCache = {
           val implicitRefs: List[ImplicitRef] =
             if (isClassDefContext)
-              try owner.thisType.implicitMembers(ImplicitOrImpliedOrGiven)
+              try owner.thisType.implicitMembers(DelegateOrGivenOrImplicit)
               catch {
                 case ex: CyclicReference => Nil
               }
@@ -404,7 +404,7 @@ object Contexts {
         case _               => None
       }
       ctx.fresh.setImportInfo(
-        new ImportInfo(implicit ctx => sym, imp.selectors, impNameOpt, imp.importImplied))
+        new ImportInfo(implicit ctx => sym, imp.selectors, impNameOpt, imp.importDelegate))
     }
 
     /** Does current phase use an erased types interpretation? */

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

@@ -344,7 +344,7 @@ object Flags {
   /** Symbol is a Java default method */
   val (_, DefaultMethod @ _, _) = newFlags(38, "<defaultmethod>")
 
-  val (Implied @ _, _, _) = newFlags(39, "delegate")
+  val (Delegate @ _, _, _) = newFlags(39, "delegate")
 
   /** Symbol is an enum class or enum case (if used with case) */
   val (Enum @ _, _, _) = newFlags(40, "<enum>")
@@ -427,7 +427,7 @@ object Flags {
 
   /** Flags representing source modifiers */
   private val CommonSourceModifierFlags: FlagSet =
-    commonFlags(Private, Protected, Final, Case, Implicit, Implied, Given, Override, JavaStatic)
+    commonFlags(Private, Protected, Final, Case, Implicit, Delegate, Given, Override, JavaStatic)
 
   val TypeSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque
@@ -449,7 +449,7 @@ object Flags {
     HigherKinded, Param, ParamAccessor,
     Scala2ExistentialCommon, Mutable, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
-    Extension, NonMember, Implicit, Given, Implied, Permanent, Synthetic,
+    Extension, NonMember, Implicit, Given, Delegate, Permanent, Synthetic,
     SuperAccessorOrScala2x, Inline)
 
   /** Flags that are not (re)set when completing the denotation, or, if symbol is
@@ -508,14 +508,14 @@ object Flags {
 
   /** Flags that can apply to a module val */
   val RetainedModuleValFlags: FlagSet = RetainedModuleValAndClassFlags |
-    Override | Final | Method | Implicit | Implied | Lazy |
+    Override | Final | Method | Implicit | Delegate | Lazy |
     Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Erased
 
   /** Flags that can apply to a module class */
   val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | Enum
 
   /** Flags retained in export forwarders */
-  val RetainedExportFlags = ImplicitOrImpliedOrGiven | Extension
+  val RetainedExportFlags = Delegate | Given | Implicit | Extension
 
 // ------- Other flag sets -------------------------------------
 
@@ -533,68 +533,47 @@ object Flags {
 
   val MethodOrModule: FlagSet = Method | Module
 
-  /** Either method or lazy or deferred */
   val MethodOrLazyOrDeferred: FlagSet = Deferred | Lazy | Method
 
-  /** An inline method or inline argument proxy */
-  val InlineOrProxy: FlagSet = Inline | InlineProxy
 
-  val ImplicitOrImplied: FlagSet = Implicit | Implied
-  val ImplicitOrImpliedOrGiven: FlagSet = Given | Implicit | Implied
-  val ImplicitOrGiven: FlagSet = Given | Implicit
+  val InlineOrProxy: FlagSet = Inline | InlineProxy  // An inline method or inline argument proxy */
 
-  val ImpliedOrGiven: FlagSet = Implied | Given
+  val DelegateOrGiven: FlagSet              = Delegate | Given
+  val DelegateOrGivenOrImplicit: FlagSet    = Delegate | Given | Implicit
+  val DelegateOrGivenOrImplicitVal: FlagSet = DelegateOrGivenOrImplicit.toTermFlags
+  val DelegateOrImplicit: FlagSet           = Delegate | Implicit
+  val GivenOrImplicit: FlagSet              = Given | Implicit
 
-  val ImplicitOrImpliedOrGivenTerm = ImplicitOrImpliedOrGiven.toTermFlags
+  val StableOrErased: FlagSet = Erased | StableRealizable   // Assumed to be pure
+  val EffectivelyFinalFlags: FlagSet = Final | Private
 
+  val PrivateMethod: FlagSet = Method | Private
 
-  /** Assumed to be pure */
-  val StableOrErased: FlagSet = StableRealizable | Erased
+  val PrivateAccessor: FlagSet = Accessor | Private
 
-  /** Labeled `private`, or `final` */
-  val EffectivelyFinalFlags: FlagSet = Private | Final
-
-  /** A private method */
-  val PrivateMethod: FlagSet = Private | Method
-
-  /** A private accessor */
-  val PrivateAccessor: FlagSet = Private | Accessor
-
-  /** An inline method */
   val InlineMethod: FlagSet = Inline | Method
 
-  /** An inline by-name parameter proxy */
   val InlineByNameProxy: FlagSet = InlineProxy | Method
 
-  /** An inline parameter */
   val InlineParam: FlagSet = Inline | Param
 
-  /** An extension method */
   val ExtensionMethod: FlagSet = Extension | Method
 
-  /** An implied method */
-  val SyntheticImpliedMethod: FlagSet = Synthetic | Implied | Method
+  val SyntheticDelegateMethod: FlagSet = Delegate | Method | Synthetic
 
-  /** An enum case */
-  val EnumCase: FlagSet = Enum | Case
+  val EnumCase: FlagSet = Case | Enum
 
-  /** A term parameter or parameter accessor */
   val TermParamOrAccessor: FlagSet = Param | ParamAccessor
 
-  /** A lazy or deferred value */
-  val LazyOrDeferred: FlagSet = Lazy | Deferred
+  val LazyOrDeferred: FlagSet = Deferred | Lazy
 
-  /** An accessor or a synthetic symbol */
   val AccessorOrSynthetic: FlagSet = Accessor | Synthetic
 
-  /** A synthetic or private definition */
-  val SyntheticOrPrivate: FlagSet = Synthetic | Private
+  val SyntheticOrPrivate: FlagSet = Private | Synthetic
 
-  /** A deferred term member or a parameter or parameter accessor (these don't have right hand sides) */
-  val DeferredOrTermParamOrAccessor: FlagSet = Deferred | TermParam | ParamAccessor
+  val DeferredOrTermParamOrAccessor: FlagSet = Deferred | ParamAccessor | TermParam // term symbols without right-hand sides
 
-  /** A deferred type member or parameter (these don't have right hand sides) */
-  val DeferredOrTypeParam: FlagSet = Deferred | TypeParam
+  val DeferredOrTypeParam: FlagSet = Deferred | TypeParam // type symbols without right-hand sides
 
   /** value that's final or inline */
   val FinalOrInline: FlagSet = Final | Inline

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

@@ -409,7 +409,7 @@ object Scopes {
       var irefs = new mutable.ListBuffer[TermRef]
       var e = lastEntry
       while (e ne null) {
-        if (e.sym.isOneOf(ImplicitOrImpliedOrGiven)) {
+        if (e.sym.isOneOf(DelegateOrGivenOrImplicit)) {
           val d = e.sym.denot
           irefs += TermRef(NoPrefix, d.symbol.asTerm).withDenot(d)
         }

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

@@ -1943,7 +1943,7 @@ object SymDenotations {
           if (keepOnly eq implicitFilter)
             if (this.is(Package)) Iterator.empty
               // implicits in package objects are added by the overriding `memberNames` in `PackageClassDenotation`
-            else info.decls.iterator.filter(_.isOneOf(ImplicitOrImpliedOrGiven))
+            else info.decls.iterator.filter(_.isOneOf(DelegateOrGivenOrImplicit))
           else info.decls.iterator
         for (sym <- ownSyms) maybeAdd(sym.name)
         names

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

@@ -142,7 +142,7 @@ class CyclicReference private (val denot: SymDenotation) extends TypeError {
         }
       }
       // Give up and give generic errors.
-      else if (cycleSym.isOneOf(ImplicitOrImpliedOrGiven, butNot = Method) && cycleSym.owner.isTerm)
+      else if (cycleSym.isOneOf(DelegateOrGivenOrImplicit, butNot = Method) && cycleSym.owner.isTerm)
         CyclicReferenceInvolvingImplicit(cycleSym)
       else
         CyclicReferenceInvolving(denot)

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

@@ -787,12 +787,12 @@ object Types {
     }
 
     /** The set of implicit term members of this type
-     *  @param kind   A subset of {Implicit, Implied} that specifies what kind of implicit should
+     *  @param kind   A subset of {Implicit, Delegate} that specifies what kind of implicit should
      *                be returned
      */
     final def implicitMembers(kind: FlagSet)(implicit ctx: Context): List[TermRef] = track("implicitMembers") {
       memberDenots(implicitFilter,
-          (name, buf) => buf ++= member(name).altsWith(_.isOneOf(ImplicitOrImpliedOrGivenTerm & kind)))
+          (name, buf) => buf ++= member(name).altsWith(_.isOneOf(DelegateOrGivenOrImplicitVal & kind)))
         .toList.map(d => TermRef(this, d.symbol.asTerm))
     }