Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

False positive in UnnecessaryDefaultInEnumSwitch triggered by (presumed) compiler bug #849

Open
Stephan202 opened this issue Dec 5, 2017 · 6 comments

Comments

@Stephan202
Copy link
Contributor

Stephan202 commented Dec 5, 2017

I cannot provide a small reproduction case yet, but let me describe the situation.

Some code triggers the following warning:

[WARNING] /some/path/to/SomeClass.java:[430,13] [UnnecessaryDefaultInEnumSwitch] Switch handles all enum values; an explicit default case is unnecessary and defeats error checking for non-exhaustive switches.
    (see http://errorprone.info/bugpattern/UnnecessaryDefaultInEnumSwitch)
  Did you mean to remove this line?

In actuality this code is covered by case 3: the default clause cannot be removed without breaking the code.

Above this warning the following stacktrace is logged:

java.lang.RuntimeException: java.lang.NullPointerException
	at com.sun.tools.javac.api.JavacTaskImpl.handleExceptions(JavacTaskImpl.java:158)
	at com.sun.tools.javac.api.JavacTaskImpl.analyze(JavacTaskImpl.java:363)
	at com.google.errorprone.fixes.SuggestedFixes.compilesWithFix(SuggestedFixes.java:660)
	at com.google.errorprone.bugpatterns.UnnecessaryDefaultInEnumSwitch.matchSwitch(UnnecessaryDefaultInEnumSwitch.java:143)
	at com.google.errorprone.scanner.ErrorProneScanner.visitSwitch(ErrorProneScanner.java:1030)
	at com.google.errorprone.scanner.ErrorProneScanner.visitSwitch(ErrorProneScanner.java:146)
	at com.sun.tools.javac.tree.JCTree$JCSwitch.accept(JCTree.java:1223)
	at com.sun.source.util.TreePathScanner.scan(TreePathScanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:42)
	at com.sun.source.util.TreeScanner.scanAndReduce(TreeScanner.java:90)
	at com.sun.source.util.TreeScanner.scan(TreeScanner.java:105)
	at com.sun.source.util.TreeScanner.visitBlock(TreeScanner.java:248)
	at com.google.errorprone.scanner.ErrorProneScanner.visitBlock(ErrorProneScanner.java:530)
	at com.google.errorprone.scanner.ErrorProneScanner.visitBlock(ErrorProneScanner.java:146)
	at com.sun.tools.javac.tree.JCTree$JCBlock.accept(JCTree.java:1026)
	at com.sun.source.util.TreePathScanner.scan(TreePathScanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:42)
	at com.sun.source.util.TreeScanner.scanAndReduce(TreeScanner.java:90)
	at com.sun.source.util.TreeScanner.visitMethod(TreeScanner.java:206)
	at com.google.errorprone.scanner.ErrorProneScanner.visitMethod(ErrorProneScanner.java:898)
	at com.google.errorprone.scanner.ErrorProneScanner.visitMethod(ErrorProneScanner.java:146)
	at com.sun.tools.javac.tree.JCTree$JCMethodDecl.accept(JCTree.java:898)
	at com.sun.source.util.TreePathScanner.scan(TreePathScanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:42)
	at com.sun.source.util.TreeScanner.scanAndReduce(TreeScanner.java:90)
	at com.sun.source.util.TreeScanner.scan(TreeScanner.java:105)
	at com.sun.source.util.TreeScanner.scanAndReduce(TreeScanner.java:113)
	at com.sun.source.util.TreeScanner.visitClass(TreeScanner.java:187)
	at com.google.errorprone.scanner.ErrorProneScanner.visitClass(ErrorProneScanner.java:590)
	at com.google.errorprone.scanner.ErrorProneScanner.visitClass(ErrorProneScanner.java:146)
	at com.sun.tools.javac.tree.JCTree$JCClassDecl.accept(JCTree.java:808)
	at com.sun.source.util.TreePathScanner.scan(TreePathScanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:82)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:42)
	at com.sun.source.util.TreeScanner.scan(TreeScanner.java:105)
	at com.sun.source.util.TreeScanner.scanAndReduce(TreeScanner.java:113)
	at com.sun.source.util.TreeScanner.visitCompilationUnit(TreeScanner.java:144)
	at com.google.errorprone.scanner.ErrorProneScanner.visitCompilationUnit(ErrorProneScanner.java:605)
	at com.google.errorprone.scanner.ErrorProneScanner.visitCompilationUnit(ErrorProneScanner.java:146)
	at com.sun.tools.javac.tree.JCTree$JCCompilationUnit.accept(JCTree.java:591)
	at com.sun.source.util.TreePathScanner.scan(TreePathScanner.java:56)
	at com.google.errorprone.scanner.Scanner.scan(Scanner.java:64)
	at com.google.errorprone.scanner.ErrorProneScannerTransformer.apply(ErrorProneScannerTransformer.java:41)
	at com.google.errorprone.ErrorProneAnalyzer.finished(ErrorProneAnalyzer.java:152)
	at com.sun.tools.javac.api.MultiTaskListener.finished(MultiTaskListener.java:120)
	at com.sun.tools.javac.main.JavaCompiler.flow(JavaCompiler.java:1425)
	at com.sun.tools.javac.main.JavaCompiler.flow(JavaCompiler.java:1374)
	at com.sun.tools.javac.main.JavaCompiler.compile(JavaCompiler.java:973)
	at com.sun.tools.javac.api.JavacTaskImpl.lambda$doCall$0(JavacTaskImpl.java:100)
	at com.sun.tools.javac.api.JavacTaskImpl.handleExceptions(JavacTaskImpl.java:142)
	at com.sun.tools.javac.api.JavacTaskImpl.doCall(JavacTaskImpl.java:96)
	at com.sun.tools.javac.api.JavacTaskImpl.call(JavacTaskImpl.java:90)
	at com.google.errorprone.BaseErrorProneCompiler.run(BaseErrorProneCompiler.java:137)
	at com.google.errorprone.BaseErrorProneCompiler.run(BaseErrorProneCompiler.java:108)
	at com.google.errorprone.ErrorProneCompiler.run(ErrorProneCompiler.java:118)
	at org.codehaus.plexus.compiler.javac.errorprone.JavacCompilerWithErrorProne$CompilerInvoker.compile(JavacCompilerWithErrorProne.java:222)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.codehaus.plexus.compiler.javac.errorprone.JavacCompilerWithErrorProne.performCompile(JavacCompilerWithErrorProne.java:91)
	at org.apache.maven.plugin.compiler.AbstractCompilerMojo.execute(AbstractCompilerMojo.java:1075)
	at org.apache.maven.plugin.compiler.CompilerMojo.execute(CompilerMojo.java:168)
	at org.apache.maven.plugin.DefaultBuildPluginManager.executeMojo(DefaultBuildPluginManager.java:134)
	at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:208)
	at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:154)
	at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:146)
	at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:117)
	at org.apache.maven.lifecycle.internal.builder.multithreaded.MultiThreadedBuilder$1.call(MultiThreadedBuilder.java:200)
	at org.apache.maven.lifecycle.internal.builder.multithreaded.MultiThreadedBuilder$1.call(MultiThreadedBuilder.java:196)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
Caused by: java.lang.NullPointerException
	at com.sun.tools.javac.model.JavacTypes.getOverriddenMethods(JavacTypes.java:327)
	at com.sun.tools.doclint.Env.setCurrent(Env.java:208)
	at com.sun.tools.doclint.Checker.scan(Checker.java:152)
	at com.sun.tools.doclint.DocLint$2.visitDecl(DocLint.java:314)
	at com.sun.tools.doclint.DocLint$DeclScanner.visitClass(DocLint.java:398)
	at com.sun.tools.doclint.DocLint$DeclScanner.visitClass(DocLint.java:382)
	at com.sun.tools.javac.tree.JCTree$JCClassDecl.accept(JCTree.java:808)
	at com.sun.source.util.TreePathScanner.scan(TreePathScanner.java:82)
	at com.sun.source.util.TreeScanner.scan(TreeScanner.java:105)
	at com.sun.source.util.TreeScanner.scanAndReduce(TreeScanner.java:113)
	at com.sun.source.util.TreeScanner.visitCompilationUnit(TreeScanner.java:144)
	at com.sun.tools.doclint.DocLint$DeclScanner.visitCompilationUnit(DocLint.java:426)
	at com.sun.tools.doclint.DocLint$DeclScanner.visitCompilationUnit(DocLint.java:382)
	at com.sun.tools.javac.tree.JCTree$JCCompilationUnit.accept(JCTree.java:591)
	at com.sun.source.util.TreePathScanner.scan(TreePathScanner.java:82)
	at com.sun.tools.doclint.DocLint$3.started(DocLint.java:325)
	at com.sun.tools.javac.api.ClientCodeWrapper$WrappedTaskListener.started(ClientCodeWrapper.java:806)
	at com.sun.tools.javac.api.MultiTaskListener.started(MultiTaskListener.java:112)
	at com.sun.tools.javac.main.JavaCompiler.attribute(JavaCompiler.java:1342)
	at com.sun.tools.javac.main.JavaCompiler.attribute(JavaCompiler.java:1323)
	at com.sun.tools.javac.api.JavacTaskImpl.analyze(JavacTaskImpl.java:384)
	at com.sun.tools.javac.api.JavacTaskImpl.lambda$analyze$1(JavacTaskImpl.java:363)
	at com.sun.tools.javac.api.JavacTaskImpl.handleExceptions(JavacTaskImpl.java:142)
	... 78 more

This stacktrace is logged at SuggestedFixes.java:662. When I drop the -Xdoclint:reference flag from our build configuration no stacktrace is logged and the false positive goes away.

I have two questions for the Error Prone team:

  • Should there perhaps be a return false statement after SuggestedFixes.java:662, just to be safe?
  • What do you think about pruning the arguments passed in to the secondary compilation at SuggestedFixes.java:648? Invocation of #compilesWithFix is very expensive, so perhaps it's worthwhile to drop -Xdoclint and certain other flags. (Such as -verbose; nobody's reading the output anyway.)
@Stephan202 Stephan202 mentioned this issue May 4, 2018
@Stephan202
Copy link
Contributor Author

A colleague of mine hit this issue again earlier this week. We were not (yet) successful in tracking down what actually causes the NPE. In PR #1020 the code is updated to no longer log the stacktrace you see above. I'd like to ask that instead/additionally the first suggestion above (the return false) is implemented. WDYT?

@ronshapiro ronshapiro mentioned this issue May 8, 2018
ronshapiro pushed a commit that referenced this issue May 8, 2018
"Fixes" #849

RELNOTES: N/A

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=195434516
ronshapiro pushed a commit that referenced this issue May 9, 2018
"Fixes" #849

RELNOTES: N/A

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=195434516
@Stephan202
Copy link
Contributor Author

Issue update: In PR #1023 the suggestion to return false was implemented. Thanks! Should I close this issue, or is it worthwhile to discuss the suggestion to prune compiler arguments?

NB: my colleague saw the issue go away by itself when he moved some Immutables interfaces to another package in another Maven module. We won't dig deeper into this, but I suspect the associated classpath change or the involvement of an annotation processor is relevant here.

@Stephan202
Copy link
Contributor Author

@cushon your fix in 9f94242 was modified in 02cebcd, such that non-IOExceptions such as the error shown above once again trigger a build failure. Was this intentional?

If you think the earlier suggestion to prune certain compiler arguments makes sense I can file a PR with a proposal.

(The NPE shown above still reproduces with AdoptOpenJDK 11.0.5+10. With a debugger I can see that it happens when doclint analyzes the class Javadoc of an Immutables-generated type derived from an interface nested in an abstract class; for this type JCClassDecl.sym is somehow null. When I try to recreate a similar situation using a small dummy class the issue does not reproduce. -XDcompilePolicy=simple vs. -XDcompilePolicy=byfile makes no difference. I can't seem to figure out which other aspects are relevant. 🤔 )

Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jan 12, 2020
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
@Stephan202
Copy link
Contributor Author

If you think the earlier suggestion to prune certain compiler arguments makes sense I can file a PR with a proposal.

Something like this: PicnicSupermarket/error-prone@ee33249, optionally optimized by placing the flags to be filtered in an ImmutableSet and testing for set membership.

Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue May 30, 2020
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jan 16, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jan 16, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
@Stephan202
Copy link
Contributor Author

An updated version of the above commit, compatible with Error Prone 2.5.1, can be found at PicnicSupermarket/error-prone@10bd828.

Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Apr 2, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue May 15, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue May 15, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jul 23, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 4, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 20, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Nov 13, 2021
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
@Stephan202
Copy link
Contributor Author

An updated version of the above commit, compatible with Error Prone 2.10.0, can be found at PicnicSupermarket/error-prone@0d7427a.

Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jan 26, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Apr 13, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Apr 13, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Apr 15, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Apr 16, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jun 5, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 4, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Oct 12, 2022
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue May 10, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jun 17, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jun 17, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 2, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 5, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Sep 22, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Oct 19, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Dec 21, 2023
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jan 3, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Feb 16, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Mar 11, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Mar 12, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Apr 26, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue May 1, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue May 31, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jul 17, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jul 17, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Jul 19, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 10, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 29, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 29, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 31, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 31, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Aug 31, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Sep 11, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Oct 1, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Oct 19, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Oct 26, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Oct 26, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Stephan202 added a commit to PicnicSupermarket/error-prone that referenced this issue Nov 19, 2024
Under certain circumstances this avoids triggering a compiler bug. It is
also expected to speed up the trial compilation somewhat. The implicit
assumption here is that it is okay to suggest a fix which introduces
another warning. (This may not be so in general, but the introduced
warning may be less severe or may be resolved manually.)

See google#849.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

1 participant