@futpib/parser 1.0.2 → 1.0.4

package/build/smaliParser.test.js

@@ -2,10 +2,12 @@ import test from 'ava';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { getParserName, runParser } from './parser.js';
 import { fetchCid } from './fetchCid.js';
-import { smaliAnnotationParser, smaliCodeParameterParser, smaliFieldParser, smaliParser } from './smaliParser.js';
+import { smaliAnnotationParser, smaliCodeOperationParser, smaliCodeParameterParser, smaliCommentParser, smaliFieldParser, smaliMethodParser, smaliParser, } from './smaliParser.js';
 import { hasExecutable } from './hasExecutable.js';
 import { baksmaliClass } from './backsmali.js';
 const hasBaksmaliPromise = hasExecutable('baksmali');
+const stringParserTestSnapshot = Symbol('stringParserTestSnapshot');
+const stringParserTestIgnore = Symbol('stringParserTestIgnore');
 function stringParserTest(parser, examples) {
     const parserName = getParserName(parser);
     for (const [input, expected] of examples) {
@@ -13,23 +15,63 @@ function stringParserTest(parser, examples) {
             const actual = await runParser(parser, input, stringParserInputCompanion, {
                 errorJoinMode: 'all',
             });
-            t.deepEqual(actual, expected);
+            if (expected === stringParserTestIgnore) {
+                t.pass('skipping test because expected is stringParserTestIgnore');
+            }
+            else if (expected === stringParserTestSnapshot) {
+                t.snapshot(actual);
+            }
+            else {
+                t.deepEqual(actual, expected);
+            }
         });
     }
 }
+stringParserTest(smaliCommentParser, [
+    [
+        '# this is a comment \n',
+        ' this is a comment ',
+    ],
+]);
 stringParserTest(smaliCodeParameterParser, [
     [
         '    .param p1\n',
         {
-            index: 1,
-            prefix: 'p',
+            register: {
+                index: 1,
+                prefix: 'p',
+            },
+            name: undefined,
+            annotation: undefined,
         },
     ],
     [
         '    .param p1, "savedInstanceState"    # Landroid/os/Bundle;\n',
         {
-            index: 1,
-            prefix: 'p',
+            register: {
+                index: 1,
+                prefix: 'p',
+            },
+            name: 'savedInstanceState',
+            annotation: undefined,
+        },
+    ],
+    [
+        `    .param p1    # Ljava/lang/ClassLoader;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param\n`,
+        {
+            register: {
+                index: 1,
+                prefix: 'p',
+            },
+            name: undefined,
+            annotation: {
+                visibility: 'build',
+                type: 'Landroid/annotation/NonNull;',
+                elements: [],
+            },
         },
     ],
 ]);
@@ -37,32 +79,98 @@ stringParserTest(smaliFieldParser, [
     [
         '.field private barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;\n',
         {
-            accessFlags: {
-                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,
+            field: {
+                accessFlags: {
+                    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,
+                },
+                field: {
+                    class: 'FILLED_LATER',
+                    name: 'barcodeScannerView',
+                    type: 'Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;',
+                },
             },
+            annotations: [],
+        },
+    ],
+    [
+        `.field public final g:Lo/b;
+    .annotation system Ldalvik/annotation/Signature;
+        value = {
+            "Lo/b<",
+            "Ljava/lang/Float;",
+            "Lo/i;",
+            ">;"
+        }
+    .end annotation
+.end field
+`,
+        {
             field: {
-                class: 'FILLED_LATER',
-                name: 'barcodeScannerView',
-                type: 'Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;',
+                accessFlags: {
+                    abstract: false,
+                    annotation: false,
+                    bridge: false,
+                    constructor: false,
+                    declaredSynchronized: false,
+                    enum: false,
+                    final: true,
+                    interface: false,
+                    native: false,
+                    private: false,
+                    protected: false,
+                    public: true,
+                    static: false,
+                    strict: false,
+                    synchronized: false,
+                    synthetic: false,
+                    transient: false,
+                    varargs: false,
+                    volatile: false,
+                },
+                field: {
+                    class: 'FILLED_LATER',
+                    name: 'g',
+                    type: 'Lo/b;',
+                },
             },
+            annotations: [
+                {
+                    visibility: 'system',
+                    type: 'Ldalvik/annotation/Signature;',
+                    elements: [
+                        {
+                            name: 'value',
+                            value: {
+                                kind: 'string',
+                                value: [
+                                    'Lo/b<',
+                                    'Ljava/lang/Float;',
+                                    'Lo/i;',
+                                    '>;',
+                                ],
+                            },
+                        },
+                    ],
+                },
+            ],
         },
     ],
 ]);
@@ -77,22 +185,177 @@ stringParserTest(smaliAnnotationParser, [
             .end annotation
 `,
         {
+            visibility: 'system',
+            type: 'Ldalvik/annotation/Signature;',
+            elements: [
+                {
+                    name: 'value',
+                    value: {
+                        kind: 'string',
+                        value: [
+                            '<T:',
+                            'Landroid/view/View;',
+                            '>(I)TT;',
+                        ],
+                    },
+                },
+            ],
+        },
+    ],
+    [
+        `        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+`,
+        {
+            visibility: 'build',
+            type: 'Landroid/annotation/NonNull;',
+            elements: [],
+        },
+    ],
+    [
+        `    .annotation system Ldalvik/annotation/Signature;
+        value = {
+            "Lo/b<",
+            "Ljava/lang/Float;",
+            "Lo/i;",
+            ">;"
+        }
+    .end annotation
+`,
+        {
+            visibility: 'system',
             type: 'Ldalvik/annotation/Signature;',
-            value: [
-                '<T:',
-                'Landroid/view/View;',
-                '>(I)TT;',
+            elements: [
+                {
+                    name: 'value',
+                    value: {
+                        kind: 'string',
+                        value: [
+                            'Lo/b<',
+                            'Ljava/lang/Float;',
+                            'Lo/i;',
+                            '>;',
+                        ],
+                    },
+                },
             ],
         },
     ],
 ]);
-for (const [dexCid, smaliFilePath, shouldSnapshot] of [
-    ['bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', 'pl/czak/minimal/MainActivity', true],
-    ['bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', 'd/m', true],
-    // [ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', 'com/journeyapps/barcodescanner/CaptureActivity', true ],
-    // [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
-]) {
-    test.serial('smali from dex ' + dexCid + ' ' + smaliFilePath, async (t) => {
+stringParserTest(smaliMethodParser, [
+    [
+        `.method public native synthetic instantiateActivity(Ljava/lang/ClassLoader;Ljava/lang/String;Landroid/content/Intent;)Landroid/app/Activity;
+    .param p1    # Ljava/lang/ClassLoader;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param
+.end method
+`,
+        stringParserTestSnapshot,
+    ],
+    [
+        `.method public native synthetic instantiateActivity(Ljava/lang/ClassLoader;Ljava/lang/String;Landroid/content/Intent;)Landroid/app/Activity;
+    .param p1    # Ljava/lang/ClassLoader;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param
+    .param p2    # Ljava/lang/String;
+        .annotation build Landroid/annotation/NonNull;
+        .end annotation
+    .end param
+    .annotation build Landroid/annotation/NonNull;
+    .end annotation
+
+    .annotation system Ldalvik/annotation/Throws;
+        value = {
+            Ljava/lang/ClassNotFoundException;,
+            Ljava/lang/IllegalAccessException;,
+            Ljava/lang/InstantiationException;
+        }
+    .end annotation
+.end method
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliCodeOperationParser, [
+    [
+        `    invoke-static {}, Le4/k;->c()Le4/k;
+`,
+        {
+            operation: 'invoke-static',
+            registers: [],
+            method: {
+                class: 'Le4/k;',
+                name: 'c',
+                prototype: {
+                    parameters: [],
+                    returnType: 'Le4/k;',
+                    shorty: 'L',
+                },
+            },
+        },
+    ],
+    [
+        `    .packed-switch 0x0
+        :pswitch_5
+    .end packed-switch
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliCodeOperationParser, [
+    [
+        `    .sparse-switch
+        -0x7073f927 -> :sswitch_47
+        -0x3465cce -> :sswitch_3e
+        0x388694fe -> :sswitch_33
+        0x3cbf870b -> :sswitch_28
+    .end sparse-switch
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliCodeOperationParser, [
+    [
+        `    .array-data 4
+        0x10100a7
+        0x101009e
+    .end array-data
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+stringParserTest(smaliMethodParser, [
+    [
+        `.method public final a()Landroid/os/Bundle;
+    .registers 2
+
+    iget v0, p0, Landroidx/lifecycle/b0;->a:I
+
+    packed-switch v0, :pswitch_data_c
+
+    :pswitch_5
+    iget-object v0, p0, Landroidx/lifecycle/b0;->b:Landroidx/lifecycle/c0;
+
+    invoke-static {v0}, Landroidx/lifecycle/c0;->a(Landroidx/lifecycle/c0;)Landroid/os/Bundle;
+
+    move-result-object v0
+
+    return-object v0
+
+    :pswitch_data_c
+    .packed-switch 0x0
+        :pswitch_5
+    .end packed-switch
+.end method
+`,
+        stringParserTestSnapshot,
+    ],
+]);
+const smaliFromDexMacro = test.macro({
+    title: (providedTitle, dexCid, smaliFilePath) => providedTitle ?? `smali from dex ${dexCid} ${smaliFilePath}`,
+    async exec(t, dexCid, smaliFilePath, shouldSnapshot) {
         const hasBaksmali = await hasBaksmaliPromise;
         if (!hasBaksmali) {
             t.pass('skipping test because baksmali is not available');
@@ -103,13 +366,45 @@ for (const [dexCid, smaliFilePath, shouldSnapshot] of [
         const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
             errorJoinMode: 'all',
         });
-        // console.dir(actual, { depth: null });
+        // Console.dir(actual, { depth: null });
         if (shouldSnapshot) {
             t.snapshot(actual);
         }
         else {
-            //console.dir(actual, { depth: null });
+            // Console.dir(actual, { depth: null });
             t.pass();
         }
+    },
+});
+test.serial(smaliFromDexMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', 'pl/czak/minimal/MainActivity', true);
+test.serial(smaliFromDexMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', 'd/m', true);
+test.serial(smaliFromDexMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', 'com/journeyapps/barcodescanner/CaptureActivity', true);
+test.serial.skip(smaliFromDexMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', '', false);
+// Minimal failing test case reproducing the a0/n parsing issue
+test('parse smali with virtual method after direct methods (a0/n issue)', async (t) => {
+    const smali = `.class public final La0/n;
+.super Landroid/view/View;
+.source "SourceFile"
+
+# direct methods
+.method public static constructor <clinit>()V
+    .registers 1
+
+    return-void
+.end method
+
+# virtual methods
+.method public final b(Lr/o;ZJIJFLa0/a;)V
+    .registers 21
+
+    invoke-virtual/range {v0 .. v6}, La0/n;->e(JIJF)V
+
+    return-void
+.end method
+`;
+    const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+        errorJoinMode: 'all',
     });
-}
+    t.truthy(actual);
+    t.is(actual.classData?.virtualMethods.length, 1);
+});

package/build/stringFromAsyncIterable.d.ts

@@ -0,0 +1 @@
+export declare function stringFromAsyncIterable(asyncIterable: AsyncIterable<string>): Promise<string>;

package/build/stringFromAsyncIterable.js

@@ -0,0 +1,7 @@
+export async function stringFromAsyncIterable(asyncIterable) {
+    let string = '';
+    for await (const chunk of asyncIterable) {
+        string += chunk;
+    }
+    return string;
+}

package/build/terminatedArrayParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createUnionParser } from './unionParser.js';
@@ -50,7 +50,7 @@ export const createTerminatedArrayParser = (elementParser, terminatorParser) =>
                     ], getParserName(elementParser, 'anonymousElement'), getParserName(terminatorParser, 'anonymousTerminator'));
                 }
                 catch (error) {
-                    if (!(error instanceof ParserParsingFailedError)) {
+                    if (!(isParserParsingFailedError(error))) {
                         throw error;
                     }
                 }
@@ -61,7 +61,7 @@ export const createTerminatedArrayParser = (elementParser, terminatorParser) =>
                 return [elements, terminatorValue];
             }
             catch (error) {
-                if (!(error instanceof ParserParsingFailedError)) {
+                if (!(isParserParsingFailedError(error))) {
                     throw error;
                 }
             }
@@ -88,7 +88,7 @@ export const createTerminatedArrayParserUnsafe = (elementParser, terminatorParse
                 return [elements, terminatorValue];
             }
             catch (error) {
-                if (!(error instanceof ParserParsingFailedError)) {
+                if (!(isParserParsingFailedError(error))) {
                     throw error;
                 }
             }

package/build/terminatedArrayParser.test.js

@@ -55,9 +55,9 @@ testProp.serial('terminatedArrayParser', [
     })
         .map(string => ({
         string,
-        terminator: string.slice(0 - terminatorLength)
+        terminator: string.slice(0 - terminatorLength),
     }))
-        .filter(({ string, terminator }) => string.split(terminator).length === 2)))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2))),
 ], async (t, { string, terminator }) => {
     const terminatedArrayParserNaive = createTerminatedArrayParserNaive(promiseCompose(createTupleParser([
         createNegativeLookaheadParser(createExactSequenceParser(terminator)),
@@ -76,9 +76,9 @@ testProp.serial('terminatedArrayParser', [
             position: parserContext.position,
         };
     };
-    const actualNaive = await naiveTotalTimer.measureAsync(() => runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion));
+    const actualNaive = await naiveTotalTimer.measureAsync(async () => runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion));
     t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
-    const actual = await optimizedTotalTimer.measureAsync(() => runParser(createTestWrapperParser(terminatedArrayParser), string, stringParserInputCompanion));
+    const actual = await optimizedTotalTimer.measureAsync(async () => runParser(createTestWrapperParser(terminatedArrayParser), string, stringParserInputCompanion));
     t.deepEqual(actual, actualNaive);
 }, {
     verbose: true,
@@ -98,9 +98,9 @@ testProp.serial('terminatedArrayParserUnsafe', [
     })
         .map(string => ({
         string,
-        terminator: string.slice(0 - terminatorLength)
+        terminator: string.slice(0 - terminatorLength),
     }))
-        .filter(({ string, terminator }) => string.split(terminator).length === 2)))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2))),
 ], async (t, { string, terminator }) => {
     const terminatedArrayParserNaive = createTerminatedArrayParserNaive(promiseCompose(createTupleParser([
         createNegativeLookaheadParser(createExactSequenceParser(terminator)),
@@ -121,7 +121,7 @@ testProp.serial('terminatedArrayParserUnsafe', [
     };
     const actualNaive = await runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion);
     t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
-    const actual = await unsafeTotalTimer.measureAsync(() => runParser(createTestWrapperParser(terminatedArrayParserUnsafe), string, stringParserInputCompanion));
+    const actual = await unsafeTotalTimer.measureAsync(async () => runParser(createTestWrapperParser(terminatedArrayParserUnsafe), string, stringParserInputCompanion));
     t.deepEqual(actual, actualNaive);
 }, {
     verbose: true,

package/build/toAsyncIterator.js

@@ -1,12 +1,12 @@
-import invariant from "invariant";
+import invariant from 'invariant';
 function isAsyncIterable(value) {
-    return value && typeof value[Symbol.asyncIterator] === 'function';
+    return typeof value === 'object' && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === 'function';
 }
 function isIterable(value) {
-    return value && typeof value[Symbol.iterator] === 'function';
+    return typeof value === 'object' && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === 'function';
 }
 function isIterator(value) {
-    return value && typeof value.next === 'function';
+    return typeof value === 'object' && value !== null && 'next' in value && typeof value.next === 'function';
 }
 function iteratorToAsyncIterator(iterator) {
     return {

package/build/unionParser.d.ts

@@ -1,3 +1,3 @@
 import { type Parser } from './parser.js';
-import { DeriveSequenceElement } from './sequence.js';
+import { type DeriveSequenceElement } from './sequence.js';
 export declare const createUnionParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Array<Parser<unknown, Sequence, Element>>) => Parser<Output, Sequence, Element>;

package/build/unionParser.js

@@ -1,6 +1,6 @@
 import { allSettledStream } from './allSettledStream.js';
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 const bigintReplacer = (_key, value) => {
     if (typeof value === 'bigint') {
@@ -41,7 +41,7 @@ export const createUnionParser = (childParsers) => {
             }
             else {
                 const error = childParserResult.reason;
-                if (error instanceof ParserParsingFailedError) {
+                if (isParserParsingFailedError(error)) {
                     parserParsingFailedErrors.push(error);
                 }
                 else {

package/build/unionParser.test.js

@@ -5,7 +5,6 @@ import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createArrayParser } from './arrayParser.js';
 import { createExactElementParser } from './exactElementParser.js';
 import { createExactSequenceParser } from './exactSequenceParser.js';
-import { ParserError } from './parserError.js';
 test('union of union of union', async (t) => {
     const parser = createUnionParser([
         createExactElementParser('a'),
@@ -42,7 +41,7 @@ test('sync and async child parsers', async (t) => {
     const result = await runParser(parser, 'a?c?', stringParserInputCompanion, {
         errorJoinMode: 'all',
     });
-    t.deepEqual(result, 'aBcD'.split(''));
+    t.deepEqual(result, [...'aBcD']);
 });
 test('multiple parsers succeeded error', async (t) => {
     const parser = createUnionParser([
@@ -52,7 +51,8 @@ test('multiple parsers succeeded error', async (t) => {
     const error = await t.throwsAsync(runParser(parser, 'foo', stringParserInputCompanion, {
         errorJoinMode: 'all',
     }), {
-        instanceOf: ParserError,
+        any: true,
+        name: 'ParserImplementationInvariantError',
     });
     t.true(error.message.includes('foo'));
     t.true(error.message.includes('foo1'));

package/build/unparser.d.ts

@@ -1,6 +1,6 @@
-import { DeriveSequenceElement } from "./sequence.js";
-import { UnparserContext, WriteEarlier, WriteLater } from "./unparserContext.js";
-import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
+import { type DeriveSequenceElement } from './sequence.js';
+import { type UnparserContext, WriteEarlier, WriteLater } from './unparserContext.js';
+import { type UnparserOutputCompanion } from './unparserOutputCompanion.js';
 type UnparserIterableValue<Sequence, Element> = Sequence | Element | WriteLater<Sequence, Element> | WriteEarlier<Sequence, Element>;
 export type UnparserResult<Sequence, Element> = AsyncIterable<UnparserIterableValue<Sequence, Element>>;
 export type Unparser<Input, Sequence, Element = DeriveSequenceElement<Sequence>> = (input: Input, unparserContext: UnparserContext<Sequence, Element>) => UnparserResult<Sequence, Element>;

package/build/unparser.js

@@ -1,6 +1,6 @@
-import invariant from "invariant";
-import { UnparserContextImplementation, WriteEarlier, WriteLater } from "./unparserContext.js";
-import { unparserImplementationInvariant } from "./unparserImplementationInvariant.js";
+import invariant from 'invariant';
+import { UnparserContextImplementation, WriteEarlier, WriteLater, } from './unparserContext.js';
+import { unparserImplementationInvariant } from './unparserImplementationInvariant.js';
 async function* onYield(asyncIterable, onYield) {
     for await (const value of asyncIterable) {
         onYield(value);
@@ -40,7 +40,9 @@ async function* elementsToSequences(values, unparserOutputCompanion) {
     }
 }
 function wrapUnparserResult(unparserResult, unparserContext, unparserOutputCompanion) {
-    return onYield(elementsToSequences(unparserResult, unparserOutputCompanion), value => unparserContext.handleYield(value));
+    return onYield(elementsToSequences(unparserResult, unparserOutputCompanion), value => {
+        unparserContext.handleYield(value);
+    });
 }
 export async function* runUnparser(unparser, input, unparserOutputCompanion) {
     const unparserContext = new UnparserContextImplementation(unparserOutputCompanion);