From d70bc51b6d077fac3c112f7b61189b4eb422a9b2 Mon Sep 17 00:00:00 2001 From: Grzegorz Kossakowski Date: Fri, 6 Dec 2013 15:53:33 +0100 Subject: [PATCH] Use `nameHashing` option throughout incremental compiler There are two categories of places in the code that need to refer to `nameHashing` option: * places where Analysis object is created so it gets proper implementation of underlying Relations object * places with logic that is specifically designed to be enabled by that option This commit covers both cases. --- compile/inc/src/main/scala/sbt/inc/Analysis.scala | 2 ++ compile/inc/src/main/scala/sbt/inc/Compile.scala | 4 ++-- compile/inc/src/main/scala/sbt/inc/Incremental.scala | 1 + .../src/main/scala/sbt/compiler/AggressiveCompile.scala | 6 +++--- .../src/main/scala/sbt/compiler/IncrementalCompiler.scala | 6 ++++++ 5 files changed, 14 insertions(+), 5 deletions(-) diff --git a/compile/inc/src/main/scala/sbt/inc/Analysis.scala b/compile/inc/src/main/scala/sbt/inc/Analysis.scala index 212b6fc6d..aaa63918d 100644 --- a/compile/inc/src/main/scala/sbt/inc/Analysis.scala +++ b/compile/inc/src/main/scala/sbt/inc/Analysis.scala @@ -56,6 +56,8 @@ trait Analysis object Analysis { lazy val Empty: Analysis = new MAnalysis(Stamps.empty, APIs.empty, Relations.empty, SourceInfos.empty, Compilations.empty) + private[sbt] def empty(nameHashing: Boolean): Analysis = new MAnalysis(Stamps.empty, APIs.empty, + Relations.empty(nameHashing = nameHashing), SourceInfos.empty, Compilations.empty) /** Merge multiple analysis objects into one. Deps will be internalized as needed. */ def merge(analyses: Traversable[Analysis]): Analysis = { diff --git a/compile/inc/src/main/scala/sbt/inc/Compile.scala b/compile/inc/src/main/scala/sbt/inc/Compile.scala index a5b56a5c5..edf714f06 100644 --- a/compile/inc/src/main/scala/sbt/inc/Compile.scala +++ b/compile/inc/src/main/scala/sbt/inc/Compile.scala @@ -157,9 +157,9 @@ private final class AnalysisCallback(internalMap: File => Option[File], external def usedName(sourceFile: File, name: String) = add(usedNames, sourceFile, name) - def nameHashing: Boolean = false // TODO: define the flag in IncOptions which controls this + def nameHashing: Boolean = options.nameHashing - def get: Analysis = addUsedNames( addCompilation( addExternals( addBinaries( addProducts( addSources(Analysis.Empty) ) ) ) ) ) + def get: Analysis = addUsedNames( addCompilation( addExternals( addBinaries( addProducts( addSources(Analysis.empty(nameHashing = nameHashing)) ) ) ) ) ) def addProducts(base: Analysis): Analysis = addAll(base, classes) { case (a, src, (prod, name)) => a.addProduct(src, prod, current product prod, name ) } def addBinaries(base: Analysis): Analysis = addAll(base, binaryDeps)( (a, src, bin) => a.addBinaryDep(src, bin, binaryClassName(bin), current binary bin) ) def addSources(base: Analysis): Analysis = diff --git a/compile/inc/src/main/scala/sbt/inc/Incremental.scala b/compile/inc/src/main/scala/sbt/inc/Incremental.scala index 79c5ee8dd..dc86f818d 100644 --- a/compile/inc/src/main/scala/sbt/inc/Incremental.scala +++ b/compile/inc/src/main/scala/sbt/inc/Incremental.scala @@ -21,6 +21,7 @@ object Incremental log: Logger, options: IncOptions)(implicit equivS: Equiv[Stamp]): (Boolean, Analysis) = { + assert(!options.nameHashing, "We don't support name hashing algorithm yet.") val incremental = new IncrementalDefaultImpl(log, options) val initialChanges = incremental.changedInitial(entry, sources, previous, current, forEntry) val binaryChanges = new DependencyChanges { diff --git a/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala b/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala index 5fc1bafba..fec36db56 100644 --- a/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala +++ b/compile/integration/src/main/scala/sbt/compiler/AggressiveCompile.scala @@ -61,7 +61,7 @@ class AggressiveCompile(cacheFile: File) cache: GlobalsCache, incrementalCompilerOptions: IncOptions)(implicit log: Logger): Analysis = { - val (previousAnalysis, previousSetup) = extract(store.get()) + val (previousAnalysis, previousSetup) = extract(store.get(), incrementalCompilerOptions) if(skip) previousAnalysis else { @@ -169,11 +169,11 @@ class AggressiveCompile(cacheFile: File) if(!combined.isEmpty) log.info(combined.mkString("Compiling ", " and ", " to " + outputDirs.map(_.getAbsolutePath).mkString(",") + "...")) } - private def extract(previous: Option[(Analysis, CompileSetup)]): (Analysis, Option[CompileSetup]) = + private def extract(previous: Option[(Analysis, CompileSetup)], incOptions: IncOptions): (Analysis, Option[CompileSetup]) = previous match { case Some((an, setup)) => (an, Some(setup)) - case None => (Analysis.Empty, None) + case None => (Analysis.empty(nameHashing = incOptions.nameHashing), None) } def javaOnly(f: File) = f.getName.endsWith(".java") diff --git a/compile/integration/src/main/scala/sbt/compiler/IncrementalCompiler.scala b/compile/integration/src/main/scala/sbt/compiler/IncrementalCompiler.scala index 8600f6a70..68ad63f2c 100644 --- a/compile/integration/src/main/scala/sbt/compiler/IncrementalCompiler.scala +++ b/compile/integration/src/main/scala/sbt/compiler/IncrementalCompiler.scala @@ -36,9 +36,15 @@ object IC extends IncrementalCompiler[Analysis, AnalyzingCompiler] def readCache(file: File): Maybe[(Analysis, CompileSetup)] = try { Maybe.just(readCacheUncaught(file)) } catch { case _: Exception => Maybe.nothing() } + @deprecated("Use overloaded variant which takes `IncOptions` as parameter.", "0.13.2") def readAnalysis(file: File): Analysis = try { readCacheUncaught(file)._1 } catch { case _: Exception => Analysis.Empty } + def readAnalysis(file: File, incOptions: IncOptions): Analysis = + try { readCacheUncaught(file)._1 } catch { + case _: Exception => Analysis.empty(nameHashing = incOptions.nameHashing) + } + def readCacheUncaught(file: File): (Analysis, CompileSetup) = Using.fileReader(IO.utf8)(file) { reader => TextAnalysisFormat.read(reader) } }