tree-sitter-swi-prolog 0.1.0 → 0.1.2

package/README.md

@@ -70,7 +70,7 @@ node scripts/check-corpus.mjs path/to/prolog/sources
 
 Releases are made from [changesets](https://github.com/changesets/changesets).
 
-1. A pull request with a user-visible change adds a changeset: run `npx changeset`, pick the bump and describe the change for users.
+1. A pull request with a user-visible change adds a changeset: run `npx changeset`, pick the bump and describe the change for users. CI fails a pull request without a changeset; for a change users don't see, add an empty one with `npx changeset --empty`.
 2. When it is merged, the **Release** workflow opens (or updates) a **Version packages** pull request that applies all pending changesets: it bumps the version in every manifest and writes their text into `CHANGELOG.md`.
 3. Merging that pull request releases the new version: the `vX.Y.Z` tag and GitHub release (with the changelog section as notes and the Wasm parser attached), npm, crates.io and PyPI.
 

package/grammar/node-types.js

@@ -0,0 +1,39 @@
+/**
+ * @file Node types of the generated SWI-Prolog parser
+ * @license MIT
+ */
+
+// Sets of node types read from src/node-types.json, which `tree-sitter
+// generate` writes from grammar.js. They are derived, never restated, so a
+// grammar change that adds or removes a node type changes them too. The
+// Kibi proofs in test/proof/ range over them.
+
+import { readFileSync } from 'node:fs';
+
+/** The node types of the generated parser, as tree-sitter describes them. */
+export const NODE_TYPES = JSON.parse(
+  readFileSync(new URL('../src/node-types.json', import.meta.url), 'utf8'),
+);
+
+/** Every named node type. */
+export const NAMED_NODE_TYPES = NODE_TYPES.filter(t => t.named).map(t => t.type);
+
+const sourceFile = NODE_TYPES.find(t => t.type === 'source_file');
+
+/**
+ * The node types a top-level term can have: the children of `source_file`,
+ * without `shebang`, which is the `#!` line before the first term rather
+ * than a term.
+ */
+export const TOP_LEVEL_TERM_TYPES = sourceFile.children.types
+  .map(t => t.type)
+  .filter(type => type !== 'shebang');
+
+/**
+ * The token types: named node types with no fields and no children, such as
+ * `atom`, `variable`, `string` and `comment`.
+ */
+export const TOKEN_TYPES = NODE_TYPES
+  .filter(t => t.named && !t.subtypes && !t.children
+    && Object.keys(t.fields ?? {}).length === 0)
+  .map(t => t.type);

package/grammar/operators.js

@@ -0,0 +1,93 @@
+/**
+ * @file Operator tables of the SWI-Prolog grammar
+ * @license MIT
+ */
+
+// Default SWI-Prolog operator table (see `current_op/3` in a fresh `swipl`).
+// Prolog priorities run the other way from tree-sitter precedences, so each
+// rule uses `1200 - priority`.
+//
+// Operators at priority 1200 only appear as the neck of a clause, in a
+// directive, or inside parentheses; see `clause`, `directive` and `_term_1200`.
+export const INFIX_HIGH = [
+  // [priority, type, operators]
+  // library(chr)
+  [1190, 'xfx', ['==>', '<=>']],
+  [1180, 'xfx', ['\\']],
+  [1150, 'xfx', ['pragma']],
+  [1105, 'xfy', ['|']],
+  [1100, 'xfy', [';']],
+  [1050, 'xfy', ['->', '*->']],
+  [1000, 'xfy', [',']],
+];
+
+export const INFIX_LOW = [
+  [990, 'xfx', [':=']],
+  // library(clpfd)
+  [760, 'yfx', ['#<==>']],
+  [750, 'xfy', ['#==>']],
+  [750, 'yfx', ['#<==']],
+  [740, 'yfx', ['#\\/']],
+  [730, 'yfx', ['#\\']],
+  [720, 'yfx', ['#/\\']],
+  [700, 'xfx', ['#>', '#<', '#>=', '#=<', '#=', '#\\=', 'in', 'ins', 'in_set']],
+  [450, 'xfx', ['..']],
+  [700, 'xfx', [
+    '=', '\\=', '==', '\\==', '@<', '@>', '@=<', '@>=', '=..', 'is', '=:=',
+    '=\\=', '<', '>', '=<', '>=', '>:<', ':<', 'as', '=@=', '\\=@=', '?=',
+  ]],
+  [600, 'xfy', [':']],
+  [500, 'yfx', ['+', '-', '/\\', '\\/', 'xor']],
+  [400, 'yfx', ['*', '/', '//', 'rem', 'mod', 'div', '<<', '>>', 'divmod', 'rdiv']],
+  [200, 'xfx', ['**']],
+  [200, 'xfy', ['^']],
+  // library(semweb/rdf_db) literals: Value^^Type, Text@Lang
+  [110, 'xfx', ['^^']],
+];
+
+export const PREFIX_HIGH = [
+  [1150, 'fx', [
+    'dynamic', 'discontiguous', 'initialization', 'meta_predicate',
+    'module_transparent', 'multifile', 'public', 'thread_local',
+    'thread_initialization', 'volatile', 'table',
+    // declarations from common libraries
+    'rdf_meta', 'persistent', 'record', 'html_meta', 'chr_constraint', 'chr_type', 'chr_option',
+  ]],
+];
+
+export const PREFIX_LOW = [
+  [900, 'fy', ['\\+']],
+  [710, 'fy', ['#\\']],
+  [500, 'fx', ['?']],
+  [200, 'fy', ['-', '+', '\\']],
+  [100, 'fx', ['@']],
+  // library(wasm)
+  [50, 'fx', ['#']],
+  [1, 'fx', ['$']],
+];
+
+export const NECKS = [':-', '-->', '=>'];
+
+// Every operator name. Each one is also a plain atom wherever an operand is
+// not expected, e.g. `foo(-, +)` or `X = (=)`.
+export const OPERATOR_NAMES = [...new Set([
+  ...NECKS, '?-',
+  ...[...INFIX_HIGH, ...INFIX_LOW, ...PREFIX_HIGH, ...PREFIX_LOW]
+    .flatMap(([, , ops]) => ops),
+])].filter(op => op !== ',' && op !== '|');
+
+
+// Operators declared with op/3 are not known to the parser. Between two
+// operands, a token of one of these kinds is read as an infix operator at
+// UNKNOWN_INFIX_PRIORITY instead: two adjacent operands are never valid
+// Prolog otherwise. Keys name the kind, values the grammar rule for it.
+export const UNKNOWN_INFIX_RULES = {
+  symbolic: '_graphic',
+  alphanumeric: '_name',
+};
+
+/** The kinds of unknown infix operator the parser reads. */
+export const UNKNOWN_INFIX_KINDS = Object.keys(UNKNOWN_INFIX_RULES);
+
+/** The priority an unknown infix operator is read at. */
+export const UNKNOWN_INFIX_PRIORITY = 700;

package/grammar.js

@@ -6,78 +6,10 @@
 /// <reference types="tree-sitter-cli/dsl" />
 // @ts-check
 
-// Default SWI-Prolog operator table (see `current_op/3` in a fresh `swipl`).
-// Prolog priorities run the other way from tree-sitter precedences, so each
-// rule uses `1200 - priority`.
-//
-// Operators at priority 1200 only appear as the neck of a clause, in a
-// directive, or inside parentheses; see `clause`, `directive` and `_term_1200`.
-const INFIX_HIGH = [
-  // [priority, type, operators]
-  // library(chr)
-  [1190, 'xfx', ['==>', '<=>']],
-  [1180, 'xfx', ['\\']],
-  [1150, 'xfx', ['pragma']],
-  [1105, 'xfy', ['|']],
-  [1100, 'xfy', [';']],
-  [1050, 'xfy', ['->', '*->']],
-  [1000, 'xfy', [',']],
-];
-
-const INFIX_LOW = [
-  [990, 'xfx', [':=']],
-  // library(clpfd)
-  [760, 'yfx', ['#<==>']],
-  [750, 'xfy', ['#==>']],
-  [750, 'yfx', ['#<==']],
-  [740, 'yfx', ['#\\/']],
-  [730, 'yfx', ['#\\']],
-  [720, 'yfx', ['#/\\']],
-  [700, 'xfx', ['#>', '#<', '#>=', '#=<', '#=', '#\\=', 'in', 'ins', 'in_set']],
-  [450, 'xfx', ['..']],
-  [700, 'xfx', [
-    '=', '\\=', '==', '\\==', '@<', '@>', '@=<', '@>=', '=..', 'is', '=:=',
-    '=\\=', '<', '>', '=<', '>=', '>:<', ':<', 'as', '=@=', '\\=@=', '?=',
-  ]],
-  [600, 'xfy', [':']],
-  [500, 'yfx', ['+', '-', '/\\', '\\/', 'xor']],
-  [400, 'yfx', ['*', '/', '//', 'rem', 'mod', 'div', '<<', '>>', 'divmod', 'rdiv']],
-  [200, 'xfx', ['**']],
-  [200, 'xfy', ['^']],
-  // library(semweb/rdf_db) literals: Value^^Type, Text@Lang
-  [110, 'xfx', ['^^']],
-];
-
-const PREFIX_HIGH = [
-  [1150, 'fx', [
-    'dynamic', 'discontiguous', 'initialization', 'meta_predicate',
-    'module_transparent', 'multifile', 'public', 'thread_local',
-    'thread_initialization', 'volatile', 'table',
-    // declarations from common libraries
-    'rdf_meta', 'persistent', 'record', 'html_meta', 'chr_constraint', 'chr_type', 'chr_option',
-  ]],
-];
-
-const PREFIX_LOW = [
-  [900, 'fy', ['\\+']],
-  [710, 'fy', ['#\\']],
-  [500, 'fx', ['?']],
-  [200, 'fy', ['-', '+', '\\']],
-  [100, 'fx', ['@']],
-  // library(wasm)
-  [50, 'fx', ['#']],
-  [1, 'fx', ['$']],
-];
-
-const NECKS = [':-', '-->', '=>'];
-
-// Every operator name. Each one is also a plain atom wherever an operand is
-// not expected, e.g. `foo(-, +)` or `X = (=)`.
-const OPERATOR_NAMES = [...new Set([
-  ...NECKS, '?-',
-  ...[...INFIX_HIGH, ...INFIX_LOW, ...PREFIX_HIGH, ...PREFIX_LOW]
-    .flatMap(([, , ops]) => ops),
-])].filter(op => op !== ',' && op !== '|');
+import {
+  INFIX_HIGH, INFIX_LOW, PREFIX_HIGH, PREFIX_LOW, NECKS, OPERATOR_NAMES,
+  UNKNOWN_INFIX_PRIORITY, UNKNOWN_INFIX_RULES,
+} from './grammar/operators.js';
 
 const precOf = priority => 1200 - priority;
 
@@ -104,7 +36,7 @@ export default grammar({
 
   extras: $ => [/\s/, $.comment],
 
-  externals: $ => [$.end, $._error_sentinel],
+  externals: $ => [$.end, $._error_sentinel, $._end_guard],
 
   word: $ => $._name,
 
@@ -160,9 +92,12 @@ export default grammar({
       // Operators declared with op/3 are not known to the parser. A symbol
       // atom or a plain name between two operands is read as an infix operator
       // at 700: two adjacent operands are never valid Prolog otherwise.
-      prec.left(precOf(700), seq(
+      prec.left(precOf(UNKNOWN_INFIX_PRIORITY), seq(
         field('left', $._arg),
-        field('operator', alias(choice($._graphic, $._name), $.operator)),
+        field('operator', alias(
+          choice(...Object.values(UNKNOWN_INFIX_RULES).map(rule => $[rule])),
+          $.operator,
+        )),
         field('right', $._arg),
       )),
     ),
@@ -190,6 +125,11 @@ export default grammar({
     ),
 
     _primary: $ => choice(
+      // Never produced. It makes the scanner run wherever an operand is
+      // expected, so a clause terminator there is lexed as `end`, a syntax
+      // error, instead of as a `.` atom that swallows the next clauses. The
+      // atom after it keeps every field that holds an operand required.
+      seq($._end_guard, $.atom),
       $.atom,
       $.variable,
       $.integer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-swi-prolog",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "SWI-Prolog grammar for tree-sitter",
   "type": "module",
   "repository": {
@@ -11,8 +11,8 @@
   "author": {
     "name": "Piotr Franczyk"
   },
-  "main": "bindings/node",
-  "types": "bindings/node",
+  "main": "bindings/node/index.js",
+  "types": "bindings/node/index.d.ts",
   "keywords": [
     "incremental",
     "parsing",
@@ -22,6 +22,7 @@
   ],
   "files": [
     "grammar.js",
+    "grammar/*.js",
     "tree-sitter.json",
     "binding.gyp",
     "prebuilds/**",
@@ -36,9 +37,11 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.1",
-    "kibi-cli": "^2.38.0",
-    "kibi-core": "^0.27.0",
-    "kibi-mcp": "^3.22.0",
+    "kibi-cli": "^2.40.0",
+    "kibi-core": "^0.29.0",
+    "kibi-lang-go": "^1.0.0",
+    "kibi-mcp": "^3.24.0",
+    "kibi-plugin-treesitter": "^3.0.0",
     "prebuildify": "^6.0.1",
     "tree-sitter": "^0.25.0",
     "tree-sitter-cli": "^0.26.7",
@@ -60,5 +63,20 @@
     "test:corpus": "node scripts/check-corpus.mjs",
     "version-packages": "node scripts/version-packages.mjs",
     "changeset": "changeset"
+  },
+  "kibi": {
+    "plugins": [
+      {
+        "package": "kibi-plugin-treesitter",
+        "capabilities": {
+          "kibi.reference-extractor.v1": {
+            "mode": "augment"
+          },
+          "kibi.symbol-extractor.v2": {
+            "mode": "augment"
+          }
+        }
+      }
+    ]
   }
 }

package/queries/tags.js

@@ -0,0 +1,19 @@
+/**
+ * @file Tag kinds of queries/tags.scm
+ * @license MIT
+ */
+
+// The kinds of tag queries/tags.scm produces (`definition.function`,
+// `reference.call`, ...), read from the query file itself so they cannot
+// drift from it. The Kibi proof in test/proof/queries.test.js ranges over
+// them.
+
+import { readFileSync } from 'node:fs';
+
+const source = readFileSync(new URL('./tags.scm', import.meta.url), 'utf8')
+  .replace(/;.*$/gm, '');
+
+/** Every `@definition.*` and `@reference.*` capture in tags.scm, once each. */
+export const TAG_KINDS = [...new Set(
+  [...source.matchAll(/@((?:definition|reference)\.[\w.]+)/g)].map(m => m[1]),
+)];

package/src/grammar.json

@@ -2240,6 +2240,19 @@
     "_primary": {
       "type": "CHOICE",
       "members": [
+        {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "_end_guard"
+            },
+            {
+              "type": "SYMBOL",
+              "name": "atom"
+            }
+          ]
+        },
         {
           "type": "SYMBOL",
           "name": "atom"
@@ -3507,6 +3520,10 @@
     {
       "type": "SYMBOL",
       "name": "_error_sentinel"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "_end_guard"
     }
   ],
   "inline": [],