Fix #7137: Remove implicit modifier from Predef.any2stringadd

Author: nicolasstucki

community-build/community-projects/scalap

@@ -345,8 +345,22 @@ class Definitions {
     newSymbol(ScalaPackageClass, tpnme.IMPLICITkw, EmptyFlags, TypeBounds.empty).entered
   def ImplicitScrutineeTypeRef: TypeRef = ImplicitScrutineeTypeSym.typeRef
 
-
-  @tu lazy val ScalaPredefModule: Symbol = ctx.requiredModule("scala.Predef")
+  @tu lazy val ScalaPredefModule: Symbol = {
+    val mod = ctx.requiredModule("scala.Predef")
+    mod.infoOrCompleter match {
+      case completer: ModuleCompleter =>
+        mod.info = new ModuleCompleter(completer.moduleClass) {
+          override def complete(root: SymDenotation)(implicit ctx: Context): Unit = {
+            super.complete(root)
+            // Disable the implicit conversion any2stringadd we remove the `implicit` moifier.
+            // Using it explicitly will emit the usual deprection warining.
+            val meth = root.requiredMethod("any2stringadd")
+            meth.resetFlag(Implicit)
+          }
+        }
+        mod
+    }
+  }
     @tu lazy val Predef_conforms : Symbol = ScalaPredefModule.requiredMethod(nme.conforms_)
     @tu lazy val Predef_classOf  : Symbol = ScalaPredefModule.requiredMethod(nme.classOf)
     @tu lazy val Predef_identity : Symbol = ScalaPredefModule.requiredMethod(nme.identity)
@@ -1309,7 +1323,7 @@ class Definitions {
         ScalaPackageClass.enter(m)
 
       // force initialization of every symbol that is synthesized or hijacked by the compiler
-      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass
+      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass :+ ScalaPredefModule
 
       isInitialized = true
     }

community-build/community-projects/scalatest

@@ -29,7 +29,7 @@ class StringConcatTest extends DottyBytecodeTest {
         |         str: String,
         |         sbuf: java.lang.StringBuffer,
         |         chsq: java.lang.CharSequence,
-        |         chrs: Array[Char]) = str + this + v + z + c + b + s + i + f + l + d + sbuf + chsq + chrs
+        |         chrs: Array[Char]) = str.toString + this + v + z + c + b + s + i + f + l + d + sbuf + chsq + chrs
         |
         |  // similar, but starting off with any2stringadd
         |  def t2(
@@ -45,7 +45,7 @@ class StringConcatTest extends DottyBytecodeTest {
         |         str: String,
         |         sbuf: java.lang.StringBuffer,
         |         chsq: java.lang.CharSequence,
-        |         chrs: Array[Char]) = this + str + v + z + c + b + s + i + f + l + d + sbuf + chsq + chrs
+        |         chrs: Array[Char]) = this.toString + str + v + z + c + b + s + i + f + l + d + sbuf + chsq + chrs
         |}
       """.stripMargin
 
@@ -60,8 +60,9 @@ class StringConcatTest extends DottyBytecodeTest {
         case Invoke(_, _, name, desc, _) => name + desc
       }
 
-      assertEquals(invokeNameDesc("t1"), List(
+      assertEquals(List(
         "<init>()V",
+        "toString()Ljava/lang/String;",
         "append(Ljava/lang/String;)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
@@ -76,12 +77,14 @@ class StringConcatTest extends DottyBytecodeTest {
         "append(Ljava/lang/StringBuffer;)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/CharSequence;)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/Object;)Ljava/lang/StringBuilder;", // test that we're not using the [C overload
-        "toString()Ljava/lang/String;"))
+        "toString()Ljava/lang/String;"),
+        invokeNameDesc("t1")
+      )
 
-      assertEquals(invokeNameDesc("t2"), List(
-        "any2stringadd(Ljava/lang/Object;)Ljava/lang/Object;",
+      assertEquals(List(
         "<init>()V",
-        "$plus$extension(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/String;",
+        "toString()Ljava/lang/String;",
+        "append(Ljava/lang/String;)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/String;)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
         "append(Z)Ljava/lang/StringBuilder;",
@@ -94,8 +97,10 @@ class StringConcatTest extends DottyBytecodeTest {
         "append(D)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/StringBuffer;)Ljava/lang/StringBuilder;",
         "append(Ljava/lang/CharSequence;)Ljava/lang/StringBuilder;",
-        "append(Ljava/lang/Object;)Ljava/lang/StringBuilder;", // test that we're not using the [C overload
-        "toString()Ljava/lang/String;"))
+        "append(Ljava/lang/Object;)Ljava/lang/StringBuilder;",
+        "toString()Ljava/lang/String;"),
+        invokeNameDesc("t2")
+      )
     }
   }
 
@@ -124,6 +129,6 @@ class StringConcatTest extends DottyBytecodeTest {
     def chsq: java.lang.CharSequence = "chsq"
     val s = t((), true, 'd', 3: Byte, 12: Short, 3, -32l, 12.3f, -4.2d, "me", sbuf, chsq, Array('a', 'b'))
     val r = s.replaceAll("""\[C@\w+""", "<ARRAY>")
-    assertEquals(r, "meTTT()trued312312.3-32-4.2sbufchsq<ARRAY>//TTTme()trued312312.3-32-4.2sbufchsq<ARRAY>")
+    assertEquals("meTTT()trued312312.3-32-4.2sbufchsq<ARRAY>//TTTme()trued312312.3-32-4.2sbufchsq<ARRAY>", r)
   }
 }

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -115,7 +115,7 @@ class TabcompleteTests extends ReplTest {
   @Test def anyRef = fromInitialState { implicit s =>
     val comp = tabComplete("(null: AnyRef).")
     assertEquals(
-      List("!=", "##", "+", "->", "==", "asInstanceOf", "clone", "ensuring", "eq", "equals", "finalize", "formatted",
+      List("!=", "##", "->", "==", "asInstanceOf", "clone", "ensuring", "eq", "equals", "finalize", "formatted",
           "getClass", "hashCode", "isInstanceOf", "ne", "notify", "notifyAll", "synchronized", "toString", "wait", "→"),
       comp.distinct.sorted)
   }

compiler/test/dotty/tools/backend/jvm/StringConcatTest.scala

@@ -0,0 +1,7 @@
+
+object App {
+  val any: Any = 3
+  val str: String = any + "a" // error
+  val str2: String = any2stringadd(any) + "a"
+  val str3: String = Predef.any2stringadd(any) + "a"
+}

compiler/test/dotty/tools/repl/TabcompleteTests.scala

@@ -83,7 +83,7 @@ class InitChecker extends PluginPhase with StandardPlugin {
         ctx.warning("tree: " + tree.symbol.defTree.show)
       }
       else {
-        ctx.warning(tree.symbol + " is neither in lib nor hello, owner = " + enclosingPkg, tree.sourcePos)
+        ctx.warning(tree.symbol.toString + " is neither in lib nor hello, owner = " + enclosingPkg, tree.sourcePos)
       }
       tree
     }

tests/neg/i7137.scala

@@ -11,7 +11,7 @@ object Macros {
     val buff = List.newBuilder[String]
     def printout(x: => String): Unit = {
 
-      buff += (try x catch { case ex => ex.getClass + ": " + ex.getMessage})
+      buff += (try x catch { case ex => ex.getClass.toString + ": " + ex.getMessage})
     }
 
     printout(defn.RootPackage.name)

tests/plugins/custom/analyzer/Analyzer_1.scala

@@ -3,7 +3,7 @@ import XmlQuote._
 object Test {
   def main(args: Array[String]): Unit = {
     assert(xml"Hello ${implicitly[Scope]} world!" == "Hello Scope(top+) world!")
-    assert(xml"Hello ${ xml"world ${implicitly[Scope] + " " + xml"${implicitly[Scope]}"}" }!" ==
+    assert(xml"Hello ${ xml"world ${implicitly[Scope].toString + " " + xml"${implicitly[Scope]}"}" }!" ==
         "Hello world Scope(top++) Scope(top+++)!")
   }
 }

tests/run-macros/tasty-definitions-1/quoted_1.scala

@@ -15,19 +15,19 @@ object Test
   def main(args: Array[String]): Unit = {
     var xs = makeFromInt(5)
     for (x <- xs ; y <- xs) {
-      assert(x == y, x + " == " + y)
+      assert(x == y, x.toString + " == " + y)
       assert(hash(x) == hash(y), "hash(%s) == hash(%s)".format(x, y))
     }
 
     xs = makeFromInt(-5)
     for (x <- xs ; y <- xs) {
-      assert(x == y, x + " == " + y)
+      assert(x == y, x.toString + " == " + y)
       assert(hash(x) == hash(y), "hash(%s) == hash(%s)".format(x, y))
     }
 
     xs = makeFromDouble(500.0)
     for (x <- xs ; y <- xs) {
-      assert(x == y, x + " == " + y)
+      assert(x == y, x.toString + " == " + y)
       assert(hash(x) == hash(y), "hash(%s) == hash(%s)".format(x, y))
     }