From 6ad545efea9af96fa656c946de8f5716df042ba4 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 14 Oct 2016 14:12:37 -0400 Subject: [PATCH 1/4] Move deprecation warnings to macro body Ref #2783 --- .../src/main/scala/sbt/Structure.scala | 12 ----- .../src/main/scala/sbt/std/TaskMacro.scala | 46 +++++++++++++++---- 2 files changed, 36 insertions(+), 22 deletions(-) diff --git a/main/settings/src/main/scala/sbt/Structure.scala b/main/settings/src/main/scala/sbt/Structure.scala index 9483dc37b..56e08e2d2 100644 --- a/main/settings/src/main/scala/sbt/Structure.scala +++ b/main/settings/src/main/scala/sbt/Structure.scala @@ -40,9 +40,7 @@ sealed abstract class SettingKey[T] extends ScopedTaskable[T] with KeyedInitiali final def :=(v: T): Setting[T] = macro std.TaskMacro.settingAssignMacroImpl[T] final def +=[U](v: U)(implicit a: Append.Value[T, U]): Setting[T] = macro std.TaskMacro.settingAppend1Impl[T, U] final def ++=[U](vs: U)(implicit a: Append.Values[T, U]): Setting[T] = macro std.TaskMacro.settingAppendNImpl[T, U] - @deprecated("Use `lhs += { x.value }`", "0.13.13") final def <+=[V](v: Initialize[V])(implicit a: Append.Value[T, V]): Setting[T] = macro std.TaskMacro.settingAppend1Position[T, V] - @deprecated("Use `lhs ++= { x.value }`", "0.13.13") final def <++=[V](vs: Initialize[V])(implicit a: Append.Values[T, V]): Setting[T] = macro std.TaskMacro.settingAppendNPosition[T, V] final def -=[U](v: U)(implicit r: Remove.Value[T, U]): Setting[T] = macro std.TaskMacro.settingRemove1Impl[T, U] final def --=[U](vs: U)(implicit r: Remove.Values[T, U]): Setting[T] = macro std.TaskMacro.settingRemoveNImpl[T, U] @@ -73,9 +71,7 @@ sealed abstract class TaskKey[T] extends ScopedTaskable[T] with KeyedInitialize[ def +=[U](v: U)(implicit a: Append.Value[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskAppend1Impl[T, U] def ++=[U](vs: U)(implicit a: Append.Values[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskAppendNImpl[T, U] - @deprecated("Use `lhs += { x.value }`", "0.13.13") def <+=[V](v: Initialize[Task[V]])(implicit a: Append.Value[T, V]): Setting[Task[T]] = macro std.TaskMacro.taskAppend1Position[T, V] - @deprecated("Use `lhs ++= { x.value }`", "0.13.13") def <++=[V](vs: Initialize[Task[V]])(implicit a: Append.Values[T, V]): Setting[Task[T]] = macro std.TaskMacro.taskAppendNPosition[T, V] final def -=[U](v: U)(implicit r: Remove.Value[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskRemove1Impl[T, U] final def --=[U](vs: U)(implicit r: Remove.Values[T, U]): Setting[Task[T]] = macro std.TaskMacro.taskRemoveNImpl[T, U] @@ -157,10 +153,6 @@ object Scoped { * @param app value to bind to this key * @return setting binding this key to the given value. */ - @deprecated("""Use `key := { x.value }` or `key ~= (old => { newValue })`. - |The RHS of `<<=` takes an `Initialize[_]` expression, which can be converted to `:=` style - |by wrapping the expression in parenthesis, and calling `.value` at the end. - |For example, `key := (key.dependsOn(compile in Test)).value`.""".stripMargin, "0.13.13") final def <<=(app: Initialize[S]): Setting[S] = macro std.TaskMacro.settingAssignPosition[S] /** Internally used function for setting a value along with the `.sbt` file location where it is defined. */ @@ -207,10 +199,6 @@ object Scoped { def :=(v: S): Setting[Task[S]] = macro std.TaskMacro.taskAssignMacroImpl[S] def ~=(f: S => S): Setting[Task[S]] = macro std.TaskMacro.taskTransformPosition[S] - @deprecated("""Use `key := { x.value }` or `key ~= (old => { newValue })`. - |The RHS of `<<=` takes an `Initialize[_]` expression, which can be converted to `:=` style - |by wrapping the expression in parenthesis, and calling `.value` at the end. - |For example, `key := (key.dependsOn(compile in Test)).value`.""".stripMargin, "0.13.13") def <<=(app: Initialize[Task[S]]): Setting[Task[S]] = macro std.TaskMacro.itaskAssignPosition[S] def set(app: Initialize[Task[S]], source: SourcePosition): Setting[Task[S]] = Def.setting(scopedKey, app, source) def transform(f: S => S, source: SourcePosition): Setting[Task[S]] = set(scopedKey(_ map f), source) diff --git a/main/settings/src/main/scala/sbt/std/TaskMacro.scala b/main/settings/src/main/scala/sbt/std/TaskMacro.scala index 770eea263..b1a346b5c 100644 --- a/main/settings/src/main/scala/sbt/std/TaskMacro.scala +++ b/main/settings/src/main/scala/sbt/std/TaskMacro.scala @@ -72,6 +72,13 @@ object TaskMacro { final val TransformInitName = "transform" final val InputTaskCreateDynName = "createDyn" final val InputTaskCreateFreeName = "createFree" + final val append1Migration = "Use `lhs += { x.value }`." + final val appendNMigration = "Use `lhs ++= { x.value }`." + final val assignMigration = + """Use `key := { x.value }` or `key ~= (old => { newValue })`. + |The RHS of `<<=` takes an `Initialize[_]` expression, which can be converted to `:=` style + |by wrapping the expression in parenthesis, and calling `.value` at the end. + |For example, `key := (key.dependsOn(compile in Test)).value`.""".stripMargin def taskMacroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Initialize[Task[T]]] = Instance.contImpl[T, Id](c, FullInstance, FullConvert, MixedBuilder)(Left(t), Instance.idTransform[c.type]) @@ -97,9 +104,14 @@ object TaskMacro { /* Implementations of <<= macro variations for tasks and settings. These just get the source position of the call site.*/ def itaskAssignPosition[T: c.WeakTypeTag](c: Context)(app: c.Expr[Initialize[Task[T]]]): c.Expr[Setting[Task[T]]] = - settingAssignPosition(c)(app) + { + c.warning(c.macroApplication.pos, assignMigration) + settingAssignPosition(c)(app) + } + private def itaskAssignPosition0[T: c.WeakTypeTag](c: Context)(app: c.Expr[Initialize[Task[T]]]): c.Expr[Setting[Task[T]]] = + settingAssignPosition0(c)(app) def taskAssignPositionT[T: c.WeakTypeTag](c: Context)(app: c.Expr[Task[T]]): c.Expr[Setting[Task[T]]] = - itaskAssignPosition(c)(c.universe.reify { Def.valueStrict(app.splice) }) + itaskAssignPosition0(c)(c.universe.reify { Def.valueStrict(app.splice) }) def taskAssignPositionPure[T: c.WeakTypeTag](c: Context)(app: c.Expr[T]): c.Expr[Setting[Task[T]]] = taskAssignPositionT(c)(c.universe.reify { TaskExtra.constant(app.splice) }) @@ -111,20 +123,34 @@ object TaskMacro { c.Expr[Setting[S]](transformMacroImpl(c)(f.tree)(TransformInitName)) def taskAppendNPosition[S: c.WeakTypeTag, V: c.WeakTypeTag](c: Context)(vs: c.Expr[Initialize[Task[V]]])(a: c.Expr[Append.Values[S, V]]): c.Expr[Setting[Task[S]]] = - c.Expr[Setting[Task[S]]](appendMacroImpl(c)(vs.tree, a.tree)(AppendNInitName)) - + { + c.warning(c.macroApplication.pos, appendNMigration) + c.Expr[Setting[Task[S]]](appendMacroImpl(c)(vs.tree, a.tree)(AppendNInitName)) + } def settingAppendNPosition[S: c.WeakTypeTag, V: c.WeakTypeTag](c: Context)(vs: c.Expr[Initialize[V]])(a: c.Expr[Append.Values[S, V]]): c.Expr[Setting[S]] = - c.Expr[Setting[S]](appendMacroImpl(c)(vs.tree, a.tree)(AppendNInitName)) - + { + c.warning(c.macroApplication.pos, appendNMigration) + c.Expr[Setting[S]](appendMacroImpl(c)(vs.tree, a.tree)(AppendNInitName)) + } def taskAppend1Position[S: c.WeakTypeTag, V: c.WeakTypeTag](c: Context)(v: c.Expr[Initialize[Task[V]]])(a: c.Expr[Append.Value[S, V]]): c.Expr[Setting[Task[S]]] = - c.Expr[Setting[Task[S]]](appendMacroImpl(c)(v.tree, a.tree)(Append1InitName)) + { + c.warning(c.macroApplication.pos, append1Migration) + c.Expr[Setting[Task[S]]](appendMacroImpl(c)(v.tree, a.tree)(Append1InitName)) + } def settingAppend1Position[S: c.WeakTypeTag, V: c.WeakTypeTag](c: Context)(v: c.Expr[Initialize[V]])(a: c.Expr[Append.Value[S, V]]): c.Expr[Setting[S]] = - c.Expr[Setting[S]](appendMacroImpl(c)(v.tree, a.tree)(Append1InitName)) - + { + c.warning(c.macroApplication.pos, append1Migration) + c.Expr[Setting[S]](appendMacroImpl(c)(v.tree, a.tree)(Append1InitName)) + } def settingAssignPure[T: c.WeakTypeTag](c: Context)(app: c.Expr[T]): c.Expr[Setting[T]] = - settingAssignPosition(c)(c.universe.reify { Def.valueStrict(app.splice) }) + settingAssignPosition0(c)(c.universe.reify { Def.valueStrict(app.splice) }) def settingAssignPosition[T: c.WeakTypeTag](c: Context)(app: c.Expr[Initialize[T]]): c.Expr[Setting[T]] = + { + c.warning(c.macroApplication.pos, assignMigration) + settingAssignPosition0[T](c)(app) + } + private def settingAssignPosition0[T: c.WeakTypeTag](c: Context)(app: c.Expr[Initialize[T]]): c.Expr[Setting[T]] = c.Expr[Setting[T]](transformMacroImpl(c)(app.tree)(AssignInitName)) /** Implementation of := macro for tasks. */ From 81284081e2df2aa5a47f3d59cb4234f9d072e728 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 14 Oct 2016 14:15:05 -0400 Subject: [PATCH 2/4] Use non-deprecated constructor --- main/src/main/scala/sbt/Load.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/src/main/scala/sbt/Load.scala b/main/src/main/scala/sbt/Load.scala index cdad4edcb..149c25aa6 100755 --- a/main/src/main/scala/sbt/Load.scala +++ b/main/src/main/scala/sbt/Load.scala @@ -847,7 +847,7 @@ object Load { (dir * -GlobFilter(DefaultTargetName)).get.nonEmpty } def noPlugins(dir: File, config: sbt.LoadBuildConfiguration): sbt.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: sbt.LoadBuildConfiguration): sbt.LoadedPlugins = loadPluginDefinition(dir, config, buildPluginDefinition(dir, s, config)) From cfac453c07d4ffe68bb831f3e5964f796546ef63 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 14 Oct 2016 14:19:53 -0400 Subject: [PATCH 3/4] Add "-deprecattion" flag to metabuild Fixes #2783 Ref #2716 `build.sbt` is treated a Scala source of metabuild, so to enable deprecation flag on build.sbt we set the option here. --- main/src/main/scala/sbt/Defaults.scala | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 6280d16d3..101bfca7f 100755 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -1009,7 +1009,7 @@ object Defaults extends BuildCommon { 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 configSettings: Seq[Setting[_]] = Classpaths.configSettings ++ configTasks ++ configPaths ++ packageConfig ++ Classpaths.compilerPluginConfig ++ deprecationSettings lazy val compileSettings: Seq[Setting[_]] = configSettings ++ (mainRunMainTask +: mainRunTask +: addBaseSources) ++ Classpaths.addUnmanagedLibrary lazy val testSettings: Seq[Setting[_]] = configSettings ++ testTasks @@ -1028,6 +1028,17 @@ object Defaults extends BuildCommon { baseDirectory := thisProject.value.base, target := baseDirectory.value / "target" ) + // build.sbt is treated a Scala source of metabuild, so to enable deprecation flag on build.sbt we set the option here. + lazy val deprecationSettings: Seq[Setting[_]] = + inConfig(Compile)(Seq( + scalacOptions := { + val old = scalacOptions.value + val existing = old.toSet + val d = "-deprecation" + if (sbtPlugin.value && !existing(d)) d :: old.toList + else old + } + )) @deprecated("Default settings split into coreDefaultSettings and IvyModule/JvmModule plugins.", "0.13.2") lazy val defaultSettings: Seq[Setting[_]] = projectBaseSettings ++ defaultConfigs From 620a49bb0c31d07346eb6a7f5bb4453bb052ffc3 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 14 Oct 2016 14:21:29 -0400 Subject: [PATCH 4/4] Improve deprecation message --- main/settings/src/main/scala/sbt/std/TaskMacro.scala | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/main/settings/src/main/scala/sbt/std/TaskMacro.scala b/main/settings/src/main/scala/sbt/std/TaskMacro.scala index b1a346b5c..6c48613dd 100644 --- a/main/settings/src/main/scala/sbt/std/TaskMacro.scala +++ b/main/settings/src/main/scala/sbt/std/TaskMacro.scala @@ -72,13 +72,11 @@ object TaskMacro { final val TransformInitName = "transform" final val InputTaskCreateDynName = "createDyn" final val InputTaskCreateFreeName = "createFree" - final val append1Migration = "Use `lhs += { x.value }`." - final val appendNMigration = "Use `lhs ++= { x.value }`." + final val append1Migration = "`<+=` operator is deprecated. Use `lhs += { x.value }`." + final val appendNMigration = "`<++=` operator is deprecated. Use `lhs ++= { x.value }`." final val assignMigration = - """Use `key := { x.value }` or `key ~= (old => { newValue })`. - |The RHS of `<<=` takes an `Initialize[_]` expression, which can be converted to `:=` style - |by wrapping the expression in parenthesis, and calling `.value` at the end. - |For example, `key := (key.dependsOn(compile in Test)).value`.""".stripMargin + """`<<=` operator is deprecated. Use `key := { x.value }` or `key ~= (old => { newValue })`. + |See http://www.scala-sbt.org/0.13/docs/Migrating-from-sbt-012x.html""".stripMargin def taskMacroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Initialize[Task[T]]] = Instance.contImpl[T, Id](c, FullInstance, FullConvert, MixedBuilder)(Left(t), Instance.idTransform[c.type])