fixed odd typing bug #44

2 files changed, 38 insertions, 13 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 3072810afe..27fc934ef6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1665,19 +1665,24 @@ trait Typers { self: Analyzer =>
             //todo: replace arg with arg.asInstanceOf[inferTypedPattern(unappFormal, arg.tpe)] instead.
             argDummy.setInfo(arg.tpe) // bq: this line fixed #1281. w.r.t. comment ^^^, maybe good enough?
           }
-          val funPrefix = fun.tpe.prefix match {
+          val funPrefix = if (fun.symbol.owner.isMethod) NoPrefix else fun.tpe.prefix match {
             case tt @ ThisType(sym) =>
-              //Console.println(" sym="+sym+" "+" .isPackageClass="+sym.isPackageClass+" .isModuleClass="+sym.isModuleClass);
-              //Console.println(" funsymown="+fun.symbol.owner+" .isClass+"+fun.symbol.owner.isClass);
-              //Console.println(" contains?"+sym.tpe.decls.lookup(fun.symbol.name));
-              if(sym != fun.symbol.owner && (sym.isPackageClass||sym.isModuleClass) /*(1)*/ ) { // (1) see 'files/pos/unapplyVal.scala'
-                if(fun.symbol.owner.isClass) {
-                  mkThisType(fun.symbol.owner)
-                } else {
-                  NoPrefix                                                 // see 'files/run/unapplyComplex.scala'
-                }
-              } else tt
-            case st @ SingleType(pre, sym) => st
+              //Console.println("tt = "+tt+" sym.isModuleClass = "+sym.isModuleClass+" sym.isPackageClass = "+sym.isPackageClass+" isStaticModul="+sym.isStaticModule+" fso = "+fun.symbol.owner+" fso.isClass"+fun.symbol.owner.isClass)
+              if((sym eq fun.symbol.owner)|| !sym.isPackageClass) {
+                //Console.println("1 ThisType("+sym+")")
+                tt
+              } else {
+                //Console.println("2 ThisType("+fun.symbol.owner+")")
+                mkThisType(fun.symbol.owner) // see 'files/pos/unapplyVal.scala'
+              }
+                //if (sym.isPackageClass && fun.symbol.owner.isClass)  { // (1)
+                //mkThisType(fun.symbol.owner)
+              //} else {
+              //  Console.println("NoPrefix")
+              //  NoPrefix                                                  // see 'files/run/unapplyComplex.scala'
+             // }
+            case st @ SingleType(pre, sym) =>
+              st
             case xx                        => xx // cannot happen?
           }
           val fun1untyped = atPos(fun.pos) {
diff --git a/test/files/run/patmatnew.scala b/test/files/run/patmatnew.scala
index b05da464a5..a61e9eb797 100644
--- a/test/files/run/patmatnew.scala
+++ b/test/files/run/patmatnew.scala
@@ -44,7 +44,8 @@ object Test extends TestConsoleMain {
       ClassDefInGuard,
       Ticket2,
       Ticket11,
-      Ticket37
+      Ticket37,
+      Ticket44
     )
 
   class Foo(j:Int) {
@@ -628,6 +629,25 @@ object Test extends TestConsoleMain {
     override def runTest { assertEquals(this.a, 2) }
   }
 
+  // #44
+
+  trait _X {
+    case class _Foo();
+    object _Bar {
+      def unapply(foo: _Foo):Boolean = true;
+    }
+  }
+  object Y extends _X {
+    val foo = _Foo()
+    foo match {
+      case _Bar() =>
+      case _      => assert(false)
+    }
+  }
+  object Ticket44 extends TestCase("#44") {
+    override def runTest { assert(Y.toString ne null) /*instantiate Y*/ }
+  }
+
 }