IssueTracker

I can reproduce this (thanks for the repro project!)

It looks like the problem is that the desugared api list from r8 contains this entry:

java/util/Collection#removeIf(Ljava/util/function/Predicate;)Z

but the bytecode here doesn't match -- it's java/util/ArrayList. Collection isn't a directly implemented interface or a direct super class, it's an interface on the super super class. The most efficient thing runtime wise would be for the signature list to inline this method on all implemented subclasses. But I should probably at least for now go and make the desugared API lookup do something similar to what it does for API lookup -- search through all super classes and interfaces as well. This isn't a new problem, so I'm very surprised this hasn't come up before (or it has, and I've forgotten).

(I have a pending CL that was working to improve the handling of fields now that r8 handles desugaring fields, I'll try to dust that off and combine the fix in there.)

I went to implement this, and hooked up inheritance search when analyzing the source file containing the call.

However, lint also handles the case where the library being analyzed is not using core library desugaring (for example, it may be a plain Java library). But when that library is consumed in a downstream app module, where library desugaring is turned on, lint then processes the partial results from the library and filters each violation through the desugaring allowlist.

At this point, it's tricky to do the inheritance search -- this happens when we no longer have a compilation environment and can do class inheritance lookups. So there are three possible solutions.

First, we pay the cost up front -- even when you're not using core library desugaring, we record whether the method is potentially library desugared if turned on. (This is also tricky because at this point we don't know which exact desugaring library version is used, which determines the exact list of APIs).

Or, more expensively, for every API violation of this type we store all the potential super class and interface names for each result...

Or, we handle this in the code which generates the desugaring API list, inlining all subclasses affected. This could be quite a long list, but on the other hand this list is really only intended to be machine readable.

This is partially fixed now; it's fully fixed for the sample project, but in the scenario I described in comment 4, it works if you also configure library desugaring to be on in the library.

likely related:

Objects.requireNonNullElse
Objects.requireNonNullElseGet

are now also showing this same false positive warning.

Android Studio Koala | 2023.3.2 Canary 2 gradle 8.6 plugin: 8.3.1

This seems unrelated. Can you file a new bug?

Specifically, for Objects.requireNonNullElse I am not seeing a lint API error, but I am seeing a warning from IntelliJ's built-in Java inspections. These should probably not show up in Android modules. I swear we've fixed that before but I'm assuming something changed to break that.

For Objects.requireNonNullElseGet I do see a lint API warning for that. But, that's not a recent change, right? I looked at R8's desugaring list and that method is not there. So that method does crash at runtime, right?

Can you file a new bug?

fair enough - will do.

I swear we've fixed that before but I'm assuming something changed to break that.

I'm not 100% sure whether it first occurred when I moved to 8.3.1, and/or to Koala Canary 2

So that method does crash at runtime, right?

funnily enough no, even when I run on Android 8.0 (in the emulator); In fact I seem to have been using that method for 2 years now and the first of those 2 years I ran it personally on a physical device (Samsung A5 2017 with Android 8.0 / other users on?) ... and yes, I am flabbergasted as well :)

I'll try and dig a little regarding the requireNonNullElseGet first as indeed I realise it should crash, and then will file a new bug (as requireNonNullElse should work regardless)

I'll add a reference here for your enjoyment :)

Actually it looks like D8 is really backporting it; I wrote this test class:

public class JavaTest {
    public void test(String s) {
        Objects.requireNonNullElse(s, "test");
        Objects.requireNonNullElseGet(s, new Supplier<String>() {
            @Override
            public String get() {
                return null;
            }
        });
    }
}

Built the APK and opened the APK analyzer, drilled to this method and invoked Show Bytecode and here's what I get:

# virtual methods
.method public test(Ljava/lang/String;)V
    .registers 3
    .param p1, "s"    # Ljava/lang/String;

    .line 8
    const-string v0, "test"

    invoke-static {p1, v0}, Lcom/example/myapplication/JavaTest$$ExternalSyntheticBackport0;->m(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

    .line 9
    new-instance v0, Lcom/example/myapplication/JavaTest$1;

    invoke-direct {v0, p0}, Lcom/example/myapplication/JavaTest$1;-><init>(Lcom/example/myapplication/JavaTest;)V

    invoke-static {p1, v0}, Lcom/example/myapplication/JavaTest$$ExternalSyntheticBackport1;->m(Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;

    .line 15
    return-void
.end method

So both methods are desugared.

Clement/Søren, I don't see this in the backport list:

$ java -cp $ANDROID_HOME/cmdline-tools/latest/lib/r8.jar com.android.tools.r8.BackportedMethodList --min-api 15  | grep requireNonNullElse
java/util/Objects#requireNonNullElse(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

(requireNonNullElse is there, requireNonNullElseGet is not.)

aha - so requireNonNullElseGet is not magical after all :)

Please let me know if I should still file a new bug.

tx

The method Objects.requireNonNullElseGet is a bit special in terms of backporting, as it takes an argument of type Supplier, which was added in API level 24. For pure backporting (no desugared library) this method can only be backported from API level 24:

$ java -cp $ANDROID_HOME/cmdline-tools/latest/lib/r8.jar com.android.tools.r8.BackportedMethodList --min-api 24  | grep requireNonNullElse
java/util/Objects#requireNonNullElse(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
java/util/Objects#requireNonNullElseGet(Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;

Setting minSdk below 24 (without using desugared library) this is the DEX for the test code.

.method public test(Ljava/lang/String;)V
    .locals 1
    .param p1, "s"    # Ljava/lang/String;

    .line 8
    const-string v0, "test"

    invoke-static {p1, v0}, Ldk/gjesse/jdk11desugaredlibrary/ObjectsTest$$ExternalSyntheticBackport0;->m(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

    .line 9
    new-instance v0, Ldk/gjesse/jdk11desugaredlibrary/ObjectsTest$1;

    invoke-direct {v0, p0}, Ldk/gjesse/jdk11desugaredlibrary/ObjectsTest$1;-><init>(Ldk/gjesse/jdk11desugaredlibrary/ObjectsTest;)V

    invoke-static {p1, v0}, Ljava/util/Objects;->requireNonNullElseGet(Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;

    .line 15
    return-void
.end method

with only Objects.requireNonNullElse getting backported.

With desugared library enabled this change, due to two things

1. desugared library adds support for Supplier
2. Objects is no longer backported, but implemented by desugared library

The "tool" com.android.tools.r8.ir.desugar.desugaredlibrary.lint.DesugaredMethodsList is used for desugared library:

java -cp $ANDROID_HOME/cmdline-tools/latest/lib/r8.jar com.android.tools.r8.ir.desugar.desugaredlibrary.lint.DesugaredMethodsList --min-api 15 --desugared-lib META-INF/desugar/d8/desugar.json --lib $ANDROID_HOME/platforms/android-34/android.jar --desugared-lib-jar desugar_jdk_libs-2.0.4.jar | grep Objects
java/util/Objects

(META-INF/desugar/d8/desugar.json is from https://maven.google.com/web/index.html?q=desu#com.android.tools:desugar_jdk_libs_configuration:2.0.4 and desugar_jdk_libs-2.0.4.jar is https://maven.google.com/web/index.html?q=desu#com.android.tools:desugar_jdk_libs:2.0.4).

The line java/util/Objects indicate that all methods of Objects are supported.

With desugared library (for any minSdk) this is the DEX for the test code:

# virtual methods
.method public test(Ljava/lang/String;)V
    .locals 1
    .param p1, "s"    # Ljava/lang/String;

    .line 8
    const-string v0, "test"

    invoke-static {p1, v0}, Lj$/util/Objects;->requireNonNullElse(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

    .line 9
    new-instance v0, Ldk/gjesse/jdk11desugaredlibrary/ObjectsTest$1;

    invoke-direct {v0, p0}, Ldk/gjesse/jdk11desugaredlibrary/ObjectsTest$1;-><init>(Ldk/gjesse/jdk11desugaredlibrary/ObjectsTest;)V

    invoke-static {p1, v0}, Lj$/util/Objects;->requireNonNullElseGet(Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;

    .line 15
    return-void
.end method

Thanks for that explanation Søren.

So, when I tried this with the latest Koala canary, it looks like things are working correctly. For the following code:

Objects.requireNonNullElse
Objects.requireNonNullElseGet

Both AGP and Studio correctly will not flag the first call.

The second call is flagged as an API error. But if I turn on core library desugaring, then that warning also goes away, both in AGP and in Studio.

There is still the issue of the builtin Java 9 APIs inspection in IntelliJ -- again, not a lint bug, but it is a Studio bug. Original submitter, can you file that one? And can you confirm (if you're not seeing warnings for these) that you are in fact using library desugaring and a recent Studio?

I've filed b/331857025 for the other issue. I'm going to close this as working unless I hear back that the above scenario is in fact still causing Android lint warnings (not the "Usage of API documented as @since 9+" warning from IntelliJ) when core library desugaring is turned on.

thanks for filing the bug!

using library desugaring and a recent Studio?

yes I am, I have desugaring in all modules + using Koala Canary 2 now.

I will have to switch back to Jelly fish anyhow due to Koala being (to put it mildly) a runaway memory and cpu lover... which makes it nearly unusable (but that's another issue) so I might not be able to follow up on the new bug in the short term.

On studio-main I can still repro the following false positive from https://issuetracker.google.com/331857025#comment16:

1. Create a new project
2. Enable desugaring, run Gradle sync
3. Add a usage of java.util.Objects#requireNonNullElse

Lint warning:

Call requires API level 30 (current min is 26): java.util.Objects#requireNonNullElse

Just tested this with Koala.1 Beta 1, and something seems to not be right with lint (see results below). Not exactly sure where the integration is not working.

Using the test from comment #9 (repro project git clone sso://user/sgjesse/B327670482) and and looking at the lint messages in the IDE I get:

The expected messages should be:

Looking at the DEX after compiling the code it is desugared as expected:

Running the command line version of the D8 lint info generation tool the output looks correct.

As far as I can see the BackportedMethodList D8 tool generated the correct desugared methods:

minApi 21 no library desugaring:

java -cp build/libs/r8.jar com.android.tools.r8.BackportedMethodList --min-api 21 --lib third_party/android_jar/lib-v34/android.jar | grep Objects

java/util/Objects#checkFromIndexSize(III)I
java/util/Objects#checkFromIndexSize(JJJ)J
java/util/Objects#checkFromToIndex(III)I
java/util/Objects#checkFromToIndex(JJJ)J
java/util/Objects#checkIndex(II)I
java/util/Objects#checkIndex(JJ)J
java/util/Objects#isNull(Ljava/lang/Object;)Z
java/util/Objects#nonNull(Ljava/lang/Object;)Z
java/util/Objects#requireNonNullElse(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

requireNonNullElse is desugared.

minApi 24 no library desugaring:

java -cp build/libs/r8.jar com.android.tools.r8.BackportedMethodList --min-api 24 --lib third_party/android_jar/lib-v34/android.jar | grep Objects

java/util/Objects#checkFromIndexSize(III)I
java/util/Objects#checkFromIndexSize(JJJ)J
java/util/Objects#checkFromToIndex(III)I
java/util/Objects#checkFromToIndex(JJJ)J
java/util/Objects#checkIndex(II)I
java/util/Objects#checkIndex(JJ)J
java/util/Objects#requireNonNullElse(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
java/util/Objects#requireNonNullElseGet(Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;

requireNonNullElse and requireNonNullElseGet are desugared.

minApi 21 with library desugaring:

java -cp build/libs/r8.jar com.android.tools.r8.BackportedMethodList --min-api 21 --lib third_party/android_jar/lib-v34/android.jar --desugared-lib src/library_desugar/jdk11/desugar_jdk_libs.json | grep Objects

java/util/Objects#checkFromIndexSize(JJJ)J
java/util/Objects#checkFromToIndex(JJJ)J
java/util/Objects#checkIndex(JJ)J```

Neither requireNonNullElse nor requireNonNullElseGet is mentioned, but META-INF/desugar/d8/lint/compile_api_level_30/desugared_apis_30_1.txt from the desugared library configuration artifact contains:

java/util/Objects

So all of Objects is desugared.

We need to track down where the information is lost.

Shouldn't this be a P1 and Koala.1 RC blocker?

not as far as I'm concerned - this is a warning only which I can just ignore. The app compiles and works perfectly fine.

Methinks you guys have more important P1's to fix. If you need inspiration, then look at #127100532 (not related to this one at all, I'm just being ... now)

I think I found the problem.

Here's the desugaring files used in the IDE:

modelArtifact?.desugaredMethodsFiles = {ArrayList@83951}  size = 2
 0 = {File@84956} "/Users/tnorbye/.gradle/caches/transforms-4/5126fdfcbb5a995f09b8be45eb610aef/transformed/desugar_jdk_libs_configuration_nio-2.0.4-desugar-lint.txt"
 1 = {File@84957} "/Users/tnorbye/.gradle/caches/transforms-4/fc5ceb7b5de2ee8487ba96f4a79c6608/transformed/D8BackportedDesugaredMethods.txt"

What we do with these files is to "merge" them. This was just reading all the signatures from both files and sorting them. When lint is checking methods it just does a binary search.

But in this case, we're getting these methods from the d8 backport list:

java/util/Objects#checkFromIndexSize(JJJ)J
java/util/Objects#checkFromToIndex(JJJ)J
java/util/Objects#checkIndex(JJ)J

And we're getting this method from the library desugaring list:

java/util/Objects

This means that we end up with this in the signature list:

java/util/Objects
java/util/Objects#checkFromIndexSize(JJJ)J
java/util/Objects#checkFromToIndex(JJJ)J
java/util/Objects#checkIndex(JJ)J

This is wrong; the first line implies that all the other three are included. But in a binary search, if our midpoint hits one of the specific methods, we'll conclude that the match must be later in the list, so we'll falsely decide the method isn't there.

I need to fix the merging of signature files to not just concatenate but to drop specific methods and fields if the other file lists the whole class.

I don't think this is a recent regression, but I think this is showing up now through a combination of the desugaring files including newly fully backported classes, and there's luck involved based on how binary search proceeds.

So I see two bugs listed in your table in comment #16: (1) With core library desugaring on, we incorrectly flag both requireNonNullElse and requireNonNullElseGet. I've uploaded a fix for that (ag/27323706). (2) With core library desugaring off, and minSdkVersion 24, lint flags requireNonNullElseGet.

For the second one, I see that lint is passed this single database file: /Users/tnorbye/.gradle/caches/transforms-4/6cf6a445b18927988f27d9e2411efbbe/transformed/D8BackportedDesugaredMethods.txt

And that file does not contain requireNonNullElseGet:

$ grep Objects /Users/tnorbye/.gradle/caches/transforms-4/6cf6a445b18927988f27d9e2411efbbe/transformed/D8BackportedDesugaredMethods.txt | grep requireNon
java/util/Objects#requireNonNull(Ljava/lang/Object;)Ljava/lang/Object;
java/util/Objects#requireNonNull(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
java/util/Objects#requireNonNullElse(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

Is this a problem in AGP/sync? cc: Scott

Found the issue in AGP for the second bug. When calling D8DesugaredMethodsGenerator.generate the minSdk is not passed, so it defaults to 1. Therefore changing from 21 to 24 does not make a difference (except for the red squiggles under Supplier goes away). When building the BackportedMethodListCommand an additional call to setMinApiLevel on the builder with the actual minSdk is missing here.

Running the command line version of the tool without --min-api gives exactly the list in comment #20.

java -cp build/libs/r8.jar com.android.tools.r8.BackportedMethodList --lib third_party/android_jar/lib-v34/android.jar | grep Objects | grep requireNon

java/util/Objects#requireNonNull(Ljava/lang/Object;)Ljava/lang/Object;
java/util/Objects#requireNonNull(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
java/util/Objects#requireNonNullElse(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

Ok, I already fixed the lint desugared-file-merging thing yesterday (https://cs.android.com/android-studio/platform/tools/base/+/4d7d46888f3e7d5c7730124ed05001c08beaf201). Over to Scott for the AGP issue.

Bingran, can you take this one?

From #21:

When building the BackportedMethodListCommand an additional call to setMinApiLevel on the builder with the actual minSdk is missing here.

(2) With core library desugaring off, and minSdkVersion 24, lint flags requireNonNullElseGet

Fixed with Ib00094d61dbc26ff49928855ebe8dcdedf5ecf48

Close the ticket based on comment #20 as the other issue has been fixed with ag/27323706

Thank you for your patience while our engineering team worked to resolve this issue. A fix for this issue is now available in:

• Android Studio Koala Feature Drop | 2024.1.2 Canary 6
• Android Gradle Plugin 8.6.0-alpha06

We encourage you to try the latest update.

If you notice further issues or have questions, please file a new bug report.

Thank you for taking the time to submit feedback — we really appreciate it!

glad to confirm this is now working fine :)

Even with Plugin 8.5.0

For anyone else happening on this issue, what you need to do is translate a URL like ionic://something into a literal __ionic_url__/something in the allowed referrers.

This seems to work for any custom scheme, not just ionic. The __whatever_url__ syntax translates to the referrer whatever:// -- I'm guessing because putting whatever:// gets filtered out somewhere in Google's systems as an invalid scheme so the __whatever_url__ syntax is a hacky work-around.

Google's documentation at https://developers.google.com/maps/documentation/javascript/get-api-key#restrict_key talks about using __file_url__ for file:// URLs, but does not make it clear this is a general-purpose mechanism that seems to work for other custom schemes as well.

The "RefererNotAllowedMapError" error suggests that "Application restrictions" is enabled in your Google Maps JavaScript API key settings with "HTTP referrers (web sites)" option. I know this is an old question that already has several answers, but I had this same problem and for me the issue was that I followed the example provided on console.developers.google.com and entered my domains in the format .domain.tld/. This didn't work at all, and I tried adding all kinds of variations to this like domain.tld, domain.tld/*, *.domain.tld etc.

What solved it for me was adding the actual protocol too; http://domain.tld/* is the only one I need for it to work on my site. I guess I'll need to add https://domain.tld/* if I were to switch to HTTPS.

Currently is working with httpsionic:// scheme.

Example: httpsionic://app