Full Code of amaembo/huntbugs for AI

gitextract_tmwxzcoo/

├── .gitattributes
├── .gitignore
├── .mailmap
├── .travis.yml
├── LICENSE
├── README.md
├── findbugs.txt
├── huntbugs/
│   ├── .classpath
│   ├── .gitignore
│   ├── .project
│   ├── .settings/
│   │   ├── org.eclipse.core.resources.prefs
│   │   ├── org.eclipse.jdt.core.prefs
│   │   ├── org.eclipse.jdt.ui.prefs
│   │   ├── org.eclipse.m2e.core.prefs
│   │   └── org.eclipse.pde.core.prefs
│   ├── pom.xml
│   └── src/
│       ├── main/
│       │   ├── java/
│       │   │   └── one/
│       │   │       └── util/
│       │   │           └── huntbugs/
│       │   │               ├── HuntBugs.java
│       │   │               ├── analysis/
│       │   │               │   ├── AnalysisListener.java
│       │   │               │   ├── AnalysisOptions.java
│       │   │               │   ├── Context.java
│       │   │               │   ├── ErrorMessage.java
│       │   │               │   └── HuntBugsResult.java
│       │   │               ├── assertions/
│       │   │               │   ├── AssertionData.java
│       │   │               │   └── MemberAsserter.java
│       │   │               ├── db/
│       │   │               │   ├── DeclaredAnnotations.java
│       │   │               │   ├── FieldStats.java
│       │   │               │   ├── Hierarchy.java
│       │   │               │   ├── MethodStats.java
│       │   │               │   └── Mutability.java
│       │   │               ├── detect/
│       │   │               │   ├── AbandonedStream.java
│       │   │               │   ├── AppendObjectOutputStream.java
│       │   │               │   ├── ArrayRangeCheck.java
│       │   │               │   ├── AtomicConcurrent.java
│       │   │               │   ├── AverageComputation.java
│       │   │               │   ├── BadMath.java
│       │   │               │   ├── BadMethodCalls.java
│       │   │               │   ├── BadMethodReferences.java
│       │   │               │   ├── BadMonitorObject.java
│       │   │               │   ├── CheckReturnValue.java
│       │   │               │   ├── CloneContract.java
│       │   │               │   ├── CompareContract.java
│       │   │               │   ├── CompareUsage.java
│       │   │               │   ├── ConditionChain.java
│       │   │               │   ├── CovariantArrays.java
│       │   │               │   ├── DeadLocalStore.java
│       │   │               │   ├── DroppedExceptionObject.java
│       │   │               │   ├── DubiousCatch.java
│       │   │               │   ├── DuplicateAssignment.java
│       │   │               │   ├── EasyMockProblems.java
│       │   │               │   ├── EmptySync.java
│       │   │               │   ├── EqualsContract.java
│       │   │               │   ├── ExceptionalExpression.java
│       │   │               │   ├── ExclusiveConditions.java
│       │   │               │   ├── ExposeRepresentation.java
│       │   │               │   ├── FieldAccess.java
│       │   │               │   ├── FinalizerContract.java
│       │   │               │   ├── FloatingPointComparison.java
│       │   │               │   ├── FloatingPointNaN.java
│       │   │               │   ├── IgnoredException.java
│       │   │               │   ├── IncorrectVarArg.java
│       │   │               │   ├── InfiniteLoop.java
│       │   │               │   ├── InfiniteRecursion.java
│       │   │               │   ├── InitializerRefersSubclass.java
│       │   │               │   ├── Internationalization.java
│       │   │               │   ├── InvalidMinMax.java
│       │   │               │   ├── IteratorContract.java
│       │   │               │   ├── JcipProblems.java
│       │   │               │   ├── KnownComparison.java
│       │   │               │   ├── LockProblems.java
│       │   │               │   ├── MinValueHandling.java
│       │   │               │   ├── MutableServletField.java
│       │   │               │   ├── Naming.java
│       │   │               │   ├── NegativeRemainder.java
│       │   │               │   ├── NewGetClass.java
│       │   │               │   ├── NoRuntimeRetention.java
│       │   │               │   ├── NonShortCircuit.java
│       │   │               │   ├── NullCheck.java
│       │   │               │   ├── NumberConstructor.java
│       │   │               │   ├── NumericComparison.java
│       │   │               │   ├── NumericPromotion.java
│       │   │               │   ├── RandomUsage.java
│       │   │               │   ├── RedundantInterfaces.java
│       │   │               │   ├── RedundantStreamCalls.java
│       │   │               │   ├── RegexProblems.java
│       │   │               │   ├── ReturnNull.java
│       │   │               │   ├── RoughConstant.java
│       │   │               │   ├── SameBranches.java
│       │   │               │   ├── SameIfChain.java
│       │   │               │   ├── SelfAssignment.java
│       │   │               │   ├── SelfComputation.java
│       │   │               │   ├── SerializationIdiom.java
│       │   │               │   ├── SpinLoop.java
│       │   │               │   ├── SqlBadArgument.java
│       │   │               │   ├── StartInConstructor.java
│       │   │               │   ├── StaticFieldFromInstanceMethod.java
│       │   │               │   ├── StaticFieldNonThreadSafe.java
│       │   │               │   ├── StringConcatInLoop.java
│       │   │               │   ├── StringIndex.java
│       │   │               │   ├── StringUsage.java
│       │   │               │   ├── SwingProblems.java
│       │   │               │   ├── SyncGetClass.java
│       │   │               │   ├── SyncOnUpdatedField.java
│       │   │               │   ├── ToArrayDowncast.java
│       │   │               │   ├── UncalledPrivateMethod.java
│       │   │               │   ├── UnnecessaryBoxing.java
│       │   │               │   ├── UnnecessaryInstanceOf.java
│       │   │               │   ├── UnreachableCatch.java
│       │   │               │   ├── UnsafeGetResource.java
│       │   │               │   ├── UnsupportedCall.java
│       │   │               │   ├── UnusedParameter.java
│       │   │               │   ├── UselessVoidMethod.java
│       │   │               │   ├── VolatileArray.java
│       │   │               │   ├── VolatileIncrement.java
│       │   │               │   ├── WaitContract.java
│       │   │               │   └── WrongMapIterator.java
│       │   │               ├── filter/
│       │   │               │   └── AnnotationFilters.java
│       │   │               ├── flow/
│       │   │               │   ├── Annotator.java
│       │   │               │   ├── Annotators.java
│       │   │               │   ├── BackLinkAnnotator.java
│       │   │               │   ├── CFG.java
│       │   │               │   ├── ClassFields.java
│       │   │               │   ├── CodeBlock.java
│       │   │               │   ├── ConstAnnotator.java
│       │   │               │   ├── Dataflow.java
│       │   │               │   ├── ETypeAnnotator.java
│       │   │               │   ├── EnumConstant.java
│       │   │               │   ├── Exceptional.java
│       │   │               │   ├── FrameContext.java
│       │   │               │   ├── GraphSearch.java
│       │   │               │   ├── Inf.java
│       │   │               │   ├── NullAnnotator.java
│       │   │               │   ├── Nullness.java
│       │   │               │   ├── PurityAnnotator.java
│       │   │               │   ├── SourceAnnotator.java
│       │   │               │   ├── TrueFalse.java
│       │   │               │   ├── ValuesFlow.java
│       │   │               │   └── etype/
│       │   │               │       ├── AndType.java
│       │   │               │       ├── ComplexType.java
│       │   │               │       ├── EType.java
│       │   │               │       ├── OrType.java
│       │   │               │       └── SingleType.java
│       │   │               ├── input/
│       │   │               │   └── XmlReportReader.java
│       │   │               ├── output/
│       │   │               │   ├── CombinedReportWriter.java
│       │   │               │   ├── HtmlReportWriter.java
│       │   │               │   ├── ReportWriter.java
│       │   │               │   ├── Reports.java
│       │   │               │   └── XmlReportWriter.java
│       │   │               ├── registry/
│       │   │               │   ├── AbstractTypeDatabase.java
│       │   │               │   ├── ClassContext.java
│       │   │               │   ├── ClassData.java
│       │   │               │   ├── DatabaseRegistry.java
│       │   │               │   ├── Detector.java
│       │   │               │   ├── DetectorRegistry.java
│       │   │               │   ├── ElementContext.java
│       │   │               │   ├── FieldContext.java
│       │   │               │   ├── FieldData.java
│       │   │               │   ├── MethodContext.java
│       │   │               │   ├── MethodData.java
│       │   │               │   └── anno/
│       │   │               │       ├── AssertNoWarning.java
│       │   │               │       ├── AssertWarning.java
│       │   │               │       ├── AstNodes.java
│       │   │               │       ├── AstVisitor.java
│       │   │               │       ├── ClassVisitor.java
│       │   │               │       ├── FieldVisitor.java
│       │   │               │       ├── MethodVisitor.java
│       │   │               │       ├── TypeDatabase.java
│       │   │               │       ├── TypeDatabaseItem.java
│       │   │               │       ├── VisitOrder.java
│       │   │               │       ├── WarningDefinition.java
│       │   │               │       └── WarningDefinitions.java
│       │   │               ├── repo/
│       │   │               │   ├── AuxRepository.java
│       │   │               │   ├── CompositeRepository.java
│       │   │               │   ├── DirRepository.java
│       │   │               │   ├── FilteredRepository.java
│       │   │               │   ├── JarRepository.java
│       │   │               │   ├── Repository.java
│       │   │               │   └── RepositoryVisitor.java
│       │   │               ├── spi/
│       │   │               │   ├── DataTests.java
│       │   │               │   └── HuntBugsPlugin.java
│       │   │               ├── util/
│       │   │               │   ├── AccessLevel.java
│       │   │               │   ├── Annotations.java
│       │   │               │   ├── Equi.java
│       │   │               │   ├── ExpressionFormatter.java
│       │   │               │   ├── Exprs.java
│       │   │               │   ├── Iterables.java
│       │   │               │   ├── Maps.java
│       │   │               │   ├── Methods.java
│       │   │               │   ├── NodeChain.java
│       │   │               │   ├── Nodes.java
│       │   │               │   ├── Types.java
│       │   │               │   ├── Variables.java
│       │   │               │   ├── Xml.java
│       │   │               │   └── YesNoMaybe.java
│       │   │               └── warning/
│       │   │                   ├── Formatter.java
│       │   │                   ├── Messages.java
│       │   │                   ├── Role.java
│       │   │                   ├── Roles.java
│       │   │                   ├── Warning.java
│       │   │                   ├── WarningAnnotation.java
│       │   │                   ├── WarningStatus.java
│       │   │                   ├── WarningType.java
│       │   │                   └── rule/
│       │   │                       ├── CategoryRule.java
│       │   │                       ├── CompositeRule.java
│       │   │                       ├── RegexRule.java
│       │   │                       └── Rule.java
│       │   └── resources/
│       │       └── huntbugs/
│       │           ├── messages.xml
│       │           ├── messages.xsd
│       │           ├── report.xsd
│       │           └── report.xsl
│       └── test/
│           └── java/
│               └── one/
│                   └── util/
│                       └── huntbugs/
│                           ├── AsserterTest.java
│                           ├── DataTest.java
│                           ├── FilteredRepositoryTest.java
│                           ├── MessagesTest.java
│                           ├── OptionsTest.java
│                           ├── ReportsTest.java
│                           ├── RuleTest.java
│                           ├── asserter/
│                           │   └── TestAsserter.java
│                           ├── registry/
│                           │   └── DetectorRegistryTest.java
│                           ├── testdata/
│                           │   ├── TestAbandonedStream.java
│                           │   ├── TestAppendObjectOutputStream.java
│                           │   ├── TestArrayRangeCheck.java
│                           │   ├── TestAtomicConcurrent.java
│                           │   ├── TestAverageComputation.java
│                           │   ├── TestBadMath.java
│                           │   ├── TestBadMethodCalls.java
│                           │   ├── TestBadMethodReferences.java
│                           │   ├── TestBadMonitorObject.java
│                           │   ├── TestCheckReturnValue.java
│                           │   ├── TestCloneContract.java
│                           │   ├── TestCompareContract.java
│                           │   ├── TestCompareUsage.java
│                           │   ├── TestConditionChain.java
│                           │   ├── TestCovariantArrays.java
│                           │   ├── TestDeadLocalStore.java
│                           │   ├── TestDroppedExceptionObject.java
│                           │   ├── TestDubiousCatch.java
│                           │   ├── TestDuplicateAssignment.java
│                           │   ├── TestEasyMockProblems.java
│                           │   ├── TestEmptySync.java
│                           │   ├── TestEqualsContract.java
│                           │   ├── TestExceptionalExpression.java
│                           │   ├── TestExclusiveConditions.java
│                           │   ├── TestExposeRepresentation.java
│                           │   ├── TestFieldAccess.java
│                           │   ├── TestFinalizer.java
│                           │   ├── TestFloatComparison.java
│                           │   ├── TestFloatNaN.java
│                           │   ├── TestIgnoredException.java
│                           │   ├── TestIncorrectVarArg.java
│                           │   ├── TestInfiniteLoop.java
│                           │   ├── TestInfiniteRecursion.java
│                           │   ├── TestInitializerRefersSubclass.java
│                           │   ├── TestInternationalization.java
│                           │   ├── TestInvalidMinMax.java
│                           │   ├── TestIteratorContract.java
│                           │   ├── TestJcipProblems.java
│                           │   ├── TestKnownComparison.java
│                           │   ├── TestLockProblems.java
│                           │   ├── TestMinValueHandling.java
│                           │   ├── TestMutableServletField.java
│                           │   ├── TestNaming.java
│                           │   ├── TestNegativeRemainder.java
│                           │   ├── TestNewGetClass.java
│                           │   ├── TestNoRuntimeRetention.java
│                           │   ├── TestNonShortCircuit.java
│                           │   ├── TestNullCheck.java
│                           │   ├── TestNumberConstructor.java
│                           │   ├── TestNumericComparison.java
│                           │   ├── TestNumericPromotion.java
│                           │   ├── TestRandomUsage.java
│                           │   ├── TestRedundantInterfaces.java
│                           │   ├── TestRedundantStreamCalls.java
│                           │   ├── TestRegexProblems.java
│                           │   ├── TestReturnNull.java
│                           │   ├── TestRoughConstants.java
│                           │   ├── TestSameBranches.java
│                           │   ├── TestSameIfChain.java
│                           │   ├── TestSelfAssignment.java
│                           │   ├── TestSelfComputation.java
│                           │   ├── TestSerializationIdiom.java
│                           │   ├── TestSpinLoop.java
│                           │   ├── TestSqlBadArgument.java
│                           │   ├── TestStartInConstructor.java
│                           │   ├── TestStaticFieldFromInstanceMethod.java
│                           │   ├── TestStaticFieldNonThreadSafe.java
│                           │   ├── TestStringConcatInLoop.java
│                           │   ├── TestStringIndex.java
│                           │   ├── TestStringUsage.java
│                           │   ├── TestSwingProblems.java
│                           │   ├── TestSyncGetClass.java
│                           │   ├── TestSyncOnUpdatedField.java
│                           │   ├── TestToArrayDowncast.java
│                           │   ├── TestUncalledPrivateMethod.java
│                           │   ├── TestUnnecessaryBoxing.java
│                           │   ├── TestUnnecessaryInstanceOf.java
│                           │   ├── TestUnreachableCatch.java
│                           │   ├── TestUnsafeGetResource.java
│                           │   ├── TestUnsupportedCall.java
│                           │   ├── TestUnusedParameter.java
│                           │   ├── TestUselessVoidMethod.java
│                           │   ├── TestValuesFlow.java
│                           │   ├── TestVolatileArray.java
│                           │   ├── TestVolatileIncrement.java
│                           │   ├── TestWaitContract.java
│                           │   ├── TestWrongMapIterator.java
│                           │   └── sub/
│                           │       └── SubFieldAccess.java
│                           └── util/
│                               └── TestIterables.java
├── huntbugs-ant-plugin/
│   ├── .classpath
│   ├── .gitignore
│   ├── .project
│   ├── .settings/
│   │   ├── org.eclipse.core.resources.prefs
│   │   ├── org.eclipse.jdt.core.prefs
│   │   └── org.eclipse.m2e.core.prefs
│   ├── pom.xml
│   └── src/
│       └── main/
│           ├── java/
│           │   └── one/
│           │       └── util/
│           │           └── huntbugs/
│           │               └── ant/
│           │                   └── HuntBugsTask.java
│           └── resources/
│               └── one/
│                   └── util/
│                       └── huntbugs/
│                           └── ant/
│                               └── antlib.xml
├── huntbugs-maven-plugin/
│   ├── .classpath
│   ├── .gitignore
│   ├── .project
│   ├── .settings/
│   │   ├── org.eclipse.core.resources.prefs
│   │   ├── org.eclipse.jdt.core.prefs
│   │   ├── org.eclipse.jdt.ui.prefs
│   │   ├── org.eclipse.m2e.core.prefs
│   │   └── org.eclipse.pde.core.prefs
│   ├── pom.xml
│   └── src/
│       └── main/
│           └── java/
│               └── one/
│                   └── util/
│                       └── huntbugs/
│                           └── maven/
│                               └── plugin/
│                                   └── HuntBugsMojo.java
├── pom.xml
├── sample-huntbugs-custom-detector/
│   ├── .gitignore
│   ├── pom.xml
│   └── src/
│       ├── main/
│       │   ├── java/
│       │   │   └── one/
│       │   │       └── util/
│       │   │           └── huntbugs/
│       │   │               └── sample/
│       │   │                   ├── SampleHuntBugsPlugin.java
│       │   │                   └── detect/
│       │   │                       └── SampleCustomDetector.java
│       │   └── resources/
│       │       ├── META-INF/
│       │       │   └── services/
│       │       │       └── one.util.huntbugs.spi.HuntBugsPlugin
│       │       └── huntbugs/
│       │           └── messages.xml
│       └── test/
│           └── java/
│               └── one/
│                   └── util/
│                       └── huntbugs/
│                           └── sample/
│                               ├── DataTest.java
│                               └── testdata/
│                                   └── TestSampleCustomDetector.java
└── sample-project/
    ├── .gitignore
    ├── pom.xml
    └── src/
        ├── main/
        │   └── java/
        │       └── one/
        │           └── util/
        │               └── huntbugs/
        │                   └── sample/
        │                       └── MyProductionCode.java
        └── test/
            └── java/
                └── one/
                    └── util/
                        └── huntbugs/
                            └── sample/
                                └── MyProductionCodeTest.java

SYMBOL INDEX (2561 symbols across 285 files)

FILE: huntbugs-ant-plugin/src/main/java/one/util/huntbugs/ant/HuntBugsTask.java
  class HuntBugsTask (line 50) | public class HuntBugsTask extends Task {
    type LogLevel (line 51) | public enum LogLevel {
    method execute (line 67) | @Override
    method addListener (line 95) | private void addListener(Context ctx) {
    method createRepository (line 106) | private List<Repository> createRepository() {
    method setClassPath (line 148) | public void setClassPath(Path classPath) {
    method setAuxClassPath (line 154) | public void setAuxClassPath(Path auxClassPath) {
    method setDiff (line 160) | public void setDiff(File diff) {
    method setXml (line 164) | public void setXml(File xml) {
    method setHtml (line 168) | public void setHtml(File html) {
    method setLog (line 172) | public void setLog(LogLevel log) {

FILE: huntbugs-maven-plugin/src/main/java/one/util/huntbugs/maven/plugin/HuntBugsMojo.java
  class HuntBugsMojo (line 62) | @Mojo(name = "huntbugs", defaultPhase = LifecyclePhase.PREPARE_PACKAGE, ...
    method execute (line 115) | @Override
    method constructRepository (line 133) | private Repository constructRepository() throws IOException {
    method addDependency (line 172) | private void addDependency(Artifact art, List<ITypeLoader> deps) throw...
    method constructOptions (line 190) | private AnalysisOptions constructOptions() {
    method addAnalysisProgressListener (line 197) | private void addAnalysisProgressListener(Context ctx) {
    method writeReports (line 208) | private void writeReports(Context ctx) throws Exception {

FILE: huntbugs/src/main/java/one/util/huntbugs/HuntBugs.java
  class HuntBugs (line 59) | public class HuntBugs {
    method parseCommandLine (line 68) | private void parseCommandLine(String[] args) {
    method createRepository (line 149) | private Repository createRepository(Path path) {
    method createTypeLoader (line 157) | private ITypeLoader createTypeLoader(Path path) {
    method run (line 165) | private int run(String[] args) {
    method glob (line 258) | static Stream<Path> glob(String mask) throws IOException {
    method main (line 273) | public static void main(String[] args) {

FILE: huntbugs/src/main/java/one/util/huntbugs/analysis/AnalysisListener.java
  type AnalysisListener (line 22) | @FunctionalInterface
    method eventOccurred (line 31) | public boolean eventOccurred(String stepName, String className, int co...

FILE: huntbugs/src/main/java/one/util/huntbugs/analysis/AnalysisOptions.java
  class AnalysisOptions (line 29) | public class AnalysisOptions {
    method set (line 36) | public void set(String name, String valueString) {
    method getRule (line 63) | public Rule getRule() {
    method setRule (line 67) | public void setRule(Rule rule) {
    method report (line 71) | public void report(PrintStream out) {

FILE: huntbugs/src/main/java/one/util/huntbugs/analysis/Context.java
  class Context (line 53) | public class Context implements HuntBugsResult {
    method Context (line 68) | public Context(Repository repository, AnalysisOptions options) {
    method getMessages (line 79) | @Override
    method getOptions (line 87) | public AnalysisOptions getOptions() {
    method addListener (line 91) | public void addListener(AnalysisListener listener) {
    method fireEvent (line 95) | boolean fireEvent(String stepName, String className, int step, int tot...
    method analyzePackage (line 103) | public void analyzePackage(String name) {
    method preparingClasses (line 126) | private boolean preparingClasses(Set<String> classes) {
    method createMetadataSystem (line 177) | MetadataSystem createMetadataSystem() {
    method lookUp (line 201) | private TypeDefinition lookUp(MetadataSystem ms, String className) {
    method analyzingClasses (line 210) | private void analyzingClasses(Set<String> classes) {
    method analyzeClass (line 224) | void analyzeClass(MetadataSystem ms, String name) {
    method addError (line 237) | public void addError(ErrorMessage msg) {
    method addWarning (line 242) | public void addWarning(Warning warning) {
    method warnings (line 249) | @Override
    method errors (line 254) | @Override
    method reportWarnings (line 259) | public void reportWarnings(PrintStream app) {
    method reportStats (line 266) | public void reportStats(PrintStream app) {
    method reportErrors (line 290) | public void reportErrors(PrintStream app) {
    method reportWarningTypes (line 294) | public void reportWarningTypes(PrintStream out) {
    method reportDatabases (line 298) | public void reportDatabases(PrintStream out) {
    method reportTitles (line 302) | public void reportTitles(PrintStream out) {
    method getClassesCount (line 306) | public int getClassesCount() {
    method getTotalClasses (line 310) | public int getTotalClasses() {
    method getErrorCount (line 314) | public int getErrorCount() {
    method incStat (line 318) | public void incStat(String key) {
    method warningTypes (line 322) | public Stream<WarningType> warningTypes() {
    method getWarningType (line 326) | public WarningType getWarningType(String typeName) {
    method getStat (line 330) | public long getStat(String key) {
    method getMainType (line 334) | private static String getMainType(String internalName) {

FILE: huntbugs/src/main/java/one/util/huntbugs/analysis/ErrorMessage.java
  class ErrorMessage (line 30) | public class ErrorMessage {
    method ErrorMessage (line 39) | public ErrorMessage(Detector detector, MemberReference method, int lin...
    method ErrorMessage (line 44) | public ErrorMessage(Detector detector, TypeDefinition type, Throwable ...
    method ErrorMessage (line 48) | public ErrorMessage(Detector detector, TypeDefinition type, String mes...
    method ErrorMessage (line 52) | public ErrorMessage(Detector detector, MemberReference method, int lin...
    method ErrorMessage (line 57) | public ErrorMessage(String detector, String className, String elementN...
    method ErrorMessage (line 67) | public ErrorMessage(String detector, String className, String elementN...
    method getClassName (line 77) | public String getClassName() {
    method getElementName (line 81) | public String getElementName() {
    method getDescriptor (line 85) | public String getDescriptor() {
    method getLine (line 89) | public int getLine() {
    method getDetector (line 93) | public String getDetector() {
    method getError (line 97) | public String getError() {
    method toString (line 105) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/analysis/HuntBugsResult.java
  type HuntBugsResult (line 27) | public interface HuntBugsResult {
    method getMessages (line 31) | Messages getMessages();
    method warnings (line 36) | Stream<Warning> warnings();
    method errors (line 41) | Stream<ErrorMessage> errors();

FILE: huntbugs/src/main/java/one/util/huntbugs/assertions/AssertionData.java
  class AssertionData (line 26) | class AssertionData {
    type Status (line 32) | enum Status {
    method AssertionData (line 36) | AssertionData(boolean hasWarning, String type, int minScore, int maxSc...
    method check (line 51) | Status check(Warning warning) {
    method finalStatus (line 67) | Status finalStatus() {
    method toString (line 71) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/assertions/MemberAsserter.java
  class MemberAsserter (line 38) | public class MemberAsserter {
    method MemberAsserter (line 45) | private MemberAsserter(MemberAsserter parent, List<AssertionData> data) {
    method forMember (line 52) | public static MemberAsserter forMember(MemberReference md) {
    method forMember (line 59) | public static MemberAsserter forMember(MemberAsserter parent, MemberRe...
    method analyzeMember (line 66) | private static List<AssertionData> analyzeMember(MemberReference md) {
    method checkWarning (line 95) | public void checkWarning(Consumer<String> errorConsumer, Warning warni...
    method checkFinally (line 111) | public void checkFinally(Consumer<String> errorConsumer) {
    method isEmpty (line 124) | public boolean isEmpty() {

FILE: huntbugs/src/main/java/one/util/huntbugs/db/DeclaredAnnotations.java
  class DeclaredAnnotations (line 36) | @TypeDatabase
    method DeclaredAnnotations (line 39) | public DeclaredAnnotations() {
    method visitType (line 43) | @Override
    class DeclaredAnnotation (line 65) | @TypeDatabaseItem(parentDatabase = DeclaredAnnotations.class)
      method getPolicy (line 69) | public RetentionPolicy getPolicy() {

FILE: huntbugs/src/main/java/one/util/huntbugs/db/FieldStats.java
  class FieldStats (line 46) | @TypeDatabase
    method FieldStats (line 61) | public FieldStats() {
    class SimpleStack (line 65) | static final class SimpleStack {
      method SimpleStack (line 73) | SimpleStack(int maxLocals) {
      method registerJump (line 78) | void registerJump(Instruction instr) {
      method preprocess (line 84) | void preprocess(Instruction instr) {
      method set (line 91) | void set(int slot, Object cst) {
      method setUnknown (line 95) | void setUnknown(int slot) {
      method get (line 99) | Object get(int slot) {
      method pushUnknown (line 103) | void pushUnknown() {
      method push (line 107) | void push(Object cst) {
      method poll (line 111) | Object poll() {
      method clear (line 116) | void clear() {
    method visitType (line 121) | @Override
    method linkUncontrolled (line 225) | private void linkUncontrolled(Object type, Object fieldName) {
    method getFlags (line 235) | public int getFlags(FieldReference fr) {
    class TypeFieldStats (line 240) | @TypeDatabaseItem(parentDatabase=FieldStats.class)
      method linkUncontrolled (line 245) | void linkUncontrolled(String fieldName) {
      method getFlags (line 250) | public int getFlags(String name) {
      method linkUncontrolled (line 257) | void linkUncontrolled() {
      method link (line 261) | void link(MethodDefinition src, FieldReference fr, boolean isStatic,...

FILE: huntbugs/src/main/java/one/util/huntbugs/db/Hierarchy.java
  class Hierarchy (line 39) | @TypeDatabase
    method Hierarchy (line 41) | public Hierarchy() {
    method visitType (line 45) | @Override
    method isOverridden (line 54) | public boolean isOverridden(MethodDefinition md) {
    method link (line 63) | private void link(TypeHierarchy th, TypeReference superType) {
    class TypeHierarchy (line 71) | @TypeDatabaseItem(parentDatabase = Hierarchy.class)
      method TypeHierarchy (line 78) | public TypeHierarchy(String name) {
      method getInternalName (line 82) | public String getInternalName() {
      method getSuperClasses (line 86) | public Set<TypeHierarchy> getSuperClasses() {
      method getSubClasses (line 90) | public Set<TypeHierarchy> getSubClasses() {
      method isOverridden (line 94) | boolean isOverridden(IMetadataResolver resolver, MemberInfo mi) {
      method isResolved (line 113) | public boolean isResolved() {
      method hasFlag (line 117) | public boolean hasFlag(long flag) {
      method toString (line 121) | @Override
      method hasSubClasses (line 126) | public boolean hasSubClasses() {
      method hasSubClassesOutOfPackage (line 130) | public boolean hasSubClassesOutOfPackage() {

FILE: huntbugs/src/main/java/one/util/huntbugs/db/MethodStats.java
  class MethodStats (line 41) | @TypeDatabase
    method MethodStats (line 53) | public MethodStats() {
    method getMethodData (line 57) | private MethodData getMethodData(MethodDefinition md) {
    method visitType (line 74) | @Override
    method getStats (line 88) | public MethodData getStats(MemberInfo mi) {
    method getStats (line 92) | public MethodData getStats(MethodReference mr) {
    method visitMethod (line 96) | private void visitMethod(MethodData mdata, MethodDefinition md) {
    method visitBody (line 107) | private void visitBody(MethodData mdata, MethodBody body) {
    class MethodData (line 180) | public static class MethodData {
      method addSubMethod (line 184) | void addSubMethod(MethodData md) {
      method testAny (line 193) | public boolean testAny(long flag, boolean exact) {
      method mayHaveSideEffect (line 205) | public boolean mayHaveSideEffect(boolean exact) {

FILE: huntbugs/src/main/java/one/util/huntbugs/db/Mutability.java
  class Mutability (line 29) | @TypeDatabase
    method Mutability (line 31) | public Mutability() {
    method visitType (line 35) | @Override
    method isKnownMutable (line 47) | public boolean isKnownMutable(TypeReference tr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/AbandonedStream.java
  class AbandonedStream (line 35) | @WarningDefinition(category="Correctness", name="AbandonedStream", maxSc...
    method visit (line 38) | @AstVisitor(nodes=AstNodes.EXPRESSIONS, minVersion=8)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/AppendObjectOutputStream.java
  class AppendObjectOutputStream (line 36) | @WarningDefinition(category = "Correctness", name = "AppendObjectOutputS...
    method visit (line 41) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method isBufferedStream (line 59) | private static boolean isBufferedStream(Expression expr) {
    method isAppendOutput (line 70) | private static boolean isAppendOutput(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/ArrayRangeCheck.java
  class ArrayRangeCheck (line 38) | @WarningDefinition(category = "Correctness", name = "ArrayIndexNegative"...
    method visit (line 46) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method checkNegative (line 92) | private static Integer checkNegative(MethodContext mc, Expression expr...
    method getMaxLength (line 103) | private static long getMaxLength(Expression expression) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/AtomicConcurrent.java
  class AtomicConcurrent (line 42) | @WarningDefinition(category = "Multithreading", name = "NonAtomicOperati...
    method visit (line 47) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method isGetOrContains (line 98) | private boolean isGetOrContains(Expression self, Expression key, Expre...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/AverageComputation.java
  class AverageComputation (line 32) | @WarningDefinition(category = "BadPractice", name = "AverageComputationC...
    method visitExpression (line 34) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method isDiv2 (line 47) | private boolean isDiv2(Expression idx) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/BadMath.java
  class BadMath (line 40) | @WarningDefinition(category = "Correctness", name = "RemOne", maxScore =...
    method checkWrongPriority (line 57) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method visit (line 88) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method checkSignedByte (line 188) | private void checkSignedByte(Expression expr, MethodContext mc) {
    method isByte (line 199) | private static boolean isByte(Expression expr) {
    method isLow8BitsClear (line 206) | private static boolean isLow8BitsClear(Expression arg) {
    method isConst (line 227) | private static boolean isConst(Expression expr, long wantedValue) {
    method isIntegral (line 232) | private static boolean isIntegral(Object constant) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/BadMethodCalls.java
  class BadMethodCalls (line 50) | @WarningDefinition(category = "BadPractice", name = "SystemExit", maxSco...
    method visit (line 79) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method checkConstructor (line 88) | private void checkConstructor(Expression node, MethodReference mr, Met...
    method check (line 120) | private void check(Expression node, MethodReference mr, NodeChain nc, ...
    method fromFile (line 259) | private boolean fromFile(Expression expr) {
    method isToStringCall (line 274) | private boolean isToStringCall(String typeName, String name, String si...
    method isTimeMeasure (line 285) | private static boolean isTimeMeasure(Node node) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/BadMethodReferences.java
  class BadMethodReferences (line 38) | @WarningDefinition(category="Correctness", name="MaxMinMethodReferenceFo...
    method visit (line 40) | @AstVisitor(nodes=AstNodes.EXPRESSIONS, minVersion=8)
    method check (line 54) | private void check(MethodHandle handle, TypeReference functionalInterf...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/BadMonitorObject.java
  class BadMonitorObject (line 36) | @WarningDefinition(category="Multithreading", name="SynchronizationOnBoo...
    method visit (line 42) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/CheckReturnValue.java
  class CheckReturnValue (line 35) | @WarningDefinition(category="BadPractice", name="ReturnValueOfRead", max...
    method visit (line 38) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method isInputStream (line 65) | private boolean isInputStream(TypeReference type) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/CloneContract.java
  class CloneContract (line 47) | @WarningDefinition(category="BadPractice", name="CloneableDoesNotImpleme...
    method beforeClass (line 55) | @ClassVisitor(order=VisitOrder.BEFORE)
    method visitBody (line 65) | @AstVisitor(nodes=AstNodes.ROOT, methodName="clone")
    method afterClass (line 102) | @ClassVisitor(order=VisitOrder.AFTER)
    method referencesClone (line 109) | private static boolean referencesClone(TypeDefinition td) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/CompareContract.java
  class CompareContract (line 37) | @WarningDefinition(category="BadPractice", name="CompareReturnsMinValue"...
    method check (line 41) | @MethodVisitor
    method visit (line 54) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/CompareUsage.java
  class CompareUsage (line 38) | @WarningDefinition(category = "BadPractice", name = "NegatingComparatorR...
    method visit (line 41) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method isCompare (line 63) | private boolean isCompare(Expression child) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/ConditionChain.java
  class ConditionChain (line 38) | @WarningDefinition(category = "RedundantCode", name = "SameConditions", ...
    method visit (line 43) | @AstVisitor
    method check (line 59) | private void check(Expression left, Expression right, AstCode condCode...
    method check (line 69) | private void check(Expression expr, Block block, MethodContext mc, boo...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/CovariantArrays.java
  class CovariantArrays (line 41) | @WarningDefinition(category="Correctness", name="ContravariantArrayStore...
    method visit (line 43) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method toRawType (line 72) | private TypeReference toRawType(TypeReference type) {
    method allImplementationsDerivedFromSubclass (line 88) | private boolean allImplementationsDerivedFromSubclass(Hierarchy h, Typ...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/DeadLocalStore.java
  class DeadLocalStore (line 46) | @WarningDefinition(category="RedundantCode", name="DeadStoreInReturn", m...
    method visit (line 53) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/DroppedExceptionObject.java
  class DroppedExceptionObject (line 35) | @WarningDefinition(category="Correctness", name="DroppedException", maxS...
    method visit (line 37) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/DubiousCatch.java
  class DubiousCatch (line 36) | @WarningDefinition(category="BadPractice", name="CatchIllegalMonitorStat...
    method visit (line 46) | @AstVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/DuplicateAssignment.java
  class DuplicateAssignment (line 39) | @WarningDefinition(category="RedundantCode", name="FieldDoubleAssignment...
    method visit (line 43) | @AstVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/EasyMockProblems.java
  class EasyMockProblems (line 38) | @WarningDefinition(category = "RedundantCode", name = "UselessEasyMockCa...
    method check (line 40) | @ClassVisitor
    method visit (line 46) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/EmptySync.java
  class EmptySync (line 34) | @WarningDefinition(category="Multithreading", name="EmptySynchronizeBloc...
    method visit (line 36) | @AstVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/EqualsContract.java
  class EqualsContract (line 54) | @WarningDefinition(category = "BadPractice", name = "EqualsReturnsTrue",...
    method visitEquals (line 72) | @AstVisitor(nodes = AstNodes.ROOT, methodName = "equals", methodSignat...
    method isInstanceOfAndSuperEquals (line 125) | private static boolean isInstanceOfAndSuperEquals(Expression expr) {
    method isSelfCheck (line 142) | private static boolean isSelfCheck(Expression expr) {
    method visitClass (line 152) | @ClassVisitor(order = VisitOrder.AFTER)
    method getPriority (line 224) | private static int getPriority(TypeDefinition td) {
    method getPriority (line 233) | private static int getPriority(MethodDefinition md) {
    method visitEqualsExpression (line 242) | @AstVisitor(nodes = AstNodes.EXPRESSIONS, methodName = "equals", metho...
    method isParameter (line 269) | private static boolean isParameter(Expression expr) {
    method isComparison (line 276) | private static boolean isComparison(Expression expr) {
    method checkGetName (line 294) | private void checkGetName(Expression expr, MethodContext mc, Expressio...
    method isClassGetName (line 306) | private static boolean isClassGetName(Expression expr) {
    method isGetClass (line 315) | private static boolean isGetClass(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/ExceptionalExpression.java
  class ExceptionalExpression (line 34) | @WarningDefinition(category="Correctness", name="ExceptionalExpression",...
    method visit (line 36) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/ExclusiveConditions.java
  class ExclusiveConditions (line 40) | @WarningDefinition(category = "Correctness", name = "AndEqualsAlwaysFals...
    method init (line 48) | @MethodVisitor
    method visit (line 53) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method isEquality (line 79) | private boolean isEquality(Expression expr) {
    method isNonEquality (line 88) | private boolean isNonEquality(Expression expr) {
    method checkEqual (line 100) | private void checkEqual(Expression equality, Expression other, MethodC...
    method checkNonEqual (line 129) | private void checkNonEqual(Expression equality, Expression other, Meth...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/ExposeRepresentation.java
  class ExposeRepresentation (line 43) | @WarningDefinition(category = "MaliciousCode", name = "ExposeMutableFiel...
    method checkClass (line 46) | @ClassVisitor
    method checkMethod (line 51) | @MethodVisitor
    method visit (line 56) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method getField (line 80) | private FieldDefinition getField(Expression expr, MethodDefinition md) {
    method getParameter (line 101) | private ParameterDefinition getParameter(Expression value) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/FieldAccess.java
  class FieldAccess (line 64) | @WarningDefinition(category="RedundantCode", name="UnusedPrivateField", ...
    class MethodLocation (line 91) | static class MethodLocation {
      method MethodLocation (line 95) | public MethodLocation(MethodDefinition md, Location loc) {
      method getAnnotations (line 100) | public WarningAnnotation<?>[] getAnnotations() {
    class FieldRecord (line 106) | static class FieldRecord {
    method visitCode (line 120) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method isMutableCollectionFactory (line 198) | private boolean isMutableCollectionFactory(Expression value, MethodRef...
    method isEmptyArray (line 211) | private static boolean isEmptyArray(Expression value) {
    method checkAnalyzed (line 216) | @MethodVisitor(order=VisitOrder.AFTER)
    method visit (line 221) | @FieldVisitor
    method checkWrite (line 330) | private boolean checkWrite(FieldContext fc, FieldDefinition fd, TypeDe...
    method tweakForSerialization (line 356) | private int tweakForSerialization(FieldDefinition fd, TypeDefinition t...
    method checkNull (line 367) | private boolean checkNull(FieldContext fc, FieldDefinition fd, TypeDef...
    method checkSingleMethod (line 386) | private void checkSingleMethod(FieldContext fc, FieldDefinition fd, Fi...
    method getWriteAnnotations (line 407) | private WarningAnnotation<?>[] getWriteAnnotations(FieldRecord fieldRe...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/FinalizerContract.java
  class FinalizerContract (line 38) | @WarningDefinition(category = "BadPractice", name = "FinalizeNullifiesSu...
    method visitFinalizer (line 47) | @AstVisitor(nodes = AstNodes.ROOT, methodName = "finalize", methodSign...
    method isSuperCall (line 89) | private boolean isSuperCall(Node child) {
    method visit (line 94) | @AstVisitor
    method isFinalizer (line 102) | private static boolean isFinalizer(MethodReference mr) {
    method getSuperfinalizer (line 106) | private static MethodDefinition getSuperfinalizer(TypeDefinition type) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/FloatingPointComparison.java
  class FloatingPointComparison (line 42) | @WarningDefinition(category = "BadPractice", name = "FloatComparison", m...
    method visit (line 44) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method tweakPriority (line 72) | private int tweakPriority(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/FloatingPointNaN.java
  class FloatingPointNaN (line 31) | @WarningDefinition(category="Correctness", name="FloatCompareToNaN", max...
    method visit (line 35) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/IgnoredException.java
  class IgnoredException (line 38) | @WarningDefinition(category="BadPractice", name="IgnoredException", maxS...
    method visit (line 40) | @AstVisitor
    method getExceptionPriority (line 54) | private static int getExceptionPriority(TypeReference tr) {
    method isTrivial (line 69) | private boolean isTrivial(List<Node> body, Variable variable) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/IncorrectVarArg.java
  class IncorrectVarArg (line 34) | @WarningDefinition(category="Correctness", name="PrimitiveArrayPassedAsV...
    method visit (line 36) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method highPriority (line 62) | private static boolean highPriority(MethodReference mr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/InfiniteLoop.java
  class InfiniteLoop (line 38) | @WarningDefinition(category = "Correctness", name = "InfiniteLoop", maxS...
    method visit (line 42) | @AstVisitor
    method checkCondition (line 55) | private void checkCondition(MethodContext mc, Loop loop, Expression ex...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/InfiniteRecursion.java
  class InfiniteRecursion (line 46) | @WarningDefinition(category = "Correctness", name = "InfiniteRecursion",...
    method init (line 51) | @MethodVisitor
    method visit (line 56) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method selfCall (line 78) | private boolean selfCall(Expression expr, MethodDefinition md) {
    method checkControlFlow (line 98) | private boolean checkControlFlow(NodeChain nc) {
    method checkArgs (line 114) | private boolean checkArgs(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/InitializerRefersSubclass.java
  class InitializerRefersSubclass (line 35) | @WarningDefinition(category="Multithreading", name="InitializerRefersSub...
    method visit (line 37) | @AstVisitor(nodes=AstNodes.EXPRESSIONS, methodName="<clinit>")

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/Internationalization.java
  class Internationalization (line 38) | @WarningDefinition(category="Internationalization", name="ConvertCaseWit...
    method add (line 43) | private static void add(String className, String methodName, String ba...
    method visit (line 80) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/InvalidMinMax.java
  class InvalidMinMax (line 34) | @WarningDefinition(category = "Correctness", name = "InvalidMinMax", max...
    method detectMethod (line 45) | private static int detectMethod(Node node) {
    method visit (line 59) | @AstVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/IteratorContract.java
  class IteratorContract (line 43) | @WarningDefinition(category = "BadPractice", name = "IteratorHasNextCall...
    method check (line 46) | @MethodVisitor
    method visitHasNext (line 51) | @AstVisitor(nodes = AstNodes.EXPRESSIONS, methodName = "hasNext", meth...
    method visitNext (line 61) | @AstVisitor(nodes = AstNodes.ROOT, methodName = "next")

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/JcipProblems.java
  class JcipProblems (line 32) | @WarningDefinition(category="BadPractice", name="NonFinalFieldInImmutabl...
    method checkClass (line 34) | @ClassVisitor
    method visitField (line 44) | @FieldVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/KnownComparison.java
  class KnownComparison (line 37) | @WarningDefinition(category = "RedundantCode", name = "ResultOfCompariso...
    method visit (line 44) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/LockProblems.java
  class LockProblems (line 38) | @WarningDefinition(category = "Multithreading", name = "IncorrectConcurr...
    method visit (line 42) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method findReplacement (line 62) | private static MethodDefinition findReplacement(String name, TypeDefin...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/MinValueHandling.java
  class MinValueHandling (line 35) | @WarningDefinition(category="Correctness", name="AbsoluteValueOfHashCode...
    method visit (line 38) | @AstVisitor
    method checkAbs (line 53) | private void checkAbs(MethodContext mc, Node body, Node parent, int pr...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/MutableServletField.java
  class MutableServletField (line 45) | @WarningDefinition(category = "Multithreading", name = "MutableServletFi...
    class MethodLocation (line 47) | static class MethodLocation {
      method MethodLocation (line 51) | public MethodLocation(MethodDefinition md, Location loc) {
      method getAnnotations (line 56) | public WarningAnnotation<?>[] getAnnotations() {
    method checkClass (line 64) | @ClassVisitor
    method checkMethod (line 69) | @MethodVisitor
    method visitCode (line 74) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/Naming.java
  class Naming (line 45) | @WarningDefinition(category = "CodeStyle", name = "BadNameOfMethod", max...
    method visitClass (line 58) | @ClassVisitor
    method visitMethod (line 80) | @MethodVisitor
    method getFutureKeywordVersion (line 119) | private String getFutureKeywordVersion(String name) {
    method checkSameAsConstructor (line 134) | @AstVisitor(nodes = AstNodes.ROOT)
    method visitField (line 151) | @FieldVisitor
    method getMistakeFix (line 162) | private MemberInfo getMistakeFix(MethodDefinition md) {
    method badMethodName (line 175) | private boolean badMethodName(String mName) {
    method badFieldName (line 181) | private boolean badFieldName(FieldDefinition fd) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NegativeRemainder.java
  class NegativeRemainder (line 34) | @WarningDefinition(category="Correctness", name="HashCodeRemainder", max...
    method visit (line 37) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method check (line 57) | private void check(Expression expr, MethodContext mc) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NewGetClass.java
  class NewGetClass (line 33) | @WarningDefinition(category="Performance", name="NewForGetClass", maxSco...
    method visit (line 37) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NoRuntimeRetention.java
  class NoRuntimeRetention (line 38) | @WarningDefinition(category = "Correctness", name = "AnnotationNoRuntime...
    method visit (line 42) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NonShortCircuit.java
  class NonShortCircuit (line 37) | @WarningDefinition(category = "CodeStyle", name = "NonShortCircuit", max...
    method visitNode (line 40) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NullCheck.java
  class NullCheck (line 43) | @WarningDefinition(category = "Correctness", name = "NullDereferenceGuar...
    method visit (line 58) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NumberConstructor.java
  class NumberConstructor (line 39) | @WarningDefinition(category = "Performance", name = "NumberConstructor",...
    method visit (line 42) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NumericComparison.java
  class NumericComparison (line 51) | @WarningDefinition(category = "Correctness", name = "ComparisonWithOutOf...
    class LongRange (line 63) | static class LongRange {
      method LongRange (line 67) | public LongRange(AstCode code, long constant) {
      method absInt (line 98) | LongRange absInt() {
      method union (line 106) | LongRange union(LongRange other) {
      method LongRange (line 112) | LongRange(long min, long max) {
      method isTrueEmpty (line 118) | boolean isTrueEmpty(LongRange realRange) {
      method isFalseEmpty (line 124) | boolean isFalseEmpty(LongRange realRange) {
    method visit (line 131) | @AstVisitor(nodes = AstNodes.ALL)
    method getIntegralType (line 224) | private JvmType getIntegralType(Expression expression) {
    method checkRem2Eq1 (line 250) | private void checkRem2Eq1(MethodContext mc, JvmType jvmType, AstCode c...
    method getExpressionRange (line 267) | private static LongRange getExpressionRange(JvmType type, Expression a...
    method getExpressionRange (line 271) | private static LongRange getExpressionRange(JvmType type, Expression a...
    method getTypeRange (line 288) | private static LongRange getTypeRange(JvmType type) {
    method intRange (line 305) | private static LongRange intRange(Expression arg, Set<Expression> visi...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/NumericPromotion.java
  class NumericPromotion (line 48) | @WarningDefinition(category = "Correctness", name = "IntegerMultiplicati...
    method visit (line 56) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method isPowerOfTen (line 157) | private boolean isPowerOfTen(long divisorVal) {
    method getSourceType (line 163) | private static String getSourceType(Expression expr) {
    method getTargetType (line 176) | private static String getTargetType(Expression expr) {
    method getMultiplicationConstant (line 189) | private static BigInteger getMultiplicationConstant(Expression arg) {
    method isToFloatingPointConversion (line 209) | private static boolean isToFloatingPointConversion(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/RandomUsage.java
  class RandomUsage (line 41) | @WarningDefinition(category = "Performance", name = "RandomNextIntViaNex...
    method visit (line 47) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method checkOnlyOnce (line 73) | void checkOnlyOnce(Expression node, MethodContext ctx) {
    method isRandomInit (line 88) | private boolean isRandomInit(Expression expr) {
    method getReplacement (line 98) | private WarningAnnotation<MemberInfo> getReplacement(String type) {
    method isRandomDouble (line 103) | private boolean isRandomDouble(Node node) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/RedundantInterfaces.java
  class RedundantInterfaces (line 31) | @WarningDefinition(category = "CodeStyle", name = "RedundantInterface", ...
    method visit (line 33) | @ClassVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/RedundantStreamCalls.java
  class RedundantStreamCalls (line 40) | @WarningDefinition(category="RedundantCode", name="RedundantStreamForEac...
    method visit (line 45) | @AstVisitor(nodes=AstNodes.EXPRESSIONS, minVersion=8)
    method isCollectionStream (line 114) | private boolean isCollectionStream(MethodReference mr) {
    method isStreamForEach (line 119) | private boolean isStreamForEach(MethodReference mr) {
    method isOptionalIsPresent (line 125) | private boolean isOptionalIsPresent(MethodReference mr) {
    method isStreamFind (line 129) | private boolean isStreamFind(MethodReference mr) {
    method isStreamCount (line 134) | private boolean isStreamCount(MethodReference mr) {
    method isStreamFilter (line 138) | private boolean isStreamFilter(MethodReference mr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/RegexProblems.java
  class RegexProblems (line 41) | @WarningDefinition(category="Correctness", name="RegexUnintended", maxSc...
    method visit (line 47) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method checkBadPatterns (line 68) | private void checkBadPatterns(MethodContext mc, Expression regexExpr, ...
    method checkRegexp (line 86) | private void checkRegexp(MethodContext mc, Expression regexExpr, int f...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/ReturnNull.java
  class ReturnNull (line 39) | @WarningDefinition(category = "BadPractice", name = "OptionalReturnNull"...
    method checkMethod (line 53) | public boolean checkMethod(MethodDefinition md) {
    method visit (line 62) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/RoughConstant.java
  class RoughConstant (line 37) | @WarningDefinition(category="BadPractice", name="RoughConstantValue", ma...
    class BadConstant (line 39) | static class BadConstant {
      method BadConstant (line 46) | BadConstant(double base, double factor, String replacement, int base...
      method exact (line 61) | public boolean exact(Number candidate) {
      method diff (line 68) | public double diff(double candidate) {
      method equalPrefix (line 72) | public boolean equalPrefix(Number candidate) {
      method addApprox (line 76) | private void addApprox(BigDecimal roundFloor) {
    method visit (line 98) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method getPriority (line 134) | private int getPriority(BadConstant badConstant, Number constValue, do...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SameBranches.java
  class SameBranches (line 46) | @WarningDefinition(category = "RedundantCode", name = "SameBranchesIf", ...
    method check (line 55) | @MethodVisitor
    method visit (line 67) | @AstVisitor
    method visitExpr (line 120) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method computePriority (line 128) | private static int computePriority(Node block, int n) {
    method nonFallThrough (line 134) | private static boolean nonFallThrough(List<Node> body) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SameIfChain.java
  class SameIfChain (line 45) | @WarningDefinition(category = "RedundantCode", name = "SameConditionChai...
    method visit (line 50) | @AstVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SelfAssignment.java
  class SelfAssignment (line 39) | @WarningDefinition(category="Correctness", name="SelfAssignmentField", m...
    method visit (line 44) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SelfComputation.java
  class SelfComputation (line 36) | @WarningDefinition(category = "Correctness", name = "SelfComputation", m...
    method visit (line 40) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method sameArgs (line 58) | private boolean sameArgs(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SerializationIdiom.java
  class SerializationIdiom (line 39) | @WarningDefinition(category="Serialization", name="ComparatorIsNotSerial...
    method visitClass (line 53) | @ClassVisitor
    method visitMethod (line 75) | @MethodVisitor
    method visitField (line 114) | @FieldVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SpinLoop.java
  class SpinLoop (line 36) | @WarningDefinition(category = "Multithreading", name = "SpinLoopOnField"...
    method visit (line 38) | @AstVisitor
    method checkCondition (line 51) | private void checkCondition(Expression cond, MethodContext mc) {
    method checkFieldRead (line 61) | private void checkFieldRead(Expression expr, MethodContext mc) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SqlBadArgument.java
  class SqlBadArgument (line 34) | @WarningDefinition(category="Correctness", name="BadResultSetArgument", ...
    method visit (line 37) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method firstParameterIsInt (line 63) | private boolean firstParameterIsInt(MethodReference mr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/StartInConstructor.java
  class StartInConstructor (line 40) | @WarningDefinition(category = "Multithreading", name = "StartInConstruct...
    method checkMethod (line 42) | @MethodVisitor
    method visit (line 47) | @AstVisitor(nodes = AstNodes.EXPRESSIONS, methodName = "<init>")

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/StaticFieldFromInstanceMethod.java
  class StaticFieldFromInstanceMethod (line 42) | @WarningDefinition(category="BadPractice", name="StaticFieldFromInstance...
    method check (line 44) | @MethodVisitor
    method visit (line 49) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/StaticFieldNonThreadSafe.java
  class StaticFieldNonThreadSafe (line 49) | @WarningDefinition(category="Multithreading", name="StaticNotThreadSafeF...
    method visitField (line 54) | @FieldVisitor
    method isNotThreadSafe (line 70) | private boolean isNotThreadSafe(TypeReference fieldType) {
    method visitCall (line 74) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/StringConcatInLoop.java
  class StringConcatInLoop (line 45) | @WarningDefinition(category = "Performance", name = "StringConcatInLoop"...
    method visit (line 47) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method isStringValueOf (line 87) | private boolean isStringValueOf(Expression expr) {
    method isStringBuilderToString (line 95) | private boolean isStringBuilderToString(Expression expr) {
    method getAppendSource (line 103) | private Expression getAppendSource(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/StringIndex.java
  class StringIndex (line 34) | @WarningDefinition(category = "RedundantCode", name = "UselessStringSubs...
    method visit (line 40) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method check (line 47) | private void check(Expression node, MethodReference mr, MethodContext ...
    method checkRange (line 85) | private void checkRange(Expression expr, int maxValue, int val, Method...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/StringUsage.java
  class StringUsage (line 36) | @WarningDefinition(category="Performance", name="StringConstructor", max...
    method visit (line 40) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SwingProblems.java
  class SwingProblems (line 35) | @WarningDefinition(category="BadPractice", name="SwingMethodNotInSwingTh...
    method check (line 37) | @MethodVisitor
    method visit (line 42) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SyncGetClass.java
  class SyncGetClass (line 40) | @WarningDefinition(category="Multithreading", name="SyncOnGetClass", max...
    method checkMethod (line 42) | @MethodVisitor
    method visit (line 47) | @AstVisitor
    method isStaticFieldAccess (line 65) | private boolean isStaticFieldAccess(Node n, TypeDefinition td) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/SyncOnUpdatedField.java
  class SyncOnUpdatedField (line 32) | @WarningDefinition(category="Multithreading", name="SynchronizationOnUpd...
    method visit (line 34) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/ToArrayDowncast.java
  class ToArrayDowncast (line 36) | @WarningDefinition(category = "Correctness", name = "ImpossibleToArrayDo...
    method visit (line 40) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UncalledPrivateMethod.java
  class UncalledPrivateMethod (line 51) | @WarningDefinition(category="RedundantCode", name="UncalledPrivateMethod...
    class NestedAnonymousCalls (line 56) | @TypeDatabase
      method NestedAnonymousCalls (line 60) | public NestedAnonymousCalls() {
      method visitType (line 64) | @Override
      method isCalled (line 78) | public boolean isCalled(MemberInfo mi) {
    method visitType (line 85) | @ClassVisitor
    method extractCalls (line 146) | static void extractCalls(MethodDefinition md, Predicate<MethodReferenc...
    method link (line 168) | private void link(MethodReference from, MethodReference to) {
    method remove (line 181) | private void remove(MemberInfo mi) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UnnecessaryBoxing.java
  class UnnecessaryBoxing (line 45) | @WarningDefinition(category = "Performance", name = "BoxedForToString", ...
    method visit (line 52) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method getUsedLocations (line 94) | private List<WarningAnnotation<?>> getUsedLocations(Expression arg, Me...
    method isBoxedToString (line 102) | private boolean isBoxedToString(Expression expr) {
    method isBoxing (line 115) | private boolean isBoxing(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UnnecessaryInstanceOf.java
  class UnnecessaryInstanceOf (line 50) | @WarningDefinition(category = "RedundantCode", name = "UnnecessaryInstan...
    method visit (line 57) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method report (line 103) | private void report(MethodContext mc, TypeReference typeRef, Expressio...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UnreachableCatch.java
  class UnreachableCatch (line 31) | @WarningDefinition(category="RedundantCode", name="UnreachableCatch", ma...
    method visit (line 33) | @AstVisitor

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UnsafeGetResource.java
  class UnsafeGetResource (line 39) | @WarningDefinition(category="BadPractice", name="UnsafeGetResource", max...
    method checkMethod (line 41) | @MethodVisitor
    method visit (line 46) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UnsupportedCall.java
  class UnsupportedCall (line 39) | @WarningDefinition(category = "CodeStyle", name = "UnsupportedCall", max...
    method check (line 41) | @MethodVisitor
    method visit (line 46) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UnusedParameter.java
  class UnusedParameter (line 48) | @WarningDefinition(category = "Correctness", name = "ConstructorParamete...
    method checkClass (line 53) | @ClassVisitor
    method visitBody (line 59) | @AstVisitor(nodes = AstNodes.ROOT)
    method isEmpty (line 135) | private boolean isEmpty(List<Node> body) {
    method findOverloadCall (line 157) | private Expression findOverloadCall(MethodDefinition md, Block block) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/UselessVoidMethod.java
  class UselessVoidMethod (line 37) | @WarningDefinition(category="RedundantCode", name="UselessVoidMethod", m...
    method checkMethod (line 39) | @AstVisitor(nodes=AstNodes.ROOT)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/VolatileArray.java
  class VolatileArray (line 31) | @WarningDefinition(category="Multithreading", name="VolatileArray", maxS...
    method checkField (line 33) | @FieldVisitor
    method getAtomicArrayReplacement (line 50) | private String getAtomicArrayReplacement(JvmType simpleType) {

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/VolatileIncrement.java
  class VolatileIncrement (line 40) | @WarningDefinition(category = "Multithreading", name = "VolatileIncremen...
    method visitNode (line 43) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)
    method computePriority (line 81) | private int computePriority(FieldDefinition field, MethodDefinition md...

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/WaitContract.java
  class WaitContract (line 44) | @WarningDefinition(category = "Multithreading", name = "WaitUnconditiona...
    method checkMethod (line 48) | @MethodVisitor
    method visit (line 53) | @AstVisitor(nodes=AstNodes.EXPRESSIONS)

FILE: huntbugs/src/main/java/one/util/huntbugs/detect/WrongMapIterator.java
  class WrongMapIterator (line 43) | @WarningDefinition(category = "Performance", name = "WrongMapIterator", ...
    method visit (line 46) | @AstVisitor(nodes = AstNodes.EXPRESSIONS)
    method usedForGetOnly (line 79) | private static boolean usedForGetOnly(Expression key, Expression mapAr...
    method getCalledMethod (line 97) | private static MethodReference getCalledMethod(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/filter/AnnotationFilters.java
  class AnnotationFilters (line 42) | public class AnnotationFilters {
    method and (line 46) | private static Predicate<Warning> and(Predicate<Warning> left, Predica...
    method getSuppressed (line 56) | private static Set<String> getSuppressed(List<CustomAnnotation> annos) {
    method forSuppressed (line 83) | private static Predicate<Warning> forSuppressed(String suppressed) {
    method forSuppressed (line 93) | private static Predicate<Warning> forSuppressed(Set<String> suppressed) {
    method forType (line 97) | public static Predicate<Warning> forType(TypeDefinition td) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/Annotator.java
  class Annotator (line 29) | abstract class Annotator<T> {
    method Annotator (line 33) | protected Annotator(String name, T defValue) {
    method forExpressions (line 38) | protected static void forExpressions(Node node, Consumer<Expression> c...
    method get (line 48) | protected T get(Expression expr) {
    method putIfAbsent (line 54) | protected void putIfAbsent(Expression expr, T data) {
    method put (line 58) | protected void put(Expression expr, T data) {
    method remove (line 62) | protected void remove(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/Annotators.java
  class Annotators (line 29) | public class Annotators {
    method Annotators (line 30) | private Annotators() {
    method register (line 38) | static int register(String name) {
    method get (line 45) | static Object get(Expression expr, int i) {
    method put (line 50) | static void put(Expression expr, int i, Object data) {
    method replace (line 59) | static void replace(Expression expr, int i, Object oldData, Object dat...
    method remove (line 69) | static void remove(Expression expr, int i) {
    method facts (line 82) | public static String facts(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/BackLinkAnnotator.java
  class BackLinkAnnotator (line 31) | public class BackLinkAnnotator extends Annotator<Set<Expression>> {
    method BackLinkAnnotator (line 33) | public BackLinkAnnotator() {
    method annotate (line 37) | void annotate(Node node) {
    method fixTernary (line 42) | private void fixTernary(Expression expr) {
    method annotateBackLinks (line 59) | private void annotateBackLinks(Expression expr) {
    method link (line 70) | private void link(Expression target, Expression source) {
    method doLink (line 78) | private void doLink(Expression target, Expression source) {
    method findUsages (line 91) | public Set<Expression> findUsages(Expression input) {
    method findTransitiveUsages (line 96) | public Stream<Expression> findTransitiveUsages(Expression expr, boolea...

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/CFG.java
  class CFG (line 65) | public class CFG {
    method CFG (line 94) | private CFG(MethodDefinition md, BasicBlock closure, Block methodBody) {
    method getConditionalBranches (line 114) | private TrueFalse<List<BasicBlock>> getConditionalBranches(BasicBlock ...
    method inlineBooleans (line 196) | private void inlineBooleans() {
    method copyBlocks (line 282) | private List<BasicBlock> copyBlocks(int copyStart, int copyEnd) {
    method renumBlocks (line 289) | private void renumBlocks() {
    method computeDupBlocks (line 295) | private List<List<BasicBlock>> computeDupBlocks(Collection<Set<Express...
    method findDuplicates (line 300) | private Collection<Set<Expression>> findDuplicates(Block methodBody) {
    method verify (line 309) | private void verify() {
    method fixBlocks (line 326) | private void fixBlocks() {
    method computeForwardTill (line 372) | private int computeForwardTill() {
    method buildBlock (line 382) | private void buildBlock(BasicBlock entry, BasicBlock exit, JumpContext...
    method buildSingleLabel (line 436) | private void buildSingleLabel(BasicBlock entry, BasicBlock exit, Label...
    method buildNode (line 449) | private void buildNode(final BasicBlock curBlock, BasicBlock nextBlock...
    method buildFinally (line 472) | private void buildFinally(final BasicBlock curBlock, BasicBlock nextBl...
    method buildTryCatch (line 485) | private void buildTryCatch(final BasicBlock curBlock, BasicBlock nextB...
    method buildSwitch (line 500) | private void buildSwitch(final BasicBlock curBlock, BasicBlock nextBlo...
    method buildLoop (line 553) | private void buildLoop(final BasicBlock curBlock, BasicBlock nextBlock...
    method buildCondition (line 584) | private void buildCondition(final BasicBlock curBlock, BasicBlock next...
    method buildExpr (line 602) | private BasicBlock buildExpr(BasicBlock entry, Expression expr, JumpCo...
    method register (line 754) | private BasicBlock register(BasicBlock block) {
    method toString (line 760) | @Override
    method build (line 768) | public static CFG build(MethodDefinition md, Block body) {
    method runDFA (line 776) | public <STATE, FACT> boolean runDFA(Annotator<FACT> annotator,
    method forBodies (line 787) | public void forBodies(BiConsumer<MethodDefinition, Block> consumer) {
    method getLambdaCFG (line 792) | public CFG getLambdaCFG(Lambda lambda) {
    method isReachable (line 796) | private boolean isReachable(BasicBlock from, BasicBlock to) {
    method isAlwaysReachable (line 815) | private boolean isAlwaysReachable(BasicBlock from, Set<BasicBlock> tar...
    method updateState (line 840) | private <T> boolean updateState(GraphSearch<T> gs, BasicBlock bb, T ne...
    method graphSearch (line 856) | public <T> SearchResult<T> graphSearch(GraphSearch<T> gs) {
    class SearchResult (line 890) | @SuppressWarnings("unchecked")
      method SearchResult (line 894) | SearchResult(GraphSearch<T> gs) {
      method atExit (line 898) | public T atExit() {
      method atFail (line 902) | public T atFail() {
      method atImplicit (line 906) | public T atImplicit() {
      method atExpression (line 910) | public T atExpression(Expression expr) {
    method blocksBy (line 915) | private Stream<BasicBlock> blocksBy(Expression expr) {
    method mayTerminateImplicitly (line 919) | public boolean mayTerminateImplicitly(Expression expr) {
    method isReachable (line 923) | public boolean isReachable(Expression expr) {
    method isAlwaysReachable (line 929) | public boolean isAlwaysReachable(Expression from, Expression to) {
    method findDeadCode (line 934) | public CodeBlock findDeadCode(Expression expr, EdgeType deadEdge) {
    method isInCFG (line 978) | public boolean isInCFG(Expression expr) {
    method isExceptional (line 982) | private boolean isExceptional(BasicBlock start) {
    method clearChanged (line 986) | void clearChanged() {
    method initialize (line 995) | void initialize() {
    class DFARunner (line 1004) | class DFARunner<STATE, FACT> {
      method DFARunner (line 1009) | DFARunner(Annotator<FACT> annotator, Dataflow<FACT, STATE> df) {
      method run (line 1014) | boolean run(int maxIteration) {
      method runIteration (line 1060) | private void runIteration(List<BasicBlock> blocks) {
      method transferConditional (line 1105) | private TrueFalse<STATE> transferConditional(Expression expr, STATE ...
      method updateState (line 1115) | private void updateState(STATE newState, BasicBlock target) {
      method toString (line 1132) | @Override
      method getBlockDescription (line 1143) | String getBlockDescription(BasicBlock bb) {
    type EdgeType (line 1149) | public enum EdgeType {
    class BasicBlock (line 1153) | static class BasicBlock {
      method BasicBlock (line 1163) | BasicBlock() {
      method BasicBlock (line 1166) | BasicBlock(int id) {
      method BasicBlock (line 1170) | BasicBlock(Expression expr) {
      method BasicBlock (line 1174) | BasicBlock(boolean synthetic, Expression expr) {
      method setId (line 1179) | void setId(int id) {
      method falseOrPass (line 1185) | BasicBlock falseOrPass() {
      method trueOrPass (line 1189) | BasicBlock trueOrPass() {
      method setExpression (line 1193) | void setExpression(Expression expr) {
      method addTarget (line 1199) | void addTarget(EdgeType type, BasicBlock target) {
      method getId (line 1227) | public String getId() {
      method targets (line 1242) | public Stream<BasicBlock> targets() {
      method targetsExcept (line 1249) | public Stream<BasicBlock> targetsExcept(EdgeType type) {
      method toString (line 1276) | @Override
    type JumpContext (line 1294) | interface JumpContext {
      method addReturn (line 1295) | void addReturn(BasicBlock block);
      method addBreak (line 1297) | void addBreak(BasicBlock block, Label label);
      method addContinue (line 1299) | void addContinue(BasicBlock block, Label label);
      method addJump (line 1301) | void addJump(BasicBlock block, Label label);
      method addExceptional (line 1303) | void addExceptional(BasicBlock block, TypeReference exception);
    class OuterJumpContext (line 1306) | class OuterJumpContext implements JumpContext {
      method addExceptional (line 1307) | @Override
      method addReturn (line 1312) | @Override
      method addBreak (line 1317) | @Override
      method addContinue (line 1325) | @Override
      method addJump (line 1330) | @Override
    class DelegatingJumpContext (line 1336) | static abstract class DelegatingJumpContext implements JumpContext {
      method DelegatingJumpContext (line 1339) | protected DelegatingJumpContext(JumpContext parent) {
      method addReturn (line 1343) | @Override
      method addBreak (line 1348) | @Override
      method addContinue (line 1353) | @Override
      method addJump (line 1358) | @Override
      method addExceptional (line 1363) | @Override
    class SwitchJumpContext (line 1369) | static class SwitchJumpContext extends DelegatingJumpContext {
      method SwitchJumpContext (line 1372) | public SwitchJumpContext(JumpContext parent, BasicBlock exit) {
      method addBreak (line 1377) | @Override
    class LoopJumpContext (line 1387) | class LoopJumpContext extends DelegatingJumpContext {
      method LoopJumpContext (line 1392) | public LoopJumpContext(JumpContext parent, BasicBlock entry, BasicBl...
      method addBreak (line 1399) | @Override
      method addContinue (line 1408) | @Override
    class LabelJumpContext (line 1418) | class LabelJumpContext extends DelegatingJumpContext {
      method LabelJumpContext (line 1421) | LabelJumpContext(JumpContext parent, Set<Label> labels) {
      method addBreak (line 1426) | @Override
      method addJump (line 1435) | @Override
    class CatchJumpContext (line 1445) | static class CatchJumpContext extends DelegatingJumpContext {
      method CatchJumpContext (line 1448) | CatchJumpContext(JumpContext parent, BasicBlock nextBlock, List<Catc...
      method addExceptional (line 1454) | @Override
      method getEntry (line 1471) | BasicBlock getEntry(CatchBlock cb) {
      method types (line 1475) | private static Collection<TypeReference> types(CatchBlock cb) {
    class FinallyJumpContext (line 1482) | static class FinallyJumpContext extends DelegatingJumpContext {
      method FinallyJumpContext (line 1485) | FinallyJumpContext(JumpContext parent) {
      method replacePass (line 1489) | private void replacePass(BasicBlock block) {
      method addReturn (line 1495) | @Override
      method addBreak (line 1501) | @Override
      method addContinue (line 1507) | @Override
      method addJump (line 1513) | @Override
      method addExceptional (line 1519) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/ClassFields.java
  class ClassFields (line 42) | public class ClassFields {
    method ClassFields (line 49) | public ClassFields(TypeDefinition td, FieldStats fieldStats, MethodSta...
    method isSideEffectFree (line 62) | public boolean isSideEffectFree(MethodReference mr, boolean exact) {
    method isKnownFinal (line 71) | public boolean isKnownFinal(MemberInfo field) {
    method isKnownEffectivelyFinal (line 76) | public boolean isKnownEffectivelyFinal(MemberInfo field) {
    method mergeConstructor (line 81) | void mergeConstructor(MethodDefinition md, Frame frame, FrameContext f...
    method setStaticFinalFields (line 93) | void setStaticFinalFields(Frame frame) {
    method clearCtorData (line 103) | public void clearCtorData() {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/CodeBlock.java
  class CodeBlock (line 20) | public class CodeBlock {
    method CodeBlock (line 25) | public CodeBlock(Expression startExpr, int length, boolean isException...

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/ConstAnnotator.java
  class ConstAnnotator (line 42) | public class ConstAnnotator extends Annotator<Object> {
    method toString (line 44) | @Override
    method ConstAnnotator (line 50) | ConstAnnotator() {
    method build (line 54) | boolean build(CFG cfg) {
    method getValue (line 71) | public Object getValue(Expression input) {
    method isConst (line 76) | public boolean isConst(Expression input, Object constant) {
    method getType (line 80) | static JvmType getType(Expression expr) {
    class ContextValues (line 85) | static final class ContextValues {
      method ContextValues (line 90) | private ContextValues(Map<Variable, Object> values) {
      method merge (line 94) | ContextValues merge(ContextValues other) {
      method add (line 107) | ContextValues add(Variable var, Object value) {
      method remove (line 118) | ContextValues remove(Variable var) {
      method transfer (line 129) | ContextValues transfer(Expression expr) {
      method resolve (line 134) | Object resolve(Expression expr) {
      method equals (line 140) | @Override
      method toString (line 150) | @Override
    class ConstDataflow (line 156) | class ConstDataflow implements Dataflow<Object, ContextValues> {
      method ConstDataflow (line 159) | ConstDataflow(ContextValues initState) {
      method resolve (line 163) | private Object resolve(ContextValues contextValues, Expression expr) {
      method resolveConditional (line 180) | private Object resolveConditional(ContextValues contextValues, Expre...
      method fromSource (line 190) | private Object fromSource(ContextValues ctx, Expression expr) {
      method getArrayLength (line 218) | private Integer getArrayLength(Expression expression) {
      method processNeg (line 243) | private Object processNeg(Expression expr) {
      method processRem (line 258) | private Object processRem(Expression expr) {
      method processDiv (line 276) | private Object processDiv(Expression expr) {
      method processMul (line 294) | private Object processMul(Expression expr) {
      method processSub (line 312) | private Object processSub(Expression expr) {
      method processAdd (line 330) | private Object processAdd(Expression expr) {
      method processCmpGe (line 348) | private Object processCmpGe(Expression expr) {
      method processCmpGt (line 367) | private Object processCmpGt(Expression expr) {
      method processCmpLe (line 385) | private Object processCmpLe(Expression expr) {
      method processCmpLt (line 404) | private Object processCmpLt(Expression expr) {
      method processCmpNe (line 422) | private Object processCmpNe(Expression expr) {
      method processCmpEq (line 441) | private Object processCmpEq(Expression expr) {
      method processKnownMethods (line 460) | private Object processKnownMethods(Expression expr, MethodReference ...
      method processUnaryOp (line 515) | private <A> Object processUnaryOp(Expression expr, Class<A> type, Fu...
      method processBinaryOp (line 535) | private <A, B> Object processBinaryOp(Expression expr, Class<A> left...
      method makeEntryState (line 551) | @Override
      method transferState (line 556) | @Override
      method transferExceptionalState (line 561) | @Override
      method transferConditionalState (line 566) | @Override
      method mergeStates (line 595) | @Override
      method sameState (line 600) | @Override
      method makeFact (line 605) | @Override
      method mergeFacts (line 782) | @Override
      method sameFact (line 793) | @Override
      method makeUnknownFact (line 798) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/Dataflow.java
  type Dataflow (line 24) | interface Dataflow<FACT, STATE> {
    method makeEntryState (line 25) | public STATE makeEntryState();
    method transferState (line 27) | public STATE transferState(STATE src, Expression expr);
    method transferExceptionalState (line 29) | public STATE transferExceptionalState(STATE src, Expression expr);
    method transferConditionalState (line 31) | public TrueFalse<STATE> transferConditionalState(STATE src, Expression...
    method mergeStates (line 33) | public STATE mergeStates(STATE s1, STATE s2);
    method sameState (line 35) | public boolean sameState(STATE s1, STATE s2);
    method makeFact (line 37) | public FACT makeFact(STATE state, Expression expr);
    method makeUnknownFact (line 39) | public FACT makeUnknownFact();
    method mergeFacts (line 41) | public FACT mergeFacts(FACT f1, FACT f2);
    method sameFact (line 43) | public boolean sameFact(FACT f1, FACT f2);
    method onSuccess (line 45) | public default void onSuccess(STATE exitState) {}
    method onFail (line 47) | public default void onFail(STATE exitState) {}

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/ETypeAnnotator.java
  class ETypeAnnotator (line 40) | public class ETypeAnnotator extends Annotator<EType> {
    method ETypeAnnotator (line 42) | ETypeAnnotator() {
    method build (line 46) | boolean build(CFG cfg) {
    method resolve (line 51) | public EType resolve(Expression expr) {
    class ContextTypes (line 56) | static class ContextTypes {
      method ContextTypes (line 61) | private ContextTypes(Map<Variable, EType> values) {
      method merge (line 65) | ContextTypes merge(ContextTypes other) {
      method and (line 79) | ContextTypes and(Variable var, EType value) {
      method add (line 94) | ContextTypes add(Variable var, EType value) {
      method remove (line 109) | ContextTypes remove(Variable var) {
      method transfer (line 120) | ContextTypes transfer(Expression expr) {
      method resolve (line 127) | EType resolve(Expression expr) {
      method equals (line 133) | @Override
      method toString (line 143) | @Override
    class ETypeDataflow (line 150) | class ETypeDataflow implements Dataflow<EType, ContextTypes> {
      method ETypeDataflow (line 153) | ETypeDataflow(ContextTypes initial) {
      method makeEntryState (line 157) | @Override
      method transferState (line 162) | @Override
      method transferExceptionalState (line 175) | @Override
      method transferConditionalState (line 188) | @Override
      method mergeStates (line 240) | @Override
      method sameState (line 245) | @Override
      method makeFact (line 250) | @Override
      method makeUnknownFact (line 310) | @Override
      method mergeFacts (line 315) | @Override
      method sameFact (line 320) | @Override
      method resolve (line 325) | private EType resolve(ContextTypes ctx, Expression expr) {
      method fromSource (line 332) | private EType fromSource(ContextTypes ctx, Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/EnumConstant.java
  class EnumConstant (line 26) | public final class EnumConstant {
    method EnumConstant (line 30) | EnumConstant(String typeName, String name) {
    method getTypeName (line 36) | public String getTypeName() {
    method getName (line 40) | public String getName() {
    method hashCode (line 44) | @Override
    method equals (line 49) | @Override
    method toString (line 59) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/Exceptional.java
  class Exceptional (line 24) | public class Exceptional {
    method Exceptional (line 27) | Exceptional(Throwable t) {
    method getType (line 31) | public TypeInfo getType() {
    method hashCode (line 35) | @Override
    method equals (line 40) | @Override
    method toString (line 50) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/FrameContext.java
  class FrameContext (line 50) | class FrameContext {
    method FrameContext (line 55) | FrameContext(MethodDefinition md, ClassFields cf) {
    method isThis (line 60) | boolean isThis(Expression expr) {
    method getCtorFields (line 64) | Map<MemberInfo, Expression> getCtorFields(MemberReference ctor) {
    method getInitialFields (line 68) | Map<MemberInfo, Expression> getInitialFields() {
    method constant (line 102) | private static Expression constant(Object val) {
    method getInitialExpression (line 108) | private static Expression getInitialExpression(JvmType simpleType) {
    method makeUpdatedNode (line 131) | Expression makeUpdatedNode(Expression src) {
    method makeFieldsFrom (line 137) | public void makeFieldsFrom(Frame frame) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/GraphSearch.java
  type GraphSearch (line 26) | public interface GraphSearch<T> {
    method markStart (line 27) | T markStart(Expression expr, boolean isEntry);
    method transfer (line 28) | T transfer(T orig, Expression from, EdgeType edge, Expression to);
    method merge (line 29) | T merge(T f1, T f2);

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/Inf.java
  class Inf (line 23) | public class Inf {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/NullAnnotator.java
  class NullAnnotator (line 42) | public class NullAnnotator extends Annotator<Nullness> {
    method NullAnnotator (line 44) | NullAnnotator() {
    method build (line 48) | boolean build(CFG cfg) {
    method resolve (line 53) | public Nullness resolve(Expression expr) {
    class ContextNulls (line 58) | static class ContextNulls {
      method ContextNulls (line 63) | private ContextNulls(Map<Variable, Nullness> values) {
      method merge (line 67) | ContextNulls merge(ContextNulls other) {
      method get (line 87) | private static Nullness get(Map<Variable, Nullness> map, Variable v) {
      method add (line 98) | ContextNulls add(Variable var, Nullness value) {
      method remove (line 110) | ContextNulls remove(Variable var) {
      method transfer (line 121) | ContextNulls transfer(Expression expr) {
      method resolve (line 131) | Nullness resolve(Expression expr) {
      method equals (line 137) | @Override
      method toString (line 147) | @Override
    class NullDataflow (line 154) | class NullDataflow implements Dataflow<Nullness, ContextNulls> {
      method NullDataflow (line 158) | NullDataflow(MethodDefinition md, ContextNulls initial) {
      method makeEntryState (line 163) | @Override
      method transferState (line 168) | @Override
      method transferExceptionalState (line 221) | @Override
      method transferConditionalState (line 226) | @Override
      method mergeStates (line 271) | @Override
      method sameState (line 276) | @Override
      method makeFact (line 281) | @Override
      method makeUnknownFact (line 337) | @Override
      method mergeFacts (line 342) | @Override
      method sameFact (line 349) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/Nullness.java
  class Nullness (line 33) | public class Nullness {
    type NullState (line 34) | public static enum NullState {
      method or (line 43) | NullState or(NullState other) {
      method isNull (line 53) | public boolean isNull() {
      method isNonNull (line 57) | public boolean isNonNull() {
    method Nullness (line 77) | private Nullness(Map<Expression, NullState> expressions) {
    method state (line 81) | private NullState state() {
    method stateAt (line 92) | public NullState stateAt(CFG cfg, Expression target) {
    class NullGraphSearch (line 128) | class NullGraphSearch implements GraphSearch<NullState> {
      method NullGraphSearch (line 131) | public NullGraphSearch(Expression target) {
      method markStart (line 135) | @Override
      method transfer (line 141) | @Override
      method merge (line 170) | @Override
    method isNull (line 191) | public boolean isNull() {
    method or (line 195) | Nullness or(Nullness other) {
    method unknownToNull (line 203) | Nullness unknownToNull() {
    method isNonNull (line 207) | public boolean isNonNull() {
    method nullAt (line 212) | public static Nullness nullAt(Expression expr) {
    method createAt (line 216) | public static Nullness createAt(Expression expr, NullState state) {
    method hashCode (line 220) | @Override
    method equals (line 225) | @Override
    method toString (line 235) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/PurityAnnotator.java
  class PurityAnnotator (line 32) | public class PurityAnnotator extends Annotator<PurityAnnotator.Purity> {
    method PurityAnnotator (line 33) | PurityAnnotator() {
    type Purity (line 37) | public static enum Purity {
      method merge (line 65) | Purity merge(Purity other) {
      method atLeast (line 69) | public boolean atLeast(Purity other) {
    method annotate (line 74) | void annotate(Node node, FrameContext fc) {
    method getOwnPurity (line 78) | private Purity getOwnPurity(Expression expr, FrameContext fc) {
    method annotatePurity (line 140) | private Purity annotatePurity(Expression expr, FrameContext fc) {
    method get (line 155) | @Override
    method isPure (line 160) | public boolean isPure(Expression expr) {
    method isSideEffectFree (line 164) | public boolean isSideEffectFree(Expression expr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/SourceAnnotator.java
  class SourceAnnotator (line 50) | public class SourceAnnotator extends Annotator<Expression> {
    method SourceAnnotator (line 54) | SourceAnnotator() {
    method build (line 58) | Collection<Expression> build(ClassFields cf, CFG cfg) {
    method getSource (line 68) | public Expression getSource(Expression input) {
    method children (line 73) | static Stream<Expression> children(Set<Expression> visited, Expression...
    method makePhiNode (line 85) | static Expression makePhiNode(Expression left, Expression right, Frame...
    method isExprEqual (line 116) | static boolean isExprEqual(Expression left, Expression right) {
    class Frame (line 135) | static class Frame {
      method Frame (line 141) | Frame(FrameContext fc, Frame closure) {
      method Frame (line 159) | private Frame(Frame parent, Map<Variable, Expression> sources, Map<M...
      method get (line 166) | Expression get(Variable var) {
      method putInitial (line 173) | private void putInitial(ParameterDefinition thisParam) {
      method merge (line 180) | Frame merge(Frame other, FrameContext fc) {
      method mergeFields (line 192) | private Map<MemberInfo, Expression> mergeFields(Map<MemberInfo, Expr...
      method mergeSources (line 210) | private Map<Variable, Expression> mergeSources(Frame other, FrameCon...
      method isEqual (line 232) | static boolean isEqual(Frame left, Frame right) {
      method replace (line 254) | private Frame replace(Variable var, Expression replacement) {
      method replaceField (line 264) | private Frame replaceField(FieldReference fr, Expression replacement) {
      method deleteAllFields (line 281) | private Frame deleteAllFields() {
      method deleteFields (line 297) | private Frame deleteFields() {
      method replaceAll (line 311) | Frame replaceAll(UnaryOperator<Expression> op) {
    class SourceDataflow (line 325) | class SourceDataflow implements Dataflow<Expression, Frame> {
      method SourceDataflow (line 329) | SourceDataflow(ClassFields cf, MethodDefinition md, Frame closure) {
      method makeEntryState (line 334) | @Override
      method transferState (line 339) | @Override
      method transferExceptionalState (line 433) | @Override
      method transferConditionalState (line 437) | @Override
      method mergeStates (line 441) | @Override
      method sameState (line 446) | @Override
      method makeFact (line 451) | @Override
      method makeUnknownFact (line 491) | @Override
      method mergeFacts (line 496) | @Override
      method sameFact (line 500) | @Override
      method onSuccess (line 505) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/TrueFalse.java
  class TrueFalse (line 22) | class TrueFalse<STATE> {
    method TrueFalse (line 25) | TrueFalse(STATE sameState) {
    method TrueFalse (line 29) | TrueFalse(STATE trueState, STATE falseState) {
    method TrueFalse (line 33) | TrueFalse(STATE trueState, STATE falseState, boolean invert) {
    method invert (line 38) | public TrueFalse<STATE> invert() {
    method toString (line 42) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/ValuesFlow.java
  class ValuesFlow (line 38) | public class ValuesFlow {
    method annotate (line 39) | public static List<Expression> annotate(Context ctx, MethodDefinition ...
    method reduce (line 59) | public static <T> T reduce(Expression input, Function<Expression, T> m...
    method reduceType (line 86) | public static TypeReference reduceType(Expression input) {
    method getSource (line 91) | public static Expression getSource(Expression input) {
    method allMatch (line 96) | public static boolean allMatch(Expression src, Predicate<Expression> p...
    method anyMatch (line 105) | public static boolean anyMatch(Expression src, Predicate<Expression> p...
    method findFirst (line 114) | public static Expression findFirst(Expression src, Predicate<Expressio...
    method hasPhiSource (line 124) | public static boolean hasPhiSource(Expression input) {
    method isSpecial (line 129) | public static boolean isSpecial(Expression expr) {
    method hasUpdatedSource (line 133) | public static boolean hasUpdatedSource(Expression e) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/etype/AndType.java
  class AndType (line 31) | public class AndType extends ComplexType {
    method AndType (line 32) | AndType(Set<SingleType> types) {
    method of (line 36) | static EType of(Set<SingleType> types) {
    method is (line 44) | @Override
    method isArray (line 67) | @Override
    method shrinkConstraint (line 90) | @Override
    method negate (line 113) | @Override
    method reduce (line 128) | @Override
    method append (line 159) | @Override
    method appendAny (line 187) | @Override
    method toString (line 209) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/etype/ComplexType.java
  class ComplexType (line 25) | abstract class ComplexType implements EType {
    method ComplexType (line 28) | public ComplexType(Set<SingleType> types) {
    method reduce (line 32) | abstract EType reduce();
    method append (line 34) | abstract EType append(SingleType st);
    method appendAny (line 36) | abstract EType appendAny(EType type);
    method hashCode (line 38) | @Override
    method equals (line 43) | @Override
    method toString (line 52) | String toString(String delimiter) {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/etype/EType.java
  type EType (line 31) | public interface EType {
    method toString (line 33) | @Override
    method negate (line 38) | @Override
    method is (line 43) | @Override
    method isArray (line 48) | @Override
    method is (line 54) | YesNoMaybe is(TypeReference tr, boolean exact);
    method isArray (line 56) | YesNoMaybe isArray();
    method shrinkConstraint (line 58) | default EType shrinkConstraint(TypeReference tr, boolean exact) {
    method negate (line 62) | EType negate();
    method exact (line 64) | public static EType exact(TypeReference tr) {
    method subType (line 68) | public static EType subType(TypeReference tr) {
    method or (line 72) | public static EType or(EType t1, EType t2) {
    method and (line 102) | public static EType and(EType t1, EType t2) {
    method unknownToNull (line 156) | default EType unknownToNull() {

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/etype/OrType.java
  class OrType (line 30) | public class OrType extends ComplexType {
    method OrType (line 31) | OrType(Set<SingleType> types) {
    method is (line 35) | @Override
    method isArray (line 63) | @Override
    method negate (line 91) | @Override
    method reduce (line 104) | @Override
    method append (line 122) | @Override
    method appendAny (line 137) | @Override
    method toString (line 159) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/flow/etype/SingleType.java
  class SingleType (line 28) | public class SingleType implements EType {
    type What (line 29) | enum What {
      method negate (line 32) | What negate() {
      method isNegative (line 47) | boolean isNegative() {
    method of (line 56) | static EType of(TypeReference tr, What what) {
    method SingleType (line 77) | SingleType(TypeReference tr, What what, boolean complete) {
    method is (line 83) | @Override
    method isArray (line 119) | @Override
    method negate (line 140) | @Override
    method toString (line 145) | @Override
    method hashCode (line 161) | @Override
    method equals (line 166) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/input/XmlReportReader.java
  class XmlReportReader (line 60) | public class XmlReportReader {
    method read (line 61) | public static HuntBugsResult read(Context ctx, Path path) throws IOExc...
    method read (line 67) | public static HuntBugsResult read(Context ctx, InputStream is) throws ...
    method read (line 74) | public static HuntBugsResult read(Context ctx, Document dom) {
    method loadErrors (line 95) | private static List<ErrorMessage> loadErrors(Document dom) {
    method loadError (line 104) | private static ErrorMessage loadError(Element e) {
    method loadWarnings (line 114) | private static List<Warning> loadWarnings(Document dom, Context ctx) {
    method loadWarning (line 123) | private static Warning loadWarning(Element e, Context ctx) {
    method loadAnnotations (line 143) | private static Stream<WarningAnnotation<?>> loadAnnotations(Element e) {
    method loadNumber (line 183) | private static Number loadNumber(String type, String value) {

FILE: huntbugs/src/main/java/one/util/huntbugs/output/CombinedReportWriter.java
  class CombinedReportWriter (line 26) | class CombinedReportWriter implements ReportWriter {
    method CombinedReportWriter (line 30) | public CombinedReportWriter(List<ReportWriter> writers) {
    method write (line 34) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/output/HtmlReportWriter.java
  class HtmlReportWriter (line 36) | class HtmlReportWriter implements ReportWriter {
    method HtmlReportWriter (line 40) | public HtmlReportWriter(Writer target) {
    method write (line 45) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/output/ReportWriter.java
  type ReportWriter (line 24) | interface ReportWriter {
    method write (line 25) | void write(Document dom);

FILE: huntbugs/src/main/java/one/util/huntbugs/output/Reports.java
  class Reports (line 58) | public final class Reports {
    method write (line 68) | public static void write(Path xmlTarget, Path htmlTarget, HuntBugsResu...
    method merge (line 92) | public static HuntBugsResult merge(Collection<HuntBugsResult> results) {
    method diff (line 115) | public static HuntBugsResult diff(HuntBugsResult oldResult, HuntBugsRe...
    method diffWarnings (line 136) | private static List<Warning> diffWarnings(List<Warning> oldWarnings, L...
    method matchScore (line 177) | private static int matchScore(Warning w1, Warning w2) {
    method makeDom (line 189) | private static Document makeDom(HuntBugsResult ctx) {
    method writeError (line 211) | private static Element writeError(Document doc, ErrorMessage e) {
    method writeWarning (line 227) | private static Element writeWarning(Document doc, Warning w, Formatter...

FILE: huntbugs/src/main/java/one/util/huntbugs/output/XmlReportWriter.java
  class XmlReportWriter (line 31) | class XmlReportWriter implements ReportWriter {
    method XmlReportWriter (line 34) | public XmlReportWriter(Writer target) {
    method write (line 38) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/AbstractTypeDatabase.java
  class AbstractTypeDatabase (line 30) | public abstract class AbstractTypeDatabase<E> {
    method AbstractTypeDatabase (line 34) | protected AbstractTypeDatabase(Function<String, E> elementSupplier) {
    method visitType (line 38) | protected void visitType(TypeDefinition td) {
    method getOrCreate (line 42) | protected E getOrCreate(TypeReference ref) {
    method getOrCreate (line 46) | protected E getOrCreate(String internalName) {
    method get (line 50) | public E get(TypeReference ref) {
    method get (line 54) | public E get(String internalName) {
    method toString (line 58) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/ClassContext.java
  class ClassContext (line 40) | public class ClassContext extends ElementContext {
    method ClassContext (line 46) | ClassContext(Context ctx, ClassData cdata, Detector detector) {
    method getTypeSpecificAnnotations (line 53) | List<WarningAnnotation<?>> getTypeSpecificAnnotations() {
    method visitClass (line 64) | boolean visitClass() {
    method visitAfterClass (line 80) | void visitAfterClass() {
    method report (line 90) | public void report(String warning, int priority, WarningAnnotation<?>....
    method error (line 110) | @Override
    method forMethod (line 115) | MethodContext forMethod(MethodData md) {
    method forField (line 119) | FieldContext forField(FieldData fd) {
    method getMemberAsserter (line 123) | MemberAsserter getMemberAsserter(MemberReference mr) {

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/ClassData.java
  class ClassData (line 36) | public class ClassData {
    method ClassData (line 42) | ClassData(TypeDefinition td) {
    method finish (line 48) | void finish(Context ctx) {
    method getAsserter (line 56) | MemberAsserter getAsserter(MemberReference mr) {
    method getAsserter (line 62) | MemberAsserter getAsserter(MemberInfo mi) {
    method registerAsserter (line 68) | MemberAsserter registerAsserter(MemberReference mr) {
    method hasAsserters (line 80) | boolean hasAsserters() {

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/DatabaseRegistry.java
  class DatabaseRegistry (line 33) | public class DatabaseRegistry {
    class DatabaseInfo (line 37) | static class DatabaseInfo<T> {
      method DatabaseInfo (line 41) | public DatabaseInfo(T db, AbstractTypeDatabase<T> parentDb) {
      method getDatabase (line 46) | public T getDatabase(TypeReference tr) {
    method DatabaseRegistry (line 53) | public DatabaseRegistry(Context ctx) {
    method queryDatabase (line 58) | public <T> Function<TypeReference, T> queryDatabase(Class<T> clazz) {
    method visitType (line 62) | void visitType(TypeDefinition td) {
    method getDatabaseInfo (line 71) | private <T> DatabaseInfo<T> getDatabaseInfo(Class<T> clazz) {
    method resolveDatabase (line 82) | private <T> DatabaseInfo<T> resolveDatabase(Class<T> clazz) {

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/Detector.java
  class Detector (line 51) | public class Detector {
    class VisitorInfo (line 72) | class VisitorInfo {
      method VisitorInfo (line 77) | public VisitorInfo(AstVisitor anno, VisitorType type, MethodHandle m...
      method bind (line 83) | public MethodHandle bind(TypeDefinition td) {
      method isApplicable (line 89) | public boolean isApplicable(MethodDefinition md) {
    type VisitorType (line 100) | static enum VisitorType {
      method runBody (line 116) | static boolean runBody(MethodHandle mh, Object det, Node n, NodeChai...
      method runExpression (line 124) | static boolean runExpression(MethodHandle mh, Object det, Node n, No...
      method VisitorType (line 132) | private VisitorType(AstNodes nodeTypes, MethodType wantedType, Strin...
      method adapt (line 145) | MethodHandle adapt(MethodHandle mh) {
    method Detector (line 152) | public Detector(Map<String, WarningType> wts, Class<?> clazz, Database...
    method bindDatabases (line 182) | MethodHandle bindDatabases(int count, TypeDefinition td, MethodHandle ...
    method getDatabase (line 194) | private <T> T getDatabase(Class<T> clazz, TypeReference tr) {
    method adapt (line 201) | private MethodHandle adapt(Method method, MethodType wantedType, Datab...
    method getWarningType (line 255) | public WarningType getWarningType(String typeName) {
    method toString (line 259) | @Override
    method newInstance (line 264) | public Object newInstance() {

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/DetectorRegistry.java
  class DetectorRegistry (line 71) | public class DetectorRegistry {
    class SystemDetector (line 87) | public static class SystemDetector {
    method DetectorRegistry (line 90) | public DetectorRegistry(Context ctx) {
    method createWarningMap (line 105) | private Map<String, WarningType> createWarningMap(Stream<WarningType> ...
    method getDefinitions (line 110) | private List<WarningDefinition> getDefinitions(Class<?> clazz) {
    method addDetector (line 117) | boolean addDetector(Class<?> clazz) {
    method createDetector (line 134) | private Detector createDetector(Class<?> clazz, Map<String, WarningTyp...
    method init (line 147) | void init() {
    method visitChildren (line 163) | private void visitChildren(Node node, NodeChain parents, List<MethodCo...
    method hasDatabases (line 187) | public boolean hasDatabases() {
    method populateDatabases (line 191) | public void populateDatabases(TypeDefinition type) {
    method analyzeClass (line 198) | public void analyzeClass(TypeDefinition type) {
    method sortMethods (line 278) | private void sortMethods(List<MethodDefinition> declMethods) {
    method sortConstructors (line 297) | private void sortConstructors(List<MethodDefinition> ctors) {
    method printTree (line 333) | private void printTree(PrintStream out, List<String> result, String ar...
    method reportWarningTypes (line 349) | public void reportWarningTypes(PrintStream out) {
    method reportDatabases (line 360) | public void reportDatabases(PrintStream out) {
    method reportTitles (line 373) | public void reportTitles(PrintStream out) {
    method getWarningType (line 389) | public WarningType getWarningType(String typeName) {
    method warningTypes (line 393) | public Stream<WarningType> warningTypes() {
    class DetectorVisitor (line 397) | private class DetectorVisitor implements RepositoryVisitor {
      method DetectorVisitor (line 403) | DetectorVisitor(String packageToVisit, boolean external) {
      method visitPackage (line 408) | @Override
      method visitClass (line 413) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/ElementContext.java
  class ElementContext (line 25) | abstract class ElementContext {
    method ElementContext (line 29) | public ElementContext(Context ctx, Detector detector) {
    method error (line 39) | abstract public void error(String message);
    method resolveWarningType (line 41) | protected WarningType resolveWarningType(String warning, int priority) {

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/FieldContext.java
  class FieldContext (line 31) | public class FieldContext extends ElementContext {
    method FieldContext (line 36) | FieldContext(Context ctx, ClassContext cc, FieldData fdata) {
    method visitField (line 43) | void visitField() {
    method report (line 54) | public void report(String warning, int priority, WarningAnnotation<?>....
    method error (line 72) | @Override
    method toString (line 77) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/FieldData.java
  class FieldData (line 24) | final class FieldData {
    method FieldData (line 27) | public FieldData(FieldDefinition fd) {
    method toString (line 31) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/MethodContext.java
  class MethodContext (line 52) | public class MethodContext extends ElementContext {
    class WarningInfo (line 53) | static class WarningInfo {
      method WarningInfo (line 60) | public WarningInfo(WarningType type, int priority, Location loc, Lis...
      method tryMerge (line 68) | boolean tryMerge(WarningInfo other) {
      method build (line 86) | Warning build() {
    method MethodContext (line 100) | MethodContext(Context ctx, ClassContext сс, MethodData md) {
    method visitMethod (line 109) | boolean visitMethod() {
    method visitAfterMethod (line 123) | void visitAfterMethod() {
    method visitNode (line 134) | boolean visitNode(Node node) {
    method finalizeMethod (line 148) | void finalizeMethod() {
    method report (line 154) | public void report(String warning, int priority, WarningAnnotation<?>....
    method report (line 158) | public void report(String warning, int priority, Node node, Collection...
    method report (line 193) | public void report(String warning, int priority, Node node, WarningAnn...
    method reportWarning (line 197) | private void reportWarning(Warning warn) {
    method getLocation (line 213) | public Location getLocation(Node node) {
    method forgetLastBug (line 221) | public void forgetLastBug() {
    method error (line 225) | @Override
    method isAnnotated (line 233) | public boolean isAnnotated() {
    method getCFG (line 237) | public CFG getCFG() {
    method isReachable (line 245) | public boolean isReachable(Expression expr) {
    method isAlwaysReachable (line 249) | public boolean isAlwaysReachable(Expression from, Expression to) {
    method mayTerminateImplicitly (line 253) | public boolean mayTerminateImplicitly(Expression expr) {
    method findDeadCode (line 257) | public CodeBlock findDeadCode(Expression expr, EdgeType edgeType) {
    method getParameterUsages (line 264) | public Set<Expression> getParameterUsages(ParameterDefinition pd) {
    method toString (line 274) | @Override
    method isFullyAnalyzed (line 279) | public boolean isFullyAnalyzed() {

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/MethodData.java
  class MethodData (line 45) | final class MethodData {
    method MethodData (line 57) | MethodData(MethodDefinition md) {
    method getLineNumber (line 61) | int getLineNumber(int offset) {
    method getMethodSpecificAnnotations (line 66) | List<WarningAnnotation<?>> getMethodSpecificAnnotations() {
    method getConverter (line 73) | private OffsetToLineNumberConverter getConverter() {
    method createConverter (line 81) | private static OffsetToLineNumberConverter createConverter(MethodDefin...
    method getOffset (line 90) | private static int getOffset(Node node) {
    method getLocation (line 110) | Location getLocation(Node node) {
    method toString (line 137) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/anno/AstNodes.java
  type AstNodes (line 27) | public enum AstNodes {

FILE: huntbugs/src/main/java/one/util/huntbugs/registry/anno/VisitOrder.java
  type VisitOrder (line 21) | public enum VisitOrder {

FILE: huntbugs/src/main/java/one/util/huntbugs/repo/AuxRepository.java
  class AuxRepository (line 26) | public class AuxRepository implements Repository {
    method AuxRepository (line 29) | public AuxRepository(ITypeLoader loader) {
    method createTypeLoader (line 33) | @Override
    method visit (line 38) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/repo/CompositeRepository.java
  class CompositeRepository (line 27) | public class CompositeRepository implements Repository {
    method CompositeRepository (line 30) | public CompositeRepository(List<Repository> repos) {
    method createTypeLoader (line 34) | @Override
    method visit (line 39) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/repo/DirRepository.java
  class DirRepository (line 33) | public class DirRepository implements Repository {
    method DirRepository (line 36) | public DirRepository(Path root) {
    method createTypeLoader (line 40) | @Override
    method visit (line 45) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/repo/FilteredRepository.java
  class FilteredRepository (line 28) | public class FilteredRepository implements Repository {
    method FilteredRepository (line 36) | public FilteredRepository(Repository repository, Predicate<String> cla...
    method createTypeLoader (line 41) | @Override
    method visit (line 46) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/repo/JarRepository.java
  class JarRepository (line 29) | public class JarRepository implements Repository {
    method JarRepository (line 32) | public JarRepository(JarFile file) {
    method createTypeLoader (line 36) | @Override
    method visit (line 41) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/repo/Repository.java
  type Repository (line 42) | public interface Repository {
    method createTypeLoader (line 43) | ITypeLoader createTypeLoader();
    method visit (line 45) | void visit(String rootPackage, RepositoryVisitor visitor);
    method createSelfRepository (line 47) | static Repository createSelfRepository() {
    method createPluginRepository (line 71) | static Repository createPluginRepository(HuntBugsPlugin huntBugsPlugin) {
    method createDetectorsRepo (line 77) | static Repository createDetectorsRepo(Class<?> clazz, String pluginNam...
    method createNullRepository (line 102) | static Repository createNullRepository() {

FILE: huntbugs/src/main/java/one/util/huntbugs/repo/RepositoryVisitor.java
  type RepositoryVisitor (line 22) | public interface RepositoryVisitor {
    method visitPackage (line 27) | public boolean visitPackage(String packageName);
    method visitClass (line 29) | public void visitClass(String className);

FILE: huntbugs/src/main/java/one/util/huntbugs/spi/DataTests.java
  class DataTests (line 43) | public abstract class DataTests {
    method test (line 45) | public static void test(String packageToAnalyze) throws Exception {

FILE: huntbugs/src/main/java/one/util/huntbugs/spi/HuntBugsPlugin.java
  type HuntBugsPlugin (line 24) | public interface HuntBugsPlugin {
    method name (line 26) | String name();
    method detectorPackage (line 28) | String detectorPackage();

FILE: huntbugs/src/main/java/one/util/huntbugs/util/AccessLevel.java
  type AccessLevel (line 27) | public enum AccessLevel {
    method min (line 30) | public AccessLevel min(AccessLevel other) {
    method select (line 34) | public int select(int publicPriority, int protectedPriority, int defau...
    method ofFlags (line 49) | public static AccessLevel ofFlags(long flags) {
    method of (line 59) | public static AccessLevel of(MethodDefinition md) {
    method of (line 64) | public static AccessLevel of(FieldDefinition fd) {

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Annotations.java
  class Annotations (line 28) | public class Annotations {
    method hasAnnotation (line 31) | public static boolean hasAnnotation(IAnnotationsProvider fd, boolean i...

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Equi.java
  class Equi (line 46) | public class Equi {
    class EquiContext (line 47) | static class EquiContext {
      method addAndCheck (line 53) | boolean addAndCheck() {
    method equiBlocks (line 61) | public static boolean equiBlocks(Block left, Block right) {
    method equiBlocks (line 65) | private static boolean equiBlocks(Block left, Block right, EquiContext...
    method equiTryCatch (line 136) | private static boolean equiTryCatch(TryCatchBlock leftTry, TryCatchBlo...
    method equiExpressions (line 164) | public static boolean equiExpressions(Expression left, Expression righ...
    method equiExpressions (line 168) | private static boolean equiExpressions(Expression left, Expression rig...
    method equiOperands (line 227) | private static boolean equiOperands(Object left, Object right, EquiCon...
    method equiMethods (line 255) | private static boolean equiMethods(final MethodReference left, final M...
    method equiFields (line 260) | private static boolean equiFields(final FieldReference left, final Fie...
    method equiLambdas (line 264) | private static boolean equiLambdas(Lambda left, Lambda right, EquiCont...
    method equiTypes (line 293) | private static boolean equiTypes(TypeReference left, TypeReference rig...

FILE: huntbugs/src/main/java/one/util/huntbugs/util/ExpressionFormatter.java
  class ExpressionFormatter (line 33) | public class ExpressionFormatter {
    method formatExpression (line 36) | public static String formatExpression(Expression expr) {
    method format (line 40) | private static StringBuilder format(StringBuilder sb, Expression expr,...
    method formatUnary (line 241) | private static StringBuilder formatUnary(StringBuilder sb, Expression ...
    method formatBinary (line 248) | private static StringBuilder formatBinary(StringBuilder sb, Expression...

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Exprs.java
  class Exprs (line 40) | public class Exprs {
    method isAssertionStatusCheck (line 42) | private static boolean isAssertionStatusCheck(Expression expr) {
    method isAssertionCondition (line 52) | private static boolean isAssertionCondition(Expression expr) {
    method isAssertionMethod (line 58) | private static boolean isAssertionMethod(Expression expr) {
    method isAssertion (line 66) | public static boolean isAssertion(Expression expr) {
    method getChild (line 71) | public static Expression getChild(Expression node, int i) {
    method getChildNoSpecial (line 75) | public static Expression getChildNoSpecial(Expression node, int i) {
    method getThis (line 83) | public static Expression getThis(Expression node) {
    method findExpression (line 91) | public static Expression findExpression(Expression node, Predicate<Exp...
    method findExpressionWithSources (line 102) | public static Expression findExpressionWithSources(Expression node, Pr...
    method findExpressionWithSources (line 106) | private static Expression findExpressionWithSources(Expression node, S...
    method isThis (line 123) | public static boolean isThis(Expression self) {
    method isParameter (line 137) | public static boolean isParameter(Expression expr) {
    method stream (line 147) | public static Stream<Expression> stream(Expression expr) {
    method bothMatch (line 151) | public static boolean bothMatch(Expression e1, Expression e2, Predicat...
    method bothChildrenMatch (line 155) | public static boolean bothChildrenMatch(Expression e, Predicate<Expres...

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Iterables.java
  class Iterables (line 26) | public class Iterables {
    method concat (line 27) | public static <T> Iterable<T> concat(Iterable<? extends T> it1, Iterab...
    method toList (line 55) | public static <T> List<T> toList(Iterable<T> iterable) {

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Maps.java
  class Maps (line 26) | public class Maps {
    method compactify (line 28) | public static <K, V> Map<K, V> compactify(Map<K, V> map) {

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Methods.java
  class Methods (line 38) | public class Methods {
    method isEqualsMethod (line 43) | public static boolean isEqualsMethod(MethodReference mr) {
    method isHashCodeMethod (line 47) | public static boolean isHashCodeMethod(MethodReference mr) {
    method isGetClass (line 51) | public static boolean isGetClass(MethodReference mr) {
    method is (line 55) | public static boolean is(MethodReference mr, String internalTypeName, ...
    method knownToThrow (line 60) | public static boolean knownToThrow(MethodReference mr) {
    method findSuperMethod (line 69) | public static MethodDefinition findSuperMethod(MethodReference mr) {
    method findSuperMethods (line 77) | public static Set<MethodDefinition> findSuperMethods(MethodReference m...
    method collectSuperMethods (line 87) | private static void collectSuperMethods(TypeDefinition type, MemberInf...
    method resolveToBridge (line 111) | public static MethodDefinition resolveToBridge(MethodDefinition md) {
    method findSuperMethod (line 141) | public static MethodDefinition findSuperMethod(TypeDefinition type, Me...
    method findMethod (line 168) | public static MethodDefinition findMethod(TypeDefinition td, MemberInf...
    method isMain (line 184) | public static boolean isMain(MethodDefinition md) {
    method isSideEffectFree (line 188) | public static boolean isSideEffectFree(MethodReference mr) {
    method isPure (line 236) | public static boolean isPure(MethodReference mr) {
    method isThrower (line 251) | public static boolean isThrower(MethodDefinition md) {
    method isSerializationMethod (line 265) | public static boolean isSerializationMethod(MethodDefinition md) {

FILE: huntbugs/src/main/java/one/util/huntbugs/util/NodeChain.java
  class NodeChain (line 38) | public class NodeChain {
    method NodeChain (line 42) | public NodeChain(NodeChain parent, Node cur) {
    method getParent (line 47) | public NodeChain getParent() {
    method getNode (line 51) | public Node getNode() {
    method toString (line 55) | @Override
    method getRoot (line 65) | public Block getRoot() {
    method isSynchronized (line 76) | public boolean isSynchronized() {
    method getSyncObject (line 90) | public Expression getSyncObject() {
    method isInTry (line 109) | public boolean isInTry(String... wantedExceptions) {
    method isInCatch (line 128) | public boolean isInCatch(String wantedException) {
    method getLambdaMethod (line 144) | public MethodDefinition getLambdaMethod() {
    method isOnlyChild (line 155) | public boolean isOnlyChild(Node node) {
    method isInLoop (line 160) | public boolean isInLoop() {

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Nodes.java
  class Nodes (line 51) | public class Nodes {
    method isOp (line 52) | public static boolean isOp(Node node, AstCode op) {
    method isInvoke (line 56) | public static boolean isInvoke(Node node) {
    method isNullCheck (line 64) | public static boolean isNullCheck(Node node) {
    method isFieldRead (line 71) | public static boolean isFieldRead(Node node) {
    method getChild (line 75) | public static Node getChild(Node node, int i) {
    method getConstant (line 82) | public static Object getConstant(Node node) {
    method ifBinaryWithConst (line 91) | public static void ifBinaryWithConst(Expression expr, BiConsumer<Expre...
    method getWrittenVariable (line 107) | public static Variable getWrittenVariable(Node node) {
    method isWriteTo (line 122) | public static boolean isWriteTo(Node node, Set<Variable> vars) {
    method isComparison (line 127) | public static boolean isComparison(Node node) {
    method isBinaryMath (line 143) | public static boolean isBinaryMath(Node node) {
    method isBoxing (line 164) | public static boolean isBoxing(Node node) {
    method isUnboxing (line 191) | public static boolean isUnboxing(Node node) {
    method isEquivalent (line 215) | public static boolean isEquivalent(Node expr1, Node expr2) {
    method isSideEffectFree (line 226) | public static boolean isSideEffectFree(Node node) {
    method isPure (line 240) | public static boolean isPure(Node node) {
    method isSynchorizedBlock (line 248) | public static boolean isSynchorizedBlock(Node node) {
    method getSyncObject (line 256) | public static Expression getSyncObject(TryCatchBlock tcb) {
    method isCompoundAssignment (line 273) | public static boolean isCompoundAssignment(Node node) {
    method dropNarrowing (line 307) | private static Expression dropNarrowing(Expression expression) {
    method find (line 321) | public static Node find(Node node, Predicate<Node> predicate) {
    method getChildren (line 332) | @SuppressWarnings("unchecked")
    method isEmptyOrBreak (line 354) | public static boolean isEmptyOrBreak(Block block) {
    method getOperation (line 369) | public static String getOperation(AstCode code) {
    method getLambdaMethod (line 410) | public static MethodDefinition getLambdaMethod(Lambda l) {
    method estimateCodeSize (line 420) | public static int estimateCodeSize(Node node) {
    method getMethodHandle (line 424) | public static MethodHandle getMethodHandle(DynamicCallSite dcs) {
    method isThrow (line 436) | public static boolean isThrow(Node node) {
    method isToFloatingPointConversion (line 447) | public static boolean isToFloatingPointConversion(Node node) {
    method facts (line 455) | public static String facts(Node node) {

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Types.java
  class Types (line 38) | public class Types {
    method lookupJdkType (line 53) | public static synchronized TypeDefinition lookupJdkType(String interna...
    method getBaseTypes (line 66) | public static List<TypeReference> getBaseTypes(TypeReference input) {
    method isInstance (line 81) | public static boolean isInstance(TypeReference type, TypeReference wan...
    method isInstance (line 85) | public static boolean isInstance(TypeReference type, String wantedType) {
    method isRandomClass (line 110) | public static boolean isRandomClass(TypeReference type) {
    method getExpressionType (line 118) | public static TypeReference getExpressionType(Expression expr) {
    method isSideEffectFreeType (line 134) | public static boolean isSideEffectFreeType(TypeReference type) {
    method samePackage (line 138) | public static boolean samePackage(String internalName1, String interna...
    method isMutable (line 149) | public static boolean isMutable(TypeReference type) {
    method isImmutable (line 159) | public static boolean isImmutable(TypeReference type) {
    method isBoxed (line 167) | public static boolean isBoxed(TypeReference type) {
    method isObject (line 171) | public static boolean isObject(TypeReference type) {
    method isCollection (line 175) | public static boolean isCollection(TypeReference type) {
    method isStream (line 179) | public static boolean isStream(TypeReference type) {
    method isString (line 183) | public static boolean isString(TypeReference type) {
    method isBaseStream (line 187) | public static boolean isBaseStream(TypeReference type) {
    method is (line 191) | public static boolean is(TypeReference type, Class<?> clazz) {
    method is (line 195) | public static boolean is(TypeReference type, String internalName) {
    method hasCompleteHierarchy (line 203) | public static boolean hasCompleteHierarchy(TypeDefinition type) {
    method mergeTypes (line 218) | public static TypeReference mergeTypes(TypeReference t1, TypeReference...
    method getSourceFile (line 242) | public static String getSourceFile(TypeDefinition type) {

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Variables.java
  class Variables (line 29) | public class Variables {
    method getMethodDefinition (line 44) | public static MethodDefinition getMethodDefinition(VariableDefinition ...

FILE: huntbugs/src/main/java/one/util/huntbugs/util/Xml.java
  class Xml (line 29) | public class Xml {
    method elements (line 31) | public static Stream<Element> elements(Element parent) {
    method getChild (line 37) | public static Element getChild(Element element, String tagName) {
    method getText (line 48) | public static String getText(Element element, String tagName) {
    method getAttribute (line 53) | public static String getAttribute(Element element, String attribute) {
    method getIntAttribute (line 59) | public static int getIntAttribute(Element element, String attribute, i...

FILE: huntbugs/src/main/java/one/util/huntbugs/util/YesNoMaybe.java
  type YesNoMaybe (line 22) | public enum YesNoMaybe {
    method yes (line 25) | public boolean yes() {
    method no (line 29) | public boolean no() {
    method of (line 33) | public static YesNoMaybe of(boolean b) {

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/Formatter.java
  class Formatter (line 28) | public class Formatter {
    method Formatter (line 40) | public Formatter() {
    method Formatter (line 44) | public Formatter(Messages msgs) {
    method getTitle (line 48) | public String getTitle(Warning warning) {
    method getDescription (line 52) | public String getDescription(Warning warning) {
    method getLongDescription (line 56) | public String getLongDescription(Warning warning) {
    method format (line 60) | private String format(String description, Warning warning, String form...
    method formatValue (line 87) | public static String formatValue(Object value, String format) {
    method formatString (line 112) | private static String formatString(String value, String format) {
    method formatLong (line 119) | private static String formatLong(long value, String format) {
    method formatInteger (line 146) | private static String formatInteger(int value, String format) {
    method formatFloat (line 162) | private static String formatFloat(float val) {
    method formatDouble (line 180) | private static String formatDouble(double val) {
    method formatTypeInfo (line 198) | private static String formatTypeInfo(TypeInfo ti, String format) {
    method formatMemberInfo (line 206) | private static String formatMemberInfo(MemberInfo mi, String format) {
    method formatConstant (line 233) | public static String formatConstant(Object constant) {

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/Messages.java
  class Messages (line 42) | public class Messages {
    class Message (line 47) | public static class Message {
      method Message (line 50) | public Message(String title, String description, String longDescript...
      method getTitle (line 56) | public String getTitle() {
      method getDescription (line 60) | public String getDescription() {
      method getLongDescription (line 64) | public String getLongDescription() {
    method Messages (line 69) | private Messages(Map<String, Message> map) {
    method getMessagesForType (line 73) | public Message getMessagesForType(WarningType warningType) {
    method getMessagesForType (line 77) | public Message getMessagesForType(String warningType) {
    method load (line 85) | public static Messages load() {
    method readMessages (line 102) | private static Document readMessages(URL messageUrl) {
    method toMap (line 114) | private static Map<String, Message> toMap(Document dom) {

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/Role.java
  class Role (line 40) | public class Role<T> {
    type Count (line 41) | public enum Count {
    method Role (line 49) | Role(String name, Class<T> type) {
    method Role (line 53) | Role(String name, Class<T> type, Count count) {
    method getCount (line 62) | public Count getCount() {
    method getType (line 66) | public Class<T> getType() {
    method hashCode (line 70) | @Override
    method equals (line 75) | @Override
    method toString (line 85) | @Override
    method create (line 90) | public WarningAnnotation<T> create(T value) {
    class MemberRole (line 94) | public static class MemberRole extends Role<MemberInfo> {
      method MemberRole (line 95) | MemberRole(String name) {
      method MemberRole (line 99) | MemberRole(String name, Count count) {
      method create (line 103) | public WarningAnnotation<MemberInfo> create(MemberReference mr) {
      method create (line 107) | public WarningAnnotation<MemberInfo> create(String internalTypeName,...
      method forName (line 111) | public static MemberRole forName(String name) {
    class NumberRole (line 116) | public static class NumberRole extends Role<Number> {
      method NumberRole (line 117) | NumberRole(String name) {
      method NumberRole (line 121) | NumberRole(String name, Count count) {
      method forName (line 125) | public static NumberRole forName(String name) {
    class StringRole (line 130) | public static class StringRole extends Role<String> {
      method StringRole (line 131) | StringRole(String name) {
      method StringRole (line 135) | StringRole(String name, Count count) {
      method createFromConst (line 139) | public WarningAnnotation<String> createFromConst(Object constant) {
      method forName (line 143) | public static StringRole forName(String name) {
    class TypeRole (line 148) | public static class TypeRole extends Role<TypeInfo> {
      method TypeRole (line 149) | TypeRole(String name) {
      method TypeRole (line 153) | TypeRole(String name, Count count) {
      method create (line 157) | public WarningAnnotation<TypeInfo> create(TypeReference tr) {
      method create (line 161) | public WarningAnnotation<TypeInfo> create(String internalTypeName) {
      method forName (line 165) | public static TypeRole forName(String name) {
    class LocationRole (line 170) | public static class LocationRole extends Role<Location> {
      method LocationRole (line 171) | LocationRole(String name) {
      method LocationRole (line 175) | LocationRole(String name, Count count) {
      method create (line 179) | public WarningAnnotation<Location> create(MethodContext mc, Node nod...
      method forName (line 183) | public static LocationRole forName(String name) {
    class OperationRole (line 188) | public static class OperationRole extends StringRole {
      method OperationRole (line 189) | public OperationRole(String name, Count count) {
      method OperationRole (line 193) | public OperationRole(String name) {
      method create (line 197) | public WarningAnnotation<String> create(AstCode code) {
      method create (line 201) | public WarningAnnotation<String> create(Expression expr) {
    class ExpressionRole (line 208) | public static class ExpressionRole extends StringRole {
      method ExpressionRole (line 209) | public ExpressionRole(String name, Count count) {
      method ExpressionRole (line 213) | public ExpressionRole(String name) {
      method create (line 217) | public WarningAnnotation<String> create(Expression expr) {
      method forName (line 222) | public static ExpressionRole forName(String name) {

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/Roles.java
  class Roles (line 35) | public final class Roles {
    method Roles (line 169) | private Roles() {

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/Warning.java
  class Warning (line 30) | public class Warning {
    method Warning (line 39) | public Warning(WarningType type, int priority, List<WarningAnnotation<...
    method Warning (line 43) | public Warning(WarningType type, int priority, List<WarningAnnotation<...
    method getClassName (line 53) | public String getClassName() {
    method getAnnotation (line 58) | public <T> T getAnnotation(Role<T> role) {
    method getAnnotation (line 66) | public WarningAnnotation<?> getAnnotation(String name) {
    method annotations (line 74) | public Stream<WarningAnnotation<?>> annotations() {
    method getScore (line 78) | public int getScore() {
    method getType (line 82) | public WarningType getType() {
    method getStatus (line 86) | public WarningStatus getStatus() {
    method withStatus (line 90) | public Warning withStatus(WarningStatus status) {
    method saturateScore (line 97) | public static int saturateScore(int score) {
    method toString (line 101) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/WarningAnnotation.java
  class WarningAnnotation (line 28) | public class WarningAnnotation<T> {
    method WarningAnnotation (line 32) | WarningAnnotation(Role<T> role, T value) {
    method getRole (line 38) | public Role<T> getRole() {
    method getValue (line 42) | public T getValue() {
    method hashCode (line 46) | @Override
    method equals (line 51) | @Override
    class TypeInfo (line 61) | public static class TypeInfo {
      method TypeInfo (line 64) | public TypeInfo(String typeName) {
      method TypeInfo (line 68) | public TypeInfo(TypeReference ref) {
      method getTypeName (line 72) | public String getTypeName() {
      method getJavaName (line 76) | public String getJavaName() {
      method getSimpleName (line 80) | public String getSimpleName() {
      method hashCode (line 119) | @Override
      method equals (line 124) | @Override
      method toString (line 130) | @Override
    class MemberInfo (line 139) | public static class MemberInfo {
      method MemberInfo (line 144) | public MemberInfo(String typeName, String name, String signature) {
      method MemberInfo (line 150) | public MemberInfo(MemberReference mr) {
      method getTypeName (line 156) | public String getTypeName() {
      method getType (line 160) | public TypeInfo getType() {
      method getName (line 164) | public String getName() {
      method getSignature (line 168) | public String getSignature() {
      method isMethod (line 172) | public boolean isMethod() {
      method toString (line 176) | @Override
      method hashCode (line 186) | @Override
      method equals (line 191) | @Override
      method getReturnType (line 201) | public TypeInfo getReturnType() {
    class Location (line 211) | public static class Location {
      method Location (line 215) | public Location(int offset, int sourceLine) {
      method getOffset (line 220) | public int getOffset() {
      method getSourceLine (line 224) | public int getSourceLine() {
      method toString (line 228) | @Override
      method hashCode (line 235) | @Override
      method equals (line 240) | @Override
    method toString (line 251) | @Override
    method forVariable (line 256) | public static WarningAnnotation<String> forVariable(Variable var) {

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/WarningStatus.java
  type WarningStatus (line 23) | public enum WarningStatus {

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/WarningType.java
  class WarningType (line 24) | public class WarningType {
    method WarningType (line 29) | public WarningType(String category, String name, int maxScore) {
    method WarningType (line 35) | public WarningType(WarningDefinition def) {
    method getCategory (line 39) | public String getCategory() {
    method getName (line 43) | public String getName() {
    method getMaxScore (line 47) | public int getMaxScore() {
    method toString (line 51) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/rule/CategoryRule.java
  class CategoryRule (line 24) | public class CategoryRule implements Rule {
    method CategoryRule (line 28) | public CategoryRule(String category, int adjustment) {
    method adjust (line 33) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/rule/CompositeRule.java
  class CompositeRule (line 26) | public class CompositeRule implements Rule {
    method CompositeRule (line 29) | public CompositeRule(List<Rule> rules) {
    method adjust (line 34) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/rule/RegexRule.java
  class RegexRule (line 26) | public class RegexRule implements Rule {
    method RegexRule (line 30) | public RegexRule(String regex, int adjustment) {
    method adjust (line 35) | @Override

FILE: huntbugs/src/main/java/one/util/huntbugs/warning/rule/Rule.java
  type Rule (line 24) | public interface Rule {
    method adjust (line 25) | WarningType adjust(WarningType wt);
    method adjust (line 28) | @Override

FILE: huntbugs/src/test/java/one/util/huntbugs/AsserterTest.java
  class AsserterTest (line 30) | public class AsserterTest {
    method test (line 31) | @Test

FILE: huntbugs/src/test/java/one/util/huntbugs/DataTest.java
  class DataTest (line 24) | public class DataTest {
    method test (line 26) | @Test

FILE: huntbugs/src/test/java/one/util/huntbugs/FilteredRepositoryTest.java
  class FilteredRepositoryTest (line 33) | public class FilteredRepositoryTest {
    method filteredRepoTest (line 34) | @Test

FILE: huntbugs/src/test/java/one/util/huntbugs/MessagesTest.java
  class MessagesTest (line 35) | public class MessagesTest {
    method testMessages (line 36) | @Test
    method testFormatter (line 44) | @Test

FILE: huntbugs/src/test/java/one/util/huntbugs/OptionsTest.java
  class OptionsTest (line 27) | public class OptionsTest {
    method testAnalysisOptions (line 28) | @Test

FILE: huntbugs/src/test/java/one/util/huntbugs/ReportsTest.java
  class ReportsTest (line 43) | public class ReportsTest {
    method testMergeZero (line 44) | @Test(expected = IllegalArgumentException.class)
    method testMerge (line 49) | @Test
    method testDiff (line 71) | @Test

FILE: huntbugs/src/test/java/one/util/huntbugs/RuleTest.java
  class RuleTest (line 35) | public class RuleTest {
    method testRules (line 36) | @Test

FILE: huntbugs/src/test/java/one/util/huntbugs/asserter/TestAsserter.java
  class TestAsserter (line 25) | @AssertWarning("BBB")
    method test (line 36) | @AssertWarning("AAA")
    method testSuppress (line 42) | @AssertWarning("ParameterOverwritte*")
    method testSuppressParam (line 49) | @AssertWarning("ParameterOverwritt*")
    method uncalled (line 55) | @AssertNoWarning("UncalledPrivateMethod")
    method testLocalClass (line 60) | public void testLocalClass() {

FILE: huntbugs/src/test/java/one/util/huntbugs/registry/DetectorRegistryTest.java
  class DetectorRegistryTest (line 32) | public class DetectorRegistryTest {
    method setUp (line 38) | @Before
    method addDetector (line 44) | @Test
    method addFakeDetector (line 51) | @Test
    method getWarnings (line 58) | private long getWarnings() {
    class TestDetector (line 62) | @WarningDefinition(category="DetectorRegistryTest", name="DetectorRegi...

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestAbandonedStream.java
  class TestAbandonedStream (line 29) | public class TestAbandonedStream {
    method testSimple (line 30) | @AssertWarning("AbandonedStream")
    method testClose (line 35) | @AssertNoWarning("AbandonedStream")
    method testSimpleOk (line 43) | @AssertNoWarning("*")
    method testSimpleReturn (line 48) | @AssertNoWarning("*")
    method testVar (line 53) | @AssertWarning("AbandonedStream")
    method testVarOk (line 59) | @AssertNoWarning("*")
    method testIf (line 66) | @AssertWarning("AbandonedStream")
    method testIfOk (line 74) | @AssertNoWarning("*")
    method testTernaryOk (line 83) | @AssertNoWarning("*")
    method testToPrimitive (line 89) | @AssertWarning("AbandonedStream")
    method testPrimitive (line 94) | @AssertWarning("AbandonedStream")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestAppendObjectOutputStream.java
  class TestAppendObjectOutputStream (line 31) | public class TestAppendObjectOutputStream {
    method createStream (line 32) | @AssertWarning("AppendObjectOutputStream")
    method createStreamComplex (line 37) | @AssertWarning("AppendObjectOutputStream")
    method createStreamConditional (line 44) | @AssertWarning("AppendObjectOutputStream")
    method createStreamNoAppend (line 52) | @AssertNoWarning("AppendObjectOutputStream")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestArrayRangeCheck.java
  class TestArrayRangeCheck (line 27) | public class TestArrayRangeCheck {
    method get (line 30) | @AssertWarning("ArrayIndexNegative")
    method test (line 36) | @AssertWarning("ArrayIndexOutOfRange")
    method testArrayBoolean (line 43) | @AssertWarning("ArrayIndexOutOfRange")
    method getValueLocal (line 52) | @AssertWarning("ArrayIndexOutOfRange")
    method testArrayClone (line 65) | @AssertWarning("ArrayIndexOutOfRange")
    method testOk (line 73) | @AssertNoWarning("*")
    method testArrayCopyOk (line 80) | @AssertNoWarning("*")
    method testArrayCopy (line 88) | @AssertWarning("ArrayLengthOutOfRange")
    method testArrayCopyLength (line 96) | @AssertWarning("ArrayLengthOutOfRange")
    method testArrayCopyIdx (line 104) | @AssertWarning("ArrayOffsetOutOfRange")
    method testArrayCopyNegative (line 112) | @AssertWarning("ArrayIndexNegative")
    method testArrayCopyCatch (line 120) | @AssertNoWarning("Array*")
    class SubArrayCheck (line 134) | public class SubArrayCheck {
      method SubArrayCheck (line 137) | SubArrayCheck(String s) {
      method SubArrayCheck (line 142) | SubArrayCheck() {
      method set (line 146) | @AssertWarning("ArrayIndexOutOfRange")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestAtomicConcurrent.java
  class TestAtomicConcurrent (line 27) | public class TestAtomicConcurrent {
    method TestAtomicConcurrent (line 31) | public TestAtomicConcurrent() {
    method testAtomic (line 37) | @AssertWarning(value="NonAtomicOperationOnConcurrentMap", minScore=40,...
    method testAtomicArray (line 46) | @AssertWarning(value="NonAtomicOperationOnConcurrentMap", minScore=61)
    method testAtomic2 (line 55) | @AssertWarning("NonAtomicOperationOnConcurrentMap")
    method testAtomicUpdate (line 65) | @AssertWarning("NonAtomicOperationOnConcurrentMap")
    method testAtomicUpdate2 (line 70) | @AssertWarning("NonAtomicOperationOnConcurrentMap")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestAverageComputation.java
  class TestAverageComputation (line 25) | public class TestAverageComputation {
    method bsearch (line 26) | @AssertWarning("AverageComputationCouldOverflow")
    method bsearch2 (line 42) | @AssertWarning("AverageComputationCouldOverflow")
    method bsearchOk (line 58) | @AssertNoWarning("AverageComputationCouldOverflow")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestBadMath.java
  class TestBadMath (line 25) | public class TestBadMath {
    method testRem (line 29) | @AssertWarning("RemOne")
    method testRemSwitch (line 38) | @AssertWarning("RemOne")
    method testRemSwitchInside (line 55) | @AssertWarning("RemOne")
    method testRemSwitchOk (line 72) | @AssertNoWarning("RemOne")
    method testRemLoop (line 90) | @AssertWarning("RemOne")
    method testRemLoopOk (line 101) | @AssertNoWarning("RemOne")
    method testRemDoWhile (line 112) | @AssertWarning("RemOne")
    method testRemDoWhileOk (line 124) | @AssertNoWarning("RemOne")
    method testRemAbs (line 136) | @AssertWarning("RemOne")
    method testRemOk (line 142) | @AssertNoWarning("RemOne")
    method testOrZero (line 150) | @AssertWarning("UselessOrWithZero")
    method testXorZero (line 156) | @AssertWarning("UselessOrWithZero")
    method TestBadMath (line 167) | @AssertNoWarning("UselessOrWithZero")
    method setNothingField (line 172) | @AssertNoWarning("*")
    method setNothingLocal (line 177) | @AssertNoWarning("*")
    method setFlags (line 186) | @AssertNoWarning("UselessOrWithZero")
    method setFlags2 (line 193) | @AssertWarning("UselessOrWithZero")
    method testAndFFFF (line 200) | @AssertWarning("UselessAndWithMinusOne")
    method testAndFFFF (line 205) | @AssertNoWarning("UselessAndWithMinusOne")
    method testAndFFFFIncorrect (line 210) | @AssertWarning("UselessAndWithMinusOne")
    method testAndFFFFConvert (line 215) | @AssertWarning("UselessAndWithMinusOne")
    method testBoolean (line 221) | @AssertNoWarning("Useless*")
    method testCompound (line 229) | @AssertNoWarning("Useless*")
    method testIncompatibleAnd (line 239) | @AssertWarning("CompareBitAndIncompatible")
    method testIncompatibleAnd2 (line 246) | @AssertWarning("CompareBitAndIncompatible")
    method testCompatibleAnd (line 253) | @AssertNoWarning("CompareBitAndIncompatible")
    method testIncompatibleOr (line 260) | @AssertWarning("CompareBitOrIncompatible")
    method testIncompatibleOr2 (line 267) | @AssertWarning("CompareBitOrIncompatible")
    method testCompatibleOr (line 274) | @AssertNoWarning("CompareBitOrIncompatible")
    method testInCompatibleOrObscure (line 281) | @AssertWarning("CompareBitOrIncompatible")
    method testUselessAnd (line 290) | @AssertWarning("UselessAndWithMinusOne")
    method isFoo (line 296) | @AssertWarning("BitCheckGreaterNegative")
    method isFooRev (line 301) | @AssertWarning("BitCheckGreaterNegative")
    method isFooStrangeButOk (line 306) | @AssertNoWarning("*")
    method isBar (line 311) | @AssertNoWarning("BitCheckGreaterNegative")
    method isFooOk (line 317) | @AssertNoWarning("*")
    method shift (line 322) | @AssertWarning("BitShiftInvalidAmount")
    method shift (line 327) | @AssertWarning("BitShiftInvalidAmount")
    method shiftLeft (line 332) | @AssertWarning("BitShiftInvalidAmount")
    method shiftOk (line 338) | @AssertNoWarning("BitShiftInvalidAmount")
    method shiftOk (line 343) | @AssertNoWarning("BitShiftInvalidAmount")
    method bitAdd (line 348) | @AssertWarning("BitAddSignedByte")
    method bitAdd (line 353) | @AssertWarning("BitAddSignedByte")
    method bitAdd2 (line 358) | @AssertWarning("BitAddSignedByte")
    method bitOr (line 363) | @AssertWarning("BitOrSignedByte")
    method hashCode (line 368) | @Override
    method testShiftPriority (line 374) | @AssertWarning(value="BitShiftWrongPriority", minScore=45, maxScore=45)
    method testShiftPriorityAnd (line 379) | @AssertWarning(value="BitShiftWrongPriority", minScore=55, maxScore=55)

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestBadMethodCalls.java
  class TestBadMethodCalls (line 40) | public class TestBadMethodCalls {
    method systemExit (line 47) | @AssertWarning(value="SystemExit", maxScore = 30)
    method runFinalizers (line 52) | @SuppressWarnings("deprecation")
    method doSomething (line 58) | @AssertWarning(value="SystemExit", minScore = 40)
    method collectSomeGarbage (line 63) | @AssertWarning(value="SystemGc", maxScore = 40)
    method collectGarbageInCatch (line 68) | @AssertNoWarning("SystemGc")
    method collectGarbageTimeMeasure (line 84) | @AssertNoWarning("SystemGc")
    method collectGarbageInGeneralCatch (line 93) | @AssertWarning("SystemGc")
    method main (line 103) | @AssertNoWarning("System*")
    method threadStopThrowable (line 109) | @SuppressWarnings("deprecation")
    method threadStop (line 115) | @SuppressWarnings("deprecation")
    method testCreateThread (line 121) | @AssertWarning("UselessThread")
    class MyThread (line 126) | static class MyThread extends Thread
      method MyThread (line 128) | @AssertNoWarning("UselessThread")
      method MyThread (line 132) | @AssertWarning("UselessThread")
      method run (line 137) | @Override
    method testBigDecimal (line 143) | @AssertWarning("BigDecimalConstructedFromDouble")
    method testBigDecimalInf (line 148) | @AssertWarning("BigDecimalConstructedFromInfiniteOrNaN")
    method testBigDecimalRound (line 153) | @AssertNoWarning("BigDecimal*")
    method urlHashCode (line 158) | @AssertWarning("URLBlockingMethod")
    method urlEquals (line 163) | @AssertWarning("URLBlockingMethod")
    method urlEquals (line 168) | @AssertNoWarning("*")
    method urlEquals2 (line 173) | @SuppressWarnings("deprecation")
    method format (line 179) | @AssertWarning("ArrayToString")
    method format2 (line 184) | @AssertWarning("ArrayToString")
    method fieldArray (line 189) | @AssertWarning("ArrayToString")
    method instanceOfToArray (line 194) | @AssertWarning("ArrayToString")
    method formatChar (line 202) | @AssertWarning("CharArrayToString")
    method format3 (line 207) | @AssertWarning("ArrayToString")
    method format4 (line 212) | @AssertNoWarning("ArrayToString")
    method hash (line 217) | @AssertWarning("ArrayHashCode")
    method hash2 (line 222) | @AssertWarning("ArrayHashCode")
    method hash3 (line 227) | @AssertWarning("ArrayHashCode")
    method testDouble (line 232) | @AssertWarning("DoubleLongBitsToDoubleOnInt")
    method testThreadPoolExecutor (line 237) | @AssertWarning("ScheduledThreadPoolExecutorChangePoolSize")
    method testBadMonth (line 242) | @SuppressWarnings("deprecation")
    method testAddCollection (line 248) | @AssertWarning("CollectionAddedToItself")
    method testAddArrayList (line 253) | @AssertWarning("CollectionAddedToItself")
    method testNullCheckAssert (line 258) | @AssertWarning("NullCheckMethodForConstant")
    method testNullCheckAssertOk (line 263) | @AssertNoWarning("NullCheckMethodForConstant")
    method testNullCheckAssert2 (line 268) | @AssertWarning("NullCheckMethodForConstant")
    method testWrongAssert (line 274) | @AssertWarning("WrongArgumentOrder")
    method testCorrectAssert (line 279) | @AssertNoWarning("*")
    method testWrongPrecondition (line 284) | @AssertWarning("WrongArgumentOrder")
    method testCorrectPrecondition (line 289) | @AssertNoWarning("*")
    method TestBadMethodCalls (line 296) | public TestBadMethodCalls() {
    method TestBadMethodCalls (line 300) | public TestBadMethodCalls(int x) {
    method hashCode (line 304) | @Override
    method process (line 310) | @AssertWarning("StreamToString")
    method size (line 315) | @AssertWarning("ConcurrentCollectionSize")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestBadMethodReferences.java
  class TestBadMethodReferences (line 26) | public class TestBadMethodReferences {
    method test (line 27) | @AssertWarning("MaxMinMethodReferenceForComparator")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestBadMonitorObject.java
  class TestBadMonitorObject (line 24) | public class TestBadMonitorObject {
    method syncNumber (line 25) | @AssertWarning("SynchronizationOnBoxedNumber")
    method syncUnsharedNumber (line 33) | @AssertWarning("SynchronizationOnUnsharedBoxed")
    method syncUnsharedBoolean (line 40) | @AssertWarning("SynchronizationOnUnsharedBoxed")
    method syncBoolean (line 47) | @AssertWarning("SynchronizationOnBoolean")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestCheckReturnValue.java
  class TestCheckReturnValue (line 29) | public class TestCheckReturnValue {
    method read (line 30) | @AssertWarning("ReturnValueOfRead")
    method skipTen (line 35) | @AssertWarning("ReturnValueOfSkip")
    method skipTenOk (line 40) | @AssertNoWarning("ReturnValueOfSkip")
    method readOk (line 48) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestCloneContract.java
  class TestCloneContract (line 25) | public class TestCloneContract {
    class Clone0 (line 26) | @AssertWarning("CloneableDoesNotImplementClone")
    class Clone1 (line 31) | public class Clone1 implements Cloneable {
      method clone (line 34) | @Override
    class Clone2 (line 41) | public class Clone2 extends Clone1 {
      method clone (line 42) | @Override
    method clone (line 49) | @Override
    class NotCloneable (line 55) | public class NotCloneable {
      method clone (line 56) | @Override

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestCompareContract.java
  class TestCompareContract (line 26) | public class TestCompareContract implements Comparable<TestCompareContra...
    method compareTo (line 28) | @Override
    method compare (line 35) | @Override

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestCompareUsage.java
  class TestCompareUsage (line 27) | public class TestCompareUsage {
    method less (line 28) | @AssertWarning("NegatingComparatorResult")
    method greater (line 37) | @AssertWarning("ComparingComparatorResultWithNumber")
    method greater2 (line 42) | @AssertWarning("ComparingComparatorResultWithNumber")
    method eq (line 48) | @AssertNoWarning("ComparingComparatorResultWithNumber")
    method ok (line 53) | @AssertNoWarning("NegatingComparatorResult")
    method lessCmp (line 60) | @AssertWarning("NegatingComparatorResult")
    method lessOk (line 65) | @AssertNoWarning("NegatingComparatorResult")
    method lessCmpOk (line 70) | @AssertNoWarning("NegatingComparatorResult")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestConditionChain.java
  class TestConditionChain (line 25) | public class TestConditionChain {
    method testSameConditions (line 26) | @AssertWarning("SameConditions")
    method testExcludingConditions (line 35) | @AssertNoWarning("*")
    method testSameConditionsElse (line 44) | @AssertWarning("SameConditions")
    method testSameConditionsChain (line 55) | @AssertWarning("SameConditions")
    method testSameConditionsChainElse1 (line 66) | @AssertWarning("SameConditions")
    method testSameConditionsChainElse2 (line 79) | @AssertWarning("SameConditions")
    method testSameConditionsExcluding (line 94) | @AssertWarning("SameConditionsExcluding")
    method testCondition (line 109) | @AssertNoWarning("SameConditionsExcluding")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestCovariantArrays.java
  class TestCovariantArrays (line 27) | public class TestCovariantArrays {
    class Parent (line 29) | static abstract class Parent {}
    class Child (line 30) | static class Child extends Parent {}
    class GrandChild (line 31) | static class GrandChild extends Child {}
    method test (line 33) | @AssertWarning("ContravariantArrayStore")
    method test2d (line 38) | @AssertNoWarning("*")
    method caaStore (line 45) | @AssertWarning("ContravariantArrayStore")
    method genericStore (line 53) | @AssertWarning("ContravariantArrayStore")
    method testNull (line 59) | @AssertNoWarning("ContravariantArrayStore")
    method caaStoreNoReport (line 67) | @AssertNoWarning("ContravariantArrayStore")
    method testTernaryPhi (line 73) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestDeadLocalStore.java
  class TestDeadLocalStore (line 31) | public class TestDeadLocalStore {
    method testDeadLocalSimple (line 34) | @AssertWarning(value = "ParameterOverwritten", minScore = 55)
    method testDeadLocalBranch (line 40) | @AssertNoWarning("ParameterOverwritten")
    class Extension (line 47) | class Extension extends TestDeadLocalStore {
      method testDeadLocalSimple (line 48) | @Override
    method testDeadIncrement (line 56) | @AssertWarning("DeadIncrementInReturn")
    method testDeadIncrementOk (line 61) | @AssertNoWarning("*")
    method testFieldIncrement (line 67) | @AssertNoWarning("DeadIncrementInReturn")
    method testDeadStore (line 72) | @SuppressWarnings("unused")
    method testDeadIncrementAssignment (line 78) | @AssertWarning("DeadIncrementInAssignment")
    method testDeadIncrementAssignment2 (line 84) | @AssertNoWarning("*")
    method testDeadParameterStore (line 92) | @AssertWarning("DeadParameterStore")
    method testDeadLocalStore (line 99) | @AssertWarning(value = "DeadLocalStore", maxScore = 45)
    method testDeadLocalStore2 (line 108) | @AssertWarning(value = "DeadLocalStore", minScore = 46)
    method testDeadLocalStoreSame (line 117) | @AssertNoWarning("*")
    method testSystemExit (line 126) | @AssertNoWarning("Dead*")
    method testDeadLocalStoreLambda (line 139) | @AssertNoWarning("*")
    method testDeadLocalStoreLambda2 (line 145) | @AssertNoWarning("*")
    method testDeadLocalStoreConst (line 155) | @AssertNoWarning("*")
    method testDeadLocalStoreConstStr (line 163) | @AssertNoWarning("*")
    method testDeadLocalStoreCatch (line 171) | @AssertNoWarning("*")
    method execute (line 180) | @AssertNoWarning("*")
    method testDeadLocalStoreTernaryOk (line 197) | @AssertNoWarning("*")
    method testDeadLocalStoreTernaryOk2 (line 206) | @AssertNoWarning("*")
    method testThrow (line 223) | @AssertNoWarning("*")
    method testDeadLocalStoreCatch2 (line 231) | @AssertNoWarning("DeadParameterStore")
    class MyException (line 243) | static class MyException extends Exception {
    method convert (line 247) | private int convert(String s) throws MyException {
    method testDeadLocalStoreCatch3 (line 253) | @AssertNoWarning("*")
    method testDeadLocalStoreLabel (line 270) | @AssertNoWarning("*")
    method testDeadLocalStoreInit (line 278) | @AssertWarning(value = "DeadLocalStore", maxScore = 35)
    method testLocalClass (line 289) | public void testLocalClass() {
    class TestClass (line 300) | static class TestClass {
      method someCalculation (line 301) | long someCalculation(long i) {
    method testUnusedLocalVariableClassInStreamMap (line 308) | public void testUnusedLocalVariableClassInStreamMap() {
    method testAndChain (line 321) | @AssertWarning(value = "DeadLocalStore", maxScore = 35)
    method testLabel (line 329) | @AssertWarning("DeadLocalStore")
    method testUnreachableCatch (line 349) | @AssertWarning("DeadLocalStore")
    method synchronizedTest (line 360) | @AssertWarning("DeadLocalStore")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestDroppedExceptionObject.java
  class TestDroppedExceptionObject (line 25) | public class TestDroppedExceptionObject {
    method test (line 26) | @AssertWarning("DroppedException")
    method testOk (line 33) | @AssertNoWarning("DroppedException")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestDubiousCatch.java
  class TestDubiousCatch (line 27) | public class TestDubiousCatch {
    method catchIllegalState (line 30) | @AssertWarning("CatchIllegalMonitorStateException")
    method catchCME (line 40) | @AssertWarning("CatchConcurrentModificationException")
    method catchCMEVoid (line 54) | @AssertWarning("CatchConcurrentModificationException")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestDuplicateAssignment.java
  class TestDuplicateAssignment (line 25) | public class TestDuplicateAssignment {
    method TestDuplicateAssignment (line 28) | @AssertNoWarning("FieldDoubleAssignment")
    method doubleFieldChain (line 33) | @SuppressWarnings("cast")
    method doubleField (line 39) | @AssertWarning("FieldDoubleAssignment")
    method doubleFieldReuse (line 45) | @AssertNoWarning("FieldDoubleAssignment")
    method doubleDiffField (line 51) | @AssertNoWarning("FieldDoubleAssignment")
    method doubleDiffFieldSameField (line 57) | @AssertWarning("FieldDoubleAssignment")
    method trickyReceiver (line 64) | @AssertWarning("FieldDoubleAssignment")
    method array (line 70) | @AssertWarning("FieldDoubleAssignment")
    method arrayOk (line 76) | @AssertNoWarning("FieldDoubleAssignment")
    method doubleDiffObject (line 82) | @AssertNoWarning("FieldDoubleAssignment")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestEasyMockProblems.java
  class TestEasyMockProblems (line 27) | public class TestEasyMockProblems {
    method testEasyMock (line 28) | @AssertWarning("UselessEasyMockCall")
    method testEasyMock2 (line 33) | @AssertWarning("UselessEasyMockCall")
    method testEasyMockOk (line 39) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestEmptySync.java
  class TestEmptySync (line 25) | public class TestEmptySync {
    method emptySync (line 26) | @AssertWarning("EmptySynchronizeBlock")
    method nonEmptySync (line 35) | @AssertNoWarning("EmptySynchronizeBlock")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestEqualsContract.java
  class TestEqualsContract (line 30) | public class TestEqualsContract {
    method equals (line 32) | @Override
    class NonPublic (line 38) | static class NonPublic {
      method equals (line 39) | @Override
      method hashCode (line 45) | @Override
    class SubClass2 (line 51) | public static class SubClass2 extends NonPublic {
      method equals (line 54) | @Override
    class Final (line 66) | public static final class Final {
      method equals (line 67) | @Override
    class ClassName (line 75) | public static final class ClassName {
      method equals (line 78) | @Override
    class OtherEquals (line 88) | @AssertWarning("EqualsOther")
      method equals (line 90) | public boolean equals(TestEqualsContract other) {
    class SelfEquals (line 95) | @AssertWarning("EqualsSelf")
      method equals (line 97) | public boolean equals(SelfEquals other) {
      method hashCode (line 101) | @Override
    class SubClass (line 107) | public static class SubClass extends SelfEquals {
      method equals (line 110) | @Override
    class SubClassNoFields (line 122) | public static class SubClassNoFields extends SelfEquals {
      method equals (line 123) | @Override
    class SubClassNoFields1 (line 130) | public static class SubClassNoFields1 extends SelfEquals {
      method equals (line 131) | @Override
    class SubClassNoFields1a (line 138) | public static class SubClassNoFields1a extends SelfEquals {
      method equals (line 139) | @Override
    class SubClassNoFields2 (line 146) | public static class SubClassNoFields2 extends SelfEquals {
      method equals (line 147) | @Override
    type EnumEquals (line 156) | @AssertWarning("EqualsEnum")
      method equals (line 161) | public boolean equals(EnumEquals other) {
    class EqualsOk (line 166) | @AssertNoWarning("*")
      method equals (line 168) | public boolean equals(EqualsOk other, int check) {
    class HashCodeObject (line 173) | public static class HashCodeObject {
      method hashCode (line 174) | @Override
    class HashCodeList (line 181) | public static class HashCodeList extends ArrayList<String> {
      method HashCodeList (line 186) | public HashCodeList(String myField) {
      method hashCode (line 190) | @Override
    class EqualsObject (line 197) | public static class EqualsObject {
      method equals (line 200) | @Override
    class EqualsObject2 (line 212) | static class EqualsObject2 {
      method equals (line 215) | @Override
    class EqualsList (line 227) | @AssertNoWarning("Equals*")
      method equals (line 232) | @Override
    class EqualsWrongField (line 243) | public static class EqualsWrongField {
      method hashCode (line 249) | @Override
      method equals (line 258) | @Override
    class EqualsFieldsOk (line 270) | @AssertNoWarning("*")
      method EqualsFieldsOk (line 275) | public EqualsFieldsOk(int x, int y) {
      method getPoint (line 280) | public Point getPoint() {
      method hashCode (line 284) | @Override
      method equals (line 289) | @Override

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestExceptionalExpression.java
  class TestExceptionalExpression (line 24) | public class TestExceptionalExpression {
    method testDivisionByZero (line 25) | @AssertWarning("ExceptionalExpression")
    method testNFE (line 32) | @AssertWarning(value="ExceptionalExpression", maxScore=60)

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestExclusiveConditions.java
  class TestExclusiveConditions (line 27) | public class TestExclusiveConditions {
    method testSimple (line 28) | @AssertWarning("AndEqualsAlwaysFalse")
    method testDiff (line 35) | @AssertNoWarning("*")
    method testOr (line 42) | @AssertWarning("OrNotEqualsAlwaysTrue")
    method testBoxing (line 49) | @AssertWarning("AndEqualsAlwaysFalse")
    method testStrings (line 58) | @AssertWarning("AndEqualsAlwaysFalse")
    method testEnum (line 65) | @AssertWarning("AndEqualsAlwaysFalse")
    method testComplex (line 72) | @AssertWarning("AndEqualsAlwaysFalse")
    method testComplexOr (line 79) | @AssertWarning("OrNotEqualsAlwaysTrue")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestExposeRepresentation.java
  class TestExposeRepresentation (line 27) | public class TestExposeRepresentation {
    class InternalClass (line 28) | private class InternalClass {
      method setField (line 31) | @AssertNoWarning("*")
    method setField (line 42) | @AssertWarning(value="ExposeMutableFieldViaParameter", minScore=30)
    method setFieldClone (line 50) | @AssertNoWarning("ExposeMutableFieldViaParameter")
    method setFieldVarArgs (line 56) | @AssertWarning(value="ExposeMutableFieldViaParameter", maxScore=29)
    method setField (line 61) | @AssertNoWarning("ExposeMutableFieldViaParameter")
    method setHashTable (line 66) | @AssertWarning(value="ExposeMutableStaticFieldViaParameter", minScore=45)
    method setPoint (line 72) | @AssertWarning("ExposeMutableFieldViaParameter")
    class Point (line 77) | public class Point {
      method getX (line 80) | public int getX() {
      method setX (line 84) | public void setX(int x) {
      method getY (line 88) | public int getY() {
      method setY (line 92) | public void setY(int y) {

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestFieldAccess.java
  class TestFieldAccess (line 35) | public class TestFieldAccess {
    method setF (line 69) | @AssertWarning("UnreadPrivateField")
    method setRef (line 77) | public void setRef(Object val) {
    class SubClass (line 81) | public class SubClass extends TestFieldAccess {
      method getE (line 82) | public int getE() {
      method setE (line 86) | public void setE(int e) {
    class TestGeneric (line 91) | @AssertNoWarning("*")
      method getData (line 95) | public T[] getData() {
      method setData (line 99) | public void setData(T[] data) {
    method inc (line 113) | public long inc() {
    method cas (line 123) | public boolean cas(Object expected, Object updated) {
    method updateReflected (line 130) | public void updateReflected() throws Exception {
    method updateMH (line 140) | public void updateMH() throws Throwable {
    method test (line 146) | @AssertWarning("FieldUsedInSingleMethod")
    method testOk (line 154) | @AssertNoWarning("*")
    method testOk (line 162) | @AssertNoWarning("*")
    method getUnwritten (line 173) | @AssertWarning("UnwrittenPublicField")
    method getUnwrittenTransient (line 181) | @AssertWarning("UnwrittenPrivateField")
    type MyEnum (line 186) | @AssertNoWarning("*")
    type MyEnum2 (line 191) | public enum MyEnum2 {
      method agg (line 202) | public void agg(String s) {
      method get (line 206) | public String get(int i) {
    method reset (line 214) | public void reset() {
    method getS (line 218) | public String getS() {
    method reset2 (line 225) | public void reset2() {
    method getS2 (line 229) | public String getS2() {
    method getValue (line 236) | public static double getValue() {
    method getValueComplex (line 248) | public static double getValueComplex() {
    method getValueNonFinal (line 255) | public static double getValueNonFinal() {
    method recreateValueNonFinal (line 259) | public static void recreateValueNonFinal() {
    method recreate (line 272) | public static void recreate() {
    method getArrayElement (line 279) | public double getArrayElement(int x) {
    type FieldInterface (line 283) | public interface FieldInterface {
    method getExposeOk (line 306) | @AssertNoWarning("*")
    method getExpose (line 316) | @AssertWarning("ExposeMutableFieldViaReturnValue")
    method setExpose (line 323) | public void setExpose(int[] expose) {
    method getExpose2 (line 330) | @AssertNoWarning("*")
    method updateExpose2 (line 337) | public void updateExpose2() {
    class Reflected (line 341) | @AssertNoWarning("*")
      method set (line 347) | public void set(String name) throws Exception {

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestFinalizer.java
  class TestFinalizer (line 28) | public class TestFinalizer {
    class SuperClass (line 29) | static class SuperClass {
      method finalize (line 30) | @Override
    class Nullify (line 36) | static class Nullify extends SuperClass {
      method finalize (line 37) | @Override
    class Useless (line 43) | static class Useless extends SuperClass {
      method finalize (line 44) | @Override
    class Useful (line 51) | static class Useful extends SuperClass {
      method finalize (line 52) | @Override
    class Useful2 (line 61) | static class Useful2 extends SuperClass {
      method finalize (line 62) | @Override
    method test (line 70) | @AssertWarning("FinalizeInvocation")
    method finalize (line 75) | @Override
    class FinalFinalizer (line 81) | static class FinalFinalizer {
      method finalize (line 82) | @Override
    class NullFields (line 88) | static class NullFields {
      method finalize (line 91) | @AssertWarning("FinalizeNullsFields")
    class NullFieldsOnly (line 99) | static class NullFieldsOnly {
      method finalize (line 103) | @AssertWarning("FinalizeOnlyNullsFields")
    class NoSuperCall (line 111) | static class NoSuperCall extends SuperClass {
      method finalize (line 112) | @AssertWarning("FinalizeNoSuperCall")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestFloatComparison.java
  class TestFloatComparison (line 25) | public class TestFloatComparison {
    method testFloat (line 26) | @AssertWarning(value="FloatComparison", minScore = 25, maxScore = 45)
    method testFloatInt (line 32) | @AssertWarning(value="FloatComparison", minScore = 5, maxScore = 20)
    method testFloat (line 38) | @AssertNoWarning("FloatComparison")
    method testDouble (line 44) | @AssertWarning(value="FloatComparison", minScore = 25, maxScore = 45)
    method testRound (line 50) | @AssertNoWarning("*")
    method testDouble (line 56) | @AssertNoWarning("FloatComparison")
    method testDouble2 (line 62) | @AssertWarning(value="FloatComparison", minScore = 5, maxScore = 15)
    method testDouble3 (line 68) | @AssertWarning(value="FloatComparison", minScore = 15, maxScore = 25)
    method testDouble4 (line 76) | @AssertWarning(value="FloatComparison", minScore = 15, maxScore = 25)
    method testDoublePhi (line 82) | @AssertWarning(value="FloatComparison", minScore = 10, maxScore = 20)
    method testDoubleTernary (line 90) | @AssertWarning(value="FloatComparison", minScore = 10, maxScore = 20)

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestFloatNaN.java
  class TestFloatNaN (line 24) | public class TestFloatNaN {
    method testLambda (line 25) | @AssertWarning("UnusedLocalVariable")
    method testFloat (line 31) | @AssertWarning("FloatCompareToNaN")
    method testNotFloat (line 37) | @AssertWarning("FloatCompareToNaN")
    method testDouble (line 43) | @AssertWarning("FloatCompareToNaN")
    method testNotDouble (line 49) | @AssertWarning("FloatCompareToNaN")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestIgnoredException.java
  class TestIgnoredException (line 25) | public class TestIgnoredException {
    method test1 (line 26) | @AssertWarning("IgnoredException")
    method testOk (line 36) | @AssertNoWarning("IgnoredException")
    method test2 (line 47) | @AssertWarning("IgnoredException")
    method test3 (line 58) | @AssertWarning("IgnoredException")
    method test4 (line 70) | @AssertWarning("IgnoredException")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestIncorrectVarArg.java
  class TestIncorrectVarArg (line 27) | public class TestIncorrectVarArg {
    method testAsList (line 28) | @AssertWarning("PrimitiveArrayPassedAsVarArg")
    method custom (line 33) | private void custom(Object... data) {
    method noVarArg (line 37) | private void noVarArg(Object[] data) {
    method testCustom (line 41) | @AssertWarning("PrimitiveArrayPassedAsVarArg")
    method testOk (line 46) | @AssertNoWarning("PrimitiveArrayPassedAsVarArg")
    method testIntStream (line 51) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestInfiniteLoop.java
  class TestInfiniteLoop (line 25) | public class TestInfiniteLoop {
    method testLoop (line 26) | @AssertWarning("InfiniteLoop")
    method testFlag (line 33) | @AssertWarning("InfiniteLoop")
    method testLoopInvariant (line 41) | @AssertNoWarning("InfiniteLoop")
    method testLoopOk (line 51) | @AssertNoWarning("InfiniteLoop")
    method testLoopPart (line 58) | @AssertNoWarning("InfiniteLoop")
    method testLoopPartOk (line 66) | @AssertNoWarning("*")
    method dump (line 76) | @AssertNoWarning("InfiniteLoop")
    method dump (line 86) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestInfiniteRecursion.java
  class TestInfiniteRecursion (line 27) | public class TestInfiniteRecursion {
    method TestInfiniteRecursion (line 28) | @AssertWarning("InfiniteRecursion")
    method TestInfiniteRecursion (line 33) | @AssertWarning("InfiniteRecursion")
    method testSimple (line 40) | @AssertWarning("InfiniteRecursion")
    method testSimple (line 45) | @AssertWarning("InfiniteRecursion")
    method testSimpleMod (line 50) | @AssertWarning("InfiniteRecursion")
    method testSimpleCheck (line 56) | @AssertWarning("InfiniteRecursion")
    method testSimpleCheck (line 63) | @AssertWarning("InfiniteRecursion")
    method testSimpleModOk (line 70) | @AssertNoWarning("InfiniteRecursion")
    method test (line 77) | @AssertWarning("InfiniteRecursion")
    method updateF (line 84) | private boolean updateF() {
    method has (line 88) | @AssertNoWarning("InfiniteRecursion")
    method printRecursively (line 95) | @AssertNoWarning("*")
    type Iface (line 105) | public interface Iface {
      method test (line 106) | @AssertWarning("InfiniteRecursion")
    class InfiniteLoop (line 112) | public static abstract class InfiniteLoop {
      method report (line 115) | @AssertWarning("InfiniteRecursion")
      method report2 (line 120) | @AssertWarning("InfiniteRecursion")
      method report3 (line 127) | @AssertWarning("InfiniteRecursion")
      method doNotReport (line 132) | @AssertNoWarning("InfiniteRecursion")
      method doNotReport2 (line 139) | @AssertNoWarning("InfiniteRecursion")
      method doNotReport3 (line 148) | @AssertNoWarning("InfiniteRecursion")
      method opaque (line 156) | protected abstract boolean opaque();

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestInitializerRefersSubclass.java
  class TestInitializerRefersSubclass (line 25) | @AssertWarning("InitializerRefersSubclass")
    class SubClass (line 29) | public static class SubClass extends TestInitializerRefersSubclass {
    class AnonymousOk (line 33) | @AssertNoWarning("InitializerRefersSubclass")
    class Anonymous (line 38) | @AssertWarning("InitializerRefersSubclass")
    class AnonymousSubClass (line 43) | static class AnonymousSubClass extends Anonymous {

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestInternationalization.java
  class TestInternationalization (line 30) | public class TestInternationalization {
    method toLowerCase (line 31) | @AssertWarning("ConvertCaseWithDefaultLocale")
    method toUpperCase (line 36) | @AssertWarning("ConvertCaseWithDefaultLocale")
    method toLowerCaseOk (line 41) | @AssertNoWarning("*")
    method toUpperCaseOk (line 46) | @AssertNoWarning("*")
    method toBytes (line 51) | @AssertWarning(value="MethodReliesOnDefaultEncoding", minScore = 40, m...
    method printWriter (line 56) | @AssertWarning(value="MethodReliesOnDefaultEncoding", minScore = 28, m...
    method printWriter (line 61) | @AssertNoWarning("*")
    method toBytesOk (line 66) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestInvalidMinMax.java
  class TestInvalidMinMax (line 25) | public class TestInvalidMinMax {
    method checkBounds (line 26) | @AssertWarning("InvalidMinMax")
    method checkBounds2 (line 31) | @AssertWarning("InvalidMinMax")
    method checkBounds3 (line 36) | @AssertWarning("InvalidMinMax")
    method checkBounds4 (line 41) | @AssertWarning("InvalidMinMax")
    method checkBounds5 (line 46) | @AssertWarning("InvalidMinMax")
    method checkBounds6 (line 51) | @AssertWarning("InvalidMinMax")
    method checkWithVars (line 58) | @AssertWarning("InvalidMinMax")
    method getScore (line 70) | @AssertWarning("InvalidMinMax")
    method checkBounds (line 79) | @AssertWarning("InvalidMinMax")
    method checkBounds (line 84) | @AssertWarning("InvalidMinMax")
    method checkBounds (line 89) | @AssertWarning("InvalidMinMax")
    method checkBoundsCorrect (line 94) | @AssertNoWarning("InvalidMinMax")
    method checkBoundsCorrect2 (line 99) | @AssertNoWarning("InvalidMinMax")
    method checkBoundsCorrect3 (line 104) | @AssertNoWarning("InvalidMinMax")
    method checkBoundsCorrect (line 111) | @AssertNoWarning("InvalidMinMax")
    method checkBoundsCorrect (line 116) | @AssertNoWarning("InvalidMinMax")
    method checkBoundsCorrect (line 121) | @AssertNoWarning("InvalidMinMax")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestIteratorContract.java
  class TestIteratorContract (line 29) | public class TestIteratorContract implements Iterator<String> {
    method hasNext (line 33) | @Override
    method next (line 44) | @Override
    class Iterator2 (line 50) | public class Iterator2 implements Iterator<String> {
      method hasNext (line 53) | @Override
      method next (line 58) | @Override
    class NonIterator (line 66) | @AssertNoWarning("*")
      method hasNext (line 68) | public boolean hasNext() {
      method next (line 72) | public String next() {

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestJcipProblems.java
  class TestJcipProblems (line 26) | @Immutable

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestKnownComparison.java
  class TestKnownComparison (line 29) | public class TestKnownComparison {
    method testFinalField (line 36) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testFinalFieldOutside (line 43) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testFinalFieldReturn (line 51) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testCompoundStore (line 60) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method TestKnownComparison (line 69) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testSideEffectFree (line 81) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method getFinalField (line 90) | private int getFinalField() {
    method TestKnownComparison (line 94) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testBooleanStringCompare (line 102) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testTernaryConstCompare (line 111) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testBooleanAssignment (line 119) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testBooleanAssignmentNot (line 127) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testBooleanAssignmentTernary (line 135) | @AssertNoWarning("*")
    method testIfConstCompare (line 143) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testIfConstNotCompare (line 153) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testIfConstStrings (line 164) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testIfConstStringsNot (line 173) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testTernaryConstCompare2 (line 184) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testIntegerStringCompare (line 192) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testBooleanBoxingCompare (line 201) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testAnd (line 210) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testArrayLength (line 219) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testAnd2 (line 229) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method test (line 238) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testOr (line 247) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testInc (line 256) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testIncrement (line 266) | @AssertNoWarning("ResultOfComparisonIsStaticallyKnown")
    method testTernary (line 277) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testLoopBreak (line 283) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testFor (line 296) | @AssertNoWarning("*")
    method testSubFor (line 305) | @AssertNoWarning("*")
    method testForContinue (line 314) | @AssertNoWarning("*")
    method testNestedForForSwitch (line 325) | @AssertNoWarning("*")
    method testNestedForFor (line 354) | @AssertNoWarning("*")
    method testIncInLoop (line 379) | @AssertNoWarning("*")
    method testInLambda (line 390) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testInLambdaFP (line 402) | @AssertNoWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testComplexLoop (line 413) | @AssertNoWarning("*")
    method testComplexLoop (line 433) | @AssertNoWarning("*")
    method testComplexLoop2 (line 468) | @AssertNoWarning("*")
    method testComplexLoop3 (line 486) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testAssert (line 505) | @AssertNoWarning("*")
    method testStaticField (line 512) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testStaticFieldOk (line 520) | @AssertNoWarning("*")
    method testInstanceField (line 529) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testInstanceFieldOk (line 537) | @AssertNoWarning("*")
    method testInstanceFieldOk2 (line 546) | @AssertNoWarning("*")
    method testInstanceFieldOk3 (line 557) | @AssertNoWarning("*")
    method testFieldLoop (line 567) | @AssertNoWarning("*")
    method getArray (line 581) | private int[] getArray() {
    method testArray (line 585) | @AssertNoWarning("*")
    class TestInitial (line 595) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    class TestFieldAssignment (line 607) | @AssertNoWarning("*")
      method TestFieldAssignment (line 611) | public TestFieldAssignment(String s) {
      method TestFieldAssignment (line 620) | public TestFieldAssignment() {
      method test (line 623) | public void test() {
    method testAioobe (line 630) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testFieldDoWhile (line 647) | @AssertNoWarning("*")
    method doSomeProcessing (line 658) | private void doSomeProcessing() {
    method testBooleanFlag (line 663) | @AssertNoWarning("*")
    method testCompareToKnown (line 670) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testWhileExitCondition (line 677) | @AssertWarning("ResultOfComparisonIsStaticallyKnownDeadCode")
    method testNestedSwitch (line 687) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method catchInfiniteLoop (line 714) | @AssertNoWarning("*")
    method testSwitchPassthru (line 728) | @AssertNoWarning("*")
    method testSwitchMisplacedDefault (line 749) | @AssertNoWarning("*")
    method testSwitchMisplacedDefault2 (line 767) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testCatch (line 784) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")
    method testOrNested (line 799) | @AssertNoWarning("*")
    class ArrayTest (line 811) | @AssertNoWarning("*")
      method ArrayTest (line 815) | public ArrayTest(boolean b) {
      method testArrayLength (line 825) | public void testArrayLength() {
    method testFinally (line 832) | @AssertNoWarning("*")
    method testNestedFinally (line 852) | public void testNestedFinally() {
    method testSystemExit (line 871) | @AssertWarning("ResultOfComparisonIsStaticallyKnown")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestLockProblems.java
  class TestLockProblems (line 28) | public class TestLockProblems {
    method waitForCondition (line 29) | @AssertWarning("IncorrectConcurrentMethod")
    method notifyCondition (line 34) | @AssertWarning("IncorrectConcurrentMethod")
    method waitForObject (line 39) | @AssertNoWarning("IncorrectConcurrentMethod")
    method waitForConditionOk (line 44) | @AssertNoWarning("*")
    method notifyCountDown (line 49) | @AssertWarning("IncorrectConcurrentMethod")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestMinValueHandling.java
  class TestMinValueHandling (line 28) | public class TestMinValueHandling {
    method testRandom (line 29) | @AssertWarning(value="AbsoluteValueOfRandomInt", minScore=50, maxScore...
    method testRandomLong (line 36) | @AssertWarning(value="AbsoluteValueOfRandomInt", minScore=30, maxScore...
    method testHashCodeRem (line 45) | @AssertWarning(value="AbsoluteValueOfHashCode", minScore=55, maxScore=60)
    method testPowerOf2Rem (line 52) | @AssertWarning(value="AbsoluteValueOfHashCode", minScore=15, maxScore=25)
    method testHashCode (line 59) | @AssertWarning(value="AbsoluteValueOfHashCode", minScore=45, maxScore=55)
    method falsePositive (line 66) | @AssertNoWarning("AbsoluteValueOfHashCode")
    method unaryMinus (line 72) | @AssertNoWarning("AbsoluteValueOfHashCode")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestMutableServletField.java
  class TestMutableServletField (line 32) | public class TestMutableServletField {
    class TestServletOk (line 34) | @AssertNoWarning("*")
      method TestServletOk (line 40) | public TestServletOk() {
      method getData (line 44) | public long getData() {
      method service (line 48) | @Override
    class TestServlet (line 53) | public static class TestServlet extends GenericServlet {
      method getData (line 59) | public long getData() {
      method service (line 63) | @Override

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNaming.java
  class TestNaming (line 27) | public class TestNaming {
    method AB (line 40) | @AssertNoWarning("BadNameOfMethod")
    method Test (line 45) | @AssertWarning(value="BadNameOfMethod", minScore=28)
    method TestNaming (line 50) | @AssertWarning(value="BadNameOfMethodSameAsConstructor", minScore=60)
    method TestNaming (line 55) | @AssertWarning(value="BadNameOfMethodSameAsConstructor", maxScore=50)
    method Test2 (line 60) | @AssertWarning(value="BadNameOfMethod", minScore=25, maxScore=28)
    method Test3 (line 65) | @AssertWarning(value="BadNameOfMethod", minScore=22, maxScore=25)
    method hashcode (line 70) | @AssertWarning(value="BadNameOfMethodMistake", minScore=55)
    method hashcode (line 75) | @AssertNoWarning("BadNameOfMethodMistake")
    method tostring (line 80) | @AssertWarning(value="BadNameOfMethodMistake", minScore=55)
    method equal (line 85) | @AssertWarning(value="BadNameOfMethodMistake", minScore=55)
    class Class1 (line 90) | public static class Class1 {
      method Test4 (line 91) | @AssertWarning(value="BadNameOfMethod", minScore=15, maxScore=20)
      method hashcode (line 96) | @AssertNoWarning("BadNameOfMethodMistake")
    class Class2 (line 102) | static class Class2 {
      method Test5 (line 103) | @AssertWarning(value="BadNameOfMethod", minScore=5, maxScore=10)
      method hashcode (line 108) | @AssertNoWarning("BadNameOfMethodMistake")
    class cls1 (line 114) | @AssertWarning(value="BadNameOfClass", minScore=30)
    class cls2 (line 119) | @AssertWarning(value="BadNameOfClass", maxScore=20)
    class MyException (line 124) | @AssertWarning(value="BadNameOfClassException", minScore=40)
    class MyOkException (line 129) | @AssertNoWarning("BadNameOfClassException")
    class File (line 134) | @AssertWarning("BadNameOfClassSameAsSuperclass")
      method File (line 138) | public File(String pathname) {
    class Closeable (line 143) | @AssertWarning("BadNameOfClassSameAsInterface")
      method close (line 145) | @Override

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNegativeRemainder.java
  class TestNegativeRemainder (line 29) | public class TestNegativeRemainder {
    method getHashBucket (line 33) | @AssertWarning("HashCodeRemainder")
    method getHashBucket2 (line 38) | @AssertWarning("HashCodeRemainder")
    method setHashBucket (line 44) | @AssertWarning("HashCodeRemainder")
    method setHashBucketOk (line 50) | @AssertNoWarning("HashCodeRemainder")
    method getHashBucketList (line 56) | @AssertWarning("HashCodeRemainder")
    method setHashBucketListOk (line 61) | @AssertNoWarning("*")
    method setHashBucketList (line 66) | @AssertWarning("HashCodeRemainder")
    method setRandomElement (line 71) | @AssertWarning("RandomIntRemainder")
    method setSplittableRandomElement (line 76) | @AssertWarning("RandomIntRemainder")
    method setElementToRandom (line 81) | @AssertNoWarning("RandomIntRemainder")
    method setRandomElementOk (line 86) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNewGetClass.java
  class TestNewGetClass (line 25) | public class TestNewGetClass {
    method test (line 26) | @AssertWarning("NewForGetClass")
    method testOk (line 31) | @AssertNoWarning("NewForGetClass")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNoRuntimeRetention.java
  class TestNoRuntimeRetention (line 31) | public class TestNoRuntimeRetention {
    method testNoRuntimeRetention (line 39) | @AssertWarning("AnnotationNoRuntimeRetention")
    method testNoRuntimeRetention (line 44) | @AssertWarning("AnnotationNoRuntimeRetention")
    method testRuntimeRetention (line 49) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNonShortCircuit.java
  class TestNonShortCircuit (line 25) | public class TestNonShortCircuit {
    method testNormal (line 29) | @AssertNoWarning("NonShortCircuit*")
    method testAnd (line 52) | @AssertWarning(value="NonShortCircuit", minScore=40, maxScore=60)
    method testOr (line 59) | @AssertWarning(value="NonShortCircuit", minScore=40, maxScore=60)
    method testOrBoxing (line 66) | @AssertNoWarning("NonShortCircuit")
    method testOrBoxing2 (line 74) | @AssertWarning(value="NonShortCircuit", minScore=40, maxScore=60)
    method testMethod (line 81) | @AssertWarning(value="NonShortCircuitDangerous", minScore = 60, maxSco...
    method testNull (line 89) | @AssertWarning(value="NonShortCircuitDangerous", minScore=75)
    method testNullOr (line 97) | @AssertWarning(value="NonShortCircuitDangerous", minScore=75)
    method testInstanceOf (line 105) | @AssertWarning(value="NonShortCircuitDangerous", minScore=75)
    method testInstanceOf (line 113) | @AssertWarning("NonShortCircuit")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNullCheck.java
  class TestNullCheck (line 34) | public class TestNullCheck {
    method testNullDeref (line 35) | @SuppressWarnings("null")
    method error (line 44) | private void error(String s) {
    method testErrorCall (line 48) | @AssertNoWarning("*")
    method testLoop (line 56) | @AssertNoWarning("*")
    method testDoubleExpressionNull (line 66) | @AssertNoWarning("*")
    method testTernaryNull (line 75) | @AssertNoWarning("*")
    method testNullExceptional (line 84) | @AssertWarning("NullDereferenceExceptional")
    method testRedundantNull (line 97) | @AssertWarning("RedundantComparisonNull")
    method testNullThrow (line 108) | @AssertNoWarning("*")
    method testFileOpen (line 117) | @AssertNoWarning("*")
    method testRedundantNotNull (line 144) | @AssertWarning(value = "RedundantComparisonNullNonNull", maxScore = 45)
    class X (line 152) | class X {
    method testRedundantNullWhile (line 156) | @AssertWarning("RedundantNullCheckNull")
    method testRedundantEqualsNull (line 166) | @AssertWarning(value = "RedundantEqualsNullCheck", minScore = 55)
    method safeTrim (line 174) | @AssertNoWarning("*")
    method addItem (line 179) | @AssertNoWarning("*")
    method testOk (line 199) | @AssertNoWarning("*")
    method testNull (line 211) | @AssertWarning(value = "RedundantNullCheckNull", maxScore = 50)
    method testAssert (line 221) | @AssertNoWarning("*")
    method testNullDerefPossible (line 235) | @AssertWarning("NullDereferencePossible")
    method testRedundantDeref (line 246) | @SuppressWarnings("unused")
    method testRedundant (line 255) | @SuppressWarnings("unused")
    method testRedundantDoubleCheck (line 264) | @SuppressWarnings("unused")
    method testRedundantDoubleCheckCall (line 275) | @SuppressWarnings("unused")
    method testWithBooleanFlag (line 284) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNumberConstructor.java
  class TestNumberConstructor (line 25) | public class TestNumberConstructor {
    method testInteger (line 26) | @AssertWarning(value="NumberConstructor", minScore = 42)
    method testInteger2 (line 31) | @AssertWarning(value="NumberConstructor", minScore = 20, maxScore = 35)
    method testLong (line 36) | @AssertWarning(value="NumberConstructor", maxScore = 15)
    method testInteger3 (line 41) | @AssertWarning(value="NumberConstructor", maxScore = 42)
    method testChar (line 46) | @AssertWarning(value="NumberConstructor", maxScore = 42)
    method testBoolean (line 51) | @AssertWarning(value="BooleanConstructor", minScore = 42, maxScore=55)
    method testFloat (line 56) | @AssertNoWarning("NumberConstructor")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNumericComparison.java
  class TestNumericComparison (line 29) | public class TestNumericComparison {
    method testByte (line 30) | @AssertNoWarning("*")
    method testChar (line 37) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testShort (line 47) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testInt (line 54) | @AssertWarning(value = "ComparisonWithOutOfRangeValue", minScore = 75)
    method testIntAlways (line 62) | @AssertWarning(value = "ComparisonWithOutOfRangeValue", maxScore = 60)
    method testIntPhi (line 70) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testCharOk (line 80) | @AssertNoWarning("ComparisonWithOutOfRangeValue")
    method testAssert (line 88) | @AssertNoWarning("*")
    method testByte (line 96) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testInt (line 104) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testArrayLength (line 111) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testArrayLengthSwitch (line 118) | @AssertWarning("SwitchBranchUnreachable")
    method testArrayLengthSwitchOk (line 136) | @AssertNoWarning("SwitchBranchUnreachable")
    method testListLength (line 152) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testBitOpOk (line 159) | @AssertNoWarning("ComparisonWithOutOfRangeValue")
    method testBitOp (line 167) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testBitOpSelf (line 175) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testBitOpPhi (line 183) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testBitOpPhi2 (line 192) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testBitOpPhiOk (line 201) | @AssertNoWarning("ComparisonWithOutOfRangeValue")
    method testBitOpPhiOk2 (line 210) | @AssertNoWarning("ComparisonWithOutOfRangeValue")
    method testRem (line 219) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testRem (line 227) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testRemPhi (line 235) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testShrOk (line 244) | @AssertNoWarning("ComparisonWithOutOfRangeValue")
    method testShr (line 252) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testUShrOk (line 260) | @AssertNoWarning("ComparisonWithOutOfRangeValue")
    method testUShr (line 268) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method testRem2 (line 276) | @AssertWarning("CheckForOddnessFailsForNegative")
    method testRem2Ok (line 283) | @AssertNoWarning("CheckForOddnessFailsForNegative")
    method countMembers (line 290) | @AssertNoWarning("*")
    method checkRandom (line 303) | @AssertWarning("ComparisonWithOutOfRangeValue")
    method checkWithCatch (line 310) | @AssertWarning("ComparisonWithOutOfRangeValue")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestNumericPromotion.java
  class TestNumericPromotion (line 25) | public class TestNumericPromotion {
    method testMultiplication (line 26) | @AssertWarning(value="IntegerMultiplicationPromotedToLong", minScore =...
    method testMultiplication2 (line 31) | @AssertWarning(value="IntegerMultiplicationPromotedToLong", minScore =...
    method testMultiplication3 (line 36) | @AssertWarning(value="IntegerMultiplicationPromotedToLong", minScore =...
    method testMultiplication4 (line 41) | @AssertWarning(value="IntegerMultiplicationPromotedToLong", minScore =...
    method testMultiplication5 (line 46) | @AssertWarning(value="IntegerMultiplicationPromotedToLong", minScore =...
    method testMultiplication6 (line 51) | @AssertWarning(value="IntegerMultiplicationPromotedToLong", minScore =...
    method testMultiplicationTwoNum (line 56) | @AssertNoWarning("IntegerMultiplicationPromotedToLong")
    method divide (line 61) | @AssertWarning("IntegerDivisionPromotedToFloat")
    method percent (line 66) | @AssertNoWarning("IntegerDivisionPromotedToFloat")
    method byTen (line 71) | @AssertWarning(value="IntegerDivisionPromotedToFloat", maxScore = 50, ...
    method pow (line 76) | @AssertWarning(value="IntegerDivisionPromotedToFloat", maxScore = 45, ...
    method format (line 81) | @AssertNoWarning("*")
    method check (line 86) | @AssertNoWarning("IntegerDivisionPromotedToFloat")
    method divideByTwo (line 93) | @AssertWarning("IntegerDivisionPromotedToFloat")
    method divideAndRound (line 99) | @AssertWarning("IntegerPromotionInCeilOrRound")
    method divideAndCeil (line 104) | @AssertWarning("IntegerPromotionInCeilOrRound")
    method divideFloat (line 109) | @AssertWarning("IntegerDivisionPromotedToFloat")
    method divideFloatOk (line 114) | @AssertNoWarning("*")
    method divideWithNeg (line 119) | @AssertWarning("IntegerDivisionPromotedToFloat")
    method divideWithNegOk (line 126) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestRandomUsage.java
  class TestRandomUsage (line 30) | public class TestRandomUsage {
    method test (line 31) | @AssertWarning("RandomDoubleToInt")
    method testMul (line 36) | @AssertWarning(value="RandomNextIntViaNextDouble", maxScore=35)
    method testRnd (line 41) | @AssertWarning("RandomDoubleToInt")
    method testRndMult (line 46) | @AssertWarning("RandomNextIntViaNextDouble")
    method testRnd (line 51) | @AssertWarning("RandomDoubleToInt")
    method testRndOk (line 56) | @AssertNoWarning("Random*")
    method testRndOnce (line 61) | @AssertWarning("RandomUsedOnlyOnce")
    method testRndArr (line 66) | @AssertNoWarning("RandomUsedOnlyOnce")
    method testRndOnceSecure (line 71) | @AssertNoWarning("RandomUsedOnlyOnce")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestRedundantInterfaces.java
  class TestRedundantInterfaces (line 32) | @AssertWarning("RedundantInterface")
    class NoRedundantInterfaces (line 36) | @AssertNoWarning("RedundantInterface")
    class NoRedundantInterfaces2 (line 41) | @AssertNoWarning("RedundantInterface")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestRedundantStreamCalls.java
  class TestRedundantStreamCalls (line 34) | public class TestRedundantStreamCalls {
    method testSet (line 35) | @AssertWarning("RedundantStreamForEach")
    method testArrayList (line 40) | @AssertWarning("RedundantStreamForEach")
    method testArrayListFind (line 45) | @AssertWarning("RedundantStreamFind")
    method testStreamFind (line 50) | @AssertWarning("RedundantStreamFind")
    method testStreamFindVar (line 56) | @AssertWarning("RedundantStreamFind")
    method testStreamFindOk (line 62) | @AssertNoWarning("*")
    method testIntStreamFind (line 71) | @AssertWarning("RedundantStreamFind")
    method testIntermediate (line 76) | @AssertNoWarning("*")
    method testParallel (line 81) | @AssertNoWarning("*")
    method testRedundantEmpty (line 86) | @AssertWarning("RedundantCollectionStream")
    method testRedundantSingleton (line 91) | @AssertWarning("RedundantCollectionStream")
    method testRedundantArray (line 96) | @AssertWarning("RedundantCollectionStream")
    method testStreamCount (line 101) | @AssertWarning("StreamCountFromCollection")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestRegexProblems.java
  class TestRegexProblems (line 28) | public class TestRegexProblems {
    method testBadRegex (line 29) | @AssertWarning("RegexBadSyntax")
    method testPipe (line 36) | @AssertWarning("RegexUnintended")
    method testDot (line 43) | @AssertWarning("RegexUnintended")
    method testDotReplace (line 50) | @AssertNoWarning("RegexUnintended")
    method testDotReplaceFirst (line 55) | @AssertWarning("RegexUnintended")
    method testFileSeparator (line 60) | @AssertWarning("RegexFileSeparator")
    method testFileSeparator2 (line 65) | @AssertWarning("RegexFileSeparator")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestReturnNull.java
  class TestReturnNull (line 27) | public class TestReturnNull {
    method testOptional (line 28) | @AssertWarning("OptionalReturnNull")
    method testBoolean (line 36) | @AssertWarning("BooleanReturnNull")
    method testArray (line 43) | @AssertWarning(value="ArrayReturnNull", minScore = 35)
    method testArrayNull (line 50) | @AssertWarning(value="ArrayReturnNull", maxScore = 30)
    method testInLambda (line 55) | @AssertWarning("OptionalReturnNull")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestRoughConstants.java
  class TestRoughConstants (line 25) | public class TestRoughConstants {
    method testNan (line 29) | @AssertNoWarning("*")
    method testNoWarning (line 47) | @AssertNoWarning("*")
    method testPi1 (line 69) | @AssertWarning(value="RoughConstantValue", minScore=50)
    method testPi2 (line 74) | @AssertWarning(value="RoughConstantValue", minScore=30)
    method testPi3 (line 79) | @AssertWarning(value="RoughConstantValue", minScore=40)
    method testPi4 (line 84) | @AssertWarning(value="RoughConstantValue", minScore=50)
    method testPi5 (line 89) | @AssertWarning(value="RoughConstantValue", minScore=50)
    method testPi6 (line 94) | @AssertWarning(value="RoughConstantValue", minScore=50)
    method test2Pi1 (line 99) | @AssertWarning(value="RoughConstantValue", minScore=40)
    method test2Pi2 (line 104) | @AssertWarning(value="RoughConstantValue", minScore=30)
    method test2Pi3 (line 109) | @AssertWarning(value="RoughConstantValue", minScore=30)
    method test2Pi4 (line 114) | @AssertWarning(value="RoughConstantValue", minScore=30)
    method testE1 (line 119) | @AssertWarning(value="RoughConstantValue", minScore=30)
    method testE2 (line 124) | @AssertWarning(value="RoughConstantValue", minScore=30)
    method testE2Digits (line 129) | @AssertWarning(value="RoughConstantValue", maxScore=20)
    method testPi2Digits (line 135) | @AssertWarning(value="RoughConstantValue", minScore=30)
    method testDoubleArray (line 141) | @AssertWarning(value="RoughConstantValue", maxScore=30)
    method testDoubleArray2 (line 147) | @AssertWarning(value="RoughConstantValue", maxScore=30)
    method testDoubleArrayHighPrecision (line 153) | @AssertWarning("RoughConstantValue")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestSameBranches.java
  class TestSameBranches (line 27) | public class TestSameBranches {
    method testSame (line 28) | @AssertWarning("SameBranchesIf")
    method testSame (line 37) | @AssertWarning("SameBranchesTernary")
    method testSameComplex (line 42) | @AssertWarning("SameBranchesIf")
    method testSameDiffLambda (line 69) | @AssertNoWarning("SameBranchesIf")
    method testSameLambdaCapture (line 78) | @AssertWarning("SameBranchesIf")
    method testSameSwitch (line 87) | @AssertWarning("SameBranchesIf")
    method testDiffComplex (line 108) | @AssertNoWarning("SameBranchesIf")
    method testDiff (line 135) | @AssertNoWarning("SameBranchesIf")
    method testSwitch (line 144) | @AssertWarning("SameBranchesSwitch")
    method testSwitchFallthrough (line 168) | @AssertNoWarning("SameBranchesSwitch")
    method testSwitchDefault (line 182) | @AssertNoWarning("SameBranchesDefault")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestSameIfChain.java
  class TestSameIfChain (line 25) | public class TestSameIfChain {
    method testSimple (line 28) | @AssertWarning("SameConditionChain")
    method testField (line 38) | @AssertWarning("SameConditionChain")
    method testOk (line 48) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestSelfAssignment.java
  class TestSelfAssignment (line 25) | public class TestSelfAssignment {
    method test (line 31) | @AssertWarning("SelfAssignmentField")
    method testArray (line 37) | @AssertWarning("SelfAssignmentField")
    method testArray (line 43) | @AssertWarning("SelfAssignmentField")
    method testArrayOk (line 49) | @AssertNoWarning("SelfAssignmentField")
    method testArrayOk2 (line 55) | @AssertNoWarning("*")
    method testArraySideEffect (line 60) | @AssertNoWarning("SelfAssignmentField")
    method testThis (line 67) | @AssertWarning("SelfAssignmentField")
    method testIncrement (line 74) | @AssertNoWarning("*")
    method testIncrementStatic (line 83) | @AssertNoWarning("*")
    method testOk (line 92) | @AssertNoWarning("SelfAssignmentField")
    method testStatic (line 97) | @AssertWarning("SelfAssignmentField")
    method testSideEffectStatic (line 103) | @AssertNoWarning("SelfAssignmentField")
    method testSideEffect (line 111) | @AssertNoWarning("SelfAssignmentField")
    method testTwoObjects (line 119) | @AssertNoWarning("SelfAssignmentField")
    method testArraySelf (line 126) | @AssertWarning("SelfAssignmentArrayElement")
    method testArraySelfDiffArray (line 131) | @AssertNoWarning("SelfAssignmentArrayElement")
    method testArraySelfCopyArray (line 136) | @AssertWarning("SelfAssignmentArrayElement")
    method testArraySelfVar (line 142) | @AssertWarning("SelfAssignmentArrayElement")
    method testArraySelfChanged (line 148) | @AssertNoWarning("SelfAssignmentArrayElement")
    method testArraySelfSideEffect (line 155) | @AssertNoWarning("SelfAssignmentArrayElement")
    method update (line 162) | private void update(int[] arr) {
    method testArraySelfDiffIndex (line 166) | @AssertNoWarning("SelfAssignmentArrayElement")
    method testNew (line 171) | @AssertNoWarning("SelfAssignmentArrayElement")
    method testLocal (line 178) | @SuppressWarnings("cast")
    method testLocal (line 185) | @SuppressWarnings("cast")
    class HeapNode (line 192) | public static class HeapNode {
    method heapify (line 197) | @AssertNoWarning("*")
    method testWithCatch (line 218) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestSelfComputation.java
  class TestSelfComputation (line 29) | public class TestSelfComputation {
    method test (line 30) | @AssertWarning("SelfComputation")
    method test (line 35) | @AssertWarning("SelfComputation")
    method testCmp (line 40) | @AssertWarning("SelfComparison")
    method testCmp (line 45) | @AssertWarning("SelfComparison")
    method testEquals (line 50) | @AssertWarning("SelfEquals")
    method testMyEquals (line 55) | @AssertNoWarning("SelfEquals")
    method test (line 60) | @AssertNoWarning("SelfComputation")
    method testLambdas (line 65) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestSerializationIdiom.java
  class TestSerializationIdiom (line 31) | public class TestSerializationIdiom implements Serializable {
    class MyComparator (line 34) | @AssertWarning("ComparatorIsNotSerializable")
      method compare (line 36) | @Override
      method readObjectNoData (line 41) | @AssertNoWarning("SerializationMethodMustBePrivate")
    class NonStaticUid (line 46) | @SuppressWarnings("serial")
    class NonFinalUid (line 52) | @SuppressWarnings("serial")
    class NonLongUid (line 58) | @SuppressWarnings("serial")
    method readObject (line 64) | @AssertWarning("SerializationMethodMustBePrivate")
    method readObjectNoData (line 69) | @AssertWarning("SerializationMethodMustBePrivate")
    method writeObject (line 73) | @AssertWarning("SerializationMethodMustBePrivate")
    class ReadResolveStatic (line 78) | public static class ReadResolveStatic implements Serializable {
      method readResolve (line 81) | @AssertWarning("ReadResolveIsStatic")
    class ReadResolveNonObject (line 87) | public static class ReadResolveNonObject implements Serializable {
      method readResolve (line 90) | @AssertWarning("ReadResolveMustReturnObject")
    class ReadObjectSynchronized (line 96) | public static class ReadObjectSynchronized implements Serializable {
      method readObject (line 99) | @AssertWarning("ReadObjectIsSynchronized")
    class WriteObjectSynchronized (line 105) | public static class WriteObjectSynchronized implements Serializable {
      method writeObject (line 108) | @AssertWarning("WriteObjectIsSynchronized")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestSpinLoop.java
  class TestSpinLoop (line 25) | public class TestSpinLoop {
    method waitForTrue (line 30) | @AssertWarning("SpinLoopOnField")
    method waitForVolatileTrue (line 36) | @AssertNoWarning("SpinLoopOnField")
    method waitForNonNull (line 46) | @AssertWarning("SpinLoopOnField")
    method waitForNonNullIndirect (line 52) | @AssertWarning("SpinLoopOnField")
    method waitForNonNullIndirect2 (line 58) | @AssertWarning("SpinLoopOnField")
    method waitForStatic (line 66) | @AssertWarning("SpinLoopOnField")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestSqlBadArgument.java
  class TestSqlBadArgument (line 29) | public class TestSqlBadArgument {
    method get (line 30) | @AssertWarning(value="BadResultSetArgument", minScore=70)
    method getConditional (line 35) | @AssertWarning(value="BadResultSetArgument", maxScore=60)
    method set (line 41) | @AssertWarning("BadPreparedStatementArgument")
    method setOk (line 46) | @AssertNoWarning("*")

FILE: huntbugs/src/test/java/one/util/huntbugs/testdata/TestStartInConstructor.java
  class TestStartInConstructor (line 25) | public class TestStartInConstructor {
    method TestStartInConstructor (line 26) | @AssertWarning(value="StartInConstructor", minScore=45, maxScore=55)
    method TestStartInConstructor (line 32) | @AssertWarnin

[
  {
    "path": ".gitattributes",
    "chars": 104,
    "preview": "* text=auto\n*.java text\n*.md text\n*.xml text\n*.xsd text\n*.xsl text\n*.bat text eol=crlf\n*.sh text eol=lf\n"
  },
  {
    "path": ".gitignore",
    "chars": 114,
    "preview": "/huntbugstest\n/target\n\n# Eclipse workspace\n.metadata\n\n# Merge files\n*.orig\n\n# IntelliJ IDEA\n.idea\n\n*.releaseBackup"
  },
  {
    "path": ".mailmap",
    "chars": 57,
    "preview": "Tagir Valeev <lany@ngs.ru> <lan@developmentontheedge.com>"
  },
  {
    "path": ".travis.yml",
    "chars": 151,
    "preview": "language: java\ninstall:\n  - mvn install -DskipTests=true -B -V\njdk:\n  - oraclejdk8\nafter_success:\n  - cd huntbugs && mvn"
  },
  {
    "path": "LICENSE",
    "chars": 9158,
    "preview": "Apache License\n\nVersion 2.0, January 2004\n\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, "
  },
  {
    "path": "README.md",
    "chars": 2621,
    "preview": "This project is abandoned and unlikely will be supported in future\n===\n\nHuntBugs 0.0.11\n===\n\n[![Join the chat at https:/"
  },
  {
    "path": "findbugs.txt",
    "chars": 39407,
    "preview": "==== Reimplemented\nabbrev=\"CNT\" type=\"CNT_ROUGH_CONSTANT_VALUE\" category=\"BAD_PRACTICE\" --> RoughConstantValue\nabbrev=\"N"
  },
  {
    "path": "huntbugs/.classpath",
    "chars": 1195,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<classpath>\n\t<classpathentry kind=\"src\" output=\"target/classes\" path=\"src/main/ja"
  },
  {
    "path": "huntbugs/.gitignore",
    "chars": 133,
    "preview": "/target/\n/huntbugs*.txt\n/huntbugs*.xml\n/huntbugs*.html\n/run.bat\n/procyon-decompiler-*.jar\n/dependency-reduced-pom.xml\n/d"
  },
  {
    "path": "huntbugs/.project",
    "chars": 537,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<projectDescription>\n\t<name>huntbugs</name>\n\t<comment></comment>\n\t<projects>\n\t</p"
  },
  {
    "path": "huntbugs/.settings/org.eclipse.core.resources.prefs",
    "chars": 150,
    "preview": "eclipse.preferences.version=1\nencoding//src/main/java=UTF-8\nencoding//src/main/resources=UTF-8\nencoding//src/test/java=U"
  },
  {
    "path": "huntbugs/.settings/org.eclipse.jdt.core.prefs",
    "chars": 24242,
    "preview": "eclipse.preferences.version=1\norg.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled\norg.eclipse.jdt.core.compi"
  },
  {
    "path": "huntbugs/.settings/org.eclipse.jdt.ui.prefs",
    "chars": 8684,
    "preview": "eclipse.preferences.version=1\neditor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true\nformatter_profile"
  },
  {
    "path": "huntbugs/.settings/org.eclipse.m2e.core.prefs",
    "chars": 86,
    "preview": "activeProfiles=\neclipse.preferences.version=1\nresolveWorkspaceProjects=true\nversion=1\n"
  },
  {
    "path": "huntbugs/.settings/org.eclipse.pde.core.prefs",
    "chars": 62,
    "preview": "BUNDLE_ROOT_PATH=target/classes\neclipse.preferences.version=1\n"
  },
  {
    "path": "huntbugs/pom.xml",
    "chars": 3421,
    "preview": "<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocat"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/HuntBugs.java",
    "chars": 11632,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/analysis/AnalysisListener.java",
    "chars": 1034,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/analysis/AnalysisOptions.java",
    "chars": 2815,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/analysis/Context.java",
    "chars": 12450,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/analysis/ErrorMessage.java",
    "chars": 3960,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/analysis/HuntBugsResult.java",
    "chars": 1123,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/assertions/AssertionData.java",
    "chars": 2313,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/assertions/MemberAsserter.java",
    "chars": 5269,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/db/DeclaredAnnotations.java",
    "chars": 2734,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/db/FieldStats.java",
    "chars": 11565,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/db/Hierarchy.java",
    "chars": 4508,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/db/MethodStats.java",
    "chars": 7477,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/db/Mutability.java",
    "chars": 1533,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/AbandonedStream.java",
    "chars": 2301,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/AppendObjectOutputStream.java",
    "chars": 3605,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/ArrayRangeCheck.java",
    "chars": 6022,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/AtomicConcurrent.java",
    "chars": 5352,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/AverageComputation.java",
    "chars": 1988,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/BadMath.java",
    "chars": 11181,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/BadMethodCalls.java",
    "chars": 16367,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/BadMethodReferences.java",
    "chars": 2686,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/BadMonitorObject.java",
    "chars": 2660,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/CheckReturnValue.java",
    "chars": 3173,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/CloneContract.java",
    "chars": 4945,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/CompareContract.java",
    "chars": 2477,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/CompareUsage.java",
    "chars": 3285,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/ConditionChain.java",
    "chars": 4390,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/CovariantArrays.java",
    "chars": 4381,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/DeadLocalStore.java",
    "chars": 9384,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/DroppedExceptionObject.java",
    "chars": 2114,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/DubiousCatch.java",
    "chars": 2388,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/DuplicateAssignment.java",
    "chars": 3977,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/EasyMockProblems.java",
    "chars": 2654,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/EmptySync.java",
    "chars": 2205,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/EqualsContract.java",
    "chars": 14924,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/ExceptionalExpression.java",
    "chars": 1822,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/ExclusiveConditions.java",
    "chars": 6306,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/ExposeRepresentation.java",
    "chars": 4502,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/FieldAccess.java",
    "chars": 20766,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/FinalizerContract.java",
    "chars": 5092,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/FloatingPointComparison.java",
    "chars": 4737,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/FloatingPointNaN.java",
    "chars": 2085,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/IgnoredException.java",
    "chars": 2804,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/IncorrectVarArg.java",
    "chars": 2964,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/InfiniteLoop.java",
    "chars": 5028,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/InfiniteRecursion.java",
    "chars": 5113,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/InitializerRefersSubclass.java",
    "chars": 2261,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/Internationalization.java",
    "chars": 6835,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/InvalidMinMax.java",
    "chars": 3470,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/IteratorContract.java",
    "chars": 4056,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/JcipProblems.java",
    "chars": 1879,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/KnownComparison.java",
    "chars": 3451,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/LockProblems.java",
    "chars": 3192,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/MinValueHandling.java",
    "chars": 3993,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/MutableServletField.java",
    "chars": 3256,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/Naming.java",
    "chars": 8509,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NegativeRemainder.java",
    "chars": 2836,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NewGetClass.java",
    "chars": 1771,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NoRuntimeRetention.java",
    "chars": 2579,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NonShortCircuit.java",
    "chars": 3914,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NullCheck.java",
    "chars": 9121,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NumberConstructor.java",
    "chars": 3911,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NumericComparison.java",
    "chars": 15659,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/NumericPromotion.java",
    "chars": 9970,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/RandomUsage.java",
    "chars": 5127,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/RedundantInterfaces.java",
    "chars": 1715,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/RedundantStreamCalls.java",
    "chars": 7301,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/RegexProblems.java",
    "chars": 5195,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/ReturnNull.java",
    "chars": 3850,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/RoughConstant.java",
    "chars": 6312,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SameBranches.java",
    "chars": 6425,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SameIfChain.java",
    "chars": 4194,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SelfAssignment.java",
    "chars": 4733,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SelfComputation.java",
    "chars": 2879,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SerializationIdiom.java",
    "chars": 5705,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SpinLoop.java",
    "chars": 2603,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SqlBadArgument.java",
    "chars": 2914,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/StartInConstructor.java",
    "chars": 2762,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/StaticFieldFromInstanceMethod.java",
    "chars": 3357,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/StaticFieldNonThreadSafe.java",
    "chars": 4338,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/StringConcatInLoop.java",
    "chars": 5561,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/StringIndex.java",
    "chars": 3995,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/StringUsage.java",
    "chars": 3035,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SwingProblems.java",
    "chars": 2260,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SyncGetClass.java",
    "chars": 2881,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/SyncOnUpdatedField.java",
    "chars": 2535,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/ToArrayDowncast.java",
    "chars": 2494,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UncalledPrivateMethod.java",
    "chars": 7412,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UnnecessaryBoxing.java",
    "chars": 6107,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UnnecessaryInstanceOf.java",
    "chars": 5567,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UnreachableCatch.java",
    "chars": 1478,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UnsafeGetResource.java",
    "chars": 3433,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UnsupportedCall.java",
    "chars": 3412,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UnusedParameter.java",
    "chars": 8167,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/UselessVoidMethod.java",
    "chars": 2171,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/VolatileArray.java",
    "chars": 2450,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/VolatileIncrement.java",
    "chars": 4369,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/WaitContract.java",
    "chars": 4294,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/detect/WrongMapIterator.java",
    "chars": 4618,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/filter/AnnotationFilters.java",
    "chars": 5644,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/Annotator.java",
    "chars": 1886,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/Annotators.java",
    "chars": 2922,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/BackLinkAnnotator.java",
    "chars": 3639,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/CFG.java",
    "chars": 61562,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/ClassFields.java",
    "chars": 4000,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/CodeBlock.java",
    "chars": 1019,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/ConstAnnotator.java",
    "chars": 33396,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/Dataflow.java",
    "chars": 1432,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/ETypeAnnotator.java",
    "chars": 14193,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/EnumConstant.java",
    "chars": 1723,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/Exceptional.java",
    "chars": 1425,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/FrameContext.java",
    "chars": 4485,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/GraphSearch.java",
    "chars": 942,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/Inf.java",
    "chars": 1749,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/NullAnnotator.java",
    "chars": 14012,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/Nullness.java",
    "chars": 8264,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/PurityAnnotator.java",
    "chars": 5750,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/SourceAnnotator.java",
    "chars": 21125,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/TrueFalse.java",
    "chars": 1325,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/ValuesFlow.java",
    "chars": 5529,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/etype/AndType.java",
    "chars": 6353,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/etype/ComplexType.java",
    "chars": 1586,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/etype/EType.java",
    "chars": 4948,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/etype/OrType.java",
    "chars": 4880,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/flow/etype/SingleType.java",
    "chars": 5393,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/input/XmlReportReader.java",
    "chars": 8419,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/output/CombinedReportWriter.java",
    "chars": 1043,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/output/HtmlReportWriter.java",
    "chars": 2290,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/output/ReportWriter.java",
    "chars": 759,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/output/Reports.java",
    "chars": 15413,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/output/XmlReportWriter.java",
    "chars": 1927,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/AbstractTypeDatabase.java",
    "chars": 1851,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/ClassContext.java",
    "chars": 4328,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/ClassData.java",
    "chars": 2639,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/DatabaseRegistry.java",
    "chars": 3792,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/Detector.java",
    "chars": 11568,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/DetectorRegistry.java",
    "chars": 17053,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/ElementContext.java",
    "chars": 1789,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/FieldContext.java",
    "chars": 2861,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/FieldData.java",
    "chars": 999,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/MethodContext.java",
    "chars": 10062,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/MethodData.java",
    "chars": 5284,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/AssertNoWarning.java",
    "chars": 1033,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/AssertWarning.java",
    "chars": 1168,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/AstNodes.java",
    "chars": 1478,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/AstVisitor.java",
    "chars": 1615,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/ClassVisitor.java",
    "chars": 1514,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/FieldVisitor.java",
    "chars": 1391,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/MethodVisitor.java",
    "chars": 1564,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/TypeDatabase.java",
    "chars": 944,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/TypeDatabaseItem.java",
    "chars": 1068,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/VisitOrder.java",
    "chars": 899,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/WarningDefinition.java",
    "chars": 1064,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/registry/anno/WarningDefinitions.java",
    "chars": 950,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/repo/AuxRepository.java",
    "chars": 1185,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/repo/CompositeRepository.java",
    "chars": 1412,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/repo/DirRepository.java",
    "chars": 3138,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/repo/FilteredRepository.java",
    "chars": 2036,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/repo/JarRepository.java",
    "chars": 2288,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/repo/Repository.java",
    "chars": 4042,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/repo/RepositoryVisitor.java",
    "chars": 933,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/spi/DataTests.java",
    "chars": 3215,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you "
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/spi/HuntBugsPlugin.java",
    "chars": 828,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you "
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/AccessLevel.java",
    "chars": 2187,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Annotations.java",
    "chars": 1952,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Equi.java",
    "chars": 12883,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/ExpressionFormatter.java",
    "chars": 11381,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Exprs.java",
    "chars": 6325,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Iterables.java",
    "chars": 1742,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Maps.java",
    "chars": 1117,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Methods.java",
    "chars": 11253,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/NodeChain.java",
    "chars": 5605,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Nodes.java",
    "chars": 16773,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Types.java",
    "chars": 9136,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Variables.java",
    "chars": 1717,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/Xml.java",
    "chars": 2230,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/util/YesNoMaybe.java",
    "chars": 931,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/warning/Formatter.java",
    "chars": 8715,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/warning/Messages.java",
    "chars": 4825,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/warning/Role.java",
    "chars": 6799,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/warning/Roles.java",
    "chars": 6470,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/warning/Warning.java",
    "chars": 3335,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/warning/WarningAnnotation.java",
    "chars": 7448,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  },
  {
    "path": "huntbugs/src/main/java/one/util/huntbugs/warning/WarningStatus.java",
    "chars": 1337,
    "preview": "/*\n * Copyright 2016 HuntBugs contributors\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you"
  }
]

// ... and 139 more files (download for full content)