semantifold 0.4.0 → 0.6.0

package/node_modules/semantifold-tree-sitter-zig-internal/node_modules/tree-sitter/vendor/tree-sitter/lib/src/wasm_store.h

@@ -0,0 +1,31 @@
+#ifndef TREE_SITTER_WASM_H_
+#define TREE_SITTER_WASM_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tree_sitter/api.h"
+#include "./parser.h"
+
+bool ts_wasm_store_start(TSWasmStore *self, TSLexer *lexer, const TSLanguage *language);
+void ts_wasm_store_reset(TSWasmStore *self);
+bool ts_wasm_store_has_error(const TSWasmStore *self);
+
+bool ts_wasm_store_call_lex_main(TSWasmStore *self, TSStateId state);
+bool ts_wasm_store_call_lex_keyword(TSWasmStore *self, TSStateId state);
+
+uint32_t ts_wasm_store_call_scanner_create(TSWasmStore *self);
+void ts_wasm_store_call_scanner_destroy(TSWasmStore *self, uint32_t scanner_address);
+bool ts_wasm_store_call_scanner_scan(TSWasmStore *self, uint32_t scanner_address, uint32_t valid_tokens_ix);
+uint32_t ts_wasm_store_call_scanner_serialize(TSWasmStore *self, uint32_t scanner_address, char *buffer);
+void ts_wasm_store_call_scanner_deserialize(TSWasmStore *self, uint32_t scanner, const char *buffer, unsigned length);
+
+void ts_wasm_language_retain(const TSLanguage *self);
+void ts_wasm_language_release(const TSLanguage *self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_WASM_H_

package/node_modules/semantifold-tree-sitter-zig-internal/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "semantifold-tree-sitter-zig-internal",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Private parser-neutral Zig snapshots using Semantifold's isolated Tree-sitter runtime",
+  "type": "module",
+  "main": "./src/zig.js",
+  "files": [
+    "src/zig.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@tree-sitter-grammars/tree-sitter-zig": "1.1.2",
+    "tree-sitter": "0.22.4"
+  }
+}

package/node_modules/semantifold-tree-sitter-zig-internal/src/zig.js

@@ -0,0 +1,134 @@
+// @ts-check
+
+import Parser from "tree-sitter"
+import ZigLanguage from "@tree-sitter-grammars/tree-sitter-zig"
+
+/** @typedef {Readonly<{row: number, column: number}>} CstPosition */
+/** @typedef {Readonly<{field: string | null, node: CstNode}>} CstChild */
+/**
+ * @typedef {Readonly<{
+ *   type: string,
+ *   named: boolean,
+ *   extra: boolean,
+ *   error: boolean,
+ *   missing: boolean,
+ *   hasError: boolean,
+ *   startIndex: number,
+ *   endIndex: number,
+ *   startPosition: CstPosition,
+ *   endPosition: CstPosition,
+ *   children: readonly CstChild[]
+ * }>} CstNode
+ */
+/** @typedef {Readonly<{schema: "semantifold.parser-cst", version: 1, language: "zig", root: CstNode}>} CstSnapshot */
+
+/**
+ * Parses the pinned Zig grammar with its isolated compatible runtime.
+ * @param {string} source - Caller-owned source text.
+ * @returns {CstSnapshot} Recursively frozen parser-neutral CST data.
+ */
+export function parseCst(source) {
+  const parser = new Parser()
+
+  // The grammar's declaration intentionally hides its native language handle as unknown.
+  parser.setLanguage(/** @type {Parser.Language} */ (/** @type {unknown} */ (ZigLanguage)))
+  const tree = parser.parse(source)
+  const convertIndex = createIndexConverter(source, tree.rootNode.endIndex)
+  const lineStarts = createLineStarts(source)
+  const root = snapshotNode(tree.rootNode, convertIndex, lineStarts)
+
+  parser.reset()
+  return Object.freeze({language: "zig", root, schema: "semantifold.parser-cst", version: 1})
+}
+
+/**
+ * @param {import("tree-sitter").SyntaxNode} node
+ * @param {(index: number) => number} convertIndex
+ * @param {readonly number[]} lineStarts
+ * @returns {CstNode}
+ */
+function snapshotNode(node, convertIndex, lineStarts) {
+  /** @type {CstChild[]} */
+  const children = []
+
+  for (let index = 0; index < node.childCount; index += 1) {
+    const child = node.child(index)
+
+    if (!child) throw new Error(`Zig Tree-sitter returned no child at index ${index}`)
+    children.push(Object.freeze({
+      field: node.fieldNameForChild(index) ?? null,
+      node: snapshotNode(child, convertIndex, lineStarts)
+    }))
+  }
+  const startIndex = convertIndex(node.startIndex)
+  const endIndex = convertIndex(node.endIndex)
+
+  return Object.freeze({
+    children: Object.freeze(children),
+    endIndex,
+    endPosition: positionForIndex(endIndex, lineStarts),
+    error: node.isError,
+    extra: node.isExtra,
+    hasError: node.hasError,
+    missing: node.isMissing,
+    named: node.isNamed,
+    startIndex,
+    startPosition: positionForIndex(startIndex, lineStarts),
+    type: node.type
+  })
+}
+
+/**
+ * Normalizes either UTF-8 byte offsets or UTF-16 offsets to UTF-16.
+ * @param {string} source
+ * @param {number} rootEndIndex
+ * @returns {(index: number) => number}
+ */
+function createIndexConverter(source, rootEndIndex) {
+  if (rootEndIndex == source.length) return (index) => index
+  const utf8Length = Buffer.byteLength(source, "utf8")
+
+  if (rootEndIndex != utf8Length) throw new Error(`Unsupported Zig Tree-sitter index extent ${rootEndIndex} for source length ${source.length}`)
+  /** @type {Map<number, number>} */
+  const byteToUtf16 = new Map([[0, 0]])
+  let byteIndex = 0
+
+  for (let utf16Index = 0; utf16Index < source.length;) {
+    const codePoint = source.codePointAt(utf16Index)
+
+    if (codePoint == null) throw new Error(`Cannot read source code point at index ${utf16Index}`)
+    const character = String.fromCodePoint(codePoint)
+
+    byteIndex += Buffer.byteLength(character, "utf8")
+    utf16Index += character.length
+    byteToUtf16.set(byteIndex, utf16Index)
+  }
+  return (index) => {
+    const converted = byteToUtf16.get(index)
+
+    if (converted == null) throw new Error(`Zig Tree-sitter returned a non-boundary byte index ${index}`)
+    return converted
+  }
+}
+
+/** @param {string} source @returns {readonly number[]} */
+function createLineStarts(source) {
+  const starts = [0]
+
+  for (let index = 0; index < source.length; index += 1) if (source[index] == "\n") starts.push(index + 1)
+  return starts
+}
+
+/** @param {number} index @param {readonly number[]} lineStarts @returns {CstPosition} */
+function positionForIndex(index, lineStarts) {
+  let low = 0
+  let high = lineStarts.length
+
+  while (low + 1 < high) {
+    const middle = Math.floor((low + high) / 2)
+
+    if (/** @type {number} */ (lineStarts[middle]) <= index) low = middle
+    else high = middle
+  }
+  return Object.freeze({column: index - /** @type {number} */ (lineStarts[low]), row: low})
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantifold",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Language-neutral semantic code analysis, transformation, generation, and execution toolkit",
   "type": "module",
   "main": "build/index.js",
@@ -21,17 +21,18 @@
     "tsconfig.json"
   ],
   "workspaces": [
-    "packages/tree-sitter-legacy"
+    "packages/tree-sitter-legacy",
+    "packages/tree-sitter-zig"
   ],
   "scripts": {
     "all-checks": "npm run lint && npm test",
-    "build": "node scripts/clean-build.js && tsc && npm run build --workspace=semantifold-tree-sitter-legacy-workspace",
+    "build": "node scripts/clean-build.js && tsc && npm run build --workspace=semantifold-tree-sitter-legacy-workspace && npm run build --workspace=semantifold-tree-sitter-zig-workspace",
     "eslint": "eslint --max-warnings 0 .",
     "lint": "npm run verify:legacy-runtime && npm run eslint && npm run typecheck",
     "prepack": "npm run verify:legacy-runtime && npm run build",
-    "pretest": "npm run verify:legacy-runtime && npm run build --workspace=semantifold-tree-sitter-legacy-workspace",
+    "pretest": "npm run verify:legacy-runtime && npm run build --workspace=semantifold-tree-sitter-legacy-workspace && npm run build --workspace=semantifold-tree-sitter-zig-workspace",
     "test": "velocious-test spec",
-    "typecheck": "tsc --noEmit && npm run typecheck --workspace=semantifold-tree-sitter-legacy-workspace",
+    "typecheck": "tsc --noEmit && npm run typecheck --workspace=semantifold-tree-sitter-legacy-workspace && npm run typecheck --workspace=semantifold-tree-sitter-zig-workspace",
     "verify:legacy-runtime": "node scripts/verify-legacy-runtime.js"
   },
   "engines": {
@@ -58,6 +59,7 @@
     "comment-parser": "^1.4.1",
     "php-parser": "^3.7.0",
     "semantifold-tree-sitter-legacy-internal": "file:packages/tree-sitter-legacy/runtime",
+    "semantifold-tree-sitter-zig-internal": "file:packages/tree-sitter-zig/runtime",
     "tree-sitter": "0.25.1",
     "tree-sitter-c-sharp": "0.23.5",
     "tree-sitter-dart-orchard": "0.7.0",
@@ -68,10 +70,12 @@
   },
   "bundleDependencies": [
     "semantifold-tree-sitter-legacy-internal",
+    "semantifold-tree-sitter-zig-internal",
     "tree-sitter"
   ],
   "acceptDependencies": {
-    "semantifold-tree-sitter-legacy-internal": "0.1.0"
+    "semantifold-tree-sitter-legacy-internal": "0.1.0",
+    "semantifold-tree-sitter-zig-internal": "0.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
@@ -84,6 +88,7 @@
     "eslint-plugin-jsdoc-tag-lines": "^1.0.1",
     "globals": "^17.0.0",
     "semantifold-tree-sitter-legacy-workspace": "0.1.0",
+    "semantifold-tree-sitter-zig-workspace": "0.1.0",
     "typescript": "^7.0.0",
     "yaml": "^2.9.0"
   }