@birdcc/linter 0.0.1-alpha.0

package/src/rules/type.ts

@@ -0,0 +1,210 @@
+import type { BirdDiagnostic } from "@birdcc/core";
+import type { FilterBodyStatement, SourceRange } from "@birdcc/parser";
+import {
+  createRuleDiagnostic,
+  filterAndFunctionDeclarations,
+  pushUniqueDiagnostic,
+  scalarTypeOfExpression,
+  type BirdRule,
+} from "./shared.js";
+
+interface MatchPair {
+  left: string;
+  right: string;
+}
+
+const normalizeLeftExpression = (value: string): string =>
+  value.replace(/^\s*if\s+/i, "").trim();
+
+const normalizeRightExpression = (value: string): string =>
+  value
+    .replace(/\bthen\b.*$/i, "")
+    .replace(/[;]+$/, "")
+    .trim();
+
+const extractMatches = (text: string): MatchPair[] => {
+  const matches: MatchPair[] = [];
+  const pattern = /([^;\n]+?)\s*~\s*([^;\n]+)/g;
+  let current = pattern.exec(text);
+
+  while (current) {
+    const left = normalizeLeftExpression(current[1] ?? "");
+    const right = normalizeRightExpression(current[2] ?? "");
+    if (left && right) {
+      matches.push({ left, right });
+    }
+    current = pattern.exec(text);
+  }
+
+  return matches;
+};
+
+const splitSetItems = (setText: string): string[] => {
+  const inner = setText.trim().slice(1, -1).trim();
+  if (!inner) {
+    return [];
+  }
+
+  return inner
+    .split(",")
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+};
+
+const statementText = (statement: FilterBodyStatement): string => {
+  if (statement.kind === "expression") {
+    return statement.expressionText;
+  }
+
+  if (statement.kind === "other") {
+    return statement.text;
+  }
+
+  if (statement.kind === "if") {
+    return statement.conditionText ?? "";
+  }
+
+  if (statement.kind === "return") {
+    return statement.valueText ?? "";
+  }
+
+  return "";
+};
+
+const declarationText = (source: string, range: SourceRange): string => {
+  const lines = source.split(/\r?\n/);
+  const startLine = Math.max(1, range.line);
+  const endLine = Math.max(startLine, range.endLine);
+  return lines.slice(startLine - 1, endLine).join("\n");
+};
+
+const typeNotIterableRule: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+
+  for (const declaration of filterAndFunctionDeclarations(parsed)) {
+    for (const statement of declaration.statements) {
+      const text = statementText(statement);
+      if (!text) {
+        continue;
+      }
+
+      for (const match of extractMatches(text)) {
+        if (match.right.startsWith("[") && match.right.endsWith("]")) {
+          continue;
+        }
+
+        pushUniqueDiagnostic(
+          diagnostics,
+          seen,
+          createRuleDiagnostic(
+            "type/not-iterable",
+            `Type '${match.right}' is not iterable in match expression '${match.left} ~ ${match.right}'`,
+            statement,
+          ),
+        );
+      }
+    }
+
+    for (const match of declaration.matches) {
+      const right = normalizeRightExpression(match.right);
+      if (right.startsWith("[") && right.endsWith("]")) {
+        continue;
+      }
+
+      pushUniqueDiagnostic(
+        diagnostics,
+        seen,
+        createRuleDiagnostic(
+          "type/not-iterable",
+          `Type '${right}' is not iterable in match expression '${match.left} ${match.operator} ${match.right}'`,
+          match,
+        ),
+      );
+    }
+  }
+
+  return diagnostics;
+};
+
+const typeSetIncompatibleRule: BirdRule = ({ parsed, text }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+
+  const evaluateSetCompatibility = (
+    left: string,
+    right: string,
+    range: SourceRange,
+  ): void => {
+    const normalizedRight = normalizeRightExpression(right);
+    if (!normalizedRight.startsWith("[") || !normalizedRight.endsWith("]")) {
+      return;
+    }
+
+    const leftType = scalarTypeOfExpression(left);
+    if (leftType === "unknown") {
+      return;
+    }
+
+    const items = splitSetItems(normalizedRight);
+    if (items.length === 0) {
+      return;
+    }
+
+    const firstType = scalarTypeOfExpression(items[0] ?? "");
+    if (firstType === "unknown" || firstType === leftType) {
+      return;
+    }
+
+    pushUniqueDiagnostic(
+      diagnostics,
+      seen,
+      createRuleDiagnostic(
+        "type/set-incompatible",
+        `Set-incompatible type (${leftType}) for match set '${normalizedRight}'`,
+        range,
+      ),
+    );
+  };
+
+  for (const declaration of filterAndFunctionDeclarations(parsed)) {
+    for (const statement of declaration.statements) {
+      const text = statementText(statement);
+      if (!text) {
+        continue;
+      }
+
+      for (const match of extractMatches(text)) {
+        evaluateSetCompatibility(match.left, match.right, statement);
+      }
+    }
+
+    for (const match of declaration.matches) {
+      evaluateSetCompatibility(match.left, match.right, match);
+    }
+
+    const hasTruncatedSetMatch = declaration.matches.some(
+      (match) => match.right.includes("[") && !match.right.includes("]"),
+    );
+
+    if (hasTruncatedSetMatch) {
+      const sourceText = declarationText(text, declaration);
+      for (const match of extractMatches(sourceText)) {
+        evaluateSetCompatibility(match.left, match.right, declaration);
+      }
+    }
+  }
+
+  return diagnostics;
+};
+
+export const typeRules: BirdRule[] = [
+  typeNotIterableRule,
+  typeSetIncompatibleRule,
+];
+
+export const collectTypeRuleDiagnostics = (
+  context: Parameters<BirdRule>[0],
+): BirdDiagnostic[] => {
+  return typeRules.flatMap((rule) => rule(context));
+};

package/test/linter.bgp-ospf.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from "vitest";
+import { lintBirdConfig } from "../src/index.js";
+
+const codesOf = async (text: string): Promise<string[]> => {
+  const result = await lintBirdConfig(text);
+  return result.diagnostics.map((item) => item.code);
+};
+
+describe("@birdcc/linter bgp+ospf rules", () => {
+  it("hits bgp/missing-local-as", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        neighbor 192.0.2.1 as 65002;
+      }
+    `);
+
+    expect(codes).toContain("bgp/missing-local-as");
+  });
+
+  it("hits bgp/missing-neighbor", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+      }
+    `);
+
+    expect(codes).toContain("bgp/missing-neighbor");
+  });
+
+  it("hits bgp/missing-remote-as", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 192.0.2.1;
+      }
+    `);
+
+    expect(codes).toContain("bgp/missing-remote-as");
+  });
+
+  it("hits bgp/as-mismatch", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 192.0.2.9 as internal;
+        neighbor 192.0.2.1 as 65002;
+      }
+    `);
+
+    expect(codes).toContain("bgp/as-mismatch");
+  });
+
+  it("does not hit bgp/missing-remote-as for internal/external sessions", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 192.0.2.1 as internal;
+        neighbor 192.0.2.2 as external;
+      }
+    `);
+
+    expect(codes).not.toContain("bgp/missing-remote-as");
+  });
+
+  it("hits bgp/timer-invalid", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 192.0.2.1 as 65001;
+        hold 2;
+        keepalive 10;
+      }
+    `);
+
+    expect(codes).toContain("bgp/timer-invalid");
+  });
+
+  it("hits ospf/missing-area", async () => {
+    const codes = await codesOf(`
+      protocol ospf core {
+      }
+    `);
+
+    expect(codes).toContain("ospf/missing-area");
+  });
+
+  it("hits ospf/backbone-stub", async () => {
+    const codes = await codesOf(`
+      protocol ospf core {
+        area 0 stub;
+      }
+    `);
+
+    expect(codes).toContain("ospf/backbone-stub");
+  });
+
+  it("hits ospf/vlink-in-backbone", async () => {
+    const codes = await codesOf(`
+      protocol ospf core {
+        area 0 vlink 192.0.2.1;
+      }
+    `);
+
+    expect(codes).toContain("ospf/vlink-in-backbone");
+  });
+
+  it("hits ospf/asbr-stub-area", async () => {
+    const codes = await codesOf(`
+      protocol ospf core {
+        area 1 {
+          stub;
+          asbr on;
+        };
+      }
+    `);
+
+    expect(codes).toContain("ospf/asbr-stub-area");
+  });
+
+  it("accepts area 0.0.0.0 as backbone area id", async () => {
+    const codes = await codesOf(`
+      protocol ospf core {
+        area 0.0.0.0 stub;
+      }
+    `);
+
+    expect(codes).toContain("ospf/backbone-stub");
+  });
+});

package/test/linter.migration.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { lintBirdConfig } from "../src/index.js";
+
+const LEGACY_PATTERNS = [
+  /^protocol\//,
+  /^security\//,
+  /^performance\//,
+  /^structure\//,
+  /^semantic\//,
+  /^parser\//,
+  /^syntax\//,
+];
+
+describe("@birdcc/linter migration", () => {
+  it("maps parser/core diagnostics to 32-rule taxonomy", async () => {
+    const result = await lintBirdConfig(`
+      filter dup_policy {
+        accept;
+      }
+
+      filter dup_policy {
+        x = 1;
+        if net ~ [10.0.0.0/129] then accept;
+      }
+
+      protocol bgp edge from missing_tpl {
+        local as 65001;
+        neighbor 192.0.2.1 as 65002;
+      }
+    `);
+
+    const codes = result.diagnostics.map((item) => item.code);
+
+    expect(codes).toContain("sym/duplicate");
+    expect(codes).toContain("sym/undefined");
+    expect(codes).toContain("sym/variable-scope");
+    expect(codes).toContain("net/invalid-prefix-length");
+  });
+
+  it("maps parser recovery issues to cfg/syntax-error", async () => {
+    const result = await lintBirdConfig(`
+      protocol bgp edge {
+        local as 65001
+    `);
+
+    const codes = result.diagnostics.map((item) => item.code);
+    expect(codes).toContain("cfg/syntax-error");
+  });
+
+  it("does not output legacy code categories", async () => {
+    const result = await lintBirdConfig(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 192.0.2.1 as 65002;
+        import filter missing_policy;
+        ipv4 {
+          max prefix 128;
+        };
+      }
+    `);
+
+    for (const code of result.diagnostics.map((item) => item.code)) {
+      expect(LEGACY_PATTERNS.some((pattern) => pattern.test(code))).toBe(false);
+    }
+  });
+});

package/test/linter.net-type.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from "vitest";
+import { lintBirdConfig } from "../src/index.js";
+
+const codesOf = async (text: string): Promise<string[]> => {
+  const result = await lintBirdConfig(text);
+  return result.diagnostics.map((item) => item.code);
+};
+
+describe("@birdcc/linter net+type rules", () => {
+  it("hits net/invalid-prefix-length", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        if net ~ [10.0.0.0/129] then accept;
+      }
+    `);
+
+    expect(codes).toContain("net/invalid-prefix-length");
+  });
+
+  it("hits net/invalid-ipv4-prefix", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        if net ~ [10.0.500.0/24] then accept;
+      }
+    `);
+
+    expect(codes).toContain("net/invalid-ipv4-prefix");
+  });
+
+  it("hits net/invalid-ipv6-prefix", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        if net ~ [2001:db8::zz/64] then accept;
+      }
+    `);
+
+    expect(codes).toContain("net/invalid-ipv6-prefix");
+  });
+
+  it("hits net/invalid-ipv4-prefix for unknown address token", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        if net ~ [example/24] then accept;
+      }
+    `);
+
+    expect(codes).toContain("net/invalid-ipv4-prefix");
+  });
+
+  it("hits net/max-prefix-length", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        if net ~ [10.0.0.0/33] then accept;
+      }
+    `);
+
+    expect(codes).toContain("net/max-prefix-length");
+  });
+
+  it("hits net/invalid-prefix-length for negative max prefix", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 192.0.2.1 as 65002;
+        ipv4 {
+          max prefix -100;
+        };
+      }
+    `);
+
+    expect(codes).toContain("net/invalid-prefix-length");
+  });
+
+  it("hits net/max-prefix-length for ipv6 channel max prefix overflow", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 2001:db8::1 as 65002;
+        ipv6 {
+          max prefix 129;
+        };
+      }
+    `);
+
+    expect(codes).toContain("net/max-prefix-length");
+  });
+
+  it("hits net/invalid-prefix-length for non-numeric max prefix token", async () => {
+    const codes = await codesOf(`
+      protocol bgp edge {
+        local as 65001;
+        neighbor 192.0.2.1 as 65002;
+        ipv4 {
+          max prefix unlimited;
+        };
+      }
+    `);
+
+    expect(codes).toContain("net/invalid-prefix-length");
+  });
+
+  it("hits type/mismatch", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        int x = "hello";
+        accept;
+      }
+    `);
+
+    expect(codes).toContain("type/mismatch");
+  });
+
+  it("hits type/not-iterable", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        if net ~ 1 then accept;
+      }
+    `);
+
+    expect(codes).toContain("type/not-iterable");
+  });
+
+  it("hits type/set-incompatible", async () => {
+    const codes = await codesOf(`
+      filter f1 {
+        if 10.0.0.1 ~ [1, 2, 3] then accept;
+      }
+    `);
+
+    expect(codes).toContain("type/set-incompatible");
+  });
+});