grammar-composer 0.6.0 → 0.6.2

package/src/parser/Grammar.ts

@@ -0,0 +1,194 @@
+import { Pattern, buildRegExp, inputStart, isPatternOptional } from 'regexp-composer'
+import { isArray } from '../utilities/Utilities.js'
+
+import { parse } from './Parser.js'
+import { validatePatternCaptureGroups } from './StaticAnalysis.js'
+import { productionToGrammarElement } from './Builder.js'
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Grammar class
+/////////////////////////////////////////////////////////////////////////////////////////////////
+export class Grammar<T> {
+	readonly productions: Record<keyof T, any>
+	readonly startProductionName: keyof T
+
+	readonly maxCacheId: number
+
+	constructor(
+		productions: Record<keyof T, any>,
+		startProductionName: keyof T,
+		maxCacheId: number) {
+
+		this.startProductionName = startProductionName
+		this.productions = productions
+		this.maxCacheId = maxCacheId
+	}
+
+	parse(text: string) {
+		return parse(text, this)
+	}
+
+	get rootElement() {
+		return this.productions[this.startProductionName]
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Exported grammar builder functions
+/////////////////////////////////////////////////////////////////////////////////////////////////
+export function zeroOrMore(content: Production): Repetition {
+	return {
+		type: 'Repetition',
+		content: productionToGrammarElement(content),
+		optional: true,
+		cached: false,
+	}
+}
+
+export function oneOrMore(content: Production): Repetition {
+	return {
+		type: 'Repetition',
+		content: productionToGrammarElement(content),
+		optional: false,
+		cached: false,
+	}
+}
+
+export function anyOf(...members: Production[]): Choice {
+	if (members.length === 0) {
+		throw new Error(`'anyOf' requires at least one member.`)
+	}
+
+	const normalizedMembers = members.map(member => productionToGrammarElement(member))
+
+	return {
+		type: 'Choice',
+		members: normalizedMembers,
+		optional: false,
+		exhaustive: false,
+		cached: false,
+	}
+}
+
+export function bestOf(...members: Production[]): Choice {
+	if (members.length === 0) {
+		throw new Error(`'bestOf' requires at least one member.`)
+	}
+
+	const normalizedMembers = members.map(member => productionToGrammarElement(member))
+
+	return {
+		type: 'Choice',
+		members: normalizedMembers,
+		optional: false,
+		exhaustive: true,
+
+		cached: false,
+	}
+}
+
+export function possibly<T extends Production>(content: Production): T {
+	return { ...productionToGrammarElement(content), optional: true } as T
+}
+
+export function pattern(pattern: Pattern): PatternTerminal {
+	if (isArray(pattern)) {
+		pattern = [inputStart, ...pattern]
+	} else {
+		pattern = [inputStart, pattern]
+	}
+
+	validatePatternCaptureGroups(pattern)
+
+	const regExp = buildRegExp(pattern)
+	const optional = isPatternOptional(pattern)
+
+	return {
+		type: 'PatternTerminal',
+		pattern,
+		regExp,
+		optional,
+
+		cached: false,
+	}
+}
+
+export function cached<T extends Production>(content: Production): T {
+	return { ...productionToGrammarElement(content), cached: true } as T
+}
+
+export function uncached<T extends Production>(content: Production): T {
+	return { ...productionToGrammarElement(content), cached: false } as T
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Type definitions
+/////////////////////////////////////////////////////////////////////////////////////////////////
+export type Production = string | GrammarElement | (() => Production) | Production[]
+
+export type GrammarElement =
+	StringTerminal |
+	PatternTerminal |
+	Nonterminal |
+	Sequence |
+	Repetition |
+	Choice |
+	NonterminalReference
+
+interface GrammarElementBase {
+	type: string
+	optional: boolean
+
+	cached: boolean
+	cacheId?: number
+
+	// The name of the grammar property this element was assigned to, if any.
+	// Used by the parser to refer to the element by name in error messages.
+	name?: string
+}
+
+export type Terminal = StringTerminal | PatternTerminal
+
+export interface StringTerminal extends GrammarElementBase {
+	type: 'StringTerminal'
+	content: string
+}
+
+export interface PatternTerminal extends GrammarElementBase {
+	type: 'PatternTerminal'
+	pattern: Pattern
+	regExp: RegExp
+}
+
+export interface Nonterminal extends GrammarElementBase {
+	type: 'Nonterminal'
+	name: string
+	content: GrammarElement
+	unwrapped: boolean
+
+	// The canonical nonterminal as defined in the grammar. Clones created for
+	// optional references and cached references keep a reference to the original,
+	// so identity comparisons work across clones.
+	grammarNonterminal?: Nonterminal
+}
+
+export interface Sequence extends GrammarElementBase {
+	type: 'Sequence'
+	members: GrammarElement[]
+}
+
+export interface Repetition extends GrammarElementBase {
+	type: 'Repetition'
+	content: GrammarElement
+}
+
+export interface Choice extends GrammarElementBase {
+	type: 'Choice'
+	members: GrammarElement[]
+	exhaustive: boolean
+}
+
+export interface NonterminalReference extends GrammarElementBase {
+	type: 'NonterminalReference'
+	reference: Function
+}

package/src/{parser-generator → parser}/ParseError.ts

@@ -122,21 +122,24 @@ export function analyzeFailedMatches(failedMatches: FailedMatch[]): FailedMatchA
 // A candidate is redundant when the same terminal is also expected by a deeper
 // production within the same context, i.e. when another candidate's production
 // appears below this candidate's production in its own stack.
+//
+// Compare within the other candidate's own stack: if there exists another
+// candidate `other` such that `candidate` is an ancestor of `other` in
+// `other`'s stack, keep only `other` (innermost).
 function isRedundantCandidate(candidate: TerminalCandidate, candidates: TerminalCandidate[]): boolean {
-	const candidateIndex = stackIndexOf(candidate.productionStack, candidate.production)
-
 	for (const other of candidates) {
 		if (other === candidate) {
 			continue
 		}
 
-		const otherIndex = stackIndexOf(candidate.productionStack, other.production)
+		const candidateIndexInOther = stackIndexOf(other.productionStack, candidate.production)
+
+		const otherIndexInOther = stackIndexOf(other.productionStack, other.production)
 
-		if (otherIndex > candidateIndex) {
+		if (candidateIndexInOther !== -1 && otherIndexInOther !== -1 && otherIndexInOther > candidateIndexInOther) {
 			return true
 		}
 	}
-
 	return false
 }
 
@@ -148,6 +151,26 @@ function stackIndexOf(productionStack: Nonterminal[], production: Nonterminal):
 	return productionStack.findIndex(nonterminal => (nonterminal.grammarNonterminal ?? nonterminal) === canonical)
 }
 
+function areTerminalsEqual(a: any, b: any): boolean {
+	if (a === b) {
+		return true
+	}
+
+	if (a?.type !== b?.type) {
+		return false
+	}
+
+	if (a.type === 'StringTerminal') {
+		return a.content === b.content
+	}
+
+	if (a.type === 'PatternTerminal') {
+		return a.regExp.source === b.regExp.source && a.regExp.flags === b.regExp.flags
+	}
+
+	return false
+}
+
 function stringifyFailedTerminal(failedMatch: FailedMatch): string {
 	const { terminal, productionStack } = failedMatch
 
@@ -155,10 +178,18 @@ function stringifyFailedTerminal(failedMatch: FailedMatch): string {
 		return terminal.name
 	}
 
-	const innermostProduction = productionStack[productionStack.length - 1]
-
-	if (innermostProduction !== undefined && innermostProduction.content === terminal) {
-		return innermostProduction.name
+	// Compare terminals by structural identity: PatternTerminals are
+	// reconstructed objects, StringTerminals are cloned, so object
+	// identity vs innermostProduction.content is not reliable.
+	//
+	// Instead check if the failed terminal equals the content of any
+	// production in the stack by value.
+	for (let i = productionStack.length - 1; i >= 0; i--) {
+		const production = productionStack[i]
+
+		if (areTerminalsEqual(production.content, terminal)) {
+			return production.name
+		}
 	}
 
 	const stringifiedLengthLimit = 100
@@ -176,7 +207,7 @@ function stringifyFailedTerminal(failedMatch: FailedMatch): string {
 // during a single parse: the grammar builder creates spread copies of the canonical
 // nonterminal for optional references and for references wrapped in cached(). Each clone
 // keeps a reference to the original in 'grammarNonterminal'.
-export function findCommonProductionPrefix(productionStacks: Nonterminal[][]): Nonterminal[] {
+function findCommonProductionPrefix(productionStacks: Nonterminal[][]): Nonterminal[] {
 	if (productionStacks.length === 0) {
 		return []
 	}
@@ -251,7 +282,7 @@ function buildExpectedGroupsMessage(expected: readonly ExpectedTerminal[]): stri
 		.join('\n\n')
 }
 
-export function formatErrorContext(input: string, offset: number, maxDisplayedLineLength: number): string {
+function formatErrorContext(input: string, offset: number, maxDisplayedLineLength: number): string {
 	const { line, column } = getLineAndColumn(input, offset)
 
 	let lineStartOffset = offset

package/src/{parser-generator/TopDownParser.ts → parser/Parser.ts}

@@ -5,7 +5,7 @@ import { type FailedMatch, ParseError } from './ParseError.js'
 //////////////////////////////////////////////////////////////////////////////////////////////
 // Main parser function
 //////////////////////////////////////////////////////////////////////////////////////////////
-export function parse(inputString: string, grammar: Grammar<any>, options?: TopDownParserOptions) {
+export function parse(inputString: string, grammar: Grammar<any>, options?: ParserOptions) {
 	options = { ...options }
 
 	const inputLength = inputString.length
@@ -15,7 +15,7 @@ export function parse(inputString: string, grammar: Grammar<any>, options?: TopD
 	let bestFailedMatches: FailedMatch[] = []
 	let bestFailedMatchesOffset = -1
 
-	const cacheKeyOffsetMultiplier = grammar.maxCacheId + 1
+	const cacheKeyOffsetMultiplier = grammar.maxCacheId > 0 ? grammar.maxCacheId + 1 : 1
 	const parseResultsCache = new Map<number, ParseResult | null>()
 
 	function updateBestFailedMatchesIfNeeded(terminal: Terminal, startOffset: number) {
@@ -58,6 +58,21 @@ export function parse(inputString: string, grammar: Grammar<any>, options?: TopD
 	}
 
 	function tryParseUncached(grammarElement: GrammarElement, startOffset: number): ParseResult | null {
+		const result = tryParseElement(grammarElement, startOffset)
+
+		if (result === null && grammarElement.optional === true) {
+			// An optional element that doesn't match is "skipped": it succeeds
+			// by consuming no input and producing no nodes. This uniformly
+			// implements the `possibly()` "or skip" semantics wherever the
+			// element appears (sequence members, repetition content, choice
+			// members, or as the content of a production itself).
+			return { endOffset: startOffset, nodes: undefined, skipped: true }
+		}
+
+		return result
+	}
+
+	function tryParseElement(grammarElement: GrammarElement, startOffset: number): ParseResult | null {
 		switch (grammarElement.type) {
 			case 'StringTerminal': {
 				const target = grammarElement.content
@@ -102,16 +117,35 @@ export function parse(inputString: string, grammar: Grammar<any>, options?: TopD
 				const groupsIndices = matchResults.indices
 
 				if (groupsIndices !== undefined) {
-					let namedGroupIndicesIdentifiers: string[] | undefined = undefined
+					const children: ParseTreeNode[] = []
+
+					// Build a reverse lookup from indices entry -> group name by identity.
+					// This is robust even when some groups do not participate (undefined)
+					// and avoids relying on Object.keys order aligning with numeric indices.
+					let indexToName: (string | undefined)[] | undefined = undefined
 
 					if (groupsIndices.groups) {
-						namedGroupIndicesIdentifiers = Object.keys(groupsIndices.groups)
-					}
+						indexToName = new Array(groupsIndices.length)
 
-					const children: ParseTreeNode[] = []
+						for (const [name, range] of Object.entries(groupsIndices.groups)) {
+							if (range === undefined) {
+								continue
+							}
 
-					for (let i = 1; i < groupsIndices.length; i++) {
-						const groupIndices = groupsIndices[i]
+							// `range` is the same array instance as groupsIndices[index]
+							const index = groupsIndices.indexOf(range)
+
+							if (index >= 0) {
+								indexToName[index] = name
+							}
+						}
+
+						// Mark which indices actually correspond to named groups
+						// (validatePatternCaptureGroups guarantees all-or-nothing, but be defensive)
+					}
+
+					for (let i = 1; i < (groupsIndices as unknown as number[][]).length; i++) {
+						const groupIndices = (groupsIndices as unknown as (number[] | undefined)[])[i]
 
 						if (groupIndices === undefined) {
 							continue
@@ -120,8 +154,10 @@ export function parse(inputString: string, grammar: Grammar<any>, options?: TopD
 						const groupStartOffset = startOffset + groupIndices[0]
 						const groupEndOffset = startOffset + groupIndices[1]
 
+						const name = indexToName?.[i] ?? i.toString()
+
 						children.push({
-							name: namedGroupIndicesIdentifiers ? namedGroupIndicesIdentifiers[i - 1] : i.toString(),
+							name,
 							startOffset: groupStartOffset,
 							endOffset: groupEndOffset,
 							sourceText: inputString.substring(groupStartOffset, groupEndOffset),
@@ -151,6 +187,13 @@ export function parse(inputString: string, grammar: Grammar<any>, options?: TopD
 					return null
 				}
 
+				if (result.skipped === true) {
+					// The content was skipped (it was optional and didn't match),
+					// so no node should be created for this nonterminal either,
+					// and the skip is propagated to the parent.
+					return { endOffset: startOffset, nodes: undefined, skipped: true }
+				}
+
 				const grammarElementName = grammarElement.name
 
 				if (grammarElement.unwrapped) {
@@ -297,6 +340,12 @@ export function parse(inputString: string, grammar: Grammar<any>, options?: TopD
 export interface ParseResult {
 	endOffset: number
 	nodes: ParseTreeNode[] | undefined
+
+	// Marks a result produced by an optional element that was "skipped" (it
+	// didn't match, so the parse succeeded by consuming no input and producing
+	// no nodes). Set internally by the parser; a receiving `Nonterminal` uses
+	// it to avoid creating a node for skipped content.
+	skipped?: boolean
 }
 
 export interface ParseTreeNode {
@@ -310,5 +359,5 @@ export interface ParseTreeNode {
 	children?: ParseTreeNode[]
 }
 
-export interface TopDownParserOptions {
+export interface ParserOptions {
 }

package/src/{parser-generator → parser}/StaticAnalysis.ts

@@ -131,7 +131,7 @@ export function detectAndAnnotateOptionalNodes(rootNode: GrammarElement) {
 		// If it stays false, it means that no improvement was made during the iteration,
 		// and we should exit the loop.
 		let atLastOneDependencyResolvedInAnyNode = false
-		
+
 		const nodesToDelete: GrammarElement[] = []
 
 		// Scan the unresolved nodes to locate any new resolved dependencies
@@ -189,10 +189,12 @@ export function detectAndAnnotateOptionalNodes(rootNode: GrammarElement) {
 		}
 	}
 
-	// All remaining unresolved nodes must now be optional,
-	// since they are all mutually cyclic and all their non-cyclic grammar elements are known to be optional.
+	// All remaining unresolved nodes are part of a strongly-connected cyclic
+	// component with no resolvable nullable base case. The least fixed-point
+	// for nullability is `false` (not optional): a cycle without an empty
+	// alternative cannot derive the empty string.
 	for (const node of unresolvedNodes.keys()) {
-		resolvedNodes.set(node, true)
+		resolvedNodes.set(node, false)
 		unresolvedNodes.delete(node)
 	}
 
@@ -210,7 +212,11 @@ export function detectAndErrorOnLeftRecursion(rootNode: GrammarElement) {
 			if (node.type === 'Nonterminal') {
 				throw new Error(`Detected left recursion for nonterminal '${node.name}'.`)
 			} else {
-				throw new Error(`Detected left recursion for node: ${JSON.stringify(node, undefined, 4)}`)
+				try {
+					throw new Error(`Detected left recursion for node: ${JSON.stringify(node, undefined, 4)}`)
+				} catch {
+					throw new Error(`Detected left recursion for node type '${(node as any).type}'.`)
+				}
 			}
 		}
 
@@ -282,7 +288,7 @@ export function validatePatternCaptureGroups(pattern: Pattern): void {
 			case 'capture': {
 				if (node.name !== undefined) {
 					if (seenNamedCaptureGroupNames.has(node.name)) {
-						throw new Error(`The regular expression pattern contains multiple named capture groups with the same name '${node.name}'. Named capture groups must have unique names.`)
+						throw new Error(`The regular expression pattern contains multiple named capture groups with the same name '${(node as any).name}'. Named capture groups must have unique names.`)
 					}
 
 					seenNamedCaptureGroupNames.add(node.name)
@@ -296,7 +302,11 @@ export function validatePatternCaptureGroups(pattern: Pattern): void {
 				return
 			}
 
-			// Composite nodes that wrap content without creating a capturing group:
+			// Composite nodes that wrap content without creating a capturing group.
+			// regexp-composer uses a `greedy` boolean to distinguish `zeroOrMore` vs
+			// `zeroOrMoreNonGreedy` etc, but both share the same `type` string
+			// (`zeroOrMore`, `oneOrMore`, `repeated`). Handle any type that wraps
+			// a single `content` field.
 			case 'possibly':
 			case 'zeroOrMore':
 			case 'oneOrMore':

package/src/{parser-generator → parser}/TerminalToText.ts

@@ -179,7 +179,7 @@ export class TerminalToText {
 
 export function escapeChar(char: string): string {
 	const charMapping: Record<string, string> = {
-		//'\\': '\\\\',
+		'\\': '\\\\',
 		"'": "\\'",
 		'\n': '\\n',
 		'\r': '\\r',

package/src/tests/Test.ts

@@ -134,7 +134,7 @@ function test1() {
 //testParserError2()
 
 //testJsonParser()
-testXmlParser()
-//testRegExpParser()
+//testXmlParser()
+testRegExpParser()
 
 //test1()

package/src/utilities/Utilities.ts

@@ -1,3 +1,5 @@
+import { type ParseTreeNode } from '../exports/Exports.js'
+
 export function roundToDigits(val: number, digits = 3) {
 	const multiplier = 10 ** digits
 
@@ -17,7 +19,7 @@ export function isBigInt(value: unknown): value is bigint {
 }
 
 export function isObject(value: unknown): value is object {
-	return typeof value === 'object' && !Array.isArray(value)
+	return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
 
 export function isArray(value: unknown): value is unknown[] {
@@ -31,3 +33,21 @@ export function isBoolean(value: unknown): value is boolean {
 export function isFunction(value: unknown): value is Function {
 	return typeof value === 'function'
 }
+
+export function stringifyParseTree(parseTree: ParseTreeNode[], depth = 0): string {
+	let result = ''
+
+	const getNewlineWithIndent = (depth: number) => `\n${'\t'.repeat(depth)}`
+
+	for (const node of parseTree) {
+		result += `${getNewlineWithIndent(depth)}${node.name}`
+
+		if (node.children && node.children.length > 0) {
+			result += stringifyParseTree(node.children, depth + 1)
+		} else {
+			result += `${getNewlineWithIndent(depth + 1)}'${node.sourceText}'`
+		}
+	}
+
+	return result
+}

package/tsconfig.json

@@ -1,55 +1,53 @@
 {
-  // Visit https://aka.ms/tsconfig to read more about this file
-  "compilerOptions": {
-	// File Layout
-	"rootDir": "./src",
-	"outDir": "./dist",
-
-	// Environment Settings
-	// See also https://aka.ms/tsconfig/module
-	"module": "nodenext",
-	"target": "esnext",
-	"types": ["node"],
-	// For nodejs:
-	// "lib": ["esnext"],
-	// "types": ["node"],
-	// and npm install -D @types/node
-
-	// Other Outputs
-	"sourceMap": true,
-	"declaration": true,
-	"declarationMap": true,
-
-	// Stricter Typechecking Options
-	// "noUncheckedIndexedAccess": true,
-	// "exactOptionalPropertyTypes": true,
-
-	// Style Options
-	"noImplicitReturns": true,
-	// "noImplicitOverride": true,
-	// "noUnusedLocals": true,
-	// "noUnusedParameters": true,
-	// "noFallthroughCasesInSwitch": true,
-	// "noPropertyAccessFromIndexSignature": true,
-
-	// Recommended Options
-	"strict": true,
-	"jsx": "react-jsx",
-	// "verbatimModuleSyntax": true,
-	"isolatedModules": true,
-	"noUncheckedSideEffectImports": true,
-	"moduleDetection": "force",
-	"skipLibCheck": true,
-
-	// Extended options not in generated tsconfig.json
-	"newLine": "lf",
-	"forceConsistentCasingInFileNames": true,
-	"alwaysStrict": true,
-
-	"noImplicitThis": true,
-	"strictBindCallApply": true,
-	"strictFunctionTypes": true,
-
-	"noErrorTruncation": true,
-  }
+	// Visit https://aka.ms/tsconfig to read more about this file
+	// Only compile library sources; tests under /tests are run by vitest and typechecked separately (tsconfig.tests.json)
+	"compilerOptions": {
+		// File Layout
+		"rootDir": "./src",
+		"outDir": "./dist",
+		// Environment Settings
+		// See also https://aka.ms/tsconfig/module
+		"module": "nodenext",
+		"target": "esnext",
+		"types": [
+			"node"
+		],
+		// For nodejs:
+		// "lib": ["esnext"],
+		// "types": ["node"],
+		// and npm install -D @types/node
+		// Other Outputs
+		"sourceMap": true,
+		"declaration": true,
+		"declarationMap": true,
+		// Stricter Typechecking Options
+		// "noUncheckedIndexedAccess": true,
+		// "exactOptionalPropertyTypes": true,
+		// Style Options
+		"noImplicitReturns": true,
+		// "noImplicitOverride": true,
+		// "noUnusedLocals": true,
+		// "noUnusedParameters": true,
+		// "noFallthroughCasesInSwitch": true,
+		// "noPropertyAccessFromIndexSignature": true,
+		// Recommended Options
+		"strict": true,
+		"jsx": "react-jsx",
+		// "verbatimModuleSyntax": true,
+		"isolatedModules": true,
+		"noUncheckedSideEffectImports": true,
+		"moduleDetection": "force",
+		"skipLibCheck": true,
+		// Extended options not in generated tsconfig.json
+		"newLine": "lf",
+		"forceConsistentCasingInFileNames": true,
+		"alwaysStrict": true,
+		"noImplicitThis": true,
+		"strictBindCallApply": true,
+		"strictFunctionTypes": true,
+		"noErrorTruncation": true,
+	},
+	"include": [
+		"src"
+	]
 }

package/dist/parser-generator/Grammar.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Grammar.d.ts","sourceRoot":"","sources":["../../src/parser-generator/Grammar.ts"],"names":[],"mappings":"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"}