@birdcc/core 0.0.1-alpha.0

package/src/symbol-table.ts

@@ -0,0 +1,171 @@
+import type { ParsedBirdDocument } from "@birdcc/parser";
+import type {
+  BirdDiagnostic,
+  BirdSymbolKind,
+  SymbolDefinition,
+  SymbolReference,
+  SymbolTable,
+} from "./types.js";
+import { createRange } from "./range.js";
+
+export const DEFAULT_DOCUMENT_URI = "memory://bird.conf";
+
+const declarationToSymbol = (
+  declaration: ParsedBirdDocument["program"]["declarations"][number],
+  uri: string,
+): SymbolDefinition | null => {
+  const toSymbol = (
+    kind: BirdSymbolKind,
+    name: string,
+    nameRange: {
+      line: number;
+      column: number;
+      endLine: number;
+      endColumn: number;
+    },
+  ): SymbolDefinition => ({
+    kind,
+    name,
+    line: nameRange.line,
+    column: nameRange.column,
+    endLine: nameRange.endLine,
+    endColumn: nameRange.endColumn,
+    uri,
+  });
+
+  if (declaration.kind === "protocol") {
+    return toSymbol("protocol", declaration.name, declaration.nameRange);
+  }
+
+  if (declaration.kind === "template") {
+    return toSymbol("template", declaration.name, declaration.nameRange);
+  }
+
+  if (declaration.kind === "filter") {
+    return toSymbol("filter", declaration.name, declaration.nameRange);
+  }
+
+  if (declaration.kind === "function") {
+    return toSymbol("function", declaration.name, declaration.nameRange);
+  }
+
+  if (declaration.kind === "table") {
+    return toSymbol("table", declaration.name, declaration.nameRange);
+  }
+
+  return null;
+};
+
+export const buildSymbolTableFromParsed = (
+  parsed: ParsedBirdDocument,
+  options: { uri?: string } = {},
+): SymbolTable => {
+  const uri = options.uri ?? DEFAULT_DOCUMENT_URI;
+  const definitions: SymbolDefinition[] = [];
+  const references: SymbolReference[] = [];
+
+  for (const declaration of parsed.program.declarations) {
+    const symbol = declarationToSymbol(declaration, uri);
+    if (symbol) {
+      definitions.push(symbol);
+    }
+
+    if (declaration.kind === "protocol" && declaration.fromTemplate) {
+      const range = declaration.fromTemplateRange ?? {
+        line: declaration.line,
+        column: declaration.column,
+        endLine: declaration.endLine,
+        endColumn: declaration.endColumn,
+      };
+
+      references.push({
+        kind: "template",
+        name: declaration.fromTemplate,
+        line: range.line,
+        column: range.column,
+        endLine: range.endLine,
+        endColumn: range.endColumn,
+        uri,
+      });
+    }
+
+    if (declaration.kind === "template" && declaration.fromTemplate) {
+      const range = declaration.fromTemplateRange ?? {
+        line: declaration.line,
+        column: declaration.column,
+        endLine: declaration.endLine,
+        endColumn: declaration.endColumn,
+      };
+
+      references.push({
+        kind: "template",
+        name: declaration.fromTemplate,
+        line: range.line,
+        column: range.column,
+        endLine: range.endLine,
+        endColumn: range.endColumn,
+        uri,
+      });
+    }
+  }
+
+  return { definitions, references };
+};
+
+export const mergeSymbolTables = (tables: SymbolTable[]): SymbolTable => {
+  const definitions: SymbolDefinition[] = [];
+  const references: SymbolReference[] = [];
+
+  for (const table of tables) {
+    definitions.push(...table.definitions);
+    references.push(...table.references);
+  }
+
+  return { definitions, references };
+};
+
+export const pushSymbolTableDiagnostics = (
+  symbolTable: SymbolTable,
+  diagnostics: BirdDiagnostic[],
+): void => {
+  const seenDefinitions = new Map<string, SymbolDefinition>();
+
+  for (const symbol of symbolTable.definitions) {
+    const key = `${symbol.kind}:${symbol.name.toLowerCase()}`;
+    const previous = seenDefinitions.get(key);
+
+    if (previous) {
+      diagnostics.push({
+        code: "semantic/duplicate-definition",
+        message: `${symbol.kind} '${symbol.name}' is already defined`,
+        severity: "error",
+        source: "core",
+        uri: symbol.uri,
+        range: createRange(symbol.line, symbol.column, symbol.name.length),
+      });
+      continue;
+    }
+
+    seenDefinitions.set(key, symbol);
+  }
+
+  for (const reference of symbolTable.references) {
+    const key = `template:${reference.name.toLowerCase()}`;
+    if (seenDefinitions.has(key)) {
+      continue;
+    }
+
+    diagnostics.push({
+      code: "semantic/undefined-reference",
+      message: `Undefined template reference '${reference.name}'`,
+      severity: "error",
+      source: "core",
+      uri: reference.uri,
+      range: createRange(
+        reference.line,
+        reference.column,
+        reference.name.length,
+      ),
+    });
+  }
+};

package/src/template-cycles.ts

@@ -0,0 +1,142 @@
+import type { ParsedBirdDocument, SourceRange } from "@birdcc/parser";
+import type { BirdDiagnostic } from "./types.js";
+
+interface ParsedDocumentWithUri {
+  uri: string;
+  parsed: ParsedBirdDocument;
+}
+
+interface TemplateInheritanceNode {
+  uri: string;
+  name: string;
+  key: string;
+  parentName?: string;
+  parentKey?: string;
+  parentRange: SourceRange;
+}
+
+const createNode = (
+  uri: string,
+  declaration: Extract<
+    ParsedBirdDocument["program"]["declarations"][number],
+    { kind: "template" }
+  >,
+): TemplateInheritanceNode => ({
+  uri,
+  name: declaration.name,
+  key: declaration.name.toLowerCase(),
+  parentName: declaration.fromTemplate,
+  parentKey: declaration.fromTemplate?.toLowerCase(),
+  parentRange: declaration.fromTemplateRange ?? declaration.nameRange,
+});
+
+const collectTemplateInheritanceNodes = (
+  parsedDocuments: ParsedDocumentWithUri[],
+): Map<string, TemplateInheritanceNode> => {
+  const nodes = new Map<string, TemplateInheritanceNode>();
+
+  for (const document of parsedDocuments) {
+    const { uri, parsed } = document;
+    for (const declaration of parsed.program.declarations) {
+      if (declaration.kind !== "template") {
+        continue;
+      }
+
+      const node = createNode(uri, declaration);
+      if (!nodes.has(node.key)) {
+        nodes.set(node.key, node);
+      }
+    }
+  }
+
+  return nodes;
+};
+
+const normalizeParsedDocuments = (
+  parsedDocuments: ParsedBirdDocument[] | ParsedDocumentWithUri[],
+): ParsedDocumentWithUri[] => {
+  if (parsedDocuments.length === 0) {
+    return [];
+  }
+
+  const first = parsedDocuments[0];
+  if ("parsed" in first && "uri" in first) {
+    return parsedDocuments as ParsedDocumentWithUri[];
+  }
+
+  return (parsedDocuments as ParsedBirdDocument[]).map((parsed, index) => ({
+    uri: `memory://document-${index + 1}.conf`,
+    parsed,
+  }));
+};
+
+export const collectCircularTemplateDiagnostics = (
+  parsedDocuments: ParsedBirdDocument[] | ParsedDocumentWithUri[],
+): BirdDiagnostic[] => {
+  const normalizedDocuments = normalizeParsedDocuments(parsedDocuments);
+  const nodes = collectTemplateInheritanceNodes(normalizedDocuments);
+  const diagnostics: BirdDiagnostic[] = [];
+  const state = new Map<string, 0 | 1 | 2>();
+  const stack: string[] = [];
+  const emitted = new Set<string>();
+
+  const visit = (key: string): void => {
+    state.set(key, 1);
+    stack.push(key);
+
+    const node = nodes.get(key);
+    const parentKey = node?.parentKey;
+
+    if (node && parentKey && nodes.has(parentKey)) {
+      const parentState = state.get(parentKey) ?? 0;
+
+      if (parentState === 0) {
+        visit(parentKey);
+      } else if (parentState === 1) {
+        const startIndex = stack.lastIndexOf(parentKey);
+        if (startIndex >= 0) {
+          const cycleKeys = [...stack.slice(startIndex), parentKey];
+          const cycleSignature = cycleKeys
+            .slice(0, -1)
+            .map((entry) => entry.toLowerCase())
+            .sort()
+            .join("->");
+
+          if (!emitted.has(cycleSignature)) {
+            emitted.add(cycleSignature);
+            const cycleNames = cycleKeys.map(
+              (entry) => nodes.get(entry)?.name ?? entry,
+            );
+
+            diagnostics.push({
+              code: "semantic/circular-template",
+              message: `Circular template inheritance detected: ${cycleNames.join(" -> ")}`,
+              severity: "error",
+              source: "core",
+              uri: node.uri,
+              range: {
+                line: node.parentRange.line,
+                column: node.parentRange.column,
+                endLine: node.parentRange.endLine,
+                endColumn: node.parentRange.endColumn,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    stack.pop();
+    state.set(key, 2);
+  };
+
+  for (const key of nodes.keys()) {
+    if ((state.get(key) ?? 0) !== 0) {
+      continue;
+    }
+
+    visit(key);
+  }
+
+  return diagnostics;
+};