lint 0.0.2-preview.1

Lint rules for Zena source, each with a fix

Readme Files Dependencies Versions

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 — .zena file discovery (collectZenaFiles)

License#

MIT

3.6 KiB Raw
/**
 * Every rule, by name, with the finding it reports. The order is the
 * order they run in within a pass; it only matters when two rules want
 * the same bytes, and then the one listed first wins the pass and the
 * other gets the next.
 */

import { NamedRule } from './rule.zena';
import { functionDeclarations } from './rules/function-declaration.zena';
import { unnecessaryCasts } from './rules/unnecessary-cast.zena';
import { unnecessaryOptionalChains } from './rules/unnecessary-optional-chain.zena';
import { unnecessaryAnnotations } from './rules/unnecessary-annotation.zena';
import { collectionLiterals } from './rules/collection-literal.zena';
import { ifInitializers } from './rules/if-initializer.zena';
import { nullishOperators } from './rules/nullish.zena';
import { matchToIf } from './rules/match-to-if.zena';
import { elseIfs } from './rules/else-if.zena';
import { preferLet } from './rules/prefer-let.zena';
import { immutableFields } from './rules/immutable-field.zena';
import { emptyConstructors } from './rules/empty-constructor.zena';
import { templateLiterals } from './rules/template-literal.zena';
import { consoleToString } from './rules/console-to-string.zena';
import { booleanReturns } from './rules/boolean-return.zena';
import { forInLoops } from './rules/for-in.zena';
import { arrowBodies } from './rules/arrow-body.zena';
import { growable } from 'zena:core';

export function allRules(): GrowableArray<NamedRule> {
  return growable<NamedRule>([
    new NamedRule('function-declaration', functionDeclarations,
        'A top-level arrow function; write a `function` declaration.'),
    new NamedRule('unnecessary-cast', unnecessaryCasts,
        'The expression already has this type; the cast can go.'),
    new NamedRule('unnecessary-optional-chain', unnecessaryOptionalChains,
        'The target is not nullable; the `?` can go.'),
    new NamedRule('unnecessary-annotation', unnecessaryAnnotations,
        'The checker infers this type; the annotation can go.'),
    new NamedRule('collection-literal', collectionLiterals,
        'A collection built by insertions; write a literal.'),
    new NamedRule('if-initializer', ifInitializers,
        'A variable assigned by an `if`; initialize it with an `if` expression.'),
    new NamedRule('nullish', nullishOperators,
        'A null test spelling out `??` or `?.`; use the operator.'),
    new NamedRule('match-to-if', matchToIf,
        'A `match` with one or two arms; write an `if`.'),
    new NamedRule('else-if', elseIfs,
        'An `else` holding only an `if`; write `else if`.'),
    new NamedRule('for-in', forInLoops,
        'An index loop that only reads the element; write `for…in`.'),
    new NamedRule('boolean-return', booleanReturns,
        'Boolean literals chosen by a condition; use the condition.'),
    new NamedRule('template-literal', templateLiterals,
        'Three or more strings joined with `+`; write a template literal.'),
    new NamedRule('console-to-string', consoleToString,
        'A string conversion in a `console` call; pass the value.'),
    new NamedRule('arrow-body', arrowBodies,
        'An arrow whose block only returns; make the expression the body.'),
    new NamedRule('prefer-let', preferLet,
        'A `var` never assigned again; declare it with `let`.'),
    new NamedRule('immutable-field', immutableFields,
        'A `var` field nothing assigns; drop the `var`.'),
    new NamedRule('empty-constructor', emptyConstructors,
        'An empty default constructor; the compiler synthesizes one.'),
  ]);
}

/** The rule named `name`, or null. */
export function ruleNamed(name: String): NamedRule | null {
  for (let rule in allRules()) {
    if (rule.name == name) {
      return rule;
    }
  }
  return null;
}
  • compiler compiler.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1
VersionPublishedDependenciesApproved by
0.0.2-preview.1 2026-11-19
  • compiler compiler.zena-lang.pkg.zena-lang.dev 0.0.2-preview.1