Normalize TypeOf types (second step towards typed transparent methods)

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

@@ -310,6 +310,7 @@ object desugar {
     val isEnum = mods.isEnumClass && !mods.is(Module)
     def isEnumCase = mods.isEnumCase
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
+    val dependentFlag = if (mods.is(Dependent)) Dependent else EmptyFlags
       // This is not watertight, but `extends AnyVal` will be replaced by `inline` later.
 
     val originalTparams = constr1.tparams
@@ -423,7 +424,7 @@ object desugar {
     // two errors without @uncheckedVariance, one of them spurious.
     val caseClassMeths = {
       def syntheticProperty(name: TermName, rhs: Tree) =
-        DefDef(name, Nil, Nil, TypeTree(), rhs).withMods(synthetic)
+        DefDef(name, Nil, Nil, TypeTree(), rhs).withMods(synthetic | dependentFlag)
       def productElemMeths = {
         val caseParams = constrVparamss.head.toArray
         for (i <- 0 until arity if nme.selectorName(i) `ne` caseParams(i).name)
@@ -553,12 +554,12 @@ object desugar {
           if (mods is Abstract) Nil
           else
             DefDef(nme.apply, derivedTparams, derivedVparamss, applyResultTpt, widenedCreatorExpr)
-              .withFlags(Synthetic | (constr1.mods.flags & DefaultParameterized)) :: widenDefs
+              .withFlags(Synthetic | dependentFlag | (constr1.mods.flags & DefaultParameterized)) :: widenDefs
         val unapplyMeth = {
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
           val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)
           DefDef(nme.unapply, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS)
-            .withMods(synthetic)
+            .withMods(synthetic | dependentFlag)
         }
         companionDefs(companionParent, applyMeths ::: unapplyMeth :: companionMembers)
       }

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

@@ -228,8 +228,9 @@ object Trees {
                 case y: List[_] => x.corresponds(y)(isSame)
                 case _ => false
               }
+            case x: Constant => x == y
             case _ =>
-              false
+              throw new AssertionError(s"Unexpected Tree in Tree comparison $x (comparing to $y)")
           }
         }
       this.getClass == that.getClass && {
@@ -623,7 +624,7 @@ object Trees {
    */
   class TypeVarBinder[-T >: Untyped] extends TypeTree[T]
 
-  /** ref.type */
+  /** ref.type  or  { ref } */
   case class SingletonTypeTree[-T >: Untyped] private[ast] (ref: Tree[T])
     extends DenotingTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = SingletonTypeTree[T]
@@ -1243,7 +1244,7 @@ object Trees {
           case TypeTree() =>
             tree
           case SingletonTypeTree(ref) =>
-            cpy.SingletonTypeTree(tree)(transform(ref))
+            cpy.SingletonTypeTree(tree)(transform(ref)(ctx.enterTypeOf()))
           case AndTypeTree(left, right) =>
             cpy.AndTypeTree(tree)(transform(left), transform(right))
           case OrTypeTree(left, right) =>

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

@@ -570,7 +570,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     override def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If = {
       val tree1 = untpd.cpy.If(tree)(cond, thenp, elsep)
       tree match {
-        case tree: If if (thenp.tpe eq tree.thenp.tpe) && (elsep.tpe eq tree.elsep.tpe) => tree1.withTypeUnchecked(tree.tpe)
+        case tree: If if (cond.tpe eq tree.cond.tpe) && (thenp.tpe eq tree.thenp.tpe) && (elsep.tpe eq tree.elsep.tpe) => tree1.withTypeUnchecked(tree.tpe)
         case _ => ta.assignType(tree1, thenp, elsep)
       }
     }
@@ -587,7 +587,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = {
       val tree1 = untpd.cpy.Match(tree)(selector, cases)
       tree match {
-        case tree: Match if sameTypes(cases, tree.cases) => tree1.withTypeUnchecked(tree.tpe)
+        case tree: Match if (selector.tpe eq tree.selector.tpe) && sameTypes(cases, tree.cases) => tree1.withTypeUnchecked(tree.tpe)
         case _ => ta.assignType(tree1, cases)
       }
     }

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

@@ -137,6 +137,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case class Transparent() extends Mod(Flags.Transparent)
 
     case class Enum() extends Mod(Flags.Enum)
+
+    case class Dependent() extends Mod(Flags.Dependent)
   }
 
   /** Modifiers and annotations for definitions

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

@@ -6,6 +6,7 @@ object Config {
   final val cacheAsSeenFrom = true
   final val cacheMemberNames = true
   final val cacheImplicitScopes = true
+  final val cacheNormalizedTypes = true
 
   final val checkCacheMembersNamed = false
 

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

@@ -146,6 +146,8 @@ class ScalaSettings extends Settings.SettingGroup {
 
   val YnoDecodeStacktraces = BooleanSetting("-Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
 
+  val YtypeNormalizationFuel = IntSetting("-Ytype-normalization-fuel", "Maximal number of steps when evaluating type expressions.", 2222222)
+
   /** Dottydoc specific settings */
   val siteRoot = StringSetting(
     "-siteroot",
@@ -154,7 +156,6 @@ class ScalaSettings extends Settings.SettingGroup {
     sys.props("user.dir")
   )
 
-
   val projectName = StringSetting (
     "-project",
     "project title",

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

@@ -32,6 +32,7 @@ object Annotations {
       for (ConstantType(c) <- argument(i) map (_.tpe)) yield c
 
     def isEvaluated: Boolean = true
+    def isEvaluating: Boolean = false
 
     def ensureCompleted(implicit ctx: Context): Unit = tree
 
@@ -85,6 +86,7 @@ object Annotations {
       myBody
     }
     override def isEvaluated = evaluated
+    override def isEvaluating = evaluated && myBody == null
   }
 
   object Annotation {
@@ -170,8 +172,10 @@ object Annotations {
 
       def unapply(ann: Annotation)(implicit ctx: Context): Option[Symbol] =
         if (ann.symbol == defn.ChildAnnot) {
-          val AppliedType(tycon, (arg: NamedType) :: Nil) = ann.tree.tpe
-          Some(arg.symbol)
+          ann.tree.tpe match { // TODO: proper fix
+            case AppliedType(tycon, (arg: NamedType) :: Nil) => Some(arg.symbol)
+            case _ => None
+          }
         }
         else None
     }

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

@@ -116,6 +116,11 @@ object Contexts {
     protected def owner_=(owner: Symbol) = _owner = owner
     def owner: Symbol = _owner
 
+    /** The owner at the point of entering TypeOf (for SingletonTypeTrees) */
+    private[this] var _inTypeOfOwner: Symbol = _
+    protected def inTypeOfOwner_=(owner: Symbol) = _inTypeOfOwner = owner
+    def inTypeOfOwner: Symbol = _inTypeOfOwner
+
     /** The current tree */
     private[this] var _tree: Tree[_ >: Untyped]= _
     protected def tree_=(tree: Tree[_ >: Untyped]) = _tree = tree
@@ -162,6 +167,32 @@ object Contexts {
       _typeComparer
     }
 
+    /** Is this context dependent? */
+    private[this] var _dependentInit: Boolean = true // NOTE: This initial value only applies to InitialContext
+    private[this] var _dependent: Boolean = false
+    final def isDependent: Boolean = {
+      def isDepOwner(owner: Symbol): Boolean =
+        if ((owner eq NoSymbol) || owner.isClass) false
+        else if (owner.flagsUNSAFE.is(Flags.Dependent)) true
+        else isDepOwner(owner.owner)
+
+      /** NOTE: The initialization of `_dependent` is rather tricky: We do need to make sure that any
+        *       enclosing context's `_dependent` has been computed, since the property is inherited. In case the
+        *       outer's `dependent` has been accessed before, we inherit the value by way of clone() in fresh(),
+        *       (and as a result `_dependentInit` will be true as well).
+        *       Otherwise we force the enclosing context's `_dependent` here, and, if the outer turns out not to be
+        *       dependent, we finally also compute `_dependent` based on this context.
+        */
+      if (!_dependentInit) {
+        _dependent = this.isInTypeOf || isDepOwner(this.owner)
+        _dependentInit = true
+      }
+      _dependent
+    }
+
+    final def isInTypeOf: Boolean =
+      this.inTypeOfOwner == this.owner
+
     /** A map in which more contextual properties can be stored
      *  Typically used for attributes that are read and written only in special situations.
      */
@@ -411,6 +442,9 @@ object Contexts {
       this.phasedCtxs = null
       // See comment related to `creationTrace` in this file
       // setCreationTrace()
+      // The _dependent member was cloned, but is monotonic anyways, so we *could* only recompute in case
+      // _dependentInit is false, but it turns out that branching here is very costly.
+      this._dependentInit = false
       this
     }
 
@@ -475,6 +509,7 @@ object Contexts {
     def setPeriod(period: Period): this.type = { this.period = period; this }
     def setMode(mode: Mode): this.type = { this.mode = mode; this }
     def setOwner(owner: Symbol): this.type = { assert(owner != NoSymbol); this.owner = owner; this }
+    def enterTypeOf(): this.type = { assert(this.owner != NoSymbol); this.inTypeOfOwner = this.owner; this }
     def setTree(tree: Tree[_ >: Untyped]): this.type = { this.tree = tree; this }
     def setScope(scope: Scope): this.type = { this.scope = scope; this }
     def setNewScope: this.type = { this.scope = newScope; this }
@@ -539,6 +574,8 @@ object Contexts {
     final def addMode(mode: Mode): Context = withModeBits(c.mode | mode)
     final def maskMode(mode: Mode): Context = withModeBits(c.mode & mode)
     final def retractMode(mode: Mode): Context = withModeBits(c.mode &~ mode)
+
+    final def enterTypeOf(): Context = if (c.isInTypeOf) c else c.fresh.enterTypeOf()
   }
 
   implicit class FreshModeChanges(val c: FreshContext) extends AnyVal {
@@ -613,6 +650,7 @@ object Contexts {
     def initialize()(implicit ctx: Context): Unit = {
       _platform = newPlatform
       definitions.init()
+      typeNormalizationFuel = settings.YtypeNormalizationFuel.value
     }
 
     def squashed(p: Phase): Phase = {
@@ -712,6 +750,8 @@ object Contexts {
     def checkSingleThreaded() =
       if (thread == null) thread = Thread.currentThread()
       else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
+
+    private[dotc] var typeNormalizationFuel: Int = 0
   }
 
   class GADTMap(initBounds: SimpleIdentityMap[Symbol, TypeBounds]) {

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

@@ -369,6 +369,9 @@ object Flags {
   /** Labeled with `erased` modifier (erased value)  */
   final val Erased = termFlag(42, "erased")
 
+  /** Labelled with `dependent` modifier */
+  final val Dependent = commonFlag(43, "dependent")
+
   // Flags following this one are not pickled
 
   /** Symbol is not a member of its owner */
@@ -436,7 +439,7 @@ object Flags {
 
   /** Flags representing source modifiers */
   final val SourceModifierFlags =
-    commonFlags(Private, Protected, Abstract, Final, Rewrite | Transparent,
+    commonFlags(Private, Protected, Abstract, Final, Rewrite | Transparent, Dependent,
      Sealed, Case, Implicit, Override, AbsOverride, Lazy, JavaStatic, Erased)
 
   /** Flags representing modifiers that can appear in trees */
@@ -457,7 +460,7 @@ object Flags {
     Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
     NonMember | ImplicitCommon | Permanent | Synthetic |
-    SuperAccessorOrScala2x | Rewrite | Transparent
+    SuperAccessorOrScala2x | Rewrite | Transparent | Dependent
 
   /** Flags that are not (re)set when completing the denotation, or, if symbol is
    *  a top-level class or object, when completing the denotation once the class
@@ -551,8 +554,8 @@ object Flags {
   /** Assumed to be pure */
   final val StableOrErased = Stable | Erased
 
-  /** Labeled `private`, `final`, `rewrite` or `transparent` */
-  final val EffectivelyFinal = Private | Final | Rewrite | Transparent
+  /** Labeled `private`, `final`, or `transparent` */
+  final val EffectivelyFinal = Private | Final | Rewrite | Transparent | Dependent
 
   /** A private method */
   final val PrivateMethod = allOf(Private, Method)
@@ -566,6 +569,12 @@ object Flags {
   /** A rewrite method */
   final val RewriteMethod = allOf(Rewrite, Method)
 
+  /** A dependent method */
+  final val DependentMethod = allOf(Dependent, Method)
+
+  /** A transparent implicit method */
+  final val TransparentImplicitMethod = allOf(Transparent, Rewrite, Implicit, Method)
+
   /** An implicit rewrite method */
   final val ImplicitRewriteMethod = allOf(Rewrite, Implicit, Method)
 

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

@@ -100,4 +100,7 @@ object Mode {
 
   /** Read comments from definitions when unpickling from TASTY */
   val ReadComments = newMode(22, "ReadComments")
+
+  /** We are in TypeOf, e.g. to type a SingletonTypeTree or to compute a derived TypeOf */
+  val InTypeOf = newMode(23, "InTypeOf")
 }