IssueTracker

As opposed to lintPublish? Or is that not relevant?

For me this is for local checks so I'm using lintChecks. Removing lintChecks from the library module and only applying it on the app module fixed the lint crash. However that's not optimal as I want to run the lint checks individually on the library module as well. It would not be interesting if this is really the cause of the issue or if it doesn't fix it for others.

I do not have any custom lint checks declared but there might be a transient lint check pulled in.

We have checkDependencies=true on our app module and apply there custom lint checks. Disabling custom lint checks has not solved the issue, though we have more custom lint checks via external dependencies (for example, timber).

#14, could you check with checkDependencies=false? It fixes problem on my project. Would be nice to hear more proves.

#15, I've set checkDependencies = false, but left our custom lint checks enabled. So far lint finished successfully without issue errors.

In my case, all builds of the >50 were a success after checkDependencies = false. However, disabling checkDependencies is not a solution as well. Since all our code is split in small logical modules, there is no point in lint. Too many false-positives and true-negatives.

I cherry-picked a change to 4.1 Beta 4 which essentially changes this error into a logged warning rather than a hard failure. That does not "fix" the problem, but it at least gets us back to the behavior of 3.6. Can someone confirm that this workaround has worked for them?

Also, I think I know what the root cause is (see notes below). However, it's hard to be sure without a repro scenario. Would anyone be willing to share an open-source project that reproduces this bug? (You can also send the project to gharrma@google.com if preferred.)

Notes:

• My current theory is that this bug is related to https://issuetracker.google.com/159733104#comment6.
  I.e., I think Lint should not be reusing the same Kotlin compiler environment to analyze multiple modules, which is what we do when checkDependencies=true.

• It is still strange that the failure is nondeterministic. However, one potential reason is that the Kotlin compiler caches many things via SoftReference.

Sorry for my long delay. I was tried with 4.1.0-beta05 (newest version to date), and the problem is still here. I added new log in case lines were changed.

Would anyone be willing to share an open-source project that reproduces this bug?

I have only closed source project with this problem. Maybe someone knows some quite large multimodule opensource project I could try setup AGP with lint and try reproduction?

I tried to reproduce with two small multimodule projects, but all builds works flawlessly. Also, I tried to reproduce using https://github.com/google/iosched, which is quite large. All builds success, just few lint errors found. In contrast, our failing project has 20 modules linted as checkDependencies, and 6 other helper modules. 145k CLOC without tests. I suppose there is a good chance problem happen due to the cache.

It is still strange that the failure is nondeterministic.

It is even non-deterministic in CI/docker builds using the same fresh environment and exactly the same code each time. Build cache and daemon is disabled there. Multithreading should be involved as well.

In addition, I found in most cases failed due to the same file #1. Just failure happens not all the time.

There are some architectural changes coming in Lint that will fix this properly, but they will not make it into 4.2.

However, there is another workaround you can try that will be available starting in AGP 4.2 Beta 4.

Essentially you can tell Lint to "reset" the Kotlin compiler between each module analysis, thereby clearing all caches. I did not make this the default behavior because the effect on performance is unknown/risky.

To enable this behavior, either set the environment variable LINT_DO_NOT_REUSE_UAST_ENV to "true", or set the JVM system property lint.do.not.reuse.uast.env to "true". For example, you can do this from the command line:

./gradlew -Dlint.do.not.reuse.uast.env=true :app:lintDebug

Or by putting this in your gradle.properties file:

systemProp.lint.do.not.reuse.uast.env=true

Status updates:

• I'm still hoping someone can confirm whether the workaround in comment#22 worked for them in AGP 4.2.

• Starting with AGP 7.0-alpha13 the root cause of this issue should be fixed completely due to the new "partial analysis" mode (enabled by default) in which Lint analyzes modules independently and merges results along the way. It fixes the issue because Lint will no longer use the same Kotlin compiler environment to analyze multiple modules (and so the risk of stale caches is gone).

I'm still hoping someone can confirm whether the workaround in comment#22 worked for them in AGP 4.2.

This unfortunately did not work for us. We actually see lint crashes after enabling via systemProp.lint.do.not.reuse.uast.env=true. See the attached log. It's also much slower, as expected.

AGP 4.2 seems to make this error much more frequent compared to 4.1, for some reason.

comment #24 The error message is very different --- it looks like a different issue to me.

Can you file a new bug? You can add a comment here linking to it.

Sure. Without that workaround, we get the same

ERROR: package fragment is not found for module:<lint-module> is a module[ModuleDescriptorImpl@5e5e6c61] file:KtFile: LiveViewerViewData.kt

error in this ticket occasionally (1-2% of the time?).

Oh, I misunderstood. So, using lint.do.not.reuse.uast.env is what causes the new crash? That is unfortunate, and I will investigate. Let me know if there is a sample project you can share that reproduces the issue.

Not sure if you still wanted the new bug, but here it is: https://issuetracker.google.com/issues/187851920

FYI the issue in comment #24 should be fixed by Change Ib7d4d6c9e in AGP 4.2.2.

And to confirm, lint.do.not.reuse.uast.env should no longer be needed at all in AGP 7.0+.

Thanks #29 . I am noticing that when this happens, after the error log for

package fragment is not found for module:<lintWithKotlin> is a module

There is another error

java.lang.IllegalArgumentException: Argument for @NotNull parameter 'descriptor' of org/jetbrains/kotlin/codegen/context/CodegenContext.intoPackagePart must not be null
	at org.jetbrains.kotlin.codegen.context.CodegenContext.$$$reportNull$$$0(CodegenContext.java)
	at org.jetbrains.kotlin.codegen.context.CodegenContext.intoPackagePart(CodegenContext.java)
	at org.jetbrains.kotlin.asJava.builder.LightClassDataProviderForClassOrObject$computeLightClassData$1$1.invoke(LightClassDataProvider.kt:51)
	at org.jetbrains.kotlin.asJava.builder.LightClassDataProviderForClassOrObject$computeLightClassData$1$1.invoke(LightClassDataProvider.kt:38)
	at org.jetbrains.kotlin.asJava.builder.LightClassBuilderKt.buildLightClass(LightClassBuilder.kt:64)
	at org.jetbrains.kotlin.asJava.builder.LightClassDataProviderForClassOrObject$computeLightClassData$1.invoke(LightClassDataProvider.kt:47)
	at org.jetbrains.kotlin.asJava.builder.LightClassDataProviderForClassOrObject$computeLightClassData$1.invoke(LightClassDataProvider.kt:38)
	at org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport.createDataHolderForClass(CliLightClassGenerationSupport.kt:64)
	at org.jetbrains.kotlin.asJava.builder.LightClassDataProviderForClassOrObject.computeLightClassData(LightClassDataProvider.kt:45)
	at org.jetbrains.kotlin.asJava.builder.LightClassDataProviderForClassOrObject.compute(LightClassDataProvider.kt:61)
	at com.intellij.psi.impl.PsiCachedValueImpl.doCompute(PsiCachedValueImpl.java:54)
	at com.intellij.util.CachedValueBase.lambda$getValueWithLock$1(CachedValueBase.java:235)
	at com.intellij.openapi.util.RecursionManager$1.doPreventingRecursion(RecursionManager.java:113)
	at com.intellij.openapi.util.RecursionManager.doPreventingRecursion(RecursionManager.java:72)
	at com.intellij.util.CachedValueBase.getValueWithLock(CachedValueBase.java:236)
	at com.intellij.psi.impl.PsiCachedValueImpl.getValue(PsiCachedValueImpl.java:43)
	at 

Does the fix address both of these?

comment #30 For those issues (package fragment is not found and Argument for @NotNull parameter...), the workaround in 4.2 is to put

systemProp.lint.do.not.reuse.uast.env=true

in your gradle.properties file as described in comment #22. Please let me know if it works or not for you.

Marking fixed in AGP 7.0.

That is, the lint.do.not.reuse.uast.env workaround should no longer be needed in AGP 7.0+. And, you should no longer see the following warnings/errors while running Lint:

ERROR: package fragment is not found for module:<lintWithKotlin>...

ERROR: Could not generate LightClass for...

java.lang.IllegalArgumentException: Argument for @NotNull parameter 'descriptor' of org/jetbrains/kotlin/codegen/context/CodegenContext.intoPackagePart must not be null

The issue is fixed due to the new "Lint partial analysis" mode (enabled by default) which creates a standalone UastEnvironment instance for each module, thereby avoiding stale caches in the Kotlin compiler frontend.

Please comment on the bug if you see any similar errors in AGP 7.0+.