23727466431

Committed 30 Mar 2026 04:06AM UTC coverage: 59.421% (+18.2%) from 41.233%

Build # 23727466431

Build Type

push

github

Committed by

web-flow

Commit Message

Python chapter 2 (+ 3?) support (#81)

* feat: introduce chapter-based CSE evaluators + improve type safety of value type + add stubs for LINKED_LIST group

* add Python Chapter 1 back to the Rollup config

* Turned resolver type-checking back on + fix build_linked_list not working

* Fix bug where groups weren't loading + Make builtins more type-safe + Added native list functions (print_linked_list, head, tail)

* my changes

* Add Python chapter 3 functions + Fix syntax of stream prelude + Add list creation instruction + Make parser variant specific + Add basic tests for standard library

* Fix rounding + add tests for linked lists

* Fixed bug regarding representation of strings (printing ["a", "b"] returned [a, b])

* Mark files as unused (for now)

* Fix test cases

* Added variant to parser in WASM compiler

* Fix linked-list prelude using the old terminology of list + Fix build_linked_list(None) returning None instead of list()

* Add ability to check output from testing framework

* Add documentation for TestCases + add the repr function

* Improve alignment with Python specs + add ability to index lists + move variant checking to the resolver + improve test names + add a lot more tests

* Add more tests for operators + restrict the not operator to only booleans + disallow booleans in the unary minus operator

* FIx print_linked_list not actually printing the linked list

* Implement while loops + unpacking with for loops + implement tuples + break and continue

* Added a public is_linked_list function, added more comprehensive test cases for is_pair and is_linked_list

* extended test cases for linked lists

* Updated to have distinction between linkedlist Value and Python List for ease of future implementation of python list

* Revert "Updated to have distinction between linkedlist Value and Python List for ease of future implementation of python list"

This reverts commit d444793b1.

* fixed and/or operator bu... (continued)

Coverage Stats

779 of 1553 branches covered (50.16%)

Branch coverage included in aggregate %.

442 of 651 new or added lines in 32 files covered. (67.9%)

17 existing lines in 4 files now uncovered.

2400 of 3797 relevant lines covered (63.21%)

3195.38 hits per line

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

73.27

/src/resolver/resolver.ts

import { ExprNS, StmtNS } from "../ast-types";
import constants from "../stdlib/py_s1_constants.json";
import { Group } from "../stdlib/utils";
import { Token } from "../tokenizer/tokenizer";
import { TokenType } from "../tokens";
import { FeatureValidator } from "../validator/types";
import { ResolverErrors } from "./errors";
type Expr = ExprNS.Expr;
type Stmt = StmtNS.Stmt;

import levenshtein from "fast-levenshtein";
// const levenshtein = require('fast-levenshtein');

const RedefineableTokenSentinel = new Token(TokenType.AT, "", 0, 0, 0);

export class Environment {
  source: string;
  // The parent of this environment
  enclosing: Environment | null;
  names: Map<string, Token>;
  // Function names in the environment.
  functions: Set<string>;
  // Names that are from import bindings, like 'y' in `from x import y`.
  // This only set at the top level environment. Child environments do not
  // copy this field.
  moduleBindings: Set<string>;
  definedNames: Set<string>;
  constructor(source: string, enclosing: Environment | null, names: Map<string, Token>) {
    this.source = source;
    this.enclosing = enclosing;
    this.names = names;
    this.functions = new Set();
    this.moduleBindings = new Set();
    this.definedNames = new Set();
  }

  /*
   * Does a full lookup up the environment chain for a name.
   * Returns the distance of the name from the current environment.
   * If name isn't found, return -1.
   * */
  lookupName(identifier: Token): number {
    const name = identifier.lexeme;
    let distance = 0;
    // eslint-disable-next-line @typescript-eslint/no-this-alias
    let curr: Environment | null = this;
    while (curr !== null) {
      if (curr.names.has(name)) {
        break;
      }
      distance += 1;
      curr = curr.enclosing;
    }
    return curr === null ? -1 : distance;
  }

  /* Looks up the name but only for the current environment. */
  lookupNameCurrentEnv(identifier: Token): Token | undefined {
    return this.names.get(identifier.lexeme);
  }
  lookupNameCurrentEnvWithError(identifier: Token) {
    if (this.lookupName(identifier) < 0) {
      throw new ResolverErrors.NameNotFoundError(
        identifier.line,
        identifier.col,
        this.source,
        identifier.indexInSource,
        identifier.indexInSource + identifier.lexeme.length,
        this.suggestName(identifier),
      );
    }
  }
  lookupNameParentEnvWithError(identifier: Token) {
    const name = identifier.lexeme;
    const parent = this.enclosing;

    if (parent === null || !parent.names.has(name)) {
      throw new ResolverErrors.NameNotFoundError(
        identifier.line,
        identifier.col,
        this.source,
        identifier.indexInSource,
        identifier.indexInSource + name.length,
        this.suggestName(identifier),
      );
    }
  }
  declareName(identifier: Token) {
    this.names.set(identifier.lexeme, identifier);
    this.definedNames.add(identifier.lexeme);
  }
  // Same as declareName but allowed to re-declare later.
  declarePlaceholderName(identifier: Token) {
    const lookup = this.lookupNameCurrentEnv(identifier);
    if (lookup !== undefined) {
      throw new ResolverErrors.NameReassignmentError(
        identifier.line,
        identifier.col,
        this.source,
        identifier.indexInSource,
        identifier.indexInSource + identifier.lexeme.length,
        lookup,
      );
    }
    this.names.set(identifier.lexeme, RedefineableTokenSentinel);
  }
  suggestNameCurrentEnv(identifier: Token): string | null {
    const name = identifier.lexeme;
    let minDistance = Infinity;
    let minName = null;
    for (const declName of this.names.keys()) {
      const dist = levenshtein.get(name, declName);
      if (dist < minDistance) {
        minDistance = dist;
        minName = declName;
      }
    }
    return minName;
  }
  /*
   * Finds name closest to name in all environments up to builtin environment.
   * Calculated using min levenshtein distance.
   * */
  suggestName(identifier: Token): string | null {
    const name = identifier.lexeme;
    let minDistance = Infinity;
    let minName = null;
    // eslint-disable-next-line @typescript-eslint/no-this-alias
    let curr: Environment | null = this;
    while (curr !== null) {
      for (const declName of curr.names.keys()) {
        const dist = levenshtein.get(name, declName);
        if (dist < minDistance) {
          minDistance = dist;
          minName = declName;
        }
      }
      curr = curr.enclosing;
    }
    if (minDistance >= 4) {
      // This is pretty far, so just return null
      return null;
    }
    return minName;
  }
}
export class Resolver implements StmtNS.Visitor<void>, ExprNS.Visitor<void> {
  source: string;
  ast: Stmt;
  environment: Environment | null;
  functionScope: Environment | null;
  private validators: FeatureValidator[];

  constructor(
    source: string,
    ast: Stmt,
    validators: FeatureValidator[] = [],
    groups: Group[] = [],
    preludeNames: string[] = [],
  ) {
    this.source = source;
    this.ast = ast;
    this.source = source;
    this.ast = ast;
    this.validators = validators;
    // The global environment
    this.environment = new Environment(
      source,
      null,
      new Map([
        // misc library
        ...constants.builtInFuncs.map(
          (name: string) => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],
        ),
        ["range", new Token(TokenType.NAME, "range", 0, 0, 0)],
        ...constants.constants.map(
          (name: string) => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],
        ),
        ...groups.flatMap(group =>
          Array.from(group.builtins.entries()).map(
            ([name]) => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],
          ),
        ),
        ...preludeNames.map(
          name => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],
        ),
      ]),
    );
    this.functionScope = null;
  }

  private runValidators(node: StmtNS.Stmt | ExprNS.Expr): void {
    for (const v of this.validators) v.validate(node, this.environment ?? undefined);
  }

  resolve(stmt: Stmt[] | Stmt | Expr[] | Expr | null) {
    if (stmt === null) {
      return;
    }
    if (stmt instanceof Array) {
      // Resolve all top-level functions first. Python allows functions declared after
      // another function to be used in that function.
      for (const st of stmt) {
        if (st instanceof StmtNS.FunctionDef) {
          this.environment?.declarePlaceholderName(st.name);
        }
      }
      for (const st of stmt) {
        this.runValidators(st);
        st.accept(this);
      }
    } else {
      this.runValidators(stmt);
      stmt.accept(this);
    }
  }

  varDeclNames(names: Map<string, Token>): Token[] | null {
    const res = Array.from(names.values()).filter(
      name =>
        // Filter out functions and module bindings.
        // Those will be handled separately, so they don't
        // need to be hoisted.
        !this.environment?.functions.has(name.lexeme) &&
        !this.environment?.moduleBindings.has(name.lexeme),
    );
    return res.length === 0 ? null : res;
  }

  functionVarConstraint(identifier: Token): void {
    if (this.functionScope == null) {
      return;
    }
    let curr = this.environment;
    while (curr !== this.functionScope) {
      if (curr !== null && curr.names.has(identifier.lexeme)) {
        const token = curr.names.get(identifier.lexeme);
        if (token === undefined) {
          throw new Error("placeholder error");
        }
        throw new ResolverErrors.NameReassignmentError(
          identifier.line,
          identifier.col,
          this.source,
          identifier.indexInSource,
          identifier.indexInSource + identifier.lexeme.length,
          token,
        );
      }
      curr = curr?.enclosing ?? null;
    }
  }

  //// STATEMENTS
  visitFileInputStmt(stmt: StmtNS.FileInput): void {
    // Create a new environment.
    const oldEnv = this.environment;
    this.environment = new Environment(this.source, this.environment, new Map());
    this.resolve(stmt.statements);
    // Grab identifiers from that new environment. That are NOT functions.
    // stmt.varDecls = this.varDeclNames(this.environment.names)
    this.environment = oldEnv;
  }

  visitFunctionDefStmt(stmt: StmtNS.FunctionDef) {
    this.environment?.declareName(stmt.name);
    this.environment?.functions.add(stmt.name.lexeme);

    // Create a new environment.
    const oldEnv = this.environment;
    // Assign the parameters to the new environment.
    const newEnv = new Map(stmt.parameters.map(param => [param.lexeme, param]));
    this.environment = new Environment(this.source, this.environment, newEnv);
    // const params = new Map(
    //     stmt.parameters.map(param => [param.lexeme, param])
    // );
    // if (this.environment !== null) {
    //     this.environment.names = params;
    // }
    this.functionScope = this.environment;
    this.resolve(stmt.body);
    // Grab identifiers from that new environment. That are NOT functions.
    // stmt.varDecls = this.varDeclNames(this.environment.names)
    // Restore old environment
    this.functionScope = null;
    this.environment = oldEnv;
  }

  visitAnnAssignStmt(stmt: StmtNS.AnnAssign): void {
    this.resolve(stmt.ann);
    this.resolve(stmt.value);
    this.functionVarConstraint(stmt.target.name);
    this.environment?.declareName(stmt.target.name);
  }

  visitAssignStmt(stmt: StmtNS.Assign): void {
    const target = stmt.target;
    if (target instanceof ExprNS.Subscript) {
      this.resolve(target); // dispatches to visitSubscriptExpr
      this.resolve(stmt.value);
      return;
    }
    this.resolve(stmt.value);
    this.functionVarConstraint(target.name);
    this.environment?.declareName(target.name);
  }

  visitAssertStmt(stmt: StmtNS.Assert): void {
    this.resolve(stmt.value);
  }
  visitForStmt(stmt: StmtNS.For): void {
    this.environment?.declareName(stmt.target);
    this.resolve(stmt.iter);
    this.resolve(stmt.body);
  }

  visitIfStmt(stmt: StmtNS.If): void {
    this.resolve(stmt.condition);
    this.resolve(stmt.body);
    this.resolve(stmt.elseBlock);
  }
  // @TODO we need to treat all global statements as variable declarations in the global
  // scope.
  visitGlobalStmt(_stmt: StmtNS.Global): void {
    // Do nothing because global can also be declared in our
    // own scope.
  }
  // @TODO nonlocals mean that any variable following that name in the current env
  // should not create a variable declaration, but instead point to an outer variable.
  visitNonLocalStmt(stmt: StmtNS.NonLocal): void {
    this.environment?.lookupNameParentEnvWithError(stmt.name);
  }

  visitReturnStmt(stmt: StmtNS.Return): void {
    if (stmt.value !== null) {
      this.resolve(stmt.value);
    }
  }

  visitWhileStmt(stmt: StmtNS.While): void {
    this.resolve(stmt.condition);
    this.resolve(stmt.body);
  }
  visitSimpleExprStmt(stmt: StmtNS.SimpleExpr): void {
    this.resolve(stmt.expression);
  }

  visitFromImportStmt(stmt: StmtNS.FromImport): void {
    for (const entry of stmt.names) {
      const binding = entry.alias ?? entry.name;
      this.environment?.declareName(binding);
      this.environment?.moduleBindings.add(binding.lexeme);
    }
  }

  visitContinueStmt(_stmt: StmtNS.Continue): void {}
  visitBreakStmt(_stmt: StmtNS.Break): void {}
  visitPassStmt(_stmt: StmtNS.Pass): void {}

  //// EXPRESSIONS
  visitVariableExpr(expr: ExprNS.Variable): void {
    this.environment?.lookupNameCurrentEnvWithError(expr.name);
  }
  visitLambdaExpr(expr: ExprNS.Lambda): void {
    // Create a new environment.
    const oldEnv = this.environment;
    // Assign the parameters to the new environment.
    const newEnv = new Map(expr.parameters.map(param => [param.lexeme, param]));
    this.environment = new Environment(this.source, this.environment, newEnv);
    this.resolve(expr.body);
    // Restore old environment
    this.environment = oldEnv;
  }
  visitMultiLambdaExpr(expr: ExprNS.MultiLambda): void {
    // Create a new environment.
    const oldEnv = this.environment;
    // Assign the parameters to the new environment.
    const newEnv = new Map(expr.parameters.map(param => [param.lexeme, param]));
    this.environment = new Environment(this.source, this.environment, newEnv);
    this.resolve(expr.body);
    // Grab identifiers from that new environment.
    expr.varDecls = Array.from(this.environment.names.values());
    // Restore old environment
    this.environment = oldEnv;
  }
  visitUnaryExpr(expr: ExprNS.Unary): void {
    this.resolve(expr.right);
  }
  visitGroupingExpr(expr: ExprNS.Grouping): void {
    this.resolve(expr.expression);
  }
  visitBinaryExpr(expr: ExprNS.Binary): void {
    this.resolve(expr.left);
    this.resolve(expr.right);
  }
  visitBoolOpExpr(expr: ExprNS.BoolOp): void {
    this.resolve(expr.left);
    this.resolve(expr.right);
  }
  visitCompareExpr(expr: ExprNS.Compare): void {
    this.resolve(expr.left);
    this.resolve(expr.right);
  }

  visitCallExpr(expr: ExprNS.Call): void {
    this.resolve(expr.callee);
    this.resolve(expr.args);
  }
  visitTernaryExpr(expr: ExprNS.Ternary): void {
    this.resolve(expr.predicate);
    this.resolve(expr.consequent);
    this.resolve(expr.alternative);
  }
  visitNoneExpr(_expr: ExprNS.None): void {}
  visitLiteralExpr(_expr: ExprNS.Literal): void {}
  visitBigIntLiteralExpr(_expr: ExprNS.BigIntLiteral): void {}
  visitComplexExpr(_expr: ExprNS.Complex): void {}
  visitListExpr(expr: ExprNS.List): void {
    this.resolve(expr.elements);
  }
  visitSubscriptExpr(expr: ExprNS.Subscript): void {
    this.resolve(expr.value);
    this.resolve(expr.index);
  }
}

1	import { ExprNS, StmtNS } from "../ast-types";	4✔
2	import constants from "../stdlib/py_s1_constants.json";	4✔
3	import { Group } from "../stdlib/utils";
4	import { Token } from "../tokenizer/tokenizer";	4✔
5	import { TokenType } from "../tokens";	4✔
6	import { FeatureValidator } from "../validator/types";
7	import { ResolverErrors } from "./errors";	4✔
8	type Expr = ExprNS.Expr;
9	type Stmt = StmtNS.Stmt;
10
11	import levenshtein from "fast-levenshtein";	4✔
12	// const levenshtein = require('fast-levenshtein');
13
14	const RedefineableTokenSentinel = new Token(TokenType.AT, "", 0, 0, 0);	4✔
15
16	export class Environment {	4✔
17	source: string;
18	// The parent of this environment
19	enclosing: Environment \| null;
20	names: Map<string, Token>;
21	// Function names in the environment.
22	functions: Set<string>;
23	// Names that are from import bindings, like 'y' in `from x import y`.
24	// This only set at the top level environment. Child environments do not
25	// copy this field.
26	moduleBindings: Set<string>;
27	definedNames: Set<string>;
28	constructor(source: string, enclosing: Environment \| null, names: Map<string, Token>) {
29	this.source = source;	1,918✔
30	this.enclosing = enclosing;	1,918✔
31	this.names = names;	1,918✔
32	this.functions = new Set();	1,918✔
33	this.moduleBindings = new Set();	1,918✔
34	this.definedNames = new Set();	1,918✔
35	}
36
37	/*
38	* Does a full lookup up the environment chain for a name.
39	* Returns the distance of the name from the current environment.
40	* If name isn't found, return -1.
41	* */
42	lookupName(identifier: Token): number {
43	const name = identifier.lexeme;	559✔
44	let distance = 0;	559✔
45	// eslint-disable-next-line @typescript-eslint/no-this-alias
46	let curr: Environment \| null = this;	559✔
47	while (curr !== null) {	559✔
48	if (curr.names.has(name)) {	971✔
49	break;	553✔
50	}
51	distance += 1;	418✔
52	curr = curr.enclosing;	418✔
53	}
54	return curr === null ? -1 : distance;	559✔
55	}
56
57	/* Looks up the name but only for the current environment. */
58	lookupNameCurrentEnv(identifier: Token): Token \| undefined {
59	return this.names.get(identifier.lexeme);	34✔
60	}
61	lookupNameCurrentEnvWithError(identifier: Token) {
62	if (this.lookupName(identifier) < 0) {	559✔
63	throw new ResolverErrors.NameNotFoundError(	6✔
64	identifier.line,
65	identifier.col,
66	this.source,
67	identifier.indexInSource,
68	identifier.indexInSource + identifier.lexeme.length,
69	this.suggestName(identifier),
70	);
71	}
72	}
73	lookupNameParentEnvWithError(identifier: Token) {
74	const name = identifier.lexeme;	1✔
75	const parent = this.enclosing;	1✔
76
77	if (parent === null \|\| !parent.names.has(name)) {	1!
78	throw new ResolverErrors.NameNotFoundError(	×
79	identifier.line,
80	identifier.col,
81	this.source,
82	identifier.indexInSource,
83	identifier.indexInSource + name.length,
84	this.suggestName(identifier),
85	);
86	}
87	}
88	declareName(identifier: Token) {
89	this.names.set(identifier.lexeme, identifier);	94✔
90	this.definedNames.add(identifier.lexeme);	94✔
91	}
92	// Same as declareName but allowed to re-declare later.
93	declarePlaceholderName(identifier: Token) {
94	const lookup = this.lookupNameCurrentEnv(identifier);	34✔
95	if (lookup !== undefined) {	34!
96	throw new ResolverErrors.NameReassignmentError(	×
97	identifier.line,
98	identifier.col,
99	this.source,
100	identifier.indexInSource,
101	identifier.indexInSource + identifier.lexeme.length,
102	lookup,
103	);
104	}
105	this.names.set(identifier.lexeme, RedefineableTokenSentinel);	34✔
106	}
107	suggestNameCurrentEnv(identifier: Token): string \| null {
108	const name = identifier.lexeme;	×
109	let minDistance = Infinity;	×
110	let minName = null;	×
111	for (const declName of this.names.keys()) {	×
112	const dist = levenshtein.get(name, declName);	×
113	if (dist < minDistance) {	×
114	minDistance = dist;	×
115	minName = declName;	×
116	}
117	}
118	return minName;	×
119	}
120	/*
121	* Finds name closest to name in all environments up to builtin environment.
122	* Calculated using min levenshtein distance.
123	* */
124	suggestName(identifier: Token): string \| null {
125	const name = identifier.lexeme;	6✔
126	let minDistance = Infinity;	6✔
127	let minName = null;	6✔
128	// eslint-disable-next-line @typescript-eslint/no-this-alias
129	let curr: Environment \| null = this;	6✔
130	while (curr !== null) {	6✔
131	for (const declName of curr.names.keys()) {	14✔
132	const dist = levenshtein.get(name, declName);	466✔
133	if (dist < minDistance) {	466✔
134	minDistance = dist;	11✔
135	minName = declName;	11✔
136	}
137	}
138	curr = curr.enclosing;	14✔
139	}
140	if (minDistance >= 4) {	6✔
141	// This is pretty far, so just return null
142	return null;	1✔
143	}
144	return minName;	5✔
145	}
146	}
147	export class Resolver implements StmtNS.Visitor<void>, ExprNS.Visitor<void> {	4✔
148	source: string;
149	ast: Stmt;
150	environment: Environment \| null;
151	functionScope: Environment \| null;
152	private validators: FeatureValidator[];
153
154	constructor(
155	source: string,
156	ast: Stmt,
157	validators: FeatureValidator[] = [],	×
158	groups: Group[] = [],	28✔
159	preludeNames: string[] = [],	28✔
160	) {
161	this.source = source;	901✔
162	this.ast = ast;	901✔
163	this.source = source;	901✔
164	this.ast = ast;	901✔
165	this.validators = validators;	901✔
166	// The global environment
167	this.environment = new Environment(	901✔
168	source,
169	null,
170	new Map([
171	// misc library
172	...constants.builtInFuncs.map(
173	(name: string) => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],	63,971✔
174	),
175	["range", new Token(TokenType.NAME, "range", 0, 0, 0)],
176	...constants.constants.map(
177	(name: string) => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],	4,505✔
178	),
179	...groups.flatMap(group =>
180	Array.from(group.builtins.entries()).map(	313✔
181	([name]) => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],	1,202✔
182	),
183	),
184	...preludeNames.map(
185	name => [name, new Token(TokenType.NAME, name, 0, 0, 0)] as [string, Token],	5,227✔
186	),
187	]),
188	);
189	this.functionScope = null;	901✔
190	}
191
192	private runValidators(node: StmtNS.Stmt \| ExprNS.Expr): void {
193	for (const v of this.validators) v.validate(node, this.environment ?? undefined);	44,800!
194	}
195
196	resolve(stmt: Stmt[] \| Stmt \| Expr[] \| Expr \| null) {
197	if (stmt === null) {	5,602!
198	return;	×
199	}
200	if (stmt instanceof Array) {	5,602✔
201	// Resolve all top-level functions first. Python allows functions declared after
202	// another function to be used in that function.
203	for (const st of stmt) {	1,350✔
204	if (st instanceof StmtNS.FunctionDef) {	1,727✔
205	this.environment?.declarePlaceholderName(st.name);	34✔
206	}
207	}
208	for (const st of stmt) {	1,350✔
209	this.runValidators(st);	1,721✔
210	st.accept(this);	1,691✔
211	}
212	} else {
213	this.runValidators(stmt);	4,252✔
214	stmt.accept(this);	4,241✔
215	}
216	}
217
218	varDeclNames(names: Map<string, Token>): Token[] \| null {
219	const res = Array.from(names.values()).filter(	×
220	name =>
221	// Filter out functions and module bindings.
222	// Those will be handled separately, so they don't
223	// need to be hoisted.
224	!this.environment?.functions.has(name.lexeme) &&	×
225	!this.environment?.moduleBindings.has(name.lexeme),
226	);
227	return res.length === 0 ? null : res;	×
228	}
229
230	functionVarConstraint(identifier: Token): void {
231	if (this.functionScope == null) {	57✔
232	return;	51✔
233	}
234	let curr = this.environment;	6✔
235	while (curr !== this.functionScope) {	6✔
236	if (curr !== null && curr.names.has(identifier.lexeme)) {	×
237	const token = curr.names.get(identifier.lexeme);	×
238	if (token === undefined) {	×
239	throw new Error("placeholder error");	×
240	}
241	throw new ResolverErrors.NameReassignmentError(	×
242	identifier.line,
243	identifier.col,
244	this.source,
245	identifier.indexInSource,
246	identifier.indexInSource + identifier.lexeme.length,
247	token,
248	);
249	}
250	curr = curr?.enclosing ?? null;	×
251	}
252	}
253
254	//// STATEMENTS
255	visitFileInputStmt(stmt: StmtNS.FileInput): void {
256	// Create a new environment.
257	const oldEnv = this.environment;	901✔
258	this.environment = new Environment(this.source, this.environment, new Map());	901✔
259	this.resolve(stmt.statements);	901✔
260	// Grab identifiers from that new environment. That are NOT functions.
261	// stmt.varDecls = this.varDeclNames(this.environment.names)
262	this.environment = oldEnv;	854✔
263	}
264
265	visitFunctionDefStmt(stmt: StmtNS.FunctionDef) {
266	this.environment?.declareName(stmt.name);	32✔
267	this.environment?.functions.add(stmt.name.lexeme);	32✔
268
269	// Create a new environment.
270	const oldEnv = this.environment;	32✔
271	// Assign the parameters to the new environment.
272	const newEnv = new Map(stmt.parameters.map(param => [param.lexeme, param]));	32✔
273	this.environment = new Environment(this.source, this.environment, newEnv);	32✔
274	// const params = new Map(
275	// stmt.parameters.map(param => [param.lexeme, param])
276	// );
277	// if (this.environment !== null) {
278	// this.environment.names = params;
279	// }
280	this.functionScope = this.environment;	32✔
281	this.resolve(stmt.body);	32✔
282	// Grab identifiers from that new environment. That are NOT functions.
283	// stmt.varDecls = this.varDeclNames(this.environment.names)
284	// Restore old environment
285	this.functionScope = null;	24✔
286	this.environment = oldEnv;	24✔
287	}
288
289	visitAnnAssignStmt(stmt: StmtNS.AnnAssign): void {
UNCOV 290	this.resolve(stmt.ann);	×
UNCOV 291	this.resolve(stmt.value);	×
UNCOV 292	this.functionVarConstraint(stmt.target.name);	×
UNCOV 293	this.environment?.declareName(stmt.target.name);	×
294	}
295
296	visitAssignStmt(stmt: StmtNS.Assign): void {
297	const target = stmt.target;	68✔
298	if (target instanceof ExprNS.Subscript) {	68✔
299	this.resolve(target); // dispatches to visitSubscriptExpr	3✔
300	this.resolve(stmt.value);	2✔
301	return;	2✔
302	}
303	this.resolve(stmt.value);	65✔
304	this.functionVarConstraint(target.name);	57✔
305	this.environment?.declareName(target.name);	57✔
306	}
307
308	visitAssertStmt(stmt: StmtNS.Assert): void {
309	this.resolve(stmt.value);	×
310	}
311	visitForStmt(stmt: StmtNS.For): void {
312	this.environment?.declareName(stmt.target);	4✔
313	this.resolve(stmt.iter);	4✔
314	this.resolve(stmt.body);	4✔
315	}
316
317	visitIfStmt(stmt: StmtNS.If): void {
318	this.resolve(stmt.condition);	×
319	this.resolve(stmt.body);	×
320	this.resolve(stmt.elseBlock);	×
321	}
322	// @TODO we need to treat all global statements as variable declarations in the global
323	// scope.
324	visitGlobalStmt(_stmt: StmtNS.Global): void {
325	// Do nothing because global can also be declared in our
326	// own scope.
327	}
328	// @TODO nonlocals mean that any variable following that name in the current env
329	// should not create a variable declaration, but instead point to an outer variable.
330	visitNonLocalStmt(stmt: StmtNS.NonLocal): void {
331	this.environment?.lookupNameParentEnvWithError(stmt.name);	1✔
332	}
333
334	visitReturnStmt(stmt: StmtNS.Return): void {
335	if (stmt.value !== null) {	13✔
336	this.resolve(stmt.value);	13✔
337	}
338	}
339
340	visitWhileStmt(stmt: StmtNS.While): void {
341	this.resolve(stmt.condition);	3✔
342	this.resolve(stmt.body);	3✔
343	}
344	visitSimpleExprStmt(stmt: StmtNS.SimpleExpr): void {
345	this.resolve(stmt.expression);	847✔
346	}
347
348	visitFromImportStmt(stmt: StmtNS.FromImport): void {
349	for (const entry of stmt.names) {	1✔
350	const binding = entry.alias ?? entry.name;	1✔
351	this.environment?.declareName(binding);	1✔
352	this.environment?.moduleBindings.add(binding.lexeme);	1✔
353	}
354	}
355
356	visitContinueStmt(_stmt: StmtNS.Continue): void {}
357	visitBreakStmt(_stmt: StmtNS.Break): void {}
358	visitPassStmt(_stmt: StmtNS.Pass): void {}
359
360	//// EXPRESSIONS
361	visitVariableExpr(expr: ExprNS.Variable): void {
362	this.environment?.lookupNameCurrentEnvWithError(expr.name);	559✔
363	}
364	visitLambdaExpr(expr: ExprNS.Lambda): void {
365	// Create a new environment.
366	const oldEnv = this.environment;	84✔
367	// Assign the parameters to the new environment.
368	const newEnv = new Map(expr.parameters.map(param => [param.lexeme, param]));	86✔
369	this.environment = new Environment(this.source, this.environment, newEnv);	84✔
370	this.resolve(expr.body);	84✔
371	// Restore old environment
372	this.environment = oldEnv;	84✔
373	}
374	visitMultiLambdaExpr(expr: ExprNS.MultiLambda): void {
375	// Create a new environment.
376	const oldEnv = this.environment;	×
377	// Assign the parameters to the new environment.
378	const newEnv = new Map(expr.parameters.map(param => [param.lexeme, param]));	×
379	this.environment = new Environment(this.source, this.environment, newEnv);	×
380	this.resolve(expr.body);	×
381	// Grab identifiers from that new environment.
382	expr.varDecls = Array.from(this.environment.names.values());	×
383	// Restore old environment
384	this.environment = oldEnv;	×
385	}
386	visitUnaryExpr(expr: ExprNS.Unary): void {
387	this.resolve(expr.right);	37✔
388	}
389	visitGroupingExpr(expr: ExprNS.Grouping): void {
390	this.resolve(expr.expression);	194✔
391	}
392	visitBinaryExpr(expr: ExprNS.Binary): void {
393	this.resolve(expr.left);	520✔
394	this.resolve(expr.right);	520✔
395	}
396	visitBoolOpExpr(expr: ExprNS.BoolOp): void {
397	this.resolve(expr.left);	22✔
398	this.resolve(expr.right);	22✔
399	}
400	visitCompareExpr(expr: ExprNS.Compare): void {
401	this.resolve(expr.left);	308✔
402	this.resolve(expr.right);	307✔
403	}
404
405	visitCallExpr(expr: ExprNS.Call): void {
406	this.resolve(expr.callee);	394✔
407	this.resolve(expr.args);	394✔
408	}
409	visitTernaryExpr(expr: ExprNS.Ternary): void {
410	this.resolve(expr.predicate);	×
411	this.resolve(expr.consequent);	×
412	this.resolve(expr.alternative);	×
413	}
414	visitNoneExpr(_expr: ExprNS.None): void {}
415	visitLiteralExpr(_expr: ExprNS.Literal): void {}
416	visitBigIntLiteralExpr(_expr: ExprNS.BigIntLiteral): void {}
417	visitComplexExpr(_expr: ExprNS.Complex): void {}
418	visitListExpr(expr: ExprNS.List): void {
419	this.resolve(expr.elements);	16✔
420	}
421	visitSubscriptExpr(expr: ExprNS.Subscript): void {
422	this.resolve(expr.value);	3✔
423	this.resolve(expr.index);	3✔
424	}
425	}

source-academy / py-slang / 23727466431

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