Warn on use of inferred quote type variable bounds

This kind of inference is not reliable. We can only consider the bounds
from type constructor where the type variable is defined but any other
constraints are ignored. Therefore it is not possible to properly infer
the type bounds of the type variable.

The solution is simple, write the bounds explicitly and just check that
those bounds conform to the use site of the type variable.

Author: nicolasstucki

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

@@ -164,25 +164,38 @@ trait QuotesAndSplices {
       case pt: TypeBounds => pt
       case _ => TypeBounds.empty
 
-    def warnOnInferredBounds(typeSym: Symbol) =
+    def warnOnInferredBounds(typeSym: Symbol, ignoredBounds: Boolean) =
       if !(typeSymInfo =:= TypeBounds.empty) && !(typeSym.info <:< typeSymInfo) then
         val (openQuote, closeQuote) = if ctx.mode.is(Mode.QuotedExprPattern) then ("'{", "}") else ("'[", "]")
-        report.warning(em"Ignored bound$typeSymInfo\n\nConsider defining bounds explicitly:\n  $openQuote $typeSym${typeSym.info & typeSymInfo}; ... $closeQuote", tree.srcPos)
+        if ignoredBounds then
+          report.warning(em"Ignored bound$typeSymInfo\n\nConsider defining bounds explicitly:\n  $openQuote $typeSym${typeSym.info & typeSymInfo}; ... $closeQuote", tree.srcPos)
+        else
+          // TODO only keep this branch this guard once SIP-53 is non-experimental
+          val extra =
+            if ctx.mode.is(Mode.QuotedExprPattern) then ""
+            else s"""
+                 |Explicit type pattern in quoted type patterns is not supported yet.
+                 |This kind of pattern will be supported with SIP-53.
+                 |SIP-53: https://docs.scala-lang.org/sips/quote-pattern-type-variable-syntax.html
+                 |""".stripMargin
+
+          report.warning(em"Type variable `$tree` has partially inferred bounds$typeSymInfo.\n\nConsider defining bounds explicitly:\n  $openQuote $typeSym$typeSymInfo; ... $closeQuote$extra", tree.srcPos)
 
     getQuotedPatternTypeVariable(tree.name.asTypeName) match
       case Some(typeSym) =>
         checkExperimentalFeature(
           "support for multiple references to the same type (without backticks) in quoted type patterns (SIP-53)",
           tree.srcPos,
           "\n\nSIP-53: https://docs.scala-lang.org/sips/quote-pattern-type-variable-syntax.html")
-        warnOnInferredBounds(typeSym)
+        warnOnInferredBounds(typeSym, ignoredBounds = true)
         ref(typeSym)
       case None =>
         val spliceContext = quotePatternSpliceContext
         val name = tree.name.toTypeName
         val nameOfSyntheticGiven = PatMatGivenVarName.fresh(tree.name.toTermName)
         val expr = untpd.cpy.Ident(tree)(nameOfSyntheticGiven)
         val typeSym = newSymbol(spliceContext.owner, name, EmptyFlags, typeSymInfo, NoSymbol, tree.span)
+        warnOnInferredBounds(typeSym, ignoredBounds = false)
         typeSym.addAnnotation(Annotation(New(ref(defn.QuotedRuntimePatterns_patternTypeAnnot.typeRef)).withSpan(tree.span)))
         addQuotedPatternTypeVariable(typeSym)
         val pat = typedPattern(expr, defn.QuotedTypeClass.typeRef.appliedTo(typeSym.typeRef))(using spliceContext)
@@ -536,8 +549,12 @@ trait QuotesAndSplices {
 object QuotesAndSplices {
   import tpd._
 
+  private enum QuotePattenKind:
+    case Expr, Type
+
   /** Key for mapping from quoted pattern type variable names into their symbol */
   private val TypeVariableKey = new Property.Key[collection.mutable.Map[TypeName, Symbol]]
+  private val QuotePattenKindKey = new Property.Key[QuotePattenKind]
 
   /** Get the symbol for the quoted pattern type variable if it exists */
   def getQuotedPatternTypeVariable(name: TypeName)(using Context): Option[Symbol] =

tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.check

@@ -0,0 +1,50 @@
+-- Error: tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala:11:18 ----------------------------------
+11 |    case '{ $x: C[t] } => // error
+   |                  ^
+   |                  Type variable `t` has partially inferred bounds <: Int.
+   |
+   |                  Consider defining bounds explicitly:
+   |                    '{ type t <: Int; ... }
+-- Error: tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala:12:18 ----------------------------------
+12 |    case '{ $x: D[t] } => // error
+   |                  ^
+   |                  Type variable `t` has partially inferred bounds >: Null <: String.
+   |
+   |                  Consider defining bounds explicitly:
+   |                    '{ type t >: Null <: String; ... }
+-- Error: tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala:15:18 ----------------------------------
+15 |    case '{ $x: E[t, t] } => // error
+   |                  ^
+   |                  Type variable `t` has partially inferred bounds <: Int.
+   |
+   |                  Consider defining bounds explicitly:
+   |                    '{ type t <: Int; ... }
+-- Error: tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala:17:18 ----------------------------------
+17 |    case '{ $x: F[t, t] } => // error // error
+   |                  ^
+   |                  Type variable `t` has partially inferred bounds <: Int.
+   |
+   |                  Consider defining bounds explicitly:
+   |                    '{ type t <: Int; ... }
+-- Error: tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala:17:21 ----------------------------------
+17 |    case '{ $x: F[t, t] } => // error // error
+   |                     ^
+   |                     Ignored bound <: String
+   |
+   |                     Consider defining bounds explicitly:
+   |                       '{ type t <: Int & String; ... }
+-- Error: tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala:18:36 ----------------------------------
+18 |    case '{ type t <: Int; $x: F[t, t] } => // error
+   |                                    ^
+   |                                    Ignored bound <: String
+   |
+   |                                    Consider defining bounds explicitly:
+   |                                      '{ type t <: Int & String; ... }
+-- Error: tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala:24:17 ----------------------------------
+24 |    case '[ F[t, t] ] => // error // will have a second error with SIP-53
+   |                 ^
+   |                 Ignored bound <: String
+   |
+   |                 This bound pattern is not supported yet.
+   |                 This kind of pattern will be supported with SIP-53.
+   |                 SIP-53: https://docs.scala-lang.org/sips/quote-pattern-type-variable-syntax.html

tests/neg-custom-args/fatal-warnings/quote-type-var-with-bounds.scala

@@ -0,0 +1,24 @@
+import scala.quoted.*
+
+class C[T <: Int]
+class D[T >: Null <: String]
+class E[T <: Int, U <: Int]
+class F[T <: Int, U <: String]
+
+def test[T: Type](e: Expr[Any])(using Quotes) =
+  e match
+    case '{ $x: t } =>
+    case '{ $x: C[t] } => // error
+    case '{ $x: D[t] } => // error
+    case '{ type t <: Int; $x: C[t] } =>
+
+    case '{ $x: E[t, t] } => // error
+
+    case '{ $x: F[t, t] } => // error // error
+    case '{ type t <: Int; $x: F[t, t] } => // error
+
+  Type.of[T] match
+    case '[ C[t] ] => // will have an error with SIP-53
+    case '[ D[t] ] => // will have an error with SIP-53
+    case '[ E[t, t] ] => // will have an error with SIP-53
+    case '[ F[t, t] ] => // error // will have a second error with SIP-53