Merge branch '0.13' into follow-deprecation

util/appmacro/src/main/scala/sbt/appmacro/ContextUtil.scala

@@ -32,12 +32,16 @@ object ContextUtil {
 	def unexpectedTree[C <: Context](tree: C#Tree): Nothing = sys.error("Unexpected macro application tree (" + tree.getClass + "): " + tree)
 }
 
+// TODO 2.11 Remove this after dropping 2.10.x support.
+private object HasCompat { val compat = ??? }; import HasCompat._
+
 /** Utility methods for macros.  Several methods assume that the context's universe is a full compiler (`scala.tools.nsc.Global`).
 * This is not thread safe due to the underlying Context and related data structures not being thread safe.
 * Use `ContextUtil[c.type](c)` to construct. */
 final class ContextUtil[C <: Context](val ctx: C)
 {
 		import ctx.universe.{Apply=>ApplyTree,_}
+		import compat._
 
 	val powerContext = ctx.asInstanceOf[reflect.macros.runtime.Context]
 	val global: powerContext.universe.type = powerContext.universe
@@ -222,17 +226,20 @@ final class ContextUtil[C <: Context](val ctx: C)
 		object appTransformer extends Transformer
 		{
 			override def transform(tree: Tree): Tree =
-				tree match
-				{
-					case ApplyTree(TypeApply(Select(_, nme), targ :: Nil), qual :: Nil) => subWrapper(nme.decoded, targ.tpe, qual, tree) match {
-						case Converted.Success(t, finalTx) => finalTx(t)
-						case Converted.Failure(p,m) => ctx.abort(p, m)
-						case _: Converted.NotApplicable[_] => super.transform(tree)
-					}
+				tree match {
+					case ApplyTree(TypeApply(Select(_, nme), targ :: Nil), qual :: Nil) =>
+						subWrapper(nme.decoded, targ.tpe, qual, tree) match {
+							case Converted.Success(t, finalTx) =>
+								changeOwner(qual, currentOwner, initialOwner) // Fixes https://github.com/sbt/sbt/issues/1150
+								finalTx(t)
+							case Converted.Failure(p,m) => ctx.abort(p, m)
+							case _: Converted.NotApplicable[_] => super.transform(tree)
+						}
 					case _ => super.transform(tree)
 				}
 		}
-
-		appTransformer.transform(t)
+		appTransformer.atOwner(initialOwner) {
+			appTransformer.transform(t)
+		}
 	}
-}
+}

util/appmacro/src/main/scala/sbt/appmacro/Instance.scala

@@ -167,7 +167,7 @@ object Instance
 		def addType(tpe: Type, qual: Tree, selection: Tree): Tree =
 		{
 			qual.foreach(checkQual)
-			val vd = util.freshValDef(tpe, qual.symbol.pos, functionSym)
+			val vd = util.freshValDef(tpe, qual.pos, functionSym)
 			inputs ::= new Input(tpe, qual, vd)
 			util.refVal(selection, vd)
 		}

util/appmacro/src/main/scala/sbt/appmacro/KListBuilder.scala

@@ -9,11 +9,15 @@ package appmacro
 /** A `TupleBuilder` that uses a KList as the tuple representation.*/
 object KListBuilder extends TupleBuilder
 {
+	// TODO 2.11 Remove this after dropping 2.10.x support.
+	private object HasCompat { val compat = ??? }; import HasCompat._
+
 	def make(c: Context)(mt: c.Type, inputs: Inputs[c.universe.type]): BuilderResult[c.type] = new BuilderResult[c.type]
 	{
 		val ctx: c.type = c
 		val util = ContextUtil[c.type](c)
 			import c.universe.{Apply=>ApplyTree,_}
+			import compat._
 			import util._
 
 		val knilType = c.typeOf[KNil]
@@ -24,7 +28,7 @@ object KListBuilder extends TupleBuilder
 		val kconsTC: Type = kconsTpe.typeConstructor
 
 		/** This is the L in the type function [L[x]] ...  */
-		val tcVariable: TypeSymbol = newTCVariable(NoSymbol)
+		val tcVariable: TypeSymbol = newTCVariable(util.initialOwner)
 
 		/** Instantiates KCons[h, t <: KList[L], L], where L is the type constructor variable */
 		def kconsType(h: Type, t: Type): Type =
@@ -65,4 +69,4 @@ object KListBuilder extends TupleBuilder
 		val alistInstance: ctx.universe.Tree = TypeApply(select(Ident(alist), "klist"), TypeTree(representationC) :: Nil)
 		def extract(param: ValDef) = bindKList(param, Nil, inputs.map(_.local))
 	}
-}
+}

util/appmacro/src/main/scala/sbt/appmacro/TupleNBuilder.scala

@@ -14,10 +14,14 @@ object TupleNBuilder extends TupleBuilder
 	final val MaxInputs = 11
 	final val TupleMethodName = "tuple"
 
+	// TODO 2.11 Remove this after dropping 2.10.x support.
+	private object HasCompat { val compat = ??? }; import HasCompat._
+
 	def make(c: Context)(mt: c.Type, inputs: Inputs[c.universe.type]): BuilderResult[c.type] = new BuilderResult[c.type]
 	{
 		val util = ContextUtil[c.type](c)
 			import c.universe.{Apply=>ApplyTree,_}
+			import compat._
 			import util._
 
 		val global: Global = c.universe.asInstanceOf[Global]
@@ -25,7 +29,7 @@ object TupleNBuilder extends TupleBuilder
 
 		val ctx: c.type = c
 		val representationC: PolyType = {
-			val tcVariable: Symbol = newTCVariable(NoSymbol)
+			val tcVariable: Symbol = newTCVariable(util.initialOwner)
 			val tupleTypeArgs = inputs.map(in => typeRef(NoPrefix, tcVariable, in.tpe :: Nil).asInstanceOf[global.Type])
 			val tuple = global.definitions.tupleType(tupleTypeArgs)
 			PolyType(tcVariable :: Nil, tuple.asInstanceOf[Type] )