diff --git a/compile/inc/src/main/scala/sbt/inc/Analysis.scala b/compile/inc/src/main/scala/sbt/inc/Analysis.scala index 956c146cb..212b6fc6d 100644 --- a/compile/inc/src/main/scala/sbt/inc/Analysis.scala +++ b/compile/inc/src/main/scala/sbt/inc/Analysis.scala @@ -59,7 +59,7 @@ object Analysis /** Merge multiple analysis objects into one. Deps will be internalized as needed. */ def merge(analyses: Traversable[Analysis]): Analysis = { - if (analyses.exists(_.relations.memberRefAndInheritanceDeps)) + if (analyses.exists(_.relations.nameHashing)) throw new IllegalArgumentException("Merging of Analyses that have" + "`relations.memberRefAndInheritanceDeps` set to `true` is not supported.") @@ -160,7 +160,7 @@ private class MAnalysis(val stamps: Stamps, val apis: APIs, val relations: Relat copy( stamps.markProduct(product, stamp), apis, relations.addProduct(src, product, name), infos ) def groupBy[K](discriminator: File => K): Map[K, Analysis] = { - if (relations.memberRefAndInheritanceDeps) + if (relations.nameHashing) throw new UnsupportedOperationException("Grouping of Analyses that have" + "`relations.memberRefAndInheritanceDeps` set to `true` is not supported.") diff --git a/compile/inc/src/main/scala/sbt/inc/Compile.scala b/compile/inc/src/main/scala/sbt/inc/Compile.scala index d9ad4cf51..e37e84cd4 100644 --- a/compile/inc/src/main/scala/sbt/inc/Compile.scala +++ b/compile/inc/src/main/scala/sbt/inc/Compile.scala @@ -151,7 +151,7 @@ private final class AnalysisCallback(internalMap: File => Option[File], external apis(sourceFile) = (HashAPI(source), savedSource) } - def memberRefAndInheritanceDeps: Boolean = false // TODO: define the flag in IncOptions which controls this + def nameHashing: Boolean = false // TODO: define the flag in IncOptions which controls this def get: Analysis = addCompilation( addExternals( addBinaries( addProducts( addSources(Analysis.Empty) ) ) ) ) def addProducts(base: Analysis): Analysis = addAll(base, classes) { case (a, src, (prod, name)) => a.addProduct(src, prod, current product prod, name ) } diff --git a/compile/inc/src/main/scala/sbt/inc/Relations.scala b/compile/inc/src/main/scala/sbt/inc/Relations.scala index 3f1b34725..516ddcef1 100644 --- a/compile/inc/src/main/scala/sbt/inc/Relations.scala +++ b/compile/inc/src/main/scala/sbt/inc/Relations.scala @@ -147,17 +147,22 @@ trait Relations def classes: Relation[File, String] /** - * Flag which indicates whether the new style (based on `memberRef` and `inheritance` source dependencies) - * of dependency tracking is enabled. When this flag is enabled access to `direct` and `publicInherited` - * relations is illegal and will cause runtime exception being thrown. + * Flag which indicates whether given Relations object supports operations needed by name hashing algorithm. * - * Conversely, when `memberRefAndInheritanceDeps` flag is disabled access to `memberRef` and `inheritance` - * relations is illegal and will cause runtime exception being thrown. + * At the moment the list includes the following operations: * - * The name of this flag is ugly but it's private to incremental compiler and it's temporary measure during - * our migration to the new dependency tracking. + * - memberRef: SourceDependencies + * - inheritance: SourceDependencies + * + * The `memberRef` and `inheritance` implement a new style source dependency tracking. When this flag is + * enabled access to `direct` and `publicInherited` relations is illegal and will cause runtime exception + * being thrown. That is done as an optimization that prevents from storing two overlapping sets of + * dependencies. + * + * Conversely, when `nameHashing` flag is disabled access to `memberRef` and `inheritance` + * relations is illegal and will cause runtime exception being thrown. */ - private[inc] def memberRefAndInheritanceDeps: Boolean + private[inc] def nameHashing: Boolean } @@ -213,19 +218,19 @@ object Relations def emptySource: Source = es private[inc] lazy val emptySourceDependencies: SourceDependencies = new SourceDependencies(e, estr) - def empty: Relations = empty(memberRefAndInheritanceDeps = false) - def empty(memberRefAndInheritanceDeps: Boolean): Relations = - if (memberRefAndInheritanceDeps) - new MRelationsMemberRefAndInheritance(e, e, emptySourceDependencies, emptySourceDependencies, estr) + def empty: Relations = empty(nameHashing = false) + def empty(nameHashing: Boolean): Relations = + if (nameHashing) + new MRelationsNameHashing(e, e, emptySourceDependencies, emptySourceDependencies, estr) else - new MRelationsDirectAndPublicInherited(e, e, es, es, estr) + new MRelationsDefaultImpl(e, e, es, es, estr) def make(srcProd: Relation[File, File], binaryDep: Relation[File, File], direct: Source, publicInherited: Source, classes: Relation[File, String]): Relations = - new MRelationsDirectAndPublicInherited(srcProd, binaryDep, direct = direct, publicInherited = publicInherited, classes) + new MRelationsDefaultImpl(srcProd, binaryDep, direct = direct, publicInherited = publicInherited, classes) private[inc] def make(srcProd: Relation[File, File], binaryDep: Relation[File, File], memberRef: SourceDependencies, inheritance: SourceDependencies, classes: Relation[File, String]): Relations = - new MRelationsMemberRefAndInheritance(srcProd, binaryDep, memberRef = memberRef, inheritance = inheritance, classes) + new MRelationsNameHashing(srcProd, binaryDep, memberRef = memberRef, inheritance = inheritance, classes) def makeSource(internal: Relation[File,File], external: Relation[File,String]): Source = new Source(internal, external) private[inc] def makeSourceDependencies(internal: Relation[File,File], external: Relation[File,String]): SourceDependencies = new SourceDependencies(internal, external) } @@ -309,7 +314,7 @@ private abstract class MRelationsCommon(val srcProd: Relation[File, File], val b * introduced by inheritance. * */ -private class MRelationsDirectAndPublicInherited(srcProd: Relation[File, File], binaryDep: Relation[File, File], +private class MRelationsDefaultImpl(srcProd: Relation[File, File], binaryDep: Relation[File, File], // direct should include everything in inherited val direct: Source, val publicInherited: Source, classes: Relation[File, String]) extends MRelationsCommon(srcProd, binaryDep, classes) @@ -317,45 +322,45 @@ private class MRelationsDirectAndPublicInherited(srcProd: Relation[File, File], def internalSrcDep: Relation[File, File] = direct.internal def externalDep: Relation[File, String] = direct.external - def memberRefAndInheritanceDeps: Boolean = false + def nameHashing: Boolean = false def memberRef: SourceDependencies = throw new UnsupportedOperationException("The `memberRef` source dependencies relation is not supported " + - "when `memberRefAndInheritanceDeps` is disabled. Do you have name hashing algorithm disabled?") + "when `nameHashing` flag is disabled.") def inheritance: SourceDependencies = throw new UnsupportedOperationException("The `memberRef` source dependencies relation is not supported " + - "when `memberRefAndInheritanceDeps` is disabled. Do you have name hashing algorithm disabled?") + "when `nameHashing` flag is disabled.") def addProduct(src: File, prod: File, name: String): Relations = - new MRelationsDirectAndPublicInherited(srcProd + (src, prod), binaryDep, direct = direct, + new MRelationsDefaultImpl(srcProd + (src, prod), binaryDep, direct = direct, publicInherited = publicInherited, classes + (src, name)) def addExternalDep(src: File, dependsOn: String, inherited: Boolean): Relations = { val newI = if(inherited) publicInherited.addExternal(src, dependsOn) else publicInherited val newD = direct.addExternal(src, dependsOn) - new MRelationsDirectAndPublicInherited( srcProd, binaryDep, direct = newD, publicInherited = newI, classes) + new MRelationsDefaultImpl( srcProd, binaryDep, direct = newD, publicInherited = newI, classes) } def addInternalSrcDeps(src: File, dependsOn: Iterable[File], inherited: Iterable[File]): Relations = { val newI = publicInherited.addInternal(src, inherited) val newD = direct.addInternal(src, dependsOn) - new MRelationsDirectAndPublicInherited( srcProd, binaryDep, direct = newD, publicInherited = newI, classes) + new MRelationsDefaultImpl( srcProd, binaryDep, direct = newD, publicInherited = newI, classes) } def addBinaryDep(src: File, dependsOn: File): Relations = - new MRelationsDirectAndPublicInherited( srcProd, binaryDep + (src, dependsOn), direct = direct, + new MRelationsDefaultImpl( srcProd, binaryDep + (src, dependsOn), direct = direct, publicInherited = publicInherited, classes) def ++ (o: Relations): Relations = { - if (memberRefAndInheritanceDeps != o.memberRefAndInheritanceDeps) + if (nameHashing != o.nameHashing) throw new UnsupportedOperationException("The `++` operation is not supported for relations " + - "with different values of `memberRefAndInheritanceDeps` flag.") - new MRelationsDirectAndPublicInherited(srcProd ++ o.srcProd, binaryDep ++ o.binaryDep, direct ++ o.direct, + "with different values of `nameHashing` flag.") + new MRelationsDefaultImpl(srcProd ++ o.srcProd, binaryDep ++ o.binaryDep, direct ++ o.direct, publicInherited ++ o.publicInherited, classes ++ o.classes) } def -- (sources: Iterable[File]) = - new MRelationsDirectAndPublicInherited(srcProd -- sources, binaryDep -- sources, direct = direct -- sources, + new MRelationsDefaultImpl(srcProd -- sources, binaryDep -- sources, direct = direct -- sources, publicInherited = publicInherited -- sources, classes -- sources) @deprecated("Broken implementation. OK to remove in 0.14", "0.13.1") @@ -370,7 +375,7 @@ private class MRelationsDirectAndPublicInherited(srcProd: Relation[File, File], def getSrc(m: Map[K, Source]): Source = m.getOrElse(k, Relations.emptySource) def getSrcDeps(m: Map[K, SourceDependencies]): SourceDependencies = m.getOrElse(k, Relations.emptySourceDependencies) - new MRelationsDirectAndPublicInherited( get(srcProdMap), get(binaryDepMap), getSrc(direct), getSrc(inherited), + new MRelationsDefaultImpl( get(srcProdMap), get(binaryDepMap), getSrc(direct), getSrc(inherited), get(classesMap)) } val keys = (srcProdMap.keySet ++ binaryDepMap.keySet ++ direct.keySet ++ inherited.keySet ++ classesMap.keySet).toList @@ -384,7 +389,7 @@ private class MRelationsDirectAndPublicInherited(srcProd: Relation[File, File], } override def equals(other: Any) = other match { - case o: MRelationsDirectAndPublicInherited => + case o: MRelationsDefaultImpl => srcProd == o.srcProd && binaryDep == o.binaryDep && direct == o.direct && publicInherited == o.publicInherited && classes == o.classes case _ => false @@ -417,62 +422,62 @@ private class MRelationsDirectAndPublicInherited(srcProd: Relation[File, File], * dependencies. Therefore this class implements the new (compared to sbt 0.13.0) dependency tracking logic * needed by the name hashing invalidation algorithm. */ -private class MRelationsMemberRefAndInheritance(srcProd: Relation[File, File], binaryDep: Relation[File, File], +private class MRelationsNameHashing(srcProd: Relation[File, File], binaryDep: Relation[File, File], // memberRef should include everything in inherited val memberRef: SourceDependencies, val inheritance: SourceDependencies, classes: Relation[File, String]) extends MRelationsCommon(srcProd, binaryDep, classes) { def direct: Source = throw new UnsupportedOperationException("The `direct` source dependencies relation is not supported " + - "when `memberRefAndInheritanceDeps` is disabled. Do you have name hashing algorithm disabled?") + "when `nameHashing` flag is disabled.") def publicInherited: Source = throw new UnsupportedOperationException("The `publicInherited` source dependencies relation is not supported " + - "when `memberRefAndInheritanceDeps` is disabled. Do you have name hashing algorithm disabled?") + "when `nameHashing` flag is disabled.") - val memberRefAndInheritanceDeps: Boolean = true + val nameHashing: Boolean = true def internalSrcDep: Relation[File, File] = memberRef.internal def externalDep: Relation[File, String] = memberRef.external def addProduct(src: File, prod: File, name: String): Relations = - new MRelationsMemberRefAndInheritance(srcProd + (src, prod), binaryDep, memberRef = memberRef, + new MRelationsNameHashing(srcProd + (src, prod), binaryDep, memberRef = memberRef, inheritance = inheritance, classes + (src, name)) def addExternalDep(src: File, dependsOn: String, inherited: Boolean): Relations = { val newIH = if(inherited) inheritance.addExternal(src, dependsOn) else inheritance val newMR = memberRef.addExternal(src, dependsOn) - new MRelationsMemberRefAndInheritance( srcProd, binaryDep, memberRef = newMR, inheritance = newIH, classes) + new MRelationsNameHashing( srcProd, binaryDep, memberRef = newMR, inheritance = newIH, classes) } def addInternalSrcDeps(src: File, dependsOn: Iterable[File], inherited: Iterable[File]): Relations = { val newIH = inheritance.addInternal(src, inherited) val newMR = memberRef.addInternal(src, dependsOn) - new MRelationsMemberRefAndInheritance( srcProd, binaryDep, memberRef = newMR, inheritance = newIH, classes) + new MRelationsNameHashing( srcProd, binaryDep, memberRef = newMR, inheritance = newIH, classes) } def addBinaryDep(src: File, dependsOn: File): Relations = - new MRelationsMemberRefAndInheritance(srcProd, binaryDep + (src, dependsOn), memberRef = memberRef, + new MRelationsNameHashing(srcProd, binaryDep + (src, dependsOn), memberRef = memberRef, inheritance = inheritance, classes) def ++ (o: Relations): Relations = { - if (!o.memberRefAndInheritanceDeps) + if (!o.nameHashing) throw new UnsupportedOperationException("The `++` operation is not supported for relations " + - "with different values of `memberRefAndInheritanceDeps` flag.") - new MRelationsMemberRefAndInheritance(srcProd ++ o.srcProd, binaryDep ++ o.binaryDep, + "with different values of `nameHashing` flag.") + new MRelationsNameHashing(srcProd ++ o.srcProd, binaryDep ++ o.binaryDep, memberRef = memberRef ++ o.memberRef, inheritance = inheritance ++ o.inheritance, classes ++ o.classes) } def -- (sources: Iterable[File]) = - new MRelationsMemberRefAndInheritance(srcProd -- sources, binaryDep -- sources, + new MRelationsNameHashing(srcProd -- sources, binaryDep -- sources, memberRef = memberRef -- sources, inheritance = inheritance -- sources, classes -- sources) def groupBy[K](f: File => K): Map[K, Relations] = { throw new UnsupportedOperationException("Merging of Analyses that have" + - "`relations.memberRefAndInheritanceDeps` set to `true` is not supported.") + "`relations.nameHashing` set to `true` is not supported.") } override def equals(other: Any) = other match { - case o: MRelationsMemberRefAndInheritance => + case o: MRelationsNameHashing => srcProd == o.srcProd && binaryDep == o.binaryDep && memberRef == o.memberRef && inheritance == o.inheritance && classes == o.classes case _ => false diff --git a/compile/interface/src/main/scala/xsbt/Dependency.scala b/compile/interface/src/main/scala/xsbt/Dependency.scala index 535a6b822..0218f6ba8 100644 --- a/compile/interface/src/main/scala/xsbt/Dependency.scala +++ b/compile/interface/src/main/scala/xsbt/Dependency.scala @@ -43,7 +43,7 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile { // build dependencies structure val sourceFile = unit.source.file.file - if (global.callback.memberRefAndInheritanceDeps) { + if (global.callback.nameHashing) { val dependenciesByMemberRef = extractDependenciesByMemberRef(unit) for(on <- dependenciesByMemberRef) processDependency(on, inherited=false) diff --git a/compile/interface/src/test/scala/xsbt/DependencySpecification.scala b/compile/interface/src/test/scala/xsbt/DependencySpecification.scala index 89f465143..040ad1d6e 100644 --- a/compile/interface/src/test/scala/xsbt/DependencySpecification.scala +++ b/compile/interface/src/test/scala/xsbt/DependencySpecification.scala @@ -80,7 +80,7 @@ class DependencySpecification extends Specification { // E verifies the core type gets pulled out val srcH = "trait H extends G.T[Int] with (E[Int] @unchecked)" - val compilerForTesting = new ScalaCompilerForUnitTesting(memberRefAndInheritanceDeps = true) + val compilerForTesting = new ScalaCompilerForUnitTesting(nameHashing = true) val sourceDependencies = compilerForTesting.extractDependenciesFromSrcs('A -> srcA, 'B -> srcB, 'C -> srcC, 'D -> srcD, 'E -> srcE, 'F -> srcF, 'G -> srcG, 'H -> srcH) sourceDependencies @@ -92,7 +92,7 @@ class DependencySpecification extends Specification { val srcC = "class C { private class Inner1 extends A }" val srcD = "class D { def foo: Unit = { class Inner2 extends B } }" - val compilerForTesting = new ScalaCompilerForUnitTesting(memberRefAndInheritanceDeps = true) + val compilerForTesting = new ScalaCompilerForUnitTesting(nameHashing = true) val sourceDependencies = compilerForTesting.extractDependenciesFromSrcs('A -> srcA, 'B -> srcB, 'C -> srcC, 'D -> srcD) sourceDependencies @@ -104,7 +104,7 @@ class DependencySpecification extends Specification { val srcC = "trait C extends B" val srcD = "class D extends C" - val compilerForTesting = new ScalaCompilerForUnitTesting(memberRefAndInheritanceDeps = true) + val compilerForTesting = new ScalaCompilerForUnitTesting(nameHashing = true) val sourceDependencies = compilerForTesting.extractDependenciesFromSrcs('A -> srcA, 'B -> srcB, 'C -> srcC, 'D -> srcD) sourceDependencies diff --git a/compile/interface/src/test/scala/xsbt/ScalaCompilerForUnitTesting.scala b/compile/interface/src/test/scala/xsbt/ScalaCompilerForUnitTesting.scala index 61fb08078..91b3830d6 100644 --- a/compile/interface/src/test/scala/xsbt/ScalaCompilerForUnitTesting.scala +++ b/compile/interface/src/test/scala/xsbt/ScalaCompilerForUnitTesting.scala @@ -19,7 +19,7 @@ import ScalaCompilerForUnitTesting.ExtractedSourceDependencies * Provides common functionality needed for unit tests that require compiling * source code using Scala compiler. */ -class ScalaCompilerForUnitTesting(memberRefAndInheritanceDeps: Boolean = false) { +class ScalaCompilerForUnitTesting(nameHashing: Boolean = false) { /** * Compiles given source code using Scala compiler and returns API representation @@ -76,7 +76,7 @@ class ScalaCompilerForUnitTesting(memberRefAndInheritanceDeps: Boolean = false) */ private def compileSrcs(srcs: String*): (Seq[File], TestCallback) = { withTemporaryDirectory { temp => - val analysisCallback = new TestCallback(memberRefAndInheritanceDeps) + val analysisCallback = new TestCallback(nameHashing) val classesDir = new File(temp, "classes") classesDir.mkdir() val compiler = prepareCompiler(classesDir, analysisCallback) diff --git a/compile/persist/src/main/scala/sbt/inc/AnalysisFormats.scala b/compile/persist/src/main/scala/sbt/inc/AnalysisFormats.scala index 5da25c868..b5ddd84f0 100644 --- a/compile/persist/src/main/scala/sbt/inc/AnalysisFormats.scala +++ b/compile/persist/src/main/scala/sbt/inc/AnalysisFormats.scala @@ -103,21 +103,21 @@ object AnalysisFormats { def makeRelation(srcProd: RFF, binaryDep: RFF, direct: RSource, publicInherited: RSource, memberRef: SourceDependencies, inheritance: SourceDependencies, classes: RFS, - memberRefAndInheritanceDeps: Boolean): Relations = if (memberRefAndInheritanceDeps) { + nameHashing: Boolean): Relations = if (nameHashing) { def isEmpty(sourceDependencies: RSource): Boolean = sourceDependencies.internal.all.isEmpty && sourceDependencies.external.all.isEmpty // we check direct dependencies only because publicInherited dependencies are subset of direct - assert(isEmpty(direct), "Direct dependencies are not empty but `memberRefAndInheritanceDeps` flag is enabled.") + assert(isEmpty(direct), "Direct dependencies are not empty but `nameHashing` flag is enabled.") Relations.make(srcProd, binaryDep, memberRef, inheritance, classes) } else { def isEmpty(sourceDependencies: SourceDependencies): Boolean = sourceDependencies.internal.all.isEmpty && sourceDependencies.external.all.isEmpty // we check memberRef dependencies only because inheritance dependencies are subset of memberRef - assert(isEmpty(memberRef), "Direct dependencies are not empty but `memberRefAndInheritanceDeps` flag is enabled.") + assert(isEmpty(memberRef), "Direct dependencies are not empty but `nameHashing` flag is enabled.") Relations.make(srcProd, binaryDep, direct, publicInherited, classes) } asProduct8[Relations, RFF, RFF, RSource, RSource, SourceDependencies, SourceDependencies, RFS, Boolean]( (a,b,c,d,e,f,g,h) =>makeRelation(a,b,c,d,e,f,g,h) )( - rs => (rs.srcProd, rs.binaryDep, rs.direct, rs.publicInherited, rs.memberRef, rs.inheritance, rs.classes, rs.memberRefAndInheritanceDeps) )( + rs => (rs.srcProd, rs.binaryDep, rs.direct, rs.publicInherited, rs.memberRef, rs.inheritance, rs.classes, rs.nameHashing) )( prodF, binF, directF, inheritedF, memberRefF, inheritanceF, csF, implicitly[Format[Boolean]]) } diff --git a/compile/persist/src/main/scala/sbt/inc/TextAnalysisFormat.scala b/compile/persist/src/main/scala/sbt/inc/TextAnalysisFormat.scala index 8c19fc94a..849c57a7f 100644 --- a/compile/persist/src/main/scala/sbt/inc/TextAnalysisFormat.scala +++ b/compile/persist/src/main/scala/sbt/inc/TextAnalysisFormat.scala @@ -134,17 +134,17 @@ object TextAnalysisFormat { } } - val memberRefAndInheritanceDeps = relations.memberRefAndInheritanceDeps + val nameHashing = relations.nameHashing writeRelation(Headers.srcProd, relations.srcProd) writeRelation(Headers.binaryDep, relations.binaryDep) - val direct = if (memberRefAndInheritanceDeps) Relations.emptySource else relations.direct - val publicInherited = if (memberRefAndInheritanceDeps) + val direct = if (nameHashing) Relations.emptySource else relations.direct + val publicInherited = if (nameHashing) Relations.emptySource else relations.publicInherited - val memberRef = if (memberRefAndInheritanceDeps) + val memberRef = if (nameHashing) relations.memberRef else Relations.emptySourceDependencies - val inheritance = if (memberRefAndInheritanceDeps) + val inheritance = if (nameHashing) relations.inheritance else Relations.emptySourceDependencies writeRelation(Headers.directSrcDep, direct.internal) @@ -213,10 +213,10 @@ object TextAnalysisFormat { // we assume that invariant that says they are subsets of direct/memberRef holds assert((directSrcDeps == emptySource) || (memberRefSrcDeps == emptySourceDependencies), "One mechanism is supported for tracking source dependencies at the time") - val memberRefAndInheritanceDeps = memberRefSrcDeps != emptySourceDependencies + val nameHashing = memberRefSrcDeps != emptySourceDependencies val classes = readStringRelation(Headers.classes) - if (memberRefAndInheritanceDeps) + if (nameHashing) Relations.make(srcProd, binaryDep, memberRefSrcDeps, inheritanceSrcDeps, classes) else Relations.make(srcProd, binaryDep, directSrcDeps, publicInheritedSrcDeps, classes) diff --git a/interface/src/main/java/xsbti/AnalysisCallback.java b/interface/src/main/java/xsbti/AnalysisCallback.java index ff239ae74..790db124a 100644 --- a/interface/src/main/java/xsbti/AnalysisCallback.java +++ b/interface/src/main/java/xsbti/AnalysisCallback.java @@ -28,8 +28,11 @@ public interface AnalysisCallback * Unreported problems are usually unreported because reporting was not enabled via a command line switch. */ public void problem(String what, Position pos, String msg, Severity severity, boolean reported); /** - * Determines whether member reference and inheritance dependencies should be extracted in given compiler - * run. + * Determines whether method calls through this interface should be interpreted as serving + * name hashing algorithm needs in given compiler run. + * + * In particular, it indicates whether member reference and inheritance dependencies should be + * extracted. * * As the signature suggests, this method's implementation is meant to be side-effect free. It's added * to AnalysisCallback because it indicates how other callback calls should be interpreted by both @@ -38,5 +41,5 @@ public interface AnalysisCallback * NOTE: This method is an implementation detail and can be removed at any point without deprecation. * Do not depend on it, please. */ - public boolean memberRefAndInheritanceDeps(); + public boolean nameHashing(); } \ No newline at end of file diff --git a/interface/src/test/scala/xsbti/TestCallback.scala b/interface/src/test/scala/xsbti/TestCallback.scala index 28bee5466..e620f6be2 100644 --- a/interface/src/test/scala/xsbti/TestCallback.scala +++ b/interface/src/test/scala/xsbti/TestCallback.scala @@ -4,7 +4,7 @@ import java.io.File import scala.collection.mutable.ArrayBuffer import xsbti.api.SourceAPI -class TestCallback(override val memberRefAndInheritanceDeps: Boolean = false) extends AnalysisCallback +class TestCallback(override val nameHashing: Boolean = false) extends AnalysisCallback { val sourceDependencies = new ArrayBuffer[(File, File, Boolean)] val binaryDependencies = new ArrayBuffer[(File, String, File, Boolean)]