Rename importDelegate -> importGiven

Author: odersky

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

@@ -480,7 +480,7 @@ object desugar {
         if (enumCases.isEmpty)
           ctx.error("Enumerations must constain at least one case", namePos)
         val enumCompanionRef = TermRefTree()
-        val enumImport = Import(importDelegate = false, enumCompanionRef, enumCases.flatMap(caseIds))
+        val enumImport = Import(importGiven = false, enumCompanionRef, enumCases.flatMap(caseIds))
         (enumImport :: enumStats, enumCases, enumCompanionRef)
       }
       else (stats, Nil, EmptyTree)

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

@@ -874,7 +874,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. Delegate by `Pure`. */
+  /** Running the expression a second time has no side effects. Implied by `Pure`. */
   val Idempotent: PurityLevel = new PurityLevel(1)
 
   val Impure: PurityLevel = new PurityLevel(0)

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

@@ -800,7 +800,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] (importDelegate: Boolean, expr: Tree[T], selectors: List[Tree[Untyped]])(implicit @constructorOnly src: SourceFile)
+  case class Import[-T >: Untyped] private[ast] (importGiven: Boolean, expr: Tree[T], selectors: List[Tree[Untyped]])(implicit @constructorOnly src: SourceFile)
     extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] = Import[T]
   }
@@ -1188,9 +1188,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)(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 Import(tree: Tree)(importGiven: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = tree match {
+        case tree: Import if (importGiven == tree.importGiven) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
+        case _ => finalize(tree, untpd.Import(importGiven, 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
@@ -1331,8 +1331,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(importDelegate, expr, selectors) =>
-              cpy.Import(tree)(importDelegate, transform(expr), selectors)
+            case Import(importGiven, expr, selectors) =>
+              cpy.Import(tree)(importGiven, 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(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 Import(importGiven: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
+    ta.assignType(untpd.Import(importGiven, 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

@@ -339,7 +339,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(importDelegate: Boolean, expr: Tree, selectors: List[Tree])(implicit src: SourceFile): Import = new Import(importDelegate, expr, selectors)
+  def Import(importGiven: Boolean, expr: Tree, selectors: List[Tree])(implicit src: SourceFile): Import = new Import(importGiven, 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

@@ -404,7 +404,7 @@ object Contexts {
         case _               => None
       }
       ctx.fresh.setImportInfo(
-        ImportInfo(sym, imp.selectors, impNameOpt, imp.importDelegate))
+        ImportInfo(sym, imp.selectors, impNameOpt, imp.importGiven))
     }
 
     /** Does current phase use an erased types interpretation? */

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

@@ -789,7 +789,7 @@ object Types {
     }
 
     /** The set of implicit term members of this type
-     *  @param kind   A subset of {Implicit, Delegate} that specifies what kind of implicit should
+     *  @param kind   A subset of {Implicit, Given} that specifies what kind of implicit should
      *                be returned
      */
     final def implicitMembers(kind: FlagSet)(implicit ctx: Context): List[TermRef] = track("implicitMembers") {

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -528,10 +528,10 @@ class TreePickler(pickler: TastyPickler) {
             }
             pickleStats(tree.constr :: rest)
           }
-        case Import(importDelegate, expr, selectors) =>
+        case Import(importGiven, expr, selectors) =>
           writeByte(IMPORT)
           withLength {
-            if (importDelegate) writeByte(GIVEN)
+            if (importGiven) writeByte(GIVEN)
             pickleTree(expr)
             pickleSelectors(selectors)
           }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -947,10 +947,10 @@ class TreeUnpickler(reader: TastyReader,
       assert(sourcePathAt(start).isEmpty)
       readByte()
       readEnd()
-      val importDelegate = nextByte == GIVEN
-      if (importDelegate) readByte()
+      val importGiven = nextByte == GIVEN
+      if (importGiven) readByte()
       val expr = readTerm()
-      setSpan(start, Import(importDelegate, expr, readSelectors()))
+      setSpan(start, Import(importGiven, expr, readSelectors()))
     }
 
     def readSelectors()(implicit ctx: Context): List[untpd.Tree] = nextByte match {

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -1072,7 +1072,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           val to = untpd.Ident(toName)
           if (toName.isEmpty) from else untpd.Thicket(from, untpd.Ident(toName))
         })
-        Import(importDelegate = false, expr, selectors)
+        Import(importGiven = false, expr, selectors)
 
       case TEMPLATEtree =>
         setSym()