From 37f793be6e71d3eca4c93fdf2b626d46389a46b2 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Tue, 8 Mar 2011 17:50:19 -0500 Subject: [PATCH 1/2] make ClasspathOptions configurable --- compile/ClasspathOptions.scala | 11 +++++++++++ compile/CompilerArguments.scala | 8 +------- main/Defaults.scala | 3 ++- main/Keys.scala | 1 + 4 files changed, 15 insertions(+), 8 deletions(-) create mode 100644 compile/ClasspathOptions.scala diff --git a/compile/ClasspathOptions.scala b/compile/ClasspathOptions.scala new file mode 100644 index 000000000..bd649b325 --- /dev/null +++ b/compile/ClasspathOptions.scala @@ -0,0 +1,11 @@ +/* sbt -- Simple Build Tool + * Copyright 2009, 2010 Mark Harrah + */ +package sbt + +final case class ClasspathOptions(autoBoot: Boolean, compiler: Boolean, extra: Boolean) +object ClasspathOptions +{ + def manual = ClasspathOptions(false, false, false) + def auto = ClasspathOptions(true, true, true) +} \ No newline at end of file diff --git a/compile/CompilerArguments.scala b/compile/CompilerArguments.scala index 809a7f27d..445d56d7e 100644 --- a/compile/CompilerArguments.scala +++ b/compile/CompilerArguments.scala @@ -12,7 +12,7 @@ package compiler * order to add these jars to the boot classpath. The 'scala.home' property must be unset because Scala * puts jars in that directory on the bootclasspath. Because we use multiple Scala versions, * this would lead to compiling against the wrong library jar.*/ -class CompilerArguments(scalaInstance: ScalaInstance, cp: ClasspathOptions) extends NotNull +final class CompilerArguments(scalaInstance: ScalaInstance, cp: ClasspathOptions) { def apply(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String]): Seq[String] = { @@ -41,12 +41,6 @@ class CompilerArguments(scalaInstance: ScalaInstance, cp: ClasspathOptions) exte def bootClasspathOption = if(cp.autoBoot) Seq("-bootclasspath", createBootClasspath) else Nil def bootClasspath = if(cp.autoBoot) sbt.IO.pathSplit(createBootClasspath).map(new File(_)).toSeq else Nil } -class ClasspathOptions(val autoBoot: Boolean, val compiler: Boolean, val extra: Boolean) extends NotNull -object ClasspathOptions -{ - def manual = new ClasspathOptions(false, false, false) - def auto = new ClasspathOptions(true, true, true) -} object CompilerArguments { def abs(files: Seq[File]): Seq[String] = files.map(_.getAbsolutePath) diff --git a/main/Defaults.scala b/main/Defaults.scala index 73229a09a..80f5e6099 100755 --- a/main/Defaults.scala +++ b/main/Defaults.scala @@ -106,7 +106,8 @@ object Defaults ) def compileBase = Seq( - compilers <<= (scalaInstance, appConfiguration, streams) map { (si, app, s) => Compiler.compilers(si)(app, s.log) }, + classpathOptions in GlobalScope :== ClasspathOptions.auto, + compilers <<= (scalaInstance, appConfiguration, streams, classpathOptions) map { (si, app, s, co) => Compiler.compilers(si, co)(app, s.log) }, javacOptions in GlobalScope :== Nil, scalacOptions in GlobalScope :== Nil, scalaInstance <<= (appConfiguration, scalaVersion){ (app, version) => ScalaInstance(version, app.provider.scalaProvider.launcher) }, diff --git a/main/Keys.scala b/main/Keys.scala index b88709038..541b113cd 100644 --- a/main/Keys.scala +++ b/main/Keys.scala @@ -68,6 +68,7 @@ object Keys val compileInputs = TaskKey[Compiler.Inputs]("compile-inputs") val scalaInstance = SettingKey[ScalaInstance]("scala-instance") val scalaVersion = SettingKey[String]("scala-version") + val classpathOptions = SettingKey[ClasspathOptions]("classpath-options") val webappDir = SettingKey[File]("webapp-dir") From 0935fba0b5c72520d3693fb0259ead8ae9cc2c0b Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Tue, 8 Mar 2011 17:51:14 -0500 Subject: [PATCH 2/2] better cycle handling in SameAPI --- compile/api/SameAPI.scala | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/compile/api/SameAPI.scala b/compile/api/SameAPI.scala index dbfc15856..ce226c0de 100644 --- a/compile/api/SameAPI.scala +++ b/compile/api/SameAPI.scala @@ -89,7 +89,7 @@ class SameAPI(tagsA: TypeVars, tagsB: TypeVars, includePrivate: Boolean, include { import SameAPI._ - private val pending = new mutable.HashSet[(Structure, Structure)] + private val pending = new mutable.HashSet[AnyRef] private[this] val debugEnabled = java.lang.Boolean.getBoolean("xsbt.api.debug") def debug(flag: Boolean, msg: => String): Boolean = { @@ -161,11 +161,15 @@ class SameAPI(tagsA: TypeVars, tagsB: TypeVars, includePrivate: Boolean, include /** Checks that the two definitions are the same, other than their name.*/ def sameDefinitionContent(a: Definition, b: Definition): Boolean = + samePending(a,b)(sameDefinitionContentDirect) + def sameDefinitionContentDirect(a: Definition, b: Definition): Boolean = + { //a.name == b.name && debug(sameAccess(a.access, b.access), "Access differed") && debug(sameModifiers(a.modifiers, b.modifiers), "Modifiers differed") && debug(sameAnnotations(a.annotations, b.annotations), "Annotations differed") && debug(sameDefinitionSpecificAPI(a, b), "Definition-specific differed") + } def sameAccess(a: Access, b: Access): Boolean = (a, b) match @@ -301,6 +305,8 @@ class SameAPI(tagsA: TypeVars, tagsB: TypeVars, includePrivate: Boolean, include } def sameType(a: Type, b: Type): Boolean = + samePending(a,b)(sameTypeDirect) + def sameTypeDirect(a: Type, b: Type): Boolean = (a, b) match { case (sa: SimpleType, sb: SimpleType) => debug(sameSimpleType(sa, sb), "Different simple types: " + DefaultShowAPI(sa) + " and " + DefaultShowAPI(sb)) @@ -325,11 +331,10 @@ class SameAPI(tagsA: TypeVars, tagsB: TypeVars, includePrivate: Boolean, include sameSimpleType(a.baseType, b.baseType) && sameAnnotations(a.annotations, b.annotations) def sameStructure(a: Structure, b: Structure): Boolean = - if(pending add ((a,b)) ) - try { sameStructureDirect(a,b) } - finally { pending -= ((a,b)) } - else - true + samePending(a,b)(sameStructureDirect) + private[this] def samePending[T](a: T, b: T)(f: (T,T) => Boolean): Boolean = + if(pending add ((a,b)) ) f(a,b) else true + def sameStructureDirect(a: Structure, b: Structure): Boolean = sameSeq(a.parents, b.parents)(sameType) && sameMembers(a.declared, b.declared) &&