TailRec phase and tests for it.

project/Build.scala

@@ -6,6 +6,12 @@ object DottyBuild extends Build {
 
   val TRAVIS_BUILD = "dotty.travis.build"
 
+  val agentOptions = List(
+    // "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005",
+    // "-agentpath:/home/dark/opt/yjp-2013-build-13072/bin/linux-x86-64/libyjpagent.so"
+  )
+
+
   val defaults = Defaults.defaultSettings ++ Seq(
     // set sources to src/, tests to test/ and resources to resources/
     scalaSource in Compile := baseDirectory.value / "src",
@@ -51,12 +57,12 @@ object DottyBuild extends Build {
        // System.err.println("BOOTPATH: " + fullpath)
 
        val travis_build = // propagate if this is a travis build
-         if (sys.props.isDefinedAt(TRAVIS_BUILD)) 
+         if (sys.props.isDefinedAt(TRAVIS_BUILD))
            List(s"-D$TRAVIS_BUILD=${sys.props(TRAVIS_BUILD)}")
-         else 
+         else
            List()
 
-       travis_build ::: fullpath
+      agentOptions ::: travis_build ::: fullpath
     }
   )
 

src/dotty/tools/dotc/Compiler.scala

@@ -20,8 +20,9 @@ class Compiler {
   def phases: List[List[Phase]] =
     List(
       List(new FrontEnd),
-      List(new LazyValsCreateCompanionObjects, new PatternMatcher),    //force separataion between lazyVals and LVCreateCO
-      List(new LazyValTranformContext().transformer, new Splitter, new TypeTestsCasts, new InterceptedMethods),
+      List(new LazyValsCreateCompanionObjects, new TailRec),    //force separataion between lazyVals and LVCreateCO
+      List(new PatternMatcher, new LazyValTranformContext().transformer,
+        new Splitter, new TypeTestsCasts, new InterceptedMethods),
       List(new Erasure),
       List(new UncurryTreeTransform)
     )

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

@@ -103,11 +103,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  where the closure's type is the target type of the expression (FunctionN, unless
    *  otherwise specified).
    */
-  def Closure(meth: TermSymbol, rhsFn: List[List[Tree]] => Tree, targetType: Type = NoType)(implicit ctx: Context): Block = {
+  def Closure(meth: TermSymbol, rhsFn: List[List[Tree]] => Tree, targs: List[Tree] = Nil, targetType: Type = NoType)(implicit ctx: Context): Block = {
     val targetTpt = if (targetType.exists) TypeTree(targetType) else EmptyTree
+    val call =
+      if (targs.isEmpty) Ident(TermRef(NoPrefix, meth))
+      else TypeApply(Ident(TermRef(NoPrefix, meth)), targs)
     Block(
       DefDef(meth, rhsFn) :: Nil,
-      Closure(Nil, Ident(TermRef(NoPrefix, meth)), targetTpt))
+      Closure(Nil, call, targetTpt))
   }
 
   def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef =

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

@@ -172,8 +172,9 @@ class Definitions {
 
   lazy val UnitClass = valueClassSymbol("scala.Unit", BoxedUnitClass, java.lang.Void.TYPE, UnitEnc)
   lazy val BooleanClass = valueClassSymbol("scala.Boolean", BoxedBooleanClass, java.lang.Boolean.TYPE, BooleanEnc)
-    lazy val Boolean_! = BooleanClass.requiredMethod(nme.UNARY_!)
+    lazy val Boolean_!   = BooleanClass.requiredMethod(nme.UNARY_!)
     lazy val Boolean_and = BooleanClass.requiredMethod(nme.ZAND)
+    lazy val Boolean_or  = BooleanClass.requiredMethod(nme.ZOR)
 
   lazy val ByteClass = valueClassSymbol("scala.Byte", BoxedByteClass, java.lang.Byte.TYPE, ByteEnc)
   lazy val ShortClass = valueClassSymbol("scala.Short", BoxedShortClass, java.lang.Short.TYPE, ShortEnc)
@@ -236,6 +237,7 @@ class Definitions {
   lazy val AnnotationClass              = ctx.requiredClass("scala.annotation.Annotation")
   lazy val ClassfileAnnotationClass     = ctx.requiredClass("scala.annotation.ClassfileAnnotation")
   lazy val StaticAnnotationClass        = ctx.requiredClass("scala.annotation.StaticAnnotation")
+  lazy val TailrecAnnotationClass       = ctx.requiredClass("scala.annotation.tailrec")
 
   // Annotation classes
   lazy val AliasAnnot = ctx.requiredClass("dotty.annotation.internal.Alias")

src/dotty/tools/dotc/core/Flags.scala

@@ -470,6 +470,15 @@ object Flags {
   /** Labeled `private` or `protected[local]` */
   final val PrivateOrLocal = Private | Local
 
+  /** Either a module or a final class */
+  final val ModuleOrFinal = ModuleClass | Final
+
+  /** Either mutable or lazy */
+  final val MutableOrLazy = Mutable | Lazy
+
+  /** Labeled `private` or `final` */
+  final val PrivateOrFinal = Private | Final
+
   /** A type parameter with synthesized name */
   final val ExpandedTypeParam = allOf(ExpandedName, TypeParam)
 

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -586,6 +586,12 @@ object SymDenotations {
     final def enclosingClass(implicit ctx: Context): Symbol =
       if (isClass || !exists) symbol else owner.enclosingClass
 
+    final def isEffectivelyFinal(implicit ctx: Context): Boolean = {
+      (this.flags is Flags.PrivateOrFinal) || (!this.owner.isClass) ||
+        ((this.owner.flags is (Flags.ModuleOrFinal)) && (!this.flags.is(Flags.MutableOrLazy))) ||
+        (this.owner.isAnonymousClass)
+    }
+
     /** The class containing this denotation which has the given effective name.
      */
     final def enclosingClassNamed(name: Name)(implicit ctx: Context): Symbol = {

src/dotty/tools/dotc/core/Symbols.scala

@@ -245,7 +245,7 @@ trait Symbols { this: Context =>
     for (name <- names) {
       val tparam = newNakedSymbol[TypeName](NoCoord)
       tparamBuf += tparam
-      trefBuf += TypeRef(owner.thisType, name).withSym(tparam, Signature.NotAMethod)
+      trefBuf += TypeRef.withSymAndName(owner.thisType, tparam, name)
     }
     val tparams = tparamBuf.toList
     val bounds = boundsFn(trefBuf.toList)
@@ -319,7 +319,7 @@ object Symbols {
     type ThisName <: Name
 
     private[this] var _id: Int = nextId
-    //assert(_id != 12325)
+    //assert(_id != 5859)
 
     /** The unique id of this symbol */
     def id = _id