wip

README.md

@@ -238,68 +238,62 @@ This can be useful as a final sanity check, even though you usually want to run
 a subset of the tests specific to the `scala-version` and `test-case` you are 
 interested in.
 
+## Upstream
+
 ```scala
-trait Upstream{
+trait Upstream{ // v1
    def foo(s: String, n: Int = 1)
 }
 ```
 ```scala
-trait Upstream{
+trait Upstream{ // v2
    // source
    def foo(s: String, n: Int = 1, @unroll b: Boolean = true)
 
    // generated
    def foo(s: String, n: Int = 1, b: Boolean = true) = foo(s, n)
-   def fooUp(s: String, n: Int, b: Boolean) = foo(s, n, b)
-   def fooDown(s: String, n: Int, b: Boolean) = foo(s, n, b)
-   def foo(s: String, n: Int) = foo(s, n, true)
+   def foo(s: String, n: Int)
 }
 ```
 
 ```scala
-trait Upstream{
+trait Upstream{ // v3
    // source
    def foo(s: String, n: Int = 1, @unroll b: Boolean = true, @unroll l: Long = 0)
 
    // generated
    def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0) = fooDown(s, n, b)
-   def fooUp(s: String, n: Int, b: Boolean) = foo(s, n, b, 0) 
-   def fooDown(s: String, n: Int, b: Boolean) = foo(s, n)
-   def foo(s: String, n: Int) = fooUp(s, n, true)
+   def foo(s: String, n: Int, b: Boolean) = foo(s, n)
+   def foo(s: String, n: Int)
 }
 ```
+
+## Downstream
+
 ```scala
-trait Downstream extends Upstream{
+trait Downstream extends Upstream{ // v1 
    final def foo(s: String, n: Int = 1) = println(s + n)
 }
 ```
 ```scala
-trait Downstream extends Upstream{
+trait Downstream extends Upstream{ // v2
    // source
-   def foo(s: String, n: Int = 1, b: Boolean = true) = println(s + n + b)
+   def foo(s: String, n: Int = 1, @unroll b: Boolean = true) = println(s + n + b)
 
    // generated
-   final def foo(s: String, n: Int = 1, b: Boolean = true) = foo(s, n)
-   final def fooUp(s: String, n: Int, b: Boolean) = foo(s, n, b)
-   final def fooDown(s: String, n: Int, b: Boolean) = foo(s, n, b)
-
-   final def foo(s: String, n: Int) = foo(s, n, true)
+   def foo(s: String, n: Int = 1, b: Boolean = true) = println(s + n + b)
+   def foo(s: String, n: Int) = foo(s, n, true)
 }
 ```
 
 ```scala
-trait Downstream extends Upstream{
+trait Downstream extends Upstream{ // v3
    // source
-   def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0)
+   def foo(s: String, n: Int = 1, @unroll b: Boolean = true, @unroll l: Long = 0) = println(s + n + b + l)
 
    // generated
-   final def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0) = fooDown(s, n, b)
-   final def fooUp(s: String, n: Int, b: Boolean, l: Long) = fooDown(s, n, b)
-   final def fooDown(s: String, n: Int, b: Boolean, l: Long) = fooDown(s, n, b)
-
-   final def foo(s: String, n: Int, b: Boolean) = foo(s, n, b, 0)
-   final def fooUp(s: String, n: Int, b: Boolean) = foo(s, n, b, 0)
-   final def fooDown(s: String, n: Int, b: Boolean) = foo(s, n)
-   final def foo(s: String, n: Int) = fooUp(s, n, true)
+   def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0) = println(s + n + b + l)
+   def foo(s: String, n: Int, b: Boolean) = foo(s, n, b, 0)
+   def foo(s: String, n: Int) = foo(s, n, true, 0)
 }
 ```

build.sc

@@ -69,7 +69,7 @@ trait UnrollModule extends Cross.Module[String]{
     "caseclass",
     "secondParameterList",
 //    "abstractTraitMethod",
-//    "abstractClassMethod"
+    "abstractClassMethod"
   )
 
 
@@ -79,9 +79,11 @@ trait UnrollModule extends Cross.Module[String]{
     override def millSourcePath = super.millSourcePath / crossValue
 
     trait CrossPlatformModule extends Module{
+      def downstreamOpt: Option[CrossPlatformModule] = None
       def mimaPrevious = Seq.empty[CrossPlatformModule]
+      def moduleDeps: Seq[CrossPlatformModule] = Nil
       trait Unrolled extends InnerScalaModule with LocalMimaModule with PlatformScalaModule{
-        def moduleDeps = Seq(annotation)
+        def moduleDeps: Seq[JavaModule] = Seq(annotation)
         def run(args: Task[Args] = T.task(Args())) = T.command{/*donothing*/}
         def mimaPreviousArtifacts = T.traverse(mimaPrevious)(_.jvm.jar)()
         def scalacPluginClasspath = T{ Agg(plugin.jar()) }
@@ -99,7 +101,7 @@ trait UnrollModule extends Cross.Module[String]{
             //"-Ydebug-type-error",
             //"-Ydebug-trace"
             //"-Xprint:typer",
-            //"-Xprint:unroll",
+            "-Xprint:unroll",
             //"-Xprint:patmat",
             //"-Xprint:superaccessors"
           )
@@ -109,69 +111,139 @@ trait UnrollModule extends Cross.Module[String]{
           def moduleDeps = Seq(Unrolled.this)
           def mainClass = Some("unroll.UnrollTestMain")
           def testFramework = T{ "" } // stub
-          def scalacOptions = Seq.empty[String]
         }
       }
 
       object jvm extends InnerScalaModule with Unrolled{
+        def moduleDeps = super.moduleDeps ++ CrossPlatformModule.this.moduleDeps.map(_.jvm.asInstanceOf[Unrolled])
         object test extends ScalaTests with UnrolledTestModule{
-
+          def moduleDeps = Seq(jvm) ++ downstreamOpt.map(_.jvm.asInstanceOf[Unrolled])
         }
       }
       object js extends InnerScalaJsModule with Unrolled{
-        object test extends ScalaJSTests with UnrolledTestModule
+        def moduleDeps = super.moduleDeps ++ CrossPlatformModule.this.moduleDeps.map(_.js.asInstanceOf[Unrolled])
+        object test extends ScalaJSTests with UnrolledTestModule{
+          def moduleDeps = Seq(js) ++ downstreamOpt.map(_.js.asInstanceOf[Unrolled])
+        }
       }
       object native extends InnerScalaNativeModule with Unrolled{
-        object test extends ScalaNativeTests with UnrolledTestModule
+        def moduleDeps = super.moduleDeps ++ CrossPlatformModule.this.moduleDeps.map(_.native.asInstanceOf[Unrolled])
+        object test extends ScalaNativeTests with UnrolledTestModule{
+          def moduleDeps = Seq(native) ++ downstreamOpt.map(_.native.asInstanceOf[Unrolled])
+        }
       }
     }
     // Different versions of Unrolled.scala
-    object v3 extends CrossPlatformModule {
-      def mimaPrevious = Seq(v1, v2)
+
+    object v1 extends CrossPlatformModule{
+      def mimaPrevious = Seq()
+      def downstreamOpt = Some(downstream)
+      object downstream extends CrossPlatformModule{
+        def moduleDeps = Seq(v1)
+      }
     }
+
     object v2 extends CrossPlatformModule {
       def mimaPrevious = Seq(v1)
+      def downstreamOpt = Some(downstream)
+      object downstream extends CrossPlatformModule{
+        def moduleDeps = Seq(v2)
+      }
     }
-    object v1 extends CrossPlatformModule{
-      def mimaPrevious = Seq()
+
+    object v3 extends CrossPlatformModule {
+      def mimaPrevious = Seq(v1, v2)
+      def downstreamOpt = Some(downstream)
+      object downstream extends CrossPlatformModule{
+        def moduleDeps = Seq(v3)
+      }
     }
 
     // proxy modules used to make sure old versions of UnrolledTestMain.scala can
     // successfully call newer versions of the Unrolled.scala
     trait ComparativeModule extends Module{
       def upstream: CrossPlatformModule
-      def upstreamTest: CrossPlatformModule
+      def downstream: Option[CrossPlatformModule] = None
+      def test: CrossPlatformModule
 
       trait ComparativePlatformScalaModule extends PlatformScalaModule{
         def sources = super.sources() ++ testutils.sources()
         def mainClass = Some("unroll.UnrollTestMain")
       }
 
       object jvm extends InnerScalaModule with ComparativePlatformScalaModule{
-        def runClasspath = super.runClasspath() ++ Seq(upstreamTest.jvm.test.compile().classes, upstream.jvm.compile().classes)
+        def runClasspath = 
+          super.runClasspath() ++ 
+            Seq(test.jvm.test.compile().classes, upstream.jvm.compile().classes) ++
+            T.traverse(downstream.flatMap(_.downstreamOpt).toSeq)(_.jvm.compile)().map(_.classes)
       }
 
       object js extends InnerScalaJsModule with ComparativePlatformScalaModule{
-        def runClasspath = super.runClasspath() ++ Seq(upstreamTest.js.test.compile().classes, upstream.js.compile().classes)
+        def runClasspath = 
+          super.runClasspath() ++ 
+            Seq(test.js.test.compile().classes, upstream.js.compile().classes) ++
+            T.traverse(downstream.flatMap(_.downstreamOpt).toSeq)(_.jvm.compile)().map(_.classes)
       }
 
       object native extends InnerScalaNativeModule with ComparativePlatformScalaModule{
-        def runClasspath = super.runClasspath() ++ Seq(upstreamTest.native.test.compile().classes, upstream.native.compile().classes)
+        def runClasspath = 
+          super.runClasspath() ++ 
+            Seq(test.native.test.compile().classes, upstream.native.compile().classes) ++
+            T.traverse(downstream.flatMap(_.downstreamOpt).toSeq)(_.jvm.compile)().map(_.classes)
       }
     }
 
-    object v2v3 extends ComparativeModule{
+    object v3v2 extends ComparativeModule{
       def upstream = v3
-      def upstreamTest = v2
-
+      def downstream = Some(v3)
+      def test = v2
     }
-    object v1v3 extends ComparativeModule{
+    object v3v1 extends ComparativeModule{
       def upstream = v3
-      def upstreamTest = v1
+      def downstream = Some(v3)
+      def test = v1
+    }
+    object v2v1 extends ComparativeModule{
+      def upstream = v2
+      def downstream = Some(v2)
+      def test = v1
     }
-    object v1v2 extends ComparativeModule{
+
+
+    object v2v1v1 extends ComparativeModule{
       def upstream = v2
-      def upstreamTest = v1
+      def downstream = Some(v1)
+      def test = v1
+    }
+    object v2v2v1 extends ComparativeModule{
+      def upstream = v2
+      def downstream = Some(v2)
+      def test = v1
+    }
+    object v3v1v1 extends ComparativeModule{
+      def upstream = v3
+      def downstream = Some(v1)
+      def test = v1
+    }
+    object v3v2v1 extends ComparativeModule{
+      def upstream = v3
+      def downstream = Some(v2)
+      def test = v1
+    }
+    object v3v3v1 extends ComparativeModule{
+      def upstream = v3
+      def downstream = Some(v3)
+      def test = v1
+    }
+    object v3v2v2 extends ComparativeModule{
+      def upstream = v3
+      def downstream = Some(v2)
+      def test = v2
+    }
+    object v3v3v2 extends ComparativeModule{
+      def upstream = v3
+      def downstream = Some(v3)
+      def test = v2
     }
 
 

unroll/tests/abstractClassMethod/v1/downstream/src/Unrolled2.scala

@@ -0,0 +1,9 @@
+package unroll
+
+object UnrolledObj extends Unrolled {
+  def foo(s: String, n: Int = 1) = s + n
+}
+
+class UnrolledCls extends Unrolled {
+  def foo(s: String, n: Int = 1) = s + n
+}

unroll/tests/abstractClassMethod/v1/src/Unrolled.scala

@@ -4,10 +4,3 @@ abstract class Unrolled{
   def foo(s: String, n: Int = 1): String
 }
 
-object Unrolled extends Unrolled{
-  def foo(s: String, n: Int = 1) = s + n
-}
-
-class UnrolledCls extends Unrolled{
-  def foo(s: String, n: Int = 1) = s + n
-}

unroll/tests/abstractClassMethod/v1/test/src/UnrollTestMain.scala

@@ -2,13 +2,15 @@ package unroll
 
 import unroll.TestUtils.logAssertStartsWith
 
+
+
 object UnrollTestMain{
   def main(args: Array[String]): Unit = {
     val unrolled = new UnrolledCls
     logAssertStartsWith(unrolled.foo("cow"), "cow1")
     logAssertStartsWith(unrolled.foo("cow", 2), "cow2")
 
-    logAssertStartsWith(Unrolled.foo("cow"), "cow1")
-    logAssertStartsWith(Unrolled.foo("cow", 2), "cow2")
+    logAssertStartsWith(UnrolledObj.foo("cow"), "cow1")
+    logAssertStartsWith(UnrolledObj.foo("cow", 2), "cow2")
   }
 }

unroll/tests/abstractClassMethod/v2/downstream/src/Unrolled2.scala

@@ -0,0 +1,10 @@
+package unroll
+
+
+object UnrolledObj extends Unrolled {
+  def foo(s: String, n: Int = 1, b: Boolean = true) = s + n + b
+}
+
+class UnrolledCls extends Unrolled {
+  def foo(s: String, n: Int = 1, b: Boolean = true) = s + n + b
+}

unroll/tests/abstractClassMethod/v2/src/Unrolled.scala

@@ -6,10 +6,3 @@ abstract class Unrolled{
   def foo(s: String, n: Int = 1, @unroll b: Boolean = true): String
 }
 
-object Unrolled extends Unrolled{
-  def foo(s: String, n: Int = 1, b: Boolean = true) = s + n + b
-}
-
-class UnrolledCls extends Unrolled{
-  def foo(s: String, n: Int = 1, b: Boolean = true) = s + n + b
-}

unroll/tests/abstractClassMethod/v2/test/src/UnrollTestMain.scala

@@ -2,16 +2,17 @@ package unroll
 
 import unroll.TestUtils.logAssertStartsWith
 
+
 object UnrollTestMain{
   def main(args: Array[String]): Unit = {
     val unrolled = new UnrolledCls
     logAssertStartsWith(unrolled.foo("cow"), "cow1true")
     logAssertStartsWith(unrolled.foo("cow", 2), "cow2true")
     logAssertStartsWith(unrolled.foo("cow", 2, false), "cow2false")
 
-    logAssertStartsWith(Unrolled.foo("cow"), "cow1true")
-    logAssertStartsWith(Unrolled.foo("cow", 2), "cow2true")
-    logAssertStartsWith(Unrolled.foo("cow", 2, false), "cow2false")
+    logAssertStartsWith(UnrolledObj.foo("cow"), "cow1true")
+    logAssertStartsWith(UnrolledObj.foo("cow", 2), "cow2true")
+    logAssertStartsWith(UnrolledObj.foo("cow", 2, false), "cow2false")
   }
 }
 

unroll/tests/abstractClassMethod/v3/downstream/src/Unrolled2.scala

@@ -0,0 +1,9 @@
+package unroll
+
+object UnrolledObj extends Unrolled {
+  def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0) = s + n + b + l
+}
+
+class UnrolledCls extends Unrolled {
+  def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0) = s + n + b + l
+}

unroll/tests/abstractClassMethod/v3/src/Unrolled.scala

@@ -3,12 +3,7 @@ package unroll
 import scala.annotation.unroll
 
 abstract class Unrolled{
-  def foo(s: String, n: Int = 1, @unroll b: Boolean = true, l: Long = 0): String
+  def foo(s: String, n: Int = 1, @unroll b: Boolean = true, @unroll l: Long = 0): String
 }
 
-object Unrolled extends Unrolled{
-  def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0) = s + n + b + l
-}
-class UnrolledCls extends Unrolled{
-  def foo(s: String, n: Int = 1, b: Boolean = true, l: Long = 0) = s + n + b + l
-}
+