Eliminating getter generation in namer/typer.

The idea is that getters shoul dbe generated later (probably during UnCurry). This is much better for handling modules,
and also obviates the need to have LocalNames. Getters can be generated as soon in the compilation pipeline as methoda always get a parameter list. That way, we can distinguihs getters from fields without playing any tricks with names.

6 files changed, 15 insertions, 98 deletions

diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 0e1de4b1b..68219bd7d 100644
--- a/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/src/dotty/tools/dotc/ast/Desugar.scala
@@ -19,24 +19,13 @@ object desugar {
 
   def valDef(vdef: ValDef)(implicit ctx: Context): Tree = {
     val ValDef(mods, name, tpt, rhs) = vdef
-    if (!ctx.owner.isClass || (mods is Private)) vdef
-    else flatTree {
-      val (field, getterRhs) =
-        if (rhs.isEmpty)
-          (EmptyTree, EmptyTree)
-        else {
-          val lname = name.toLocalName
-          (cpy.ValDef(vdef, mods, lname, tpt, rhs), Ident(lname))
-        }
-      val getter = cpy.DefDef(vdef, mods | Accessor, name, Nil, Nil, tpt, getterRhs)
-      if (!(mods is Mutable)) field :: getter :: Nil
-      else {
-        val setterParam = makeSyntheticParameter(tpt = TypeTree(getter))
-        val setter = cpy.DefDef(vdef,
-          mods | Accessor, name.getterToSetter, Nil, (setterParam :: Nil) :: Nil,
-          EmptyTree, refOfDef(setterParam))
-        field :: getter :: setter :: Nil
-      }
+    if (!ctx.owner.isClass || (mods is Private) || !(mods is Mutable)) vdef
+    else {
+      val setterParam = makeSyntheticParameter(tpt = TypeTree(vdef))
+      val setter = cpy.DefDef(vdef,
+        mods | Accessor, name.setterName, Nil, (setterParam :: Nil) :: Nil,
+        EmptyTree, refOfDef(setterParam))
+      Thicket(vdef, setter)
     }
   }
 
@@ -233,7 +222,7 @@ object desugar {
     val clsSelf = cpy.ValDef(self, self.mods, self.name, SingletonTypeTree(Ident(name)), self.rhs)
     val clsTmpl = cpy.Template(tmpl, constr, parents, clsSelf, body)
     val cls = TypeDef(mods.toTypeFlags & AccessFlags | ModuleClassCreationFlags, clsName, clsTmpl)
-    Thicket(valDef(modul), cls)
+    Thicket(modul, cls)
   }
 
   def memberDef(tree: Tree)(implicit ctx: Context): Tree = tree match {
diff --git a/src/dotty/tools/dotc/ast/TreeInfo.scala b/src/dotty/tools/dotc/ast/TreeInfo.scala
index 4dba38e0e..416c64079 100644
--- a/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -323,7 +323,7 @@ trait TypedTreeInfo extends TreeInfo[Type] {self: Trees.Instance[Type] =>
     def sym = tree.symbol
     def isVar    = sym is Mutable
     def isGetter =
-      mayBeVarGetter(sym) && sym.owner.info.member(sym.name.asTermName.getterToSetter).exists
+      mayBeVarGetter(sym) && sym.owner.info.member(sym.name.asTermName.setterName).exists
 
     tree match {
       case Ident(_) => isVar
diff --git a/src/dotty/tools/dotc/core/NameOps.scala b/src/dotty/tools/dotc/core/NameOps.scala
index 9e658f4af..1ca3bc418 100644
--- a/src/dotty/tools/dotc/core/NameOps.scala
+++ b/src/dotty/tools/dotc/core/NameOps.scala
@@ -66,8 +66,6 @@ object NameOps {
     def isModuleVarName(name: Name): Boolean =
       name.stripAnonNumberSuffix endsWith MODULE_VAR_SUFFIX
 
-    def isLocalName = name.isInstanceOf[LocalName]
-
     /** Is name a variable name? */
     def isVariableName: Boolean = {
       val first = name.head
@@ -190,12 +188,7 @@ object NameOps {
     def expandedSetterName(base: Symbol)(implicit ctx: Context): TermName =
       name.expandedName(base, separator = TRAIT_SETTER_SEPARATOR)
 
-    def getterName: TermName = name match {
-      case name: LocalName => name.toGlobalName
-      case name => name
-    }
-
-    def getterToSetter: TermName = name ++ SETTER_SUFFIX
+    def setterName: TermName = name ++ SETTER_SUFFIX
 
     def setterToGetter: TermName = {
       val p = name.indexOfSlice(TRAIT_SETTER_SEPARATOR)
diff --git a/src/dotty/tools/dotc/core/Names.scala b/src/dotty/tools/dotc/core/Names.scala
index 8cc07d5b5..77be4843c 100644
--- a/src/dotty/tools/dotc/core/Names.scala
+++ b/src/dotty/tools/dotc/core/Names.scala
@@ -53,9 +53,6 @@ object Names {
     /** Is this name a term name? */
     def isTermName: Boolean
 
-    /** Is this name a local name? */
-    def isLocalName: Boolean = this.isInstanceOf[LocalName]
-
     /** This name converted to a type name */
     def toTypeName: TypeName
 
@@ -68,9 +65,6 @@ object Names {
     /** This name downcasted to a term name */
     def asTermName: TermName
 
-    /** This name converted to a local field name */
-    def toLocalName: LocalName
-
     /** Create a new name of same kind as this one, in the given
      *  basis, with `len` characters taken from `cs` starting at `offset`.
      */
@@ -173,8 +167,6 @@ object Names {
     def asTypeName = throw new ClassCastException(this + " is not a type name")
     def asTermName = this
 
-    def toLocalName: LocalName = toTypeName.toLocalName
-
     override def hashCode: Int = start
 
     override protected[this] def newBuilder: Builder[Char, Name] = termNameBuilder
@@ -182,7 +174,7 @@ object Names {
     def fromChars(cs: Array[Char], offset: Int, len: Int): TermName = termName(cs, offset, len)
   }
 
-  class TypeName(val start: Int, val length: Int, initialTermName: TermName) extends Name {
+  class TypeName(val start: Int, val length: Int, val toTermName: TermName) extends Name {
     type ThisName = TypeName
     def isTypeName = true
     def isTermName = false
@@ -190,26 +182,6 @@ object Names {
     def asTypeName = this
     def asTermName = throw new ClassCastException(this + " is not a term name")
 
-    private[this] var _termName = initialTermName
-
-    def toTermName: TermName = _termName match {
-      case tn: LocalName =>
-        synchronized { tn.toGlobalName }
-      case tn =>
-        tn
-    }
-
-    def toLocalName: LocalName = _termName match {
-      case tn: LocalName =>
-        tn
-      case _ =>
-        synchronized {
-          val lname = new LocalName(start, length, _termName)
-          _termName = lname
-          lname
-        }
-    }
-
     override def hashCode: Int = -start
 
     override protected[this] def newBuilder: Builder[Char, Name] =
@@ -218,41 +190,6 @@ object Names {
     def fromChars(cs: Array[Char], offset: Int, len: Int): TypeName = typeName(cs, offset, len)
   }
 
-  /* A local name representing a field that has otherwise the same name as
-   * a normal term name. Used to avoid name clashes between fields and methods.
-   * Local names are linked to their corresponding term anmes and type names.
-   *
-   * The encoding is as follows.
-   *
-   * If there are only a term name and type name:
-   *
-   *              TermName
-   *               |    ^
-   *     _typeName |    | _termName
-   *               v    |
-   *              TypeName
-   *
-   *  If there is also a local name:
-   *
-   *              TermName
-   *               |    ^
-   *               |    +--------------+ _termNme
-   *               |                   |
-   *     _typeName |                LocalName
-   *               |                   ^
-   *               |    +--------------+ _termName
-   *               v    |
-   *              TypeName
-   */
-  class LocalName(start: Int, length: Int, _next: TermName) extends TermName(start, length, _next) {
-    override def hashCode: Int = start + 1
-    def toGlobalName: TermName = next
-    override protected[this] def newBuilder: Builder[Char, Name] =
-      termNameBuilder.mapResult(_.toLocalName)
-    override def fromChars(cs: Array[Char], offset: Int, len: Int): TermName =
-      termName(cs, offset, len).toLocalName
-  }
-
   // Nametable
 
   private final val InitialHashSize = 0x8000
diff --git a/src/dotty/tools/dotc/printing/PlainPrinter.scala b/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 04afa5709..ee3526d1b 100644
--- a/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -64,9 +64,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def nameString(name: Name): String = name.toString + {
     if (ctx.settings.debugNames.value)
-      if (name.isLocalName) "/L"
-      else if (name.isTypeName) "/T"
-      else "/V"
+      if (name.isTypeName) "/T" else "/V"
     else ""
   }
 
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 6922111f4..43065285c 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -413,7 +413,7 @@ class Typer extends Namer with Applications with Implicits {
           cpy.Assign(tree, lhs1, typed(tree.rhs, ref.info)).withType(defn.UnitType)
         case ref: TermRef if ref.info.isParameterless =>
           val pre = ref.prefix
-          val setterName = ref.name.getterToSetter
+          val setterName = ref.name.setterName
           val setter = pre.member(setterName)
           lhs1 match {
             case lhs1: RefTree if setter.exists =>
@@ -595,10 +595,10 @@ class Typer extends Namer with Applications with Implicits {
       case untpd.EmptyTree =>
         assert(isFullyDefined(pt))
         (EmptyTree, pt)
-      case original: DefDef =>
+      case original: ValDef =>
         val meth = symbolOfTree(original)
         assert(meth.exists, meth)
-        (EmptyTree, meth.info.resultType)
+        (EmptyTree, meth.info)
       case original =>
         val original1 = typed(original)
         (original1, original1.tpe)