Fix #7137: Do not import Predef.any2stringadd by default

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

@@ -370,6 +370,7 @@ object StdNames {
     val add_ : N                = "add"
     val acc: N                  = "acc"
     val annotation: N           = "annotation"
+    val any2stringadd: N        = "any2stringadd"
     val anyHash: N              = "anyHash"
     val anyValClass: N          = "anyValClass"
     val append: N               = "append"

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -16,7 +16,10 @@ import Decorators._
 object ImportInfo {
   /** The import info for a root import from given symbol `sym` */
   def rootImport(refFn: () => TermRef, importGiven: Boolean = false)(implicit ctx: Context): ImportInfo = {
-    val selectors = untpd.Ident(nme.WILDCARD) :: Nil
+    // selectors: { _, any2stringadd => _ }
+    val selectors = untpd.Ident(nme.WILDCARD) ::
+                    Thicket(untpd.Ident(nme.any2stringadd) :: untpd.Ident(nme.WILDCARD) :: Nil) ::
+                    Nil
     def expr(implicit ctx: Context) = tpd.Ident(refFn())
     def imp(implicit ctx: Context) = tpd.Import(importGiven = importGiven, expr, selectors)
     new ImportInfo(imp.symbol, selectors, None, importGiven = importGiven, isRootImport = true)

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

@@ -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/test/dotty/tools/repl/TabcompleteTests.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)
   }

tests/neg/i7137.scala

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

tests/plugins/custom/analyzer/Analyzer_1.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/run-macros/tasty-definitions-1/quoted_1.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/run-macros/xml-interpolation-4/Test_2.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/equality.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))
     }