Simplify isClosed logic

Author: nicolasstucki

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

@@ -24,7 +24,7 @@ import dotty.tools.dotc.core.Symbols.*
  *
  *   Operations:
  *   - `s =?= p` checks if a scrutinee `s` matches the pattern `p` while accumulating extracted parts of the code.
- *   - `isClosedUnder(x1, .., xn)('{e})` returns true if and only if all the references in `e` to names defined in the pattern are contained in the set `{x1, ... xn}`.
+ *   - `isClosedUnderEnv(x1, .., xn)('{e})` returns true if and only if all the references in `e` to names defined in the pattern are contained in the set `{x1, ... xn}`.
  *   - `lift(x1, .., xn)('{e})` returns `(y1, ..., yn) => [xi = $yi]'{e}` where `yi` is an `Expr` of the type of `xi`.
  *   - `withEnv(x1 -> y1, ..., xn -> yn)(matching)` evaluates matching recording that `xi` is equivalent to `yi`.
  *   - `matched` denotes that the the match succeeded and `matched('{e})` denotes that a match succeeded and extracts `'{e}`
@@ -34,10 +34,10 @@ import dotty.tools.dotc.core.Symbols.*
  *
  *   ```scala
  *   /* Term hole */
- *   '{ e } =?= '{ hole[T] }  &&  typeOf('{e}) <:< T && isClosedUnder()('{e})  ===>   matched('{e})
+ *   '{ e } =?= '{ hole[T] }  &&  typeOf('{e}) <:< T && isClosedUnderEnv()('{e})  ===>   matched('{e})
  *
  *   /* Higher order term hole */
- *   '{ e } =?= '{ hole[(T1, ..., Tn) => T](x1, ..., xn) }  &&  isClosedUnder(x1, ... xn)('{e})  ===>   matched(lift(x1, ..., xn)('{e}))
+ *   '{ e } =?= '{ hole[(T1, ..., Tn) => T](x1, ..., xn) }  &&  isClosedUnderEnv(x1, ... xn)('{e})  ===>   matched(lift(x1, ..., xn)('{e}))
  *
  *   /* Match literal */
  *   '{ lit } =?= '{ lit }   ===>   matched
@@ -199,12 +199,9 @@ object QuoteMatcher {
         /* 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 =>
-          scrutinee match
-            case ClosedPatternTerm(scrutinee) => matched(scrutinee)
-            case _ => notMatched
-
+            if patternHole.symbol.eq(defn.QuotedRuntimePatterns_patternHole) =>
+          if scrutinee.tpe <:< tpt.tpe && isClosedUnderEnvEnv(scrutinee) then matched(scrutinee)
+          else notMatched
 
         /* Higher order term hole */
         // Matches an open term and wraps it into a lambda that provides the free variables
@@ -431,21 +428,19 @@ object QuoteMatcher {
     || summon[Env].get(devirtualizedScrutinee).contains(pattern)
     || devirtualizedScrutinee.allOverriddenSymbols.contains(pattern)
 
-  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]] {
-        def apply(x: Set[Symbol], tree: Tree)(using Context): Set[Symbol] =
-          tree match
-            case tree: Ident if summon[Env].contains(tree.symbol) => foldOver(x + tree.symbol, tree)
-            case _ => foldOver(x, tree)
-      }
-      accumulator.apply(Set.empty, term)
-  }
+  /** Matches a term that does not contain free variables defined in the pattern (i.e. not defined in `Env`) */
+  private def isClosedUnderEnvEnv(term: Tree)(using Env, Context): Boolean =
+    freePatternVars(term).isEmpty
+
+  /** Return all free variables of the term defined in the pattern (i.e. defined in `Env`) */
+  private def freePatternVars(term: Tree)(using Env, Context): Set[Symbol] =
+    val accumulator = new TreeAccumulator[Set[Symbol]] {
+      def apply(x: Set[Symbol], tree: Tree)(using Context): Set[Symbol] =
+        tree match
+          case tree: Ident if summon[Env].contains(tree.symbol) => foldOver(x + tree.symbol, tree)
+          case _ => foldOver(x, tree)
+    }
+    accumulator.apply(Set.empty, term)
 
   /** Result of matching a part of an expression */
   private opaque type Matching = Option[Tuple]