Fix ignored type variable bound warning in type quote pattern

Author: nicolasstucki

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

@@ -110,8 +110,6 @@ trait QuotesAndSplices {
   def typedSplicePattern(tree: untpd.SplicePattern, pt: Type)(using Context): Tree = {
     record("typedSplicePattern")
     if isFullyDefined(pt, ForceDegree.flipBottom) then
-      def patternOuterContext(ctx: Context): Context =
-        if (ctx.mode.is(Mode.QuotedPattern)) patternOuterContext(ctx.outer) else ctx
       val typedArgs = withMode(Mode.InQuotePatternHoasArgs) {
         tree.args.map {
           case arg: untpd.Ident =>
@@ -125,8 +123,7 @@ trait QuotesAndSplices {
         report.error("References to `var`s cannot be used in higher-order pattern", arg.srcPos)
       val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
       val patType = if tree.args.isEmpty then pt else defn.FunctionOf(argTypes, pt)
-      val pat = typedPattern(tree.body, defn.QuotedExprClass.typeRef.appliedTo(patType))(
-        using spliceContext.retractMode(Mode.QuotedPattern).addMode(Mode.Pattern).withOwner(patternOuterContext(ctx).owner))
+      val pat = typedPattern(tree.body, defn.QuotedExprClass.typeRef.appliedTo(patType))(using quotePatternSpliceContext)
       val baseType = pat.tpe.baseType(defn.QuotedExprClass)
       val argType = if baseType.exists then baseType.argTypesHi.head else defn.NothingType
       untpd.cpy.SplicePattern(tree)(pat, typedArgs).withType(pt)
@@ -166,14 +163,27 @@ trait QuotesAndSplices {
     val typeSymInfo = pt match
       case pt: TypeBounds => pt
       case _ => TypeBounds.empty
+
+    def warnOnInferredBounds(typeSym: Symbol) =
+      if !(typeSymInfo =:= TypeBounds.empty) && !(typeSym.info <:< typeSymInfo) then
+        val (openQuote, closeQuote) = if isInQuotedExprPattern then ("'{", "}") else ("'[", "]")
+        if isInQuotedTypePattern then // TODO remove this branch once SIP-53 is non-experimental
+          report.warning(
+            em"""Ignored bound$typeSymInfo
+                |
+                |This kind of pattern will be supported with SIP-53.
+                |SIP-53: https://docs.scala-lang.org/sips/quote-pattern-type-variable-syntax.html
+                |""", tree.srcPos)
+        else
+          report.warning(em"Ignored bound$typeSymInfo\n\nConsider defining bounds explicitly:\n  $openQuote $typeSym${typeSym.info & typeSymInfo}; ... $closeQuote", 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")
-        if !(typeSymInfo =:= TypeBounds.empty) && !(typeSym.info <:< typeSymInfo) then
-          report.warning(em"Ignored bound$typeSymInfo\n\nConsider defining bounds explicitly `'{ $typeSym${typeSym.info & typeSymInfo}; ... }`", tree.srcPos)
+        warnOnInferredBounds(typeSym)
         ref(typeSym)
       case None =>
         def spliceOwner(ctx: Context): Symbol =
@@ -454,7 +464,7 @@ trait QuotesAndSplices {
         "\n\nSIP-53: https://docs.scala-lang.org/sips/quote-pattern-type-variable-syntax.html")
 
     val (typeTypeVariables, patternCtx) =
-      val quoteCtx = quotePatternContext()
+      val quoteCtx = quotePatternContext(quoted.isType)
       if untpdTypeVariables.isEmpty then (Nil, quoteCtx)
       else typedBlockStats(untpdTypeVariables)(using quoteCtx)
 
@@ -536,20 +546,49 @@ 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]]
 
+  /** Key that track in which kind of quote pattern we are */
+  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] =
     ctx.property(TypeVariableKey).get.get(name)
 
-    /** Get the symbol for the quoted pattern type variable if it exists */
+  /** Get the symbol for the quoted pattern type variable if it exists */
   def addQuotedPatternTypeVariable(sym: Symbol)(using Context): Unit =
     ctx.property(TypeVariableKey).get.update(sym.name.asTypeName, sym)
 
-  /** Context used to type the contents of a quoted */
-  def quotePatternContext()(using Context): Context =
+  /** Is the current context in a quoted expression pattern?
+   *  But not in the splice of a quoted expression pattern.
+   */
+  def isInQuotedExprPattern(using Context): Boolean =
+    ctx.property(QuotePattenKindKey).contains(QuotePattenKind.Expr)
+
+  /** Is the current context in a quoted type pattern?
+   *  But not in the splice of a quoted type pattern.
+   */
+  def isInQuotedTypePattern(using Context): Boolean =
+    ctx.property(QuotePattenKindKey).contains(QuotePattenKind.Type)
+
+  /** Context used to type the contents of a quote pattern */
+  def quotePatternContext(isTypePattern: Boolean)(using Context): Context =
     quoteContext.fresh.setNewScope
       .addMode(Mode.QuotedPattern).retractMode(Mode.Pattern)
+      .addMode(Mode.QuotedPattern).retractMode(Mode.Pattern) // TODO do we need Mode.QuotedPattern?
       .setProperty(TypeVariableKey, collection.mutable.Map.empty)
+      .setProperty(QuotePattenKindKey, if isTypePattern then QuotePattenKind.Type else QuotePattenKind.Expr)
+
+  /** Context used to type the contents of a quote pattern splice */
+  def quotePatternSpliceContext(using Context): Context =
+    def patternOuterContext(ctx: Context): Context =
+      if ctx.mode.is(Mode.QuotedPattern) then patternOuterContext(ctx.outer) else ctx
+    spliceContext
+      .retractMode(Mode.QuotedPattern).addMode(Mode.Pattern)
+      .dropProperty(QuotePattenKindKey)
+      .withOwner(patternOuterContext(ctx).owner)
 }

tests/neg-macros/quote-type-variable-no-inference.check

@@ -3,7 +3,8 @@
   |                 ^
   |                 Ignored bound <: Double
   |
-  |                 Consider defining bounds explicitly `'{ type t <: Int & Double; ... }`
+  |                 This kind of pattern will be supported with SIP-53.
+  |                 SIP-53: https://docs.scala-lang.org/sips/quote-pattern-type-variable-syntax.html
 -- [E057] Type Mismatch Error: tests/neg-macros/quote-type-variable-no-inference.scala:5:9 -----------------------------
 5 |    case '[ F[t, t] ] => // warn // error // error
   |         ^