Merge pull request scala-js#3804 from sjrd/dedicated-types-for-names

Introduce dedicated types for the kinds of `Ident`s and their `Name`s.

Author: gzm0

compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala

@@ -20,8 +20,8 @@ import scala.reflect.{ClassTag, classTag}
 import scala.reflect.internal.Flags
 
 import org.scalajs.ir
-import ir.{Trees => js, Types => jstpe}
-import ir.Trees.OptimizerHints
+import org.scalajs.ir.{Definitions => defs, Trees => js, Types => jstpe}
+import org.scalajs.ir.Trees.OptimizerHints
 
 import org.scalajs.nscplugin.util.ScopedVar
 import ScopedVar.withScopedVars
@@ -667,7 +667,7 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
       val superClass = {
         val superClassSym = currentClassSym.superClass
         if (isNestedJSClass(superClassSym)) {
-          js.VarRef(js.Ident(JSSuperClassParamName))(jstpe.AnyType)
+          js.VarRef(js.LocalIdent(JSSuperClassParamName))(jstpe.AnyType)
         } else {
           js.LoadJSConstructor(encodeClassRef(superClassSym))
         }
@@ -1105,19 +1105,19 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
   }
 
   private def genFormalArg(index: Int)(implicit pos: Position): js.ParamDef = {
-    js.ParamDef(js.Ident("arg$" + index), jstpe.AnyType,
+    js.ParamDef(js.LocalIdent(defs.LocalName("arg$" + index)), jstpe.AnyType,
         mutable = false, rest = false)
   }
 
   private def genRestFormalArg()(implicit pos: Position): js.ParamDef = {
-    js.ParamDef(js.Ident("arg$rest"), jstpe.AnyType,
+    js.ParamDef(js.LocalIdent(defs.LocalName("arg$rest")), jstpe.AnyType,
         mutable = false, rest = true)
   }
 
   private def genFormalArgRef(index: Int, minArgc: Int)(
       implicit pos: Position): js.Tree = {
     if (index <= minArgc)
-      js.VarRef(js.Ident("arg$" + index))(jstpe.AnyType)
+      js.VarRef(js.LocalIdent(defs.LocalName("arg$" + index)))(jstpe.AnyType)
     else
       js.JSSelect(genRestArgRef(), js.IntLiteral(index - 1 - minArgc))
   }
@@ -1135,7 +1135,7 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
   }
 
   private def genRestArgRef()(implicit pos: Position): js.Tree =
-    js.VarRef(js.Ident("arg$rest"))(jstpe.AnyType)
+    js.VarRef(js.LocalIdent(defs.LocalName("arg$rest")))(jstpe.AnyType)
 
   private def hasRepeatedParam(sym: Symbol) = {
     enteringPhase(currentRun.uncurryPhase) {

compiler/src/main/scala/org/scalajs/nscplugin/GenJSExports.scala

@@ -17,20 +17,12 @@ import scala.collection.mutable
 import scala.tools.nsc._
 
 import org.scalajs.ir
-import ir.{Trees => js, Types => jstpe}
+import org.scalajs.ir.{Definitions => defs, Trees => js, Types => jstpe}
 
 import org.scalajs.nscplugin.util.{ScopedVar, VarBox}
 import ScopedVar.withScopedVars
 
-/** Encoding of symbol names for JavaScript
- *
- *  Some issues that this encoding solves:
- *  * Overloading: encode the full signature in the JS name
- *  * Same scope for fields and methods of a class
- *  * Global access to classes and modules (by their full name)
- *
- *  @author Sébastien Doeraene
- */
+/** Encoding of symbol names for the IR. */
 trait JSEncoding[G <: Global with Singleton] extends SubComponent {
   self: GenJSCode[G] =>
 
@@ -51,24 +43,28 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
    *  local name scope using [[reserveLocalName]]. Otherwise, this name can
    *  clash with another local identifier.
    */
-  final val JSSuperClassParamName = "$superClass"
+  final val JSSuperClassParamName = defs.LocalName("$superClass")
 
   // Fresh local name generator ----------------------------------------------
 
   private val usedLocalNames = new ScopedVar[mutable.Set[String]]
-  private val returnLabelName = new ScopedVar[VarBox[Option[String]]]
-  private val localSymbolNames = new ScopedVar[mutable.Map[Symbol, String]]
+  private val localSymbolNames = new ScopedVar[mutable.Map[Symbol, defs.LocalName]]
+  private val usedLabelNames = new ScopedVar[mutable.Set[String]]
+  private val labelSymbolNames = new ScopedVar[mutable.Map[Symbol, defs.LabelName]]
+  private val returnLabelName = new ScopedVar[VarBox[Option[defs.LabelName]]]
   private val isReserved = Set("arguments", "eval")
 
   def withNewLocalNameScope[A](body: => A): A = {
     withScopedVars(
         usedLocalNames := mutable.Set.empty,
-        returnLabelName := null,
-        localSymbolNames := mutable.Map.empty
+        localSymbolNames := mutable.Map.empty,
+        usedLabelNames := mutable.Set.empty,
+        labelSymbolNames := mutable.Map.empty,
+        returnLabelName := null
     )(body)
   }
 
-  def reserveLocalName(name: String): Unit = {
+  def reserveLocalName(name: defs.LocalName): Unit = {
     require(usedLocalNames.isEmpty,
         s"Trying to reserve the name '$name' but names have already been " +
         "allocated")
@@ -85,48 +81,61 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
         case None =>
           inner
         case Some(labelName) =>
-          js.Labeled(js.Ident(labelName), tpe, inner)
+          js.Labeled(js.LabelIdent(labelName), tpe, inner)
       }
     }
   }
 
-  private def freshName(base: String = "x"): String = {
+  private def freshNameGeneric[N <: String](base: String,
+      usedNamesSet: mutable.Set[String], createNameFun: String => N): N = {
     var suffix = 1
     var longName = base
-    while (usedLocalNames(longName) || isReserved(longName)) {
+    while (usedNamesSet(longName) || isReserved(longName)) {
       suffix += 1
-      longName = base+"$"+suffix
+      longName = base + "$" + suffix
     }
-    usedLocalNames += longName
-    mangleJSName(longName)
+    usedNamesSet += longName
+    createNameFun(mangleJSName(longName))
   }
 
-  def freshLocalIdent()(implicit pos: ir.Position): js.Ident =
-    js.Ident(freshName(), None)
+  private def freshName(base: String): defs.LocalName =
+    freshNameGeneric(base, usedLocalNames, defs.LocalName(_))
 
-  def freshLocalIdent(base: String)(implicit pos: ir.Position): js.Ident =
-    js.Ident(freshName(base), Some(base))
+  def freshLocalIdent()(implicit pos: ir.Position): js.LocalIdent =
+    js.LocalIdent(freshName("x"), None)
 
-  private def localSymbolName(sym: Symbol): String =
+  def freshLocalIdent(base: String)(implicit pos: ir.Position): js.LocalIdent =
+    js.LocalIdent(freshName(base), Some(base))
+
+  private def localSymbolName(sym: Symbol): defs.LocalName =
     localSymbolNames.getOrElseUpdate(sym, freshName(sym.name.toString))
 
-  def getEnclosingReturnLabel()(implicit pos: ir.Position): js.Ident = {
+  private def freshLabelName(base: String): defs.LabelName =
+    freshNameGeneric(base, usedLabelNames, defs.LabelName(_))
+
+  def freshLabelIdent(base: String)(implicit pos: ir.Position): js.LabelIdent =
+    js.LabelIdent(freshLabelName(base))
+
+  private def labelSymbolName(sym: Symbol): defs.LabelName =
+    labelSymbolNames.getOrElseUpdate(sym, freshLabelName(sym.name.toString))
+
+  def getEnclosingReturnLabel()(implicit pos: ir.Position): js.LabelIdent = {
     val box = returnLabelName.get
     if (box == null)
       throw new IllegalStateException(s"No enclosing returnable scope at $pos")
     if (box.value.isEmpty)
-      box.value = Some(freshName("_return"))
-    js.Ident(box.value.get)
+      box.value = Some(freshLabelName("_return"))
+    js.LabelIdent(box.value.get)
   }
 
   // Encoding methods ----------------------------------------------------------
 
-  def encodeLabelSym(sym: Symbol)(implicit pos: Position): js.Ident = {
+  def encodeLabelSym(sym: Symbol)(implicit pos: Position): js.LabelIdent = {
     require(sym.isLabel, "encodeLabelSym called with non-label symbol: " + sym)
-    js.Ident(localSymbolName(sym), Some(sym.unexpandedName.decoded))
+    js.LabelIdent(labelSymbolName(sym))
   }
 
-  def encodeFieldSym(sym: Symbol)(implicit pos: Position): js.Ident = {
+  def encodeFieldSym(sym: Symbol)(implicit pos: Position): js.FieldIdent = {
     require(sym.owner.isClass && sym.isTerm && !sym.isMethod && !sym.isModule,
         "encodeFieldSym called with non-field symbol: " + sym)
 
@@ -135,11 +144,12 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
       if (name0.charAt(name0.length()-1) != ' ') name0
       else name0.substring(0, name0.length()-1)
 
-    js.Ident(mangleJSName(name), Some(sym.unexpandedName.decoded))
+    js.FieldIdent(defs.FieldName(mangleJSName(name)),
+        Some(sym.unexpandedName.decoded))
   }
 
   def encodeMethodSym(sym: Symbol, reflProxy: Boolean = false)(
-      implicit pos: Position): js.Ident = {
+      implicit pos: Position): js.MethodIdent = {
 
     require(sym.isMethod,
         "encodeMethodSym called with non-method symbol: " + sym)
@@ -150,19 +160,20 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
 
     val paramsString = makeParamsString(sym, reflProxy)
 
-    js.Ident(encodedName + paramsString,
+    js.MethodIdent(defs.MethodName(encodedName + paramsString),
         Some(sym.unexpandedName.decoded + paramsString))
   }
 
-  def encodeStaticMemberSym(sym: Symbol)(implicit pos: Position): js.Ident = {
+  def encodeStaticMemberSym(sym: Symbol)(implicit pos: Position): js.MethodIdent = {
     require(sym.isStaticMember,
         "encodeStaticMemberSym called with non-static symbol: " + sym)
-    js.Ident(
-        mangleJSName(encodeMemberNameInternal(sym)) + "__" + internalName(sym.tpe),
+    js.MethodIdent(
+        defs.MethodName(
+            mangleJSName(encodeMemberNameInternal(sym)) + "__" + internalName(sym.tpe)),
         Some(sym.unexpandedName.decoded))
   }
 
-  def encodeLocalSym(sym: Symbol)(implicit pos: Position): js.Ident = {
+  def encodeLocalSym(sym: Symbol)(implicit pos: Position): js.LocalIdent = {
     /* The isValueParameter case is necessary to work around an internal bug
      * of scalac: for some @varargs methods, the owner of some parameters is
      * the enclosing class rather the method, so !sym.owner.isClass fails.
@@ -172,7 +183,7 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
     require(sym.isValueParameter ||
         (!sym.owner.isClass && sym.isTerm && !sym.isMethod && !sym.isModule),
         "encodeLocalSym called with non-local symbol: " + sym)
-    js.Ident(localSymbolName(sym), Some(sym.unexpandedName.decoded))
+    js.LocalIdent(localSymbolName(sym), Some(sym.unexpandedName.decoded))
   }
 
   def foreignIsImplClass(sym: Symbol): Boolean =
@@ -191,24 +202,26 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
   def encodeClassRef(sym: Symbol): jstpe.ClassRef =
     jstpe.ClassRef(encodeClassFullName(sym))
 
-  def encodeClassFullNameIdent(sym: Symbol)(implicit pos: Position): js.Ident = {
-    js.Ident(encodeClassFullName(sym), Some(sym.fullName))
-  }
+  def encodeClassFullNameIdent(sym: Symbol)(implicit pos: Position): js.ClassIdent =
+    js.ClassIdent(encodeClassFullName(sym), Some(sym.fullName))
+
+  private val BoxedStringModuleClassName = defs.ClassName("jl_String$")
+  private val BoxedVoidModuleClassName = defs.ClassName("jl_Void$")
 
-  def encodeClassFullName(sym: Symbol): String = {
+  def encodeClassFullName(sym: Symbol): defs.ClassName = {
     assert(!sym.isPrimitiveValueClass,
         s"Illegal encodeClassFullName(${sym.fullName}")
     if (sym == jsDefinitions.HackedStringClass) {
       ir.Definitions.BoxedStringClass
     } else if (sym == jsDefinitions.HackedStringModClass) {
-      "jl_String$"
+      BoxedStringModuleClassName
     } else if (sym == definitions.BoxedUnitClass) {
       // Rewire scala.runtime.BoxedUnit to java.lang.Void, as the IR expects
       // BoxedUnit$ is a JVM artifact
       ir.Definitions.BoxedUnitClass
     } else if (sym == jsDefinitions.BoxedUnitModClass) {
       // Same for its module class
-      "jl_Void$"
+      BoxedVoidModuleClassName
     } else {
       ir.Definitions.encodeClassName(
           sym.fullName + (if (needsModuleClassSuffix(sym)) "$" else ""))

compiler/src/main/scala/org/scalajs/nscplugin/JSEncoding.scala

@@ -16,7 +16,7 @@ import scala.collection.mutable
 
 import scala.tools.nsc.Global
 
-import org.scalajs.ir.Trees.isValidIdentifier
+import org.scalajs.ir.Trees.isValidJSIdentifier
 
 /**
  *  Prepare export generation
@@ -324,7 +324,7 @@ trait PrepJSExports[G <: Global with Singleton] { this: PrepJSInterop[G] =>
           }
 
           // The top-level name must be a valid JS identifier
-          if (!isValidIdentifier(name)) {
+          if (!isValidJSIdentifier(name)) {
             reporter.error(annot.pos,
                 "The top-level export name must be a valid JavaScript " +
                 "identifier")

compiler/src/main/scala/org/scalajs/nscplugin/PrepJSExports.scala

@@ -18,7 +18,7 @@ import nsc._
 import scala.collection.immutable.ListMap
 import scala.collection.mutable
 
-import org.scalajs.ir.Trees.{isValidIdentifier, JSNativeLoadSpec}
+import org.scalajs.ir.Trees.{isValidJSIdentifier, JSNativeLoadSpec}
 
 /** Prepares classes extending js.Any for JavaScript interop
  *
@@ -725,7 +725,7 @@ abstract class PrepJSInterop[G <: Global with Singleton](val global: G)
 
         def parseGlobalPath(pathName: String): Global = {
           val globalRef :: path = parsePath(pathName)
-          if (!isValidIdentifier(globalRef)) {
+          if (!isValidJSIdentifier(globalRef)) {
             reporter.error(pos,
                 "The name of a JS global variable must be a valid JS " +
                 s"identifier (got '$globalRef')")

compiler/src/main/scala/org/scalajs/nscplugin/PrepJSInterop.scala

@@ -14,8 +14,7 @@ package org.scalajs.nscplugin
 
 import scala.tools.nsc._
 
-import org.scalajs.ir
-import ir.{Definitions, Types}
+import org.scalajs.ir.Types
 
 /** Conversions from scalac `Type`s to the IR `Type`s and `TypeRef`s. */
 trait TypeConversions[G <: Global with Singleton] extends SubComponent {

compiler/src/main/scala/org/scalajs/nscplugin/TypeConversions.scala

@@ -55,7 +55,7 @@ class OptimizationTest extends JSASTTest {
     }
     """.
     hasExactly(2, "calls to Array.apply methods") {
-      case js.Apply(_, js.LoadModule(jstpe.ClassRef("s_Array$")), js.Ident(methodName, _), _)
+      case js.Apply(_, js.LoadModule(jstpe.ClassRef("s_Array$")), js.MethodIdent(methodName, _), _)
           if methodName.startsWith("apply__") =>
     }
   }