lint 0.0.2-preview.1
Lint rules for Zena source, each with a fix
lint#
Lint rules for Zena source code, each with an automated fix. The compiler and type checker drive every rule, and when a fix is applied it is type-checked again before it is kept.
Usage#
Command Line#
zena lint [--fix] [--only a,b] [--skip a,b] <paths...>
zena lint --list-rules
A path is a .zena file or a directory, searched for them. Without --fix the command prints each finding as path:line:column: message [rule] and exits 1 when there is one; with --fix it rewrites the files. -v on the command lists every fix and the text of any rejected one.
The language server (zena lsp) publishes the findings as warnings and offers each as a quick fix, plus a source.fixAll.zena code action for the whole file.
Library API#
import { LintOptions, lintFile } from 'lint';
import { Project } from 'lint/checking';
import { allRules } from 'lint/rules';
let project = new Project();
let options = new LintOptions(allRules());
let report = await lintFile(project, 'src/main.zena', options);
Rules#
| Rule | Rewrite |
|---|---|
function-declaration |
top-level let f = (…) => … → function f(…) { … } |
unnecessary-cast |
x as T where x: T → x (from the checker's warning, less contextually typed operands) |
unnecessary-optional-chain |
x?.f, x?[i], f?(…) on a non-nullable target → x.f, x[i], f(…) |
unnecessary-annotation |
let x: T = e with e: T; return types the body implies; callback parameter types |
collection-literal |
new Array<T>() + push runs → growable<T>([…]); new Map<K, V>() + []= → {k => v} |
if-initializer |
var x = d; if (c) { x = a; } → let x = if (c) a else d |
nullish |
if (x != null) x else d → x ?? d; if (x != null) x.f else null → x?.f |
match-to-if |
one- and two-arm match → if, if (x is T), if (let P = x) |
else-if |
else { if (…) { … } } → else if (…) { … } |
for-in |
index loops that read only xs[i] → for (let x in xs) |
boolean-return |
if (c) { return true; } return false; → return c;; if (c) true else false → c |
template-literal |
three or more +-joined strings → a template literal |
console-to-string |
console.log(`${x}`) and console.log(i32ToString(x)) → console.log(x) |
arrow-body |
(x) => { return e; } → (x) => e |
prefer-let |
var never assigned again → let |
immutable-field |
var field nothing assigns → immutable field (#private, or the class is not exported) |
empty-constructor |
new() {} on a class with no other constructor → removed; the default is synthesized |
Libraries#
lint/lint/lint— lint driver (lintFile,lintSource,LintOptions,FileReport)lint/checking— compiler project wrapper and overlay host (Project,CheckedFile)lint/checked— checked module wrapper (CheckedFile)lint/rules— rule registry (allRules,ruleNamed)lint/rule— rule runner (NamedRule,proposeEdits,messageOf)lint/context— rule traversal context (RuleContext)lint/source— byte-range edits (Edit,applyEdits,columnOf)lint/files—.zenafile discovery (collectZenaFiles)
License#
MIT
26.4 KiB
Raw
/**
* What a rule sees: one checked file, and the questions every rule asks
* of it — the text of a node, its parent, its type, whether an
* expression mentions a binding, whether it is safe to evaluate twice.
*
* A rule is a function from a `RuleContext` to nothing; it calls
* `replace` or `remove` for each change it wants, and the driver
* decides which of those changes survive (see lint.zena).
*/
import { Set } from 'zena:collections';
import {
Node, Module, Expression, Identifier, NumberLiteral, StringLiteral,
BooleanLiteral, NullLiteral, TemplateLiteral, BinaryExpression,
UnaryExpression, AssignmentExpression, AsExpression, IsExpression,
FunctionExpression, CallExpression, MemberExpression, IndexExpression,
ThisExpression, NewExpression, ArrayLiteral, RecordLiteral, MapLiteral,
TupleLiteral, MatchExpression, IfExpression, Statement, BlockStatement,
ExpressionStatement, VariableDeclaration, IdentifierPattern, Pattern,
Parameter, SourceLocation, PropertyAssignment, SpreadElement,
ClassDeclaration, MixinDeclaration, MethodDefinition, AccessorDeclaration,
FieldDefinition, ImportDeclaration, SuperInitializer,
} from 'compiler/ast';
import { walk, walkEnter } from 'compiler/visitor';
import { SemanticModel, Symbol, DiagnosticCode, Diagnostic } from 'compiler/compiler';
import { SymbolId } from 'compiler/scope';
import { DenseNodeMap } from 'compiler/node-map';
import {
Type, ClassType, UnionType, NullType, FunctionType, TypeAliasType,
TypeParameterType, isBigIntLiteralRaw, typeToString, typeContainsTypeParameter,
} from 'compiler/types';
import { typesEqual, isNullableType, unwrapAliases } from 'compiler/checker';
import { CheckedFile } from './checked.zena';
import {
Edit, lineOf, indentationAt, columnOf, hasCommentIn, pastSemicolon,
skipWhitespace, skipWhitespaceBack, lineStart, lineEnd,
} from './source.zena';
import { growable } from 'zena:core';
/** A rule: looks at a file, proposes edits. */
export type Rule = (ctx: RuleContext) => void;
/** How wide a line the rewrites try to stay within. */
export let LINE_WIDTH = 80;
let LEFT_PAREN = 40;
let RIGHT_PAREN = 41;
/** A byte range `[start, end)` of the source. */
export final class Span(start: i32, end: i32)
var debugEnabled = false;
/**
* Makes rules print why they declined a site, where a rule bothers to
* say. `zena lint` turns it on for `ZENA_LINT_DEBUG`.
*/
export function setDebug(on: boolean): void {
debugEnabled = on;
}
export final class RuleContext {
file: CheckedFile;
source: String;
ast: Module;
model: SemanticModel;
edits: GrowableArray<Edit>;
/** The rule currently running, stamped on each edit. */
var rule: String = '';
/** Print why a rule declined, where a rule bothers to say; see `setDebug`. */
debug: boolean = debugEnabled;
#parents: DenseNodeMap<Node>;
/** Every binding some assignment writes to, by sym id. */
var #assigned: Set<SymbolId> | null = null;
/** Imports already asked for this pass, as `module:name`. */
#pendingImports = new Set<String>();
var #nextGroup = 0;
var #openGroup = 0;
/** Extents already computed, by node id. */
#extents = new Map<i32, Span>();
new(file: CheckedFile)
: file = file,
source = file.source,
ast = file.ast,
model = file.model,
edits = new Array<Edit>(),
#parents = buildParents(file.ast);
// --------------------------------------------------------------------
// Proposing edits
// --------------------------------------------------------------------
/** Replaces the bytes `[start, end)` with `text`. */
replaceRange(start: i32, end: i32, text: String): void {
this.#nextGroup += 1;
let group = if (this.#openGroup != 0) this.#openGroup else this.#nextGroup;
this.edits.push(new Edit(start, end, text, this.rule, lineOf(this.source, start), group));
}
/** An edit that supports the rule's fixes rather than being one; see `Edit.shared`. */
#insertShared(at: i32, text: String): void {
this.#nextGroup += 1;
let edit = new Edit(at, at, text, this.rule, lineOf(this.source, at), this.#nextGroup);
edit.shared = true;
this.edits.push(edit);
}
/**
* Starts a rewrite of several edits that stand or fall together. Every
* edit until `endGroup` joins it.
*/
beginGroup(): void {
this.#nextGroup += 1;
this.#openGroup = this.#nextGroup;
}
endGroup(): void {
this.#openGroup = 0;
}
/** Replaces a node's text. */
replace(node: Node, text: String): void {
let start = this.start(node);
let end = this.end(node);
if (start < 0 || end < start) {
return;
}
this.replaceRange(start, end, text);
}
/** Deletes the bytes `[start, end)`. */
removeRange(start: i32, end: i32): void {
this.replaceRange(start, end, '');
}
/**
* Deletes a statement or member together with the lines it occupies,
* when nothing else shares them; otherwise just its own text.
*/
removeLines(node: Node): void {
let start = this.start(node);
let end = this.statementEnd(node);
let from = lineStart(this.source, start);
let to = lineEnd(this.source, end);
let before = this.slice(from, start).trim();
let after = this.slice(end, to).trim();
if (before.length > 0 || after.length > 0) {
this.removeRange(start, end);
return;
}
this.removeRange(from, if (to < this.source.length) to + 1 else to);
}
/**
* Makes sure `name` is imported from `module`, adding it to an existing
* import of that module or adding a new import after the last one.
*/
ensureImport(name: String, module: String): void {
let key = `${module}:${name}`;
if (this.#pendingImports.has(key)) {
return;
}
this.#pendingImports.add(key);
var lastImport: Node | null = null;
for (let stmt in this.ast.body) {
if (let ImportDeclaration {moduleSpecifier, imports} = stmt) {
lastImport = stmt;
if (moduleSpecifier.value != module) {
continue;
}
for (let spec in imports) {
if (spec.local.name == name) {
return;
}
}
if (imports.length > 0) {
let at = this.end(imports[imports.length - 1]);
this.#insertShared(at, `, ${name}`);
return;
}
}
}
let line = `import { ${name} } from '${module}';`;
if (lastImport != null) {
let at = this.statementEnd(lastImport);
this.#insertShared(at, `\n${line}`);
} else if (this.ast.body.length > 0) {
let at = this.start(this.ast.body[0]);
this.#insertShared(at, `${line}\n\n`);
}
}
// --------------------------------------------------------------------
// Reading the file
// --------------------------------------------------------------------
/** The node's source text, or '' for a node without a location. */
text(node: Node): String {
let start = this.start(node);
let end = this.end(node);
if (start < 0 || end < start) {
return '';
}
return this.source.sliceBytes(start, end);
}
/** The source text in `[start, end)`. */
slice(start: i32, end: i32): String {
return this.source.sliceBytes(start, end);
}
/**
* The first byte of the node's text. The parser dates some nodes from
* their operator — a `BinaryExpression` from `+`, an `AsExpression`
* from `as` — so the extent is taken over the node and its descendants,
* and then widened over the parentheses that group them (see `extent`).
*/
start(node: Node): i32 {
return this.extent(node).start;
}
/** The byte after the node's text; see `start`. */
end(node: Node): i32 {
return this.extent(node).end;
}
/**
* The byte range of a node's text.
*
* Parentheses are not nodes, so the range the descendants span can
* start inside a group — `(a || b) && c` spans from `a` — or end
* inside one. The text is scanned for parentheses it does not balance,
* skipping string literals and comments, and the range is widened by a
* `(` or `)` for each, as long as that is what lies beyond it.
*/
extent(node: Node): Span {
if (let (true, known) = this.#extents.get(node.id as i32)) {
return known;
}
var least = -1;
var most = -1;
let skipped = new Array<Span>();
let spliced = this.#splicedArguments(node);
walkEnter(node, (n) => {
let loc = n.loc;
if (loc == null || !this.isParsed(n) || spliced.has(n.id as i32)) {
return;
}
if (least < 0 || loc.start < least) {
least = loc.start;
}
if (loc.end > most) {
most = loc.end;
}
if (n is StringLiteral || n is TemplateLiteral) {
skipped.push(new Span(loc.start, loc.end));
}
});
if (least < 0) {
let none = new Span(-1, -1);
this.#extents[node.id as i32] = none;
return none;
}
for (let comment in this.ast.comments) {
if (comment.start < most && comment.end > least) {
skipped.push(new Span(comment.start, comment.end));
}
}
let source = this.source;
var depth = 0;
var missingOpen = 0;
var i = least;
while (i < most) {
var inSkipped = false;
for (let span in skipped) {
if (i >= span.start && i < span.end) {
i = span.end;
inSkipped = true;
break;
}
}
if (inSkipped) {
continue;
}
let b = source.getByteAt(i);
if (b == LEFT_PAREN) {
depth += 1;
} else if (b == RIGHT_PAREN) {
if (depth == 0) {
missingOpen += 1;
} else {
depth -= 1;
}
}
i += 1;
}
var start = least;
while (missingOpen > 0) {
let before = skipWhitespaceBack(source, start);
if (before < 0 || source.getByteAt(before) != LEFT_PAREN) {
break;
}
start = before;
missingOpen -= 1;
}
var end = most;
while (depth > 0) {
let after = skipWhitespace(source, end);
if (after >= source.length || source.getByteAt(after) != RIGHT_PAREN) {
break;
}
end = after + 1;
depth -= 1;
}
let span = new Span(start, end);
this.#extents[node.id as i32] = span;
return span;
}
/**
* The ids of every node under `root` that the checker spliced into a
* call's arguments from the callee's parameter defaults. They are
* parsed nodes of this file, but of the callee's declaration, so their
* text lies anywhere; `SemanticModel.getOriginalArgCount` says where
* the caller's own arguments end.
*/
#splicedArguments(root: Node): Set<i32> {
let spliced = new Set<i32>();
let model = this.model;
walkEnter(root, (n) => {
let args = match (n) {
case CallExpression {args}: args
case NewExpression {args}: args
case SuperInitializer {args}: args
case _: null
};
if (args == null) {
return;
}
let written = model.getOriginalArgCount(n);
if (written < 0 || written >= args.length) {
return;
}
var i = written;
while (i < args.length) {
walkEnter(args[i], (d) => {
spliced.add(d.id as i32);
});
i += 1;
}
});
return spliced;
}
/**
* Whether the parser made this node. The scope builder and checker
* synthesize nodes into the tree (an operator method's name, say) and
* give them whatever location was to hand, so only a parsed node's
* location says where text is. A parsed node's id is in the module's
* range (see `Module.lastNodeId`).
*/
isParsed(node: Node): boolean {
let id = node.id as i32;
return id >= (this.ast.id as i32) && id <= (this.ast.lastNodeId as i32);
}
/** The start the parser recorded, which is what a diagnostic points at. */
recordedStart(node: Node): i32 {
let loc = node.loc;
return loc?.start ?? -1;
}
/** A statement's end, taking a directly following `;` along. */
statementEnd(node: Node): i32 {
return pastSemicolon(this.source, this.end(node));
}
/** The indentation of the line a node starts on. */
indentOf(node: Node): String {
return indentationAt(this.source, this.start(node));
}
/** The 0-based column a node starts at. */
columnOf(node: Node): i32 {
return columnOf(this.source, this.start(node));
}
/** 1-based line of a node's first byte. */
lineOf(node: Node): i32 {
return lineOf(this.source, this.start(node));
}
/** Whether `node`'s text is on one line. */
isSingleLine(node: Node): boolean {
let start = this.start(node);
if (start < 0) {
return false;
}
return lineOf(this.source, start) == lineOf(this.source, this.end(node));
}
/** Whether a comment lies inside the node's range. */
hasComment(node: Node): boolean {
let start = this.start(node);
if (start < 0) {
return true;
}
return hasCommentIn(this.ast.comments, start, this.end(node));
}
/** Whether a comment lies inside `[start, end)`. */
hasCommentIn(start: i32, end: i32): boolean {
return hasCommentIn(this.ast.comments, start, end);
}
// --------------------------------------------------------------------
// The tree
// --------------------------------------------------------------------
parent(node: Node): Node | null {
if (let (true, p) = this.#parents.get(node)) {
return p;
}
return null;
}
/** Whether `ancestor` is on the path from `node` to the module. */
isWithin(node: Node, ancestor: Node): boolean {
var current = this.parent(node);
while (current != null) {
if (current === ancestor) {
return true;
}
current = this.parent(current);
}
return false;
}
/** Whether `node` sits directly in the module body. */
isTopLevel(node: Node): boolean {
let p = this.parent(node);
return p != null && p is Module;
}
// --------------------------------------------------------------------
// Types and symbols
// --------------------------------------------------------------------
typeOf(node: Node): Type | null {
return this.model.getNodeType(node);
}
/** The type the checker gave a binding, by its declaring pattern or parameter. */
bindingTypeOf(declaration: Node): Type | null {
let sym = this.model.resolveDeclaration(declaration);
if (sym == null) {
return null;
}
return this.model.getBindingType(sym);
}
/** The binding an identifier refers to. */
symbolOf(identifier: Node): Symbol | null {
return this.model.resolve(identifier);
}
/** The sym a pattern or parameter declares. */
declaredSymbol(declaration: Node): Symbol | null {
return this.model.resolveDeclaration(declaration);
}
/** Whether two types are the same type, through transparent aliases. */
sameType(a: Type | null, b: Type | null): boolean {
if (a == null || b == null) {
return false;
}
return typesEqual(a, b);
}
isNullable(t: Type | null): boolean {
if (t == null) {
return false;
}
return isNullableType(unwrapAliases(t));
}
/** `t` without transparent aliases. */
unwrap(t: Type): Type {
return unwrapAliases(t);
}
/** Whether the type is one of the wasm value types rather than a reference. */
isPrimitive(t: Type | null): boolean {
if (t == null) {
return false;
}
let name = typeToString(unwrapAliases(t));
return name == 'i32' || name == 'i64' || name == 'f32' || name == 'f64' ||
name == 'u32' || name == 'u64' || name == 'u8' || name == 'u16' ||
name == 'i8' || name == 'i16' || name == 'boolean' || name == 'v128' ||
name == 'void';
}
isString(t: Type | null): boolean {
if (t == null) {
return false;
}
return typeToString(unwrapAliases(t)) == 'String';
}
isVoid(t: Type | null): boolean {
if (t == null) {
return false;
}
return typeToString(unwrapAliases(t)) == 'void';
}
/** The diagnostics of one code, in this file. */
diagnosticsOf(code: DiagnosticCode): GrowableArray<Diagnostic> {
let out = new Array<Diagnostic>();
for (let diagnostic in this.file.diagnostics) {
if (diagnostic.code == code) {
out.push(diagnostic);
}
}
return out;
}
// --------------------------------------------------------------------
// Questions about expressions
// --------------------------------------------------------------------
/**
* Whether an expression's type comes from where it is used rather
* than from what it is: a literal that takes the expected type, an
* arrow whose parameters are typed by the call, a `new` whose type
* arguments are inferred. Removing the context (an annotation, a
* cast) around such an expression changes it, even when the checker
* says the two types agree.
*/
isContextuallyTyped(expr: Node): boolean {
return match (expr) {
case NumberLiteral {raw}: !isBigIntLiteralRaw(raw)
case BooleanLiteral {}: true
case NullLiteral {}: true
case ArrayLiteral {}: true
case RecordLiteral {}: true
case MapLiteral {}: true
case TupleLiteral {}: true
case FunctionExpression {}: true
case UnaryExpression {argument}: this.isContextuallyTyped(argument)
case NewExpression {typeArguments}: {
if (typeArguments != null) {
false
} else {
// `new Map()` takes its type arguments from the annotation.
let t = this.typeOf(expr);
t != null && t is ClassType && t.typeArguments != null
}
}
// Branches of different types join to the type the context gives
// them: `let s: Shape = if (c) new Square() else new Circle()` is
// a `Shape`, and without the annotation a `Square | Circle`.
case IfExpression {consequent, alternate}: {
this.isContextuallyTyped(consequent) ||
(alternate != null && (this.isContextuallyTyped(alternate) ||
!this.sameType(this.typeOf(consequent), this.typeOf(alternate))))
}
case MatchExpression {cases}: {
var any = false;
for (let c in cases) {
if (this.isContextuallyTyped(c.body) ||
!this.sameType(this.typeOf(cases[0].body), this.typeOf(c.body))) {
any = true;
}
}
any
}
case BlockStatement {body}: {
// A value block's last expression is its value.
if (body.length == 0) {
false
} else {
let tail = this.singleExpression(body[body.length - 1]);
tail != null && this.isContextuallyTyped(tail)
}
}
case CallExpression {callee, typeArguments}: {
// A generic function called without type arguments may take them
// from the context: `empty()` as `Array<i32>`.
if (typeArguments != null) {
false
} else {
let t = this.typeOf(callee);
if (t != null && t is FunctionType) {
let ft = t;
let generic = ft.genericSource ?? ft;
let tps = generic.typeParameters;
tps != null && tps.length > 0 &&
typeContainsTypeParameter(generic.returnType)
} else {
false
}
}
}
case AsExpression {}: false
case BinaryExpression {operator, left, right}: {
// `??` and arithmetic on literals pass the context through.
operator == '??' && this.isContextuallyTyped(right) ||
(this.isContextuallyTyped(left) && this.isContextuallyTyped(right))
}
case _: false
};
}
/**
* Whether evaluating `expr` has no effect and reads nothing that
* could change between two evaluations in the same statement: a
* literal, a name, a field path, arithmetic on those. Used before an
* expression is moved to a position where it runs a different number
* of times.
*/
isPure(expr: Node): boolean {
return match (expr) {
case Identifier {}: true
case NumberLiteral {}: true
case StringLiteral {}: true
case BooleanLiteral {}: true
case NullLiteral {}: true
case ThisExpression {}: true
case MemberExpression {object, optional}: !optional && this.isPure(object)
case IndexExpression {object, index}: this.isPure(object) && this.isPure(index)
case UnaryExpression {argument}: this.isPure(argument)
case BinaryExpression {left, right}: this.isPure(left) && this.isPure(right)
case AsExpression {expression}: this.isPure(expression)
case IsExpression {expression}: this.isPure(expression)
case TemplateLiteral {expressions}: {
var all = true;
for (let e in expressions) {
if (!this.isPure(e)) {
all = false;
}
}
all
}
case ArrayLiteral {elements}: {
var all = true;
for (let e in elements) {
if (!this.isPure(e)) {
all = false;
}
}
all
}
case TupleLiteral {elements}: {
var all = true;
for (let e in elements) {
if (!this.isPure(e)) {
all = false;
}
}
all
}
case RecordLiteral {properties}: {
var all = true;
for (let p in properties) {
if (let PropertyAssignment {value} = p) {
if (!this.isPure(value)) {
all = false;
}
} else {
all = false;
}
}
all
}
case NewExpression {args}: {
// An allocation with no effects: `new Array<T>(0)`. The
// constructor could do anything, so only the collection classes
// the rules care about count.
let callee = expr.callee.name;
if (callee == 'Array' || callee == 'GrowableArray' || callee == 'Map' ||
callee == 'HashMap' || callee == 'Set' || callee == 'HashSet') {
var all = true;
for (let a in args) {
if (!this.isPure(a)) {
all = false;
}
}
all
} else {
false
}
}
case _: false
};
}
/**
* Whether `expr`'s subtree contains an identifier resolving to the
* binding `sym`.
*/
mentions(expr: Node, sym: Symbol): boolean {
var found = false;
let model = this.model;
walkEnter(expr, (n) => {
if (found) {
return;
}
if (n is Identifier) {
let s = model.resolve(n);
if (s != null && (s.id as i32) == (sym.id as i32)) {
found = true;
}
}
});
return found;
}
/** Whether any identifier in `expr` resolves to a binding in `symbols`. */
mentionsAny(expr: Node, symbols: GrowableArray<Symbol>): boolean {
for (let s in symbols) {
if (this.mentions(expr, s)) {
return true;
}
}
return false;
}
/**
* Whether `root`'s subtree contains a statement or expression that
* assigns to `sym`, including compound assignment.
*/
assignsTo(root: Node, sym: Symbol): boolean {
var found = false;
let model = this.model;
walkEnter(root, (n) => {
if (found) {
return;
}
if (let AssignmentExpression {left} = n) {
walkEnter(left, (l) => {
if (l is Identifier) {
let s = model.resolve(l);
if (s != null && (s.id as i32) == (sym.id as i32)) {
found = true;
}
}
});
}
});
return found;
}
/** Whether some assignment anywhere in the file writes `sym`. */
isEverAssigned(sym: Symbol): boolean {
let assigned = this.#assigned ?? this.#collectAssigned();
return assigned.has(sym.id);
}
#collectAssigned(): Set<SymbolId> {
let assigned = new Set<SymbolId>();
let model = this.model;
walkEnter(this.ast, (n) => {
if (let AssignmentExpression {left} = n) {
walkEnter(left, (l) => {
if (l is Identifier) {
let s = model.resolve(l);
if (s != null) {
assigned.add(s.id);
}
}
});
}
});
this.#assigned = assigned;
return assigned;
}
/** The symbols the pattern declares. */
patternSymbols(pattern: Node): GrowableArray<Symbol> {
let out = new Array<Symbol>();
let model = this.model;
walkEnter(pattern, (n) => {
if (n is IdentifierPattern) {
let s = model.resolveDeclaration(n);
if (s != null) {
out.push(s);
}
}
});
return out;
}
/**
* The body of the innermost function, method or accessor enclosing
* `node`, or the module when it is at the top level: the region in
* which a local's assignments can appear.
*/
enclosingBody(node: Node): Node {
var current = this.parent(node);
while (current != null) {
match (current) {
case FunctionExpression {}: { return current; }
case MethodDefinition {}: { return current; }
case AccessorDeclaration {}: { return current; }
case Module {}: { return current; }
case _: {}
}
current = this.parent(current);
}
return this.ast;
}
/**
* Whether `expr` is a plain name or `this`-rooted field path that
* reads the same thing each time (no calls, no indexing).
*/
isSimpleReference(expr: Node): boolean {
return match (expr) {
case Identifier {}: true
case ThisExpression {}: true
case MemberExpression {object, optional, isSymbolAccess}: {
!optional && !isSymbolAccess && this.isSimpleReference(object)
}
case _: false
};
}
/** The expression inside a block holding exactly one expression statement, else null. */
singleExpression(node: Node): Expression | null {
match (node) {
case BlockStatement {body}: {
if (body.length != 1) {
return null;
}
if (let ExpressionStatement {expression} = body[0]) {
return expression;
}
return null;
}
case ExpressionStatement {expression}: { return expression; }
case Expression as e: { return e; }
case _: { return null; }
}
return null;
}
/** The statements of a block, or the one statement, as a list. */
statementsOf(node: Node): GrowableArray<Statement> {
return match (node) {
case BlockStatement {body}: body
case Statement as s: {
let one = growable<Statement>([s]);
one
}
case _: new Array<Statement>(0)
};
}
}
/** A parent table for every node under `root`. */
function buildParents(root: Module): DenseNodeMap<Node> {
let parents = new DenseNodeMap<Node>(root.id, root.lastNodeId);
let stack = new Array<Node>();
walk(root, (n) => {
if (stack.length > 0) {
parents[n] = stack[stack.length - 1];
}
stack.push(n);
return true;
}, (n) => {
stack.pop();
});
return parents;
}
- compiler compiler.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
| Version | Published | Dependencies | Approved by |
|---|---|---|---|
| 0.0.2-preview.1 | 2026-11-19 |
|
|