Names are no longer Seqs

Drop Seq implementation of name. This implementation
was always problematic because it entailed potentially
very costly conversions to toSimpleName. We now have
better control over when we convert a name to a simple
name.

Author: odersky

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

@@ -403,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)
     }

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/core/Definitions.scala

@@ -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.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

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

@@ -164,7 +164,7 @@ object NameKinds {
   val ExpandPrefixName        = new QualifiedNameKind(EXPANDPREFIX, "$")
 
   val ExpandedName = new QualifiedNameKind(EXPANDED, str.EXPAND_SEPARATOR) {
-    private val FalseSuper = "$$super".toTermName
+    private val FalseSuper = termName("$$super")
     private val FalseSuperLength = FalseSuper.length
 
     override def unmangle(name: SimpleTermName): TermName = {
@@ -216,10 +216,10 @@ object NameKinds {
   object DefaultGetterName extends NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
     def mkString(underlying: TermName, info: ThisInfo) = {
       val prefix = if (underlying.isConstructorName) nme.DEFAULT_GETTER_INIT else underlying
-      prefix.toString + nme.DEFAULT_GETTER + (info.num + 1)
+      prefix.toString + str.DEFAULT_GETTER + (info.num + 1)
     }
 
-    private val dgLen = nme.DEFAULT_GETTER.length
+    private val dgLen = str.DEFAULT_GETTER.length
 
     override def unmangle(name: SimpleTermName): TermName = {
       var i = name.length

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

@@ -52,24 +52,32 @@ object NameOps {
   implicit class NameDecorator[N <: Name](val name: N) extends AnyVal {
     import nme._
 
+    def testSimple(f: SimpleTermName => Boolean): Boolean = name match {
+      case name: SimpleTermName => f(name)
+      case name: TypeName => name.toTermName.testSimple(f)
+      case _ => false
+    }
+
     def likeTyped(n: PreName): N =
       (if (name.isTermName) n.toTermName else n.toTypeName).asInstanceOf[N]
 
     def isConstructorName = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
     def isStaticConstructorName = name == STATIC_CONSTRUCTOR
     def isLocalDummyName = name startsWith LOCALDUMMY_PREFIX
-    def isReplWrapperName = name.toSimpleName containsSlice INTERPRETER_IMPORT_WRAPPER
+    def isReplWrapperName = name.toString contains str.INTERPRETER_IMPORT_WRAPPER
     def isSetterName = name endsWith SETTER_SUFFIX
-    def isScala2LocalSuffix = name.endsWith(" ")
-    def isSelectorName = name.startsWith("_") && name.tail.forall(_.isDigit)
+    def isScala2LocalSuffix = testSimple(_.endsWith(" "))
+    def isSelectorName = testSimple(n => n.startsWith("_") && n.drop(1).forall(_.isDigit))
 
     /** Is name a variable name? */
-    def isVariableName: Boolean = name.length > 0 && {
-      val first = name.head
-      (((first.isLower && first.isLetter) || first == '_')
-        && (name != false_)
-        && (name != true_)
-        && (name != null_))
+    def isVariableName: Boolean = testSimple { n =>
+      n.length > 0 && {
+        val first = n.head
+        (((first.isLower && first.isLetter) || first == '_')
+          && (n != false_)
+          && (n != true_)
+          && (n != null_))
+      }
     }
 
     def isOpAssignmentName: Boolean = name match {
@@ -91,11 +99,10 @@ object NameOps {
      *  method needs to work on mangled as well as unmangled names because
      *  it is also called from the backend.
      */
-    def stripModuleClassSuffix: Name = name.toTermName match {
-      case n: SimpleTermName if n.endsWith("$") =>
-        name.unmangleClassName.exclude(ModuleClassName)
-      case _ =>
-        name.exclude(ModuleClassName)
+    def stripModuleClassSuffix: N = likeTyped {
+      val name1 =
+        if (name.isSimple && name.endsWith("$")) name.unmangleClassName else name
+      name.exclude(ModuleClassName)
     }
 
     /** If flags is a ModuleClass but not a Package, add module class suffix */
@@ -159,56 +166,13 @@ object NameOps {
       }
     }
 
-    def unmangleClassName: N =
-      if (name.isSimple && name.isTypeName)
-        if (name.endsWith(MODULE_SUFFIX) && !tpnme.falseModuleClassNames.contains(name.asTypeName))
-          likeTyped(name.dropRight(MODULE_SUFFIX.length).moduleClassName)
-        else name
-      else name
-
-    /** Translate a name into a list of simple TypeNames and TermNames.
-     *  In all segments before the last, type/term is determined by whether
-     *  the following separator char is '.' or '#'.  The last segment
-     *  is of the same type as the original name.
-     *
-     *  Examples:
-     *
-     *  package foo {
-     *    object Lorax { object Wog ; class Wog }
-     *    class Lorax  { object Zax ; class Zax }
-     *  }
-     *
-     *  f("foo.Lorax".toTermName)  == List("foo": Term, "Lorax": Term) // object Lorax
-     *  f("foo.Lorax".toTypeName)  == List("foo": Term, "Lorax": Type) // class Lorax
-     *  f("Lorax.Wog".toTermName)  == List("Lorax": Term, "Wog": Term) // object Wog
-     *  f("Lorax.Wog".toTypeName)  == List("Lorax": Term, "Wog": Type) // class Wog
-     *  f("Lorax#Zax".toTermName)  == List("Lorax": Type, "Zax": Term) // object Zax
-     *  f("Lorax#Zax".toTypeName)  == List("Lorax": Type, "Zax": Type) // class Zax
-     *
-     *  Note that in actual scala syntax you cannot refer to object Zax without an
-     *  instance of Lorax, so Lorax#Zax could only mean the type.  One might think
-     *  that Lorax#Zax.type would work, but this is not accepted by the parser.
-     *  For the purposes of referencing that object, the syntax is allowed.
-     */
-    def segments: List[Name] = {
-      def mkName(name: Name, follow: Char): Name =
-        if (follow == '.') name.toTermName else name.toTypeName
-
-      name.indexWhere(ch => ch == '.' || ch == '#') match {
-        case -1 =>
-          if (name.isEmpty) scala.Nil else name :: scala.Nil
-        case idx =>
-          mkName(name take idx, name(idx)) :: (name drop (idx + 1)).segments
-      }
-    }
-
     /** Is a synthetic function name
      *    - N for FunctionN
      *    - N for ImplicitFunctionN
       *   - (-1) otherwise
      */
     def functionArity: Int =
-      functionArityFor(tpnme.Function) max functionArityFor(tpnme.ImplicitFunction)
+      functionArityFor(str.Function) max functionArityFor(str.ImplicitFunction)
 
     /** Is a function name
      *    - FunctionN for N >= 0
@@ -221,20 +185,20 @@ object NameOps {
      *    - ImplicitFunctionN for N >= 0
      *    - false otherwise
      */
-    def isImplicitFunction: Boolean = functionArityFor(tpnme.ImplicitFunction) >= 0
+    def isImplicitFunction: Boolean = functionArityFor(str.ImplicitFunction) >= 0
 
     /** Is a synthetic function name
      *    - FunctionN for N > 22
      *    - ImplicitFunctionN for N >= 0
      *    - false otherwise
      */
     def isSyntheticFunction: Boolean = {
-      functionArityFor(tpnme.Function) > MaxImplementedFunctionArity ||
-        functionArityFor(tpnme.ImplicitFunction) >= 0
+      functionArityFor(str.Function) > MaxImplementedFunctionArity ||
+        functionArityFor(str.ImplicitFunction) >= 0
     }
 
     /** Parsed function arity for function with some specific prefix */
-    private def functionArityFor(prefix: Name): Int = {
+    private def functionArityFor(prefix: String): Int = {
       if (name.startsWith(prefix))
         try name.toString.substring(prefix.length).toInt
         catch { case _: NumberFormatException => -1 }
@@ -285,6 +249,13 @@ object NameOps {
     /** If name length exceeds allowable limit, replace part of it by hash */
     def compactified(implicit ctx: Context): TermName = termName(compactify(name.toString))
 
+    def unmangleClassName: N = name.toTermName match {
+      case name: SimpleTermName
+      if name.endsWith(str.MODULE_SUFFIX) && !nme.falseModuleClassNames.contains(name) =>
+        likeTyped(name.dropRight(str.MODULE_SUFFIX.length).moduleClassName)
+      case _ => name
+    }
+
     def unmangle(kind: NameKind): N = likeTyped {
       name rewrite {
         case unmangled: SimpleTermName =>
@@ -306,11 +277,11 @@ object NameOps {
   implicit class TermNameDecorator(val name: TermName) extends AnyVal {
     import nme._
 
-    def setterName: TermName = name.exclude(FieldName) ++ SETTER_SUFFIX
+    def setterName: TermName = name.exclude(FieldName) ++ str.SETTER_SUFFIX
 
     def getterName: TermName =
       name.exclude(FieldName).mapLast(n =>
-        if (n.endsWith(SETTER_SUFFIX)) n.take(n.length - SETTER_SUFFIX.length).asSimpleName
+        if (n.endsWith(SETTER_SUFFIX)) n.take(n.length - str.SETTER_SUFFIX.length).asSimpleName
         else n)
 
     def fieldName: TermName =
@@ -324,7 +295,7 @@ object NameOps {
       else FieldName(name)
 
     def stripScala2LocalSuffix: TermName =
-      if (name.isScala2LocalSuffix) name.init.asTermName else name
+      if (name.isScala2LocalSuffix) name.asSimpleName.dropRight(1) else name
 
     /** The name unary_x for a prefix operator x */
     def toUnaryName: TermName = name match {

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

@@ -88,8 +88,8 @@ object Names {
     /** Replace operator symbols by corresponding \$op_name's. */
     def encode: Name
 
-    def firstPart: TermName
-    def lastPart: TermName
+    def firstPart: SimpleTermName
+    def lastPart: SimpleTermName
 
     /** A more efficient version of concatenation */
     def ++ (other: Name): ThisName = ++ (other.toString)
@@ -204,7 +204,15 @@ object Names {
 
     def apply(n: Int) = chrs(start + n)
 
-    private def contains(ch: Char): Boolean = {
+    def exists(p: Char => Boolean): Boolean = {
+      var i = 0
+      while (i < length && !p(chrs(start + i))) i += 1
+      i < length
+    }
+
+    def forall(p: Char => Boolean) = !exists(!p(_))
+
+    def contains(ch: Char): Boolean = {
       var i = 0
       while (i < length && chrs(start + i) != ch) i += 1
       i < length
@@ -224,6 +232,12 @@ object Names {
       i > str.length
     }
 
+    def lastIndexOf(ch: Char, start: Int = length - 1): Int = {
+      var i = start
+      while (i >= 0 && apply(i) != ch) i -= 1
+      i
+    }
+
     override def replace(from: Char, to: Char): SimpleTermName = {
       val cs = new Array[Char](length)
       Array.copy(chrs, start, cs, 0, length)
@@ -233,6 +247,19 @@ object Names {
       termName(cs, 0, length)
     }
 
+    def slice(from: Int, until: Int): SimpleTermName = {
+      assert(0 <= from && from <= until && until <= length)
+      termName(chrs, start + from, until - from)
+    }
+
+    def drop(n: Int) = slice(n, length)
+    def take(n: Int) = slice(0, n)
+    def dropRight(n: Int) = slice(0, length - n)
+    def takeRight(n: Int) = slice(length - n, length)
+
+    def head = apply(0)
+    def last = apply(length - 1)
+
     def isSimple = true
     def asSimpleName = this
     def toSimpleName = this
@@ -242,12 +269,6 @@ object Names {
     def mapLast(f: SimpleTermName => SimpleTermName) = f(this)
     def mapParts(f: SimpleTermName => SimpleTermName) = f(this)
 
-    /*def exists(p: Char => Boolean): Boolean = {
-      var i = 0
-      while (i < length && !p(chrs(start + i))) i += 1
-      i < length
-    }*/
-
     def encode: SimpleTermName =
       if (dontEncode(toTermName)) this else NameTransformer.encode(this)
 
@@ -490,24 +511,6 @@ object Names {
 
   val dontEncode = Set(CONSTRUCTOR, EMPTY_PACKAGE, REFINEMENT)
 
-  def termNameBuilder: Builder[Char, TermName] =
-    StringBuilder.newBuilder.mapResult(termName)
-
-  def typeNameBuilder: Builder[Char, TypeName] =
-    StringBuilder.newBuilder.mapResult(termName(_).toTypeName)
-
-  implicit class nameToSeq(val name: Name) extends IndexedSeqOptimized[Char, Name] {
-    def length = name.asSimpleName.length
-    def apply(n: Int) = name.asSimpleName.apply(n)
-    override protected[this] def newBuilder: Builder[Char, Name] =
-      if (name.isTypeName) typeNameBuilder else termNameBuilder
-
-    def seq: WrappedString = new WrappedString(name.toString)
-    override protected[this] def thisCollection: WrappedString = seq
-    def indexOfSlice(name: Name): Int = indexOfSlice(name.toString)
-    def containsSlice(name: Name): Boolean = containsSlice(name.toString)
-  }
-
   implicit val NameOrdering: Ordering[Name] = new Ordering[Name] {
     private def compareInfos(x: NameInfo, y: NameInfo): Int =
       if (x.kind.tag != y.kind.tag) x.kind.tag - y.kind.tag