constructors & getters-setters

src/dotty/tools/dotc/Compiler.scala

@@ -24,17 +24,6 @@ class Compiler {
    *  all refs to it would become outdated - they could not be dereferenced in the
    *  new phase.
    *
-   *  As an example, addGetters would change a field
-   *
-   *     val x: T
-   *
-   *  to a method
-   *
-   *     def x: T
-   *
-   *  but this would affect the signature of `x` (goes from NotAMethod to a method
-   *  signature). So we can't do this before erasure.
-   *
    *  After erasure, signature changing denot-transformers are OK because erasure
    *  will make sure that only term refs with fixed SymDenotations survive beyond it. This
    *  is possible because:
@@ -57,13 +46,15 @@ class Compiler {
            new TailRec),
       List(new PatternMatcher,
            new ExplicitOuter,
-           new LazyValsTransform,
+           // new LazyValTranformContext().transformer, // disabled, awaiting fixes
            new Splitter),
       List(new ElimByName,
            new InterceptedMethods,
-           new Literalize),
+           new Literalize,
+           new GettersSetters),
       List(new Erasure),
-      List(new CapturedVars)
+      List(new CapturedVars, new Constructors)/*,
+      List(new LambdaLift)*/
     )
 
   var runId = 1

src/dotty/tools/dotc/ElimLocals.scala

@@ -19,4 +19,4 @@ class ElimLocals extends MiniPhaseTransform with SymTransformer { thisTransforme
   private def dropLocal(ref: SymDenotation)(implicit ctx: Context) =
     if (ref.flags is Local) ref.copySymDenotation(initFlags = ref.flags &~ Local)
     else ref
-}
+}

src/dotty/tools/dotc/Flatten.scala

@@ -12,4 +12,4 @@ class Flatten extends MiniPhaseTransform with SymTransformer { thisTransformer =
   override def phaseName = "flatten"
 
   def transformSym(ref: SymDenotation)(implicit ctx: Context) = ???
-}
+}

src/dotty/tools/dotc/TypeErasure.scala

@@ -31,7 +31,7 @@ object TypeErasure {
    */
   def isErasedType(tp: Type)(implicit ctx: Context): Boolean = tp match {
     case tp: TypeRef =>
-      tp.symbol.isClass
+      tp.symbol.isClass && tp.symbol != defn.AnyClass
     case _: TermRef =>
       true
     case JavaArrayType(elem) =>
@@ -87,15 +87,36 @@ object TypeErasure {
   private val javaSigFn = erasureFn(isJava = true, isSemi = false, isConstructor = false, wildcardOK = true)
   private val semiErasureFn = erasureFn(isJava = false, isSemi = true, isConstructor = false, wildcardOK = false)
 
-  def erasure(tp: Type)(implicit ctx: Context): Type = scalaErasureFn(tp)
-  def semiErasure(tp: Type)(implicit ctx: Context): Type = semiErasureFn(tp)
+  /** The current context with a phase no later than erasure */
+  private def erasureCtx(implicit ctx: Context) =
+    if (ctx.erasedTypes) ctx.withPhase(ctx.erasurePhase) else ctx
+
+  def erasure(tp: Type)(implicit ctx: Context): Type = scalaErasureFn(tp)(erasureCtx)
+  def semiErasure(tp: Type)(implicit ctx: Context): Type = semiErasureFn(tp)(erasureCtx)
   def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): TypeName = {
     val normTp =
       if (tp.isRepeatedParam) tp.translateParameterized(defn.RepeatedParamClass, defn.SeqClass)
       else tp
-    (if (isJava) javaSigFn else scalaSigFn).sigName(normTp)
+    (if (isJava) javaSigFn else scalaSigFn).sigName(normTp)(erasureCtx)
+  }
+
+  /** The erasure of a top-level reference. Differs from normal erasure in that
+   *  TermRefs are kept instead of being widened away.
+   */
+  def erasedRef(tp: Type)(implicit ctx: Context): Type = tp match {
+    case tp: TermRef =>
+      assert(tp.symbol.exists, tp)
+      TermRef(erasedRef(tp.prefix), tp.symbol.asTerm)
+    case tp =>
+      erasure(tp)
   }
 
+  /** The erasure of a function result type. Differs from normal erasure in that
+   *  Unit is kept instead of being mapped to BoxedUnit.
+   */
+  def eraseResult(tp: Type)(implicit ctx: Context): Type =
+    scalaErasureFn.eraseResult(tp)(erasureCtx)
+
   /**  The symbol's erased info. This is the type's erasure, except for the following symbols:
    *
    *   - For $asInstanceOf           : [T]T
@@ -113,8 +134,8 @@ object TypeErasure {
 
     if ((sym eq defn.Any_asInstanceOf) || (sym eq defn.Any_isInstanceOf)) eraseParamBounds(sym.info.asInstanceOf[PolyType])
     else if (sym.isAbstractType) TypeAlias(WildcardType)
-    else if (sym.isConstructor) outer.addParam(sym.owner.asClass, erase(tp))
-    else erase(tp)
+    else if (sym.isConstructor) outer.addParam(sym.owner.asClass, erase(tp)(erasureCtx))
+    else erase(tp)(erasureCtx)
   }
 
   def isUnboundedGeneric(tp: Type)(implicit ctx: Context) = !(
@@ -147,7 +168,7 @@ object TypeErasure {
           def loop(bcs: List[ClassSymbol], bestSoFar: ClassSymbol): ClassSymbol = bcs match {
             case bc :: bcs1 =>
               if (cls2.derivesFrom(bc))
-                if (!bc.is(Trait)) bc
+                if (!bc.is(Trait) && bc != defn.AnyClass) bc
                 else loop(bcs1, if (bestSoFar.derivesFrom(bc)) bestSoFar else bc)
               else
                 loop(bcs1, bestSoFar)
@@ -225,7 +246,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
    *   - For NoType or NoPrefix, the type itself.
    *   - For any other type, exception.
    */
-  def apply(tp: Type)(implicit ctx: Context): Type = tp match {
+  private def apply(tp: Type)(implicit ctx: Context): Type = tp match {
     case tp: TypeRef =>
       val sym = tp.symbol
       if (!sym.isClass) this(tp.info)
@@ -236,8 +257,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
       if (parent isRef defn.ArrayClass) eraseArray(tp)
       else this(parent)
     case tp: TermRef =>
-      assert(tp.symbol.exists, tp)
-      TermRef(NoPrefix, tp.symbol.asTerm)
+      this(tp.widen)
     case ThisType(_) | SuperType(_, _) =>
       tp
     case ExprType(rt) =>
@@ -269,7 +289,8 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
         val parents: List[TypeRef] =
           if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil
           else removeLaterObjects(classParents.mapConserve(eraseTypeRef))
-        tp.derivedClassInfo(NoPrefix, parents, decls, this(tp.selfType))
+        val erasedDecls = decls.filteredScope(d => !d.isType || d.isClass)
+        tp.derivedClassInfo(NoPrefix, parents, erasedDecls, erasedRef(tp.selfType))
           // can't replace selftype by NoType because this would lose the sourceModule link
       }
     case NoType | NoPrefix | ErrorType | JavaArrayType(_) =>
@@ -278,7 +299,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
       tp
   }
 
-  def eraseArray(tp: RefinedType)(implicit ctx: Context) = {
+  private def eraseArray(tp: RefinedType)(implicit ctx: Context) = {
     val defn.ArrayType(elemtp) = tp
     if (elemtp derivesFrom defn.NullClass) JavaArrayType(defn.ObjectType)
     else if (isUnboundedGeneric(elemtp))
@@ -327,7 +348,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
   /** The name of the type as it is used in `Signature`s.
    *  Need to ensure correspondence with erasure!
    */
-  def sigName(tp: Type)(implicit ctx: Context): TypeName = tp match {
+  private def sigName(tp: Type)(implicit ctx: Context): TypeName = tp match {
     case tp: TypeRef =>
       val sym = tp.symbol
       if (!sym.isClass) sigName(tp.info)
@@ -337,8 +358,8 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
       sigName(this(tp))
     case JavaArrayType(elem) =>
       sigName(elem) ++ "[]"
-    case tp: TypeBounds =>
-      sigName(tp.hi)
+    case tp: TermRef =>
+      sigName(tp.widen)
     case ExprType(rt) =>
       sigName(defn.FunctionType(Nil, rt))
     case tp: TypeProxy =>

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

@@ -90,7 +90,7 @@ object desugar {
   def valDef(vdef: ValDef)(implicit ctx: Context): Tree = {
     val ValDef(mods, name, tpt, rhs) = vdef
     def setterNeeded =
-      (mods is Mutable) && ctx.owner.isClass && (!(mods is Private) || (ctx.owner is Trait))
+      (mods is Mutable) && ctx.owner.isClass && (!(mods is PrivateLocal) || (ctx.owner is Trait))
     if (setterNeeded) {
       // todo: copy of vdef as getter needed?
       // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos ?

src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -6,6 +6,7 @@ import core._
 import Types._, Contexts._, Constants._, Names._, Flags._
 import SymDenotations._, Symbols._, Annotations._, Trees._, Symbols._
 import Denotations._, Decorators._
+import dotty.tools.dotc.transform.SymUtils._
 
 /** A map that applies three functions and a substitution together to a tree and
  *  makes sure they are coordinated so that the result is well-typed. The functions are
@@ -42,13 +43,7 @@ final class TreeTypeMap(
   import tpd._
 
   /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */
-  def mapOwner(sym: Symbol) = {
-    def loop(from: List[Symbol], to: List[Symbol]): Symbol =
-      if (from.isEmpty) sym
-      else if (sym eq from.head) to.head
-      else loop(from.tail, to.tail)
-    loop(oldOwners, newOwners)
-  }
+  def mapOwner(sym: Symbol) = sym.subst(oldOwners, newOwners)
 
   /** Replace occurrences of `This(oldOwner)` in some prefix of a type
    *  by the corresponding `This(newOwner)`.

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

@@ -408,7 +408,6 @@ object Trees {
   abstract class NameTree[-T >: Untyped] extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] <: NameTree[T]
     def name: Name
-    def withName(name1: Name)(implicit ctx: Context): untpd.NameTree
   }
 
   /** Tree refers by name to a denotation */
@@ -449,7 +448,6 @@ object Trees {
   case class Ident[-T >: Untyped] private[ast] (name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = Ident[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.Ident = untpd.cpy.Ident(this)(name)
     def qualifier: Tree[T] = genericEmptyTree
   }
 
@@ -460,7 +458,6 @@ object Trees {
   case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = Select[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.Select = untpd.cpy.Select(this)(qualifier, name)
   }
 
   class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)
@@ -656,7 +653,6 @@ object Trees {
   case class SelectFromTypeTree[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = SelectFromTypeTree[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.SelectFromTypeTree = untpd.cpy.SelectFromTypeTree(this)(qualifier, name)
   }
 
   /** left & right */
@@ -702,7 +698,6 @@ object Trees {
     extends NameTree[T] with DefTree[T] with PatternTree[T] {
     type ThisTree[-T >: Untyped] = Bind[T]
     override def envelope: Position = pos union initialPos
-    def withName(name: Name)(implicit ctx: Context): untpd.Bind = untpd.cpy.Bind(this)(name, body)
   }
 
   /** tree_1 | ... | tree_n */
@@ -734,15 +729,13 @@ object Trees {
   case class ValDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TermName, tpt: Tree[T], rhs: Tree[T])
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = ValDef[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.ValDef = untpd.cpy.ValDef(this)(name = name.toTermName)
     assert(isEmpty || tpt != genericEmptyTree)
   }
 
   /** mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs */
   case class DefDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TermName, tparams: List[TypeDef[T]], vparamss: List[List[ValDef[T]]], tpt: Tree[T], rhs: Tree[T])
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = DefDef[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.DefDef = untpd.cpy.DefDef(this)(name = name.toTermName)
     assert(tpt != genericEmptyTree)
   }
 
@@ -754,7 +747,6 @@ object Trees {
   case class TypeDef[-T >: Untyped] private[ast] (mods: Modifiers[T], name: TypeName, rhs: Tree[T])
     extends MemberDef[T] {
     type ThisTree[-T >: Untyped] = TypeDef[T]
-    def withName(name: Name)(implicit ctx: Context): untpd.TypeDef = untpd.cpy.TypeDef(this)(name = name.toTypeName)
 
     /** Is this a definition of a class? */
     def isClassDef = rhs.isInstanceOf[Template[_]]
@@ -820,7 +812,7 @@ object Trees {
   }
 
   class EmptyValDef[T >: Untyped] extends ValDef[T](
-    Modifiers[T](Private), nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T]) with WithoutTypeOrPos[T] {
+    Modifiers[T](PrivateLocal), nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T]) with WithoutTypeOrPos[T] {
     override def isEmpty: Boolean = true
   }
 
@@ -1344,6 +1336,7 @@ object Trees {
     abstract class TreeTraverser extends TreeAccumulator[Unit] {
       def traverse(tree: Tree): Unit
       def apply(x: Unit, tree: Tree) = traverse(tree)
+      protected def traverseChildren(tree: Tree) = foldOver((), tree)
     }
 
     /** Fold `f` over all tree nodes, in depth-first, prefix order */
@@ -1361,6 +1354,19 @@ object Trees {
         else foldOver(x1, tree)
       }
     }
+
+    def rename(tree: NameTree, newName: Name)(implicit ctx: Context): tree.ThisTree[T] = {
+      tree match {
+        case tree: Ident => cpy.Ident(tree)(newName)
+        case tree: Select => cpy.Select(tree)(tree.qualifier, newName)
+        case tree: Bind => cpy.Bind(tree)(newName, tree.body)
+        case tree: ValDef => cpy.ValDef(tree)(name = newName.asTermName)
+        case tree: DefDef => cpy.DefDef(tree)(name = newName.asTermName)
+        case tree: untpd.PolyTypeDef => untpd.cpy.PolyTypeDef(tree)(tree.mods, newName.asTypeName, tree.tparams, tree.rhs)
+        case tree: TypeDef => cpy.TypeDef(tree)(name = newName.asTypeName)
+        case tree: SelectFromTypeTree => cpy.SelectFromTypeTree(tree)(tree.qualifier, newName)
+      }
+    }.asInstanceOf[tree.ThisTree[T]]
   }
 }
   // ----- Helper functions and classes ---------------------------------------