Merge pull request #2199 from retronym/ticket/7214

SI-7214 outer check based on dealiased pattern type.

2 files changed, 60 insertions, 1 deletions

diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index f5f577677c..ea193465ad 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -5365,7 +5365,9 @@ trait Types extends api.Types { self: SymbolTable =>
       case _ =>
         NoType
     }
-    patType match {
+    // See the test for SI-7214 for motivation for dealias. Later `treeCondStrategy#outerTest`
+    // generates an outer test based on `patType.prefix` with automatically dealises.
+    patType.dealias match {
       case TypeRef(pre, sym, args) =>
         val pre1 = maybeCreateDummyClone(pre, sym)
         (pre1 ne NoType) && isPopulated(copyTypeRef(patType, pre1, sym, args), selType)
diff --git a/test/files/run/t7214.scala b/test/files/run/t7214.scala
new file mode 100644
index 0000000000..ff1ea8082d
--- /dev/null
+++ b/test/files/run/t7214.scala
@@ -0,0 +1,57 @@
+// pattern matcher crashes here trying to synthesize an uneeded outer test.
+//     no-symbol does not have an owner
+// at scala.reflect.internal.SymbolTable.abort(SymbolTable.scala:49)
+// at scala.tools.nsc.Global.abort(Global.scala:253)
+// at scala.reflect.internal.Symbols$NoSymbol.owner(Symbols.scala:3248)
+// at scala.reflect.internal.Symbols$Symbol.effectiveOwner(Symbols.scala:678)
+// at scala.reflect.internal.Symbols$Symbol.isDefinedInPackage(Symbols.scala:664)
+// at scala.reflect.internal.TreeGen.mkAttributedSelect(TreeGen.scala:188)
+// at scala.reflect.internal.TreeGen.mkAttributedRef(TreeGen.scala:124)
+// at scala.tools.nsc.ast.TreeDSL$CODE$.REF(TreeDSL.scala:308)
+// at scala.tools.nsc.typechecker.PatternMatching$TreeMakers$TypeTestTreeMaker$treeCondStrategy$.outerTest(PatternMatching.scala:1209)
+class Crash {
+  type Alias = C#T
+
+  val c = new C
+  val t = new c.T
+
+  // Crash via a Typed Pattern...
+  (t: Any) match {
+    case e: Alias =>
+  }
+
+  // ... or via a Typed Extractor Pattern.
+  object Extractor {
+    def unapply(a: Alias): Option[Any] = None
+  }
+  (t: Any) match {
+    case Extractor() =>
+    case _ =>
+  }
+
+  // checking that correct outer tests are applied when
+  // aliases for path dependent types are involved.
+  val c2 = new C
+  type CdotT = c.T
+  type C2dotT = c2.T
+
+  val outerField = t.getClass.getDeclaredFields.find(_.getName contains ("outer")).get
+  outerField.setAccessible(true)
+
+  (t: Any) match {
+    case _: C2dotT =>
+      println(s"!!! wrong match. t.outer=${outerField.get(t)} / c2 = $c2") // this matches on 2.10.0
+    case _: CdotT =>
+    case _ =>
+      println(s"!!! wrong match. t.outer=${outerField.get(t)} / c = $c")
+  }
+}
+
+class C {
+  class T
+}
+
+object Test extends App {
+  new Crash
+}
+