23790160202

Committed 31 Mar 2026 09:24AM UTC coverage: 62.878% (+3.5%) from 59.421%

Build # 23790160202

Build Type

Pull #129

github

Committed by

web-flow

Commit Message

Merge b68958bdb into 0e5a36381

Pull Request Pull Request #129: Add new standard library functions

Coverage Stats

778 of 1450 branches covered (53.66%)

Branch coverage included in aggregate %.

64 of 107 new or added lines in 8 files covered. (59.81%)

129 existing lines in 14 files now uncovered.

2547 of 3838 relevant lines covered (66.36%)

3347.98 hits per line

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

93.53

/src/ast-types.ts

// This file is autogenerated by generate-ast.ts. DO NOT EDIT THIS FILE DIRECTLY.
import { Token } from "./tokenizer";
import { PyComplexNumber } from "./types";

export type FunctionParam = Token & { isStarred: boolean };
export type AssignTarget = ExprNS.Variable | ExprNS.Subscript;
export namespace ExprNS {
  export interface Visitor<T> {
    visitBigIntLiteralExpr(expr: BigIntLiteral): T;
    visitBinaryExpr(expr: Binary): T;
    visitCompareExpr(expr: Compare): T;
    visitBoolOpExpr(expr: BoolOp): T;
    visitGroupingExpr(expr: Grouping): T;
    visitLiteralExpr(expr: Literal): T;
    visitUnaryExpr(expr: Unary): T;
    visitTernaryExpr(expr: Ternary): T;
    visitLambdaExpr(expr: Lambda): T;
    visitMultiLambdaExpr(expr: MultiLambda): T;
    visitVariableExpr(expr: Variable): T;
    visitCallExpr(expr: Call): T;
    visitListExpr(expr: List): T;
    visitSubscriptExpr(expr: Subscript): T;
    visitStarredExpr(expr: Starred): T;
    visitNoneExpr(expr: None): T;
    visitComplexExpr(expr: Complex): T;
  }
  export abstract class Expr {
    abstract readonly kind: string;
    startToken: Token;
    endToken: Token;
    protected constructor(startToken: Token, endToken: Token) {
      this.startToken = startToken;
      this.endToken = endToken;
    }
    abstract accept(visitor: Visitor<any>): any;
  }
  export class BigIntLiteral extends Expr {
    readonly kind = "BigIntLiteral";
    value: string;
    constructor(startToken: Token, endToken: Token, value: string) {
      super(startToken, endToken);
      this.value = value;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitBigIntLiteralExpr(this);
    }
  }
  export class Binary extends Expr {
    readonly kind = "Binary";
    left: Expr;
    operator: Token;
    right: Expr;
    constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr) {
      super(startToken, endToken);
      this.left = left;
      this.operator = operator;
      this.right = right;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitBinaryExpr(this);
    }
  }
  export class Compare extends Expr {
    readonly kind = "Compare";
    left: Expr;
    operator: Token;
    right: Expr;
    constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr) {
      super(startToken, endToken);
      this.left = left;
      this.operator = operator;
      this.right = right;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitCompareExpr(this);
    }
  }
  export class BoolOp extends Expr {
    readonly kind = "BoolOp";
    left: Expr;
    operator: Token;
    right: Expr;
    constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr) {
      super(startToken, endToken);
      this.left = left;
      this.operator = operator;
      this.right = right;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitBoolOpExpr(this);
    }
  }
  export class Grouping extends Expr {
    readonly kind = "Grouping";
    expression: Expr;
    constructor(startToken: Token, endToken: Token, expression: Expr) {
      super(startToken, endToken);
      this.expression = expression;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitGroupingExpr(this);
    }
  }
  export class Literal extends Expr {
    readonly kind = "Literal";
    value: true | false | number | string;
    constructor(startToken: Token, endToken: Token, value: true | false | number | string) {
      super(startToken, endToken);
      this.value = value;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitLiteralExpr(this);
    }
  }
  export class Unary extends Expr {
    readonly kind = "Unary";
    operator: Token;
    right: Expr;
    constructor(startToken: Token, endToken: Token, operator: Token, right: Expr) {
      super(startToken, endToken);
      this.operator = operator;
      this.right = right;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitUnaryExpr(this);
    }
  }
  export class Ternary extends Expr {
    readonly kind = "Ternary";
    predicate: Expr;
    consequent: Expr;
    alternative: Expr;
    constructor(
      startToken: Token,
      endToken: Token,
      predicate: Expr,
      consequent: Expr,
      alternative: Expr,
    ) {
      super(startToken, endToken);
      this.predicate = predicate;
      this.consequent = consequent;
      this.alternative = alternative;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitTernaryExpr(this);
    }
  }
  export class Lambda extends Expr {
    readonly kind = "Lambda";
    parameters: FunctionParam[];
    body: Expr;
    constructor(startToken: Token, endToken: Token, parameters: FunctionParam[], body: Expr) {
      super(startToken, endToken);
      this.parameters = parameters;
      this.body = body;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitLambdaExpr(this);
    }
  }
  export class MultiLambda extends Expr {
    readonly kind = "MultiLambda";
    parameters: FunctionParam[];
    body: StmtNS.Stmt[];
    varDecls: Token[];
    constructor(
      startToken: Token,
      endToken: Token,
      parameters: FunctionParam[],
      body: StmtNS.Stmt[],
      varDecls: Token[],
    ) {
      super(startToken, endToken);
      this.parameters = parameters;
      this.body = body;
      this.varDecls = varDecls;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitMultiLambdaExpr(this);
    }
  }
  export class Variable extends Expr {
    readonly kind = "Variable";
    name: Token;
    constructor(startToken: Token, endToken: Token, name: Token) {
      super(startToken, endToken);
      this.name = name;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitVariableExpr(this);
    }
  }
  export class Call extends Expr {
    readonly kind = "Call";
    callee: Expr;
    args: Expr[];
    constructor(startToken: Token, endToken: Token, callee: Expr, args: Expr[]) {
      super(startToken, endToken);
      this.callee = callee;
      this.args = args;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitCallExpr(this);
    }
  }
  export class List extends Expr {
    readonly kind = "List";
    elements: Expr[];
    constructor(startToken: Token, endToken: Token, elements: Expr[]) {
      super(startToken, endToken);
      this.elements = elements;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitListExpr(this);
    }
  }
  export class Subscript extends Expr {
    readonly kind = "Subscript";
    value: Expr;
    index: Expr;
    constructor(startToken: Token, endToken: Token, value: Expr, index: Expr) {
      super(startToken, endToken);
      this.value = value;
      this.index = index;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitSubscriptExpr(this);
    }
  }
  export class Starred extends Expr {
    readonly kind = "Starred";
    value: Expr;
    constructor(startToken: Token, endToken: Token, value: Expr) {
      super(startToken, endToken);
      this.value = value;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitStarredExpr(this);
    }
  }
  export class None extends Expr {
    readonly kind = "None";
    constructor(startToken: Token, endToken: Token) {
      super(startToken, endToken);
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitNoneExpr(this);
    }
  }
  export class Complex extends Expr {
    readonly kind = "Complex";
    value: PyComplexNumber;
    constructor(startToken: Token, endToken: Token, value: string) {
      super(startToken, endToken);
      this.value = PyComplexNumber.fromString(value);
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitComplexExpr(this);
    }
  }
}
export namespace StmtNS {
  export interface Visitor<T> {
    visitPassStmt(stmt: Pass): T;
    visitAssignStmt(stmt: Assign): T;
    visitAnnAssignStmt(stmt: AnnAssign): T;
    visitBreakStmt(stmt: Break): T;
    visitContinueStmt(stmt: Continue): T;
    visitReturnStmt(stmt: Return): T;
    visitFromImportStmt(stmt: FromImport): T;
    visitGlobalStmt(stmt: Global): T;
    visitNonLocalStmt(stmt: NonLocal): T;
    visitAssertStmt(stmt: Assert): T;
    visitIfStmt(stmt: If): T;
    visitWhileStmt(stmt: While): T;
    visitForStmt(stmt: For): T;
    visitFunctionDefStmt(stmt: FunctionDef): T;
    visitSimpleExprStmt(stmt: SimpleExpr): T;
    visitFileInputStmt(stmt: FileInput): T;
  }
  export abstract class Stmt {
    abstract readonly kind: string;
    startToken: Token;
    endToken: Token;
    protected constructor(startToken: Token, endToken: Token) {
      this.startToken = startToken;
      this.endToken = endToken;
    }
    abstract accept(visitor: Visitor<any>): any;
  }
  export class Pass extends Stmt {
    readonly kind = "Pass";
    constructor(startToken: Token, endToken: Token) {
      super(startToken, endToken);
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitPassStmt(this);
    }
  }
  export class Assign extends Stmt {
    readonly kind = "Assign";
    target: AssignTarget;
    value: ExprNS.Expr;
    constructor(startToken: Token, endToken: Token, target: AssignTarget, value: ExprNS.Expr) {
      super(startToken, endToken);
      this.target = target;
      this.value = value;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitAssignStmt(this);
    }
  }
  export class AnnAssign extends Stmt {
    readonly kind = "AnnAssign";
    target: ExprNS.Variable;
    value: ExprNS.Expr;
    ann: ExprNS.Expr;
    constructor(
      startToken: Token,
      endToken: Token,
      target: ExprNS.Variable,
      value: ExprNS.Expr,
      ann: ExprNS.Expr,
    ) {
      super(startToken, endToken);
      this.target = target;
      this.value = value;
      this.ann = ann;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitAnnAssignStmt(this);
    }
  }
  export class Break extends Stmt {
    readonly kind = "Break";
    constructor(startToken: Token, endToken: Token) {
      super(startToken, endToken);
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitBreakStmt(this);
    }
  }
  export class Continue extends Stmt {
    readonly kind = "Continue";
    constructor(startToken: Token, endToken: Token) {
      super(startToken, endToken);
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitContinueStmt(this);
    }
  }
  export class Return extends Stmt {
    readonly kind = "Return";
    value: ExprNS.Expr | null;
    constructor(startToken: Token, endToken: Token, value: ExprNS.Expr | null) {
      super(startToken, endToken);
      this.value = value;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitReturnStmt(this);
    }
  }
  export class FromImport extends Stmt {
    readonly kind = "FromImport";
    module: Token;
    names: { name: Token; alias: Token | null }[];
    constructor(
      startToken: Token,
      endToken: Token,
      module: Token,
      names: { name: Token; alias: Token | null }[],
    ) {
      super(startToken, endToken);
      this.module = module;
      this.names = names;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitFromImportStmt(this);
    }
  }
  export class Global extends Stmt {
    readonly kind = "Global";
    name: Token;
    constructor(startToken: Token, endToken: Token, name: Token) {
      super(startToken, endToken);
      this.name = name;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitGlobalStmt(this);
    }
  }
  export class NonLocal extends Stmt {
    readonly kind = "NonLocal";
    name: Token;
    constructor(startToken: Token, endToken: Token, name: Token) {
      super(startToken, endToken);
      this.name = name;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitNonLocalStmt(this);
    }
  }
  export class Assert extends Stmt {
    readonly kind = "Assert";
    value: ExprNS.Expr;
    constructor(startToken: Token, endToken: Token, value: ExprNS.Expr) {
      super(startToken, endToken);
      this.value = value;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitAssertStmt(this);
    }
  }
  export class If extends Stmt {
    readonly kind = "If";
    condition: ExprNS.Expr;
    body: Stmt[];
    elseBlock: Stmt[] | null;
    constructor(
      startToken: Token,
      endToken: Token,
      condition: ExprNS.Expr,
      body: Stmt[],
      elseBlock: Stmt[] | null,
    ) {
      super(startToken, endToken);
      this.condition = condition;
      this.body = body;
      this.elseBlock = elseBlock;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitIfStmt(this);
    }
  }
  export class While extends Stmt {
    readonly kind = "While";
    condition: ExprNS.Expr;
    body: Stmt[];
    constructor(startToken: Token, endToken: Token, condition: ExprNS.Expr, body: Stmt[]) {
      super(startToken, endToken);
      this.condition = condition;
      this.body = body;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitWhileStmt(this);
    }
  }
  export class For extends Stmt {
    readonly kind = "For";
    target: Token;
    iter: ExprNS.Expr;
    body: Stmt[];
    constructor(
      startToken: Token,
      endToken: Token,
      target: Token,
      iter: ExprNS.Expr,
      body: Stmt[],
    ) {
      super(startToken, endToken);
      this.target = target;
      this.iter = iter;
      this.body = body;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitForStmt(this);
    }
  }
  export class FunctionDef extends Stmt {
    readonly kind = "FunctionDef";
    name: Token;
    parameters: FunctionParam[];
    body: Stmt[];
    varDecls: Token[];
    constructor(
      startToken: Token,
      endToken: Token,
      name: Token,
      parameters: FunctionParam[],
      body: Stmt[],
      varDecls: Token[],
    ) {
      super(startToken, endToken);
      this.name = name;
      this.parameters = parameters;
      this.body = body;
      this.varDecls = varDecls;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitFunctionDefStmt(this);
    }
  }
  export class SimpleExpr extends Stmt {
    readonly kind = "SimpleExpr";
    expression: ExprNS.Expr;
    constructor(startToken: Token, endToken: Token, expression: ExprNS.Expr) {
      super(startToken, endToken);
      this.expression = expression;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitSimpleExprStmt(this);
    }
  }
  export class FileInput extends Stmt {
    readonly kind = "FileInput";
    statements: Stmt[];
    varDecls: Token[];
    constructor(startToken: Token, endToken: Token, statements: Stmt[], varDecls: Token[]) {
      super(startToken, endToken);
      this.statements = statements;
      this.varDecls = varDecls;
    }
    override accept(visitor: Visitor<any>): any {
      return visitor.visitFileInputStmt(this);
    }
  }
}

1	// This file is autogenerated by generate-ast.ts. DO NOT EDIT THIS FILE DIRECTLY.
2	import { Token } from "./tokenizer";
3	import { PyComplexNumber } from "./types";	6✔
4
5	export type FunctionParam = Token & { isStarred: boolean };
6	export type AssignTarget = ExprNS.Variable \| ExprNS.Subscript;
7	export namespace ExprNS {	6✔
8	export interface Visitor<T> {
9	visitBigIntLiteralExpr(expr: BigIntLiteral): T;
10	visitBinaryExpr(expr: Binary): T;
11	visitCompareExpr(expr: Compare): T;
12	visitBoolOpExpr(expr: BoolOp): T;
13	visitGroupingExpr(expr: Grouping): T;
14	visitLiteralExpr(expr: Literal): T;
15	visitUnaryExpr(expr: Unary): T;
16	visitTernaryExpr(expr: Ternary): T;
17	visitLambdaExpr(expr: Lambda): T;
18	visitMultiLambdaExpr(expr: MultiLambda): T;
19	visitVariableExpr(expr: Variable): T;
20	visitCallExpr(expr: Call): T;
21	visitListExpr(expr: List): T;
22	visitSubscriptExpr(expr: Subscript): T;
23	visitStarredExpr(expr: Starred): T;
24	visitNoneExpr(expr: None): T;
25	visitComplexExpr(expr: Complex): T;
26	}
27	export abstract class Expr {	6✔
28	abstract readonly kind: string;
29	startToken: Token;
30	endToken: Token;
31	protected constructor(startToken: Token, endToken: Token) {
32	this.startToken = startToken;	122,500✔
33	this.endToken = endToken;	122,500✔
34	}
35	abstract accept(visitor: Visitor<any>): any;
36	}
37	export class BigIntLiteral extends Expr {	6✔
38	readonly kind = "BigIntLiteral";	3,348✔
39	value: string;
40	constructor(startToken: Token, endToken: Token, value: string) {
41	super(startToken, endToken);	3,348✔
42	this.value = value;	3,348✔
43	}
44	override accept(visitor: Visitor<any>): any {
45	return visitor.visitBigIntLiteralExpr(this);	1,002✔
46	}
47	}
48	export class Binary extends Expr {	6✔
49	readonly kind = "Binary";	2,653✔
50	left: Expr;
51	operator: Token;
52	right: Expr;
53	constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr) {
54	super(startToken, endToken);	2,653✔
55	this.left = left;	2,653✔
56	this.operator = operator;	2,653✔
57	this.right = right;	2,653✔
58	}
59	override accept(visitor: Visitor<any>): any {
60	return visitor.visitBinaryExpr(this);	558✔
61	}
62	}
63	export class Compare extends Expr {	6✔
64	readonly kind = "Compare";	3,152✔
65	left: Expr;
66	operator: Token;
67	right: Expr;
68	constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr) {
69	super(startToken, endToken);	3,152✔
70	this.left = left;	3,152✔
71	this.operator = operator;	3,152✔
72	this.right = right;	3,152✔
73	}
74	override accept(visitor: Visitor<any>): any {
75	return visitor.visitCompareExpr(this);	317✔
76	}
77	}
78	export class BoolOp extends Expr {	6✔
79	readonly kind = "BoolOp";	4,901✔
80	left: Expr;
81	operator: Token;
82	right: Expr;
83	constructor(startToken: Token, endToken: Token, left: Expr, operator: Token, right: Expr) {
84	super(startToken, endToken);	4,901✔
85	this.left = left;	4,901✔
86	this.operator = operator;	4,901✔
87	this.right = right;	4,901✔
88	}
89	override accept(visitor: Visitor<any>): any {
90	return visitor.visitBoolOpExpr(this);	34✔
91	}
92	}
93	export class Grouping extends Expr {	6✔
94	readonly kind = "Grouping";	2,741✔
95	expression: Expr;
96	constructor(startToken: Token, endToken: Token, expression: Expr) {
97	super(startToken, endToken);	2,741✔
98	this.expression = expression;	2,741✔
99	}
100	override accept(visitor: Visitor<any>): any {
101	return visitor.visitGroupingExpr(this);	204✔
102	}
103	}
104	export class Literal extends Expr {	6✔
105	readonly kind = "Literal";	6,608✔
106	value: true \| false \| number \| string;
107	constructor(startToken: Token, endToken: Token, value: true \| false \| number \| string) {
108	super(startToken, endToken);	6,608✔
109	this.value = value;	6,608✔
110	}
111	override accept(visitor: Visitor<any>): any {
112	return visitor.visitLiteralExpr(this);	752✔
113	}
114	}
115	export class Unary extends Expr {	6✔
116	readonly kind = "Unary";	709✔
117	operator: Token;
118	right: Expr;
119	constructor(startToken: Token, endToken: Token, operator: Token, right: Expr) {
120	super(startToken, endToken);	709✔
121	this.operator = operator;	709✔
122	this.right = right;	709✔
123	}
124	override accept(visitor: Visitor<any>): any {
125	return visitor.visitUnaryExpr(this);	46✔
126	}
127	}
128	export class Ternary extends Expr {	6✔
129	readonly kind = "Ternary";	4,458✔
130	predicate: Expr;
131	consequent: Expr;
132	alternative: Expr;
133	constructor(
134	startToken: Token,
135	endToken: Token,
136	predicate: Expr,
137	consequent: Expr,
138	alternative: Expr,
139	) {
140	super(startToken, endToken);	4,458✔
141	this.predicate = predicate;	4,458✔
142	this.consequent = consequent;	4,458✔
143	this.alternative = alternative;	4,458✔
144	}
145	override accept(visitor: Visitor<any>): any {
UNCOV 146	return visitor.visitTernaryExpr(this);	×
147	}
148	}
149	export class Lambda extends Expr {	6✔
150	readonly kind = "Lambda";	2,926✔
151	parameters: FunctionParam[];
152	body: Expr;
153	constructor(startToken: Token, endToken: Token, parameters: FunctionParam[], body: Expr) {
154	super(startToken, endToken);	2,926✔
155	this.parameters = parameters;	2,926✔
156	this.body = body;	2,926✔
157	}
158	override accept(visitor: Visitor<any>): any {
159	return visitor.visitLambdaExpr(this);	94✔
160	}
161	}
162	export class MultiLambda extends Expr {	6✔
UNCOV 163	readonly kind = "MultiLambda";	×
164	parameters: FunctionParam[];
165	body: StmtNS.Stmt[];
166	varDecls: Token[];
167	constructor(
168	startToken: Token,
169	endToken: Token,
170	parameters: FunctionParam[],
171	body: StmtNS.Stmt[],
172	varDecls: Token[],
173	) {
174	super(startToken, endToken);	×
175	this.parameters = parameters;	×
176	this.body = body;	×
UNCOV 177	this.varDecls = varDecls;	×
178	}
179	override accept(visitor: Visitor<any>): any {
UNCOV 180	return visitor.visitMultiLambdaExpr(this);	×
181	}
182	}
183	export class Variable extends Expr {	6✔
184	readonly kind = "Variable";	60,461✔
185	name: Token;
186	constructor(startToken: Token, endToken: Token, name: Token) {
187	super(startToken, endToken);	60,461✔
188	this.name = name;	60,461✔
189	}
190	override accept(visitor: Visitor<any>): any {
191	return visitor.visitVariableExpr(this);	937✔
192	}
193	}
194	export class Call extends Expr {	6✔
195	readonly kind = "Call";	27,887✔
196	callee: Expr;
197	args: Expr[];
198	constructor(startToken: Token, endToken: Token, callee: Expr, args: Expr[]) {
199	super(startToken, endToken);	27,887✔
200	this.callee = callee;	27,887✔
201	this.args = args;	27,887✔
202	}
203	override accept(visitor: Visitor<any>): any {
204	return visitor.visitCallExpr(this);	643✔
205	}
206	}
207	export class List extends Expr {	6✔
208	readonly kind = "List";	38✔
209	elements: Expr[];
210	constructor(startToken: Token, endToken: Token, elements: Expr[]) {
211	super(startToken, endToken);	38✔
212	this.elements = elements;	38✔
213	}
214	override accept(visitor: Visitor<any>): any {
215	return visitor.visitListExpr(this);	19✔
216	}
217	}
218	export class Subscript extends Expr {	6✔
219	readonly kind = "Subscript";	293✔
220	value: Expr;
221	index: Expr;
222	constructor(startToken: Token, endToken: Token, value: Expr, index: Expr) {
223	super(startToken, endToken);	293✔
224	this.value = value;	293✔
225	this.index = index;	293✔
226	}
227	override accept(visitor: Visitor<any>): any {
228	return visitor.visitSubscriptExpr(this);	3✔
229	}
230	}
231	export class Starred extends Expr {	6✔
232	readonly kind = "Starred";	35✔
233	value: Expr;
234	constructor(startToken: Token, endToken: Token, value: Expr) {
235	super(startToken, endToken);	35✔
236	this.value = value;	35✔
237	}
238	override accept(visitor: Visitor<any>): any {
239	return visitor.visitStarredExpr(this);	13✔
240	}
241	}
242	export class None extends Expr {	6✔
243	readonly kind = "None";	2,024✔
244	constructor(startToken: Token, endToken: Token) {
245	super(startToken, endToken);	2,024✔
246	}
247	override accept(visitor: Visitor<any>): any {
248	return visitor.visitNoneExpr(this);	127✔
249	}
250	}
251	export class Complex extends Expr {	6✔
252	readonly kind = "Complex";	266✔
253	value: PyComplexNumber;
254	constructor(startToken: Token, endToken: Token, value: string) {
255	super(startToken, endToken);	266✔
256	this.value = PyComplexNumber.fromString(value);	266✔
257	}
258	override accept(visitor: Visitor<any>): any {
259	return visitor.visitComplexExpr(this);	265✔
260	}
261	}
262	}
263	export namespace StmtNS {	6✔
264	export interface Visitor<T> {
265	visitPassStmt(stmt: Pass): T;
266	visitAssignStmt(stmt: Assign): T;
267	visitAnnAssignStmt(stmt: AnnAssign): T;
268	visitBreakStmt(stmt: Break): T;
269	visitContinueStmt(stmt: Continue): T;
270	visitReturnStmt(stmt: Return): T;
271	visitFromImportStmt(stmt: FromImport): T;
272	visitGlobalStmt(stmt: Global): T;
273	visitNonLocalStmt(stmt: NonLocal): T;
274	visitAssertStmt(stmt: Assert): T;
275	visitIfStmt(stmt: If): T;
276	visitWhileStmt(stmt: While): T;
277	visitForStmt(stmt: For): T;
278	visitFunctionDefStmt(stmt: FunctionDef): T;
279	visitSimpleExprStmt(stmt: SimpleExpr): T;
280	visitFileInputStmt(stmt: FileInput): T;
281	}
282	export abstract class Stmt {	6✔
283	abstract readonly kind: string;
284	startToken: Token;
285	endToken: Token;
286	protected constructor(startToken: Token, endToken: Token) {
287	this.startToken = startToken;	63,074✔
288	this.endToken = endToken;	63,074✔
289	}
290	abstract accept(visitor: Visitor<any>): any;
291	}
292	export class Pass extends Stmt {	6✔
293	readonly kind = "Pass";	49✔
294	constructor(startToken: Token, endToken: Token) {
295	super(startToken, endToken);	49✔
296	}
297	override accept(visitor: Visitor<any>): any {
298	return visitor.visitPassStmt(this);	14✔
299	}
300	}
301	export class Assign extends Stmt {	6✔
302	readonly kind = "Assign";	664✔
303	target: AssignTarget;
304	value: ExprNS.Expr;
305	constructor(startToken: Token, endToken: Token, target: AssignTarget, value: ExprNS.Expr) {
306	super(startToken, endToken);	664✔
307	this.target = target;	664✔
308	this.value = value;	664✔
309	}
310	override accept(visitor: Visitor<any>): any {
311	return visitor.visitAssignStmt(this);	98✔
312	}
313	}
314	export class AnnAssign extends Stmt {	6✔
315	readonly kind = "AnnAssign";	17✔
316	target: ExprNS.Variable;
317	value: ExprNS.Expr;
318	ann: ExprNS.Expr;
319	constructor(
320	startToken: Token,
321	endToken: Token,
322	target: ExprNS.Variable,
323	value: ExprNS.Expr,
324	ann: ExprNS.Expr,
325	) {
326	super(startToken, endToken);	17✔
327	this.target = target;	17✔
328	this.value = value;	17✔
329	this.ann = ann;	17✔
330	}
331	override accept(visitor: Visitor<any>): any {
UNCOV 332	return visitor.visitAnnAssignStmt(this);	×
333	}
334	}
335	export class Break extends Stmt {	6✔
336	readonly kind = "Break";	7✔
337	constructor(startToken: Token, endToken: Token) {
338	super(startToken, endToken);	7✔
339	}
340	override accept(visitor: Visitor<any>): any {
UNCOV 341	return visitor.visitBreakStmt(this);	×
342	}
343	}
344	export class Continue extends Stmt {	6✔
345	readonly kind = "Continue";	7✔
346	constructor(startToken: Token, endToken: Token) {
347	super(startToken, endToken);	7✔
348	}
349	override accept(visitor: Visitor<any>): any {
UNCOV 350	return visitor.visitContinueStmt(this);	×
351	}
352	}
353	export class Return extends Stmt {	6✔
354	readonly kind = "Return";	26,756✔
355	value: ExprNS.Expr \| null;
356	constructor(startToken: Token, endToken: Token, value: ExprNS.Expr \| null) {
357	super(startToken, endToken);	26,756✔
358	this.value = value;	26,756✔
359	}
360	override accept(visitor: Visitor<any>): any {
361	return visitor.visitReturnStmt(this);	39✔
362	}
363	}
364	export class FromImport extends Stmt {	6✔
365	readonly kind = "FromImport";	8✔
366	module: Token;
367	names: { name: Token; alias: Token \| null }[];
368	constructor(
369	startToken: Token,
370	endToken: Token,
371	module: Token,
372	names: { name: Token; alias: Token \| null }[],
373	) {
374	super(startToken, endToken);	8✔
375	this.module = module;	8✔
376	this.names = names;	8✔
377	}
378	override accept(visitor: Visitor<any>): any {
379	return visitor.visitFromImportStmt(this);	1✔
380	}
381	}
382	export class Global extends Stmt {	6✔
383	readonly kind = "Global";	1✔
384	name: Token;
385	constructor(startToken: Token, endToken: Token, name: Token) {
386	super(startToken, endToken);	1✔
387	this.name = name;	1✔
388	}
389	override accept(visitor: Visitor<any>): any {
UNCOV 390	return visitor.visitGlobalStmt(this);	×
391	}
392	}
393	export class NonLocal extends Stmt {	6✔
394	readonly kind = "NonLocal";	9✔
395	name: Token;
396	constructor(startToken: Token, endToken: Token, name: Token) {
397	super(startToken, endToken);	9✔
398	this.name = name;	9✔
399	}
400	override accept(visitor: Visitor<any>): any {
401	return visitor.visitNonLocalStmt(this);	4✔
402	}
403	}
404	export class Assert extends Stmt {	6✔
405	readonly kind = "Assert";	5✔
406	value: ExprNS.Expr;
407	constructor(startToken: Token, endToken: Token, value: ExprNS.Expr) {
408	super(startToken, endToken);	5✔
409	this.value = value;	5✔
410	}
411	override accept(visitor: Visitor<any>): any {
UNCOV 412	return visitor.visitAssertStmt(this);	×
413	}
414	}
415	export class If extends Stmt {	6✔
416	readonly kind = "If";	11,440✔
417	condition: ExprNS.Expr;
418	body: Stmt[];
419	elseBlock: Stmt[] \| null;
420	constructor(
421	startToken: Token,
422	endToken: Token,
423	condition: ExprNS.Expr,
424	body: Stmt[],
425	elseBlock: Stmt[] \| null,
426	) {
427	super(startToken, endToken);	11,440✔
428	this.condition = condition;	11,440✔
429	this.body = body;	11,440✔
430	this.elseBlock = elseBlock;	11,440✔
431	}
432	override accept(visitor: Visitor<any>): any {
UNCOV 433	return visitor.visitIfStmt(this);	×
434	}
435	}
436	export class While extends Stmt {	6✔
437	readonly kind = "While";	66✔
438	condition: ExprNS.Expr;
439	body: Stmt[];
440	constructor(startToken: Token, endToken: Token, condition: ExprNS.Expr, body: Stmt[]) {
441	super(startToken, endToken);	66✔
442	this.condition = condition;	66✔
443	this.body = body;	66✔
444	}
445	override accept(visitor: Visitor<any>): any {
446	return visitor.visitWhileStmt(this);	3✔
447	}
448	}
449	export class For extends Stmt {	6✔
450	readonly kind = "For";	66✔
451	target: Token;
452	iter: ExprNS.Expr;
453	body: Stmt[];
454	constructor(
455	startToken: Token,
456	endToken: Token,
457	target: Token,
458	iter: ExprNS.Expr,
459	body: Stmt[],
460	) {
461	super(startToken, endToken);	66✔
462	this.target = target;	66✔
463	this.iter = iter;	66✔
464	this.body = body;	66✔
465	}
466	override accept(visitor: Visitor<any>): any {
467	return visitor.visitForStmt(this);	4✔
468	}
469	}
470	export class FunctionDef extends Stmt {	6✔
471	readonly kind = "FunctionDef";	5,681✔
472	name: Token;
473	parameters: FunctionParam[];
474	body: Stmt[];
475	varDecls: Token[];
476	constructor(
477	startToken: Token,
478	endToken: Token,
479	name: Token,
480	parameters: FunctionParam[],
481	body: Stmt[],
482	varDecls: Token[],
483	) {
484	super(startToken, endToken);	5,681✔
485	this.name = name;	5,681✔
486	this.parameters = parameters;	5,681✔
487	this.body = body;	5,681✔
488	this.varDecls = varDecls;	5,681✔
489	}
490	override accept(visitor: Visitor<any>): any {
491	return visitor.visitFunctionDefStmt(this);	69✔
492	}
493	}
494	export class SimpleExpr extends Stmt {	6✔
495	readonly kind = "SimpleExpr";	8,000✔
496	expression: ExprNS.Expr;
497	constructor(startToken: Token, endToken: Token, expression: ExprNS.Expr) {
498	super(startToken, endToken);	8,000✔
499	this.expression = expression;	8,000✔
500	}
501	override accept(visitor: Visitor<any>): any {
502	return visitor.visitSimpleExprStmt(this);	1,096✔
503	}
504	}
505	export class FileInput extends Stmt {	6✔
506	readonly kind = "FileInput";	10,298✔
507	statements: Stmt[];
508	varDecls: Token[];
509	constructor(startToken: Token, endToken: Token, statements: Stmt[], varDecls: Token[]) {
510	super(startToken, endToken);	10,298✔
511	this.statements = statements;	10,298✔
512	this.varDecls = varDecls;	10,298✔
513	}
514	override accept(visitor: Visitor<any>): any {
515	return visitor.visitFileInputStmt(this);	1,151✔
516	}
517	}
518	}

source-academy / py-slang / 23790160202

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