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
2.2 KiB
Raw
/**
* A constructor that takes nothing and does nothing is the default one.
*
* class Counter { class Counter {
* var n = 0; var n = 0;
* new() {} → }
* }
*
* The compiler synthesizes the default constructor for a class that
* declares no constructor at all. A class with a named constructor does
* not get one (language-reference.md §"Namespace and Default Constructor
* Rules"), so there the empty `new()` stays.
*/
import {
Node, ClassDeclaration, MethodDefinition, BlockStatement, Identifier,
} from 'compiler/ast';
import { walkEnter } from 'compiler/visitor';
import { RuleContext } from '../context.zena';
export function emptyConstructors(ctx: RuleContext): void {
walkEnter(ctx.ast, (n) => {
if (n is ClassDeclaration) {
rewrite(ctx, n);
}
});
}
function rewrite(ctx: RuleContext, decl: ClassDeclaration): void {
if (decl.isExtension) {
return;
}
var constructors = 0;
var empty: MethodDefinition | null = null;
for (let member in decl.body) {
if (let MethodDefinition {isConstructor} = member) {
if (!isConstructor) {
continue;
}
constructors += 1;
let method = member as MethodDefinition;
if (isEmptyDefault(method)) {
empty = method;
}
}
}
if (empty == null || constructors != 1 || ctx.hasComment(empty)) {
return;
}
ctx.removeLines(empty);
}
/** `new() {}` or `new();`: no parameters, no initializers, no statements. */
function isEmptyDefault(method: MethodDefinition): boolean {
if (method.params.length != 0 || method.typeParameters != null ||
method.receiver != null || method.superInitializer != null ||
method.decorators.length != 0 || method.isDeclare || method.isAbstract ||
method.isShared) {
return false;
}
let initializers = method.initializerList;
if (initializers != null && initializers.length != 0) {
return false;
}
if (let Identifier {name} = method.name) {
if (name != '<constructor>') {
return false;
}
} else {
return false;
}
let body = method.body;
if (body == null) {
return true;
}
if (let BlockStatement {body as statements} = body) {
return statements.length == 0;
}
return false;
}
- 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 |
|
|