Remove extra .toTermNames

Author: OlivierBlanvillain

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -365,7 +365,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   def getAnnotPickle(jclassName: String, sym: Symbol): Option[Annotation] = None
 
 
-  def getRequiredClass(fullname: String): Symbol = ctx.requiredClass(fullname.toTermName)
+  def getRequiredClass(fullname: String): Symbol = ctx.requiredClass(fullname)
 
   def getClassIfDefined(fullname: String): Symbol = NoSymbol // used only for android. todo: implement
 
@@ -375,12 +375,12 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   def requiredClass[T](implicit evidence: ClassTag[T]): Symbol =
-    ctx.requiredClass(erasureString(evidence.runtimeClass).toTermName)
+    ctx.requiredClass(erasureString(evidence.runtimeClass))
 
   def requiredModule[T](implicit evidence: ClassTag[T]): Symbol = {
     val moduleName = erasureString(evidence.runtimeClass)
     val className = if (moduleName.endsWith("$")) moduleName.dropRight(1)  else moduleName
-    ctx.requiredModule(className.toTermName)
+    ctx.requiredModule(className)
   }
 
 
@@ -1193,8 +1193,8 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
         val arity = field.meth.tpe.widenDealias.paramTypes.size - _1.size
         val returnsUnit = field.meth.tpe.widenDealias.resultType.classSymbol == UnitClass
         if (returnsUnit)
-          ctx.requiredClass(("scala.compat.java8.JProcedure" + arity).toTermName)
-        else ctx.requiredClass(("scala.compat.java8.JFunction" + arity).toTermName)
+          ctx.requiredClass(("scala.compat.java8.JProcedure" + arity))
+        else ctx.requiredClass(("scala.compat.java8.JFunction" + arity))
       }
     }
   }

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

@@ -201,7 +201,7 @@ class Definitions {
   lazy val OpsPackageVal = ctx.newCompletePackageSymbol(RootClass, nme.OPS_PACKAGE).entered
   lazy val OpsPackageClass = OpsPackageVal.moduleClass.asClass
 
-  lazy val ScalaPackageVal = ctx.requiredPackage("scala")
+  lazy val ScalaPackageVal = ctx.requiredPackage(nme.scala_)
   lazy val ScalaMathPackageVal = ctx.requiredPackage("scala.math")
   lazy val ScalaPackageClass = {
     val cls = ScalaPackageVal.moduleClass.asClass
@@ -212,8 +212,8 @@ class Definitions {
     cls
   }
   lazy val ScalaPackageObjectRef = ctx.requiredModuleRef("scala.package")
-  lazy val JavaPackageVal = ctx.requiredPackage("java")
-  lazy val JavaLangPackageVal = ctx.requiredPackage("java.lang")
+  lazy val JavaPackageVal = ctx.requiredPackage(nme.java)
+  lazy val JavaLangPackageVal = ctx.requiredPackage(jnme.JavaLang)
   // fundamental modules
   lazy val SysPackage = ctx.requiredModule("scala.sys.package")
     lazy val Sys_errorR = SysPackage.moduleClass.requiredMethodRef(nme.error)
@@ -339,11 +339,11 @@ class Definitions {
 
     lazy val Predef_ConformsR = ScalaPredefModule.requiredClass("<:<").typeRef
     def Predef_Conforms(implicit ctx: Context) = Predef_ConformsR.symbol
-    lazy val Predef_conformsR = ScalaPredefModule.requiredMethodRef("$conforms")
+    lazy val Predef_conformsR = ScalaPredefModule.requiredMethodRef(nme.conforms_)
     def Predef_conforms(implicit ctx: Context) = Predef_conformsR.symbol
-    lazy val Predef_classOfR = ScalaPredefModule.requiredMethodRef("classOf")
+    lazy val Predef_classOfR = ScalaPredefModule.requiredMethodRef(nme.classOf)
     def Predef_classOf(implicit ctx: Context) = Predef_classOfR.symbol
-    lazy val Predef_undefinedR = ScalaPredefModule.requiredMethodRef("???")
+    lazy val Predef_undefinedR = ScalaPredefModule.requiredMethodRef(nme.???)
     def Predef_undefined(implicit ctx: Context) = Predef_undefinedR.symbol
     // The set of all wrap{X, Ref}Array methods, where X is a value type
     val Predef_wrapArray = new PerRun[collection.Set[Symbol]]({ implicit ctx =>

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

@@ -393,7 +393,7 @@ object StdNames {
     val ClassManifestFactory: N = "ClassManifestFactory"
     val classOf: N              = "classOf"
     val clone_ : N              = "clone"
- //   val conforms : N             = "conforms" // Dotty deviation: no special treatment of conforms, so the occurrence of the name here would cause to unintended implicit shadowing. Should find a less common name for it in Predef.
+    val conforms_ : N           = "$conforms"
     val copy: N                 = "copy"
     val currentMirror: N        = "currentMirror"
     val create: N               = "create"

compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala

@@ -49,7 +49,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
       def printNat() = print(Yellow(" " + readNat()).show)
       def printName() = {
         val idx = readNat()
-        print(nameColor(" " + idx + " [" + nameRefToString(NameRef(idx)) + "]").show)
+        print(nameColor(" " + idx + " [" + nameRefToString(NameRef(idx)) + "]"))
       }
       def printTree(): Unit = {
         newLine()

sbt-dotty/sbt-test/sbt-dotty/compiler-plugin/plugin/DivideZero.scala

@@ -26,7 +26,7 @@ class DivideZero extends PluginPhase with StandardPlugin {
 
   private def isNumericDivide(sym: Symbol)(implicit ctx: Context): Boolean = {
     def test(tpe: String): Boolean =
-      (sym.owner eq ctx.requiredClass(tpe.toTermName)) && sym.name.show == "/"
+      (sym.owner eq ctx.requiredClass(tpe)) && sym.name.show == "/"
 
     test("scala.Int") || test("scala.Long") || test("scala.Short") || test("scala.Float") || test("scala.Double")
   }

tests/plugins/neg/divideZero-research/plugin_1.scala

@@ -23,7 +23,7 @@ class DivideZero extends MiniPhase with ResearchPlugin {
 
   private def isNumericDivide(sym: Symbol)(implicit ctx: Context): Boolean = {
     def test(tpe: String): Boolean =
-      (sym.owner eq ctx.requiredClass(tpe.toTermName)) && sym.name == nme.DIV
+      (sym.owner eq ctx.requiredClass(tpe)) && sym.name == nme.DIV
 
     test("scala.Int") || test("scala.Long") || test("scala.Short") || test("scala.Float") || test("scala.Double")
   }

tests/plugins/neg/divideZero/plugin_1.scala

@@ -24,7 +24,7 @@ class DivideZero extends PluginPhase with StandardPlugin {
 
   private def isNumericDivide(sym: Symbol)(implicit ctx: Context): Boolean = {
     def test(tpe: String): Boolean =
-      (sym.owner eq ctx.requiredClass(tpe.toTermName)) && sym.name == nme.DIV
+      (sym.owner eq ctx.requiredClass(tpe)) && sym.name == nme.DIV
 
     test("scala.Int") || test("scala.Long") || test("scala.Short") || test("scala.Float") || test("scala.Double")
   }

tests/plugins/pos/divideZero/plugin_1.scala

@@ -0,0 +1,41 @@
+import dotty.tools.dotc._
+import core._
+import Contexts.Context
+import plugins.Plugin
+import Phases.Phase
+import ast.tpd
+import transform.MegaPhase.MiniPhase
+import Decorators._
+import Symbols.Symbol
+import Constants.Constant
+import StdNames._
+
+
+class DivideZero extends MiniPhase with Plugin {
+  val name: String = "divideZero"
+  override val description: String = "divide by zero check"
+
+  val phaseName = name
+
+  override val research = true
+
+  override def init(options: List[String], phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] = {
+    val (before, after) = phases.span(ps => !ps.exists(_.phaseName == "pickler"))
+    before ++ (List(this) :: after)
+  }
+
+  private def isNumericDivide(sym: Symbol)(implicit ctx: Context): Boolean = {
+    def test(tpe: String): Boolean =
+      (sym.owner eq ctx.requiredClass(tpe)) && sym.name == nme.DIV
+
+    test("scala.Int") || test("scala.Long") || test("scala.Short") || test("scala.Float") || test("scala.Double")
+  }
+
+  override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = tree match {
+    case tpd.Apply(fun, tpd.Literal(Constants.Constant(v)) :: Nil) if isNumericDivide(fun.symbol) && v == 0 =>
+      ctx.warning("divide by zero", tree.pos)
+      tree
+    case _ =>
+      tree
+  }
+}