/* sbt -- Simple Build Tool
 * Copyright 2008, 2009 Mark Harrah
 */
package sbt

trait trait Conditional[Source, Product, External] extends java.lang.Object with NotNull with ScalaObjectConditional[>: Nothing <: AnySource, >: Nothing <: AnyProduct, >: Nothing <: AnyExternal] extends NotNullNotNull
{
	type >: Nothing <: sbt.TaskAnalysis[Source,Product,External]AnalysisType <: TaskAnalysis[Source, Product, External]
	val Conditional.this.AnalysisTypeanalysis: Conditional.this.AnalysisTypeAnalysisType = => Conditional.this.AnalysisTypeloadAnalysis
	
	protected def => Conditional.this.AnalysisTypeloadAnalysis: Conditional.this.AnalysisTypeAnalysisType
	protected def => sbt.Loggerlog: sbt.LoggerLogger

	protected def => StringproductType: StringString
	protected def => StringproductTypePlural: StringString
	
	protected def => Iterable[Source]sourcesToProcess: Iterable[Source]Iterable[Source]
	
	protected def (Source)BooleansourceExists(Sourcesource: SourceSource): BooleanBoolean
	protected def (Source)LongsourceLastModified(Sourcesource: SourceSource): LongLong
	
	protected def (Product)BooleanproductExists(Productproduct: ProductProduct): BooleanBoolean
	protected def (Product)LongproductLastModified(Productproduct: ProductProduct): LongLong
	
	protected def (Iterable[External])Iterable[(External, Conditional.this.ExternalInfo)]externalInfo(Iterable[External]externals: Iterable[External]Iterable[External]): Iterable[(External, Conditional.this.ExternalInfo)]Iterable[(External, ExternalInfo)]
	
	protected def (Conditional.this.ConditionalAnalysis)Option[String]execute(Conditional.this.ConditionalAnalysiscAnalysis: Conditional.this.ConditionalAnalysisConditionalAnalysis): Option[String]Option[String]
	
	final case class class ExternalInfo extends java.lang.Object with NotNull with ScalaObject with ProductExternalInfo(Booleanavailable: BooleanBoolean, LonglastModified: LongLong) extends NotNullNotNull
	trait trait ConditionalAnalysis extends java.lang.Object with NotNullConditionalAnalysis extends NotNullNotNull
	{
		def => Iterable[Source]dirtySources: Iterable[Source]Iterable[Source]
		def => Iterable[Source]cleanSources: Iterable[Source]Iterable[Source]
		def => IntdirectlyModifiedSourcesCount: IntInt
		def => IntinvalidatedSourcesCount: IntInt
		def => IntremovedSourcesCount: IntInt
	}
	
	final def => Option[String]run =
	{
		val Option[String]result = (Conditional.this.ConditionalAnalysis)Option[String]execute(=> <refinement> extends java.lang.Object with Conditional.this.ConditionalAnalysisanalyze)
		(Boolean)UnitprocessingComplete(Option[String]result.=> BooleanisEmpty)
		Option[String]result
	}
	private def => <refinement> extends java.lang.Object with Conditional.this.ConditionalAnalysisanalyze =
	{
		import scala.collection.mutable.HashSet
		
		val Iterable[Source]sourcesSnapshot = => Iterable[Source]sourcesToProcess
		val scala.collection.mutable.HashSet[Source]removedSources = scala.collection.mutable.HashSet[Source]new scala.collection.mutable.HashSet[Source]HashSet[Source]
		scala.collection.mutable.HashSet[Source]removedSources (Iterable[Source])Unit++= => Conditional.this.AnalysisTypeanalysis.=> scala.collection.Set[Source]allSources
		scala.collection.mutable.HashSet[Source]removedSources (Iterable[Source])Unit--= Iterable[Source]sourcesSnapshot
		val IntremovedCount = scala.collection.mutable.HashSet[Source]removedSources.=> Intsize
		for(((Source) => Unit)Unitremoved <- scala.collection.mutable.HashSet[Source]removedSources)
			=> Conditional.this.AnalysisTypeanalysis.(Source)UnitremoveDependent(Sourceremoved)
		
		val scala.collection.mutable.HashSet[Source]unmodified = scala.collection.mutable.HashSet[Source]new scala.collection.mutable.HashSet[Source]HashSet[Source]
		val scala.collection.mutable.HashSet[Source]modified = scala.collection.mutable.HashSet[Source]new scala.collection.mutable.HashSet[Source]HashSet[Source]
		
		for(((Source) => Unit)Unitsource <- Iterable[Source]sourcesSnapshot)
		{
			Unitif((Source)BooleanisSourceModified(Sourcesource))
			{
				=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Source ")"Source " (Any)java.lang.String+ Sourcesource (Any)java.lang.String+ java.lang.String(" directly modified.")" directly modified.")
				scala.collection.mutable.HashSet[Source]modified (Source)Unit+= Sourcesource
			}
			else
			{
				=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Source ")"Source " (Any)java.lang.String+ Sourcesource (Any)java.lang.String+ java.lang.String(" unmodified.")" unmodified.")
				scala.collection.mutable.HashSet[Source]unmodified (Source)Unit+= Sourcesource
			}
		}
		val IntdirectlyModifiedCount = scala.collection.mutable.HashSet[Source]modified.=> Intsize
		for((((External, Conditional.this.ExternalInfo)) => Unit)Unit(Externalexternal, Conditional.this.ExternalInfoinfo) <- (Iterable[External])Iterable[(External, Conditional.this.ExternalInfo)]externalInfo(=> Conditional.this.AnalysisTypeanalysis.=> scala.collection.Set[External]allExternals))
		{
			val scala.collection.Set[Source]dependentSources = => Conditional.this.AnalysisTypeanalysis.(External)Option[scala.collection.Set[Source]]externalDependencies(Externalexternal).=> scala.collection.Set[Source]get
			Unitif(Conditional.this.ExternalInfoinfo.=> Booleanavailable)
			{
				val LongdependencyLastModified = Conditional.this.ExternalInfoinfo.=> LonglastModified
				for(((Source) => Unit)UnitdependentSource <- scala.collection.Set[Source]dependentSources; ((scala.collection.Set[Product]) => Unit)UnitdependentProducts <- => Conditional.this.AnalysisTypeanalysis.(Source)Option[scala.collection.Set[Product]]products(SourcedependentSource))
				{
					scala.collection.Set[Product]dependentProducts.((Product) => Boolean)Option[Product]find(Productp => (Product)LongproductLastModified(Productp) (Long)Boolean< LongdependencyLastModified) Unitmatch
					{
						Unitcase Some(ProductmodifiedProduct) =>
						{
							=> sbt.Loggerlog.(=> String)Unitdebug(=> StringproductType (Any)java.lang.String+ java.lang.String(" ")" " (Any)java.lang.String+ ProductmodifiedProduct (Any)java.lang.String+ java.lang.String(" older than external dependency ")" older than external dependency " (Any)java.lang.String+ Externalexternal)
							scala.collection.mutable.HashSet[Source]unmodified (Source)Unit-= SourcedependentSource
							scala.collection.mutable.HashSet[Source]modified (Source)Unit+= SourcedependentSource
						}
						Unitcase object NoneNone => Unit()
					}
				}
			}
			else
			{
				=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("External dependency ")"External dependency " (Any)java.lang.String+ Externalexternal (Any)java.lang.String+ java.lang.String(" not found.")" not found.")
				scala.collection.mutable.HashSet[Source]unmodified (Iterable[Source])Unit--= scala.collection.Set[Source]dependentSources
				scala.collection.mutable.HashSet[Source]modified (Iterable[Source])Unit++= scala.collection.Set[Source]dependentSources
				=> Conditional.this.AnalysisTypeanalysis.(External)UnitremoveExternalDependency(Externalexternal)
			}
		}
		
		val scala.collection.mutable.HashSet[Source]handled = scala.collection.mutable.HashSet[Source]new scala.collection.mutable.scala.collection.mutable.HashSet[Source]HashSet[Source]
		def (Iterable[Source])UnitmarkModified(Iterable[Source]changed: Iterable[Source]Iterable[Source]) { for(((Source) => Unit)Unitc <- Iterable[Source]changed if => Boolean!scala.collection.mutable.HashSet[Source]handled.(Source)Booleancontains(Sourcec)) (Source)UnitmarkSourceModified(Sourcec) }
		def (Source)UnitmarkSourceModified(Sourcesrc: SourceSource)
		{
			scala.collection.mutable.HashSet[Source]unmodified (Source)Unit-= Sourcesrc
			scala.collection.mutable.HashSet[Source]modified (Source)Unit+= Sourcesrc
			scala.collection.mutable.HashSet[Source]handled (Source)Unit+= Sourcesrc
			(Source)UnitmarkDependenciesModified(Sourcesrc)
		}
		def (Source)UnitmarkDependenciesModified(Sourcesrc: SourceSource) { => Conditional.this.AnalysisTypeanalysis.(Source)Option[scala.collection.Set[Source]]removeDependencies(Sourcesrc).((scala.collection.Set[Source]) => Unit)Option[Unit]map((Iterable[Source])UnitmarkModified) }

		(Iterable[Source])UnitmarkModified(scala.collection.mutable.HashSet[Source]modified.=> List[Source]toList)
		scala.collection.mutable.HashSet[Source]removedSources.((Source) => Unit)Unitforeach((Source)UnitmarkDependenciesModified)
		
		for(((Source) => Unit)Unitchanged <- scala.collection.mutable.HashSet[Source]removedSources (Iterable[Source])scala.collection.mutable.Set[Source]++ scala.collection.mutable.HashSet[Source]modified)
			=> Conditional.this.AnalysisTypeanalysis.(Source)UnitremoveSource(Sourcechanged)
		
		template $anon extends java.lang.Object with Conditional.this.ConditionalAnalysisnew Conditional.this.ConditionalAnalysisConditionalAnalysis
		{
			def => scala.collection.Set[Source]dirtySources = scala.collection.mutable.HashSet[Source]modified.=> scala.collection.Set[Source]readOnly
			def => scala.collection.Set[Source]cleanSources = scala.collection.mutable.HashSet[Source]unmodified.=> scala.collection.Set[Source]readOnly
			def => IntdirectlyModifiedSourcesCount = IntdirectlyModifiedCount
			def => IntinvalidatedSourcesCount = => scala.collection.Set[Source]dirtySources.=> Intsize (Int)Int- IntdirectlyModifiedCount
			def => IntremovedSourcesCount = IntremovedCount
			override def ()java.lang.StringtoString =
			{
				java.lang.String("  Source analysis: ")"  Source analysis: " (Any)java.lang.String+ => IntdirectlyModifiedSourcesCount (Any)java.lang.String+ java.lang.String(" new/modified, ")" new/modified, " (Any)java.lang.String+
					=> IntinvalidatedSourcesCount (Any)java.lang.String+ java.lang.String(" indirectly invalidated, ")" indirectly invalidated, " (Any)java.lang.String+
					=> IntremovedSourcesCount (Any)java.lang.String+ java.lang.String(" removed.")" removed."
			}
		}
	}
	
	protected def => BooleancheckLastModified = Boolean(true)true
	protected def => BooleannoProductsImpliesModified = Boolean(true)true
	protected def (Source)BooleanisSourceModified(Sourcesource: SourceSource) =
	{
		=> Conditional.this.AnalysisTypeanalysis.(Source)Option[scala.collection.Set[Product]]products(Sourcesource) Booleanmatch
		{
			Booleancase object NoneNone =>
			{
				=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("New file ")"New file " (Any)java.lang.String+ Sourcesource)
				Boolean(true)true
			}
			Booleancase Some(scala.collection.Set[Product]sourceProducts) =>
			{
				val LongsourceModificationTime = (Source)LongsourceLastModified(Sourcesource)
				def (Product)BooleanisOutofdate(Productp: ProductProduct) =
					=> Boolean!(Product)BooleanproductExists(Productp) (Boolean)Boolean|| (=> BooleancheckLastModified (Boolean)Boolean&& (Product)LongproductLastModified(Productp) (Long)Boolean< LongsourceModificationTime)
				
				scala.collection.Set[Product]sourceProducts.((Product) => Boolean)Option[Product]find((Product)BooleanisOutofdate) Booleanmatch
				{
					Booleancase Some(ProductmodifiedProduct) =>
						=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Outdated ")"Outdated " (Any)java.lang.String+ => StringproductType (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ ProductmodifiedProduct (Any)java.lang.String+ java.lang.String(" for source ")" for source " (Any)java.lang.String+ Sourcesource)
						Boolean(true)true
					Booleancase object NoneNone =>
						Booleanif(=> BooleannoProductsImpliesModified (Boolean)Boolean&& scala.collection.Set[Product]sourceProducts.=> BooleanisEmpty)
						{
							// necessary for change detection that depends on last modified
							=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Source ")"Source " (Any)java.lang.String+ Sourcesource (Any)java.lang.String+ java.lang.String(" has no products, marking it modified.")" has no products, marking it modified.")
							Boolean(true)true
						}
						else
							Boolean(false)false
				}
			}
		}
	}
	protected def (Boolean)UnitprocessingComplete(Booleansuccess: BooleanBoolean)
	{
		Unitif(Booleansuccess)
		{
			=> Conditional.this.AnalysisTypeanalysis.()Option[String]save()
			=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("  Post-analysis: ")"  Post-analysis: " (Any)java.lang.String+ => Conditional.this.AnalysisTypeanalysis.=> scala.collection.Set[Product]allProducts.=> Seq[Product]toSeq.=> Intlength (Any)java.lang.String+ java.lang.String(" ")" " (Any)java.lang.String+ => StringproductTypePlural (Any)java.lang.String+ java.lang.String(".")".")
		}
		else
			=> Conditional.this.AnalysisTypeanalysis.()Option[String]revert()
	}
}

abstract class class CompileConfiguration extends java.lang.Object with NotNull with ScalaObjectCompileConfiguration extends NotNullNotNull
{
	def => Stringlabel: StringString
	def => sbt.PathFindersources: sbt.PathFinderPathFinder
	def => sbt.PathoutputDirectory: sbt.PathPath
	def => sbt.PathFinderclasspath: sbt.PathFinderPathFinder
	def => sbt.PathanalysisPath: sbt.PathPath
	def => sbt.PathprojectPath: sbt.PathPath
	def => sbt.Loggerlog: sbt.LoggerLogger
	def => Seq[String]options: Seq[String]Seq[String]
	def => Iterable[String]testDefinitionClassNames: Iterable[String]Iterable[String]
}
import java.io.File
class class CompileConditional extends java.lang.Object with sbt.Conditional[sbt.Path,sbt.Path,java.io.File] with ScalaObjectCompileConditional(sbt.CompileConfigurationconfig: sbt.CompileConfigurationCompileConfiguration) extends sbt.Conditional[sbt.Path,sbt.Path,java.io.File]Conditional[Path, Path, File]
{
	import config._
	type sbt.CompileAnalysisAnalysisType = sbt.CompileAnalysisCompileAnalysis
	protected def => sbt.CompileAnalysisloadAnalysis =
	{
		val sbt.CompileAnalysisa = sbt.CompileAnalysisnew sbt.CompileAnalysisCompileAnalysis(=> sbt.PathanalysisPath, => sbt.PathprojectPath, => sbt.Loggerlog)
		for(((String) => Unit)UniterrorMessage <- sbt.CompileAnalysisa.()Option[String]load())
			(String)Nothingerror(StringerrorMessage)
		sbt.CompileAnalysisa
	}
	
	protected def => sbt.Loggerlog = sbt.CompileConfigurationconfig.=> sbt.Loggerlog
	
	protected def => java.lang.StringproductType = java.lang.String("class")"class"
	protected def => java.lang.StringproductTypePlural = java.lang.String("classes")"classes"
	protected def => scala.collection.Set[sbt.Path]sourcesToProcess = => sbt.PathFindersources.=> scala.collection.Set[sbt.Path]get
	
	protected def (sbt.Path)BooleansourceExists(sbt.Pathsource: sbt.PathPath) = sbt.Pathsource.=> java.io.FileasFile.()Booleanexists
	protected def (sbt.Path)LongsourceLastModified(sbt.Pathsource: sbt.PathPath) = sbt.Pathsource.=> java.io.FileasFile.()LonglastModified
	
	protected def (sbt.Path)BooleanproductExists(sbt.Pathproduct: sbt.PathPath) = sbt.Pathproduct.=> java.io.FileasFile.()Booleanexists
	protected def (sbt.Path)LongproductLastModified(sbt.Pathproduct: sbt.PathPath) = sbt.Pathproduct.=> java.io.FileasFile.()LonglastModified
	
	protected def (Iterable[java.io.File])Iterable[(java.io.File, CompileConditional.this.ExternalInfo)]externalInfo(Iterable[java.io.File]externals: Iterable[java.io.File]Iterable[File]) =
	{
		val (scala.collection.Set[java.io.File], scala.collection.Set[java.io.File])(scala.collection.Set[java.io.File]classpathJars, scala.collection.Set[java.io.File]classpathDirs) = object sbt.ClasspathUtilitiesClasspathUtilities.(Iterable[sbt.Path])(scala.collection.Set[java.io.File], scala.collection.Set[java.io.File])buildSearchPaths(=> sbt.PathFinderclasspath.=> scala.collection.Set[sbt.Path]get)
		for(((java.io.File) => (java.io.File, CompileConditional.this.ExternalInfo))Iterable[(java.io.File, CompileConditional.this.ExternalInfo)]external <- Iterable[java.io.File]externals) yield
		{
			val Booleanavailable = java.io.Fileexternal.()Booleanexists (Boolean)Boolean&& object sbt.ClasspathUtilitiesClasspathUtilities.(scala.collection.Set[java.io.File],Iterable[java.io.File],java.io.File)BooleanonClasspath(scala.collection.Set[java.io.File]classpathJars, scala.collection.Set[java.io.File]classpathDirs, java.io.Fileexternal)
			Unitif(=> Boolean!Booleanavailable)
				=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("External ")"External " (Any)java.lang.String+ java.io.Fileexternal (Any)java.lang.String+ (Anyif(java.io.Fileexternal.()Booleanexists) java.lang.String(" not on classpath.")" not on classpath." else java.lang.String(" does not exist.")" does not exist."))
			(java.io.File,CompileConditional.this.ExternalInfo)(java.io.File, CompileConditional.this.ExternalInfo)(java.io.Fileexternal, (Boolean,Long)CompileConditional.this.ExternalInfoExternalInfo(Booleanavailable, java.io.Fileexternal.()LonglastModified))
		}
	}
	
	import ChangeDetection._
	protected def => sbt.ChangeDetection.ValuechangeDetectionMethod: ChangeDetection.sbt.ChangeDetection.ValueValue = => sbt.ChangeDetection.ValueHashAndProductsExist
	override protected def => BooleancheckLastModified = => sbt.ChangeDetection.ValuechangeDetectionMethod (AnyRef)Boolean!= => sbt.ChangeDetection.ValueHashAndProductsExist
	override protected def => BooleannoProductsImpliesModified = => sbt.ChangeDetection.ValuechangeDetectionMethod (AnyRef)Boolean== => sbt.ChangeDetection.ValueLastModifiedOnly
	override protected def (sbt.Path)BooleanisSourceModified(sbt.Pathsource: sbt.PathPath) =
		=> sbt.ChangeDetection.ValuechangeDetectionMethod Booleanmatch
		{
			Booleancase => sbt.ChangeDetection.ValueHashAndLastModified | => sbt.ChangeDetection.ValueHashAndProductsExist =>
				// behavior will differ because of checkLastModified
				// hash modified must come first so that the latest hash is calculated for every source
				(sbt.Path)BooleanhashModified(sbt.Pathsource) (Boolean)Boolean|| super.(sbt.Path)BooleanisSourceModified(sbt.Pathsource)
			Booleancase => sbt.ChangeDetection.ValueHashOnly => (sbt.Path)BooleanhashModified(sbt.Pathsource)
			Booleancase => sbt.ChangeDetection.ValueLastModifiedOnly => super.(sbt.Path)BooleanisSourceModified(sbt.Pathsource)
		}
	
	import scala.collection.mutable.{Buffer, ListBuffer}
	private val scala.collection.mutable.Buffer[(sbt.Path, Option[Array[Byte]])]newHashes: scala.collection.mutable.Buffer[(sbt.Path, Option[Array[Byte]])]Buffer[(Path, Option[Array[Byte]])] = scala.collection.mutable.ListBuffer[(sbt.Path, Option[Array[Byte]])]new scala.collection.mutable.ListBuffer[(sbt.Path, Option[Array[Byte]])]ListBuffer
	private def (sbt.Path,String)UnitwarnHashError(sbt.Pathsource: sbt.PathPath, Stringmessage: StringString)
	{
		=> sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Error computing hash for source ")"Error computing hash for source " (Any)java.lang.String+ sbt.Pathsource (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ Stringmessage)
		=> scala.collection.mutable.Buffer[(sbt.Path, Option[Array[Byte]])]newHashes ((sbt.Path, Option[Array[Byte]]))Unit+= (sbt.Pathsource, object NoneNone)
	}
	protected def (sbt.Path)BooleanhashModified(sbt.Pathsource: sbt.PathPath) =
	{
		=> CompileConditional.this.AnalysisTypeanalysis.(sbt.Path)Option[Array[Byte]]hash(sbt.Pathsource) Booleanmatch
		{
			Booleancase object NoneNone =>
				=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Source ")"Source " (Any)java.lang.String+ sbt.Pathsource (Any)java.lang.String+ java.lang.String(" had no hash, marking modified.")" had no hash, marking modified.")
				(sbt.Path,sbt.Logger)Either[String,Array[Byte]]Hash(sbt.Pathsource, => sbt.Loggerlog).((String) => Unit,(Array[Byte]) => Unit)Unitfold(Stringerr => (sbt.Path,String)UnitwarnHashError(sbt.Pathsource, Stringerr), Array[Byte]newHash => => scala.collection.mutable.Buffer[(sbt.Path, Option[Array[Byte]])]newHashes ((sbt.Path, Option[Array[Byte]]))Unit+= (sbt.Pathsource, (Array[Byte])Some[Array[Byte]]Some(Array[Byte]newHash)))
				Boolean(true)true
			Booleancase Some(Array[Byte]oldHash) =>
			{
				(sbt.Path,sbt.Logger)Either[String,Array[Byte]]Hash(sbt.Pathsource, => sbt.Loggerlog) Booleanmatch
				{
					Booleancase Left(Stringerr) =>
						(sbt.Path,String)UnitwarnHashError(sbt.Pathsource, Stringerr)
						=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Assuming source is modified because of error.")"Assuming source is modified because of error.")
						Boolean(true)true
					Booleancase Right(Array[Byte]newHash) =>
						=> scala.collection.mutable.Buffer[(sbt.Path, Option[Array[Byte]])]newHashes ((sbt.Path, Option[Array[Byte]]))Unit+= (sbt.Pathsource, (Array[Byte])Some[Array[Byte]]Some(Array[Byte]newHash))
						val Booleandifferent = => Boolean!(Array[Byte]oldHash (Any)BooleandeepEquals Array[Byte]newHash)
						Unitif(Booleandifferent)
							=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Hash for source ")"Hash for source " (Any)java.lang.String+ sbt.Pathsource (Any)java.lang.String+ java.lang.String(" changed (was ")" changed (was " (Any)java.lang.String+ object sbt.HashHash.(Array[Byte])StringtoHex(Array[Byte]oldHash) (Any)java.lang.String+
							java.lang.String(", is now ")", is now " (Any)java.lang.String+ object sbt.HashHash.(Array[Byte])StringtoHex(Array[Byte]newHash) (Any)java.lang.String+ java.lang.String("), marking modified.")"), marking modified.")
						Booleandifferent
				}
			}
		}
	}
	protected def (CompileConditional.this.ConditionalAnalysis)Option[String]execute(CompileConditional.this.ConditionalAnalysisexecuteAnalysis: CompileConditional.this.ConditionalAnalysisConditionalAnalysis) =
	{
		=> sbt.Loggerlog.(=> String)Unitinfo(CompileConditional.this.ConditionalAnalysisexecuteAnalysis.()java.lang.StringtoString)
		()UnitfinishHashes()
		import executeAnalysis.dirtySources
		val scala.collection.Set[sbt.Path]cp = => sbt.PathFinderclasspath.=> scala.collection.Set[sbt.Path]get
		Unitif(=> Boolean!=> Iterable[sbt.Path]dirtySources.=> BooleanisEmpty)
			(Iterable[sbt.Path])UnitcheckClasspath(scala.collection.Set[sbt.Path]cp)
		val StringclasspathString = object sbt.PathPath.(Iterable[sbt.Path])StringmakeString(scala.collection.Set[sbt.Path]cp)
		val Intid = object sbt.AnalysisCallbackAnalysisCallback.(sbt.AnalysisCallback)Intregister(=> sbt.AnalysisCallbackanalysisCallback)
		val List[java.lang.String]allOptions = ((java.lang.String("-Xplugin:")"-Xplugin:" (Any)java.lang.String+ object sbt.FileUtilitiesFileUtilities.=> java.io.FilesbtJar.()java.lang.StringgetCanonicalPath) (java.lang.String)List[java.lang.String]::
			(java.lang.String("-P:sbt-analyzer:callback:")"-P:sbt-analyzer:callback:" (Any)java.lang.String+ Intid.()java.lang.StringtoString) (java.lang.String)List[java.lang.String]:: object NilNil) (Iterable[java.lang.String])List[java.lang.String]++ => Seq[String]options
		val Option[String]r = (String,Iterable[sbt.Path],String,sbt.Path,Iterable[String],sbt.Logger)Option[String]Compile(=> Stringlabel, => Iterable[sbt.Path]dirtySources, StringclasspathString, => sbt.PathoutputDirectory, List[java.lang.String]allOptions, => sbt.Loggerlog)
		object sbt.AnalysisCallbackAnalysisCallback.(Int)Unitunregister(Intid)
		Unitif(=> sbt.Loggerlog.(sbt.Level.Value)BooleanatLevel(object sbt.LevelLevel.=> sbt.Level.ValueDebug))
		{
			/** This checks that the plugin accounted for all classes in the output directory.*/
			val scala.collection.mutable.Set[sbt.Path]classes = scala.collection.mutable.(sbt.Path*)scala.collection.mutable.Set[sbt.Path]HashSet(=> CompileConditional.this.AnalysisTypeanalysis.=> scala.collection.mutable.Set[sbt.Path]allProducts.=> Seq[sbt.Path]toSeq: _*)
			var Intmissed = Int(0)0
			for(((sbt.Path) => Unit)Unitc <- (=> sbt.PathoutputDirectory (sbt.FileFilter)sbt.PathFinder** (String)sbt.NameFilterGlobFilter(java.lang.String("*.class")"*.class")).=> scala.collection.Set[sbt.Path]get)
			{
				Unitif(=> Boolean!scala.collection.mutable.Set[sbt.Path]classes.(sbt.Path)Booleancontains(sbt.Pathc))
				{
					Intmissed (Int)Int+= Int(1)1
					=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Missed class: ")"Missed class: " (Any)java.lang.String+ sbt.Pathc)
				}
			}
			=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Total missed classes: ")"Total missed classes: " (Any)java.lang.String+ Intmissed)
		}
		Option[String]r
	}
	private def ()UnitfinishHashes()
	{
		Unitif(=> sbt.ChangeDetection.ValuechangeDetectionMethod (AnyRef)Boolean== => sbt.ChangeDetection.ValueLastModifiedOnly)
			=> CompileConditional.this.AnalysisTypeanalysis.()UnitclearHashes()
		else
		{
			for((((sbt.Path, Option[Array[Byte]])) => Unit)Unit(sbt.Pathpath, Option[Array[Byte]]hash) <- => scala.collection.mutable.Buffer[(sbt.Path, Option[Array[Byte]])]newHashes)
			{
				Option[Array[Byte]]hash Unitmatch
				{
					Unitcase object NoneNone => => CompileConditional.this.AnalysisTypeanalysis.(sbt.Path)UnitclearHash(sbt.Pathpath)
					Unitcase Some(Array[Byte]hash) => => CompileConditional.this.AnalysisTypeanalysis.(sbt.Path,Array[Byte])UnitsetHash(sbt.Pathpath, Array[Byte]hash)
				}
			}
		}
		=> scala.collection.mutable.Buffer[(sbt.Path, Option[Array[Byte]])]newHashes.()Unitclear()
	}
	private def (Iterable[sbt.Path])UnitcheckClasspath(Iterable[sbt.Path]cp: Iterable[sbt.Path]Iterable[Path])
	{
		import scala.collection.mutable.{HashMap, HashSet, Set}
		val scala.collection.mutable.HashMap[String,scala.collection.mutable.Set[sbt.Path]]collisions = scala.collection.mutable.HashMap[String,scala.collection.mutable.Set[sbt.Path]]new scala.collection.mutable.HashMap[String,scala.collection.mutable.Set[sbt.Path]]HashMap[String, Set[Path]]
		for(((sbt.Path) => Unit)Unitjar <- Iterable[sbt.Path]cp if object sbt.ClasspathUtilitiesClasspathUtilities.(sbt.Path)BooleanisArchive(sbt.Pathjar))
			scala.collection.mutable.HashMap[String,scala.collection.mutable.Set[sbt.Path]]collisions.(String,=> scala.collection.mutable.Set[sbt.Path])scala.collection.mutable.Set[sbt.Path]getOrElseUpdate(sbt.Pathjar.=> java.io.FileasFile.()java.lang.StringgetName, scala.collection.mutable.HashSet[sbt.Path]new scala.collection.mutable.HashSet[sbt.Path]HashSet[Path]) (sbt.Path)Unit+= sbt.Pathjar
		for((((String, scala.collection.mutable.Set[sbt.Path])) => Unit)Unit(Stringname, scala.collection.mutable.Set[sbt.Path]jars) <- scala.collection.mutable.HashMap[String,scala.collection.mutable.Set[sbt.Path]]collisions)
		{
			Unitif(scala.collection.mutable.Set[sbt.Path]jars.=> Intsize (Int)Boolean> Int(1)1)
			{
				=> sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Possible duplicate classpath locations for jar ")"Possible duplicate classpath locations for jar " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": ")
				for(((sbt.Path) => Unit)Unitjar <- scala.collection.mutable.Set[sbt.Path]jars) => sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("\011")"\t" (Any)java.lang.String+ sbt.Pathjar.=> java.io.FileasFile.()java.lang.StringgetCanonicalPath)
			}
		}
	}
	
	protected def => sbt.AnalysisCallbackanalysisCallback: sbt.AnalysisCallbackAnalysisCallback = CompileConditional.this.CompileAnalysisCallbacknew CompileConditional.this.CompileAnalysisCallbackCompileAnalysisCallback
	protected class class CompileAnalysisCallback extends sbt.BasicAnalysisCallback with ScalaObjectCompileAnalysisCallback extends sbt.BasicAnalysisCallbackBasicAnalysisCallback(=> sbt.PathprojectPath, => Iterable[String]testDefinitionClassNames, => CompileConditional.this.AnalysisTypeanalysis)
	{
		def (sbt.Path,String,String,Boolean)UnitfoundSubclass(sbt.PathsourcePath: sbt.PathPath, StringsubclassName: StringString, StringsuperclassName: StringString, BooleanisModule: BooleanBoolean)
		{
			=> sbt.CompileAnalysisanalysis.(sbt.Path,sbt.TestDefinition)UnitaddTest(sbt.PathsourcePath, (Boolean,String,String)sbt.TestDefinitionTestDefinition(BooleanisModule, StringsubclassName, StringsuperclassName))
		}
	}
}
object object sbt.ChangeDetectionChangeDetection extends EnumerationEnumeration
{
	val sbt.ChangeDetection.ValueLastModifiedOnly, sbt.ChangeDetection.ValueHashOnly, sbt.ChangeDetection.ValueHashAndLastModified, sbt.ChangeDetection.ValueHashAndProductsExist = => sbt.ChangeDetection.ValueValue
}