Merge pull request #2128 from dotty-staging/add-semantic-names

Delay name mangling

Author: odersky

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,