Merge branch 'master' into GenASM

10 files changed, 157 insertions, 9 deletions

diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index 64edbdb8bd..b7b7ca5840 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -4579,7 +4579,7 @@ trait Types extends api.Types { self: SymbolTable =>
         var rebind0 = pre.findMember(sym.name, BRIDGE, 0, true)
         if (rebind0 == NoSymbol) {
           if (sym.isAliasType) throw missingAliasException
-          if (settings.debug.value) println(pre+"."+sym+" does no longer exist, phase = "+phase)
+          debugwarn(pre+"."+sym+" does no longer exist, phase = "+phase)
           throw new MissingTypeControl // For build manager and presentation compiler purposes
           //assert(false, pre+"."+sym+" does no longer exist, phase = "+phase)
         }
@@ -4635,7 +4635,7 @@ trait Types extends api.Types { self: SymbolTable =>
             if ((pre1 eq pre) && (sym1 eq sym) && (args1 eq args)/* && sym.isExternal*/) {
               tp
             } else if (sym1 == NoSymbol) {
-              if (settings.debug.value) println("adapt fail: "+pre+" "+pre1+" "+sym)
+              debugwarn("adapt fail: "+pre+" "+pre1+" "+sym)
               tp
             } else {
               copyTypeRef(tp, pre1, sym1, args1)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index c5b49ceca1..891c55ba1e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -863,6 +863,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
 
     def genField(f: IField) {
       debuglog("Adding field: " + f.symbol.fullName)
+      
       val jfield = jclass.addNewField(
         javaFlags(f.symbol) | javaFieldFlags(f.symbol),
         javaName(f.symbol),
@@ -1917,6 +1918,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
          ((sym.rawflags & (Flags.FINAL | Flags.MODULE)) != 0)
       && !sym.enclClass.isInterface
       && !sym.isClassConstructor
+      && (sym.isLazy || sym.isPrivate || !sym.isMutable)  // fix for SI-3569, is it sufficient?
     )
 
     mkFlags(
diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index afe0b42167..d7b4171c65 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -726,7 +726,6 @@ trait ContextErrors {
         // we have to set the type of tree to ErrorType only in the very last
         // fallback action that is done in the inference (tracking it manually is error prone).
         // This avoids entering infinite loop in doTypeApply.
-        // TODO: maybe we should do the same thing with inferExprAlternative.
         if (implicitly[Context].reportErrors) setError(tree)
       }
 
@@ -736,6 +735,8 @@ trait ContextErrors {
           "argument types " + argtpes.mkString("(", ",", ")") +
          (if (pt == WildcardType) "" else " and expected result type " + pt)
         val (pos, msg) = ambiguousErrorMsgPos(tree.pos, pre, best, firstCompeting, msg0)
+        // discover last attempt in a similar way as for NoBestMethodAlternativeError
+        if (implicitly[Context].ambiguousErrors) setError(tree)
         issueAmbiguousTypeError(pre, best, firstCompeting, AmbiguousTypeError(tree, pos, msg))
       }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 90e07023bb..2c564c097f 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -312,13 +312,14 @@ trait Contexts { self: Analyzer =>
       unit.error(pos, if (checking) "\n**** ERROR DURING INTERNAL CHECKING ****\n" + msg else msg)
 
     def issue(err: AbsTypeError) {
-      if (settings.debug.value) println("issue error: " + err.errMsg)
+      debugwarn("issue error: " + err.errMsg)
       if (reportErrors) unitError(err.errPos, addDiagString(err.errMsg))
       else if (bufferErrors) { buffer += err }
       else throw new TypeError(err.errPos, err.errMsg)
     }
 
     def issueAmbiguousError(pre: Type, sym1: Symbol, sym2: Symbol, err: AbsTypeError) {
+      debugwarn("issue ambiguous error: " + err.errMsg)
       if (ambiguousErrors) {
         if (!pre.isErroneous && !sym1.isErroneous && !sym2.isErroneous)
           unitError(err.errPos, err.errMsg)
@@ -327,6 +328,7 @@ trait Contexts { self: Analyzer =>
     }
 
     def issueAmbiguousError(err: AbsTypeError) {
+      debugwarn("issue ambiguous error: " + err.errMsg)
       if (ambiguousErrors)
         unitError(err.errPos, addDiagString(err.errMsg))
       else if (bufferErrors) { buffer += err }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 896d8c711d..cea5858915 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -1493,14 +1493,12 @@ trait Infer {
             if (improves(alt, best)) alt else best)
           val competing = applicable.dropWhile(alt => best == alt || improves(best, alt))
           if (best == NoSymbol) {
-            if (pt == WildcardType)
-              NoBestMethodAlternativeError(tree, argtpes, pt)
-            else
-              inferMethodAlternative(tree, undetparams, argtpes, WildcardType)
+            if (pt == WildcardType) NoBestMethodAlternativeError(tree, argtpes, pt)
+            else inferMethodAlternative(tree, undetparams, argtpes, WildcardType)
           } else if (!competing.isEmpty) {
             if (!(argtpes exists (_.isErroneous)) && !pt.isErroneous)
               AmbiguousMethodAlternativeError(tree, pre, best, competing.head, argtpes, pt)
-            setError(tree)
+            else setError(tree)
             ()
           } else {
 //            checkNotShadowed(tree.pos, pre, best, applicable)
diff --git a/test/files/neg/t5554.check b/test/files/neg/t5554.check
new file mode 100644
index 0000000000..8f657fd32f
--- /dev/null
+++ b/test/files/neg/t5554.check
@@ -0,0 +1,67 @@
+t5554.scala:14: error: ambiguous reference to overloaded definition,
+both method apply in object Foo1 of type (x: Int)(implicit z: String)String
+and  method apply in object Foo1 of type (x: Int)Base[T]
+match argument types (Int)
+  def test1[T]: Int = Foo1[T](1)
+                          ^
+t5554.scala:16: error: ambiguous reference to overloaded definition,
+both method apply in object Foo1 of type (x: Int)(implicit z: String)String
+and  method apply in object Foo1 of type (x: Int)Base[T]
+match argument types (Int)
+  def test3[T]: String = Foo1[T](1)
+                             ^
+t5554.scala:17: error: ambiguous reference to overloaded definition,
+both method apply in object Foo1 of type (x: Int)(implicit z: String)String
+and  method apply in object Foo1 of type (x: Int)Base[T]
+match argument types (Int)
+  def test4[T] = Foo1[T](1)
+                     ^
+t5554.scala:22: error: ambiguous reference to overloaded definition,
+both method apply in object Foo1 of type (x: Int)(implicit z: String)String
+and  method apply in object Foo1 of type (x: Int)Base[T]
+match argument types (Int)
+  def test5[T]: Int = Foo1[T](1)
+                          ^
+t5554.scala:25: error: ambiguous reference to overloaded definition,
+both method apply in object Foo1 of type (x: Int)(implicit z: String)String
+and  method apply in object Foo1 of type (x: Int)Base[T]
+match argument types (Int)
+  def test8[T] = Foo1[T](1)
+                     ^
+t5554.scala:29: error: ambiguous reference to overloaded definition,
+both method apply in object Foo2 of type (x: Int)(implicit z: String)Base[T]
+and  method apply in object Foo2 of type (x: Int)Base[T]
+match argument types (Int)
+  def test9[T]: String = Foo2[T](1)
+                             ^
+t5554.scala:30: error: ambiguous reference to overloaded definition,
+both method apply in object Foo2 of type (x: Int)(implicit z: String)Base[T]
+and  method apply in object Foo2 of type (x: Int)Base[T]
+match argument types (Int) and expected result type Base[T]
+  def test10[T]: Base[T] = Foo2[T](1)
+                               ^
+t5554.scala:31: error: ambiguous reference to overloaded definition,
+both method apply in object Foo2 of type (x: Int)(implicit z: String)Base[T]
+and  method apply in object Foo2 of type (x: Int)Base[T]
+match argument types (Int)
+  def test11[T] = Foo2[T](1)
+                      ^
+t5554.scala:36: error: ambiguous reference to overloaded definition,
+both method apply in object Foo2 of type (x: Int)(implicit z: String)Base[T]
+and  method apply in object Foo2 of type (x: Int)Base[T]
+match argument types (Int)
+  def test12[T]: String = Foo2[T](1)
+                              ^
+t5554.scala:37: error: ambiguous reference to overloaded definition,
+both method apply in object Foo2 of type (x: Int)(implicit z: String)Base[T]
+and  method apply in object Foo2 of type (x: Int)Base[T]
+match argument types (Int) and expected result type Base[T]
+  def test13[T]: Base[T] = Foo2[T](1)
+                               ^
+t5554.scala:38: error: ambiguous reference to overloaded definition,
+both method apply in object Foo2 of type (x: Int)(implicit z: String)Base[T]
+and  method apply in object Foo2 of type (x: Int)Base[T]
+match argument types (Int)
+  def test14[T] = Foo2[T](1)
+                      ^
+11 errors found
diff --git a/test/files/neg/t5554.scala b/test/files/neg/t5554.scala
new file mode 100644
index 0000000000..d279abea7f
--- /dev/null
+++ b/test/files/neg/t5554.scala
@@ -0,0 +1,39 @@
+class Base[T]
+
+object Foo1 {
+  def apply[T](x: Int): Base[T] = new Base[T]
+  def apply[T](x: Int)(implicit z: String): String = z
+}
+
+object Foo2 {
+  def apply[T](x: Int): Base[T] = new Base[T]
+  def apply[T](x: Int)(implicit z: String): Base[T] = new Base[T]
+}
+
+object Test1 {
+  def test1[T]: Int = Foo1[T](1)
+  def test2[T]: Base[T] = Foo1[T](1)
+  def test3[T]: String = Foo1[T](1)
+  def test4[T] = Foo1[T](1)
+}
+
+object Test2 {
+  implicit val v: String = "foo"
+  def test5[T]: Int = Foo1[T](1)
+  def test6[T]: Base[T] = Foo1[T](1)
+  def test7[T]: String = Foo1[T](1)
+  def test8[T] = Foo1[T](1)
+}
+
+object Test3 {
+  def test9[T]: String = Foo2[T](1)
+  def test10[T]: Base[T] = Foo2[T](1)
+  def test11[T] = Foo2[T](1)
+}
+
+object Test4 {
+  implicit val v: String = "foo"
+  def test12[T]: String = Foo2[T](1)
+  def test13[T]: Base[T] = Foo2[T](1)
+  def test14[T] = Foo2[T](1)
+}
diff --git a/test/files/run/t3569.check b/test/files/run/t3569.check
new file mode 100644
index 0000000000..aa19916324
--- /dev/null
+++ b/test/files/run/t3569.check
@@ -0,0 +1,14 @@
+1
+private final int Test$X.x2
+private final int Test$X.x3
+private final int Test$X.x5
+private final int Test$X.x6
+private final int Test$X.x7
+private int Test$X.x4
+private volatile int Test$X.bitmap$priv$0
+public int Test$X.x
+public volatile int Test$X.bitmap$0
+private int Test$Y.z1
+public int Test$Y.x
+public int Test$Y.y
+public int Test$Y.z2
diff --git a/test/files/run/t3569.flags b/test/files/run/t3569.flags
new file mode 100644
index 0000000000..6933d924d3
--- /dev/null
+++ b/test/files/run/t3569.flags
@@ -0,0 +1 @@
+-Yinline
\ No newline at end of file
diff --git a/test/files/run/t3569.scala b/test/files/run/t3569.scala
new file mode 100644
index 0000000000..e553f16ff8
--- /dev/null
+++ b/test/files/run/t3569.scala
@@ -0,0 +1,24 @@
+object Test {
+  lazy val lv = scala.util.Random.nextInt()
+  
+  class X(final var x: Int)  {
+    final private[this] var x2: Int = 0
+    final var x3: Int = 0
+    private[this] var x4: Int = 0
+    final private[this] var x5: Int = 0
+    final lazy val x6: Int = 0
+    final private[this] lazy val x7: Int = 0
+  }
+  case class Y(final var x: Int, final private var y: Int, var z1: Int, private var z2: Int) { }
+  
+  def f = new X(0).x += 1
+  def main(args: Array[String]) {
+    f
+    val s = new X(0)
+    s.x += 1
+    println(s.x)
+    
+    (classOf[X].getDeclaredFields map ("" + _)).sorted foreach println
+    (classOf[Y].getDeclaredFields map ("" + _)).sorted foreach println
+  }
+}