change MatchTypeInDisguise scope

Author: rochala

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -23,10 +23,6 @@ import dotty.tools.dotc.util.SourcePosition
 
 import scala.collection.mutable
 import scala.util.control.NonFatal
-import dotty.tools.dotc.core.Types.MatchType
-import dotty.tools.dotc.core.Types.AppliedType
-import dotty.tools.dotc.core.Types.TypeRef
-import dotty.tools.dotc.core.Types.MatchAlias
 
 /**
  * One of the results of a completion query.
@@ -369,24 +365,8 @@ object Completion {
 
     /** Completions for derived members of `MatchType`'s type. */
     def matchTypeCompletions(qual: Tree)(using Context): CompletionMap =
-      /** Extractor for match types hidden behind an AppliedType/MatchAlias */
-      object MatchTypeInDisguise {
-        def unapply(tp: AppliedType): Option[MatchType] = tp match {
-          case AppliedType(tycon: TypeRef, args) =>
-            tycon.info match {
-              case MatchAlias(alias) =>
-                alias.applyIfParameterized(args) match {
-                  case mt: MatchType => Some(mt)
-                  case _ => None
-                }
-              case _ => None
-            }
-          case _ => None
-        }
-      }
-
       qual.tpe.widenDealias match 
-        case MatchTypeInDisguise(mt) => accessibleMembers(mt.reduced).groupByName
+        case ctx.typer.MatchTypeInDisguise(mt) => accessibleMembers(mt.reduced).groupByName
         case _ => Map.empty 
 
     /** Completions from extension methods */

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

@@ -1499,6 +1499,22 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     assignType(cpy.Closure(tree)(env1, meth1, target), meth1, target)
   }
 
+  /** Extractor for match types hidden behind an AppliedType/MatchAlias */
+  object MatchTypeInDisguise {
+    def unapply(tp: AppliedType)(using Context): Option[MatchType] = tp match {
+      case AppliedType(tycon: TypeRef, args) =>
+        tycon.info match {
+          case MatchAlias(alias) =>
+            alias.applyIfParameterized(args) match {
+              case mt: MatchType => Some(mt)
+              case _ => None
+            }
+          case _ => None
+        }
+      case _ => None
+    }
+  }
+
   def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
     tree.selector match {
       case EmptyTree =>
@@ -1526,21 +1542,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         val selType = rawSelectorTpe match
           case c: ConstantType if tree.isInline => c
           case otherTpe => otherTpe.widen
-        /** Extractor for match types hidden behind an AppliedType/MatchAlias */
-        object MatchTypeInDisguise {
-          def unapply(tp: AppliedType): Option[MatchType] = tp match {
-            case AppliedType(tycon: TypeRef, args) =>
-              tycon.info match {
-                case MatchAlias(alias) =>
-                  alias.applyIfParameterized(args) match {
-                    case mt: MatchType => Some(mt)
-                    case _ => None
-                  }
-                case _ => None
-              }
-            case _ => None
-          }
-        }
 
         /** Does `tree` has the same shape as the given match type?
          *  We only support typed patterns with empty guards, but