skylot/jadx · error · JadxRuntimeException

Arguments count limit reached: {}

Error message

Arguments count limit reached: {}

What it means

Thrown by consumeMethodArgs() as an endless-loop guard. The method expects to parse approximately argsCount argument types, but allows a margin of +10 for synthetic methods. If the parsed argument count exceeds argsCount + 10 without hitting the closing ')', the parser assumes the signature is malformed and aborts rather than looping forever.

Source

Thrown at jadx-core/src/main/java/jadx/core/dex/nodes/parser/SignatureParser.java:342

		return types;
	}

	public List<ArgType> consumeMethodArgs(int argsCount) {
		consume('(');
		if (lookAhead(')')) {
			consume(')');
			return Collections.emptyList();
		}
		List<ArgType> args = new ArrayList<>(argsCount);
		int limit = argsCount + 10; // just prevent endless loop, args count can be different for synthetic methods
		do {
			ArgType type = consumeType();
			if (type == null) {
				throw new JadxRuntimeException("Unexpected end of signature");
			}
			args.add(type);
			if (args.size() > limit) {
				throw new JadxRuntimeException("Arguments count limit reached: " + args.size());
			}
		} while (!lookAhead(')'));
		consume(')');
		return args;
	}

	private static String mergeSignature(List<String> list) {
		if (list.size() == 1) {
			return list.get(0);
		}
		StringBuilder sb = new StringBuilder();
		for (String s : list) {
			sb.append(s);
		}
		return sb.toString();
	}

	public String getSignature() {

View on GitHub (pinned to e738a26571)

Solutions

1. Upgrade jadx — the limit heuristic and argument-count reconciliation improve over time.
2. Catch JadxRuntimeException per class/method and skip the offender.
3. Report the issue with the method name, declared argsCount, and the full signature.
4. Strip the method's Signature attribute before decompiling as a workaround.

try {
    javaClass.decompile();
} catch (JadxRuntimeException e) {
    LOG.warn("Method arg-count limit hit in {}: {}", javaClass.getName(), e.getMessage());
}

When it happens

Trigger: consumeMethodArgs() is called with an argsCount value, the do-while loop keeps calling consumeType() and adding to args, and args.size() exceeds argsCount + 10 while lookAhead(')') remains false. This happens when the signature's argument list is far longer than the declared argsCount, or when the closing ')' is missing so the parser never terminates.

Common situations: A method Signature attribute whose argument list does not match the method descriptor's argument count by more than 10 — typically from obfuscators that rewrite method signatures, or from DEX files where the Signature and the actual parameter count diverge significantly.

Related errors

• Bad name for type variable: {}
• Can't parse type: {}, unexpected: {}
• No inner type found: {}
• Unexpected inner type found: {}
• Failed to parse generic types map

AI-assisted analysis of skylot/jadx@e738a26571 (2026-08-14). Data as JSON: /api/errors/fc62ec849b87baaf. Report an issue: GitHub.