Delay name mangling

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

@@ -30,9 +30,9 @@ import Decorators._
 import tpd._
 
 import scala.tools.asm
-import NameOps._
 import StdNames.nme
 import NameOps._
+import NameKinds.DefaultGetterName
 import dotty.tools.dotc.core
 import dotty.tools.dotc.core.Names.TypeName
 
@@ -255,7 +255,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
           val evalue = t.symbol.name.toString // value the actual enumeration value.
           av.visitEnum(name, edesc, evalue)
         } else {
-          assert(toDenot(t.symbol).name.toTermName.defaultGetterIndex >= 0) // this should be default getter. do not emmit.
+          assert(toDenot(t.symbol).name.is(DefaultGetterName)) // this should be default getter. do not emmit.
         }
       case t: SeqLiteral =>
         val arrAnnotV: AnnotationVisitor = av.visitArray(name)
@@ -421,7 +421,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val Flag_METHOD: Flags = Flags.Method.bits
   val ExcludedForwarderFlags: Flags = {
       Flags.Specialized | Flags.Lifted | Flags.Protected | Flags.JavaStatic |
-     Flags.ExpandedName | Flags.Bridge | Flags.VBridge | Flags.Private | Flags.Macro
+      Flags.Bridge | Flags.VBridge | Flags.Private | Flags.Macro
   }.bits
 
 
@@ -544,8 +544,8 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def toTermName: Name = n.toTermName
     def dropModule: Name = n.stripModuleClassSuffix
 
-    def len: Int = n.length
-    def offset: Int = n.start
+    def len: Int = n.toSimpleName.length
+    def offset: Int = n.toSimpleName.start
     def isTermName: Boolean = n.isTermName
     def startsWith(s: String): Boolean = n.startsWith(s)
   }
@@ -557,7 +557,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def fullName: String = sym.showFullName
     def simpleName: Name = sym.name
     def javaSimpleName: Name = toDenot(sym).name // addModuleSuffix(simpleName.dropLocal)
-    def javaBinaryName: Name = toDenot(sym).fullNameSeparated("/") // addModuleSuffix(fullNameInternal('/'))
+    def javaBinaryName: Name = javaClassName.replace('.', '/').toTypeName // TODO: can we make this a string? addModuleSuffix(fullNameInternal('/'))
     def javaClassName: String = toDenot(sym).fullName.toString// addModuleSuffix(fullNameInternal('.')).toString
     def name: Name = sym.name
     def rawname: Name = {
@@ -794,7 +794,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
     def memberInfo(s: Symbol): Type = tp.memberInfo(s)
 
-    def decls: List[Symbol] = tp.decls.map(_.symbol).toList
+    def decls: List[Symbol] = tp.decls.toList
 
     def members: List[Symbol] =
       tp.memberDenots(takeAllFilter, (name, buf) => buf ++= tp.member(name).alternatives).map(_.symbol).toList

compiler/src/dotty/tools/dotc/FromTasty.scala

@@ -17,6 +17,7 @@ import Decorators._
 import dotty.tools.dotc.transform.Pickler
 import tasty.DottyUnpickler
 import ast.tpd._
+import NameKinds.QualifiedName
 
 /** Compiler for TASTY files.
  *  Usage:
@@ -74,7 +75,7 @@ object FromTasty extends Driver {
       case unit: TASTYCompilationUnit =>
         val className = unit.className.toTypeName
         val clsd =
-          if (className.contains('.')) ctx.base.staticRef(className)
+          if (className.is(QualifiedName)) ctx.base.staticRef(className)
           else defn.EmptyPackageClass.info.decl(className)
         def cannotUnpickle(reason: String) = {
           ctx.error(s"class $className cannot be unpickled because $reason")

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -6,6 +6,7 @@ import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
 import Decorators._
+import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import language.higherKinds
 import typer.FrontEnd
 import collection.mutable.ListBuffer
@@ -128,7 +129,7 @@ object desugar {
   def makeImplicitParameters(tpts: List[Tree], forPrimaryConstructor: Boolean)(implicit ctx: Context) =
     for (tpt <- tpts) yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param
-       val epname = ctx.freshName(nme.EVIDENCE_PARAM_PREFIX).toTermName
+       val epname = EvidenceParamName.fresh()
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit)
     }
 
@@ -186,7 +187,7 @@ object desugar {
       case (vparam :: vparams) :: vparamss1 =>
         def defaultGetter: DefDef =
           DefDef(
-            name = meth.name.defaultGetterName(n),
+            name = DefaultGetterName(meth.name, n),
             tparams = meth.tparams.map(tparam => dropContextBound(toDefParam(tparam))),
             vparamss = takeUpTo(normalizedVparamss.nestedMap(toDefParam), n),
             tpt = TypeTree(),
@@ -230,7 +231,7 @@ object desugar {
   private def evidenceParams(meth: DefDef)(implicit ctx: Context): List[ValDef] =
     meth.vparamss.reverse match {
       case (vparams @ (vparam :: _)) :: _ if vparam.mods is Implicit =>
-        vparams.dropWhile(!_.name.startsWith(nme.EVIDENCE_PARAM_PREFIX))
+        vparams.dropWhile(!_.name.is(EvidenceParamName))
       case _ =>
         Nil
     }
@@ -244,7 +245,7 @@ object desugar {
   def typeDef(tdef: TypeDef)(implicit ctx: Context): Tree = {
     if (tdef.mods is PrivateLocalParam) {
       val tparam = cpy.TypeDef(tdef)(name = tdef.name.expandedName(ctx.owner))
-        .withMods(tdef.mods &~ PrivateLocal | ExpandedName)
+        .withMods(tdef.mods &~ PrivateLocal)
       val alias = cpy.TypeDef(tdef)(rhs = refOfDef(tparam))
         .withMods(tdef.mods & VarianceFlags | PrivateLocalParamAccessor | Synthetic)
       Thicket(tparam, alias)
@@ -402,7 +403,7 @@ object desugar {
 
     def anyRef = ref(defn.AnyRefAlias.typeRef)
     def productConstr(n: Int) = {
-      val tycon = scalaDot((tpnme.Product.toString + n).toTypeName)
+      val tycon = scalaDot((str.Product + n).toTypeName)
       val targs = constrVparamss.head map (_.tpt)
       if (targs.isEmpty) tycon else AppliedTypeTree(tycon, targs)
     }
@@ -635,7 +636,7 @@ object desugar {
         case (named, tpt) :: Nil =>
           derivedValDef(original, named, tpt, matchExpr, mods)
         case _ =>
-          val tmpName = ctx.freshName().toTermName
+          val tmpName = UniqueName.fresh()
           val patMods =
             mods & Lazy | Synthetic | (if (ctx.owner.isClass) PrivateLocal else EmptyFlags)
           val firstDef =
@@ -810,7 +811,7 @@ object desugar {
         val selectPos = Position(left.pos.start, op.pos.end, op.pos.start)
         Apply(Select(left, op.name).withPos(selectPos), args)
       } else {
-        val x = ctx.freshName().toTermName
+        val x = UniqueName.fresh()
         val selectPos = Position(op.pos.start, right.pos.end, op.pos.start)
         new InfixOpBlock(
           ValDef(x, TypeTree(), left).withMods(synthetic),
@@ -888,7 +889,7 @@ object desugar {
         case id: Ident if isVarPattern(id) && id.name != nme.WILDCARD => (id, id)
         case Typed(id: Ident, _) if isVarPattern(id) && id.name != nme.WILDCARD => (pat, id)
         case _ =>
-          val name = ctx.freshName().toTermName
+          val name = UniqueName.fresh()
           (Bind(name, pat), Ident(name))
       }
 

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -157,7 +157,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   }
 
   /** Is name a left-associative operator? */
-  def isLeftAssoc(operator: Name) = operator.nonEmpty && (operator.last != ':')
+  def isLeftAssoc(operator: Name) = !operator.isEmpty && (operator.toSimpleName.last != ':')
 
   /** can this type be a type pattern? */
   def mayBeTypePat(tree: untpd.Tree): Boolean = unsplice(tree) match {

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -316,7 +316,7 @@ object Trees {
     def namePos =
       if (pos.exists)
         if (rawMods.is(Synthetic)) Position(pos.point, pos.point)
-        else Position(pos.point, pos.point + name.stripModuleClassSuffix.length, pos.point)
+        else Position(pos.point, pos.point + name.stripModuleClassSuffix.lastPart.length, pos.point)
       else pos
   }
 

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -12,6 +12,7 @@ import Denotations._, Decorators._, DenotTransformers._
 import collection.mutable
 import util.{Property, SourceFile, NoSource}
 import typer.ErrorReporting._
+import NameKinds.TempResultName
 
 import scala.annotation.tailrec
 import scala.io.Codec
@@ -897,7 +898,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def evalOnce(tree: Tree)(within: Tree => Tree)(implicit ctx: Context) = {
     if (isIdempotentExpr(tree)) within(tree)
     else {
-      val vdef = SyntheticValDef(ctx.freshName("ev$").toTermName, tree)
+      val vdef = SyntheticValDef(TempResultName.fresh(), tree)
       Block(vdef :: Nil, within(Ident(vdef.namedType)))
     }
   }

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -65,9 +65,9 @@ class ScalaSettings extends Settings.SettingGroup {
   val YcheckMods = BooleanSetting("-Ycheck-mods", "Check that symbols and their defining trees have modifiers in sync")
   val debug = BooleanSetting("-Ydebug", "Increase the quantity of debugging output.")
   val debugAlias = BooleanSetting("-Ydebug-alias", "Never follow alias when printing types")
-  val debugNames = BooleanSetting("-YdebugNames", "Show name-space indicators when printing names")
   val debugTrace = BooleanSetting("-Ydebug-trace", "Trace core operations")
   val debugFlags = BooleanSetting("-Ydebug-flags", "Print all flags of definitions")
+  val debugNames = BooleanSetting("-Ydebug-names", "Show internal representation of names")
   val debugOwners = BooleanSetting("-Ydebug-owners", "Print all owners of definitions (requires -Yprint-syms)")
   val termConflict = ChoiceSetting("-Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error")
   val log = PhasesSetting("-Ylog", "Log operations during")

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

@@ -174,9 +174,6 @@ object Contexts {
     protected def freshNames_=(freshNames: FreshNameCreator) = _freshNames = freshNames
     def freshNames: FreshNameCreator = _freshNames
 
-    def freshName(prefix: String = ""): String = freshNames.newName(prefix)
-    def freshName(prefix: Name): String = freshName(prefix.toString)
-
     /** A map in which more contextual properties can be stored */
     private var _moreProperties: Map[Key[Any], Any] = _
     protected def moreProperties_=(moreProperties: Map[Key[Any], Any]) = _moreProperties = moreProperties
@@ -297,7 +294,7 @@ object Contexts {
 
     /** Is this a context that introduces a non-empty scope? */
     def isNonEmptyScopeContext: Boolean =
-      (this.scope ne outer.scope) && this.scope.nonEmpty
+      (this.scope ne outer.scope) && !this.scope.isEmpty
 
     /** Leave message in diagnostics buffer if it exists */
     def diagnose(str: => String) =

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

@@ -67,7 +67,7 @@ class Definitions {
     enterTypeField(cls, name, flags | ClassTypeParamCreationFlags, scope)
 
   private def enterSyntheticTypeParam(cls: ClassSymbol, paramFlags: FlagSet, scope: MutableScope, suffix: String = "T0") =
-    enterTypeParam(cls, suffix.toTypeName.expandedName(cls), ExpandedName | paramFlags, scope)
+    enterTypeParam(cls, suffix.toTypeName.expandedName(cls), paramFlags, scope)
 
   // NOTE: Ideally we would write `parentConstrs: => Type*` but SIP-24 is only
   // implemented in Dotty and not in Scala 2.
@@ -108,7 +108,7 @@ class Definitions {
    *        def apply(implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    */
-  private def newFunctionNTrait(name: TypeName) = {
+  def newFunctionNTrait(name: TypeName) = {
     val completer = new LazyType {
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         val cls = denot.asClass.classSymbol
@@ -119,7 +119,7 @@ class Definitions {
             enterTypeParam(cls, name ++ "$T" ++ i.toString, Contravariant, decls)
         val resParam = enterTypeParam(cls, name ++ "$R", Covariant, decls)
         val (methodType, parentTraits) =
-          if (name.startsWith(tpnme.ImplicitFunction)) {
+          if (name.firstPart.startsWith(str.ImplicitFunction)) {
             val superTrait =
               FunctionType(arity).appliedTo(argParams.map(_.typeRef) ::: resParam.typeRef :: Nil)
             (ImplicitMethodType, ctx.normalizeToClassRefs(superTrait :: Nil, cls, decls))
@@ -723,12 +723,11 @@ class Definitions {
   /** If type `ref` refers to a class in the scala package, its name, otherwise EmptyTypeName */
   def scalaClassName(ref: Type)(implicit ctx: Context): TypeName = scalaClassName(ref.classSymbol)
 
-  private def isVarArityClass(cls: Symbol, prefix: Name) = {
-    val name = scalaClassName(cls)
-    name.startsWith(prefix) &&
-    name.length > prefix.length &&
-    name.drop(prefix.length).forall(_.isDigit)
-  }
+  private def isVarArityClass(cls: Symbol, prefix: String) =
+    scalaClassName(cls).testSimple(name =>
+      name.startsWith(prefix) &&
+      name.length > prefix.length &&
+      name.drop(prefix.length).forall(_.isDigit))
 
   def isBottomClass(cls: Symbol) =
     cls == NothingClass || cls == NullClass
@@ -758,9 +757,9 @@ class Definitions {
    */
   def isSyntheticFunctionClass(cls: Symbol) = scalaClassName(cls).isSyntheticFunction
 
-  def isAbstractFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.AbstractFunction)
-  def isTupleClass(cls: Symbol) = isVarArityClass(cls, tpnme.Tuple)
-  def isProductClass(cls: Symbol) = isVarArityClass(cls, tpnme.Product)
+  def isAbstractFunctionClass(cls: Symbol) = isVarArityClass(cls, str.AbstractFunction)
+  def isTupleClass(cls: Symbol) = isVarArityClass(cls, str.Tuple)
+  def isProductClass(cls: Symbol) = isVarArityClass(cls, str.Product)
 
   /** Returns the erased class of the function class `cls`
    *    - FunctionN for N > 22 becomes FunctionXXL
@@ -933,23 +932,6 @@ class Definitions {
 
   // ----- Initialization ---------------------------------------------------
 
-  /** Give the scala package a scope where a FunctionN trait is automatically
-   *  added when someone looks for it.
-   */
-  private def makeScalaSpecial()(implicit ctx: Context) = {
-    val oldInfo = ScalaPackageClass.classInfo
-    val oldDecls = oldInfo.decls
-    val newDecls = new MutableScope(oldDecls) {
-      override def lookupEntry(name: Name)(implicit ctx: Context): ScopeEntry = {
-        val res = super.lookupEntry(name)
-        if (res == null && name.isTypeName && name.isSyntheticFunction)
-          newScopeEntry(newFunctionNTrait(name.asTypeName))
-        else res
-      }
-    }
-    ScalaPackageClass.info = oldInfo.derivedClassInfo(decls = newDecls)
-  }
-
   /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   lazy val syntheticScalaClasses = List(
     AnyClass,
@@ -977,8 +959,6 @@ class Definitions {
   def init()(implicit ctx: Context) = {
     this.ctx = ctx
     if (!_isInitialized) {
-      makeScalaSpecial()
-
       // force initialization of every symbol that is synthesized or hijacked by the compiler
       val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
 

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

@@ -4,8 +4,9 @@ package core
 
 import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation }
 import Contexts.{Context, ContextBase}
-import Names.{Name, PreName}
-import Names.TypeName
+import Names._
+import NameOps._
+import NameKinds._
 import StdNames._
 import Symbols.NoSymbol
 import Symbols._
@@ -1171,27 +1172,42 @@ object Denotations {
      *  if generateStubs is set, generates stubs for missing top-level symbols
      */
     def staticRef(path: Name, generateStubs: Boolean = true)(implicit ctx: Context): Denotation = {
-      def recur(path: Name, len: Int): Denotation = {
-        val point = path.lastIndexOf('.', len - 1)
-        val owner =
-          if (point > 0) recur(path.toTermName, point).disambiguate(_.info.isParameterless)
-          else if (path.isTermName) defn.RootClass.denot
-          else defn.EmptyPackageClass.denot
+      def select(prefix: Denotation, selector: Name): Denotation = {
+        val owner = prefix.disambiguate(_.info.isParameterless)
         if (owner.exists) {
-          val name = path slice (point + 1, len)
-          val result = owner.info.member(name)
-          if (result ne NoDenotation) result
+          val result = owner.info.member(selector)
+          if (result.exists) result
           else {
             val alt =
-              if (generateStubs) missingHook(owner.symbol.moduleClass, name)
+              if (generateStubs) missingHook(owner.symbol.moduleClass, selector)
               else NoSymbol
-            if (alt.exists) alt.denot
-            else MissingRef(owner, name)
+            if (alt.exists) alt.denot else MissingRef(owner, selector)
           }
         }
         else owner
       }
-      recur(path, path.length)
+      def recur(path: Name, wrap: TermName => Name = identity): Denotation = path match {
+        case path: TypeName =>
+          recur(path.toTermName, n => n.toTypeName)
+        case ModuleClassName(underlying) =>
+          recur(underlying, n => wrap(ModuleClassName(n)))
+        case QualifiedName(prefix, selector) =>
+          select(recur(prefix), wrap(selector))
+        case qn @ AnyQualifiedName(prefix, _) =>
+          recur(prefix, n => wrap(qn.info.mkString(n).toTermName))
+        case path: SimpleTermName =>
+          def recurSimple(len: Int, wrap: TermName => Name): Denotation = {
+            val point = path.lastIndexOf('.', len - 1)
+            val selector = wrap(path.slice(point + 1, len).asTermName)
+            val prefix =
+              if (point > 0) recurSimple(point, identity)
+              else if (selector.isTermName) defn.RootClass.denot
+              else defn.EmptyPackageClass.denot
+            select(prefix, selector)
+          }
+          recurSimple(path.length, wrap)
+      }
+      recur(path)
     }
 
     /** If we are looking for a non-existing term name in a package,