Detect uncaptured used of type variables

Author: zeptometer

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

@@ -268,18 +268,6 @@ sealed trait GadtState {
     finally if !result then restore(saved)
     result
 
-  def unifySyms(params1: List[Symbol], params2: List[Symbol])(using Context) =
-    addToConstraint(params1)
-    addToConstraint(params2)
-    val paramrefs1 = params1 map (gadt.tvarOrError(_))
-    val paramrefs2 = params2 map (gadt.tvarOrError(_))
-    for ((p1, p2) <- paramrefs1.zip(paramrefs2))
-    do
-      println(s"unifySyms: adding constr ${p1.show} <:< ${p2.show}")
-      addLess(p1.origin, p2.origin)
-      println(s"unifySyms: adding constr ${p2.show} <:< ${p1.show}")
-      addLess(p2.origin, p1.origin)
-
   // ---- Protected/internal -----------------------------------------------
 
   override protected def constraint = gadt.constraint

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

@@ -171,7 +171,6 @@ trait QuotesAndSplices {
       val splice1 = typedSplicePattern(splice, defn.FunctionOf(argTypes, pt))
       untpd.cpy.Apply(tree)(splice1.select(nme.apply), typedArgs).withType(pt)
     else // $x(...) higher-order quasipattern
-      // TODO-18271: Case for highr-order quasi-quote pattern with type params
       if args.isEmpty then
          report.error("Missing arguments for open pattern", tree.srcPos)
       typedSplicePattern(untpd.cpy.SplicePattern(tree)(splice.body, Nil, args), pt)
@@ -406,7 +405,6 @@ object QuotesAndSplices {
         val resultType1 = resultType.subst(fromSymbols, pt.paramRefs)
         MethodType(args1, resultType1)
       }
-      val tpe = PolyType(typeargs1)(_ => bounds, resultTypeExp)
-      RefinedType(defn.PolyFunctionType, nme.apply, tpe)
+      defn.PolyFunctionOf(PolyType(typeargs1)(_ => bounds, resultTypeExp))
   }
 }

compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala

@@ -244,14 +244,14 @@ class QuoteMatcher(debug: Boolean) {
             if patternHole.symbol.eq(defn.QuotedRuntimePatterns_patternHole) &&
                tpt2.tpe.derivesFrom(defn.RepeatedParamClass) =>
           scrutinee match
-            case Typed(s, tpt1) if s.tpe <:< tpt.tpe => matched(scrutinee)
+            case Typed(s, tpt1) if isSubTypeUnderEnv(s, tpt) => matched(scrutinee)
             case _ => notMatched
 
         /* Term hole */
         // Match a scala.internal.Quoted.patternHole and return the scrutinee tree
         case TypeApply(patternHole, tpt :: Nil)
             if patternHole.symbol.eq(defn.QuotedRuntimePatterns_patternHole) &&
-                scrutinee.tpe <:< tpt.tpe =>
+                isSubTypeUnderEnv(scrutinee, tpt) =>
           scrutinee match
             case ClosedPatternTerm(scrutinee) => matched(scrutinee)
             case _ => notMatched
@@ -360,7 +360,7 @@ class QuoteMatcher(debug: Boolean) {
                 /* Match reference */
                 case _: Ident if symbolMatch(scrutinee, pattern) => matched
                 /* Match type */
-                case TypeTreeTypeTest(pattern) if scrutinee.tpe <:< pattern.tpe => matched
+                case TypeTreeTypeTest(pattern) if isSubTypeUnderEnv(scrutinee, pattern) => matched
                 case _ => notMatched
 
             /* Match application */
@@ -439,7 +439,7 @@ class QuoteMatcher(debug: Boolean) {
             // TODO remove this?
             case TypeTreeTypeTest(scrutinee) =>
               pattern match
-                case TypeTreeTypeTest(pattern) if scrutinee.tpe <:< pattern.tpe => matched
+                case TypeTreeTypeTest(pattern) if isSubTypeUnderEnv(scrutinee, pattern) => matched
                 case _ => notMatched
 
             /* Match val */
@@ -476,8 +476,13 @@ class QuoteMatcher(debug: Boolean) {
                       case (scparams :: screst, ptparams :: ptrest) =>
                         (scparams, ptparams) match
                           case (TypeDefs(scparams), TypeDefs(ptparams)) =>
-                            matchTypeParams(scparams, ptparams)
-                            matchParamss(screst, ptrest)
+                            scparams.foreach(tdef => println(s"tdef.rhs = ${tdef.rhs.show}"))
+                            if scparams.exists(tdef => tdef.rhs.isEmpty) then
+                              notMatched
+
+                            val newEnv = summon[Env] ++ scparams.map(_.symbol).zip(ptparams.map(_.symbol))
+                            val (resEnv, mrrest) = withEnv(newEnv)(matchParamss(screst, ptrest))
+                            (resEnv, mrrest)
                           case (ValDefs(scparams), ValDefs(ptparams)) =>
                             val mr1 = matchLists(scparams, ptparams)(_ =?= _)
                             val newEnv = summon[Env] ++ scparams.map(_.symbol).zip(ptparams.map(_.symbol))
@@ -569,20 +574,32 @@ class QuoteMatcher(debug: Boolean) {
     || summon[Env].get(devirtualizedScrutinee).contains(pattern)
     || devirtualizedScrutinee.allOverriddenSymbols.contains(pattern)
 
+  private def isSubTypeUnderEnv(scrutinee: Tree, pattern: Tree)(using Env, Context): Boolean =
+    val env = summon[Env]
+    scrutinee.subst(env.keys.toList, env.values.toList).tpe <:< pattern.tpe
+
   private object ClosedPatternTerm {
     /** Matches a term that does not contain free variables defined in the pattern (i.e. not defined in `Env`) */
     def unapply(term: Tree)(using Env, Context): Option[term.type] =
       if freePatternVars(term).isEmpty then Some(term) else None
 
     /** Return all free variables of the term defined in the pattern (i.e. defined in `Env`) */
     def freePatternVars(term: Tree)(using Env, Context): Set[Symbol] =
-      val accumulator = new TreeAccumulator[Set[Symbol]] {
+      val typeAccumulator = new TypeAccumulator[Set[Symbol]] {
+        def apply(x: Set[Symbol], tp: Type): Set[Symbol] =
+          if summon[Env].contains(tp.typeSymbol) then
+            foldOver(x + tp.typeSymbol, tp)
+          else
+            foldOver(x, tp)
+      }
+      val treeAccumulator = new TreeAccumulator[Set[Symbol]] {
         def apply(x: Set[Symbol], tree: Tree)(using Context): Set[Symbol] =
+          val tvars = typeAccumulator(Set.empty, tree.tpe)
           tree match
-            case tree: Ident if summon[Env].contains(tree.symbol) => foldOver(x + tree.symbol, tree)
-            case _ => foldOver(x, tree)
+            case tree: Ident if summon[Env].contains(tree.symbol) => foldOver(x ++ tvars + tree.symbol, tree)
+            case _ => foldOver(x ++ tvars, tree)
       }
-      accumulator.apply(Set.empty, term)
+      treeAccumulator(Set.empty, term)
   }
 
   enum MatchResult:
@@ -685,16 +702,6 @@ class QuoteMatcher(debug: Boolean) {
   private def matchedOpen(tree: Tree, patternTpe: Type, argIds: List[Tree], argTypes: List[Type], typeArgs: List[Type], env: Env)(using Context): MatchingExprs =
     Seq(MatchResult.OpenTree(tree, patternTpe, argIds, argTypes, typeArgs, env))
 
-  // private def unifySyms(params1: List[Symbol], params2: List[Symbol])(using Context) =
-  //   ctx.gadtState.addToConstraint(params1)
-  //   ctx.gadtState.addToConstraint(params2)
-  //   val paramrefs1 = params1 map (ctx.gadt.tvarOrError(_))
-  //   val paramrefs2 = params2 map (ctx.gadt.tvarOrError(_))
-  //   for ((p1, p2) <- paramrefs1.zip(paramrefs2))
-  //   do
-  //     p1 <:< p2
-  //     p2 <:< p1
-
   extension (self: MatchingExprs)
       /** Concatenates the contents of two successful matchings */
       def &&& (that: MatchingExprs): MatchingExprs = self ++ that