Merge pull request #6041 from dotty-staging/fix-import-implied

Refine `import implied` rules to smooth migration

Author: smarter

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

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

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

@@ -751,7 +751,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] (impliedOnly: Boolean, expr: Tree[T], selectors: List[Tree[Untyped]])(implicit @constructorOnly src: SourceFile)
+  case class Import[-T >: Untyped] private[ast] (importImplied: Boolean, expr: Tree[T], selectors: List[Tree[Untyped]])(implicit @constructorOnly src: SourceFile)
     extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] = Import[T]
   }
@@ -1140,9 +1140,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)(impliedOnly: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = tree match {
-        case tree: Import if (impliedOnly == tree.impliedOnly) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
-        case _ => finalize(tree, untpd.Import(impliedOnly, expr, selectors)(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 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
@@ -1283,8 +1283,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(impliedOnly, expr, selectors) =>
-              cpy.Import(tree)(impliedOnly, transform(expr), selectors)
+            case Import(importImplied, expr, selectors) =>
+              cpy.Import(tree)(importImplied, transform(expr), selectors)
             case PackageDef(pid, stats) =>
               cpy.PackageDef(tree)(transformSub(pid), transformStats(stats)(localCtx))
             case Annotated(arg, annot) =>
@@ -1403,7 +1403,7 @@ object Trees {
               this(x, rhs)
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
               this(this(this(this(x, constr), parents), self), tree.body)
-            case Import(impliedOnly, expr, selectors) =>
+            case Import(importImplied, expr, selectors) =>
               this(x, expr)
             case PackageDef(pid, stats) =>
               this(this(x, pid), stats)(localCtx)

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

@@ -326,8 +326,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Block(cdef :: Nil, New(cls.typeRef, Nil))
   }
 
-  def Import(impliedOnly: Boolean, expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
-    ta.assignType(untpd.Import(impliedOnly, expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
+  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 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

@@ -323,7 +323,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(impliedOnly: Boolean, expr: Tree, selectors: List[Tree])(implicit src: SourceFile): Import = new Import(impliedOnly, expr, selectors)
+  def Import(importImplied: Boolean, expr: Tree, selectors: List[Tree])(implicit src: SourceFile): Import = new Import(importImplied, 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/ConstraintHandling.scala

@@ -85,7 +85,8 @@ trait ConstraintHandling[AbstractContext] {
 
       val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)
       val equalBounds = isUpper && (lo eq bound) || !isUpper && (bound eq hi)
-      if (equalBounds && !bound.existsPart(_.isInstanceOf[WildcardType])) {
+      if (equalBounds &&
+         !bound.existsPart(bp => bp.isInstanceOf[WildcardType] || (bp eq param))) {
         // The narrowed bounds are equal and do not contain wildcards,
         // so we can remove `param` from the constraint.
         // (Handling wildcards requires choosing a bound, but we don't know which

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

@@ -151,13 +151,11 @@ object Contexts {
     /** The current type comparer. This ones updates itself automatically for
      *  each new context.
      */
-    private[this] var _typeComparer: TypeComparer = null
-    protected def typeComparer_=(typeComparer: TypeComparer): Unit = {
-      assert(typeComparer.ctx eq this)
-      _typeComparer = typeComparer
-    }
-    final def typeComparer: TypeComparer = {
-      if (_typeComparer == null) _typeComparer = outer.typeComparer.copyIn(this)
+    private[this] var _typeComparer: TypeComparer = _
+    protected def typeComparer_=(typeComparer: TypeComparer): Unit = _typeComparer = typeComparer
+    def typeComparer: TypeComparer = {
+      if (_typeComparer.ctx ne this)
+        _typeComparer = _typeComparer.copyIn(this)
       _typeComparer
     }
 
@@ -406,7 +404,7 @@ object Contexts {
         case _               => None
       }
       ctx.fresh.setImportInfo(
-        new ImportInfo(implicit ctx => sym, imp.selectors, impNameOpt, imp.impliedOnly))
+        new ImportInfo(implicit ctx => sym, imp.selectors, impNameOpt, imp.importImplied))
     }
 
     /** Does current phase use an erased types interpretation? */
@@ -422,29 +420,31 @@ object Contexts {
     def useColors: Boolean =
       base.settings.color.value == "always"
 
-    protected def init(outer: Context): this.type = {
+    protected def init(outer: Context, origin: Context): this.type = {
+      util.Stats.record("Context.fresh")
       _outer = outer
-      _period = outer.period
-      _mode = outer.mode
-      _owner = outer.owner
-      _tree = outer.tree
-      _scope = outer.scope
-      _typerState = outer.typerState
-      _typeAssigner = outer.typeAssigner
-      _importInfo = outer.importInfo
-      _gadt = outer.gadt
-      _searchHistory = outer.searchHistory
-      _source = outer.source
-      _moreProperties = outer.moreProperties
-      _store = outer.store
+      _period = origin.period
+      _mode = origin.mode
+      _owner = origin.owner
+      _tree = origin.tree
+      _scope = origin.scope
+      _typerState = origin.typerState
+      _typeAssigner = origin.typeAssigner
+      _importInfo = origin.importInfo
+      _gadt = origin.gadt
+      _searchHistory = origin.searchHistory
+      _typeComparer = origin.typeComparer
+      _source = origin.source
+      _moreProperties = origin.moreProperties
+      _store = origin.store
       this
     }
 
-    /** A fresh clone of this context. */
-    def fresh: FreshContext = {
-      util.Stats.record("Context.fresh")
-      new FreshContext(base).init(this)
-    }
+    /** A fresh clone of this context embedded in this context. */
+    def fresh: FreshContext = freshOver(this)
+
+    /** A fresh clone of this context embedded in the specified `outer` context. */
+    def freshOver(outer: Context): FreshContext = new FreshContext(base).init(outer, this)
 
     final def withOwner(owner: Symbol): Context =
       if (owner ne this.owner) fresh.setOwner(owner) else this

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

@@ -101,4 +101,7 @@ object Mode {
 
   /** We are synthesizing the receiver of an extension method */
   val SynthesizeExtMethodReceiver: Mode = newMode(23, "SynthesizeExtMethodReceiver")
+
+  /** Are we trying to find a hidden implicit? */
+  val FindHiddenImplicits: Mode = newMode(24, "FindHiddenImplicits")
 }

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

@@ -532,10 +532,10 @@ class TreePickler(pickler: TastyPickler) {
             }
             pickleStats(tree.constr :: rest)
           }
-        case Import(impliedOnly, expr, selectors) =>
+        case Import(importImplied, expr, selectors) =>
           writeByte(IMPORT)
           withLength {
-            if (impliedOnly) writeByte(IMPLIED)
+            if (importImplied) writeByte(IMPLIED)
             pickleTree(expr)
             pickleSelectors(selectors)
           }

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

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

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

@@ -1049,7 +1049,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(impliedOnly = false, expr, selectors)
+        Import(importImplied = false, expr, selectors)
 
       case TEMPLATEtree =>
         setSym()