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

2.9 KiB Raw
/**
 * `x?.f`, `x?[i]` and `f?(…)` where the receiver or callee cannot be
 * `null` become `x.f`, `x[i]` and `f(…)`.
 *
 * The checker reports these (`DiagnosticCode.UnnecessaryNullish`); this
 * rule removes the `?` before `.`, `[` or `(`.
 */

import { Expression, MemberExpression, IndexExpression, CallExpression } from 'compiler/ast';
import { walkEnter } from 'compiler/visitor';
import { DiagnosticCode } from 'compiler/compiler';
import { RuleContext } from '../context.zena';
import { skipWhitespace } from '../source.zena';

let LEFT_PAREN = 40;
let RIGHT_PAREN = 41;
let DOT = 46;
let QUESTION = 63;
let LEFT_BRACKET = 91;

export function unnecessaryOptionalChains(ctx: RuleContext): void {
  let warnings = ctx.diagnosticsOf(DiagnosticCode.UnnecessaryNullish);
  if (warnings.length == 0) {
    return;
  }
  let optionalBySpan = new Map<String, Expression>();
  walkEnter(ctx.ast, (n) => {
    if (!ctx.isParsed(n)) {
      return;
    }
    let loc = n.loc;
    if (loc == null) {
      return;
    }
    match (n) {
      case MemberExpression {optional}: {
        if (optional) {
          optionalBySpan[`${loc.start}:${loc.end}`] = n;
        }
      }
      case IndexExpression {optional}: {
        if (optional) {
          optionalBySpan[`${loc.start}:${loc.end}`] = n;
        }
      }
      case CallExpression {optional}: {
        if (optional) {
          optionalBySpan[`${loc.start}:${loc.end}`] = n;
        }
      }
      case _: {}
    }
  });
  if (optionalBySpan.size == 0) {
    return;
  }
  for (let warning in warnings) {
    let location = warning.location;
    if (location == null) {
      continue;
    }
    let key = `${location.start}:${location.start + location.length}`;
    if (let (true, expr) = optionalBySpan.get(key)) {
      let q = questionOffset(ctx, expr);
      if (q >= 0) {
        ctx.removeRange(q, q + 1);
      }
    }
  }
}

/** Byte offset of the `?` in `expr`'s optional operator, or -1. */
function questionOffset(ctx: RuleContext, expr: Expression): i32 {
  let (target, afterQuestion) = match (expr) {
    case MemberExpression {object}: (object, DOT)
    case IndexExpression {object}: (object, LEFT_BRACKET)
    case CallExpression {callee}: (callee, LEFT_PAREN)
    case _: { return -1; }
  };
  let source = ctx.source;
  let limit = ctx.end(expr);
  var i = ctx.end(target);
  if (i < 0 || limit < 0) {
    return -1;
  }
  while (i + 1 < limit) {
    i = skipWhitespace(source, i);
    var skippedComment = false;
    for (let comment in ctx.ast.comments) {
      if (i >= comment.start && i < comment.end) {
        i = comment.end;
        skippedComment = true;
        break;
      }
    }
    if (skippedComment) {
      continue;
    }
    if (i < limit && source.getByteAt(i) == RIGHT_PAREN) {
      i += 1;
      continue;
    }
    if (i + 1 < limit && source.getByteAt(i) == QUESTION &&
        source.getByteAt(i + 1) == afterQuestion) {
      return i;
    }
    return -1;
  }
  return -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