First steps to support dependent matches

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

@@ -349,6 +349,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
@@ -483,7 +484,7 @@ object desugar {
     // two errors without @uncheckedVariance, one of them spurious.
     val caseClassMeths = {
       def syntheticProperty(name: TermName, tpt: Tree, rhs: Tree) =
-        DefDef(name, Nil, Nil, tpt, rhs).withMods(synthetic)
+        DefDef(name, Nil, Nil, tpt, rhs).withMods(synthetic | dependentFlag)
       def productElemMeths = {
         val caseParams = derivedVparamss.head.toArray
         for (i <- List.range(0, arity) if nme.selectorName(i) `ne` caseParams(i).name)
@@ -606,7 +607,7 @@ object desugar {
           else {
             val copiedFlagsMask = DefaultParameterized | (copiedAccessFlags & Private)
             val appMods = {
-              val mods = Modifiers(Synthetic | constr1.mods.flags & copiedFlagsMask)
+              val mods = Modifiers(Synthetic | dependentFlag | constr1.mods.flags & copiedFlagsMask)
               if (restrictedAccess) mods.withPrivateWithin(constr1.mods.privateWithin)
               else mods
             }
@@ -622,7 +623,7 @@ object desugar {
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
           val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)
           DefDef(methName, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS)
-            .withMods(synthetic)
+            .withMods(synthetic | dependentFlag)
         }
         companionDefs(companionParent, applyMeths ::: unapplyMeth :: companionMembers)
       }

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

@@ -217,8 +217,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 && {
@@ -620,7 +621,7 @@ object Trees {
    */
   class TypeVarBinder[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends TypeTree[T]
 
-  /** ref.type */
+  /** ref.type  or  { ref } */
   case class SingletonTypeTree[-T >: Untyped] private[ast] (ref: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends DenotingTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = SingletonTypeTree[T]
@@ -1248,7 +1249,7 @@ object Trees {
             case TypeTree() =>
               tree
             case SingletonTypeTree(ref) =>
-              cpy.SingletonTypeTree(tree)(transform(ref))
+              cpy.SingletonTypeTree(tree)(transform(ref)(ctx.enterTypeOf()))
             case RefinedTypeTree(tpt, refinements) =>
               cpy.RefinedTypeTree(tree)(transform(tpt), transformSub(refinements))
             case AppliedTypeTree(tpt, args) =>

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

@@ -46,10 +46,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.Apply(fn, args), fn, args)
   }
 
-  def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
-    assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply[_]])
+  def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply =
     ta.assignType(untpd.TypeApply(fn, args), fn, args)
-  }
 
   def Literal(const: Constant)(implicit ctx: Context): Literal =
     ta.assignType(untpd.Literal(const))
@@ -590,7 +588,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 = untpdCpy.If(tree)(cond, thenp, elsep)
       tree match {
-        case tree: If if (thenp.tpe eq tree.thenp.tpe) && (elsep.tpe eq tree.elsep.tpe) &&
+        case tree: If if (cond.tpe eq tree.cond.tpe) && (thenp.tpe eq tree.thenp.tpe) && (elsep.tpe eq tree.elsep.tpe) &&
           ((tree.tpe eq thenp.tpe) || (tree.tpe eq elsep.tpe)) =>
           // The last guard is a conservative check similar to the one done in `Block` above,
           // if `tree.tpe` is not identical to the type of one of its branch, it might have been
@@ -611,9 +609,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = {
+      @tailrec
+      def sameCases(trees: List[CaseDef], trees1: List[CaseDef]): Boolean = {
+        if (trees.isEmpty) trees1.isEmpty
+        else if (trees1.isEmpty) trees.isEmpty
+        else {
+          val cd = trees.head
+          val cd1 = trees1.head
+          (cd.pat.tpe eq cd1.pat.tpe) && (cd.guard.tpe eq cd1.guard.tpe) && (cd.body.tpe eq cd1.body.tpe) &&
+            sameCases(trees.tail, trees1.tail)
+        }
+      }
+
       val tree1 = untpdCpy.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) && sameCases(cases, tree.cases) => tree1.withTypeUnchecked(tree.tpe)
         case _ => ta.assignType(tree1, selector, cases)
       }
     }
@@ -1126,7 +1136,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   @tailrec
   def sameTypes(trees: List[tpd.Tree], trees1: List[tpd.Tree]): Boolean = {
-    if (trees.isEmpty) trees.isEmpty
+    if (trees.isEmpty) trees1.isEmpty
     else if (trees1.isEmpty) trees.isEmpty
     else (trees.head.tpe eq trees1.head.tpe) && sameTypes(trees.tail, trees1.tail)
   }

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

@@ -152,6 +152,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case class Enum()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Enum)
 
     case class Instance()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implied)
+
+    case class Dependent()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Dependent)
   }
 
   /** Modifiers and annotations for definitions

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

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

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

@@ -148,6 +148,8 @@ class ScalaSettings extends Settings.SettingGroup {
 
   val YnoDecodeStacktraces: Setting[Boolean] = 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)
+
   val YinstrumentClosures: Setting[Boolean] = BooleanSetting("-Yinstrument-closures", "Add instrumentation code that counts closure creations.")
   val YinstrumentAllocations: Setting[Boolean] = BooleanSetting("-Yinstrument-allocations", "Add instrumentation code that counts allocations.")
 
@@ -159,7 +161,6 @@ class ScalaSettings extends Settings.SettingGroup {
     sys.props("user.dir")
   )
 
-
   val projectName: Setting[String] = StringSetting (
     "-project",
     "project title",

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

@@ -33,6 +33,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
 
@@ -86,6 +87,7 @@ object Annotations {
       myBody
     }
     override def isEvaluated: Boolean = evaluated
+    override def isEvaluating: Boolean = evaluated && myBody == null
   }
 
   object Annotation {
@@ -171,8 +173,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

@@ -113,6 +113,11 @@ object Contexts {
     protected def owner_=(owner: Symbol): Unit = _owner = owner
     final 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]): Unit = _tree = tree
@@ -161,6 +166,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
+
     /** The current source file */
     private[this] var _source: SourceFile = _
     protected def source_=(source: SourceFile): Unit = _source = source
@@ -427,6 +458,7 @@ object Contexts {
       _period = outer.period
       _mode = outer.mode
       _owner = outer.owner
+      _inTypeOfOwner = outer.inTypeOfOwner
       _tree = outer.tree
       _scope = outer.scope
       _typerState = outer.typerState
@@ -437,6 +469,11 @@ object Contexts {
       _source = outer.source
       _moreProperties = outer.moreProperties
       _store = outer.store
+      // 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.
+      _dependentInit = false
       this
     }
 
@@ -523,6 +560,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 }
@@ -592,6 +630,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 {
@@ -668,6 +708,7 @@ object Contexts {
     def initialize()(implicit ctx: Context): Unit = {
       _platform = newPlatform
       definitions.init()
+      typeNormalizationFuel = settings.YtypeNormalizationFuel.value
     }
 
     def squashed(p: Phase): Phase = {
@@ -772,6 +813,8 @@ object Contexts {
     def checkSingleThreaded(): Unit =
       if (thread == null) thread = Thread.currentThread()
       else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
+
+    private[dotc] var typeNormalizationFuel: Int = 0
   }
 
   sealed abstract class GADTMap {

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

@@ -395,6 +395,9 @@ object Flags {
   /** Labeled with `erased` modifier (erased value)  */
   final val Erased: FlagSet = 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 */
@@ -463,7 +466,7 @@ object Flags {
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque
 
   final val TermSourceModifierFlags: FlagSet =
-    CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Erased
+    CommonSourceModifierFlags.toTermFlags | Inline | Dependent | AbsOverride | Lazy | Erased
 
   /** Flags representing modifiers that can appear in trees */
   final val ModifierFlags: FlagSet =
@@ -483,7 +486,7 @@ object Flags {
     Scala2ExistentialCommon | MutableOrOpaque | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessor.toCommonFlags |
     Extension.toCommonFlags | NonMember | Implicit | Implied | Permanent | Synthetic |
-    SuperAccessorOrScala2x | Inline
+    SuperAccessorOrScala2x | Inline | 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
@@ -591,7 +594,7 @@ object Flags {
   final val StableOrErased: FlagSet = StableRealizable | Erased
 
   /** Labeled `private`, `final`, or `inline` */
-  final val EffectivelyFinal: FlagSet = Private | Final | Inline
+  final val EffectivelyFinal: FlagSet = Private | Final | Inline  | Dependent
 
   /** A private method */
   final val PrivateMethod: FlagConjunction = allOf(Private, Method)
@@ -602,6 +605,9 @@ object Flags {
   /** An inline method */
   final val InlineMethod: FlagConjunction = allOf(Inline, Method)
 
+  /** A dependent method */
+  final val DependentMethod = allOf(Dependent, Method)
+
   /** An inline by-name parameter proxy */
   final val InlineByNameProxy: FlagConjunction = allOf(InlineProxy, Method)
 

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

@@ -99,6 +99,9 @@ object Mode {
   /** Read comments from definitions when unpickling from TASTY */
   val ReadComments: Mode = newMode(22, "ReadComments")
 
+  /** We are in TypeOf, e.g. to type a SingletonTypeTree or to compute a derived TypeOf */
+  val InTypeOf: Mode = newMode(23, "InTypeOf")
+
   /** We are synthesizing the receiver of an extension method */
   val SynthesizeExtMethodReceiver: Mode = newMode(23, "SynthesizeExtMethodReceiver")
 }