Allow constraining type parameters of all enclosing functions

gadtSyms/gadtContext became redundant, so they were removed.

The logic in typedDefDef was adjusted to only create a fresh context
when necessary.

Author: abgruszecki

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

@@ -455,7 +455,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
                 case _ => false
               }) ||
               narrowGADTBounds(tp2, tp1, approx, isUpper = false)) &&
-            GADTusage(tp2.symbol)
+            { tp1.isRef(NothingClass) || GADTusage(tp2.symbol) }
         }
         isSubApproxHi(tp1, info2.lo) || compareGADT || fourthTry
 
@@ -714,7 +714,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
               (gbounds1 != null) &&
                 (isSubTypeWhenFrozen(gbounds1.hi, tp2) ||
                 narrowGADTBounds(tp1, tp2, approx, isUpper = true)) &&
-                GADTusage(tp1.symbol)
+                { tp2.isRef(AnyClass) || GADTusage(tp1.symbol) }
             }
             isSubType(hi1, tp2, approx.addLow) || compareGADT
           case _ =>

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -401,9 +401,9 @@ class TreeChecker extends Phase with SymTransformer {
         }
       }
 
-    override def typedCase(tree: untpd.CaseDef, selType: Type, pt: Type, gadtSyms: Set[Symbol])(implicit ctx: Context): CaseDef = {
+    override def typedCase(tree: untpd.CaseDef, selType: Type, pt: Type)(implicit ctx: Context): CaseDef = {
       withPatSyms(tpd.patVars(tree.pat.asInstanceOf[tpd.Tree])) {
-        super.typedCase(tree, selType, pt, gadtSyms)
+        super.typedCase(tree, selType, pt)
       }
     }
 

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -531,9 +531,12 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
   /** A utility object offering methods for rewriting inlined code */
   object reducer {
 
+    import dotty.tools.dotc.core.Contexts.GADTMap
+
     /** An extractor for terms equivalent to `new C(args)`, returning the class `C`,
      *  a list of bindings, and the arguments `args`. Can see inside blocks and Inlined nodes and can
      *  follow a reference to an inline value binding to its right hand side.
+ *
      *  @return    optionally, a triple consisting of
      *             - the class `C`
      *             - the arguments `args`
@@ -729,7 +732,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     def reduceInlineMatch(scrutinee: Tree, scrutType: Type, cases: List[CaseDef], typer: Typer)(implicit ctx: Context): MatchRedux = {
 
       val isImplicit = scrutinee.isEmpty
-      val gadtSyms = typer.gadtSyms(scrutType)
 
       /** Try to match pattern `pat` against scrutinee reference `scrut`. If successful add
        *  bindings for variables bound in this pattern to `caseBindingMap`.
@@ -920,7 +922,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           }
 
         if (!isImplicit) caseBindingMap += ((NoSymbol, scrutineeBinding))
-        val gadtCtx = typer.gadtContext(gadtSyms).addMode(Mode.GADTflexible)
+        val gadtCtx = ctx.fresh.setFreshGADTBounds.addMode(Mode.GADTflexible)
         if (reducePattern(caseBindingMap, scrutineeSym.termRef, cdef.pat)(gadtCtx)) {
           val (caseBindings, from, to) = substBindings(caseBindingMap.toList, mutable.ListBuffer(), Nil, Nil)
           val guardOK = cdef.guard.isEmpty || {

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1335,8 +1335,16 @@ class Namer { typer: Typer =>
       // it would be erased to BoxedUnit.
       def dealiasIfUnit(tp: Type) = if (tp.isRef(defn.UnitClass)) defn.UnitType else tp
 
-      var rhsCtx = ctx.addMode(Mode.InferringReturnType)
+      var rhsCtx = ctx.fresh.addMode(Mode.InferringReturnType)
       if (sym.isInlineMethod) rhsCtx = rhsCtx.addMode(Mode.InlineableBody)
+      if (typeParams.nonEmpty) {
+        rhsCtx.setFreshGADTBounds
+        typeParams.foreach { tdef =>
+          val TypeBounds(lo, hi) = tdef.info.bounds
+          rhsCtx.gadt.addBound(tdef, lo, isUpper = false)
+          rhsCtx.gadt.addBound(tdef, hi, isUpper = true)
+        }
+      }
       def rhsType = typedAheadExpr(mdef.rhs, (inherited orElse rhsProto).widenExpr)(rhsCtx).tpe
 
       // Approximate a type `tp` with a type that does not contain skolem types.

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1047,37 +1047,8 @@ class Typer extends Namer
     assignType(cpy.Match(tree)(sel, cases1), sel, cases1)
   }
 
-  /** gadtSyms = "all type parameters of enclosing methods that appear
-    *              non-variantly in the selector type" todo: should typevars
-    *              which appear with variances +1 and -1 (in different
-    *              places) be considered as well?
-    */
-  def gadtSyms(selType: Type)(implicit ctx: Context): Set[Symbol] = trace(i"GADT syms of $selType", gadts) {
-    val accu = new TypeAccumulator[Set[Symbol]] {
-      def apply(tsyms: Set[Symbol], t: Type): Set[Symbol] = {
-        val tsyms1 = t match {
-          case tr: TypeRef if (tr.symbol is TypeParam) && tr.symbol.owner.isTerm && variance == 0 =>
-            tsyms + tr.symbol
-          case _ =>
-            tsyms
-        }
-        foldOver(tsyms1, t)
-      }
-    }
-    accu(Set.empty, selType)
-  }
-
-  /** Context with fresh GADT bounds for all gadtSyms */
-  def gadtContext(gadtSyms: Set[Symbol])(implicit ctx: Context): Context = {
-    val gadtCtx = ctx.fresh.setFreshGADTBounds
-    for (sym <- gadtSyms)
-      if (!gadtCtx.gadt.contains(sym)) gadtCtx.gadt.addEmptyBounds(sym)
-    gadtCtx
-  }
-
   def typedCases(cases: List[untpd.CaseDef], selType: Type, pt: Type)(implicit ctx: Context): List[CaseDef] = {
-    val gadts = gadtSyms(selType)
-    cases.mapconserve(typedCase(_, selType, pt, gadts))
+    cases.mapconserve(typedCase(_, selType, pt))
   }
 
   /** - strip all instantiated TypeVars from pattern types.
@@ -1105,9 +1076,9 @@ class Typer extends Namer
     }
 
   /** Type a case. */
-  def typedCase(tree: untpd.CaseDef, selType: Type, pt: Type, gadtSyms: Set[Symbol])(implicit ctx: Context): CaseDef = track("typedCase") {
+  def typedCase(tree: untpd.CaseDef, selType: Type, pt: Type)(implicit ctx: Context): CaseDef = track("typedCase") {
     val originalCtx = ctx
-    val gadtCtx = gadtContext(gadtSyms)
+    val gadtCtx: Context = ctx.fresh.setFreshGADTBounds
 
     def caseRest(pat: Tree)(implicit ctx: Context) = {
       val pat1 = indexPattern(tree).transform(pat)
@@ -1537,19 +1508,38 @@ class Typer extends Namer
     if (sym is ImplicitOrImplied) checkImplicitConversionDefOK(sym)
     val tpt1 = checkSimpleKinded(typedType(tpt))
 
-    var rhsCtx = ctx
-    if (sym.isConstructor && !sym.isPrimaryConstructor && tparams1.nonEmpty) {
-      // for secondary constructors we need a context that "knows"
-      // that their type parameters are aliases of the class type parameters.
-      // See pos/i941.scala
-      rhsCtx = ctx.fresh.setFreshGADTBounds
-      (tparams1, sym.owner.typeParams).zipped.foreach { (tdef, tparam) =>
-        val tr = tparam.typeRef
-        rhsCtx.gadt.addBound(tdef.symbol, tr, isUpper = false)
-        rhsCtx.gadt.addBound(tdef.symbol, tr, isUpper = true)
+    val rhsCtx: Context = {
+      var _result: FreshContext = null
+      def resultCtx(): FreshContext = {
+        if (_result == null) _result = ctx.fresh
+        _result
+      }
+
+      if (tparams1.nonEmpty) {
+        resultCtx().setFreshGADTBounds
+        if (!sym.isConstructor) {
+          // if we're _not_ in a constructor, allow constraining type parameters
+          tparams1.foreach { tdef =>
+            val tb @ TypeBounds(lo, hi) = tdef.symbol.info.bounds
+            resultCtx().gadt.addBound(tdef.symbol, lo, isUpper = false)
+            resultCtx().gadt.addBound(tdef.symbol, hi, isUpper = true)
+          }
+        } else if (!sym.isPrimaryConstructor) {
+          // otherwise, for secondary constructors we need a context that "knows"
+          // that their type parameters are aliases of the class type parameters.
+          // See pos/i941.scala
+          (tparams1, sym.owner.typeParams).zipped.foreach { (tdef, tparam) =>
+            val tr = tparam.typeRef
+            resultCtx().gadt.addBound(tdef.symbol, tr, isUpper = false)
+            resultCtx().gadt.addBound(tdef.symbol, tr, isUpper = true)
+          }
+        }
       }
+
+      if (sym.isInlineMethod) resultCtx().addMode(Mode.InlineableBody)
+
+      if (_result ne null) _result else ctx
     }
-    if (sym.isInlineMethod) rhsCtx = rhsCtx.addMode(Mode.InlineableBody)
     val rhs1 = typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(rhsCtx)
 
     if (sym.isInlineMethod) {

tests/neg/classOf.check

@@ -2,5 +2,7 @@
 Test.C{I = String} is not a class type
 [116..117] in classOf.scala
 T is not a class type
+
+where:    T is a type in method f2 with bounds <: String
 [72..73] in classOf.scala
 T is not a class type

tests/pos/gadt-all-params.scala

@@ -0,0 +1,9 @@
+object `gadt-all-params` {
+  enum Expr[T] {
+    case UnitLit extends Expr[Unit]
+  }
+
+  def foo[T >: TT <: TT, TT](e: Expr[T]): T = e match {
+    case Expr.UnitLit => ()
+  }
+}

tests/pos/gadt-inference.scala

@@ -0,0 +1,44 @@
+object `gadt-inference` {
+  enum Expr[T] {
+    case StrLit(s: String) extends Expr[String]
+    case IntLit(i: Int) extends Expr[Int]
+  }
+  import Expr._
+
+  def eval[T](e: Expr[T]) =
+    e match {
+      case StrLit(s) =>
+        val a = (??? : T) : String
+        s : T
+      case IntLit(i) =>
+        val a = (??? : T) : Int
+        i : T
+    }
+
+  def nested[T](o: Option[Expr[T]]) =
+    o match {
+      case Some(e) => e match {
+        case StrLit(s) =>
+          val a = (??? : T) : String
+          s : T
+        case IntLit(i) =>
+          val a = (??? : T) : Int
+          i : T
+      }
+      case None => ???
+    }
+
+  def local[T](e: Expr[T]) = {
+    def eval[T](e: Expr[T]) =
+      e match {
+        case StrLit(s) =>
+          val a = (??? : T) : String
+          s : T
+        case IntLit(i) =>
+          val a = (??? : T) : Int
+          i : T
+      }
+
+    eval(e) : T
+  }
+}

tests/run-macros/tasty-extractors-3.check

@@ -10,6 +10,8 @@ Type.SymRef(IsClassDefSymbol(<scala.Any>), Type.ThisType(Type.SymRef(IsPackageDe
 
 Type.SymRef(IsTypeDefSymbol(<Test$._$_$T>), NoPrefix())
 
+Type.SymRef(IsTypeDefSymbol(<Test$._$_$T>), NoPrefix())
+
 TypeBounds(Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix())))), Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix())))))
 
 Type.SymRef(IsClassDefSymbol(<scala.Int>), Type.SymRef(IsPackageDefSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageDefSymbol(<<root>>), NoPrefix()))))