fixed Signature generation

6 files changed, 52 insertions, 27 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index dc0a3d362c..44821f569a 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -397,19 +397,21 @@ abstract class GenJVM extends SubComponent {
       nattr
     }
 
-    def addGenericSignature(jmember: JMember, sym: Symbol, tp: Type) {
-      if (settings.target.value == "jvm-1.5" && erasure.needsJavaSig(tp)) {
-        val sig = erasure.javaSig(tp)
-        val index = jmember.getConstantPool().addUtf8(sig).toShort
-        if (settings.debug.value && settings.verbose.value) println("add generic sig "+sym+":"+tp+" ==> "+sig+" @ "+index)
-        val buf = ByteBuffer.allocate(2)
-        buf.putShort(index)
-        addAttribute(jmember, nme.SignatureATTR, buf)
-      }
-    }
-
     def addGenericSignature(jmember: JMember, sym: Symbol) {
-      addGenericSignature(jmember, sym, atPhase(currentRun.erasurePhase)(sym.info))
+      if (!sym.hasFlag(Flags.PRIVATE | Flags.EXPANDEDNAME | Flags.SYNTHETIC) && settings.target.value == "jvm-1.5") {
+        erasure.javaSig(sym) match {
+          case Some(sig) =>
+            val index = jmember.getConstantPool().addUtf8(sig).toShort
+            if (settings.debug.value && settings.verbose.value)
+              atPhase(currentRun.erasurePhase) {
+                println("add generic sig "+sym+":"+sym.info+" ==> "+sig+" @ "+index)
+              }
+            val buf = ByteBuffer.allocate(2)
+            buf.putShort(index)
+            addAttribute(jmember, nme.SignatureATTR, buf)
+          case None =>
+        }
+      }
     }
 
     def addAnnotations(jmember: JMember, attributes: List[AnnotationInfo]) {
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index 52e247db02..a9baef9176 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -110,8 +110,6 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
             else if (clazz == ArrayClass) List(erasedTypeRef(ObjectClass))
             else removeDoubleObject(parents map this),
             decls, clazz)
-        case WildcardType =>
-          AnyRefClass.tpe
         case _ =>
           mapOver(tp)
       }
@@ -143,7 +141,7 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
     }
   }
 
-  def needsJavaSig(tp: Type) = NeedsSigCollector.collect(tp)
+  private def needsJavaSig(tp: Type) = NeedsSigCollector.collect(tp)
 
   private lazy val tagOfClass = new HashMap[Symbol,Char] + (
     ByteClass -> BYTE_TAG,
@@ -157,16 +155,14 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
     UnitClass -> VOID_TAG
   )
 
-  def javaSig(sym: Symbol): Option[String] =
-    if (needsJavaSig(sym.info)) {
-      Some(javaSig(sym.info))
-    } else {
-      None
-    }
+  def javaSig(sym: Symbol): Option[String] = atPhase(currentRun.erasurePhase) {
+    if (needsJavaSig(sym.info)) Some(javaSig(sym.info))
+    else None
+  }
 
-  def javaSig(tp: Type): String = javaSig(List(), tp)
+  private def javaSig(tp: Type): String = javaSig(List(), tp)
 
-  def javaSig(tparams: List[Symbol], tp0: Type): String = {
+  private def javaSig(tparams: List[Symbol], tp0: Type): String = {
     val tp = tp0.normalize
     tp match {
       case st: SubType =>
@@ -189,6 +185,10 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
           ARRAY_TAG.toString+(args map javaSig).mkString
         else if (sym.isTypeParameterOrSkolem)
           TVAR_TAG.toString+sym.name+";"
+        else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass)
+          javaSig(ObjectClass.tpe)
+        else if (sym == UnitClass)
+          javaSig(BoxedUnitClass.tpe)
         else if (isValueClass(sym))
           tagOfClass(sym).toString
         else if (sym.isClass)
@@ -218,7 +218,8 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer {
         def paramSig(tsym: Symbol) = tsym.name+boundSig(hiBounds(tsym.info.bounds))
         "<"+(tparams map paramSig).mkString+">"+javaSig(restpe)
       case MethodType(formals, restpe) =>
-        "("+(formals map javaSig).mkString+")"+javaSig(restpe)
+        "("+(formals map javaSig).mkString+")"+
+        (if (restpe.typeSymbol == UnitClass) VOID_TAG.toString else javaSig(restpe))
       case RefinedType(parents, decls) if (!parents.isEmpty) =>
         javaSig(parents.head)
       case ClassInfoType(parents, _, _) =>
diff --git a/test/files/neg/t1033.check b/test/files/neg/t1033.check
new file mode 100644
index 0000000000..16e799264b
--- /dev/null
+++ b/test/files/neg/t1033.check
@@ -0,0 +1,4 @@
+t1033.scala:5: error: return outside method definition
+      return 10
+      ^
+one error found
diff --git a/test/files/neg/t1033.scala b/test/files/neg/t1033.scala
new file mode 100644
index 0000000000..3aed8bb11a
--- /dev/null
+++ b/test/files/neg/t1033.scala
@@ -0,0 +1,13 @@
+object A {
+  def f :Int = {
+    class B {
+      println("B")
+      return 10
+    }
+    new B
+    20
+  }
+  def main(args: Array[String]) {
+    f
+  }
+}
diff --git a/test/pending/pos/sig/sigs.java b/test/pending/pos/sig/sigs.java
index 0fc0c7008f..ddf8ec45b0 100755
--- a/test/pending/pos/sig/sigs.java
+++ b/test/pending/pos/sig/sigs.java
@@ -1,5 +1,6 @@
 package test;
 class Test extends T {
-    Object y = bar("abc");
+    Inner i = new Inner();
     String x = foo("abc");
-}
\ No newline at end of file
+    String y = i.bar("abc");
+}
diff --git a/test/pending/pos/sig/sigs.scala b/test/pending/pos/sig/sigs.scala
index 4579f225d9..72a293d0e6 100755
--- a/test/pending/pos/sig/sigs.scala
+++ b/test/pending/pos/sig/sigs.scala
@@ -1,6 +1,10 @@
 package test
 class T {
-  def foo[T](x: T): T = x
+  def foo[T <: String](x: T): T = x
   def bar[T](x: T): T = x
+  class Inner {
+    def foo[T](x: T): T = x
+    def bar[T](x: T): T = x
+  }
 }