Merge pull request #174 from dotty-staging/reb

Pattern matcher

Author: DarkDimius

bench/src/test/scala/TestsAsBenchmarks.scala

@@ -0,0 +1,61 @@
+package dotty.tools.benchmarks
+
+import java.lang.annotation.Annotation
+import java.lang.reflect.Method
+
+import org.junit.runner.Request
+import org.junit.runner.notification.RunNotifier
+import org.scalameter.PerformanceTest.OnlineRegressionReport
+import org.scalameter.api._
+import org.scalameter.reporting.RegressionReporter.Tester
+
+import scala.collection.mutable.ListBuffer
+
+
+abstract class TestsToBenchmarkConverter
+(targetClass: Class[_],
+ filterAnnot: Class[_ <: java.lang.annotation.Annotation] = classOf[org.junit.Test].asInstanceOf[Class[_ <: java.lang.annotation.Annotation]])
+  extends OnlineRegressionReport {
+
+  // accept all the results, do not fail
+  override def tester: Tester = new Tester.Accepter
+
+  override def executor: Executor = LocalExecutor(warmer, aggregator, measurer)
+  val testNames = getMethodsAnnotatedWith(targetClass, filterAnnot).map(_.getName).sorted
+
+
+  val tests = testNames.map{name =>
+    val runner = Request.method(targetClass, name).getRunner
+    (name, Gen.single("test")(name).map(Request.method(targetClass, _).getRunner))}.toMap
+  //Gen.enumeration("test")(testNames:_*)
+
+  performance of targetClass.getSimpleName config (Context(reports.resultDir -> "./tmp")) in {
+    for (test <- testNames)
+      measure.method(test) in {
+        using(tests(test)) curve test in {
+          r =>
+            val dummy = new RunNotifier()
+            r.run(dummy)
+        }
+      }
+  }
+
+  def getMethodsAnnotatedWith(clazz: Class[_], annotation: Class[_ <: java.lang.annotation.Annotation]): List[Method] = {
+    val methods = ListBuffer[Method]()
+    var klass: Class[_] = clazz
+    while (klass ne classOf[AnyRef]) {
+      val allMethods = klass.getDeclaredMethods
+      import scala.collection.JavaConversions._
+      for (method <- allMethods) {
+        if (annotation == null || method.isAnnotationPresent(annotation)) {
+          val annotInstance: Annotation = method.getAnnotation(annotation)
+          methods.add(method)
+        }
+      }
+      klass = klass.getSuperclass
+    }
+    methods.toList
+  }
+}
+
+object dotcTests extends TestsToBenchmarkConverter(classOf[dotc.tests])

project/Build.scala

@@ -1,13 +1,12 @@
+import sbt.Keys._
 import sbt._
-import Keys._
-import Process._
 
 object DottyBuild extends Build {
 
   val TRAVIS_BUILD = "dotty.travis.build"
 
   val agentOptions = List(
-    // "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005",
+    // "-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"
   )
 
@@ -74,4 +73,51 @@ object DottyBuild extends Build {
   )
 
   lazy val dotty = Project(id = "dotty", base = file("."), settings = defaults)
+
+  lazy val benchmarkSettings = Defaults.defaultSettings ++ Seq(
+
+    // to get Scala 2.11
+    resolvers += Resolver.sonatypeRepo("releases"),
+
+    baseDirectory in (Test,run) := (baseDirectory in dotty).value,
+
+
+    libraryDependencies ++= Seq("com.storm-enroute" %% "scalameter" % "0.6" % Test,
+      "com.novocode" % "junit-interface" % "0.11-RC1"),
+    testFrameworks += new TestFramework("org.scalameter.ScalaMeterFramework"),
+
+    // scalac options
+    scalacOptions in Global ++= Seq("-feature", "-deprecation", "-language:_"),
+
+    javacOptions ++= Seq("-Xlint:unchecked", "-Xlint:deprecation"),
+
+    fork in Test := true,
+    parallelExecution in Test := false,
+
+    // http://grokbase.com/t/gg/simple-build-tool/135ke5y90p/sbt-setting-jvm-boot-paramaters-for-scala
+    javaOptions <++= (dependencyClasspath in Runtime, packageBin in Compile) map { (attList, bin) =>
+      // put the Scala {library, reflect, compiler} in the classpath
+      val path = for {
+        file <- attList.map(_.data)
+        path = file.getAbsolutePath
+        prefix = if(path.endsWith(".jar")) "p" else "a"
+      } yield "-Xbootclasspath/"+ prefix +":" + path
+      // dotty itself needs to be in the bootclasspath
+      val fullpath = ("-Xbootclasspath/a:" + bin) :: path.toList
+      // System.err.println("BOOTPATH: " + fullpath)
+
+      val travis_build = // propagate if this is a travis build
+        if (sys.props.isDefinedAt(TRAVIS_BUILD))
+          List(s"-D$TRAVIS_BUILD=${sys.props(TRAVIS_BUILD)}")
+        else
+          List()
+      val res = agentOptions ::: travis_build ::: fullpath
+      println("Running with javaOptions: " +res)
+      res
+    }
+  )
+
+
+  lazy val benchmarks = Project(id = "dotty-bench", settings = benchmarkSettings,
+    base = file("bench")) dependsOn(dotty % "compile->test")
 }

src/dotty/tools/dotc/Compiler.scala

@@ -6,7 +6,7 @@ import Contexts._
 import Periods._
 import Symbols._
 import Scopes._
-import typer.{FrontEnd, Typer, Mode, ImportInfo}
+import typer.{FrontEnd, Typer, Mode, ImportInfo, RefChecks}
 import reporting.ConsoleReporter
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform._
@@ -16,25 +16,54 @@ import dotty.tools.dotc.core.Denotations.SingleDenotation
 
 class Compiler {
 
+  /** Meta-ordering constraint:
+   *
+   *  DenotTransformers that change the signature of  their denotation's info must go
+   *  after erasure. The reason is that denotations are permanently referred to by
+   *  TermRefs which contain a signature. If the signature of a symbol would change,
+   *  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:
+   *
+   *   - splitter has run, so every ident or select refers to a unique symbol
+   *   - after erasure, asSeenFrom is the identity, so every reference has a
+   *     plain SymDenotation, as opposed to a UniqueRefDenotation.
+   */
   def phases: List[List[Phase]] =
     List(
       List(new FrontEnd),
-      List(new Companions),
+      List(new FirstTransform,
+           new SyntheticMethods),
       List(new SuperAccessors),
-      // pickling and refchecks goes here
-      List(new ElimRepeated, new ElimLocals),
-      List(new ExtensionMethods),
-      List(new TailRec),
+      // pickling goes here
+      List(new RefChecks,
+           new ElimRepeated,
+           new ElimLocals,
+           new ExtensionMethods,
+           new TailRec),
       List(new PatternMatcher,
-           new LazyValTranformContext().transformer,
+           new ExplicitOuter,
+           new LazyValsTransform,
            new Splitter),
-      List(new Nullarify,
-           new TypeTestsCasts,
+      List(new ElimByName,
            new InterceptedMethods,
            new Literalize),
       List(new Erasure),
-      List(new UncurryTreeTransform
-        /* , new Constructors */)
+      List(new CapturedVars)
     )
 
   var runId = 1

src/dotty/tools/dotc/ElimLocals.scala

@@ -6,12 +6,12 @@ import DenotTransformers.SymTransformer
 import Phases.Phase
 import Contexts.Context
 import SymDenotations.SymDenotation
-import TreeTransforms.TreeTransform
+import TreeTransforms.MiniPhaseTransform
 import Flags.Local
 
 /** Widens all private[this] and protected[this] qualifiers to just private/protected */
-class ElimLocals extends TreeTransform with SymTransformer { thisTransformer =>
-  override def name = "elimlocals"
+class ElimLocals extends MiniPhaseTransform with SymTransformer { thisTransformer =>
+  override def phaseName = "elimLocals"
 
   def transformSym(ref: SymDenotation)(implicit ctx: Context) =
     dropLocal(ref)

src/dotty/tools/dotc/Flatten.scala

@@ -0,0 +1,15 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.SymTransformer
+import Phases.Phase
+import Contexts.Context
+import SymDenotations.SymDenotation
+import TreeTransforms.MiniPhaseTransform
+
+class Flatten extends MiniPhaseTransform with SymTransformer { thisTransformer =>
+  override def phaseName = "flatten"
+
+  def transformSym(ref: SymDenotation)(implicit ctx: Context) = ???
+}

src/dotty/tools/dotc/Run.scala

@@ -28,6 +28,12 @@ class Run(comp: Compiler)(implicit ctx: Context) {
     compileSources(sources)
   }
 
+  /** TODO: There's a fundamental design problem here: We assmble phases using `squash`
+   *  when we first build the compiler. But we modify them with -Yskip, -Ystop
+   *  on each run. That modification needs to either trasnform the tree structure,
+   *  or we need to assmeble phases on each run, and take -Yskip, -Ystop into
+   *  account. I think the latter would be preferable.
+   */
   def compileSources(sources: List[SourceFile]) = Stats.monitorHeartBeat {
     if (sources forall (_.exists)) {
       units = sources map (new CompilationUnit(_))
@@ -36,18 +42,19 @@ class Run(comp: Compiler)(implicit ctx: Context) {
         ctx.settings.YstopAfter.value.containsPhase(phase.prev)
       val phasesToRun = ctx.allPhases.init
         .takeWhile(!stoppedBefore(_))
-        .filterNot(ctx.settings.Yskip.value.containsPhase(_))
-      for (phase <- phasesToRun) {
+        .filterNot(ctx.settings.Yskip.value.containsPhase(_)) // TODO: skip only subphase
+      for (phase <- phasesToRun)
         if (!ctx.reporter.hasErrors) {
           phase.runOn(units)
           def foreachUnit(op: Context => Unit)(implicit ctx: Context): Unit =
             for (unit <- units) op(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
           if (ctx.settings.Xprint.value.containsPhase(phase))
             foreachUnit(printTree)
-          if (ctx.settings.Ycheck.value.containsPhase(phase) && !ctx.reporter.hasErrors)
-            foreachUnit(TreeChecker.check)
+          if (ctx.settings.Ycheck.value.containsPhase(phase) && !ctx.reporter.hasErrors) {
+            assert(phase.isCheckable, s"phase $phase is not checkable")
+            foreachUnit(TreeChecker.check(phasesToRun, _))
+          }
         }
-      }
     }
   }