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)
{
=> 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 =>
(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))
{
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
}