mirror of
https://github.com/morluto/rea.git
synced 2026-11-18 20:53:00 +00:00
fix(android): report method disassembly failure as unavailable body (#12090)
* fix(android): report method disassembly failure as unavailable body Catch JADX bridge get_method_body failures in inspectMethod and project as an unavailable body with disassembly_failed marker, avoiding generic execution_failure with irrelevant rea doctor remediation. Fixes #10482 * fix(android): preserve method identity when disassembly is unavailable * fix(android): retain method identity when smali generation fails --------- Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
This commit is contained in:
1 parent
486470ec9b
commit
dc6799d488
10 files changed
+251
-65
No files matched your search
@@ -713,10 +713,19 @@ class ReaJadxBridge {
|
||||
TextUtilKt.truncateToBytes(block, current.getMaxSourceBytes()), "smali", true, markers);
|
||||
}
|
||||
|
||||
private static final class MethodDisassemblyUnavailable extends IllegalArgumentException {
|
||||
MethodDisassemblyUnavailable(String message) { super(message); }
|
||||
}
|
||||
|
||||
private static String selectMethodSmali(JadxSession.MethodSmali smali, String shortId) {
|
||||
if (!smali.getFound())
|
||||
throw new IllegalArgumentException("JADX could not disassemble " + shortId
|
||||
+ (smali.getNote() == null ? "" : ": " + smali.getNote()));
|
||||
if (!smali.getFound()) {
|
||||
String reason = "JADX could not disassemble " + shortId
|
||||
+ (smali.getNote() == null ? "" : ": " + smali.getNote());
|
||||
// JADX folds caller interruption into the same result as failed generation
|
||||
// and missing blocks, but leaves the interrupt flag set.
|
||||
if (Thread.currentThread().isInterrupted()) throw new IllegalArgumentException(reason);
|
||||
throw new MethodDisassemblyUnavailable(reason);
|
||||
}
|
||||
// Upstream returns every same-name overload, and can return an unterminated
|
||||
// trailing block. Match the full original identity before applying output limits.
|
||||
List<String> matches = smali.getBlocks().stream().filter(block -> {
|
||||
@@ -724,10 +733,10 @@ class ReaJadxBridge {
|
||||
return header.startsWith(".method ") && header.endsWith(" " + shortId);
|
||||
}).toList();
|
||||
if (matches.size() != 1)
|
||||
throw new IllegalArgumentException("Disassembly could not establish one selected method: " + shortId);
|
||||
throw new MethodDisassemblyUnavailable("Disassembly could not establish one selected method: " + shortId);
|
||||
String block = matches.get(0);
|
||||
if (!block.stripTrailing().endsWith("\n.end method"))
|
||||
throw new IllegalArgumentException("Selected method disassembly is incomplete: " + shortId);
|
||||
throw new MethodDisassemblyUnavailable("Selected method disassembly is incomplete: " + shortId);
|
||||
return block;
|
||||
}
|
||||
|
||||
@@ -1003,14 +1012,22 @@ class ReaJadxBridge {
|
||||
List<MethodSnapshot> overloads = methods(cls, args);
|
||||
int index = integer(args, "overload_index", 0);
|
||||
if (index >= overloads.size()) throw new InputFailure("overload_index", "overload_index out of range: " + index);
|
||||
JavaMethod method = method(cls, overloads.get(index));
|
||||
JadxSession.SmartCode code = methodBody(current, cls, overloads.get(index), method);
|
||||
return json(Map.of("class_name", cls.summary().get("full_name"),
|
||||
"method_name", overloads.get(index).name(), "full_name", method.getFullName(),
|
||||
"dex_descriptor", overloads.get(index).summary().get("dex_descriptor"),
|
||||
"overload_index", index, "overload_count", overloads.size(),
|
||||
"mode", code.getKind(), "fell_back", code.getFellBack(),
|
||||
"markers", code.getMarkers(), "body", code.getText()));
|
||||
MethodSnapshot selected = overloads.get(index);
|
||||
JavaMethod method = method(cls, selected);
|
||||
Map<String, Object> result = new LinkedHashMap<>(Map.of(
|
||||
"class_name", cls.summary().get("full_name"),
|
||||
"method_name", selected.name(), "full_name", method.getFullName(),
|
||||
"dex_descriptor", selected.summary().get("dex_descriptor"),
|
||||
"overload_index", index, "overload_count", overloads.size()));
|
||||
try {
|
||||
JadxSession.SmartCode code = methodBody(current, cls, selected, method);
|
||||
result.putAll(Map.of("mode", code.getKind(), "fell_back", code.getFellBack(),
|
||||
"markers", code.getMarkers(), "body", code.getText()));
|
||||
} catch (MethodDisassemblyUnavailable failure) {
|
||||
result.put("mode", "unavailable");
|
||||
result.put("body_unavailable_reason", failure.getMessage());
|
||||
}
|
||||
return json(result);
|
||||
}
|
||||
List<JavaNode> uses;
|
||||
String target = (String) cls.summary().get("full_name");
|
||||
|
||||
@@ -307,8 +307,9 @@ overload even when Java code generation renames a method. If the selected Java
|
||||
body was omitted, including a method merged into a synthetic bridge, REA returns
|
||||
its original smali with the `java_body_unavailable` marker. The marker describes
|
||||
missing Java; it does not infer why the method was omitted or name a replacement.
|
||||
Unresolved or duplicate disassembly identities fail instead of attributing another
|
||||
method's instructions to the selection.
|
||||
If disassembly cannot establish one complete block for the selected method, the
|
||||
result keeps that method's identity and reports `body_status: "not_available"`
|
||||
with a `body_unavailable_reason`. Both `representation` and `source` are null.
|
||||
|
||||
Native and abstract methods are identified from access flags
|
||||
captured before code generation. They report `body_status: "not_available"`, an
|
||||
|
||||
@@ -437,11 +437,22 @@ const inspectMethod = async (
|
||||
class_name: summary.full_name,
|
||||
method: selected,
|
||||
overload_count: candidates.length,
|
||||
representation: body.mode,
|
||||
body_status: body.body.length === 0 ? "not_available" : "available",
|
||||
fell_back: body.fell_back,
|
||||
markers: body.markers,
|
||||
source: normalizeJadxText(body.body),
|
||||
...(body.mode === "unavailable"
|
||||
? {
|
||||
representation: null,
|
||||
body_status: "not_available",
|
||||
body_unavailable_reason: body.body_unavailable_reason,
|
||||
fell_back: false,
|
||||
markers: ["disassembly_failed"],
|
||||
source: null,
|
||||
}
|
||||
: {
|
||||
representation: body.mode,
|
||||
body_status: body.body.length === 0 ? "not_available" : "available",
|
||||
fell_back: body.fell_back,
|
||||
markers: body.markers,
|
||||
source: normalizeJadxText(body.body),
|
||||
}),
|
||||
...mappingOf(mapping, () => [
|
||||
classQuery(summary),
|
||||
...methodQueries(summary).filter(
|
||||
|
||||
@@ -139,18 +139,28 @@ export const jadxExternalReferenceSummarySchema = z.object({
|
||||
observed_method_count: count,
|
||||
prototypes: z.array(jadxMethodMetadataSchema).min(1),
|
||||
});
|
||||
export const jadxMethodSchema = z.object({
|
||||
const jadxMethodIdentity = {
|
||||
class_name: z.string(),
|
||||
method_name: z.string(),
|
||||
full_name: z.string(),
|
||||
overload_index: count,
|
||||
overload_count: count,
|
||||
dex_descriptor: dexDescriptorSchema,
|
||||
mode: z.enum(["java", "smali"]),
|
||||
fell_back: z.boolean(),
|
||||
markers: z.array(z.string()),
|
||||
body: z.string(),
|
||||
});
|
||||
};
|
||||
export const jadxMethodSchema = z.discriminatedUnion("mode", [
|
||||
z.object({
|
||||
...jadxMethodIdentity,
|
||||
mode: z.enum(["java", "smali"]),
|
||||
fell_back: z.boolean(),
|
||||
markers: z.array(z.string()),
|
||||
body: z.string(),
|
||||
}),
|
||||
z.strictObject({
|
||||
...jadxMethodIdentity,
|
||||
mode: z.literal("unavailable"),
|
||||
body_unavailable_reason: z.string().min(1),
|
||||
}),
|
||||
]);
|
||||
export const jadxXrefsSchema = z.object({
|
||||
target: z.string(),
|
||||
reference_target: z.literal("external").optional(),
|
||||
|
||||
@@ -217,21 +217,38 @@ it.each(["inspect_android_class", "inspect_android_method"] as const)(
|
||||
},
|
||||
);
|
||||
|
||||
it("preserves native absence and optional historical omission without inventing mapping facts", () => {
|
||||
const { mapping: _mapping, ...native } = methodReport();
|
||||
const facts = {
|
||||
...native,
|
||||
body_status: "not_available",
|
||||
it.each([
|
||||
{
|
||||
markers: ["native_method"],
|
||||
source: { status: "complete", text: "", reported_total_bytes: 0 },
|
||||
};
|
||||
const { parent } = fixture("inspect_android_method", facts);
|
||||
const result = projectAnalysisView(parent, { kind: "summary" });
|
||||
if (!result.ok) throw result.error;
|
||||
const view = androidMethodSummaryViewResultSchema.parse(result.value);
|
||||
expect(view.summary).toEqual(facts);
|
||||
expect(Object.hasOwn(view.summary, "mapping")).toBe(false);
|
||||
});
|
||||
},
|
||||
{
|
||||
representation: null,
|
||||
body_unavailable_reason:
|
||||
"Selected method disassembly is incomplete: update()V",
|
||||
markers: ["disassembly_failed"],
|
||||
source: null,
|
||||
},
|
||||
])(
|
||||
"preserves method absence with $markers and historical omission of mapping",
|
||||
(absence) => {
|
||||
const { mapping: _mapping, ...method } = methodReport();
|
||||
const facts = {
|
||||
...method,
|
||||
body_status: "not_available",
|
||||
fell_back: false,
|
||||
...absence,
|
||||
};
|
||||
const { parent } = fixture("inspect_android_method", facts);
|
||||
const result = projectAnalysisView(parent, { kind: "summary" });
|
||||
if (!result.ok) throw result.error;
|
||||
const view = androidMethodSummaryViewResultSchema.parse(result.value);
|
||||
expect(view.summary).toEqual(facts);
|
||||
expect(Object.hasOwn(view.summary, "mapping")).toBe(false);
|
||||
if (absence.source === null)
|
||||
expect(view.unknowns).toContain(absence.body_unavailable_reason);
|
||||
},
|
||||
);
|
||||
|
||||
it.each(["inspect_android_class", "inspect_android_method"] as const)(
|
||||
"rejects malformed historical %s facts with a typed source error",
|
||||
|
||||
@@ -127,7 +127,10 @@ export const projectAndroidSymbolSummary = (
|
||||
summary: parsed.value,
|
||||
unknowns: [
|
||||
...shared.unknowns,
|
||||
...(parsed.value.source.status === "partial"
|
||||
...(parsed.value.source === null
|
||||
? [parsed.value.body_unavailable_reason]
|
||||
: []),
|
||||
...(parsed.value.source?.status === "partial"
|
||||
? [
|
||||
"The selected method source is partial; retained text does not establish a complete method body.",
|
||||
]
|
||||
|
||||
@@ -223,6 +223,14 @@ const engine = z.strictObject({
|
||||
const common = { engine };
|
||||
|
||||
/** Portable observations with explicit decompiler and identity limitations. */
|
||||
const methodInspectionIdentity = {
|
||||
...common,
|
||||
class_name: z.string(),
|
||||
method,
|
||||
overload_count: z.int().positive(),
|
||||
mapping: androidMappingReportSchema.exactOptional(),
|
||||
};
|
||||
|
||||
export const androidResultSchemas = {
|
||||
inspect_android_jni_bindings: androidJniReportSchema.extend(common),
|
||||
inspect_android_package: z.strictObject({
|
||||
@@ -267,18 +275,25 @@ export const androidResultSchemas = {
|
||||
inner_classes: z.array(z.string()),
|
||||
mapping: androidMappingReportSchema.exactOptional(),
|
||||
}),
|
||||
inspect_android_method: z.strictObject({
|
||||
...common,
|
||||
class_name: z.string(),
|
||||
method: method,
|
||||
overload_count: z.int().positive(),
|
||||
representation: z.enum(["java", "smali"]),
|
||||
body_status: z.enum(["available", "not_available"]),
|
||||
fell_back: z.boolean(),
|
||||
markers: z.array(z.string()),
|
||||
source: textCoverage,
|
||||
mapping: androidMappingReportSchema.exactOptional(),
|
||||
}),
|
||||
inspect_android_method: z.union([
|
||||
z.strictObject({
|
||||
...methodInspectionIdentity,
|
||||
representation: z.enum(["java", "smali"]),
|
||||
body_status: z.enum(["available", "not_available"]),
|
||||
fell_back: z.boolean(),
|
||||
markers: z.array(z.string()),
|
||||
source: textCoverage,
|
||||
}),
|
||||
z.strictObject({
|
||||
...methodInspectionIdentity,
|
||||
representation: z.null(),
|
||||
body_status: z.literal("not_available"),
|
||||
body_unavailable_reason: z.string().min(1),
|
||||
fell_back: z.literal(false),
|
||||
markers: z.array(z.string()),
|
||||
source: z.null(),
|
||||
}),
|
||||
]),
|
||||
trace_android_references: z.strictObject({
|
||||
...common,
|
||||
target_definition: z.enum(["defined", "external"]),
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
import { fileIdentity } from "../../fixtures/evidenceSubject.js";
|
||||
import { canonicalOutputSchema } from "../../fixtures/canonicalOutputSchema.js";
|
||||
import { createMcpSchemaValidation } from "../../fixtures/mcpSchemaValidation.js";
|
||||
import { SdkErrorCode } from "@modelcontextprotocol/client";
|
||||
import { packagedJadxBridgeIdentity } from "../../support/packagedJadxBridge.js";
|
||||
import { ArtifactResourceScope } from "../../../src/resources/ArtifactResourceScope.js";
|
||||
@@ -748,7 +750,7 @@ it("exposes overload candidates and executes only an explicitly selected ambiguo
|
||||
reported_signature: "choose(int): void",
|
||||
dex_descriptor: "(I)V",
|
||||
});
|
||||
expect(result.source.text).toContain("overload 1");
|
||||
expect(result.source?.text).toContain("overload 1");
|
||||
const references = await service.execute("trace_android_references", input);
|
||||
expect(references).toMatchObject({
|
||||
ok: false,
|
||||
@@ -844,12 +846,12 @@ it.each(["truncated", "smali"])(
|
||||
const result = androidResultSchemas.inspect_android_method.parse(
|
||||
outcome.value.normalized_result,
|
||||
);
|
||||
expect(result.source.status).toBe(
|
||||
expect(result.source?.status).toBe(
|
||||
mode === "truncated" ? "partial" : "complete",
|
||||
);
|
||||
expect(result.representation).toBe(mode === "smali" ? "smali" : "java");
|
||||
if (mode === "truncated")
|
||||
expect(result.source.reported_total_bytes).toBe(100);
|
||||
expect(result.source?.reported_total_bytes).toBe(100);
|
||||
else expect(result.fell_back).toBe(true);
|
||||
await provider.close();
|
||||
await verifyCleanup(launches);
|
||||
@@ -1471,6 +1473,52 @@ it("accepts exact selected-overload smali from the bridge", async () => {
|
||||
await verifyCleanup(launches);
|
||||
});
|
||||
|
||||
it.each(["unavailable-body", "unavailable-wrong-descriptor"] as const)(
|
||||
"preserves verified method identity for %s",
|
||||
async (mode) => {
|
||||
const { service, apk, launches, provider } = await setup(mode);
|
||||
try {
|
||||
const outcome = await service.execute("inspect_android_method", {
|
||||
path: apk,
|
||||
class_name: "fixture.Target",
|
||||
method_name: "choose",
|
||||
overload_index: 1,
|
||||
});
|
||||
if (mode === "unavailable-wrong-descriptor") {
|
||||
expect(outcome).toMatchObject({
|
||||
ok: false,
|
||||
error: { _tag: "AnalysisOutputError" },
|
||||
});
|
||||
return;
|
||||
}
|
||||
if (!outcome.ok) throw outcome.error;
|
||||
expect(outcome.value.normalized_result).toMatchObject({
|
||||
method: { overload_index: 1, dex_descriptor: "(I)V" },
|
||||
overload_count: 2,
|
||||
representation: null,
|
||||
body_status: "not_available",
|
||||
body_unavailable_reason:
|
||||
"Disassembly could not establish one selected method: choose(I)V",
|
||||
markers: ["disassembly_failed"],
|
||||
source: null,
|
||||
});
|
||||
const { assertions } = createMcpSchemaValidation();
|
||||
const advertised = canonicalOutputSchema("inspect_android_method");
|
||||
expect(
|
||||
assertions.validateSchema(advertised),
|
||||
JSON.stringify(assertions.errors),
|
||||
).toBe(true);
|
||||
expect(
|
||||
assertions.validate(advertised, outcome.value),
|
||||
JSON.stringify(assertions.errors),
|
||||
).toBe(true);
|
||||
} finally {
|
||||
await provider.close();
|
||||
await verifyCleanup(launches);
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
it("retains parsed native body absence without claiming an empty implementation", async () => {
|
||||
const { service, apk, launches, provider } = await setup("native-method");
|
||||
const outcome = await service.execute("inspect_android_method", {
|
||||
@@ -1483,7 +1531,7 @@ it("retains parsed native body absence without claiming an empty implementation"
|
||||
outcome.value.normalized_result,
|
||||
);
|
||||
expect(result.body_status).toBe("not_available");
|
||||
expect(result.source.text).toBe("");
|
||||
expect(result.source?.text).toBe("");
|
||||
expect(result.markers).toEqual(["native_method"]);
|
||||
await provider.close();
|
||||
await verifyCleanup(launches);
|
||||
|
||||
@@ -12,6 +12,8 @@ import java.lang.reflect.*;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.*;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.zip.*;
|
||||
import kotlin.coroutines.EmptyCoroutineContext;
|
||||
import kotlinx.coroutines.BuildersKt;
|
||||
@@ -697,6 +699,7 @@ public class ReaJadxMetadataRegression {
|
||||
require(ordinary.get("mode").getAsString().equals("java") && ordinary.get("body").getAsString().contains("COUNT"),
|
||||
"Ordinary executable method no longer produces Java");
|
||||
verifyNoBodyMethods(handle, bridge, holder.current());
|
||||
verifyDisassemblyGenerationFailure(handle, bridge, holder.current());
|
||||
verifyMergedMethods(handle, bridge);
|
||||
verifyConstantFields(handle, bridge, holder.current());
|
||||
verifyRawMemberNames(handle, bridge);
|
||||
@@ -855,17 +858,67 @@ public class ReaJadxMetadataRegression {
|
||||
select.invoke(null, new JadxSession.MethodSmali("highlightText", blocks, true, null), "highlightText()V");
|
||||
throw new AssertionError("Unproven disassembly identity or completeness was accepted");
|
||||
} catch (InvocationTargetException failure) {
|
||||
require(failure.getCause() instanceof IllegalArgumentException,
|
||||
"Disassembly uncertainty lost its failure reason");
|
||||
require(failure.getCause().getClass().getSimpleName().equals("MethodDisassemblyUnavailable")
|
||||
&& failure.getCause().getMessage().contains("highlightText()V"),
|
||||
"Disassembly uncertainty lost its method-scoped reason");
|
||||
}
|
||||
}
|
||||
String reason = "smali generation failed: controlled timeout";
|
||||
for (String reason : Arrays.asList(null, "class has no smali (no code)",
|
||||
"smali generation failed: controlled timeout")) {
|
||||
try {
|
||||
select.invoke(null, new JadxSession.MethodSmali("highlightText", List.of(), false, reason), "highlightText()V");
|
||||
throw new AssertionError("Missing disassembly was accepted as a body");
|
||||
} catch (InvocationTargetException failure) {
|
||||
require(failure.getCause().getClass().getSimpleName().equals("MethodDisassemblyUnavailable")
|
||||
&& failure.getCause().getMessage().contains("highlightText()V")
|
||||
&& (reason == null || failure.getCause().getMessage().contains(reason)),
|
||||
"Missing disassembly lost its method-scoped reason: " + failure.getCause());
|
||||
}
|
||||
}
|
||||
Thread.currentThread().interrupt();
|
||||
try {
|
||||
select.invoke(null, new JadxSession.MethodSmali("highlightText", List.of(), false, reason), "highlightText()V");
|
||||
throw new AssertionError("Disassembly generation failure was accepted");
|
||||
select.invoke(null, new JadxSession.MethodSmali("highlightText", List.of(), false, "smali generation failed: null"),
|
||||
"highlightText()V");
|
||||
throw new AssertionError("Interrupted disassembly returned a body");
|
||||
} catch (InvocationTargetException failure) {
|
||||
require(failure.getCause() instanceof IllegalArgumentException
|
||||
&& failure.getCause().getMessage().contains(reason), "Original disassembly failure reason was lost");
|
||||
require(failure.getCause().getClass() == IllegalArgumentException.class
|
||||
&& Thread.currentThread().isInterrupted(), "Disassembly consumed the caller interruption");
|
||||
} finally {
|
||||
Thread.interrupted();
|
||||
}
|
||||
}
|
||||
|
||||
private static void verifyDisassemblyGenerationFailure(Method handle, Object bridge, JadxSession session)
|
||||
throws Exception {
|
||||
JsonObject input = methodArguments("fixture.MixedInitialization", "<clinit>");
|
||||
JsonObject complete = call(handle, bridge, "get_method_body", input);
|
||||
Field pool = JadxSession.class.getDeclaredField("decompilePool");
|
||||
pool.setAccessible(true);
|
||||
ExecutorService rejected = Executors.newSingleThreadExecutor();
|
||||
rejected.shutdown();
|
||||
Object original = pool.get(session);
|
||||
pool.set(session, rejected);
|
||||
try {
|
||||
JsonObject unavailable = call(handle, bridge, "get_method_body", input);
|
||||
require(unavailable.get("mode").getAsString().equals("unavailable")
|
||||
&& !unavailable.has("body") && !unavailable.has("fell_back") && !unavailable.has("markers"),
|
||||
"Rejected disassembly work did not report an unavailable body: " + unavailable);
|
||||
require(unavailable.get("body_unavailable_reason").getAsString().contains("smali generation failed"),
|
||||
"JADX generation failure reason was discarded: " + unavailable);
|
||||
for (String key : List.of("class_name", "method_name", "full_name", "dex_descriptor",
|
||||
"overload_index", "overload_count")) {
|
||||
require(complete.get(key).equals(unavailable.get(key)), "Disassembly failure changed " + key);
|
||||
}
|
||||
try {
|
||||
call(handle, bridge, "get_method_body", methodArguments("fixture.MixedInitialization", "touch"));
|
||||
throw new AssertionError("A Java generation error was classified as unavailable disassembly");
|
||||
} catch (AssertionError failure) {
|
||||
require(failure.getCause() instanceof IllegalArgumentException
|
||||
&& failure.getCause().getMessage().startsWith("// ERROR:"),
|
||||
"Java generation did not keep its provider error: " + failure);
|
||||
}
|
||||
} finally {
|
||||
pool.set(session, original);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Vendored
+13
-2
@@ -239,7 +239,7 @@ register("get_method_body", ({ method_name, overload_index }) => {
|
||||
const selected = methods.filter((method) => method.name === method_name)[
|
||||
overload_index
|
||||
];
|
||||
return json({
|
||||
const identity = {
|
||||
class_name: "fixture.Target",
|
||||
method_name,
|
||||
full_name: `fixture.Target.${method_name}`,
|
||||
@@ -247,7 +247,18 @@ register("get_method_body", ({ method_name, overload_index }) => {
|
||||
mode === "wrong-method" ? overload_index + 1 : overload_index,
|
||||
overload_count: method_name === "choose" ? 2 : 1,
|
||||
dex_descriptor:
|
||||
mode === "wrong-descriptor" ? "()V" : selected.dex_descriptor,
|
||||
mode === "wrong-descriptor" || mode === "unavailable-wrong-descriptor"
|
||||
? "()V"
|
||||
: selected.dex_descriptor,
|
||||
};
|
||||
if (mode === "unavailable-body" || mode === "unavailable-wrong-descriptor")
|
||||
return json({
|
||||
...identity,
|
||||
mode: "unavailable",
|
||||
body_unavailable_reason: `Disassembly could not establish one selected method: ${selected.raw_name}${selected.dex_descriptor}`,
|
||||
});
|
||||
return json({
|
||||
...identity,
|
||||
mode:
|
||||
mode === "smali" || mode === "selected-overload-smali" ? "smali" : "java",
|
||||
fell_back: mode === "smali" || mode === "selected-overload-smali",
|
||||
|
||||
Reference in new issue
Block a user