[CI Only] Check approach

Author: abgruszecki

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

@@ -874,10 +874,7 @@ object Contexts {
                 boundCache = boundCache.updated(sym, bounds)
                 bounds
             }
-          ).reporting({ res =>
-            // i"gadt bounds $sym: $res"
-            ""
-          }, gadts)
+          )// .reporting({ res => i"gadt bounds $sym: $res" }, gadts)
       }
     }
 

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

@@ -148,7 +148,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
 
   def isSubType(tp1: Type, tp2: Type)(implicit nc: AbsentContext): Boolean = isSubType(tp1, tp2, NoApprox)
 
-  protected def recur(tp1: Type, tp2: Type): Boolean = trace(s"isSubType ${traceInfo(tp1, tp2)} $approx", subtyping) {
+  protected def frozenDescr = if (frozenConstraint) " frozen" else ""
+  protected def recur(tp1: Type, tp2: Type): Boolean = trace(s"isSubType ${traceInfo(tp1, tp2)} $approx$frozenDescr", subtyping) {
 
     def monitoredIsSubType = {
       if (pendingSubTypes == null) {
@@ -541,11 +542,19 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
         }
         compareTypeLambda
       case OrType(tp21, tp22) =>
-        val tp1a = tp1.widenDealiasKeepRefiningAnnots
-        if (tp1a ne tp1)
-          // Follow the alias; this might avoid truncating the search space in the either below
-          // Note that it's safe to widen here because singleton types cannot be part of `|`.
-          return recur(tp1a, tp2)
+        // Note: this code assumes that or-types are left-associative
+        def isSingletonlessTypeUnion(tp: Type): Boolean = tp match {
+          case OrType(a, b) => !b.isSingleton && isSingletonlessTypeUnion(a)
+          case _ => !tp.isSingleton
+        }
+        if (!tp22.isSingleton && isSingletonlessTypeUnion(tp21)) {
+          val tp1a = tp1.widenDealiasKeepRefiningAnnots
+          if (tp1a ne tp1)
+            // Follow the alias; this might avoid truncating the search space in the either below
+            // Note that it's safe to widen here because we ensured that
+            // singleton types are not top-level members of tp2
+            return recur(tp1a, tp2)
+        }
 
         // Rewrite T1 <: (T211 & T212) | T22 to T1 <: (T211 | T22) and T1 <: (T212 | T22)
         // and analogously for T1 <: T21 | (T221 & T222)
@@ -1238,7 +1247,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
    *  Test that the resulting bounds are still satisfiable.
    */
   private def narrowGADTBounds(tr: NamedType, bound: Type, approx: ApproxState, isUpper: Boolean): Boolean = {
-    val boundImprecise = if (isUpper) approx.high else approx.low
+     val boundImprecise = approx.high || approx.low
+//    val boundImprecise = if (isUpper) approx.high else approx.low
     ctx.mode.is(Mode.GADTflexible) && !frozenConstraint && !boundImprecise && {
       val tparam = tr.symbol
       gadts.println(i"narrow gadt bound of $tparam: ${tparam.info} from ${if (isUpper) "above" else "below"} to $bound ${bound.toString} ${bound.isRef(tparam)}")

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

@@ -2752,6 +2752,7 @@ object Types {
   object OrType {
     def apply(tp1: Type, tp2: Type)(implicit ctx: Context): OrType = {
       assertUnerased()
+      assert(!tp2.dealias.isInstanceOf[OrType])
       unique(new CachedOrType(tp1, tp2))
     }
     def make(tp1: Type, tp2: Type)(implicit ctx: Context): Type =

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

@@ -1025,6 +1025,11 @@ class Typer extends Namer
 
   /** gadtSyms = "all type parameters of enclosing methods appearing in selector type" */
   def gadtSyms(selType: Type)(implicit ctx: Context): Set[Symbol] = trace(i"GADT syms of $selType", gadts) {
+//    def enclosingRealMethod(sym: Symbol): Symbol =
+//      if (sym.isRealMethod) sym else if (sym.exists) enclosingRealMethod(sym) else NoSymbol
+//    val erm = enclosingRealMethod(ctx.owner)
+//    ctx.tree
+    // println(i"gadtSyms: owner=${ctx.owner} erm=$erm info=${erm.initial} mbr=${erm.info.allMembers} candidate=${erm.termRef.widenTermRefExpr.asInstanceOf[PolyType].paramInfoss}%, %")
     val accu = new TypeAccumulator[Set[Symbol]] {
       def apply(tsyms: Set[Symbol], t: Type): Set[Symbol] = {
         val tsyms1 = t match {
@@ -1520,19 +1525,38 @@ class Typer extends Namer
     if (sym is Implicit) 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 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)(rhsCtx)
 
     if (sym.isInlineMethod) PrepareInlineable.registerInlineInfo(sym, ddef.rhs, _ => rhs1)

tests/pos/candidate.scala

@@ -0,0 +1,3 @@
+object buffer2 {
+  var Some(z) = Some(0)
+}