@birdcc/parser 0.0.1-alpha.0 → 0.0.1-alpha.1

package/src/declarations/parse-declarations.ts

@@ -1,84 +0,0 @@
-import type { Node as SyntaxNode } from "web-tree-sitter";
-import type { BirdDeclaration, ParseIssue } from "../types.js";
-import {
-  parseDefineDeclaration,
-  parseIncludeDeclaration,
-  parseRouterIdDeclaration,
-  parseTableDeclaration,
-  parseTemplateDeclaration,
-} from "./basic.js";
-import { parseFilterDeclaration, parseFunctionDeclaration } from "./filter.js";
-import { parseProtocolDeclaration } from "./protocol.js";
-import {
-  parseRouterIdFromStatement,
-  parseTableFromStatement,
-} from "./top-level.js";
-
-export const parseDeclarations = (
-  rootNode: SyntaxNode,
-  source: string,
-  issues: ParseIssue[],
-): BirdDeclaration[] => {
-  const declarations: BirdDeclaration[] = [];
-
-  for (const child of rootNode.namedChildren) {
-    if (child.type === "include_declaration") {
-      declarations.push(parseIncludeDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "define_declaration") {
-      declarations.push(parseDefineDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "router_id_declaration") {
-      declarations.push(parseRouterIdDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "table_declaration") {
-      declarations.push(parseTableDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "protocol_declaration") {
-      declarations.push(parseProtocolDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "template_declaration") {
-      declarations.push(parseTemplateDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "filter_declaration") {
-      declarations.push(parseFilterDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "function_declaration") {
-      declarations.push(parseFunctionDeclaration(child, source, issues));
-      continue;
-    }
-
-    if (child.type === "top_level_statement") {
-      const routerFromTopLevel = parseRouterIdFromStatement(
-        child,
-        source,
-        issues,
-      );
-      if (routerFromTopLevel) {
-        declarations.push(routerFromTopLevel);
-        continue;
-      }
-
-      const tableFromTopLevel = parseTableFromStatement(child, source, issues);
-      if (tableFromTopLevel) {
-        declarations.push(tableFromTopLevel);
-      }
-    }
-  }
-
-  return declarations;
-};

package/src/declarations/protocol.ts

@@ -1,597 +0,0 @@
-import type { Node as SyntaxNode } from "web-tree-sitter";
-import type {
-  ChannelEntry,
-  ExportStatement,
-  ImportStatement,
-  ParseIssue,
-  ProtocolStatement,
-} from "../types.js";
-import { pushMissingFieldIssue } from "../issues.js";
-import { isPresentNode, mergeRanges, textOf, toRange } from "../tree.js";
-import {
-  CHANNEL_DIRECTIONS,
-  PROTOCOL_STATEMENT_TYPES,
-  type ProtocolDeclaration,
-  isIpLiteralCandidate,
-  normalizeChannelType,
-  protocolTypeTextAndRange,
-  protocolStatementNodesOf,
-} from "./shared.js";
-
-// Keep API near parseProtocolStatements and channel fallback behavior.
-const parseImportExportNode = (
-  statementNode: SyntaxNode,
-  source: string,
-): ImportStatement | ExportStatement => {
-  const statementRange = toRange(statementNode, source);
-  const clauseNode = statementNode.childForFieldName("clause");
-  const isImport = statementNode.type === "import_statement";
-
-  const base = {
-    kind: isImport ? ("import" as const) : ("export" as const),
-    ...statementRange,
-  };
-
-  if (!isPresentNode(clauseNode) || clauseNode.type === "all_clause") {
-    return {
-      ...base,
-      mode: "all",
-    };
-  }
-
-  if (clauseNode.type === "none_clause") {
-    return {
-      ...base,
-      mode: "none",
-    };
-  }
-
-  if (
-    clauseNode.type === "filter_name_clause" ||
-    clauseNode.type === "filter_block_clause"
-  ) {
-    const filterNameNode = clauseNode.childForFieldName("filter_name");
-
-    return {
-      ...base,
-      mode: "filter",
-      filterName: isPresentNode(filterNameNode)
-        ? textOf(filterNameNode, source)
-        : undefined,
-      filterNameRange: isPresentNode(filterNameNode)
-        ? toRange(filterNameNode, source)
-        : undefined,
-    };
-  }
-
-  if (clauseNode.type === "where_clause") {
-    const whereExpressionNode =
-      clauseNode.childForFieldName("where_expression");
-
-    return {
-      ...base,
-      mode: "where",
-      whereExpression: isPresentNode(whereExpressionNode)
-        ? textOf(whereExpressionNode, source)
-        : undefined,
-      whereExpressionRange: isPresentNode(whereExpressionNode)
-        ? toRange(whereExpressionNode, source)
-        : undefined,
-      clauseText: textOf(clauseNode, source),
-    };
-  }
-
-  const clauseText = textOf(clauseNode, source).trim();
-  const lowered = clauseText.toLowerCase();
-
-  if (lowered === "none" || lowered.startsWith("none ")) {
-    return {
-      ...base,
-      mode: "none",
-      clauseText,
-    };
-  }
-
-  if (lowered.startsWith("where ")) {
-    return {
-      ...base,
-      mode: "where",
-      whereExpression: clauseText.slice("where ".length).trim(),
-      clauseText,
-    };
-  }
-
-  if (lowered.startsWith("filter ")) {
-    const maybeName = clauseText.slice("filter ".length).trim();
-    return {
-      ...base,
-      mode: "filter",
-      filterName:
-        maybeName.length > 0 && !maybeName.startsWith("{")
-          ? maybeName
-          : undefined,
-      clauseText,
-    };
-  }
-
-  return {
-    ...base,
-    mode: "other",
-    clauseText,
-  };
-};
-
-const parseChannelEntries = (
-  channelBodyNode: SyntaxNode,
-  source: string,
-): ChannelEntry[] => {
-  const entries: ChannelEntry[] = [];
-  const namedChildren = channelBodyNode.namedChildren;
-
-  for (let index = 0; index < namedChildren.length; index += 1) {
-    const entryNode = namedChildren[index];
-    if (!entryNode) {
-      continue;
-    }
-
-    const entryRange = toRange(entryNode, source);
-
-    if (entryNode.type === "channel_table_statement") {
-      const tableNameNode = entryNode.childForFieldName("table_name");
-      entries.push({
-        kind: "table",
-        tableName: isPresentNode(tableNameNode)
-          ? textOf(tableNameNode, source)
-          : "",
-        tableNameRange: isPresentNode(tableNameNode)
-          ? toRange(tableNameNode, source)
-          : entryRange,
-        ...entryRange,
-      });
-      continue;
-    }
-
-    if (
-      entryNode.type === "identifier" &&
-      textOf(entryNode, source).toLowerCase() === "table" &&
-      namedChildren[index + 1]?.type === "identifier"
-    ) {
-      const tableNameNode = namedChildren[index + 1];
-      const tableRange = mergeRanges(
-        entryRange,
-        toRange(tableNameNode, source),
-      );
-      entries.push({
-        kind: "table",
-        tableName: textOf(tableNameNode, source),
-        tableNameRange: toRange(tableNameNode, source),
-        ...tableRange,
-      });
-      index += 1;
-      continue;
-    }
-
-    if (
-      entryNode.type === "import_statement" ||
-      entryNode.type === "export_statement"
-    ) {
-      const statement = parseImportExportNode(entryNode, source);
-      const clauseText = statement.clauseText?.toLowerCase() ?? "";
-
-      if (
-        statement.mode === "other" &&
-        (clauseText.startsWith("limit ") ||
-          clauseText.startsWith("keep filtered "))
-      ) {
-        if (clauseText.startsWith("keep filtered ")) {
-          entries.push({
-            kind: "keep-filtered",
-            value: (statement.clauseText ?? "")
-              .slice("keep filtered ".length)
-              .trim(),
-            valueRange: entryRange,
-            ...entryRange,
-          });
-        } else {
-          const payload = (statement.clauseText ?? "")
-            .slice("limit ".length)
-            .trim();
-          const actionMarker = " action ";
-          const actionIndex = payload.toLowerCase().indexOf(actionMarker);
-          const limitValue =
-            actionIndex === -1 ? payload : payload.slice(0, actionIndex).trim();
-          const limitAction =
-            actionIndex === -1
-              ? undefined
-              : payload.slice(actionIndex + actionMarker.length).trim();
-
-          entries.push({
-            kind: "limit",
-            direction: statement.kind === "export" ? "export" : "import",
-            value: limitValue,
-            valueRange: entryRange,
-            action: limitAction,
-            actionRange: limitAction ? entryRange : undefined,
-            ...entryRange,
-          });
-        }
-        continue;
-      }
-
-      if (statement.kind === "import") {
-        entries.push({
-          kind: "import",
-          mode: statement.mode,
-          filterName: statement.filterName,
-          filterNameRange: statement.filterNameRange,
-          whereExpression: statement.whereExpression,
-          whereExpressionRange: statement.whereExpressionRange,
-          clauseText: statement.clauseText,
-          ...entryRange,
-        });
-      } else {
-        entries.push({
-          kind: "export",
-          mode: statement.mode,
-          filterName: statement.filterName,
-          filterNameRange: statement.filterNameRange,
-          whereExpression: statement.whereExpression,
-          whereExpressionRange: statement.whereExpressionRange,
-          clauseText: statement.clauseText,
-          ...entryRange,
-        });
-      }
-      continue;
-    }
-
-    if (entryNode.type === "channel_limit_statement") {
-      const directionNode = entryNode.childForFieldName("direction");
-      const limitValueNode = entryNode.childForFieldName("limit_value");
-      const limitActionNode = entryNode.childForFieldName("limit_action");
-
-      const directionText = isPresentNode(directionNode)
-        ? textOf(directionNode, source).toLowerCase()
-        : "import";
-      const direction = CHANNEL_DIRECTIONS.has(directionText)
-        ? (directionText as "import" | "receive" | "export")
-        : "import";
-
-      entries.push({
-        kind: "limit",
-        direction,
-        value: isPresentNode(limitValueNode)
-          ? textOf(limitValueNode, source)
-          : "",
-        valueRange: isPresentNode(limitValueNode)
-          ? toRange(limitValueNode, source)
-          : entryRange,
-        action: isPresentNode(limitActionNode)
-          ? textOf(limitActionNode, source)
-          : undefined,
-        actionRange: isPresentNode(limitActionNode)
-          ? toRange(limitActionNode, source)
-          : undefined,
-        ...entryRange,
-      });
-      continue;
-    }
-
-    if (entryNode.type === "channel_debug_statement") {
-      const debugClauseNode = entryNode.childForFieldName("debug_clause");
-      entries.push({
-        kind: "debug",
-        clauseText: isPresentNode(debugClauseNode)
-          ? textOf(debugClauseNode, source)
-          : textOf(entryNode, source),
-        ...entryRange,
-      });
-      continue;
-    }
-
-    if (
-      entryNode.type === "identifier" &&
-      textOf(entryNode, source).toLowerCase() === "debug" &&
-      namedChildren[index + 1]
-    ) {
-      const clauseNode = namedChildren[index + 1];
-      const debugRange = mergeRanges(entryRange, toRange(clauseNode, source));
-      entries.push({
-        kind: "debug",
-        clauseText: textOf(clauseNode, source),
-        ...debugRange,
-      });
-      index += 1;
-      continue;
-    }
-
-    if (entryNode.type === "channel_keep_filtered_statement") {
-      const switchValueNode = entryNode.childForFieldName("switch_value");
-      entries.push({
-        kind: "keep-filtered",
-        value: isPresentNode(switchValueNode)
-          ? textOf(switchValueNode, source)
-          : "",
-        valueRange: isPresentNode(switchValueNode)
-          ? toRange(switchValueNode, source)
-          : entryRange,
-        ...entryRange,
-      });
-      continue;
-    }
-
-    entries.push({
-      kind: "other",
-      text: textOf(entryNode, source),
-      ...entryRange,
-    });
-  }
-
-  return entries;
-};
-
-export const parseProtocolStatements = (
-  blockNode: SyntaxNode,
-  source: string,
-  issues: ParseIssue[],
-): ProtocolStatement[] => {
-  const statements: ProtocolStatement[] = [];
-  const nodes = protocolStatementNodesOf(blockNode);
-  const childNodes = blockNode.namedChildren;
-  const fallbackChannelIndices = new Set<number>();
-
-  for (const statementNode of nodes) {
-    const statementRange = toRange(statementNode, source);
-
-    if (statementNode.type === "local_as_statement") {
-      const asnNode = statementNode.childForFieldName("asn");
-      if (!isPresentNode(asnNode)) {
-        pushMissingFieldIssue(
-          issues,
-          statementNode,
-          "Missing ASN in local as statement",
-          source,
-        );
-      }
-
-      statements.push({
-        kind: "local-as",
-        asn: isPresentNode(asnNode) ? textOf(asnNode, source) : "",
-        asnRange: isPresentNode(asnNode)
-          ? toRange(asnNode, source)
-          : statementRange,
-        ...statementRange,
-      });
-      continue;
-    }
-
-    if (statementNode.type === "neighbor_statement") {
-      const addressNode = statementNode.childForFieldName("address");
-      const asnNode = statementNode.childForFieldName("asn");
-
-      if (!isPresentNode(addressNode)) {
-        pushMissingFieldIssue(
-          issues,
-          statementNode,
-          "Missing neighbor address",
-          source,
-        );
-      }
-
-      const addressText = isPresentNode(addressNode)
-        ? textOf(addressNode, source)
-        : "";
-      const addressKind =
-        isPresentNode(addressNode) && isIpLiteralCandidate(addressText)
-          ? "ip"
-          : "other";
-
-      statements.push({
-        kind: "neighbor",
-        address: addressText,
-        addressRange: isPresentNode(addressNode)
-          ? toRange(addressNode, source)
-          : statementRange,
-        addressKind,
-        asn: isPresentNode(asnNode) ? textOf(asnNode, source) : undefined,
-        asnRange: isPresentNode(asnNode) ? toRange(asnNode, source) : undefined,
-        ...statementRange,
-      });
-      continue;
-    }
-
-    if (
-      statementNode.type === "import_statement" ||
-      statementNode.type === "export_statement"
-    ) {
-      statements.push(parseImportExportNode(statementNode, source));
-      continue;
-    }
-
-    if (statementNode.type === "channel_statement") {
-      const channelTypeNode = statementNode.childForFieldName("channel_type");
-      const channelBodyNode = statementNode.childForFieldName("body");
-      const channelTypeText = isPresentNode(channelTypeNode)
-        ? textOf(channelTypeNode, source)
-        : "";
-
-      statements.push({
-        kind: "channel",
-        channelType: normalizeChannelType(channelTypeText),
-        channelTypeRange: isPresentNode(channelTypeNode)
-          ? toRange(channelTypeNode, source)
-          : statementRange,
-        entries: isPresentNode(channelBodyNode)
-          ? parseChannelEntries(channelBodyNode, source)
-          : [],
-        ...statementRange,
-      });
-      continue;
-    }
-
-    if (statementNode.type === "expression_statement") {
-      statements.push({
-        kind: "other",
-        text: textOf(statementNode, source),
-        ...statementRange,
-      });
-      continue;
-    }
-  }
-
-  for (let index = 0; index < childNodes.length - 1; index += 1) {
-    const maybeChannelTypeNode = childNodes[index];
-    const maybeChannelBodyNode = childNodes[index + 1];
-    if (!maybeChannelTypeNode || !maybeChannelBodyNode) {
-      continue;
-    }
-
-    if (
-      maybeChannelTypeNode.type !== "identifier" ||
-      maybeChannelBodyNode.type !== "block"
-    ) {
-      continue;
-    }
-
-    const channelTypeText = textOf(maybeChannelTypeNode, source);
-    const channelType = normalizeChannelType(channelTypeText);
-    if (channelType === "unknown") {
-      continue;
-    }
-
-    const channelRange = mergeRanges(
-      toRange(maybeChannelTypeNode, source),
-      toRange(maybeChannelBodyNode, source),
-    );
-
-    statements.push({
-      kind: "channel",
-      channelType,
-      channelTypeRange: toRange(maybeChannelTypeNode, source),
-      entries: parseChannelEntries(maybeChannelBodyNode, source),
-      ...channelRange,
-    });
-
-    fallbackChannelIndices.add(index);
-    fallbackChannelIndices.add(index + 1);
-    index += 1;
-  }
-
-  for (let index = 0; index < childNodes.length; index += 1) {
-    const currentNode = childNodes[index];
-
-    if (
-      PROTOCOL_STATEMENT_TYPES.has(currentNode.type) ||
-      fallbackChannelIndices.has(index)
-    ) {
-      continue;
-    }
-
-    let endIndex = index;
-
-    while (endIndex + 1 < childNodes.length) {
-      const nextNode = childNodes[endIndex + 1];
-      if (
-        PROTOCOL_STATEMENT_TYPES.has(nextNode.type) ||
-        fallbackChannelIndices.has(endIndex + 1)
-      ) {
-        break;
-      }
-
-      endIndex += 1;
-    }
-
-    const lastNode = childNodes[endIndex];
-    const text = source.slice(currentNode.startIndex, lastNode.endIndex).trim();
-
-    if (text.length > 0) {
-      statements.push({
-        kind: "other",
-        text,
-        ...mergeRanges(toRange(currentNode, source), toRange(lastNode, source)),
-      });
-    }
-
-    index = endIndex;
-  }
-
-  return statements;
-};
-
-export const parseProtocolDeclaration = (
-  declarationNode: SyntaxNode,
-  source: string,
-  issues: ParseIssue[],
-): ProtocolDeclaration => {
-  const declarationRange = toRange(declarationNode, source);
-  const protocolTypeNode = declarationNode.childForFieldName("protocol_type");
-  const protocolVariantNode =
-    declarationNode.childForFieldName("protocol_variant");
-  const nameNode = declarationNode.childForFieldName("name");
-  const fromTemplateNode = declarationNode.childForFieldName("from_template");
-  const bodyNode = declarationNode.childForFieldName("body");
-  const hasFromKeyword = declarationNode.children.some(
-    (entry) => entry.type === "from",
-  );
-
-  if (!isPresentNode(protocolTypeNode)) {
-    pushMissingFieldIssue(
-      issues,
-      declarationNode,
-      "Missing protocol type for protocol declaration",
-      source,
-    );
-  }
-
-  if (!isPresentNode(nameNode)) {
-    pushMissingFieldIssue(
-      issues,
-      declarationNode,
-      "Missing name for protocol declaration",
-      source,
-    );
-  }
-
-  if (hasFromKeyword && !isPresentNode(fromTemplateNode)) {
-    pushMissingFieldIssue(
-      issues,
-      declarationNode,
-      "Missing template name after from clause",
-      source,
-    );
-  }
-
-  if (!isPresentNode(bodyNode)) {
-    issues.push({
-      code: "syntax/unbalanced-brace",
-      message: "Missing '{' for protocol declaration",
-      ...declarationRange,
-    });
-  }
-
-  const { protocolType, protocolTypeRange } = protocolTypeTextAndRange(
-    protocolTypeNode,
-    protocolVariantNode,
-    source,
-    declarationRange,
-  );
-
-  return {
-    kind: "protocol",
-    protocolType,
-    protocolTypeRange,
-    name: isPresentNode(nameNode) ? textOf(nameNode, source) : "",
-    nameRange: isPresentNode(nameNode)
-      ? toRange(nameNode, source)
-      : declarationRange,
-    fromTemplate: isPresentNode(fromTemplateNode)
-      ? textOf(fromTemplateNode, source)
-      : undefined,
-    fromTemplateRange: isPresentNode(fromTemplateNode)
-      ? toRange(fromTemplateNode, source)
-      : undefined,
-    statements: isPresentNode(bodyNode)
-      ? parseProtocolStatements(bodyNode, source, issues)
-      : [],
-    ...declarationRange,
-  };
-};