From a0193d28ea1bf25824bc41b1e08ba128cd9041f3 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sun, 19 Jun 2016 21:39:29 +0100
Subject: [PATCH] Cleanup mainProj

---
 main/src/main/scala/sbt/Defaults.scala        | 68 ++++++++-----------
 main/src/main/scala/sbt/EvaluateTask.scala    | 42 +-----------
 main/src/main/scala/sbt/Extracted.scala       | 10 +--
 main/src/main/scala/sbt/Keys.scala            |  3 +-
 main/src/main/scala/sbt/Main.scala            |  2 +-
 main/src/main/scala/sbt/Plugins.scala         |  2 +-
 main/src/main/scala/sbt/Project.scala         | 15 ++--
 main/src/main/scala/sbt/Resolvers.scala       |  6 +-
 main/src/main/scala/sbt/ScopeFilter.scala     |  2 +-
 main/src/main/scala/sbt/ScopedKeyData.scala   |  2 +-
 .../sbt/internal/EvaluateConfigurations.scala |  2 -
 .../src/main/scala/sbt/internal/Inspect.scala | 20 +++---
 main/src/main/scala/sbt/internal/Load.scala   |  6 +-
 .../scala/sbt/internal/PluginsDebug.scala     |  2 +-
 .../scala/sbt/internal/SessionSettings.scala  |  3 -
 .../main/scala/sbt/plugins/JvmPlugin.scala    |  3 +-
 16 files changed, 69 insertions(+), 119 deletions(-)

diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala
index 0d5cb6891..5913f0e5a 100755
--- a/main/src/main/scala/sbt/Defaults.scala
+++ b/main/src/main/scala/sbt/Defaults.scala
@@ -41,7 +41,7 @@ import sbt.internal.util.Cache.seqFormat
 import sbt.util.Logger
 import sbt.internal.CommandStrings.ExportStream
 
-import xsbti.Maybe
+import xsbti.{ CrossValue, Maybe }
 import sbt.util.InterfaceUtil.{ f1, o2m }
 
 import sbt.internal.util.Types._
@@ -76,8 +76,7 @@ object Defaults extends BuildCommon {
   def thisBuildCore: Seq[Setting[_]] = inScope(GlobalScope.copy(project = Select(ThisBuild)))(Seq(
     managedDirectory := baseDirectory.value / "lib_managed"
   ))
-  @deprecated("Use AutoPlugins and globalSbtCore instead.", "0.13.2")
-  lazy val globalCore: Seq[Setting[_]] = globalDefaults(defaultTestTasks(test) ++ defaultTestTasks(testOnly) ++ defaultTestTasks(testQuick) ++ Seq(
+  private[sbt] lazy val globalCore: Seq[Setting[_]] = globalDefaults(defaultTestTasks(test) ++ defaultTestTasks(testOnly) ++ defaultTestTasks(testQuick) ++ Seq(
     excludeFilter :== HiddenFileFilter
   ) ++ globalIvyCore ++ globalJvmCore) ++ globalSbtCore
 
@@ -196,8 +195,7 @@ object Defaults extends BuildCommon {
     historyPath <<= historyPath or target(t => Some(t / ".history")),
     sourceDirectory := baseDirectory.value / "src",
     sourceManaged := crossTarget.value / "src_managed",
-    resourceManaged := crossTarget.value / "resource_managed",
-    cacheDirectory := crossTarget.value / CacheDirectoryName / thisProject.value.id / "global"
+    resourceManaged := crossTarget.value / "resource_managed"
   )
 
   lazy val configPaths = sourceConfigPaths ++ resourceConfigPaths ++ outputConfigPaths
@@ -229,7 +227,6 @@ object Defaults extends BuildCommon {
     resources <<= Classpaths.concat(managedResources, unmanagedResources)
   )
   lazy val outputConfigPaths = Seq(
-    cacheDirectory := crossTarget.value / CacheDirectoryName / thisProject.value.id / configuration.value.name,
     classDirectory := crossTarget.value / (prefix(configuration.value.name) + "classes"),
     target in doc := crossTarget.value / (prefix(configuration.value.name) + "api")
   )
@@ -358,10 +355,10 @@ object Defaults extends BuildCommon {
       override def pollInterval = interval
       override def watchingMessage(s: WatchState) = msg(s)
       override def triggeredMessage(s: WatchState) = trigMsg(s)
-      override def watchPaths(s: State) = EvaluateTask.evaluateTask(Project structure s, key, s, base) match {
-        case Some(Value(ps)) => ps
-        case Some(Inc(i))    => throw i
-        case None            => sys.error("key not found: " + Def.displayFull(key))
+      override def watchPaths(s: State) = EvaluateTask(Project structure s, key, s, base) match {
+        case Some((_, Value(ps))) => ps
+        case Some((_, Inc(i)))    => throw i
+        case None                 => sys.error("key not found: " + Def.displayFull(key))
       }
     }
   }
@@ -710,10 +707,6 @@ object Defaults extends BuildCommon {
   @deprecated("Use `Util.pairID` instead", "0.12.0")
   def pairID = Util.pairID
 
-  @deprecated("Use the cacheDirectory val on streams.", "0.13.0")
-  def perTaskCache(key: TaskKey[_]): Setting[File] =
-    cacheDirectory ~= { _ / ("for_" + key.key.label) }
-
   @deprecated("Use `packageTaskSettings` instead", "0.12.0")
   def packageTasks(key: TaskKey[File], mappingsTask: Initialize[Task[Seq[(File, String)]]]) = packageTaskSettings(key, mappingsTask)
   def packageTaskSettings(key: TaskKey[File], mappingsTask: Initialize[Task[Seq[(File, String)]]]) =
@@ -848,6 +841,7 @@ object Defaults extends BuildCommon {
   def consoleQuickTask = consoleTask(externalDependencyClasspath, consoleQuick)
   def consoleTask(classpath: TaskKey[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] =
     (compilers in task, classpath in task, scalacOptions in task, initialCommands in task, cleanupCommands in task, taskTemporaryDirectory in task, scalaInstance in task, streams) map {
+      // TODO: Make exhaustive after zinc is updated to include https://github.com/sbt/zinc/pull/128
       case (cs: IncrementalCompilerImpl.Compilers, cp, options, initCommands, cleanup, temp, si, s) =>
         val cpFiles = data(cp)
         val fullcp = (cpFiles ++ si.allJars).distinct
@@ -978,8 +972,8 @@ object Defaults extends BuildCommon {
 
   private def distinctParser(exs: Set[String], raw: Boolean): Parser[Seq[String]] =
     {
-      import DefaultParsers._
-      val base = token(Space) ~> token(NotSpace - "--" examples exs)
+      import DefaultParsers._, Parser.and
+      val base = token(Space) ~> token(and(NotSpace, not("--", "Unexpected: ---")) examples exs)
       val recurse = base flatMap { ex =>
         val (matching, notMatching) = exs.partition(GlobFilter(ex).accept _)
         distinctParser(notMatching, raw) map { result => if (raw) ex +: result else matching.toSeq ++ result }
@@ -1028,7 +1022,6 @@ object Defaults extends BuildCommon {
   lazy val runnerSettings: Seq[Setting[_]] = Seq(runnerTask)
   lazy val baseTasks: Seq[Setting[_]] = projectTasks ++ packageBase
 
-  lazy val baseClasspaths: Seq[Setting[_]] = Classpaths.publishSettings ++ Classpaths.baseSettings
   lazy val configSettings: Seq[Setting[_]] = Classpaths.configSettings ++ configTasks ++ configPaths ++ packageConfig ++ Classpaths.compilerPluginConfig
 
   lazy val compileSettings: Seq[Setting[_]] = configSettings ++ (mainRunMainTask +: mainRunTask +: addBaseSources) ++ Classpaths.addUnmanagedLibrary
@@ -1037,10 +1030,6 @@ object Defaults extends BuildCommon {
   lazy val itSettings: Seq[Setting[_]] = inConfig(IntegrationTest)(testSettings)
   lazy val defaultConfigs: Seq[Setting[_]] = inConfig(Compile)(compileSettings) ++ inConfig(Test)(testSettings) ++ inConfig(Runtime)(Classpaths.configSettings)
 
-  // settings that are not specific to a configuration
-  @deprecated("Settings now split into AutoPlugins.", "0.13.2")
-  lazy val projectBaseSettings: Seq[Setting[_]] = projectCore ++ runnerSettings ++ paths ++ baseClasspaths ++ baseTasks ++ compileBase ++ disableAggregation
-
   // These are project level settings that MUST be on every project.
   lazy val coreDefaultSettings: Seq[Setting[_]] =
     projectCore ++ disableAggregation ++ Seq(
@@ -1048,8 +1037,6 @@ object Defaults extends BuildCommon {
       baseDirectory := thisProject.value.base,
       target := baseDirectory.value / "target"
     )
-  @deprecated("Default settings split into coreDefaultSettings and IvyModule/JvmModule plugins.", "0.13.2")
-  lazy val defaultSettings: Seq[Setting[_]] = projectBaseSettings ++ defaultConfigs
 
 }
 object Classpaths {
@@ -1136,8 +1123,6 @@ object Classpaths {
     publishLocal <<= publishTask(publishLocalConfiguration, deliverLocal),
     publishM2 <<= publishTask(publishM2Configuration, deliverLocal)
   )
-  @deprecated("This has been split into jvmPublishSettings and ivyPublishSettings.", "0.13.2")
-  val publishSettings: Seq[Setting[_]] = ivyPublishSettings ++ jvmPublishSettings
 
   private[this] def baseGlobalDefaults = Defaults.globalDefaults(Seq(
     conflictWarning :== ConflictWarning.default("global"),
@@ -1168,7 +1153,11 @@ object Classpaths {
       val id = app.provider.id
       val scalaVersion = app.provider.scalaProvider.version
       val binVersion = binaryScalaVersion(scalaVersion)
-      val cross = if (id.crossVersioned) CrossVersion.binary else CrossVersion.Disabled
+      val cross = id.crossVersionedValue match {
+        case CrossValue.Disabled => CrossVersion.Disabled
+        case CrossValue.Full     => CrossVersion.binary
+        case CrossValue.Binary   => CrossVersion.full
+      }
       val base = ModuleID(id.groupID, id.name, sbtVersion.value, crossVersion = cross)
       CrossVersion(scalaVersion, binVersion)(base).copy(crossVersion = CrossVersion.Disabled)
     }
@@ -1185,11 +1174,11 @@ object Classpaths {
     organizationHomepage <<= organizationHomepage or homepage,
     projectInfo <<= (name, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers) apply ModuleInfo,
     overrideBuildResolvers <<= appConfiguration(isOverrideRepositories),
-    externalResolvers <<= (externalResolvers.task.?, resolvers, appResolvers, useJCenter) {
+    externalResolvers := ((externalResolvers.?.value, resolvers.value, appResolvers.value, useJCenter.value) match {
       case (Some(delegated), Seq(), _, _) => delegated
-      case (_, rs, Some(ars), uj)         => task { ars ++ rs }
-      case (_, rs, _, uj)                 => task { Resolver.withDefaultResolvers(rs, uj, mavenCentral = true) }
-    },
+      case (_, rs, Some(ars), uj)         => ars ++ rs
+      case (_, rs, _, uj)                 => Resolver.withDefaultResolvers(rs, uj, mavenCentral = true)
+    }),
     appResolvers := {
       val ac = appConfiguration.value
       val uj = useJCenter.value
@@ -1319,8 +1308,6 @@ object Classpaths {
       }
     }
   )
-  @deprecated("Split into ivyBaseSettings and jvmBaseSettings.", "0.13.2")
-  val baseSettings: Seq[Setting[_]] = ivyBaseSettings ++ jvmBaseSettings
 
   def warnResolversConflict(ress: Seq[Resolver], log: Logger): Unit = {
     val resset = ress.toSet
@@ -1686,10 +1673,9 @@ object Classpaths {
     for (f <- productsImplTask.value) yield APIMappings.store(analyzed(f, compile.value), apiURL.value).put(artifact.key, art).put(moduleID.key, module).put(configuration.key, config)
   }
 
-  private[this] def productsImplTask: Initialize[Task[Seq[File]]] =
-    (products.task, packageBin.task, exportJars) flatMap { (psTask, pkgTask, useJars) =>
-      if (useJars) Seq(pkgTask).join else psTask
-    }
+  private[this] def productsImplTask: Initialize[Task[Seq[File]]] = Def.task {
+    if (exportJars.value) Seq(packageBin.value) else products.value
+  }
 
   def constructBuildDependencies: Initialize[BuildDependencies] = loadedBuild(lb => BuildUtil.dependencies(lb.units))
 
@@ -2056,10 +2042,12 @@ trait BuildExtra extends BuildCommon with DefExtra {
     moduleSettings := new PomConfiguration(file.value, ivyScala.value, ivyValidate.value, managedScalaInstance.value)
 
   def runInputTask(config: Configuration, mainClass: String, baseArguments: String*): Initialize[InputTask[Unit]] =
-    inputTask { result =>
-      (fullClasspath in config, runner in (config, run), streams, result) map { (cp, r, s, args) =>
-        toError(r.run(mainClass, data(cp), baseArguments ++ args, s.log))
-      }
+    Def.inputTask {
+      import Def._
+      val r = (runner in (config, run)).value
+      val cp = (fullClasspath in config).value
+      val args = spaceDelimited().parsed
+      toError(r.run(mainClass, data(cp), baseArguments ++ args, streams.value.log))
     }
   def runTask(config: Configuration, mainClass: String, arguments: String*): Initialize[Task[Unit]] =
     (fullClasspath in config, runner in (config, run), streams) map { (cp, r, s) =>
diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala
index ab9526e08..871d6e919 100644
--- a/main/src/main/scala/sbt/EvaluateTask.scala
+++ b/main/src/main/scala/sbt/EvaluateTask.scala
@@ -100,21 +100,6 @@ sealed trait EvaluateTaskConfig {
   def minForcegcInterval: Duration
 }
 final object EvaluateTaskConfig {
-  /** Pulls in the old configuration format. */
-  def apply(old: EvaluateConfig): EvaluateTaskConfig = {
-    object AdaptedTaskConfig extends EvaluateTaskConfig {
-      def restrictions: Seq[Tags.Rule] = old.restrictions
-      def checkCycles: Boolean = old.checkCycles
-      def progressReporter: ExecuteProgress[Task] = old.progress
-      def cancelStrategy: TaskCancellationStrategy =
-        if (old.cancelable) TaskCancellationStrategy.Signal
-        else TaskCancellationStrategy.Null
-      def forceGarbageCollection = GCUtil.defaultForceGarbageCollection
-      def minForcegcInterval = GCUtil.defaultMinForcegcInterval
-    }
-    AdaptedTaskConfig
-  }
-
   @deprecated("Use the alternative that specifies minForcegcInterval", "0.13.9")
   def apply(restrictions: Seq[Tags.Rule],
     checkCycles: Boolean,
@@ -152,14 +137,6 @@ final object EvaluateTaskConfig {
 final case class PluginData(dependencyClasspath: Seq[Attributed[File]], definitionClasspath: Seq[Attributed[File]], resolvers: Option[Seq[Resolver]], report: Option[UpdateReport], scalacOptions: Seq[String]) {
   val classpath: Seq[Attributed[File]] = definitionClasspath ++ dependencyClasspath
 }
-object PluginData {
-  @deprecated("Use the alternative that specifies the compiler options and specific classpaths.", "0.13.1")
-  def apply(dependencyClasspath: Seq[Attributed[File]], definitionClasspath: Seq[Attributed[File]], resolvers: Option[Seq[Resolver]], report: Option[UpdateReport]): PluginData =
-    PluginData(dependencyClasspath, definitionClasspath, resolvers, report, Nil)
-  @deprecated("Use the alternative that specifies the specific classpaths.", "0.13.0")
-  def apply(classpath: Seq[Attributed[File]], resolvers: Option[Seq[Resolver]], report: Option[UpdateReport]): PluginData =
-    PluginData(classpath, Nil, resolvers, report, Nil)
-}
 
 object EvaluateTask {
   import std.{ TaskExtra, Transform }
@@ -245,7 +222,7 @@ object EvaluateTask {
 
   def injectSettings: Seq[Setting[_]] = Seq(
     (state in GlobalScope) ::= dummyState,
-    (streamsManager in GlobalScope) ::= dummyStreamsManager,
+    (streamsManager in GlobalScope) ::= Def.dummyStreamsManager,
     (executionRoots in GlobalScope) ::= dummyRoots
   )
 
@@ -260,10 +237,6 @@ object EvaluateTask {
       processResult(result, log)
     }
 
-  @deprecated("This method does not apply state changes requested during task execution and does not honor concurrent execution restrictions.  Use 'apply' instead.", "0.11.1")
-  def evaluateTask[T](structure: BuildStructure, taskKey: ScopedKey[Task[T]], state: State, ref: ProjectRef, checkCycles: Boolean = false, maxWorkers: Int = SystemProcessors): Option[Result[T]] =
-    apply(structure, taskKey, state, ref, EvaluateConfig(false, defaultRestrictions(maxWorkers), checkCycles)).map(_._2)
-
   /**
    * Evaluates `taskKey` and returns the new State and the result of the task wrapped in Some.
    * If the task is not defined, None is returned.  The provided task key is resolved against the current project `ref`.
@@ -277,9 +250,6 @@ object EvaluateTask {
    * If the task is not defined, None is returned.  The provided task key is resolved against the current project `ref`.
    * `config` configures concurrency and canceling of task execution.
    */
-  @deprecated("Use EvaluateTaskConfig option instead.", "0.13.5")
-  def apply[T](structure: BuildStructure, taskKey: ScopedKey[Task[T]], state: State, ref: ProjectRef, config: EvaluateConfig): Option[(State, Result[T])] =
-    apply(structure, taskKey, state, ref, EvaluateTaskConfig(config))
   def apply[T](structure: BuildStructure, taskKey: ScopedKey[Task[T]], state: State, ref: ProjectRef, config: EvaluateTaskConfig): Option[(State, Result[T])] = {
     withStreams(structure, state) { str =>
       for ((task, toNode) <- getTask(structure, taskKey, state, str, ref)) yield runTask(task, state, str, structure.index.triggers, config)(toNode)
@@ -327,14 +297,8 @@ object EvaluateTask {
       for (t <- structure.data.get(resolvedScope, taskKey.key)) yield (t, nodeView(state, streams, taskKey :: Nil))
     }
   def nodeView[HL <: HList](state: State, streams: Streams, roots: Seq[ScopedKey[_]], dummies: DummyTaskMap = DummyTaskMap(Nil)): NodeView[Task] =
-    Transform((dummyRoots, roots) :: (dummyStreamsManager, streams) :: (dummyState, state) :: dummies)
+    Transform((dummyRoots, roots) :: (Def.dummyStreamsManager, streams) :: (dummyState, state) :: dummies)
 
-  @deprecated("Use new EvaluateTaskConfig option to runTask", "0.13.5")
-  def runTask[T](root: Task[T], state: State, streams: Streams, triggers: Triggers[Task], config: EvaluateConfig)(implicit taskToNode: NodeView[Task]): (State, Result[T]) =
-    {
-      val newConfig = EvaluateTaskConfig(config)
-      runTask(root, state, streams, triggers, newConfig)(taskToNode)
-    }
   def runTask[T](root: Task[T], state: State, streams: Streams, triggers: Triggers[Task], config: EvaluateTaskConfig)(implicit taskToNode: NodeView[Task]): (State, Result[T]) =
     {
       import ConcurrentRestrictions.{ completionService, TagMap, Tag, tagged, tagsKey }
@@ -406,7 +370,7 @@ object EvaluateTask {
     case in @ Incomplete(Some(node: Task[_]), _, _, _, _) => in.copy(node = transformNode(node))
     case i => i
   }
-  type AnyCyclic = Execute[Task]#CyclicException[_]
+  type AnyCyclic = Execute[({ type A[_] <: AnyRef })#A]#CyclicException[_]
   def convertCyclicInc: Incomplete => Incomplete = {
     case in @ Incomplete(_, _, _, _, Some(c: AnyCyclic)) =>
       in.copy(directCause = Some(new RuntimeException(convertCyclic(c))))
diff --git a/main/src/main/scala/sbt/Extracted.scala b/main/src/main/scala/sbt/Extracted.scala
index fc2f17795..dff713b17 100644
--- a/main/src/main/scala/sbt/Extracted.scala
+++ b/main/src/main/scala/sbt/Extracted.scala
@@ -13,23 +13,25 @@ final case class Extracted(structure: BuildStructure, session: SessionSettings,
   lazy val currentUnit = structure units currentRef.build
   lazy val currentProject = currentUnit defined currentRef.project
   lazy val currentLoader: ClassLoader = currentUnit.loader
-  def get[T](key: TaskKey[T]): Task[T] = get(key.task)
 
   /**
    * Gets the value assigned to `key` in the computed settings map.
    * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
    * Other axes are resolved to be `Global` if they are not specified.
    */
-  def get[T](key: SettingKey[T]) = getOrError(inCurrent(key), key.key)
+  def get[T](key: SettingKey[T]): T = getOrError(inCurrent(key.scope), key.key)
+  def get[T](key: TaskKey[T]): Task[T] = getOrError(inCurrent(key.scope), key.key)
 
   /**
    * Gets the value assigned to `key` in the computed settings map wrapped in Some.  If it does not exist, None is returned.
    * If the project axis is not explicitly specified, it is resolved to be the current project according to the extracted `session`.
    * Other axes are resolved to be `Global` if they are not specified.
    */
-  def getOpt[T](key: SettingKey[T]): Option[T] = structure.data.get(inCurrent(key), key.key)
+  def getOpt[T](key: SettingKey[T]): Option[T] = structure.data.get(inCurrent(key.scope), key.key)
+  def getOpt[T](key: TaskKey[T]): Option[Task[T]] = structure.data.get(inCurrent(key.scope), key.key)
 
-  private[this] def inCurrent[T](key: SettingKey[T]): Scope = if (key.scope.project == This) key.scope.copy(project = Select(currentRef)) else key.scope
+  private[this] def inCurrent[T](scope: Scope): Scope =
+    if (scope.project == This) scope.copy(project = Select(currentRef)) else scope
 
   /**
    * Runs the task specified by `key` and returns the transformed State and the resulting value of the task.
diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala
index 980c99021..2e214701b 100644
--- a/main/src/main/scala/sbt/Keys.scala
+++ b/main/src/main/scala/sbt/Keys.scala
@@ -148,8 +148,6 @@ object Keys {
 
   // Output paths
   val classDirectory = SettingKey[File]("class-directory", "Directory for compiled classes and copied resources.", AMinusSetting)
-  @deprecated("Use the cacheDirectory provided by streams.", "0.13.0")
-  val cacheDirectory = SettingKey[File]("cache-directory", "Directory used for caching task data.", BMinusSetting)
   val cleanFiles = SettingKey[Seq[File]]("clean-files", "The files to recursively delete during a clean.", BSetting)
   val cleanKeepFiles = SettingKey[Seq[File]]("clean-keep-files", "Files to keep during a clean.", CSetting)
   val crossPaths = SettingKey[Boolean]("cross-paths", "If true, enables cross paths, which distinguish input and output directories for cross-building.", ASetting)
@@ -275,6 +273,7 @@ object Keys {
   val defaultConfiguration = SettingKey[Option[Configuration]]("default-configuration", "Defines the configuration used when none is specified for a dependency in ivyXML.", CSetting)
 
   val products = TaskKey[Seq[File]]("products", "Build products that get packaged.", BMinusTask)
+  // TODO: This is used by exportedProducts, exportedProductsIfMissing, exportedProductsNoTracking..
   @deprecated("This task is unused by the default project and will be removed.", "0.13.0")
   val productDirectories = TaskKey[Seq[File]]("product-directories", "Base directories of build products.", CTask)
   val exportJars = SettingKey[Boolean]("export-jars", "Determines whether the exported classpath for this project contains classes (false) or a packaged jar (true).", BSetting)
diff --git a/main/src/main/scala/sbt/Main.scala b/main/src/main/scala/sbt/Main.scala
index 98f809ab5..ff2a5139b 100644
--- a/main/src/main/scala/sbt/Main.scala
+++ b/main/src/main/scala/sbt/Main.scala
@@ -134,7 +134,7 @@ object BuiltinCommands {
     {
       val scalaVersion = e.getOpt(Keys.scalaVersion)
       val scalaHome = e.getOpt(Keys.scalaHome).flatMap(idFun)
-      val instance = e.getOpt(Keys.scalaInstance.task).flatMap(_ => quiet(e.runTask(Keys.scalaInstance, s)._2))
+      val instance = e.getOpt(Keys.scalaInstance).flatMap(_ => quiet(e.runTask(Keys.scalaInstance, s)._2))
       (scalaVersion, scalaHome, instance) match {
         case (sv, Some(home), Some(si)) => "local Scala version " + selectScalaVersion(sv, si) + " at " + home.getAbsolutePath
         case (_, Some(home), None)      => "a local Scala build at " + home.getAbsolutePath
diff --git a/main/src/main/scala/sbt/Plugins.scala b/main/src/main/scala/sbt/Plugins.scala
index a8975e138..e990b2879 100644
--- a/main/src/main/scala/sbt/Plugins.scala
+++ b/main/src/main/scala/sbt/Plugins.scala
@@ -341,7 +341,7 @@ ${listConflicts(conflicting)}""")
     val m = ru.runtimeMirror(loader)
     val im = m.reflect(ap)
     val hasGetterOpt = catching(classOf[ScalaReflectionException]) opt {
-      im.symbol.asType.toType.declaration(ru.newTermName("autoImport")) match {
+      im.symbol.asType.toType.decl(ru.TermName("autoImport")) match {
         case ru.NoSymbol => false
         case sym => sym.asTerm.isGetter || sym.asTerm.isModule
       }
diff --git a/main/src/main/scala/sbt/Project.scala b/main/src/main/scala/sbt/Project.scala
index 456e6e20e..456f8d407 100755
--- a/main/src/main/scala/sbt/Project.scala
+++ b/main/src/main/scala/sbt/Project.scala
@@ -592,7 +592,8 @@ object Project extends ProjectExtra {
       val p = EvaluateTask.executeProgress(extracted, extracted.structure, state)
       val r = EvaluateTask.restrictions(state)
       val fgc = EvaluateTask.forcegc(extracted, extracted.structure)
-      runTask(taskKey, state, EvaluateTaskConfig(r, checkCycles, p, ch, fgc))
+      val mfi = EvaluateTask.minForcegcInterval(extracted, extracted.structure)
+      runTask(taskKey, state, EvaluateTaskConfig(r, checkCycles, p, ch, fgc, mfi))
     }
   def runTask[T](taskKey: ScopedKey[Task[T]], state: State, config: EvaluateTaskConfig): Option[(State, Result[T])] = {
     val extracted = Project.extract(state)
@@ -627,21 +628,21 @@ object Project extends ProjectExtra {
 private[sbt] trait GeneratedRootProject
 
 trait ProjectExtra0 {
-   implicit def wrapProjectReferenceSeqEval[T <% ProjectReference](rs: => Seq[T]): Seq[Eval[ProjectReference]] =
+   implicit def wrapProjectReferenceSeqEval[T](rs: => Seq[T])(implicit ev: T => ProjectReference): Seq[Eval[ProjectReference]] =
     rs map { r => Eval.later(r: ProjectReference) }
 }
 
 trait ProjectExtra extends ProjectExtra0 {
-  implicit def classpathDependencyEval[T <% ClasspathDep[ProjectReference]](p: => T): Eval[ClasspathDep[ProjectReference]] =
+  implicit def classpathDependencyEval[T](p: => T)(implicit ev: T => ClasspathDep[ProjectReference]): Eval[ClasspathDep[ProjectReference]] =
     Eval.later(p: ClasspathDep[ProjectReference])
-  implicit def wrapProjectReferenceEval[T <% ProjectReference](ref: => T): Eval[ProjectReference] =
+  implicit def wrapProjectReferenceEval[T](ref: => T)(implicit ev: T => ProjectReference): Eval[ProjectReference] =
     Eval.later(ref: ProjectReference)
 
-  implicit def wrapSettingDefinitionEval[T <% Def.SettingsDefinition](d: => T): Eval[Def.SettingsDefinition] = Eval.later(d)
+  implicit def wrapSettingDefinitionEval[T](d: => T)(implicit ev: T => Def.SettingsDefinition): Eval[Def.SettingsDefinition] = Eval.later(d)
   implicit def wrapSettingSeqEval(ss: => Seq[Setting[_]]): Eval[Def.SettingsDefinition] = Eval.later(new Def.SettingList(ss))
 
-  implicit def configDependencyConstructor[T <% ProjectReference](p: T): Constructor = new Constructor(p)
-  implicit def classpathDependency[T <% ProjectReference](p: T): ClasspathDep[ProjectReference] = new ClasspathDependency(p, None)
+  implicit def configDependencyConstructor[T](p: T)(implicit ev: T => ProjectReference): Constructor = new Constructor(p)
+  implicit def classpathDependency[T](p: T)(implicit ev: T => ProjectReference): ClasspathDep[ProjectReference] = new ClasspathDependency(p, None)
 
 
   // These used to be in Project so that they didn't need to get imported (due to Initialize being nested in Project).
diff --git a/main/src/main/scala/sbt/Resolvers.scala b/main/src/main/scala/sbt/Resolvers.scala
index ed3f1541a..4d24fdb19 100644
--- a/main/src/main/scala/sbt/Resolvers.scala
+++ b/main/src/main/scala/sbt/Resolvers.scala
@@ -97,9 +97,9 @@ object Resolvers {
   abstract class DistributedVCS {
     val scheme: String
 
-    def clone(from: String, to: File)
+    def clone(from: String, to: File): Unit
 
-    def checkout(branch: String, in: File)
+    def checkout(branch: String, in: File): Unit
 
     def toResolver: Resolver = (info: ResolveInfo) => {
       val uri = info.uri.withoutMarkerScheme
@@ -167,7 +167,7 @@ object Resolvers {
     }
 
   private[this] def normalizeDirectoryName(name: String): String =
-    StringUtilities.normalize(dropExtensions(name))
+    dropExtensions(name).toLowerCase(Locale.ENGLISH).replaceAll("""\W+""", "-")
 
   private[this] def dropExtensions(name: String): String = name.takeWhile(_ != '.')
 
diff --git a/main/src/main/scala/sbt/ScopeFilter.scala b/main/src/main/scala/sbt/ScopeFilter.scala
index b171f3ee4..7c4972050 100644
--- a/main/src/main/scala/sbt/ScopeFilter.scala
+++ b/main/src/main/scala/sbt/ScopeFilter.scala
@@ -187,7 +187,7 @@ object ScopeFilter {
   /** Base functionality for filters on values of type `In` that need access to build data.*/
   sealed abstract class Base[In] { self =>
     /** Implements this filter. */
-    private[sbt] def apply(data: Data): In => Boolean
+    private[ScopeFilter] def apply(data: Data): In => Boolean
 
     /** Constructs a filter that selects values that match this filter but not `other`.*/
     def --(other: Base[In]): Base[In] = this && -other
diff --git a/main/src/main/scala/sbt/ScopedKeyData.scala b/main/src/main/scala/sbt/ScopedKeyData.scala
index 76d20d04f..ae5d57b76 100644
--- a/main/src/main/scala/sbt/ScopedKeyData.scala
+++ b/main/src/main/scala/sbt/ScopedKeyData.scala
@@ -10,7 +10,7 @@ final case class ScopedKeyData[A](scoped: ScopedKey[A], value: Any) {
   def settingValue: Option[Any] = fold(const(None), const(None), Some(value))
   def description: String = fold(fmtMf("Task: %s"), fmtMf("Input task: %s"),
     "Setting: %s = %s" format (key.manifest.toString, value.toString))
-  def fold[A](targ: OptManifest[_] => A, itarg: OptManifest[_] => A, s: => A): A =
+  def fold[T](targ: OptManifest[_] => T, itarg: OptManifest[_] => T, s: => T): T =
     if (key.manifest.runtimeClass == classOf[Task[_]]) targ(key.manifest.typeArguments.head)
     else if (key.manifest.runtimeClass == classOf[InputTask[_]]) itarg(key.manifest.typeArguments.head)
     else s
diff --git a/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala b/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala
index 248d77480..3287662a1 100644
--- a/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala
+++ b/main/src/main/scala/sbt/internal/EvaluateConfigurations.scala
@@ -235,7 +235,6 @@ private[sbt] object EvaluateConfigurations {
       }
     }
 
-  @deprecated("This method is no longer part of the public API.", "0.13.7")
   def splitExpressions(lines: Seq[String]): (Seq[(String, Int)], Seq[(String, LineRange)]) = {
     val blank = (_: String).forall(isSpace)
     val isImport = firstNonSpaceIs("import ")
@@ -246,7 +245,6 @@ private[sbt] object EvaluateConfigurations {
     val (imports, settings) = lines.zipWithIndex span importOrBlank
     (imports filterNot fstS(blankOrComment), groupedLines(settings, blank, blankOrComment))
   }
-  @deprecated("This method is deprecated and no longer used.", "0.13.7")
   def groupedLines(lines: Seq[(String, Int)], delimiter: String => Boolean, skipInitial: String => Boolean): Seq[(String, LineRange)] =
     {
       val fdelim = fstS(delimiter)
diff --git a/main/src/main/scala/sbt/internal/Inspect.scala b/main/src/main/scala/sbt/internal/Inspect.scala
index a8ffb3111..0d1e9ff6a 100644
--- a/main/src/main/scala/sbt/internal/Inspect.scala
+++ b/main/src/main/scala/sbt/internal/Inspect.scala
@@ -12,14 +12,16 @@ import java.io.File
 object Inspect {
   sealed trait Mode
   final case class Details(actual: Boolean) extends Mode
-  private[this] final class Opt(override val toString: String) extends Mode
-  val DependencyTree: Mode = new Opt("tree")
-  val Uses: Mode = new Opt("inspect")
-  val Definitions: Mode = new Opt("definitions")
+  private[sbt] case object DependencyTreeMode extends Mode { override def toString = "tree" }
+  private[sbt] case object UsesMode extends Mode { override def toString = "inspect" }
+  private[sbt] case object DefinitionsMode extends Mode { override def toString = "definitions" }
+  val DependencyTree: Mode = DependencyTreeMode
+  val Uses: Mode = UsesMode
+  val Definitions: Mode = DefinitionsMode
 
   def parser: State => Parser[(Inspect.Mode, ScopedKey[_])] = (s: State) => spacedModeParser(s) flatMap {
-    case opt @ (Uses | Definitions)          => allKeyParser(s).map(key => (opt, Def.ScopedKey(Global, key)))
-    case opt @ (DependencyTree | Details(_)) => spacedKeyParser(s).map(key => (opt, key))
+    case opt @ (UsesMode | DefinitionsMode)      => allKeyParser(s).map(key => (opt, Def.ScopedKey(Global, key)))
+    case opt @ (DependencyTreeMode | Details(_)) => spacedKeyParser(s).map(key => (opt, key))
   }
   val spacedModeParser: (State => Parser[Mode]) = (s: State) => {
     val actual = "actual" ^^^ Details(true)
@@ -43,12 +45,12 @@ object Inspect {
       option match {
         case Details(actual) =>
           Project.details(structure, actual, sk.scope, sk.key)
-        case DependencyTree =>
+        case DependencyTreeMode =>
           val basedir = new File(Project.session(s).current.build)
           Project.settingGraph(structure, basedir, sk).dependsAscii
-        case Uses =>
+        case UsesMode =>
           Project.showUses(Project.usedBy(structure, true, sk.key))
-        case Definitions =>
+        case DefinitionsMode =>
           Project.showDefinitions(sk.key, Project.definitions(structure, true, sk.key))
       }
     }
diff --git a/main/src/main/scala/sbt/internal/Load.scala b/main/src/main/scala/sbt/internal/Load.scala
index ea26f3561..08a136c82 100755
--- a/main/src/main/scala/sbt/internal/Load.scala
+++ b/main/src/main/scala/sbt/internal/Load.scala
@@ -5,7 +5,7 @@ package sbt
 package internal
 
 import sbt.internal.util.{ Settings, Show, ~> }
-import sbt.librarymanagement.{ Configuration, Configurations, Resolver }
+import sbt.librarymanagement.{ Configuration, Configurations, Resolver, UpdateOptions }
 import sbt.internal.librarymanagement.{ InlineIvyConfiguration, IvyPaths }
 
 import java.io.File
@@ -58,7 +58,7 @@ private[sbt] object Load {
       val checksums = Nil
       val ivyPaths = new IvyPaths(baseDirectory, bootIvyHome(state.configuration))
       val ivyConfiguration = new InlineIvyConfiguration(ivyPaths, Resolver.withDefaultResolvers(Nil),
-        Nil, Nil, localOnly, lock, checksums, None, log)
+        Nil, Nil, localOnly, lock, checksums, None, UpdateOptions(), log)
       val compilers = Compiler.compilers(ClasspathOptions.boot, ivyConfiguration)(state.configuration, log)
       val evalPluginDef = EvaluateTask.evalPluginDef(log) _
       val delegates = defaultDelegates
@@ -790,7 +790,7 @@ private[sbt] object Load {
       (dir * -GlobFilter(DefaultTargetName)).get.nonEmpty
     }
   def noPlugins(dir: File, config: LoadBuildConfiguration): LoadedPlugins =
-    loadPluginDefinition(dir, config, PluginData(config.globalPluginClasspath, None, None))
+    loadPluginDefinition(dir, config, PluginData(config.globalPluginClasspath, Nil, None, None, Nil))
   def buildPlugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins =
     loadPluginDefinition(dir, config, buildPluginDefinition(dir, s, config))
 
diff --git a/main/src/main/scala/sbt/internal/PluginsDebug.scala b/main/src/main/scala/sbt/internal/PluginsDebug.scala
index 77d44ca3b..5d9551356 100644
--- a/main/src/main/scala/sbt/internal/PluginsDebug.scala
+++ b/main/src/main/scala/sbt/internal/PluginsDebug.scala
@@ -39,7 +39,7 @@ private[sbt] class PluginsDebug(val available: List[AutoPlugin], val nameToKey:
       if(possible.nonEmpty) {
         val explained = possible.map(explainPluginEnable)
         val possibleString =
-          if(explained.size > 1) explained.zipWithIndex.map{case (s,i) => s"$i. $s"}.mkString("Multiple plugins are available that can provide $notFoundKey:\n", "\n", "")
+          if(explained.size > 1) explained.zipWithIndex.map{case (s,i) => s"$i. $s"}.mkString(s"Multiple plugins are available that can provide $notFoundKey:\n", "\n", "")
           else s"$notFoundKey is provided by an available (but not activated) plugin:\n${explained.mkString}"
         def impossiblePlugins = impossible.map(_.plugin.label).mkString(", ")
         val imPostfix = if(impossible.isEmpty) "" else s"\n\nThere are other available plugins that provide $notFoundKey, but they are impossible to add: $impossiblePlugins"
diff --git a/main/src/main/scala/sbt/internal/SessionSettings.scala b/main/src/main/scala/sbt/internal/SessionSettings.scala
index 9ad788620..2d036bddf 100755
--- a/main/src/main/scala/sbt/internal/SessionSettings.scala
+++ b/main/src/main/scala/sbt/internal/SessionSettings.scala
@@ -135,7 +135,6 @@ object SessionSettings {
       oldState.log.warn("Discarding " + pluralize(oldSettings.size, " session setting") + ".  Use 'session save' to persist session settings.")
   }
 
-  @deprecated("This method will no longer be public", "0.13.7")
   def removeRanges[T](in: Seq[T], ranges: Seq[(Int, Int)]): Seq[T] = {
     val asSet = (Set.empty[Int] /: ranges) { case (s, (hi, lo)) => s ++ (hi to lo) }
     in.zipWithIndex.flatMap { case (t, index) => if (asSet(index + 1)) Nil else t :: Nil }
@@ -181,7 +180,6 @@ object SessionSettings {
       reapply(newSession.copy(original = newSession.mergeSettings, append = Map.empty), s)
     }
 
-  @deprecated("This method will no longer be public", "0.13.7")
   def writeSettings(pref: ProjectRef, settings: List[SessionSetting], original: Seq[Setting[_]], structure: BuildStructure): (Seq[SessionSetting], Seq[Setting[_]]) = {
     val project = Project.getProject(pref, structure).getOrElse(sys.error("Invalid project reference " + pref))
     val writeTo: File = BuildPaths.configurationSources(project.base).headOption.getOrElse(new File(project.base, "build.sbt"))
@@ -222,7 +220,6 @@ object SessionSettings {
     (newWithPos.reverse, other ++ oldShifted)
   }
 
-  @deprecated("This method will no longer be public", "0.13.7")
   def needsTrailingBlank(lines: Seq[String]) = lines.nonEmpty && !lines.takeRight(1).exists(_.trim.isEmpty)
 
   /** Prints all the user-defined SessionSettings (not raw) to System.out. */
diff --git a/main/src/main/scala/sbt/plugins/JvmPlugin.scala b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
index 953bf2682..e34dc835d 100644
--- a/main/src/main/scala/sbt/plugins/JvmPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/JvmPlugin.scala
@@ -27,8 +27,7 @@ object JvmPlugin extends AutoPlugin {
     Defaults.paths ++
     Classpaths.jvmPublishSettings ++
     Classpaths.jvmBaseSettings ++
-    Defaults.projectTasks ++
-    Defaults.packageBase ++
+    Defaults.baseTasks ++
     Defaults.compileBase ++
     Defaults.defaultConfigs
   override lazy val globalSettings: Seq[Setting[_]] =