@futpib/parser 1.0.4 → 1.0.6

package/src/parserContext.ts

@@ -36,6 +36,8 @@ export type ParserContext<Sequence, Element> = {
 	equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
 
 	get position(): number;
+	get furthestReadPosition(): number;
+	get furthestPeekedPosition(): number;
 	peek(offset: number): Promise<Element | undefined>;
 	peekSequence(start: number, end: number): Promise<Sequence | undefined>;
 	skip(offset: number): void;
@@ -46,6 +48,7 @@ export type ParserContext<Sequence, Element> = {
 	lookahead(options?: LookaheadOptions): ParserContext<Sequence, Element>;
 	unlookahead(): void;
 	dispose(): void;
+	[Symbol.dispose](): void;
 
 	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
 	invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
@@ -117,6 +120,14 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._inputReader.position;
 	}
 
+	get furthestReadPosition() {
+		return this._inputReader.furthestReadPosition;
+	}
+
+	get furthestPeekedPosition() {
+		return this._inputReader.furthestPeekedPosition;
+	}
+
 	async peek(offset: number): Promise<Element | undefined> {
 		if (
 			this._options.sliceEnd !== undefined
@@ -169,7 +180,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		const element = await this.peek(offset);
 
 		if (element === undefined) {
-			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
+			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position, this._inputReader.furthestReadPosition, this._inputReader.furthestPeekedPosition);
 		}
 
 		this.skip(offset + 1);
@@ -181,7 +192,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		const sequence = await this.peekSequence(start, end);
 
 		if (sequence === undefined) {
-			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
+			throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position, this._inputReader.furthestReadPosition, this._inputReader.furthestPeekedPosition);
 		}
 
 		this.skip(end);
@@ -300,11 +311,15 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		this._parentParserContext = undefined;
 	}
 
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+
 	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy> {
 		const parserContext = this;
 
 		return customInvariant(function (lazyMessage: LazyMessage) {
-			return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position);
+			return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition);
 		}, value, format, ...formatArguments);
 	}
 
@@ -316,22 +331,22 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 		if (errorJoinMode === 'none') {
 			return customInvariant(function (lazyMessage: LazyMessage) {
-				return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position);
+				return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition);
 			}, value, format, ...formatArguments);
 		}
 
 		if (errorJoinMode === 'furthest') {
 			return customInvariant(function (userLazyMessage: LazyMessage) {
-				let furthestPosition = 0;
+				let furthestChildErrorPosition = 0;
 				let furthestChildErrors: ParserParsingFailedError[] = [];
 
 				for (const childError of childErrors) {
-					if (childError.position < furthestPosition) {
+					if (childError.position < furthestChildErrorPosition) {
 						continue;
 					}
 
-					if (childError.position > furthestPosition) {
-						furthestPosition = childError.position;
+					if (childError.position > furthestChildErrorPosition) {
+						furthestChildErrorPosition = childError.position;
 						furthestChildErrors = [ childError ];
 						continue;
 					}
@@ -354,7 +369,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 						return furthestChildError.stack?.split('\n').map(line => '  ' + line);
 					}).join('\n'),
-				], parserContext._depth, furthestPosition, furthestChildErrors);
+				], parserContext._depth, furthestChildErrorPosition, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, furthestChildErrors);
 			}, value, format, ...formatArguments);
 		}
 
@@ -396,7 +411,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 						return deepestChildError.stack?.split('\n').map(line => '  ' + line);
 					}).join('\n'),
-				], deepestDepth, parserContext.position, deepestChildErrors);
+				], deepestDepth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, deepestChildErrors);
 			}, value, format, ...formatArguments);
 		}
 
@@ -417,7 +432,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 
 						return childError.stack?.split('\n').map(line => '  ' + line);
 					}).join('\n'),
-				], parserContext._depth, parserContext.position, childErrors);
+				], parserContext._depth, parserContext.position, parserContext._inputReader.furthestReadPosition, parserContext._inputReader.furthestPeekedPosition, childErrors);
 			}, value, format, ...formatArguments);
 		}
 

package/src/parserError.ts

@@ -23,6 +23,8 @@ type ParserErrorInterface = ParserError;
 export interface ParserParsingFailedError extends ParserErrorInterface {
 	depth: number;
 	position: number;
+	furthestReadPosition: number;
+	furthestPeekedPosition: number;
 }
 
 export function isParserParsingFailedError(value: unknown): value is ParserParsingFailedError {
@@ -34,6 +36,10 @@ export function isParserParsingFailedError(value: unknown): value is ParserParsi
 			&& typeof value.depth === 'number'
 			&& 'position' in value
 			&& typeof value.position === 'number'
+			&& 'furthestReadPosition' in value
+			&& typeof value.furthestReadPosition === 'number'
+			&& 'furthestPeekedPosition' in value
+			&& typeof value.furthestPeekedPosition === 'number'
 	);
 }
 
@@ -80,6 +86,8 @@ function createParserErrorModule(
 			message: LazyMessage,
 			public readonly depth: number,
 			public readonly position: number,
+			public readonly furthestReadPosition: number,
+			public readonly furthestPeekedPosition: number,
 		) {
 			super(message);
 		}
@@ -102,9 +110,11 @@ function createParserErrorModule(
 			message: LazyMessage,
 			depth: number,
 			position: number,
+			furthestReadPosition: number,
+			furthestPeekedPosition: number,
 			public readonly childErrors: ParserParsingFailedErrorInterface[],
 		) {
-			super(message, depth, position);
+			super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
 		}
 	}
 
@@ -115,9 +125,11 @@ function createParserErrorModule(
 			message: LazyMessage,
 			depth: number,
 			position: number,
+			furthestReadPosition: number,
+			furthestPeekedPosition: number,
 			public readonly childErrors: ParserParsingFailedErrorInterface[],
 		) {
-			super(message, depth, position);
+			super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
 		}
 	}
 
@@ -128,9 +140,11 @@ function createParserErrorModule(
 			message: LazyMessage,
 			depth: number,
 			position: number,
+			furthestReadPosition: number,
+			furthestPeekedPosition: number,
 			public readonly childErrors: ParserParsingFailedErrorInterface[],
 		) {
-			super(message, depth, position);
+			super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
 		}
 	}
 

package/src/regexpParser.test.ts

@@ -184,3 +184,81 @@ test('regexpParser with negative lookahead should match single char', async t =>
 	t.is(position, 1); // Consumed 1 character
 	t.truthy(remainingInput); // There's remaining input (the space)
 });
+
+test('regexpParser should match exact 6-character input', async t => {
+	const regexpParser = createRegExpParser(/abcdef/);
+
+	const result = await runParser(
+		regexpParser,
+		'abcdef',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], 'abcdef');
+});
+
+test('regexpParser should match quoted string of length 6', async t => {
+	const regexpParser = createRegExpParser(/"[^"]*"/);
+
+	const result = await runParser(
+		regexpParser,
+		'"abcd"', // 6 characters total
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '"abcd"');
+});
+
+// Property-based tests for fixed-length patterns
+
+testProp(
+	'regexpParser should match exact n-character input for any length',
+	[fc.integer({ min: 1, max: 20 })],
+	async (t, length) => {
+		const input = 'a'.repeat(length);
+		const regex = new RegExp(`a{${length}}`);
+		const regexpParser = createRegExpParser(regex);
+
+		const result = await runParser(
+			regexpParser,
+			input,
+			stringParserInputCompanion,
+		);
+
+		t.is(result[0], input);
+	},
+);
+
+testProp(
+	'regexpParser should match quoted strings of any length',
+	[fc.integer({ min: 0, max: 20 })],
+	async (t, contentLength) => {
+		const content = 'x'.repeat(contentLength);
+		const input = `"${content}"`;
+		const regexpParser = createRegExpParser(/"[^"]*"/);
+
+		const result = await runParser(
+			regexpParser,
+			input,
+			stringParserInputCompanion,
+		);
+
+		t.is(result[0], input);
+	},
+);
+
+testProp(
+	'regexpParser greedy patterns should match any length input',
+	[fc.stringMatching(/^[a-z]+$/).filter(s => s.length > 0 && s.length <= 20)],
+	async (t, input) => {
+		const regexpParser = createRegExpParser(/[a-z]+/);
+
+		const result = await runParser(
+			regexpParser,
+			input,
+			stringParserInputCompanion,
+		);
+
+		t.is(result[0], input);
+	},
+);

package/src/regexpParser.ts

@@ -8,17 +8,49 @@ export const createRegExpParser = (
 		let window = 1;
 		let lastMatch: RegExpExecArray | undefined;
 		let reachedEndOfInput = false;
+		let inputLength: number | undefined;
 
 		while (true) {
 			const sequence = await parserContext.peekSequence(start, start + window);
 
 			if (sequence === undefined) {
-				reachedEndOfInput = true;
+				if (!reachedEndOfInput) {
+					reachedEndOfInput = true;
+
+					// Binary search to find actual input length
+					// We know: length >= start (we've peeked successfully before)
+					// We know: length < start + window (current peek failed)
+					let lo = start;
+					let hi = start + window;
+					while (hi - lo > 1) {
+						const mid = (lo + hi) >> 1;
+						const probe = await parserContext.peekSequence(0, mid);
+						if (probe !== undefined) {
+							lo = mid;
+						} else {
+							hi = mid;
+						}
+					}
+					inputLength = lo;
+
+					// Try matching against the full input
+					if (inputLength > 0) {
+						const fullInput = await parserContext.peekSequence(0, inputLength);
+						if (fullInput !== undefined) {
+							const match = regexp.exec(fullInput);
+							if (match !== null && match.index === 0) {
+								parserContext.skip(match[0].length);
+								return match;
+							}
+						}
+					}
+				}
+
 				window = Math.floor(window / 2);
 
 				if (window === 0) {
 					// Get the full sequence we've accumulated to verify matches
-					const fullSequence = await parserContext.peekSequence(0, start);
+					const fullSequence = await parserContext.peekSequence(0, inputLength ?? start);
 
 					// Verify any previous match is still valid with full context
 					// For lookahead/lookbehind assertions, additional input might invalidate a match
@@ -46,7 +78,7 @@ export const createRegExpParser = (
 				continue;
 			}
 
-			const fullSequence = await parserContext.peekSequence(0, start + window);
+			const fullSequence = await parserContext.peekSequence(0, inputLength ?? start + window);
 
 			if (fullSequence === undefined) {
 				continue;

package/src/regularExpressionParser.ts

@@ -12,6 +12,7 @@ import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js'
 import { createTerminatedArrayParser } from './terminatedArrayParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createObjectParser } from './objectParser.js';
 import {
 	type CharacterSet,
 	type CodePointRange,
@@ -648,20 +649,20 @@ type Quantifier =
 	| { type: 'optional' }
 	| { type: 'repeat'; bounds: RepeatBounds };
 
-const starQuantifierParser: Parser<Quantifier, string> = promiseCompose(
-	createExactSequenceParser('*'),
-	() => ({ type: 'star' as const }),
-);
+const starQuantifierParser: Parser<Quantifier, string> = createObjectParser({
+	type: 'star' as const,
+	_marker: createExactSequenceParser('*'),
+});
 
-const plusQuantifierParser: Parser<Quantifier, string> = promiseCompose(
-	createExactSequenceParser('+'),
-	() => ({ type: 'plus' as const }),
-);
+const plusQuantifierParser: Parser<Quantifier, string> = createObjectParser({
+	type: 'plus' as const,
+	_marker: createExactSequenceParser('+'),
+});
 
-const optionalQuantifierParser: Parser<Quantifier, string> = promiseCompose(
-	createExactSequenceParser('?'),
-	() => ({ type: 'optional' as const }),
-);
+const optionalQuantifierParser: Parser<Quantifier, string> = createObjectParser({
+	type: 'optional' as const,
+	_marker: createExactSequenceParser('?'),
+});
 
 // Parse a number for quantifiers
 const numberParser: Parser<number, string> = parserCreatorCompose(
@@ -759,24 +760,22 @@ const nonCaptureGroupParser: Parser<RegularExpression, string> = promiseCompose(
 type LookaheadMarker = { type: 'lookahead-marker'; isPositive: boolean; inner: RegularExpression };
 
 // Positive lookahead (?=...)
-const positiveLookaheadMarkerParser: Parser<LookaheadMarker, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('(?='),
-		createParserAccessorParser(() => alternationParser),
-		createExactSequenceParser(')'),
-	]),
-	([, inner]) => ({ type: 'lookahead-marker' as const, isPositive: true, inner }),
-);
+const positiveLookaheadMarkerParser: Parser<LookaheadMarker, string> = createObjectParser({
+	type: 'lookahead-marker' as const,
+	isPositive: true as const,
+	_open: createExactSequenceParser('(?='),
+	inner: createParserAccessorParser(() => alternationParser),
+	_close: createExactSequenceParser(')'),
+});
 
 // Negative lookahead (?!...)
-const negativeLookaheadMarkerParser: Parser<LookaheadMarker, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('(?!'),
-		createParserAccessorParser(() => alternationParser),
-		createExactSequenceParser(')'),
-	]),
-	([, inner]) => ({ type: 'lookahead-marker' as const, isPositive: false, inner }),
-);
+const negativeLookaheadMarkerParser: Parser<LookaheadMarker, string> = createObjectParser({
+	type: 'lookahead-marker' as const,
+	isPositive: false as const,
+	_open: createExactSequenceParser('(?!'),
+	inner: createParserAccessorParser(() => alternationParser),
+	_close: createExactSequenceParser(')'),
+});
 
 const groupParser: Parser<RegularExpression, string> = createUnionParser([
 	namedCaptureGroupParser,
@@ -789,15 +788,15 @@ const groupParser: Parser<RegularExpression, string> = createUnionParser([
 type AnchorMarker = { type: 'start-anchor-marker' } | { type: 'end-anchor-marker' };
 type ParsedElement = RegularExpression | AnchorMarker | LookaheadMarker;
 
-const startAnchorMarkerParser: Parser<AnchorMarker, string> = promiseCompose(
-	createExactSequenceParser('^'),
-	() => ({ type: 'start-anchor-marker' as const }),
-);
+const startAnchorMarkerParser: Parser<AnchorMarker, string> = createObjectParser({
+	type: 'start-anchor-marker' as const,
+	_marker: createExactSequenceParser('^'),
+});
 
-const endAnchorMarkerParser: Parser<AnchorMarker, string> = promiseCompose(
-	createExactSequenceParser('$'),
-	() => ({ type: 'end-anchor-marker' as const }),
-);
+const endAnchorMarkerParser: Parser<AnchorMarker, string> = createObjectParser({
+	type: 'end-anchor-marker' as const,
+	_marker: createExactSequenceParser('$'),
+});
 
 // Atom: the basic unit that can be quantified (excluding anchors)
 const atomParser: Parser<RegularExpression, string> = createUnionParser([
@@ -832,7 +831,7 @@ const quantifiedParser: Parser<RegularExpression, string> = promiseCompose(
 );
 
 // Element in a sequence: either a quantified atom, anchor marker, or lookahead marker
-const sequenceElementParser: Parser<ParsedElement, string> = createUnionParser<ParsedElement, string>([
+const sequenceElementParser: Parser<ParsedElement, string> = createUnionParser([
 	startAnchorMarkerParser,
 	endAnchorMarkerParser,
 	positiveLookaheadMarkerParser,

package/src/separatedArrayParser.ts

@@ -21,7 +21,7 @@ export const createSeparatedArrayParser = <ElementOutput, Sequence>(
 		const elements: ElementOutput[] = [];
 
 		while (true) {
-			const elementParserContext = parserContext.lookahead();
+			using elementParserContext = parserContext.lookahead();
 			const initialPosition = elementParserContext.position;
 
 			try {
@@ -39,8 +39,6 @@ export const createSeparatedArrayParser = <ElementOutput, Sequence>(
 				}
 
 				throw error;
-			} finally {
-				elementParserContext.dispose();
 			}
 
 			parser = separatorThenElementParser;

package/src/separatedNonEmptyArrayParser.ts

@@ -21,7 +21,7 @@ export const createSeparatedNonEmptyArrayParser = <ElementOutput, Sequence>(
 		const elements: ElementOutput[] = [];
 
 		while (true) {
-			const elementParserContext = parserContext.lookahead();
+			using elementParserContext = parserContext.lookahead();
 			const initialPosition = elementParserContext.position;
 
 			try {
@@ -39,8 +39,6 @@ export const createSeparatedNonEmptyArrayParser = <ElementOutput, Sequence>(
 				}
 
 				throw error;
-			} finally {
-				elementParserContext.dispose();
 			}
 
 			parser = separatorThenElementParser;

package/src/sliceBoundedParser.test.ts

@@ -32,7 +32,7 @@ test('sliceBoundedParser', async t => {
 test('sliceBoundedParser mustConsumeAll: true fail to cosume all', async t => {
 	const parser = createTupleParser([
 		createElementParser<string>(),
-		createSliceBoundedParser(createArrayParser(createExactElementParser('b' as string)), 2),
+		createSliceBoundedParser(createArrayParser(createExactElementParser<string>('b')), 2),
 		createElementParser(),
 	]);
 
@@ -45,7 +45,7 @@ test('sliceBoundedParser mustConsumeAll: true fail to cosume all', async t => {
 test('sliceBoundedParser mustConsumeAll: false', async t => {
 	const parser = createTupleParser([
 		createElementParser<string>(),
-		createSliceBoundedParser(createArrayParser(createExactElementParser('b' as string)), 2, false),
+		createSliceBoundedParser(createArrayParser(createExactElementParser<string>('b')), 2, false),
 		createElementParser(),
 	]);
 

package/src/sliceBoundedParser.ts

@@ -8,30 +8,26 @@ export const createSliceBoundedParser = <Output, Sequence>(
 	const sliceBoundedParser: typeof childParser = async parserContext => {
 		const absoluteSliceEnd = parserContext.position + sliceEnd;
 
-		const childParserContext = parserContext.lookahead({
+		using childParserContext = parserContext.lookahead({
 			sliceEnd: absoluteSliceEnd,
 		});
 
-		try {
-			const value = await childParser(childParserContext);
+		const value = await childParser(childParserContext);
 
-			childParserContext.invariant(
-				(
-					!mustConsumeAll
-					|| childParserContext.position === absoluteSliceEnd
-				),
-				'child parser must consume all input in the slice (%s in total, up to position %s), instead consumed %s up to position %s',
-				sliceEnd,
-				absoluteSliceEnd,
-				childParserContext.position - parserContext.position,
-				childParserContext.position,
-			);
+		childParserContext.invariant(
+			(
+				!mustConsumeAll
+				|| childParserContext.position === absoluteSliceEnd
+			),
+			'child parser must consume all input in the slice (%s in total, up to position %s), instead consumed %s up to position %s',
+			sliceEnd,
+			absoluteSliceEnd,
+			childParserContext.position - parserContext.position,
+			childParserContext.position,
+		);
 
-			childParserContext.unlookahead();
-			return value;
-		} finally {
-			childParserContext.dispose();
-		}
+		childParserContext.unlookahead();
+		return value;
 	};
 
 	setParserName(sliceBoundedParser, [

package/src/smaliParser.test.ts

@@ -441,3 +441,67 @@ test('parse smali with virtual method after direct methods (a0/n issue)', async
 	t.truthy(actual);
 	t.is(actual.classData?.virtualMethods.length, 1);
 });
+
+// Minimal failing test case for .end local directive
+test('parse smali with .end local directive', async t => {
+	const smali = `.class public Lpl/czak/minimal/MainActivity;
+.super Landroid/app/Activity;
+
+# direct methods
+.method private sumToN(I)I
+    .registers 4
+    .param p1, "n"    # I
+
+    const/4 v0, 0x0
+
+    .local v0, "sum":I
+    const/4 v1, 0x1
+
+    .local v1, "i":I
+    :goto_2
+    if-gt v1, p1, :cond_8
+
+    add-int/2addr v0, v1
+
+    add-int/lit8 v1, v1, 0x1
+
+    goto :goto_2
+
+    .end local v1    # "i":I
+    :cond_8
+    return v0
+.end method
+`;
+
+	const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+		errorJoinMode: 'all',
+	});
+
+	t.truthy(actual);
+	t.is(actual.classData?.directMethods.length, 1);
+});
+
+// Minimal test case for .local with generic type signature
+test('parse smali with .local directive with generic type signature', async t => {
+	const smali = `.class public Lpl/czak/minimal/MainActivity;
+.super Landroid/app/Activity;
+
+# direct methods
+.method private useLambda()Ljava/lang/String;
+    .registers 3
+
+    new-instance v0, Lpl/czak/minimal/MainActivity$$ExternalSyntheticLambda0;
+
+    .local v0, "supplier":Ljava/util/function/Supplier;, "Ljava/util/function/Supplier<Ljava/lang/String;>;"
+
+    return-object v0
+.end method
+`;
+
+	const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+		errorJoinMode: 'all',
+	});
+
+	t.truthy(actual);
+	t.is(actual.classData?.directMethods.length, 1);
+});