@futpib/parser 1.0.3 → 1.0.6

package/src/javaScript.ts

@@ -0,0 +1,36 @@
+import type * as estree from 'estree';
+import { type StripMeta } from './javaScriptParser.js';
+
+export type JavaScriptProgram = StripMeta<estree.Program>;
+export type JavaScriptStatement = StripMeta<estree.Statement>;
+export type JavaScriptExpression = StripMeta<estree.Expression>;
+export type JavaScriptIdentifier = StripMeta<estree.Identifier>;
+export type JavaScriptLiteral = StripMeta<estree.Literal>;
+export type JavaScriptBlockStatement = StripMeta<estree.BlockStatement>;
+export type JavaScriptExpressionStatement = StripMeta<estree.ExpressionStatement>;
+export type JavaScriptVariableDeclaration = StripMeta<estree.VariableDeclaration>;
+export type JavaScriptVariableDeclarator = StripMeta<estree.VariableDeclarator>;
+export type JavaScriptIfStatement = StripMeta<estree.IfStatement>;
+export type JavaScriptWhileStatement = StripMeta<estree.WhileStatement>;
+export type JavaScriptForStatement = StripMeta<estree.ForStatement>;
+export type JavaScriptReturnStatement = StripMeta<estree.ReturnStatement>;
+export type JavaScriptThrowStatement = StripMeta<estree.ThrowStatement>;
+export type JavaScriptTryStatement = StripMeta<estree.TryStatement>;
+export type JavaScriptCatchClause = StripMeta<estree.CatchClause>;
+export type JavaScriptEmptyStatement = StripMeta<estree.EmptyStatement>;
+export type JavaScriptFunctionDeclaration = StripMeta<estree.FunctionDeclaration>;
+export type JavaScriptFunctionExpression = StripMeta<estree.FunctionExpression>;
+export type JavaScriptArrowFunctionExpression = StripMeta<estree.ArrowFunctionExpression>;
+export type JavaScriptBinaryExpression = StripMeta<estree.BinaryExpression>;
+export type JavaScriptLogicalExpression = StripMeta<estree.LogicalExpression>;
+export type JavaScriptUnaryExpression = StripMeta<estree.UnaryExpression>;
+export type JavaScriptUpdateExpression = StripMeta<estree.UpdateExpression>;
+export type JavaScriptAssignmentExpression = StripMeta<estree.AssignmentExpression>;
+export type JavaScriptConditionalExpression = StripMeta<estree.ConditionalExpression>;
+export type JavaScriptCallExpression = StripMeta<estree.SimpleCallExpression>;
+export type JavaScriptNewExpression = StripMeta<estree.NewExpression>;
+export type JavaScriptMemberExpression = StripMeta<estree.MemberExpression>;
+export type JavaScriptArrayExpression = StripMeta<estree.ArrayExpression>;
+export type JavaScriptObjectExpression = StripMeta<estree.ObjectExpression>;
+export type JavaScriptProperty = StripMeta<estree.Property>;
+export type JavaScriptThisExpression = StripMeta<estree.ThisExpression>;

package/src/javaScriptParser.ts

@@ -0,0 +1,57 @@
+import type * as estree from 'estree';
+import * as acorn from 'acorn';
+import { type Parser } from './parser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createRegExpParser } from './regexpParser.js';
+
+type PositionalFields = 'loc' | 'range' | 'start' | 'end' | 'leadingComments' | 'trailingComments' | 'comments' | 'innerComments';
+
+export type StripMeta<T> =
+	T extends Array<infer U> ? Array<StripMeta<U>> :
+		T extends object ? { [K in Exclude<keyof T, PositionalFields>]: StripMeta<T[K]> } :
+			T;
+
+export type JavaScriptProgram = StripMeta<estree.Program>;
+
+function stripMeta(node: unknown): unknown {
+	if (node === null || node === undefined) {
+		return node;
+	}
+
+	if (typeof node !== 'object') {
+		return node;
+	}
+
+	if (Array.isArray(node)) {
+		return node.map(element => stripMeta(element));
+	}
+
+	const result: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (
+			key === 'loc'
+			|| key === 'range'
+			|| key === 'start'
+			|| key === 'end'
+			|| key === 'raw'
+			|| key === 'leadingComments'
+			|| key === 'trailingComments'
+			|| key === 'comments'
+			|| key === 'innerComments'
+		) {
+			continue;
+		}
+
+		result[key] = stripMeta(value);
+	}
+
+	return result;
+}
+
+export const javaScriptProgramParser: Parser<JavaScriptProgram, string> = promiseCompose(
+	createRegExpParser(/[\s\S]*/),
+	match => {
+		const ast = acorn.parse(match[0], { ecmaVersion: 'latest', sourceType: 'script' });
+		return stripMeta(ast) as JavaScriptProgram;
+	},
+);

package/src/javaScriptUnparser.test.ts

@@ -0,0 +1,37 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryJavaScriptProgram } from './arbitraryJavaScript.js';
+import { javaScriptProgramUnparser } from './javaScriptUnparser.js';
+import { javaScriptProgramParser } from './javaScriptParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+
+async function collectString(asyncIterable: AsyncIterable<string>): Promise<string> {
+	let result = '';
+	for await (const chunk of asyncIterable) {
+		result += chunk;
+	}
+
+	return result;
+}
+
+testProp(
+	'javaScript roundtrip',
+	[arbitraryJavaScriptProgram],
+	async (t, program) => {
+		const source = await collectString(runUnparser(
+			javaScriptProgramUnparser, program, stringUnparserOutputCompanion));
+
+		const reparsed = await runParser(
+			javaScriptProgramParser, source, stringParserInputCompanion);
+
+		t.deepEqual(reparsed, program);
+	},
+	{
+		verbose: true,
+		seed,
+	},
+);

package/src/javaScriptUnparser.ts

@@ -0,0 +1,7 @@
+import { generate } from 'astring';
+import { type Unparser } from './unparser.js';
+import { type JavaScriptProgram } from './javaScriptParser.js';
+
+export const javaScriptProgramUnparser: Unparser<JavaScriptProgram, string> = async function * (program) {
+	yield generate(program);
+};

package/src/javaUnparser.test.ts

@@ -0,0 +1,37 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryJavaCompilationUnit } from './arbitraryJava.js';
+import { javaCompilationUnitUnparser } from './javaUnparser.js';
+import { javaCompilationUnitParser } from './javaParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+
+async function collectString(asyncIterable: AsyncIterable<string>): Promise<string> {
+	let result = '';
+	for await (const chunk of asyncIterable) {
+		result += chunk;
+	}
+
+	return result;
+}
+
+testProp(
+	'javaUnparser roundtrip',
+	[arbitraryJavaCompilationUnit],
+	async (t, compilationUnit) => {
+		const source = await collectString(runUnparser(
+			javaCompilationUnitUnparser, compilationUnit, stringUnparserOutputCompanion));
+
+		const reparsed = await runParser(
+			javaCompilationUnitParser, source, stringParserInputCompanion);
+
+		t.deepEqual(reparsed, compilationUnit);
+	},
+	{
+		verbose: true,
+		seed,
+	},
+);