@futpib/parser 1.0.3 → 1.0.6

package/src/dalvikExecutableParser.test.ts.md

@@ -129,10 +129,10 @@ Generated by [AVA](https://avajs.dev).
                         value: 90,
                       },
                       {
-                        name: 'onCreate',
+                        name: 'label',
                         registerNum: 0,
                         type: 'startLocal',
-                        type_: 'Ljava/lang/CharSequence;',
+                        type_: 'Landroid/widget/TextView;',
                       },
                       {
                         type: 'special',
@@ -632,3 +632,164 @@ Generated by [AVA](https://avajs.dev).
       ],
       link: undefined,
     }
+
+## method Lpl/czak/minimal/MainActivity;.getPackedSwitchResult from bafkreifycfnx4xf3nlml4qavlyxr6bes66nxsow3iaqjghewfsozoj2h3q
+
+> Snapshot 1
+
+    {
+      accessFlags: @Object {
+        abstract: false,
+        annotation: false,
+        bridge: false,
+        constructor: false,
+        declaredSynchronized: false,
+        enum: false,
+        final: false,
+        interface: false,
+        native: false,
+        private: true,
+        protected: false,
+        public: false,
+        static: false,
+        strict: false,
+        synchronized: false,
+        synthetic: false,
+        transient: false,
+        varargs: false,
+        volatile: false,
+      },
+      code: {
+        debugInfo: {
+          bytecode: [
+            {
+              type: 'special',
+              value: 14,
+            },
+            {
+              type: 'special',
+              value: 64,
+            },
+            {
+              type: 'special',
+              value: 58,
+            },
+            {
+              type: 'special',
+              value: 58,
+            },
+            {
+              type: 'special',
+              value: 58,
+            },
+            {
+              type: 'special',
+              value: 58,
+            },
+          ],
+          lineStart: 102,
+          parameterNames: [
+            'value',
+          ],
+        },
+        insSize: 2,
+        instructions: [
+          {
+            operation: 'packed-switch',
+            registers: [
+              2,
+            ],
+            targetInstructionIndex: 11,
+          },
+          {
+            operation: 'const-string',
+            registers: [
+              0,
+            ],
+            string: 'other',
+          },
+          {
+            operation: 'return-object',
+            registers: [
+              0,
+            ],
+          },
+          {
+            operation: 'const-string',
+            registers: [
+              0,
+            ],
+            string: 'three',
+          },
+          {
+            operation: 'return-object',
+            registers: [
+              0,
+            ],
+          },
+          {
+            operation: 'const-string',
+            registers: [
+              0,
+            ],
+            string: 'two',
+          },
+          {
+            operation: 'return-object',
+            registers: [
+              0,
+            ],
+          },
+          {
+            operation: 'const-string',
+            registers: [
+              0,
+            ],
+            string: 'one',
+          },
+          {
+            operation: 'return-object',
+            registers: [
+              0,
+            ],
+          },
+          {
+            operation: 'const-string',
+            registers: [
+              0,
+            ],
+            string: 'zero',
+          },
+          {
+            operation: 'return-object',
+            registers: [
+              0,
+            ],
+          },
+          {
+            operation: 'packed-switch-payload',
+            targetInstructionIndices: [
+              9,
+              7,
+              5,
+              3,
+            ],
+            value: 0,
+          },
+        ],
+        outsSize: 0,
+        registersSize: 3,
+        tries: [],
+      },
+      method: {
+        class: 'Lpl/czak/minimal/MainActivity;',
+        name: 'getPackedSwitchResult',
+        prototype: {
+          parameters: [
+            'I',
+          ],
+          returnType: 'Ljava/lang/String;',
+          shorty: 'LI',
+        },
+      },
+    }

package/src/dalvikExecutableParser.ts

@@ -4,6 +4,7 @@ import { type Iso } from 'monocle-ts';
 import { createExactElementParser } from './exactElementParser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { createObjectParser } from './objectParser.js';
 import { cloneParser, setParserName, type Parser } from './parser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -53,8 +54,17 @@ import { createDisjunctionParser } from './disjunctionParser.js';
 import { createElementTerminatedSequenceParser } from './elementTerminatedSequenceParser.js';
 import { createElementTerminatedArrayParserUnsafe } from './elementTerminatedArrayParser.js';
 import {
-	createDalvikBytecodeParser, type DalvikBytecode, type DalvikBytecodeOperation, type DalvikBytecodeOperationResolvers, resolveDalvikBytecodeOperation,
+	createRawDalvikBytecodeParser, type RawDalvikBytecode, type RawDalvikBytecodeOperation, type RawDalvikBytecodeOperationResolvers, resolveRawDalvikBytecodeOperationIndices,
 } from './dalvikBytecodeParser.js';
+import {
+	buildCodeUnitToIndexMap,
+	codeUnitToInstructionIndex,
+	convertBranchOffsetsToInstructionOffsets,
+	unwrapBranchOffsets,
+	type DalvikBytecode,
+	type DalvikBytecodeOperation,
+} from './dalvikBytecodeParser/addressConversion.js';
+import { isoCodeUnit, isoInstructionIndex } from './dalvikExecutableParser/typedNumbers.js';
 import {
 	byteParser, ubyteParser, uintParser, uleb128p1NumberParser, ushortParser,
 } from './dalvikExecutableParser/typeParsers.js';
@@ -70,6 +80,7 @@ import {
 	type DalvikExecutableCode,
 	type DalvikExecutableDebugInfo,
 	type DalvikExecutableEncodedValue,
+	dalvikExecutableMethodEquals,
 } from './dalvikExecutable.js';
 
 // https://source.android.com/docs/core/runtime/dex-format
@@ -101,13 +112,10 @@ type SizeOffset = {
 	offset: number;
 };
 
-const sizeOffsetParser: Parser<SizeOffset, Uint8Array> = promiseCompose(
-	createTupleParser([
-		uintParser,
-		uintParser,
-	]),
-	([ size, offset ]) => ({ size, offset }),
-);
+const sizeOffsetParser: Parser<SizeOffset, Uint8Array> = createObjectParser({
+	size: uintParser,
+	offset: uintParser,
+});
 
 type DalvikExecutableHeaderItem = {
 	version: number;
@@ -127,58 +135,23 @@ type DalvikExecutableHeaderItem = {
 	data: SizeOffset;
 };
 
-const dalvikExecutableHeaderItemParser: Parser<DalvikExecutableHeaderItem, Uint8Array> = promiseCompose(
-	createTupleParser([
-		dalvikExecutableHeaderVersionParser,
-		uintParser,
-		createFixedLengthSequenceParser(20),
-		uintParser,
-		uintParser,
-		uintParser,
-		sizeOffsetParser,
-		uintParser,
-		sizeOffsetParser,
-		sizeOffsetParser,
-		sizeOffsetParser,
-		sizeOffsetParser,
-		sizeOffsetParser,
-		sizeOffsetParser,
-		sizeOffsetParser,
-	]),
-	([
-		version,
-		checksum,
-		sha1Hash,
-		fileSize,
-		headerSize,
-		endianTag,
-		link,
-		mapOffset,
-		stringIds,
-		typeIds,
-		prototypeIds,
-		fieldIds,
-		methodIds,
-		classDefinitions,
-		data,
-	]) => ({
-		version,
-		checksum,
-		sha1Hash,
-		fileSize,
-		headerSize,
-		endianTag,
-		link,
-		mapOffset,
-		stringIds,
-		typeIds,
-		prototypeIds,
-		fieldIds,
-		methodIds,
-		classDefinitions,
-		data,
-	}),
-);
+const dalvikExecutableHeaderItemParser: Parser<DalvikExecutableHeaderItem, Uint8Array> = createObjectParser({
+	version: dalvikExecutableHeaderVersionParser,
+	checksum: uintParser,
+	sha1Hash: createFixedLengthSequenceParser<Uint8Array>(20),
+	fileSize: uintParser,
+	headerSize: uintParser,
+	endianTag: uintParser,
+	link: sizeOffsetParser,
+	mapOffset: uintParser,
+	stringIds: sizeOffsetParser,
+	typeIds: sizeOffsetParser,
+	prototypeIds: sizeOffsetParser,
+	fieldIds: sizeOffsetParser,
+	methodIds: sizeOffsetParser,
+	classDefinitions: sizeOffsetParser,
+	data: sizeOffsetParser,
+});
 
 type DalvikExecutableStringIdItem = OffsetToStringDataItem;
 
@@ -723,13 +696,10 @@ type DalvikExecutableEncodedFieldDiff = {
 	accessFlags: DalvikExecutableAccessFlags;
 };
 
-const encodedFieldParser: Parser<DalvikExecutableEncodedFieldDiff, Uint8Array> = promiseCompose(
-	createTupleParser([
-		uleb128NumberParser,
-		uleb128FieldAccessFlagsParser,
-	]),
-	([ fieldIndexDiff, accessFlags ]) => ({ fieldIndexDiff, accessFlags }),
-);
+const encodedFieldParser: Parser<DalvikExecutableEncodedFieldDiff, Uint8Array> = createObjectParser({
+	fieldIndexDiff: uleb128NumberParser,
+	accessFlags: uleb128FieldAccessFlagsParser,
+});
 
 type DalvikExecutableEncodedField = {
 	fieldIndex: IndexIntoFieldIds;
@@ -894,13 +864,11 @@ const createEncodedValueArgParser = (valueType: number): Parser<number, Uint8Arr
 	byte => byte >> 5,
 );
 
-const encodedValueByteParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = promiseCompose(
-	createTupleParser([
-		createExactElementParser(0),
-		byteParser,
-	]),
-	([ _, value ]) => ({ type: 'byte' as const, value }),
-);
+const encodedValueByteParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = createObjectParser({
+	type: 'byte' as const,
+	_tag: createExactElementParser(0),
+	value: byteParser,
+});
 
 setParserName(encodedValueByteParser, 'encodedValueByteParser');
 
@@ -1543,18 +1511,16 @@ const encodedArrayParser: Parser<DalvikExecutableTaggedEncodedValue[], Uint8Arra
 
 setParserName(encodedArrayParser, 'encodedArrayParser');
 
-const encodedValueArrayParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = promiseCompose(
-	createTupleParser([
-		parserCreatorCompose(
-			() => createEncodedValueArgParser(0x1C),
-			valueArg => parserContext => {
-				parserContext.invariant(valueArg === 0, '(encodedValueArrayParser) valueArg: %s', valueArg);
-			},
-		)(),
-		encodedArrayParser,
-	]),
-	([ _, array ]) => ({ type: 'array' as const, value: array }),
-);
+const encodedValueArrayParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = createObjectParser({
+	type: 'array' as const,
+	_tag: parserCreatorCompose(
+		() => createEncodedValueArgParser(0x1C),
+		valueArg => parserContext => {
+			parserContext.invariant(valueArg === 0, '(encodedValueArrayParser) valueArg: %s', valueArg);
+		},
+	)(),
+	value: encodedArrayParser,
+});
 
 setParserName(encodedValueArrayParser, 'encodedValueArrayParser');
 
@@ -1612,18 +1578,16 @@ const encodedAnnotationParser: Parser<DalvikExecutableEncodedAnnotation, Uint8Ar
 
 setParserName(encodedAnnotationParser, 'encodedAnnotationParser');
 
-const encodedValueAnnotationParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = promiseCompose(
-	createTupleParser([
-		parserCreatorCompose(
-			() => createEncodedValueArgParser(0x1D),
-			valueArg => parserContext => {
-				parserContext.invariant(valueArg === 0, '(encodedValueAnnotationParser) valueArg: %s', valueArg);
-			},
-		)(),
-		encodedAnnotationParser,
-	]),
-	([ _, annotation ]) => ({ type: 'annotation' as const, value: annotation }),
-);
+const encodedValueAnnotationParser: Parser<DalvikExecutableTaggedEncodedValue, Uint8Array> = createObjectParser({
+	type: 'annotation' as const,
+	_tag: parserCreatorCompose(
+		() => createEncodedValueArgParser(0x1D),
+		valueArg => parserContext => {
+			parserContext.invariant(valueArg === 0, '(encodedValueAnnotationParser) valueArg: %s', valueArg);
+		},
+	)(),
+	value: encodedAnnotationParser,
+});
 
 setParserName(encodedValueAnnotationParser, 'encodedValueAnnotationParser');
 
@@ -1910,16 +1874,16 @@ const dalvikExecutableDebugByteCodeValueParser: Parser<DalvikExecutableDebugByte
 	() => ubyteParser,
 	(value): Parser<DalvikExecutableDebugByteCodeValueItem, Uint8Array> => {
 		switch (value) {
-			case 0x01: { return promiseCompose(
-				uleb128NumberParser,
-				addressDiff => ({ type: 'advancePc', addressDiff }),
-			);
+			case 0x01: { return createObjectParser({
+				type: 'advancePc' as const,
+				addressDiff: uleb128NumberParser,
+			});
 			}
 
-			case 0x02: { return promiseCompose(
-				sleb128NumberParser,
-				lineDiff => ({ type: 'advanceLine', lineDiff }),
-			);
+			case 0x02: { return createObjectParser({
+				type: 'advanceLine' as const,
+				lineDiff: sleb128NumberParser,
+			});
 			}
 
 			case 0x03: { return promiseCompose(
@@ -2074,13 +2038,10 @@ type DalvikExecutableAnnotationItem = {
 	encodedAnnotation: DalvikExecutableEncodedAnnotation;
 };
 
-const dalvikExecutableAnnotationItemParser: Parser<DalvikExecutableAnnotationItem, Uint8Array> = promiseCompose(
-	createTupleParser([
-		dalvikExecutableAnnotationItemVisibilityParser,
-		encodedAnnotationParser,
-	]),
-	([ visibility, encodedAnnotation ]) => ({ visibility, encodedAnnotation }),
-);
+const dalvikExecutableAnnotationItemParser: Parser<DalvikExecutableAnnotationItem, Uint8Array> = createObjectParser({
+	visibility: dalvikExecutableAnnotationItemVisibilityParser,
+	encodedAnnotation: encodedAnnotationParser,
+});
 
 setParserName(dalvikExecutableAnnotationItemParser, 'dalvikExecutableAnnotationItemParser');
 
@@ -2284,15 +2245,12 @@ type DalvikExecutableMapItem = {
 	offset: number;
 };
 
-const dalvikExecutableMapItemParser: Parser<DalvikExecutableMapItem, Uint8Array> = promiseCompose(
-	createTupleParser([
-		dalvikExecutableMapItemTypeParser,
-		ushortParser,
-		uintParser,
-		uintParser,
-	]),
-	([ type, _unused, size, offset ]) => ({ type, size, offset }),
-);
+const dalvikExecutableMapItemParser: Parser<DalvikExecutableMapItem, Uint8Array> = createObjectParser({
+	type: dalvikExecutableMapItemTypeParser,
+	_unused: ushortParser,
+	size: uintParser,
+	offset: uintParser,
+});
 
 type DalvikExecutableMapList = DalvikExecutableMapItem[];
 
@@ -2708,16 +2666,27 @@ const createDalvikExecutableParser = <Instructions>({
 			for (const [ offset, codeItem ] of codeItemByOffset) {
 				const debugInfo = debugInfoByOffset.get(codeItem.debugInfoOffset);
 
+				// Build code unit to instruction index mapping for address conversion
+				const rawInstructions = codeItem.instructions as RawDalvikBytecodeOperation[];
+				const codeUnitToIndexMap = Array.isArray(rawInstructions) ? buildCodeUnitToIndexMap(rawInstructions) : undefined;
+
+				// Convert branch offsets from code units to instruction offsets
+				// Tier 1 (CodeUnit) -> Tier 2 (InstructionIndex) -> Tier 3 (plain numbers)
+				const convertedInstructions: Instructions = (Array.isArray(rawInstructions) && codeUnitToIndexMap)
+					? unwrapBranchOffsets(convertBranchOffsetsToInstructionOffsets(rawInstructions)) as Instructions
+					: codeItem.instructions;
+
 				codeByOffset.set(offset, {
 					registersSize: codeItem.registersSize,
 					insSize: codeItem.insSize,
 					outsSize: codeItem.outsSize,
 					debugInfo,
-					instructions: codeItem.instructions,
+					instructions: convertedInstructions,
 					tries: codeItem.tryItems.map(tryItem => {
 						const handler_ = codeItem.handlers.get(tryItem.handlerOffset);
 						invariant(handler_, 'Handler must be there. Handler offset: %s', tryItem.handlerOffset);
 
+						// Convert handler addresses from code units to instruction indices (unwrapped for Tier 3)
 						const handler = {
 							handlers: handler_.handlers.map(encodedHandler => {
 								const type = types.at(encodedHandler.typeIndex);
@@ -2725,15 +2694,27 @@ const createDalvikExecutableParser = <Instructions>({
 
 								return {
 									type,
-									address: encodedHandler.address,
+									handlerInstructionIndex: codeUnitToIndexMap
+										? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(encodedHandler.address), codeUnitToIndexMap))
+										: encodedHandler.address,
 								};
 							}),
-							catchAllAddress: handler_.catchAllAddress,
+							catchAllInstructionIndex: (handler_.catchAllAddress !== undefined && codeUnitToIndexMap)
+								? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(handler_.catchAllAddress), codeUnitToIndexMap))
+								: handler_.catchAllAddress,
 						};
 
+						// Convert try block addresses from code units to instruction indices (unwrapped for Tier 3)
+						const startInstructionIndex = codeUnitToIndexMap
+							? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(tryItem.startAddress), codeUnitToIndexMap))
+							: tryItem.startAddress;
+						const endInstructionIndex = codeUnitToIndexMap
+							? isoInstructionIndex.unwrap(codeUnitToInstructionIndex(isoCodeUnit.wrap(tryItem.startAddress + tryItem.instructionCount), codeUnitToIndexMap))
+							: tryItem.startAddress + tryItem.instructionCount;
+
 						return {
-							startAddress: tryItem.startAddress,
-							instructionCount: tryItem.instructionCount,
+							startInstructionIndex,
+							instructionCount: endInstructionIndex - startInstructionIndex,
 							handler,
 						};
 					}),
@@ -2744,7 +2725,7 @@ const createDalvikExecutableParser = <Instructions>({
 				[ isoOffsetToClassDataItem.wrap(0), undefined ],
 			]);
 
-			const resolvers: DalvikBytecodeOperationResolvers = {
+			const resolvers: RawDalvikBytecodeOperationResolvers = {
 				resolveIndexIntoStringIds(indexIntoStringIds) {
 					const string = strings.at(indexIntoStringIds);
 					invariant(string !== undefined, 'String must be there. String id: %s', indexIntoStringIds);
@@ -2787,7 +2768,7 @@ const createDalvikExecutableParser = <Instructions>({
 
 				return {
 					...rest,
-					instructions: instructions.map((instruction: DalvikBytecodeOperation) => resolveDalvikBytecodeOperation(instruction, resolvers)) as Instructions,
+					instructions: instructions.map((instruction: DalvikBytecodeOperation) => resolveRawDalvikBytecodeOperationIndices(instruction as RawDalvikBytecodeOperation, resolvers)) as Instructions,
 				};
 			}
 
@@ -3213,14 +3194,8 @@ const createDalvikExecutableParser = <Instructions>({
 			if (classDef.annotations?.parameterAnnotations && classDef.classData) {
 				const allMethods = [...(classDef.classData.directMethods ?? []), ...(classDef.classData.virtualMethods ?? [])];
 				classDef.annotations.parameterAnnotations.sort((a, b) => {
-					const indexA = allMethods.findIndex(m => 
-						m.method.name === a.method.name && 
-						m.method.prototype.shorty === a.method.prototype.shorty
-					);
-					const indexB = allMethods.findIndex(m => 
-						m.method.name === b.method.name && 
-						m.method.prototype.shorty === b.method.prototype.shorty
-					);
+					const indexA = allMethods.findIndex(m => dalvikExecutableMethodEquals(m.method, a.method));
+					const indexB = allMethods.findIndex(m => dalvikExecutableMethodEquals(m.method, b.method));
 					return indexA - indexB;
 				});
 			}
@@ -3234,9 +3209,16 @@ const createDalvikExecutableParser = <Instructions>({
 	),
 )();
 
+// The factory creates a parser that outputs RawDalvikBytecode, but the parser internally transforms
+// instructions via unwrapBranchOffsets(convertBranchOffsetsToInstructionOffsets(...)) and
+// resolveRawDalvikBytecodeOperationIndices to produce DalvikBytecode with plain number indices.
+// The cast is required because TypeScript can't track this internal transformation.
 export const dalvikExecutableParser: Parser<DalvikExecutable<DalvikBytecode>, Uint8Array> = createDalvikExecutableParser({
-	createInstructionsParser: createDalvikBytecodeParser,
-});
+	createInstructionsParser: createRawDalvikBytecodeParser,
+}) as Parser<DalvikExecutable<DalvikBytecode>, Uint8Array>;
+
+// Re-export public types
+export { type DalvikBytecodeOperation, type DalvikBytecode } from './dalvikBytecodeParser/addressConversion.js';
 
 setParserName(dalvikExecutableParser, 'dalvikExecutableParser');
 

package/src/dalvikExecutableParserAgainstSmaliParser.test.ts

@@ -217,6 +217,9 @@ const parseAllClassesInDexAgainstSmaliMacro = test.macro({
 });
 
 const testCasesByCid: Record<string, Array<string | { smaliFilePath: string; isolate?: boolean }>> = {
+	bafkreifycfnx4xf3nlml4qavlyxr6bes66nxsow3iaqjghewfsozoj2h3q: [
+		{ smaliFilePath: 'pl/czak/minimal/MainActivity', isolate: true },
+	],
 	bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda: [
 		{ smaliFilePath: 'androidx/activity/ComponentActivity$1', isolate: true },
 		{ smaliFilePath: 'androidx/activity/R$id', isolate: true },
@@ -361,3 +364,4 @@ test.serial(
 		);
 	},
 );
+

package/src/dalvikExecutableUnparser/poolScanners.ts

@@ -14,11 +14,11 @@ import {
 	isDalvikExecutableField,
 	isDalvikExecutableMethod,
 } from '../dalvikExecutable.js';
-import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
+import { type DalvikBytecodeOperation } from '../dalvikBytecodeParser/addressConversion.js';
 import { type PoolBuilders } from './poolBuilders.js';
 
 export function scanForPoolReferences(
-	dalvikExecutable: DalvikExecutable<DalvikBytecode>,
+	dalvikExecutable: DalvikExecutable<DalvikBytecodeOperation[]>,
 	poolBuilders: PoolBuilders,
 ): void {
 	const { stringPool, typePool, protoPool, fieldPool, methodPool } = poolBuilders;
@@ -198,7 +198,7 @@ export function scanForPoolReferences(
 		}
 	}
 
-	function scanCode(code: undefined | DalvikExecutableCode<DalvikBytecode>): void {
+	function scanCode(code: undefined | DalvikExecutableCode<DalvikBytecodeOperation[]>): void {
 		if (!code) {
 			return;
 		}
@@ -249,12 +249,12 @@ export function scanForPoolReferences(
 		}
 	}
 
-	function scanMethod(method: DalvikExecutableMethodWithAccess<DalvikBytecode>): void {
+	function scanMethod(method: DalvikExecutableMethodWithAccess<DalvikBytecodeOperation[]>): void {
 		addMethod(method.method);
 		scanCode(method.code);
 	}
 
-	function scanClassData(classData: undefined | DalvikExecutableClassData<DalvikBytecode>): void {
+	function scanClassData(classData: undefined | DalvikExecutableClassData<DalvikBytecodeOperation[]>): void {
 		if (!classData) {
 			return;
 		}
@@ -276,7 +276,7 @@ export function scanForPoolReferences(
 		}
 	}
 
-	function scanClassDefinition(classDef: DalvikExecutableClassDefinition<DalvikBytecode>): void {
+	function scanClassDefinition(classDef: DalvikExecutableClassDefinition<DalvikBytecodeOperation[]>): void {
 		addType(classDef.class);
 		addType(classDef.superclass);