Rework NamedTypes

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

@@ -85,13 +85,8 @@ object Trees {
      *  which implements copy-on-write. Another use-case is in method interpolateAndAdapt in Typer,
      *  where we overwrite with a simplified version of the type itself.
      */
-    private[dotc] def overwriteType(tpe: T) = {
-      if (this.isInstanceOf[Template[_]])
-        tpe match {
-          case tpe: TermRef => assert(tpe.hasFixedSym , s"$this <--- $tpe")
-        }
+    private[dotc] def overwriteType(tpe: T) =
       myTpe = tpe
-    }
 
     /** The type of the tree. In case of an untyped tree,
      *   an UnAssignedTypeException is thrown. (Overridden by empty trees)

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

@@ -382,7 +382,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val targs = tp.argTypes
     val tycon = tp.typeConstructor
     New(tycon)
-      .select(TermRef.withSym(tycon, constr))
+      .select(TermRef(tycon, constr))
       .appliedToTypes(targs)
       .appliedToArgs(args)
   }
@@ -709,7 +709,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       val tp =
         if (sym.isType) {
           assert(!sym.is(TypeParam))
-          TypeRef(tree.tpe, sym.name.asTypeName)
+          TypeRef(tree.tpe, sym.asType)
         }
         else
           TermRef(tree.tpe, sym.name.asTermName, sym.denot.asSeenFrom(tree.tpe))
@@ -718,8 +718,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     /** A select node with the given selector name and signature and a computed type */
     def selectWithSig(name: Name, sig: Signature)(implicit ctx: Context): Tree =
-      untpd.SelectWithSig(tree, name, sig)
-        .withType(TermRef(tree.tpe, name.asTermName.withSig(sig)))
+      untpd.SelectWithSig(tree, name, sig).withType(tree.tpe.select(name.asTermName, sig))
 
     /** A select node with selector name and signature taken from `sym`.
      *  Note: Use this method instead of select(sym) if the referenced symbol
@@ -927,7 +926,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
       else denot.asSingleDenotation.termRef
     val fun = receiver
-      .select(TermRef.withSym(receiver.tpe, selected.termSymbol.asTerm))
+      .select(TermRef(receiver.tpe, selected.termSymbol.asTerm))
       .appliedToTypes(targs)
 
     def adaptLastArg(lastParam: Tree, expectedType: Type) = {

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -106,6 +106,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YkeepComments = BooleanSetting("-Ykeep-comments", "Keep comments when scanning source files.")
   val YforceSbtPhases = BooleanSetting("-Yforce-sbt-phases", "Run the phases used by sbt for incremental compilation (ExtractDependencies and ExtractAPI) even if the compiler is ran outside of sbt, for debugging.")
   val YdumpSbtInc = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.")
+  val YupdateStale = BooleanSetting("-Yupdate-stale", "Automically update stale top-level classes and objects to latest version")
   val YcheckAllPatmat = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)")
   val YretainTrees = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree")
   val YshowTreeIds = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.")

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

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

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

@@ -209,7 +209,7 @@ class Definitions {
    *  members at runtime.
    */
   lazy val ScalaShadowingPackageVal = ctx.requiredPackage(nme.scalaShadowing)
-  lazy val ScalaShadowingPackageClass = ScalaShadowingPackageVal.moduleClass.asClass
+  def ScalaShadowingPackageClass(implicit ctx: Context) = ScalaShadowingPackageVal.moduleClass.asClass
 
   /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)
    *  because after erasure the Any and AnyVal references get remapped to the Object methods
@@ -510,7 +510,6 @@ class Definitions {
   lazy val IndexOutOfBoundsException = ctx.requiredClass("java.lang.IndexOutOfBoundsException")
   lazy val ClassClass                = ctx.requiredClass("java.lang.Class")
   lazy val BoxedNumberClass          = ctx.requiredClass("java.lang.Number")
-  lazy val ThrowableClass            = ctx.requiredClass("java.lang.Throwable")
   lazy val ClassCastExceptionClass   = ctx.requiredClass("java.lang.ClassCastException")
   lazy val ArithmeticExceptionClass  = ctx.requiredClass("java.lang.ArithmeticException")
     lazy val ArithmeticExceptionClass_stringConstructor  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
@@ -525,6 +524,8 @@ class Definitions {
 
   // in scalac modified to have Any as parent
 
+  lazy val ThrowableType: TypeRef          = ctx.requiredClassRef("java.lang.Throwable")
+  def ThrowableClass(implicit ctx: Context) = ThrowableType.symbol.asClass
   lazy val SerializableType: TypeRef       = ctx.requiredClassRef("scala.Serializable")
   def SerializableClass(implicit ctx: Context) = SerializableType.symbol.asClass
   lazy val StringBuilderType: TypeRef      = ctx.requiredClassRef("scala.collection.mutable.StringBuilder")
@@ -680,7 +681,6 @@ class Definitions {
   // Derived types
 
   def RepeatedParamType = RepeatedParamClass.typeRef
-  def ThrowableType = ThrowableClass.typeRef
 
   def ClassType(arg: Type)(implicit ctx: Context) = {
     val ctype = ClassClass.typeRef
@@ -829,6 +829,9 @@ class Definitions {
   def isTupleClass(cls: Symbol) = isVarArityClass(cls, str.Tuple)
   def isProductClass(cls: Symbol) = isVarArityClass(cls, str.Product)
 
+  def isScalaShadowingPackageClass(cls: Symbol) =
+    cls.name == tpnme.scalaShadowing && cls.owner == RootClass
+
   /** Returns the erased class of the function class `cls`
    *    - FunctionN for N > 22 becomes FunctionXXL
    *    - FunctionN for 22 > N >= 0 remains as FunctionN