23335436240

Committed 20 Mar 2026 08:45AM UTC coverage: 41.582% (+6.7%) from 34.925%

Build # 23335436240

Build Type

Pull #104

github

Committed by

web-flow

Commit Message

Merge eb57da64b into 8feccc8f9

Pull Request Pull Request #104: feat: replace hand-written parser with Nearley grammar

Coverage Stats

448 of 1382 branches covered (32.42%)

Branch coverage included in aggregate %.

525 of 620 new or added lines in 20 files covered. (84.68%)

37 existing lines in 2 files now uncovered.

1392 of 3043 relevant lines covered (45.74%)

67.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.95

/src/parser/parser-adapter.ts

/**
 * Adapter for Nearley parser to match the interface of the old hand-written parser
 */

import nearley from "nearley";
import pythonLexer from "./lexer";
import grammar from "./python-grammar";
import { StmtNS } from "../ast-types";

/**
 * NearleyParser - Drop-in replacement for the old Parser class
 */
export class NearleyParser {
  private readonly source: string;

  constructor(source: string, _tokens?: unknown[]) {
    // Note: Nearley doesn't use pre-tokenized input in the same way
    // The lexer is integrated into the parser
    this.source = source;
  }

  /**
   * Parse the source code and return the AST
   */
  parse(): StmtNS.FileInput {
    // Create a new parser instance with our grammar
    const parser = new nearley.Parser(
      nearley.Grammar.fromCompiled({
        ...(grammar as nearley.CompiledRules),
        Lexer: pythonLexer as nearley.Lexer,
      }),
    );

    try {
      // Feed the source code to the parser
      parser.feed(this.source);

      // Check if we got results
      if (parser.results.length === 0) {
        throw new Error("Unexpected end of input - no parse results");
      }

      // Ambiguous grammar is a bug — fail loudly so tests catch it
      if (parser.results.length > 1) {
        throw new Error(`Ambiguous grammar: ${parser.results.length} possible parses for input`);
      }

      // Return the first (or only) parse result
      return parser.results[0];
    } catch (error: unknown) {
      // Transform Nearley errors to match our error format
      const err = error as {
        token?: { value?: string; type?: string; line?: number; col?: number };
      };
      if (err.token) {
        const token = err.token;
        const line = token.line || 0;
        const col = token.col || 0;
        throw new ParseError(
          `Unexpected token: ${token.value || token.type} at line ${line}, column ${col}`,
          line,
          col,
          this.source,
        );
      }
      throw error;
    }
  }
}

/**
 * Error class for parse errors
 */
export class ParseError extends SyntaxError {
  line: number;
  col: number;
  source: string;

  constructor(message: string, line: number, col: number, source: string) {
    super(message);
    this.name = "ParseError";
    this.line = line;
    this.col = col;
    this.source = source;
  }
}

/**
 * Convenience function to parse Python source code
 */
export function parse(source: string): StmtNS.FileInput {
  const parser = new NearleyParser(source);
  return parser.parse();
}

1	/**
2	* Adapter for Nearley parser to match the interface of the old hand-written parser
3	*/
4
5	import nearley from "nearley";	3✔
6	import pythonLexer from "./lexer";	3✔
7	import grammar from "./python-grammar";	3✔
8	import { StmtNS } from "../ast-types";
9
10	/**
11	* NearleyParser - Drop-in replacement for the old Parser class
12	*/
13	export class NearleyParser {	3✔
14	private readonly source: string;
15
16	constructor(source: string, _tokens?: unknown[]) {
17	// Note: Nearley doesn't use pre-tokenized input in the same way
18	// The lexer is integrated into the parser
19	this.source = source;	230✔
20	}
21
22	/**
23	* Parse the source code and return the AST
24	*/
25	parse(): StmtNS.FileInput {
26	// Create a new parser instance with our grammar
27	const parser = new nearley.Parser(	230✔
28	nearley.Grammar.fromCompiled({
29	...(grammar as nearley.CompiledRules),
30	Lexer: pythonLexer as nearley.Lexer,
31	}),
32	);
33
34	try {	230✔
35	// Feed the source code to the parser
36	parser.feed(this.source);	230✔
37
38	// Check if we got results
39	if (parser.results.length === 0) {	227!
NEW 40	throw new Error("Unexpected end of input - no parse results");	×
41	}
42
43	// Ambiguous grammar is a bug — fail loudly so tests catch it
44	if (parser.results.length > 1) {	227!
NEW 45	throw new Error(`Ambiguous grammar: ${parser.results.length} possible parses for input`);	×
46	}
47
48	// Return the first (or only) parse result
49	return parser.results[0];	227✔
50	} catch (error: unknown) {
51	// Transform Nearley errors to match our error format
52	const err = error as {	3✔
53	token?: { value?: string; type?: string; line?: number; col?: number };
54	};
55	if (err.token) {	3✔
56	const token = err.token;	3✔
57	const line = token.line \|\| 0;	3!
58	const col = token.col \|\| 0;	3!
59	throw new ParseError(	3✔
60	`Unexpected token: ${token.value \|\| token.type} at line ${line}, column ${col}`,	3!
61	line,
62	col,
63	this.source,
64	);
65	}
NEW 66	throw error;	×
67	}
68	}
69	}
70
71	/**
72	* Error class for parse errors
73	*/
74	export class ParseError extends SyntaxError {	3✔
75	line: number;
76	col: number;
77	source: string;
78
79	constructor(message: string, line: number, col: number, source: string) {
80	super(message);	3✔
81	this.name = "ParseError";	3✔
82	this.line = line;	3✔
83	this.col = col;	3✔
84	this.source = source;	3✔
85	}
86	}
87
88	/**
89	* Convenience function to parse Python source code
90	*/
91	export function parse(source: string): StmtNS.FileInput {	3✔
92	const parser = new NearleyParser(source);	173✔
93	return parser.parse();	173✔
94	}

source-academy / py-slang / 23335436240

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous