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.4 KiB Raw
/**
 * `let f = (a: i32): i32 => …` at the top level becomes
 * `function f(a: i32): i32 { … }`.
 *
 * A top-level arrow has nothing to capture, so the two mean the same
 * thing; the declaration says so, hoists, and can never become a closure
 * by a later edit (language-reference.md §4). An expression body becomes
 * a block that returns it. A `let` with a type annotation is left alone:
 * the annotation is what gives its parameters their types.
 */

import {
  VariableDeclaration, IdentifierPattern, FunctionExpression, BlockStatement,
} from 'compiler/ast';
import { RuleContext } from '../context.zena';
import { skipWhitespace, skipWhitespaceBack, isMultiLine } from '../source.zena';

let EQUALS = 61;
let GREATER = 62;

export function functionDeclarations(ctx: RuleContext): void {
  for (let stmt in ctx.ast.body) {
    if (let VariableDeclaration {kind, pattern, typeAnnotation, init, exported} = stmt) {
      if (kind != 'let' || typeAnnotation != null) {
        continue;
      }
      if (!(pattern is IdentifierPattern) || !(init is FunctionExpression)) {
        continue;
      }
      let fe = init;
      let name = pattern.name;
      let source = ctx.source;

      // The signature is everything between the `=` after the name and
      // the `=>` before the body, which includes any `async`/`gen`
      // modifier and type parameters wherever the parser put the arrow's
      // own location.
      var afterName = ctx.end(pattern);
      while (afterName < source.length && source.getByteAt(afterName) != EQUALS) {
        afterName += 1;
      }
      let arrow = arrowBefore(source, ctx.start(fe.body));
      if (arrow < 0 || afterName >= arrow) {
        continue;
      }
      var header = source.sliceBytes(afterName + 1, arrow).trim();
      var modifiers = '';
      if (fe.isAsync && header.startsWith('async')) {
        header = header.sliceBytes(5, header.length).trim();
        modifiers = 'async ';
      }
      if (fe.isGenerator && header.startsWith('gen')) {
        header = header.sliceBytes(3, header.length).trim();
        modifiers = modifiers + 'gen ';
      }
      if (!(header.startsWith('(') || header.startsWith('<'))) {
        continue;
      }

      let indent = ctx.indentOf(stmt);
      let body = fe.body;
      let bodyText = if (body is BlockStatement) {
        ctx.text(body)
      } else {
        let expression = ctx.text(body);
        `{\n${indent}  return ${expression};\n${indent}}`
      };
      let exportPrefix = if (exported) 'export ' else '';
      let text = `${exportPrefix}${modifiers}function ${name}${header} ${bodyText}`;
      if (ctx.debug) {
        // A statement's recorded location is reliable; a difference means
        // some descendant's is not, and the rewrite will probably fail.
        let loc = stmt.loc;
        if (loc != null && (loc.start != ctx.start(stmt) || loc.end != ctx.end(stmt))) {
          console.log(`function-declaration ${name}: recorded ${i32ToString(loc.start)}..${i32ToString(loc.end)}, extent ${i32ToString(ctx.start(stmt))}..${i32ToString(ctx.end(stmt))}`);
        }
      }
      ctx.replaceRange(ctx.start(stmt), ctx.statementEnd(stmt), text);
    }
  }
}

/** The offset of the `=>` whose right side starts at `bodyStart`, or -1. */
function arrowBefore(source: String, bodyStart: i32): i32 {
  let last = skipWhitespaceBack(source, bodyStart);
  if (last < 1) {
    return -1;
  }
  if (source.getByteAt(last) != GREATER || source.getByteAt(last - 1) != EQUALS) {
    return -1;
  }
  return last - 1;
}
  • 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