support explicitly defining sequences of settings in .sbt files

main/Build.scala

@@ -62,20 +62,21 @@ object EvaluateConfigurations
 	def evaluateConfiguration(eval: Eval, name: String, lines: Seq[String], imports: Seq[String], offset: Int): Seq[Setting[_]] =
 	{
 		val (importExpressions, settingExpressions) = splitExpressions(lines)
-		for((settingExpression,line) <- addOffset(offset, settingExpressions)) yield
+		addOffset(offset, settingExpressions) flatMap { case (settingExpression,line) =>
 			evaluateSetting(eval, name, (imports.map(s => (s, -1)) ++ addOffset(offset, importExpressions)), settingExpression, line)
+		}
 	}
 	def addOffset(offset: Int, lines: Seq[(String,Int)]): Seq[(String,Int)] =
 		lines.map { case (s, i) => (s, i + offset) }
 
-	def evaluateSetting(eval: Eval, name: String, imports: Seq[(String,Int)], expression: String, line: Int): Setting[_] =
+	def evaluateSetting(eval: Eval, name: String, imports: Seq[(String,Int)], expression: String, line: Int): Seq[Setting[_]] =
 	{
 		val result = try {
-			eval.eval(expression, imports = new EvalImports(imports, name), srcName = name, tpeName = Some("sbt.Project.Setting[_]"), line = line)
+			eval.eval(expression, imports = new EvalImports(imports, name), srcName = name, tpeName = Some("sbt.Project.SettingsDefinition"), line = line)
 		} catch {
 			case e: sbt.compiler.EvalException => throw new MessageOnlyException(e.getMessage)
 		}
-		result.value.asInstanceOf[Setting[_]]
+		result.value.asInstanceOf[Project.SettingsDefinition].settings
 	}
 	private[this] def fstS(f: String => Boolean): ((String,Int)) => Boolean = { case (s,i) => f(s.trim) }
 	def splitExpressions(lines: Seq[String]): (Seq[(String,Int)], Seq[(String,Int)]) =

main/Main.scala

@@ -236,8 +236,8 @@ object BuiltinCommands
 	def set = Command.single(SetCommand, setBrief, setDetailed) { (s, arg) =>
 		val extracted = Project extract s
 		import extracted._
-		val setting = EvaluateConfigurations.evaluateSetting(session.currentEval(), "<set>", imports(extracted), arg, 0)
+		val settings = EvaluateConfigurations.evaluateSetting(session.currentEval(), "<set>", imports(extracted), arg, 0)
-		val append = Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, setting :: Nil)
+		val append = Load.transformSettings(Load.projectScope(currentRef), currentRef.build, rootProject, settings)
 		val newSession = session.appendSettings( append map (a => (a, arg)))
 		reapply(newSession, structure, s)
 	}

sbt/package.scala

@@ -6,8 +6,10 @@ package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtr
 {
 	type Setting[T] = Project.Setting[T]
 	type ScopedKey[T] = Project.ScopedKey[T]
+	type SettingsDefinition = Project.SettingsDefinition
 	type File = java.io.File
 	type URI = java.net.URI
+
 	implicit def maybeToOption[S](m: xsbti.Maybe[S]): Option[S] =
 		if(m.isDefined) Some(m.get) else None
 	def uri(s: String): URI = new URI(s)
@@ -33,4 +35,8 @@ package object sbt extends sbt.std.TaskExtra with sbt.Types with sbt.ProcessExtr
 	{
 		def files: Seq[File] = Build data s
 	}
+
+	def all(settings: Seq[Setting[_]]): SettingsDefinition = new Project.SettingList(settings)
+	def seq(settings: Setting[_]*): SettingsDefinition = all(settings)
+	implicit def settingsDefinitionToSeq(sd: SettingsDefinition): Seq[Setting[_]] = sd.settings
 }

util/collection/Settings.scala

@@ -179,8 +179,13 @@ trait Init[Scope]
 				case Seq(x, xs @ _*) => (join(xs) zipWith x)( (t,h) => h +: t)
 			}
 	}
-	final class Setting[T](val key: ScopedKey[T], val init: Initialize[T])
+	sealed trait SettingsDefinition {
+		def settings: Seq[Setting[_]]
+	}
+	final class SettingList(val settings: Seq[Setting[_]]) extends SettingsDefinition
+	final class Setting[T](val key: ScopedKey[T], val init: Initialize[T]) extends SettingsDefinition
 	{
+		def settings = this :: Nil
 		def definitive: Boolean = !init.dependsOn.contains(key)
 		def dependsOn: Seq[ScopedKey[_]] = remove(init.dependsOn, key)
 		def mapReferenced(g: MapScoped): Setting[T] = new Setting(key, init mapReferenced g)