@birdcc/linter 0.0.1-alpha.0

package/src/rules/shared.ts

@@ -0,0 +1,354 @@
+import { isIP } from "node:net";
+import type {
+  BirdDiagnostic,
+  BirdDiagnosticSeverity,
+  CoreSnapshot,
+} from "@birdcc/core";
+import type {
+  BirdDeclaration,
+  FilterBodyStatement,
+  FilterDeclaration,
+  FunctionDeclaration,
+  ParsedBirdDocument,
+  ProtocolDeclaration,
+  ProtocolStatement,
+  SourceRange,
+  TableDeclaration,
+  TemplateDeclaration,
+} from "@birdcc/parser";
+import { RULE_SEVERITY, type RuleCode } from "./catalog.js";
+
+export interface RuleContext {
+  text: string;
+  parsed: ParsedBirdDocument;
+  core: CoreSnapshot;
+}
+
+export type BirdRule = (context: RuleContext) => BirdDiagnostic[];
+
+export const normalizeClause = (text: string): string =>
+  text.trim().replace(/\s+/g, " ").toLowerCase();
+
+export const createRuleDiagnostic = (
+  code: RuleCode,
+  message: string,
+  range: SourceRange,
+  source: BirdDiagnostic["source"] = "linter",
+): BirdDiagnostic => ({
+  code,
+  message,
+  severity: RULE_SEVERITY[code],
+  source,
+  range: {
+    line: range.line,
+    column: range.column,
+    endLine: range.endLine,
+    endColumn: range.endColumn,
+  },
+});
+
+export const diagnosticDedupKey = (diagnostic: BirdDiagnostic): string =>
+  [
+    diagnostic.code,
+    diagnostic.message,
+    diagnostic.range.line,
+    diagnostic.range.column,
+    diagnostic.range.endLine,
+    diagnostic.range.endColumn,
+  ].join(":");
+
+export const pushUniqueDiagnostic = (
+  diagnostics: BirdDiagnostic[],
+  seen: Set<string>,
+  diagnostic: BirdDiagnostic,
+): void => {
+  const key = diagnosticDedupKey(diagnostic);
+  if (seen.has(key)) {
+    return;
+  }
+
+  seen.add(key);
+  diagnostics.push(diagnostic);
+};
+
+export const withSeverity = (
+  code: RuleCode,
+  diagnostic: Omit<BirdDiagnostic, "severity" | "code">,
+): BirdDiagnostic => ({
+  ...diagnostic,
+  code,
+  severity: RULE_SEVERITY[code],
+});
+
+export const protocolDeclarations = (
+  parsed: ParsedBirdDocument,
+): ProtocolDeclaration[] =>
+  parsed.program.declarations.filter(
+    (declaration): declaration is ProtocolDeclaration =>
+      declaration.kind === "protocol",
+  );
+
+export const templateDeclarations = (
+  parsed: ParsedBirdDocument,
+): TemplateDeclaration[] =>
+  parsed.program.declarations.filter(
+    (declaration): declaration is TemplateDeclaration =>
+      declaration.kind === "template",
+  );
+
+export const tableDeclarations = (
+  parsed: ParsedBirdDocument,
+): TableDeclaration[] =>
+  parsed.program.declarations.filter(
+    (declaration): declaration is TableDeclaration =>
+      declaration.kind === "table",
+  );
+
+export const filterDeclarations = (
+  parsed: ParsedBirdDocument,
+): FilterDeclaration[] =>
+  parsed.program.declarations.filter(
+    (declaration): declaration is FilterDeclaration =>
+      declaration.kind === "filter",
+  );
+
+export const functionDeclarations = (
+  parsed: ParsedBirdDocument,
+): FunctionDeclaration[] =>
+  parsed.program.declarations.filter(
+    (declaration): declaration is FunctionDeclaration =>
+      declaration.kind === "function",
+  );
+
+export const filterAndFunctionDeclarations = (
+  parsed: ParsedBirdDocument,
+): Array<FilterDeclaration | FunctionDeclaration> =>
+  parsed.program.declarations.filter(
+    (declaration): declaration is FilterDeclaration | FunctionDeclaration =>
+      declaration.kind === "filter" || declaration.kind === "function",
+  );
+
+export const routerIdDeclarations = (
+  parsed: ParsedBirdDocument,
+): BirdDeclaration[] =>
+  parsed.program.declarations.filter(
+    (declaration) => declaration.kind === "router-id",
+  );
+
+export const isProtocolType = (
+  declaration: ProtocolDeclaration,
+  expected: string,
+): boolean => declaration.protocolType.toLowerCase() === expected;
+
+export const protocolOtherStatements = (
+  declaration: ProtocolDeclaration,
+): ProtocolStatement[] =>
+  declaration.statements.filter((statement) => statement.kind === "other");
+
+export const protocolOtherTextEntries = (
+  declaration: ProtocolDeclaration,
+): Array<{ text: string; range: SourceRange }> => {
+  const entries: Array<{ text: string; range: SourceRange }> = [];
+
+  for (const statement of declaration.statements) {
+    if (statement.kind === "other") {
+      entries.push({ text: statement.text, range: statement });
+      continue;
+    }
+
+    if (statement.kind !== "channel") {
+      continue;
+    }
+
+    for (const entry of statement.entries) {
+      if (entry.kind !== "other") {
+        continue;
+      }
+
+      entries.push({ text: entry.text, range: entry });
+    }
+  }
+
+  return entries;
+};
+
+export const channelOtherEntries = (
+  declaration: ProtocolDeclaration,
+): Array<{ channelType: string; text: string; range: SourceRange }> => {
+  const entries: Array<{
+    channelType: string;
+    text: string;
+    range: SourceRange;
+  }> = [];
+
+  for (const statement of declaration.statements) {
+    if (statement.kind !== "channel") {
+      continue;
+    }
+
+    for (const entry of statement.entries) {
+      if (entry.kind !== "other") {
+        continue;
+      }
+
+      entries.push({
+        channelType: statement.channelType,
+        text: entry.text,
+        range: entry,
+      });
+    }
+  }
+
+  return entries;
+};
+
+export const numericValue = (value: string | undefined): number | null => {
+  if (!value) {
+    return null;
+  }
+
+  const normalized = value.trim();
+  if (!/^-?\d+$/.test(normalized)) {
+    return null;
+  }
+
+  const parsed = Number.parseInt(normalized, 10);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+
+export const extractFirstNumberAfterKeyword = (
+  text: string,
+  keyword: string,
+): number | null => {
+  const pattern = new RegExp(`${keyword}\\s+(-?\\d+)`, "i");
+  const matched = text.match(pattern);
+  return numericValue(matched?.[1]);
+};
+
+export const hasBooleanValue = (value: string): boolean =>
+  ["on", "off", "yes", "no", "true", "false", "enabled", "disabled"].includes(
+    normalizeClause(value),
+  );
+
+export const extractFunctionCalls = (text: string): string[] => {
+  const names: string[] = [];
+  const pattern = /\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+  const ignored = new Set(["if", "switch", "print", "defined"]);
+  let current = pattern.exec(text);
+
+  while (current) {
+    const name = current[1] ?? "";
+    const matchIndex = current.index ?? -1;
+    const isMethodCall = matchIndex > 0 && text[matchIndex - 1] === ".";
+    if (name.length > 0 && !ignored.has(name.toLowerCase()) && !isMethodCall) {
+      names.push(name);
+    }
+    current = pattern.exec(text);
+  }
+
+  return names;
+};
+
+export const scalarTypeOfExpression = (
+  expressionText: string,
+): "int" | "bool" | "string" | "ip" | "prefix" | "unknown" => {
+  const text = expressionText.trim();
+  if (/^-?\d+$/.test(text)) {
+    return "int";
+  }
+  if (/^(true|false|yes|no|on|off)$/i.test(text)) {
+    return "bool";
+  }
+  if (
+    (text.startsWith('"') && text.endsWith('"')) ||
+    (text.startsWith("'") && text.endsWith("'"))
+  ) {
+    return "string";
+  }
+  if (text.includes("/") && isPrefixLiteral(text)) {
+    return "prefix";
+  }
+  if (isIP(text) !== 0) {
+    return "ip";
+  }
+  return "unknown";
+};
+
+export const isPrefixLiteral = (value: string): boolean => {
+  const [address, lengthText] = value.split("/");
+  if (!address || !lengthText) {
+    return false;
+  }
+
+  const length = numericValue(lengthText);
+  if (length === null || length < 0 || length > 128) {
+    return false;
+  }
+
+  const family = isIP(address.trim());
+  if (family === 4) {
+    return length <= 32;
+  }
+
+  if (family === 6) {
+    return length <= 128;
+  }
+
+  return false;
+};
+
+export const eachFilterBodyExpression = (
+  parsed: ParsedBirdDocument,
+): Array<{ statement: FilterBodyStatement; declarationName: string }> => {
+  const list: Array<{
+    statement: FilterBodyStatement;
+    declarationName: string;
+  }> = [];
+
+  for (const declaration of filterAndFunctionDeclarations(parsed)) {
+    for (const statement of declaration.statements) {
+      list.push({ statement, declarationName: declaration.name });
+    }
+  }
+
+  return list;
+};
+
+export const findTemplateByName = (
+  parsed: ParsedBirdDocument,
+  templateName: string,
+): TemplateDeclaration | undefined => {
+  const lowered = templateName.toLowerCase();
+  return templateDeclarations(parsed).find(
+    (item) => item.name.toLowerCase() === lowered,
+  );
+};
+
+export const hasSymbolKind = (
+  core: CoreSnapshot,
+  kind: "protocol" | "template" | "filter" | "function" | "table",
+  name: string,
+): boolean => {
+  const lowered = name.toLowerCase();
+  return core.symbols.some(
+    (symbol) => symbol.kind === kind && symbol.name.toLowerCase() === lowered,
+  );
+};
+
+export const createProtocolDiagnostic = (
+  code: RuleCode,
+  message: string,
+  declaration: ProtocolDeclaration,
+  severity?: BirdDiagnosticSeverity,
+): BirdDiagnostic => ({
+  code,
+  message,
+  severity: severity ?? RULE_SEVERITY[code],
+  source: "linter",
+  range: {
+    line: declaration.nameRange.line,
+    column: declaration.nameRange.column,
+    endLine: declaration.nameRange.endLine,
+    endColumn: declaration.nameRange.endColumn,
+  },
+});

package/src/rules/sym.ts

@@ -0,0 +1,342 @@
+import type { BirdDiagnostic } from "@birdcc/core";
+import type {
+  ChannelEntry,
+  ChannelExportEntry,
+  ChannelImportEntry,
+  ProtocolDeclaration,
+  SourceRange,
+} from "@birdcc/parser";
+import {
+  createRuleDiagnostic,
+  eachFilterBodyExpression,
+  extractFunctionCalls,
+  filterDeclarations,
+  findTemplateByName,
+  functionDeclarations,
+  hasSymbolKind,
+  normalizeClause,
+  pushUniqueDiagnostic,
+  protocolDeclarations,
+  tableDeclarations,
+  type BirdRule,
+} from "./shared.js";
+
+const normalizeProtocolFamily = (text: string): string =>
+  normalizeClause(text).split(" ")[0] ?? "";
+const BUILTIN_FILTER_NAMES = new Set([
+  "all",
+  "none",
+  "accept",
+  "reject",
+  "announce",
+]);
+const BUILTIN_FUNCTION_NAMES = new Set([
+  "net",
+  "bgp_path",
+  "bgp_community",
+  "bgp_ext_community",
+  "bgp_large_community",
+  "bgp_origin",
+  "defined",
+  "len",
+  "match",
+  "route_source",
+  "roa_check",
+  "prefix",
+  "ip",
+  "int",
+]);
+
+const isImportOrExportFilterClause = (
+  value: unknown,
+): value is {
+  mode: "filter";
+  filterName?: string;
+  filterNameRange?: SourceRange;
+} => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  return (value as { mode?: string }).mode === "filter";
+};
+
+const isChannelFilterClause = (
+  entry: ChannelEntry,
+): entry is ChannelImportEntry | ChannelExportEntry =>
+  (entry.kind === "import" || entry.kind === "export") &&
+  entry.mode === "filter";
+
+const collectProtocolFilterClauses = (
+  declaration: ProtocolDeclaration,
+): Array<{ filterName?: string; range: SourceRange }> => {
+  const clauses: Array<{ filterName?: string; range: SourceRange }> = [];
+
+  for (const statement of declaration.statements) {
+    if (isImportOrExportFilterClause(statement)) {
+      clauses.push({
+        filterName: statement.filterName,
+        range: statement.filterNameRange ?? statement,
+      });
+      continue;
+    }
+
+    if (statement.kind !== "channel") {
+      continue;
+    }
+
+    for (const entry of statement.entries) {
+      if (!isChannelFilterClause(entry)) {
+        continue;
+      }
+
+      clauses.push({
+        filterName: entry.filterName,
+        range: entry.filterNameRange ?? entry,
+      });
+    }
+  }
+
+  return clauses;
+};
+
+const symProtoTypeMismatchRule: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    if (!declaration.fromTemplate) {
+      continue;
+    }
+
+    const template = findTemplateByName(parsed, declaration.fromTemplate);
+    if (!template) {
+      continue;
+    }
+
+    const protocolFamily = normalizeProtocolFamily(declaration.protocolType);
+    const templateFamily = normalizeProtocolFamily(template.templateType);
+    if (
+      protocolFamily.length === 0 ||
+      templateFamily.length === 0 ||
+      protocolFamily === templateFamily
+    ) {
+      continue;
+    }
+
+    pushUniqueDiagnostic(
+      diagnostics,
+      seen,
+      createRuleDiagnostic(
+        "sym/proto-type-mismatch",
+        `Protocol '${declaration.name}' (${declaration.protocolType}) cannot use template '${template.name}' (${template.templateType})`,
+        declaration.fromTemplateRange ?? declaration.nameRange,
+      ),
+    );
+  }
+
+  return diagnostics;
+};
+
+const symFilterRequiredRule: BirdRule = ({ parsed, core }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+  const filterNames = new Set(
+    filterDeclarations(parsed).map((item) => item.name.toLowerCase()),
+  );
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    for (const clause of collectProtocolFilterClauses(declaration)) {
+      const name = clause.filterName?.trim();
+      if (!name) {
+        pushUniqueDiagnostic(
+          diagnostics,
+          seen,
+          createRuleDiagnostic(
+            "sym/filter-required",
+            `Protocol '${declaration.name}' requires a filter name in import/export filter clause`,
+            clause.range,
+          ),
+        );
+        continue;
+      }
+
+      const loweredName = name.toLowerCase();
+      if (
+        !filterNames.has(loweredName) &&
+        !hasSymbolKind(core, "filter", name)
+      ) {
+        if (BUILTIN_FILTER_NAMES.has(loweredName)) {
+          continue;
+        }
+
+        pushUniqueDiagnostic(
+          diagnostics,
+          seen,
+          createRuleDiagnostic(
+            "sym/filter-required",
+            `Protocol '${declaration.name}' references unknown filter '${name}'`,
+            clause.range,
+          ),
+        );
+      }
+    }
+  }
+
+  return diagnostics;
+};
+
+const symFunctionRequiredRule: BirdRule = ({ parsed, core }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+  const functions = new Set(
+    functionDeclarations(parsed).map((item) => item.name.toLowerCase()),
+  );
+  for (const builtin of BUILTIN_FUNCTION_NAMES) {
+    functions.add(builtin);
+  }
+
+  for (const { statement, declarationName } of eachFilterBodyExpression(
+    parsed,
+  )) {
+    const textParts: string[] = [];
+    if (statement.kind === "expression") {
+      textParts.push(statement.expressionText);
+    }
+    if (statement.kind === "other") {
+      textParts.push(statement.text);
+    }
+    if (statement.kind === "if" && statement.conditionText) {
+      textParts.push(statement.conditionText);
+    }
+
+    if (textParts.length === 0) {
+      continue;
+    }
+
+    const joined = textParts.join(" ");
+    for (const callName of extractFunctionCalls(joined)) {
+      if (
+        functions.has(callName.toLowerCase()) ||
+        hasSymbolKind(core, "function", callName)
+      ) {
+        continue;
+      }
+
+      pushUniqueDiagnostic(
+        diagnostics,
+        seen,
+        createRuleDiagnostic(
+          "sym/function-required",
+          `Declaration '${declarationName}' references undefined function '${callName}'`,
+          statement,
+        ),
+      );
+    }
+  }
+
+  return diagnostics;
+};
+
+const symTableRequiredRule: BirdRule = ({ parsed, core }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+  const tableNames = new Set(
+    tableDeclarations(parsed).map((item) => item.name.toLowerCase()),
+  );
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    for (const statement of declaration.statements) {
+      if (statement.kind === "channel") {
+        for (const entry of statement.entries) {
+          if (entry.kind !== "table") {
+            continue;
+          }
+
+          const tableName = entry.tableName.trim();
+          if (!tableName) {
+            pushUniqueDiagnostic(
+              diagnostics,
+              seen,
+              createRuleDiagnostic(
+                "sym/table-required",
+                `Protocol '${declaration.name}' requires a table name in channel table clause`,
+                entry,
+              ),
+            );
+            continue;
+          }
+
+          if (
+            !tableNames.has(tableName.toLowerCase()) &&
+            !hasSymbolKind(core, "table", tableName)
+          ) {
+            pushUniqueDiagnostic(
+              diagnostics,
+              seen,
+              createRuleDiagnostic(
+                "sym/table-required",
+                `Protocol '${declaration.name}' references unknown table '${tableName}'`,
+                entry.tableNameRange,
+              ),
+            );
+          }
+        }
+      }
+
+      if (statement.kind !== "other") {
+        continue;
+      }
+
+      const text = statement.text;
+      const matched = text.match(/\btable\b(?:\s+([A-Za-z_][A-Za-z0-9_]*))?/i);
+      if (!matched) {
+        continue;
+      }
+
+      const tableName = matched[1]?.trim();
+      if (!tableName) {
+        pushUniqueDiagnostic(
+          diagnostics,
+          seen,
+          createRuleDiagnostic(
+            "sym/table-required",
+            `Protocol '${declaration.name}' requires table name after 'table'`,
+            statement,
+          ),
+        );
+        continue;
+      }
+
+      if (
+        !tableNames.has(tableName.toLowerCase()) &&
+        !hasSymbolKind(core, "table", tableName)
+      ) {
+        pushUniqueDiagnostic(
+          diagnostics,
+          seen,
+          createRuleDiagnostic(
+            "sym/table-required",
+            `Protocol '${declaration.name}' references unknown table '${tableName}'`,
+            statement,
+          ),
+        );
+      }
+    }
+  }
+
+  return diagnostics;
+};
+
+export const symRules: BirdRule[] = [
+  symProtoTypeMismatchRule,
+  symFilterRequiredRule,
+  symFunctionRequiredRule,
+  symTableRequiredRule,
+];
+
+export const collectSymRuleDiagnostics = (
+  context: Parameters<BirdRule>[0],
+): BirdDiagnostic[] => {
+  return symRules.flatMap((rule) => rule(context));
+};