Merge pull request typesafehub#2 from Duhemm/incremental-scenarios

New testing framework for the incremental compiler

Author: eed3si9n

Diff for: build.sbt

@@ -67,7 +67,6 @@ lazy val compileRoot: Project = (project in file(".")).
     classpathProj,
     classfileProj,
     compileInterfaceProj,
-    compileInterfaceOldProj,
     compileIncrementalProj,
     compilePersistProj,
     compilerProj,
@@ -150,38 +149,35 @@ lazy val compileInterfaceProj = (project in internalPath / "compile-bridge").
     // compiler instances that are memory hungry
     javaOptions in Test += "-Xmx1G",
     libraryDependencies ++= Seq(sbtIO, utilLogging),
-    scalaVersion := scala211,
-    crossScalaVersions := Nil
+    scalaSource in Compile := {
+      scalaVersion.value match {
+        case v if v startsWith "2.11" => baseDirectory.value / "src" / "main" / "scala"
+        case _                        => baseDirectory.value / "src-2.10" / "main" / "scala"
+      }
+    },
+    scalacOptions := {
+      scalaVersion.value match {
+        case v if v startsWith "2.11" => scalacOptions.value
+        case _                        => scalacOptions.value filterNot (Set("-Xfatal-warnings", "-deprecation") contains _)
+      }
+    }
     // artifact in (Compile, packageSrc) := Artifact(srcID).copy(configurations = Compile :: Nil).extra("e:component" -> srcID)
   )
 
-lazy val compileInterfaceOldProj = (project in internalPath / "compile-bridge-2.10").
-  dependsOn(interfaceProj % "compile;test->test", apiProj % "test->test").
+// Implements the core functionality of detecting and propagating changes incrementally.
+//   Defines the data structures for representing file fingerprints and relationships and the overall source analysis
+lazy val compileIncrementalProj = (project in internalPath / "compile-inc").
+  dependsOn (apiProj, classpathProj, compileInterfaceProj % Test).
   settings(
-    baseSettings,
-    libraryDependencies += scalaCompiler.value,
-    name := "Compiler Interface for pre 2.11 Scala",
-    exportJars := true,
+    testedBaseSettings,
+    libraryDependencies ++= Seq(sbtIO, utilLogging, utilRelation),
     // we need to fork because in unit tests we set usejavacp = true which means
     // we are expecting all of our dependencies to be on classpath so Scala compiler
     // can use them while constructing its own classpath for compilation
     fork in Test := true,
     // needed because we fork tests and tests are ran in parallel so we have multiple Scala
     // compiler instances that are memory hungry
     javaOptions in Test += "-Xmx1G",
-    libraryDependencies ++= Seq(sbtIO, utilLogging),
-    crossScalaVersions := Seq(scala210, scala293, scala282),
-    scalacOptions := { scalacOptions.value filterNot (Set("-Xfatal-warnings", "-deprecation") contains _) },
-    scalaSource in Test := (scalaSource in compileInterfaceProj in Test).value
-  )
-
-// Implements the core functionality of detecting and propagating changes incrementally.
-//   Defines the data structures for representing file fingerprints and relationships and the overall source analysis
-lazy val compileIncrementalProj = (project in internalPath / "compile-inc").
-  dependsOn (apiProj, classpathProj).
-  settings(
-    testedBaseSettings,
-    libraryDependencies ++= Seq(sbtIO, utilLogging, utilRelation),
     name := "Incremental Compiler"
   )
 

Diff for: internal/compile-bridge-2.10/NOTICE

@@ -29,7 +29,7 @@ object Dependency {
  * where it originates from. The Symbol->Classfile mapping is implemented by
  * LocateClassFile that we inherit from.
  */
-final class Dependency(val global: CallbackGlobal) extends LocateClassFile {
+final class Dependency(val global: CallbackGlobal) extends LocateClassFile with GlobalHelpers {
   import global._
 
   def newPhase(prev: Phase): Phase = new DependencyPhase(prev)

Diff for: internal/compile-bridge-2.10/src/main/scala/xsbt/API.scala renamed to internal/compile-bridge/src-2.10/main/scala/xsbt/API.scala

@@ -193,7 +193,7 @@ class ExtractAPI[GlobalType <: CallbackGlobal](val global: GlobalType,
               build(base, typeParameters(in, typeParams0), Nil)
             case MethodType(params, resultType) =>
               build(resultType, typeParams, parameterList(params) :: valueParameters)
-            case Nullary(resultType) => // 2.9 and later
+            case NullaryMethodType(resultType) =>
               build(resultType, typeParams, valueParameters)
             case returnType =>
               val t2 = processType(in, dropConst(returnType))
@@ -231,8 +231,8 @@ class ExtractAPI[GlobalType <: CallbackGlobal](val global: GlobalType,
     case _                      => t
   }
   private def dropNullary(t: Type): Type = t match {
-    case Nullary(un) => un
-    case _           => t
+    case NullaryMethodType(un) => un
+    case _                     => t
   }
 
   private def typeDef(in: Symbol, s: Symbol): xsbti.api.TypeMember =
@@ -309,7 +309,7 @@ class ExtractAPI[GlobalType <: CallbackGlobal](val global: GlobalType,
         None
     }
   private def ignoreClass(sym: Symbol): Boolean =
-    sym.isLocalClass || sym.isAnonymousClass || sym.fullName.endsWith(LocalChild.toString)
+    sym.isLocalClass || sym.isAnonymousClass || sym.fullName.endsWith(tpnme.LOCAL_CHILD.toString)
 
   // This filters private[this] vals/vars that were not in the original source.
   //  The getter will be used for processing instead.
@@ -326,7 +326,7 @@ class ExtractAPI[GlobalType <: CallbackGlobal](val global: GlobalType,
       val absOver = s.hasFlag(ABSOVERRIDE)
       val abs = s.hasFlag(ABSTRACT) || s.hasFlag(DEFERRED) || absOver
       val over = s.hasFlag(OVERRIDE) || absOver
-      new xsbti.api.Modifiers(abs, over, s.isFinal, s.hasFlag(SEALED), isImplicit(s), s.hasFlag(LAZY), hasMacro(s))
+      new xsbti.api.Modifiers(abs, over, s.isFinal, s.hasFlag(SEALED), isImplicit(s), s.hasFlag(LAZY), s.hasFlag(MACRO))
     }
 
   private def isImplicit(s: Symbol) = s.hasFlag(Flags.IMPLICIT)
@@ -412,7 +412,7 @@ class ExtractAPI[GlobalType <: CallbackGlobal](val global: GlobalType,
         case t: ExistentialType               => makeExistentialType(in, t)
         case NoType                           => Constants.emptyType // this can happen when there is an error that will be reported by a later phase
         case PolyType(typeParams, resultType) => new xsbti.api.Polymorphic(processType(in, resultType), typeParameters(in, typeParams))
-        case Nullary(resultType) =>
+        case NullaryMethodType(resultType) =>
           warning("sbt-api: Unexpected nullary method type " + in + " in " + in.owner); Constants.emptyType
         case _ => warning("sbt-api: Unhandled type " + t.getClass + " : " + t); Constants.emptyType
       }

Diff for: internal/compile-bridge-2.10/src/main/scala/xsbt/Analyzer.scala renamed to internal/compile-bridge/src-2.10/main/scala/xsbt/Analyzer.scala

@@ -38,7 +38,7 @@ import scala.tools.nsc._
  * The tree walking algorithm walks into TypeTree.original explicitly.
  *
  */
-class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) {
+class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) extends GlobalHelpers {
   import global._
 
   def extract(unit: CompilationUnit): Set[String] = {

Diff for: internal/compile-bridge-2.10/src/main/scala/xsbt/Command.scala renamed to internal/compile-bridge/src-2.10/main/scala/xsbt/Command.scala

@@ -0,0 +1,16 @@
+package xsbt
+
+import scala.tools.nsc.Global
+
+trait GlobalHelpers {
+  val global: CallbackGlobal
+  import global.{ analyzer, Tree }
+
+  object MacroExpansionOf {
+    def unapply(tree: Tree): Option[Tree] = {
+      tree.attachments.all.collect {
+        case att: analyzer.MacroExpansionAttachment => att.expandee
+      }.headOption
+    }
+  }
+}

Diff for: internal/compile-bridge-2.10/src/main/scala/xsbt/Compat.scala renamed to internal/compile-bridge/src-2.10/main/scala/xsbt/Compat.scala

@@ -21,7 +21,7 @@ abstract class LocateClassFile {
     // catch package objects (that do not have this flag set)
     if (sym hasFlag scala.tools.nsc.symtab.Flags.PACKAGE) None else {
       import scala.tools.nsc.symtab.Flags
-      val name = flatname(sym, classSeparator) + moduleSuffix(sym)
+      val name = flatname(sym, classSeparator) + sym.moduleSuffix
       findClass(name).map { case (file, inOut) => (file, name, inOut) } orElse {
         if (isTopLevelModule(sym)) {
           val linked = sym.companionClass

Diff for: internal/compile-bridge-2.10/src/main/scala/xsbt/CompilerInterface.scala renamed to internal/compile-bridge/src-2.10/main/scala/xsbt/CompilerInterface.scala

@@ -65,19 +65,18 @@ class ExtractUsedNamesSpecification extends UnitSpec {
     assert(usedNames === expectedNames)
   }
 
-  // test for https://issues.scala-lang.org/browse/SI-7173
-  // Note: This tests is disabled for Scala pre-2.11 because of the issue mentioned above.
-  it should "extract names of constants (only for 2.11)" in {
+  // pending test for https://issues.scala-lang.org/browse/SI-7173
+  it should "extract names of constants" in pendingUntilFixed {
     val src = "class A { final val foo = 12; def bar: Int = foo }"
     val compilerForTesting = new ScalaCompilerForUnitTesting(nameHashing = true)
     val usedNames = compilerForTesting.extractUsedNamesFromSrc(src)
     val expectedNames = standardNames ++ Set("A", "foo", "Int")
-    assert(!isScala211 || usedNames === expectedNames)
+    assert(usedNames === expectedNames)
   }
 
   // test for https://github.com/gkossakowski/sbt/issues/4
-  // Note: This tests is disabled for Scala pre-2.11 because of the issue mentioned above.
-  it should "extract names from method calls on Dynamic (only for 2.11)" in {
+  // TODO: we should fix it by having special treatment of `selectDynamic` and `applyDynamic` calls
+  it should "extract names from method calls on Dynamic" in pendingUntilFixed {
     val srcA = """|import scala.language.dynamics
                   |class A extends Dynamic {
                   | def selectDynamic(name: String): Int = name.length
@@ -86,11 +85,9 @@ class ExtractUsedNamesSpecification extends UnitSpec {
     val compilerForTesting = new ScalaCompilerForUnitTesting(nameHashing = true)
     val usedNames = compilerForTesting.extractUsedNamesFromSrc(srcA, srcB)
     val expectedNames = standardNames ++ Set("B", "A", "a", "Int", "selectDynamic", "bla")
-    assert(!isScala211 || usedNames === expectedNames)
+    assert(usedNames === expectedNames)
   }
 
-  private val isScala211 = scala.util.Properties.versionNumberString.startsWith("2.11")
-
   /**
    * Standard names that appear in every compilation unit that has any class
    * definition.