28708329040

Committed 04 Jul 2026 01:52PM UTC coverage: 78.665% (+0.02%) from 78.643%

Build # 28708329040

Build Type

Pull #193

github

Committed by

web-flow

Commit Message

Merge 3d99acb22 into 966e5fa49

Pull Request Pull Request #193: Renaming variables to match SICPy

Coverage Stats

2539 of 3492 branches covered (72.71%)

Branch coverage included in aggregate %.

51 of 53 new or added lines in 6 files covered. (96.23%)

45 existing lines in 2 files now uncovered.

6015 of 7382 relevant lines covered (81.48%)

13706.61 hits per line

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

91.58

/src/stdlib/parser.ts

import { ExprNS, FunctionParam, StmtNS } from "../ast-types";
import { Context } from "../engines/cse/context";
import { handleRuntimeError } from "../engines/cse/error";
import { appInstr } from "../engines/cse/instrCreator";
import { BuiltinValue, ListValue, NoneValue, StringValue, Value } from "../engines/cse/stash";
import { operatorTranslator } from "../engines/cse/types";
import { TypeError } from "../errors/errors";
import { parse } from "../parser";
import pythonLexer from "../parser/lexer";
import { GroupName, minArgMap, Validate } from "./utils";

const None: NoneValue = { type: "none" };

function pair(h: Value, t: Value): ListValue {
  return { type: "list", value: [h, t] };
}

function vector_to_llist(arr: Value[]): ListValue | NoneValue {
  let res: ListValue | NoneValue = None;
  for (let i = arr.length - 1; i >= 0; i--) {
    res = pair(arr[i], res);
  }
  return res;
}

function isDeclaration(node: StmtNS.Stmt | null | undefined): boolean {
  if (!node) return false;
  const type = node.kind;
  return type === "FunctionDef" || type === "Assign" || type === "AnnAssign";
}

function hasDeclaration(statements: StmtNS.Stmt[]): boolean {
  return statements.some(isDeclaration);
}

function makeSequenceIfNeeded(
  statements: StmtNS.Stmt[] | StmtNS.Stmt | null | undefined,
  declaredNames: Set<string>,
): Value {
  if (!statements) return None;
  if (!Array.isArray(statements)) return transform(statements, declaredNames);
  if (statements.length === 0) {
    return None;
  }
  if (statements.length === 1) {
    return transform(statements[0], declaredNames);
  }
  return vector_to_llist([
    { type: "string", value: "sequence" },
    vector_to_llist(statements.map(stmt => transform(stmt, declaredNames))),
  ]);
}

function makeBlockIfNeeded(statements: StmtNS.Stmt[], declaredNames: Set<string>): Value {
  return hasDeclaration(statements)
    ? vector_to_llist([
        { type: "string", value: "block" },
        makeSequenceIfNeeded(statements, declaredNames),
      ])
    : makeSequenceIfNeeded(statements, declaredNames);
}

function transformParam(p: FunctionParam): Value {
  const nameNode = vector_to_llist([
    { type: "string", value: "name" },
    { type: "string", value: p.lexeme },
  ]);
  if (p.isStarred) {
    return vector_to_llist([{ type: "string", value: "rest_element" }, nameNode]);
  }
  return nameNode;
}

function transform(
  node: ExprNS.Expr | StmtNS.Stmt | null | undefined,
  declaredNames: Set<string>,
): Value {
  if (!node) return None;
  const type = node.kind;
  switch (type) {
    case "FileInput":
      return makeSequenceIfNeeded((node as StmtNS.FileInput).statements, declaredNames);
    case "SimpleExpr":
      return transform((node as StmtNS.SimpleExpr).expression, declaredNames);
    case "Literal": {
      const lit = node as ExprNS.Literal;
      let val: Value;
      if (typeof lit.value === "number") val = { type: "number", value: lit.value };
      else if (typeof lit.value === "boolean") val = { type: "bool", value: lit.value };
      else if (typeof lit.value === "string") val = { type: "string", value: lit.value };
      else val = None;
      return vector_to_llist([{ type: "string", value: "literal" }, val]);
    }
    case "BigIntLiteral":
      return vector_to_llist([
        { type: "string", value: "literal" },
        { type: "bigint", value: BigInt((node as ExprNS.BigIntLiteral).value) },
      ]);
    case "Complex":
      return vector_to_llist([
        { type: "string", value: "literal" },
        { type: "complex", value: (node as ExprNS.Complex).value },
      ]);
    case "None":
      return vector_to_llist([{ type: "string", value: "literal" }, None]);
    case "Variable":
      return vector_to_llist([
        { type: "string", value: "name" },
        { type: "string", value: (node as ExprNS.Variable).name.lexeme },
      ]);
    case "Binary":
      return vector_to_llist([
        { type: "string", value: "binary_operator_combination" },
        {
          type: "string",
          value: operatorTranslator((node as ExprNS.Binary).operator.type),
        },
        transform((node as ExprNS.Binary).left, declaredNames),
        transform((node as ExprNS.Binary).right, declaredNames),
      ]);
    case "BoolOp":
      return vector_to_llist([
        { type: "string", value: "logical_composition" },
        {
          type: "string",
          value: operatorTranslator((node as ExprNS.BoolOp).operator.type),
        },
        transform((node as ExprNS.BoolOp).left, declaredNames),
        transform((node as ExprNS.BoolOp).right, declaredNames),
      ]);
    case "Compare":
      return vector_to_llist([
        { type: "string", value: "comparison" },
        {
          type: "string",
          value: operatorTranslator((node as ExprNS.Compare).operator.type),
        },
        transform((node as ExprNS.Compare).left, declaredNames),
        transform((node as ExprNS.Compare).right, declaredNames),
      ]);
    case "Unary":
      return vector_to_llist([
        { type: "string", value: "unary_operator_combination" },
        {
          type: "string",
          value: operatorTranslator((node as ExprNS.Unary).operator.type),
        },
        transform((node as ExprNS.Unary).right, declaredNames),
      ]);
    case "Assign": {
      const assign = node as StmtNS.Assign;
      const isDecl =
        assign.target instanceof ExprNS.Variable && !declaredNames.has(assign.target.name.lexeme);
      if (isDecl && assign.target instanceof ExprNS.Variable) {
        declaredNames.add(assign.target.name.lexeme);
      }
      return vector_to_llist([
        { type: "string", value: isDecl ? "declaration" : "assignment" },
        transform(assign.target, declaredNames),
        transform(assign.value, declaredNames),
      ]);
    }
    case "AnnAssign":
      return vector_to_llist([
        { type: "string", value: "annotated_assignment" },
        transform((node as StmtNS.AnnAssign).target, declaredNames),
        transform((node as StmtNS.AnnAssign).ann, declaredNames),
        transform((node as StmtNS.AnnAssign).value, declaredNames),
      ]);
    case "Grouping":
      return transform((node as ExprNS.Grouping).expression, declaredNames);
    case "If":
      return vector_to_llist([
        { type: "string", value: "conditional_statement" },
        transform((node as StmtNS.If).condition, declaredNames),
        makeSequenceIfNeeded((node as StmtNS.If).body, declaredNames),
        makeSequenceIfNeeded((node as StmtNS.If).elseBlock, declaredNames),
      ]);
    case "Ternary":
      return vector_to_llist([
        { type: "string", value: "conditional_expression" },
        transform((node as ExprNS.Ternary).predicate, declaredNames),
        transform((node as ExprNS.Ternary).consequent, declaredNames),
        transform((node as ExprNS.Ternary).alternative, declaredNames),
      ]);
    case "While":
      return vector_to_llist([
        { type: "string", value: "while_loop" },
        transform((node as StmtNS.While).condition, declaredNames),
        makeSequenceIfNeeded((node as StmtNS.While).body, declaredNames),
      ]);
    case "For": {
      const forNode = node as StmtNS.For;
      return vector_to_llist([
        { type: "string", value: "for_loop" },
        vector_to_llist([
          { type: "string", value: "name" },
          { type: "string", value: forNode.target.lexeme },
        ]),
        transform(forNode.iter, declaredNames),
        makeSequenceIfNeeded(forNode.body, declaredNames),
      ]);
    }
    case "FunctionDef": {
      const fn = node as StmtNS.FunctionDef;
      return vector_to_llist([
        { type: "string", value: "function_declaration" },
        vector_to_llist([
          { type: "string", value: "name" },
          { type: "string", value: fn.name.lexeme },
        ]),
        vector_to_llist(fn.parameters.map(transformParam)),
        makeBlockIfNeeded(fn.body, declaredNames),
      ]);
    }
    case "Lambda": {
      const lam = node as ExprNS.Lambda;
      return vector_to_llist([
        { type: "string", value: "lambda_expression" },
        vector_to_llist(lam.parameters.map(transformParam)),
        vector_to_llist([
          { type: "string", value: "return_statement" },
          transform(lam.body, declaredNames),
        ]),
      ]);
    }
    case "MultiLambda": {
      const lam = node as ExprNS.MultiLambda;
      return vector_to_llist([
        { type: "string", value: "lambda_expression" },
        vector_to_llist(lam.parameters.map(transformParam)),
        makeBlockIfNeeded(lam.body, declaredNames),
      ]);
    }
    case "Return":
      return vector_to_llist([
        { type: "string", value: "return_statement" },
        transform((node as StmtNS.Return).value, declaredNames),
      ]);
    case "Call":
      return vector_to_llist([
        { type: "string", value: "application" },
        transform((node as ExprNS.Call).callee, declaredNames),
        vector_to_llist((node as ExprNS.Call).args.map(arg => transform(arg, declaredNames))),
      ]);
    case "List":
      return vector_to_llist([
        { type: "string", value: "array_expression" },
        vector_to_llist((node as ExprNS.List).elements.map(el => transform(el, declaredNames))),
      ]);
    case "Subscript":
      return vector_to_llist([
        { type: "string", value: "object_access" },
        transform((node as ExprNS.Subscript).value, declaredNames),
        transform((node as ExprNS.Subscript).index, declaredNames),
      ]);
    case "Starred":
      return vector_to_llist([
        { type: "string", value: "starred_expression" },
        transform((node as ExprNS.Starred).value, declaredNames),
      ]);
    case "FromImport":
      return vector_to_llist([
        { type: "string", value: "import_from" },
        { type: "string", value: (node as StmtNS.FromImport).module.lexeme },
        vector_to_llist(
          (node as StmtNS.FromImport).names.map(n => ({ type: "string", value: n.name.lexeme })),
        ),
      ]);
    case "Global":
      return vector_to_llist([
        { type: "string", value: "global_statement" },
        { type: "string", value: (node as StmtNS.Global).name.lexeme },
      ]);
    case "NonLocal":
      return vector_to_llist([
        { type: "string", value: "nonlocal_statement" },
        { type: "string", value: (node as StmtNS.NonLocal).name.lexeme },
      ]);
    case "Assert":
      return vector_to_llist([
        { type: "string", value: "assert_statement" },
        transform((node as StmtNS.Assert).value, declaredNames),
      ]);
    case "Pass":
      return vector_to_llist([{ type: "string", value: "pass_statement" }]);
    case "Break":
      return vector_to_llist([{ type: "string", value: "break_statement" }]);
    case "Continue":
      return vector_to_llist([{ type: "string", value: "continue_statement" }]);
    default:
      throw new Error("Cannot transform unknown type: " + type);
  }
}

class ParserBuiltins {
  @Validate(1, 1, "parse", false)
  static parse(args: Value[], source: string, command: ExprNS.Call, context: Context): Value {
    if (args[0].type !== "string") {
      handleRuntimeError(context, new TypeError(source, command, context, args[0].type, "string"));
    }
    const x = args[0].value;
    const program = parse(x + "\n");
    const declaredNames = new Set<string>();
    return transform(program, declaredNames);
  }

  @Validate(2, 2, "apply_in_underlying_python", false)
  static async apply_in_underlying_python(
    args: Value[],
    source: string,
    command: ExprNS.Call,
    context: Context,
  ): Promise<Value | undefined> {
    const func = args[0];
    const argList = args[1];
    const argArray: Value[] = [];
    let current = argList;
    while (current && current.type === "list" && current.value.length === 2) {
      argArray.push(current.value[0]);
      current = current.value[1];
    }

    if (func.type === "builtin") {
      return func.func(argArray, source, command, context);
    }
    context.stash.push(func);
    argArray.forEach(arg => context.stash.push(arg));
    context.control.push(appInstr(argArray.length, command));
  }

  @Validate(1, 1, "tokenize", false)
  static tokenize(args: Value[], source: string, command: ExprNS.Call, context: Context): Value {
    if (args[0].type !== "string") {
      handleRuntimeError(context, new TypeError(source, command, context, args[0].type, "string"));
    }
    const x = args[0].value;
    pythonLexer.reset(x);
    const tokens: StringValue[] = [];
    let tok;
    while ((tok = pythonLexer.next())) {
      tokens.push({ type: "string", value: tok.value });
    }
    return vector_to_llist(tokens);
  }
}

const parserBuiltins = new Map<string, BuiltinValue>();
for (const builtin of Object.getOwnPropertyNames(ParserBuiltins)) {
  const member = (ParserBuiltins as unknown as Record<string, unknown>)[builtin];
  if (typeof member === "function" && !builtin.startsWith("_")) {
    const fn = member as BuiltinValue["func"];
    parserBuiltins.set(builtin, {
      type: "builtin",
      func: fn,
      name: builtin,
      minArgs: minArgMap.get(builtin) || 0,
    });
  }
}

export default {
  name: GroupName.MCE,
  prelude: "",
  builtins: parserBuiltins,
};

1	import { ExprNS, FunctionParam, StmtNS } from "../ast-types";	1✔
2	import { Context } from "../engines/cse/context";
3	import { handleRuntimeError } from "../engines/cse/error";	1✔
4	import { appInstr } from "../engines/cse/instrCreator";	1✔
5	import { BuiltinValue, ListValue, NoneValue, StringValue, Value } from "../engines/cse/stash";
6	import { operatorTranslator } from "../engines/cse/types";	1✔
7	import { TypeError } from "../errors/errors";	1✔
8	import { parse } from "../parser";	1✔
9	import pythonLexer from "../parser/lexer";	1✔
10	import { GroupName, minArgMap, Validate } from "./utils";	1✔
11
12	const None: NoneValue = { type: "none" };	1✔
13
14	function pair(h: Value, t: Value): ListValue {
15	return { type: "list", value: [h, t] };	626✔
16	}
17
18	function vector_to_llist(arr: Value[]): ListValue \| NoneValue {
19	let res: ListValue \| NoneValue = None;	281✔
20	for (let i = arr.length - 1; i >= 0; i--) {	281✔
21	res = pair(arr[i], res);	626✔
22	}
23	return res;	281✔
24	}
25
26	function isDeclaration(node: StmtNS.Stmt \| null \| undefined): boolean {
27	if (!node) return false;	12!
28	const type = node.kind;	12✔
29	return type === "FunctionDef" \|\| type === "Assign" \|\| type === "AnnAssign";	12✔
30	}
31
32	function hasDeclaration(statements: StmtNS.Stmt[]): boolean {
33	return statements.some(isDeclaration);	12✔
34	}
35
36	function makeSequenceIfNeeded(
37	statements: StmtNS.Stmt[] \| StmtNS.Stmt \| null \| undefined,
38	declaredNames: Set<string>,
39	): Value {
40	if (!statements) return None;	94✔
41	if (!Array.isArray(statements)) return transform(statements, declaredNames);	93!
42	if (statements.length === 0) {	93!
43	return None;	×
44	}
45	if (statements.length === 1) {	93✔
46	return transform(statements[0], declaredNames);	86✔
47	}
48	return vector_to_llist([	7✔
49	{ type: "string", value: "sequence" },
50	vector_to_llist(statements.map(stmt => transform(stmt, declaredNames))),	17✔
51	]);
52	}
53
54	function makeBlockIfNeeded(statements: StmtNS.Stmt[], declaredNames: Set<string>): Value {
55	return hasDeclaration(statements)	12✔
56	? vector_to_llist([
57	{ type: "string", value: "block" },
58	makeSequenceIfNeeded(statements, declaredNames),
59	])
60	: makeSequenceIfNeeded(statements, declaredNames);
61	}
62
63	function transformParam(p: FunctionParam): Value {
64	const nameNode = vector_to_llist([	8✔
65	{ type: "string", value: "name" },
66	{ type: "string", value: p.lexeme },
67	]);
68	if (p.isStarred) {	8✔
69	return vector_to_llist([{ type: "string", value: "rest_element" }, nameNode]);	1✔
70	}
71	return nameNode;	7✔
72	}
73
74	function transform(
75	node: ExprNS.Expr \| StmtNS.Stmt \| null \| undefined,
76	declaredNames: Set<string>,
77	): Value {
78	if (!node) return None;	334✔
79	const type = node.kind;	333✔
80	switch (type) {	333!
81	case "FileInput":
82	return makeSequenceIfNeeded((node as StmtNS.FileInput).statements, declaredNames);	72✔
83	case "SimpleExpr":
84	return transform((node as StmtNS.SimpleExpr).expression, declaredNames);	55✔
85	case "Literal": {
86	const lit = node as ExprNS.Literal;	17✔
87	let val: Value;
88	if (typeof lit.value === "number") val = { type: "number", value: lit.value };	17✔
89	else if (typeof lit.value === "boolean") val = { type: "bool", value: lit.value };	16✔
90	else if (typeof lit.value === "string") val = { type: "string", value: lit.value };	1!
91	else val = None;	×
92	return vector_to_llist([{ type: "string", value: "literal" }, val]);	17✔
93	}
94	case "BigIntLiteral":
95	return vector_to_llist([	71✔
96	{ type: "string", value: "literal" },
97	{ type: "bigint", value: BigInt((node as ExprNS.BigIntLiteral).value) },
98	]);
99	case "Complex":
100	return vector_to_llist([	2✔
101	{ type: "string", value: "literal" },
102	{ type: "complex", value: (node as ExprNS.Complex).value },
103	]);
104	case "None":
105	return vector_to_llist([{ type: "string", value: "literal" }, None]);	1✔
106	case "Variable":
107	return vector_to_llist([	28✔
108	{ type: "string", value: "name" },
109	{ type: "string", value: (node as ExprNS.Variable).name.lexeme },
110	]);
111	case "Binary":
112	return vector_to_llist([	10✔
113	{ type: "string", value: "binary_operator_combination" },
114	{
115	type: "string",
116	value: operatorTranslator((node as ExprNS.Binary).operator.type),
117	},
118	transform((node as ExprNS.Binary).left, declaredNames),
119	transform((node as ExprNS.Binary).right, declaredNames),
120	]);
121	case "BoolOp":
122	return vector_to_llist([	2✔
123	{ type: "string", value: "logical_composition" },
124	{
125	type: "string",
126	value: operatorTranslator((node as ExprNS.BoolOp).operator.type),
127	},
128	transform((node as ExprNS.BoolOp).left, declaredNames),
129	transform((node as ExprNS.BoolOp).right, declaredNames),
130	]);
131	case "Compare":
132	return vector_to_llist([	7✔
133	{ type: "string", value: "comparison" },
134	{
135	type: "string",
136	value: operatorTranslator((node as ExprNS.Compare).operator.type),
137	},
138	transform((node as ExprNS.Compare).left, declaredNames),
139	transform((node as ExprNS.Compare).right, declaredNames),
140	]);
141	case "Unary":
142	return vector_to_llist([	2✔
143	{ type: "string", value: "unary_operator_combination" },
144	{
145	type: "string",
146	value: operatorTranslator((node as ExprNS.Unary).operator.type),
147	},
148	transform((node as ExprNS.Unary).right, declaredNames),
149	]);
150	case "Assign": {
151	const assign = node as StmtNS.Assign;	8✔
152	const isDecl =
153	assign.target instanceof ExprNS.Variable && !declaredNames.has(assign.target.name.lexeme);	8✔
154	if (isDecl && assign.target instanceof ExprNS.Variable) {	8✔
155	declaredNames.add(assign.target.name.lexeme);	7✔
156	}
157	return vector_to_llist([	8✔
158	{ type: "string", value: isDecl ? "declaration" : "assignment" },	8✔
159	transform(assign.target, declaredNames),
160	transform(assign.value, declaredNames),
161	]);
162	}
163	case "AnnAssign":
NEW 164	return vector_to_llist([	×
165	{ type: "string", value: "annotated_assignment" },
166	transform((node as StmtNS.AnnAssign).target, declaredNames),
167	transform((node as StmtNS.AnnAssign).ann, declaredNames),
168	transform((node as StmtNS.AnnAssign).value, declaredNames),
169	]);
170	case "Grouping":
171	return transform((node as ExprNS.Grouping).expression, declaredNames);	×
172	case "If":
173	return vector_to_llist([	2✔
174	{ type: "string", value: "conditional_statement" },
175	transform((node as StmtNS.If).condition, declaredNames),
176	makeSequenceIfNeeded((node as StmtNS.If).body, declaredNames),
177	makeSequenceIfNeeded((node as StmtNS.If).elseBlock, declaredNames),
178	]);
179	case "Ternary":
180	return vector_to_llist([	1✔
181	{ type: "string", value: "conditional_expression" },
182	transform((node as ExprNS.Ternary).predicate, declaredNames),
183	transform((node as ExprNS.Ternary).consequent, declaredNames),
184	transform((node as ExprNS.Ternary).alternative, declaredNames),
185	]);
186	case "While":
187	return vector_to_llist([	4✔
188	{ type: "string", value: "while_loop" },
189	transform((node as StmtNS.While).condition, declaredNames),
190	makeSequenceIfNeeded((node as StmtNS.While).body, declaredNames),
191	]);
192	case "For": {
193	const forNode = node as StmtNS.For;	2✔
194	return vector_to_llist([	2✔
195	{ type: "string", value: "for_loop" },
196	vector_to_llist([
197	{ type: "string", value: "name" },
198	{ type: "string", value: forNode.target.lexeme },
199	]),
200	transform(forNode.iter, declaredNames),
201	makeSequenceIfNeeded(forNode.body, declaredNames),
202	]);
203	}
204	case "FunctionDef": {
205	const fn = node as StmtNS.FunctionDef;	12✔
206	return vector_to_llist([	12✔
207	{ type: "string", value: "function_declaration" },
208	vector_to_llist([
209	{ type: "string", value: "name" },
210	{ type: "string", value: fn.name.lexeme },
211	]),
212	vector_to_llist(fn.parameters.map(transformParam)),
213	makeBlockIfNeeded(fn.body, declaredNames),
214	]);
215	}
216	case "Lambda": {
217	const lam = node as ExprNS.Lambda;	3✔
218	return vector_to_llist([	3✔
219	{ type: "string", value: "lambda_expression" },
220	vector_to_llist(lam.parameters.map(transformParam)),
221	vector_to_llist([
222	{ type: "string", value: "return_statement" },
223	transform(lam.body, declaredNames),
224	]),
225	]);
226	}
227	case "MultiLambda": {
228	const lam = node as ExprNS.MultiLambda;	×
NEW 229	return vector_to_llist([	×
230	{ type: "string", value: "lambda_expression" },
231	vector_to_llist(lam.parameters.map(transformParam)),
232	makeBlockIfNeeded(lam.body, declaredNames),
233	]);
234	}
235	case "Return":
236	return vector_to_llist([	8✔
237	{ type: "string", value: "return_statement" },
238	transform((node as StmtNS.Return).value, declaredNames),
239	]);
240	case "Call":
241	return vector_to_llist([	8✔
242	{ type: "string", value: "application" },
243	transform((node as ExprNS.Call).callee, declaredNames),
244	vector_to_llist((node as ExprNS.Call).args.map(arg => transform(arg, declaredNames))),	8✔
245	]);
246	case "List":
247	return vector_to_llist([	4✔
248	{ type: "string", value: "array_expression" },
249	vector_to_llist((node as ExprNS.List).elements.map(el => transform(el, declaredNames))),	5✔
250	]);
251	case "Subscript":
252	return vector_to_llist([	1✔
253	{ type: "string", value: "object_access" },
254	transform((node as ExprNS.Subscript).value, declaredNames),
255	transform((node as ExprNS.Subscript).index, declaredNames),
256	]);
257	case "Starred":
258	return vector_to_llist([	1✔
259	{ type: "string", value: "starred_expression" },
260	transform((node as ExprNS.Starred).value, declaredNames),
261	]);
262	case "FromImport":
263	return vector_to_llist([	2✔
264	{ type: "string", value: "import_from" },
265	{ type: "string", value: (node as StmtNS.FromImport).module.lexeme },
266	vector_to_llist(
267	(node as StmtNS.FromImport).names.map(n => ({ type: "string", value: n.name.lexeme })),	3✔
268	),
269	]);
270	case "Global":
271	return vector_to_llist([	1✔
272	{ type: "string", value: "global_statement" },
273	{ type: "string", value: (node as StmtNS.Global).name.lexeme },
274	]);
275	case "NonLocal":
276	return vector_to_llist([	1✔
277	{ type: "string", value: "nonlocal_statement" },
278	{ type: "string", value: (node as StmtNS.NonLocal).name.lexeme },
279	]);
280	case "Assert":
281	return vector_to_llist([	2✔
282	{ type: "string", value: "assert_statement" },
283	transform((node as StmtNS.Assert).value, declaredNames),
284	]);
285	case "Pass":
286	return vector_to_llist([{ type: "string", value: "pass_statement" }]);	4✔
287	case "Break":
288	return vector_to_llist([{ type: "string", value: "break_statement" }]);	1✔
289	case "Continue":
290	return vector_to_llist([{ type: "string", value: "continue_statement" }]);	1✔
291	default:
292	throw new Error("Cannot transform unknown type: " + type);	×
293	}
294	}
295
296	class ParserBuiltins {
297	@Validate(1, 1, "parse", false)
298	static parse(args: Value[], source: string, command: ExprNS.Call, context: Context): Value {	1✔
299	if (args[0].type !== "string") {	77✔
300	handleRuntimeError(context, new TypeError(source, command, context, args[0].type, "string"));	5✔
301	}
302	const x = args[0].value;	72✔
303	const program = parse(x + "\n");	72✔
304	const declaredNames = new Set<string>();	72✔
305	return transform(program, declaredNames);	72✔
306	}
307
308	@Validate(2, 2, "apply_in_underlying_python", false)
309	static async apply_in_underlying_python(	1✔
310	args: Value[],
311	source: string,
312	command: ExprNS.Call,
313	context: Context,
314	): Promise<Value \| undefined> {
315	const func = args[0];	14✔
316	const argList = args[1];	14✔
317	const argArray: Value[] = [];	14✔
318	let current = argList;	14✔
319	while (current && current.type === "list" && current.value.length === 2) {	14✔
320	argArray.push(current.value[0]);	23✔
321	current = current.value[1];	23✔
322	}
323
324	if (func.type === "builtin") {	14✔
325	return func.func(argArray, source, command, context);	7✔
326	}
327	context.stash.push(func);	7✔
328	argArray.forEach(arg => context.stash.push(arg));	11✔
329	context.control.push(appInstr(argArray.length, command));	7✔
330	}
331
332	@Validate(1, 1, "tokenize", false)
333	static tokenize(args: Value[], source: string, command: ExprNS.Call, context: Context): Value {	1✔
334	if (args[0].type !== "string") {	6✔
335	handleRuntimeError(context, new TypeError(source, command, context, args[0].type, "string"));	3✔
336	}
337	const x = args[0].value;	3✔
338	pythonLexer.reset(x);	3✔
339	const tokens: StringValue[] = [];	3✔
340	let tok;
341	while ((tok = pythonLexer.next())) {	3✔
342	tokens.push({ type: "string", value: tok.value });	7✔
343	}
344	return vector_to_llist(tokens);	3✔
345	}
346	}
347
348	const parserBuiltins = new Map<string, BuiltinValue>();	1✔
349	for (const builtin of Object.getOwnPropertyNames(ParserBuiltins)) {	1✔
350	const member = (ParserBuiltins as unknown as Record<string, unknown>)[builtin];	6✔
351	if (typeof member === "function" && !builtin.startsWith("_")) {	6✔
352	const fn = member as BuiltinValue["func"];	3✔
353	parserBuiltins.set(builtin, {	3✔
354	type: "builtin",
355	func: fn,
356	name: builtin,
357	minArgs: minArgMap.get(builtin) \|\| 0,	3!
358	});
359	}
360	}
361
362	export default {	1✔
363	name: GroupName.MCE,
364	prelude: "",
365	builtins: parserBuiltins,
366	};

source-academy / py-slang / 28708329040

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