Skip to content

ADFA-7138: Rewrite opted-in apps to requery and add the SQLite debugger to debug builds - #2262

Open
davidschachterADFA wants to merge 14 commits into
sqlite-debugger/ADFA-7135from
sqlite-debugger/ADFA-7138
Open

davidschachterADFA wants to merge 14 commits into
sqlite-debugger/ADFA-7135from
sqlite-debugger/ADFA-7138

Conversation

@davidschachterADFA

@davidschachterADFA davidschachterADFA commented Nov 16, 2026 •

Copy link
Copy Markdown
Collaborator

ADFA-7138

Code on the Go's Gradle plugin moves an opted-in app to requery at build time and adds the SQLite debugger to its debug builds. Opt-in: cogo.sqliteDebugger=true in the project's gradle.properties. Design, rules and known limits: gradle-plugin/docs/sqlite-rewrite.md.

Stack: on sqlite-debugger/ADFA-7135. It bundles the debugger AAR from its own tree, which needs ADFA-7137's broadcast, so merge it after ADFA-7137.

What it does

  • A class transform (AGP instrumentation, scope ALL, every variant) rewrites android.database.sqlite to requery: renames, String[] to Object[] descriptors, redirects to a small helper module (subprojects/sqlite-rewrite-runtime) for open flags, CancellationSignal, Context.openOrCreateDatabase/deleteDatabase and DatabaseUtils queries, and a build failure naming class, method and line for anything requery lacks (OpenParams, COLLATE UNICODE, casts to Android's cursor classes, ...). androidx's framework classes are rewritten too, so Room and WorkManager keep noBackupDirectory and allowDataLossOnRecovery.
  • The helper AAR (every variant) and the debugger AAR plus kotlin-stdlib (debuggable variants only) are bundled in Code on the Go's assets and passed to Gradle like logsender. A check task fails the build clearly when requery (from the project's libs/) or androidx.sqlite is missing.
  • Quick Build is off for opted-in projects; the IDE shows why (new string quick_build_disabled_sqlite_debugger).
  • scripts/check-release-apk-no-sqlite-debugger.sh checks that an APK carries no debugger.

Tests: rule tests on bytecode compiled from Java samples, run through a verifier and JVM linking against requery 3.49.0, android.jar and androidx; resolution of every member of the 10 renamed classes and of androidx.sqlite's framework classes; a real AGP build that transforms a local AAR and the injected helper; plugin TestKit tests (debuggable-only injection, missing AAR, missing requery, Quick Build off); the release-APK script on fake and real APKs. Reviewed by Sonnet, twice by Opus, and in a review across all tickets.

Verified on a device (Galaxy Note 20, Android 13, arm64-v8a and armeabi-v7a; an app built on the host with this plugin through its init script): SQLiteOpenHelper, Room with its default factory, WorkManager and Context.openOrCreateDatabase run on requery's SQLite 3.49.0 with no source change; WorkManager's work survives a force-stop; the debugger lists and queries all databases; the release build runs on requery and contains no debugger. Host build cost: about +4 s on a first debug build, nothing measurable cached.

Not verified: a project from the template built inside Code on the Go (needs the template line, dev-assets#79), build time on a phone, offline resolution of kotlin-stdlib on a device. The new Quick Build message is a string in an existing message, not checked at 2x font scale on a device. Open question on the ticket: the build-failure rule also applies to library classes.

Docs: CLAUDE.md and ARCHITECTURE.md list :subprojects:sqlite-rewrite-runtime as a module without ABI flavors.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Claude Code Review

This repository is configured for manual code reviews. Comment @claude review for a one-time review, or @claude review always to subscribe this PR to a review on every future push.

Tip: disable this comment in your organization's Code Review settings.

@davidschachterADFA davidschachterADFA left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Stack: this is the tip (layer 3) of #2244 -> #2259 (ADFA-7135, base) -> #2262. #2260 and #2261 sit on #2259 in a separate line; the description says to merge after #2260. Claims were checked at the stack tip, which is this head, 461fd39. No approvals exist on this PR.

Repo rules: REVIEW.md (coaching doc, no written approve/request-changes rule) and CLAUDE.md. The default verdict table applied. The author is the authenticated account, so the verdict is COMMENT.

MINOR

  • QuickBuildProjectSupport.kt:104 - the IDE pre-check reads only the root gradle.properties; Gradle's findProperty also sees other sources
  • SqliteRewritePlugin.kt:64 - withRuntimeConfiguration silently skips an unrecognised variant type, after the class rewrite is already registered

NITPICK - none

Previous rounds: no earlier review comments. Evidence ledger (REVIEW.md): ticket fit checked against the PR description and design doc; tests exist for the rewrite rules, plugin wiring, the Quick Build opt-in check and the release-APK script (not run, static review); no UI beyond one string, so font scale is untouched; threading: the gradle.properties read happens inside the existing suspend provisioner; security: no untrusted input beyond the project's own gradle.properties and the bundled AARs.

Considered and not posted: the COLLATE UNICODE / hard-failure rules also apply to library classes (already disclosed as an open question in the description); the app's own CancellationSignal listener is replaced by the helper (documented in Known limits and the javadoc); IDE debug builds now run sqlite-debugger's assembleRelease with the NDK (by design, the same shape as logsender). Not verified: AGP's behaviour when two plugins call setAsmFramesComputationMode (this plugin sets the default, COPY_FRAMES), anything at runtime or on a device. Static review only, nothing was built.

Verdict computed: COMMENT (only MINOR findings; and self-authored). Submitted as COMMENT.

}

/** [isSqliteDebuggerEnabled] for the `gradle.properties` in [projectRoot]; false when it cannot be read. */
fun isSqliteDebuggerEnabled(projectRoot: File): Boolean =

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

MINOR: the IDE decides the opt-in from the root gradle.properties only, but the Gradle plugin decides it with findProperty.

AndroidIDEGradlePlugin applies the rewrite when findProperty("cogo.sqliteDebugger") == "true". That also matches a gradle.properties in a module directory or in ~/.gradle. In those cases isSqliteDebuggerEnabled returns false, Quick Build is staged and built, and the plugin then refuses it and ends in the "variant setup missing" message that the new pre-check exists to avoid. It is MINOR because the only effect is that message (the documented opt-in, the root file, is handled), and an unreadable file also reads as "not opted in" without a log line.

Either document that the property belongs in the root gradle.properties, or log the read failure in the runCatching.

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 2c78e0a: the check reads the Gradle user home, then the app modules, then the root gradle.properties, as findProperty sees them (first file that defines it wins; only true opts in), and a read failure is logged. Tests cover each source, an override, and an unreadable file.

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

MINOR: partly fixed at 810fe1c. The check now reads the user home, the app modules and the root, but the module list can be empty exactly when a user taps Quick Build during sync.

GradleQuickBuildProvisioner.runProxyAppBuild calls projectManager.getAndroidAppModules() before awaitProjectModel. ProjectManagerImpl.getAndroidModules() returns an empty list while workspace is null, so during sync only the user home and the root file are read. A project whose cogo.sqliteDebugger=true is in an app module's own gradle.properties, with a Quick Build tap during sync, is staged and built, and the plugin then refuses it with the "variant setup missing" message this check exists to avoid. The code comment on awaitProjectModel says a tap during sync is common. Only a module-level opt-in is affected, hence MINOR.

Run the check after awaitProjectModel and before stage, or read the opt-in from the module directories found without the workspace.

variant.instrumentation.setAsmFramesComputationMode(SqliteRewriter.FRAMES_MODE)

val capitalized = variant.name.replaceFirstChar { it.uppercase() }
variant.withRuntimeConfiguration {

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

MINOR: the runtime-helper dependency and check<Variant>SqliteRewriteClasspath are registered only inside withRuntimeConfiguration, which does nothing for a variant that is neither ApplicationVariantImpl nor AnalyticsEnabledApplicationVariant.

For such a variant the class transform above is still registered and rewrites calls to SqliteRewriteRuntime, but the helper AAR is never added and the check never runs. The build succeeds and the first redirected call throws NoClassDefFoundError on the device. SqliteDebuggerPlugin has the same silent skip. It is MINOR because the helper (shared with LogSenderPlugin) covers both variant types AGP produces today, so no current build reaches it.

Make the helper throw or log a warning in the unmatched branch, so a future AGP wrapper fails the build instead of the app.

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in 4e4718f: the rewrite and debugger plugins now fail the build, naming the variant and its class, when its runtime configuration cannot be reached; logsender keeps its skip. Unit test with a stand-in variant.

davidschachterADFA and others added 10 commits November 15, 2026 23:22
… redirects to

The build-time rewrite (next commits) moves an app from android.database.sqlite
to requery, which lacks a few platform entry points: open flags,
CancellationSignal overloads, Context.openOrCreateDatabase and
deleteDatabase, and the DatabaseUtils query helpers. The rewritten
classes call static helpers for these instead.

The helpers are a Java-only module, so one AAR serves every ABI. Code on
the Go injects it into apps; it is not shipped in the template's libs/,
so it always matches the plugin's rules. The module is registered in
settings.gradle.kts and in AndroidModuleConf, which builds it as a
release AAR for the apps built with Code on the Go.

Tests: the pure helper functions run on the JVM in the gradle-plugin
tests (next commit).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
…ugin

Apps built in Code on the Go that opt in must run on requery's SQLite
(3.49.0) so the debugger can hook it. SqliteRewriter is an ASM class
visitor, applied by an AGP transform to the app's and its libraries'
classes:

- renames android.database.sqlite types to requery's, and String[]
  descriptors to Object[];
- redirects open flags, CancellationSignal, Context.openOrCreateDatabase
  and deleteDatabase, and the DatabaseUtils query helpers to
  sqlite-rewrite-runtime;
- fails the build, naming class, method and line, for APIs requery lacks:
  OpenParams, COLLATE UNICODE (requery has no ICU), casts to Android's
  cursor classes, method handles, unredirectable Context database calls;
- copies frames (COPY_FRAMES), inserting a String[] cast at the start of
  a method whose parameter is retyped to Object[] so its frames stay
  valid; memoizes hierarchy lookups; keeps the cursor taint at join
  points; looks up missing members through every renamed ancestor; adds
  OPEN_CREATE only to read-write opens.

androidx.core is exempt from the build-failure rule: its
SQLiteCursorCompat calls setFillWindowForwardOnly, which a real transform
run found missing.

FrameworkSQLiteOpenHelperFactory is not redirected to requery's factory,
which ignores noBackupDirectory and allowDataLossOnRecovery; WorkManager
sets both, so its database would be recreated empty on every start.
androidx's framework classes are rewritten instead and honour both
options.

Tests: SqliteRewriterTest and SqliteRewriteResolutionTest rewrite Java
samples and the real androidx.sqlite 2.6.2 framework classes and check
that every reference resolves in requery 3.49.0 (except
execPerConnectionSQL, which throws UnsupportedOperationException when
called; Room 2.8.4 and WorkManager 2.10.0 were surveyed with javap and
run on a device); BytecodeVerifier runs the JVM verifier over rewritten classes;
the runtime helper's pure functions run on the JVM. The tests fail on CI
when their jars are missing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
…he classpath

The rewrite is useful only when the helper AAR is on the app's classpath
and requery is present. Code on the Go bundles the helper in its assets
(release AAR, no v7/v8 flavors), extracts it at startup, and passes its
path to Gradle as -Pandroidide.sqliteRewriteRuntime.aar, always, like
logsender: the plugin reads it only for an opted-in project and then
names the missing file instead of a missing property.

SqliteRewritePlugin registers the class transform on every variant and
adds the helper to every variant's runtime classpath.
checkSqliteRewriteClasspath fails the build with a clear message when
requery or androidx.sqlite is missing from the app: requery comes from
the project's libs/, as in ADFA-7082, and the build says so.

withRuntimeConfiguration moves from LogSenderPlugin to a shared internal
function so the rewrite and the debugger plugins use the same one.
GradlePluginConfig names the opt-in property cogo.sqliteDebugger.

Tests: the plugin and the check task run in a real Gradle build with the
sample project, in the commit that applies the plugin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
…ed in

Code on the Go bundles the sqlite-debugger release AAR (one AAR carries
both ABIs), extracts it at startup and passes its path to Gradle as
-Pandroidide.sqliteDebugger.aar, like logsender. SqliteDebuggerPlugin
adds it and kotlin-stdlib to the runtime classpath of debuggable
variants only: it reads Variant.debuggable in onVariants. A release build
never carries the debugger.

Tests: SqliteDebuggerPluginTest, with the commit that applies the plugin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
cogo.sqliteDebugger=true in gradle.properties applies both plugins: the
rewrite moves the app to requery in every variant, and the debugger,
which needs requery, goes into the debuggable variants only. Without the
property neither is applied.

Tests: a dry run shows the class transform task for a project with the
property and none without; the rewrite plugin and the classpath check
task run in real Gradle builds with the sample project; a transform run
compiles an app and checks the rewritten classes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
…ted into the debugger

Quick Build ships edited classes as a separate payload, compiled by its
own daemon from the project's source, so it never passes through the
SQLite rewrite. Mixed with rewritten baseline classes it would hand
android.database.sqlite objects to requery ones.

- AndroidIDEGradlePlugin does not apply Quick Build to an opted-in
  project and logs why.
- GradleQuickBuildProvisioner refuses before staging, which writes into
  the project, and the IDE shows a string saying why, instead of ending
  in "variant setup missing".
- ComponentProxiabilityResolver keeps DebuggerStartup in its by-name list
  as a guard only.

Tests: SqliteDebuggerPluginTest checks which variants get the debugger AAR, with the property absent and set, and that Quick Build is not applied;
QuickBuildProjectSupport decides the opt-in from gradle.properties as
the Gradle plugin does (root file read, missing file is no opt-in); the
provisioner refuses before staging with its own message.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
scripts/check-release-apk-no-sqlite-debugger.sh fails when an APK holds
libsqlitedbg.so, the DebuggerStartup provider, the <queries> entry for
Code on the Go, or the debugger's class prefix in any dex, so a release
build can be checked by script (acceptance criteria 2 and 3). INTERNET is
only a warning line: the app may declare it for itself. It runs with
pipefail and reads the APK with unzip and aapt2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
gradle-plugin/docs/sqlite-rewrite.md explains the rewrite: what it
renames and redirects, what it rejects, the Spike 0 survey result, the
helper and debugger AAR wiring, the Quick Build exclusion and the APK
check. The sqlite-debugger README, CLAUDE.md and ARCHITECTURE.md list the
new module and point to it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
…perty sees

The plugin decides the opt-in with findProperty, which sees the Gradle user home and the app
module gradle.properties as well as the root one. The IDE read only the root file, so such a project
was staged and then refused with the misleading variant-setup message, and a read failure counted
as not opted in without a log line. The check now reads user home, app module and root (first
defining one wins) and logs a read failure. Tests: opt-in in root, in user home, in the module,
false overriding true, and an unreadable file reported and treated as not set.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
… reached

SqliteRewritePlugin registers the class rewrite before it adds the helper AAR and the classpath
check, and withRuntimeConfiguration silently skipped a variant type it did not know, so the app
would build and throw NoClassDefFoundError on the device. The two SQLite plugins now use
requireRuntimeConfiguration, which throws naming the variant and its class; LogSender keeps the
skipping helper. Test: a stand-in variant (TestKit cannot produce an unknown variant type) makes
the decision function throw, while withRuntimeConfiguration still skips it.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
davidschachterADFA and others added 4 commits November 16, 2026 10:05
No conflicts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
Adds a how-to for existing projects to the debugger's README (ADFA-7138,
item 5): the gradle.properties line, requery's AAR in libs/, the androidx
libraries requery needs, and what to expect in a debug build. It says what
the line changes (every variant moves to requery, Quick Build is off), that
commenting it out turns it off, and that Room's BundledSQLiteDriver is not
covered. The details stay in gradle-plugin/docs/sqlite-rewrite.md, which it
links to.

The template line itself is in dev-assets, on sqlite-debugger/ADFA-7138,
stacked on dev-assets#79.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn
The rewrite fails the build on a class that uses something requery lacks,
naming class, method and line. For the app's own code that is enough; for
a library class the user cannot change, the message gave no way out. It
now ends with one: comment out cogo.sqliteDebugger=true in
gradle.properties to build without the SQLite debugger. The transform
cannot tell an app class from a library class, so the line covers both.

The fail rule itself stays (decided 2026-11-16): the rewrite runs in
release builds too, so a warning would let a released app ship a call
that crashes when it runs.

The new test fails without the change (its "in a library" check); the
rewrite tests pass with it. The rewrite doc and the debugger README say
the message now carries the way out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vh2DAYT7GPoC2cDzo8LErn

@davidschachterADFA davidschachterADFA left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Re-review of #2262 at 810fe1c (medium effort). Verdict computed: COMMENT (MINOR findings only; GitHub also refuses APPROVE/REQUEST_CHANGES on a self-authored PR). Nothing here blocks merge.

MINOR

  • GradleQuickBuildProvisioner.kt:350 - the Quick Build opt-in check still misses a module-level gradle.properties when the tap comes during sync (reply in the existing thread on QuickBuildProjectSupport.kt:104, not a new thread)
  • CheckSqliteRewriteClasspathTask.kt:61 - the classpath guard does not check androidx.core, which the docs say the rewrite needs
  • SqliteRewriteRules.kt:94 - no() stores {""} where the KDoc and decide() expect an empty set

NITPICK - none

Stack. Layer 2 of 4, a tip: below #2259 (sqlite-debugger/ADFA-7135, on #2244). Siblings on #2259: #2260 (ADFA-7137) and, on it, #2261 (ADFA-7139), the other tip (2007193). #2260 and #2261 do not touch this layer's files except the debugger README, so claims were checked at this head. Nothing was dropped as fixed higher up.

Rules applied. REVIEW.md and CLAUDE.md at the head. REVIEW.md is "a coaching doc, not a gate" with no approve/request-changes rule, so the skill's default table applied.

Prior threads (judged on the code at this head, not on the replies).

  • QuickBuildProjectSupport.kt:104 opt-in read from the root file only: partly fixed. isSqliteDebuggerEnabled(projectRoot, gradleUserHome, moduleDirs) now reads the user home, the app modules and the root, first definition wins, and logs a read failure. But the module list comes from getAndroidAppModules(), which is empty until the Gradle sync has built the workspace, and the provisioner calls it before awaitProjectModel. Reply posted in that thread.
  • SqliteRewritePlugin.kt:64 silent skip for an unrecognized variant: fixed. requireRuntimeConfiguration throws a GradleException naming the variant and its class; SqliteRewritePlugin and SqliteDebuggerPlugin use it, and LogSender keeps its skip. A stand-in-variant test covers it.

Merges and new commits. 3605133 (#2244 through #2259, no conflicts) and 810fe1c (#2259's README corrections) are clean. 627aa94 (README "Turning it on in an app"): the two links resolve (sqlite-rewrite.md#turning-it-on and #rules are headings there), and its steps agree with the rewrite doc (the one-line opt-in, requery's AAR in libs/, androidx.sqlite and androidx.core, Quick Build off, release builds rewritten but without the debugger). I could not check that the template's app/libs/sqlite-android.aar exists: it is in dev-assets. 2394a80 (failure message and test): the message now ends with a one-line way out, the test asserts that last line, and the README and rewrite doc say so. The way out names gradle.properties, which is right for the documented opt-in.

Static review only: no build, no device. Leads from the built-in review that I discarded: two app modules with different values (the IDE builds one module, and the plugin decides per project), a replaced CancellationSignal listener (stated in the helper's Javadoc, and Android's signal holds one listener), the double lifecycle message and the rule living on both sides (noise, not a defect), the repeated ZipFile opens (performance only), and the reflective Component.getDebuggable lookup: I cannot verify which AGP type declares it without a build, and the fallback path exists, so this is not verified either way.

private val REQUIRED =
listOf(
"requery's SQLiteDatabase ($REQUERY_ENTRY)" to REQUERY_ENTRY,
"androidx.sqlite's SupportSQLiteDatabase ($ANDROIDX_SQLITE_ENTRY)" to ANDROIDX_SQLITE_ENTRY,

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

MINOR: the guard checks requery and androidx.sqlite but not androidx.core, which the rewrite and requery also need.

SqliteRewriteRuntime.toCancellationSignal returns androidx.core.os.CancellationSignal, and sqlite-rewrite-runtime declares androidx.core compileOnly. The rewrite doc (step 3) and the new README say requery needs androidx.core too, and a file dependency brings neither. An app with androidx.sqlite but no androidx.core passes this task, and the first rawQuery(..., cancellationSignal) throws NoClassDefFoundError on the device, which is what this task exists to prevent. Unreachable today for the template and for any app with AppCompat, Room or WorkManager, which all bring androidx.core.

Add an androidx/core/os/CancellationSignal.class entry to REQUIRED, and name androidx.core in message.

fun no(
owner: String,
name: String,
desc: String = "",

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

MINOR: no() defaults desc to "", so a member listed without a descriptor is stored as {""}, not as the empty set the KDoc promises for "every descriptor".

SqliteRewriter.decide tests it.isEmpty() || desc in it and fieldProblem tests "" in descs || desc in descs. A method entry added with the default would never match in decide (its real descriptor is not ""), so the unsupported call would pass the rewrite and fail with NoSuchMethodError on the device. Unreachable today: every current entry passes an explicit descriptor.

Make the default produce the empty set (skip the add when desc is empty), or test "" in it in decide as fieldProblem does.

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

Successfully merging this pull request may close these issues.

1 participant