tree-sitter-shik 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Maksim Iakovlev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,8 @@
+# Shik treesitter grammar
+
+Install with cargo
+
+```
+cargo install tree-sitter-shik
+```
+

package/binding.gyp

@@ -0,0 +1,35 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_shik_binding",
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
+      ],
+      "include_dirs": [
+        "src",
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+      ],
+      "variables": {
+        "has_scanner": "<!(node -p \"fs.existsSync('src/scanner.c')\")"
+      },
+      "conditions": [
+        ["has_scanner=='true'", {
+          "sources+": ["src/scanner.c"],
+        }],
+        ["OS!='win'", {
+          "cflags_c": [
+            "-std=c11",
+          ],
+        }, { # OS == "win"
+          "cflags_c": [
+            "/std:c11",
+            "/utf-8",
+          ],
+        }],
+      ],
+    }
+  ]
+}

package/bindings/node/binding.cc

@@ -0,0 +1,19 @@
+#include <napi.h>
+
+typedef struct TSLanguage TSLanguage;
+
+extern "C" TSLanguage *tree_sitter_shik();
+
+// "tree-sitter", "language" hashed with BLAKE2
+const napi_type_tag LANGUAGE_TYPE_TAG = {
+    0x8AF2E5212AD58ABF, 0xD5006CAD83ABBA16
+};
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    auto language = Napi::External<TSLanguage>::New(env, tree_sitter_shik());
+    language.TypeTag(&LANGUAGE_TYPE_TAG);
+    exports["language"] = language;
+    return exports;
+}
+
+NODE_API_MODULE(tree_sitter_shik_binding, Init)

package/bindings/node/binding_test.js

@@ -0,0 +1,9 @@
+const assert = require("node:assert");
+const { test } = require("node:test");
+
+const Parser = require("tree-sitter");
+
+test("can load grammar", () => {
+  const parser = new Parser();
+  assert.doesNotThrow(() => parser.setLanguage(require(".")));
+});

package/bindings/node/index.d.ts

@@ -0,0 +1,27 @@
+type BaseNode = {
+  type: string;
+  named: boolean;
+};
+
+type ChildNode = {
+  multiple: boolean;
+  required: boolean;
+  types: BaseNode[];
+};
+
+type NodeInfo =
+  | (BaseNode & {
+      subtypes: BaseNode[];
+    })
+  | (BaseNode & {
+      fields: { [name: string]: ChildNode };
+      children: ChildNode[];
+    });
+
+type Language = {
+  language: unknown;
+  nodeTypeInfo: NodeInfo[];
+};
+
+declare const language: Language;
+export = language;

package/bindings/node/index.js

@@ -0,0 +1,11 @@
+const root = require("path").join(__dirname, "..", "..");
+
+module.exports =
+  typeof process.versions.bun === "string"
+    // Support `bun build --compile` by being statically analyzable enough to find the .node file at build-time
+    ? require(`../../prebuilds/${process.platform}-${process.arch}/tree-sitter-shik.node`)
+    : require("node-gyp-build")(root);
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

package/grammar.js

@@ -0,0 +1,213 @@
+/**
+ * @file scripting language
+ * @author pungy <max.yakovlev555@gmail.com>
+ * @license MIT
+ */
+
+
+/**
+ * TreeSitter grammar
+ */
+
+const ws = /[ \t]/;
+const wsO = /[ \t]*/;
+const wsM = /[ \t]+/;
+const newline = /\r?\n/;
+
+const PREC = {
+  PIPE: 1,
+  CHAIN: 2,
+  FLOW: 3,
+  APPLY: 4,
+
+  LITERAL: 1,
+};
+
+module.exports = grammar({
+  name: 'shik',
+
+  word: $ => $.identifier,
+
+  extras: $ => [
+    ws,
+    newline,
+    $.line_comment,
+    $.block_comment,
+  ],
+
+  rules: {
+    program: $ => repeat($.statement),
+
+    statement: $ => seq($.expression, newline),
+
+    line_comment: $ => token(seq(
+      ';',
+      /.*/
+    )),
+
+    block_comment: $ => token(seq(
+      '{*',
+      /[^*]*\*+([^}*][^*]*\*+)*/,
+      '}',
+    )),
+
+    expression: $ => choice($.flow_expression, $.chain_expression, $.pipe_expression, $.application, $.primary),
+
+    pipe_expression: $ => prec.left(PREC.PIPE, seq(
+      field('left', $.expression),
+      '$>',
+      field('right', $.expression),
+    )),
+    chain_expression: $ => prec.left(PREC.CHAIN, seq(
+      field('left', $.expression),
+      '$',
+      field('right', $.expression),
+    )),
+
+    flow_expression: $ => prec.left(PREC.FLOW, seq(
+      field('left', $.expression),
+      '#>',
+      field('right', $.expression),
+    )),
+
+    application: $ => prec.left(PREC.APPLY, seq(
+      field('fn', $.expression),
+      field('arg', $.primary),
+    )),
+
+    primary: $ => choice(
+      $.lambda,
+      $.let_expression,
+      $.match_expression,
+      $.list,
+      $.object,
+      $.literal,
+      $.identifier,
+      $.parenthesized,
+      $.block,
+      $.lazy,
+    ),
+
+    parenthesized: $ => seq('(', $.expression, ')'),
+    block: $ => seq(
+      "'(",
+      repeat(seq($.expression, optional(newline))),
+      ')'
+    ),
+    lazy: $ => seq(
+      "#(",
+      repeat(seq($.expression, optional(newline))),
+      ')'
+    ),
+
+    list: $ => seq(
+      '[',
+      repeat($.primary),
+      ']'
+    ),
+
+    object: $ => seq(
+      '{',
+      repeat($.object_items),
+      '}'
+    ),
+    object_items: $ => seq(
+      field('key', $.primary),
+      field('value', $.primary),
+    ),
+
+    match_expression: $ => seq(
+      'match',
+      field('value', $.primary),
+      '{',
+      repeat($.match_arm),
+      '}'
+    ),
+    match_arm: $ => seq(
+      field('pattern', choice(
+        $.match_pattern,
+        seq('#', field('name', $.identifier)),
+      )),
+      field('body', $.primary),
+    ),
+
+    let_expression: $ => seq(
+      'let$',
+      field('name', $.let_pattern),
+      field('value', $.expression)
+    ),
+    let_pattern: $ => choice($.identifier, $.let_list_pattern),
+    let_list_pattern: $ => seq(
+      '[',
+      repeat($.let_pattern),
+      field('rest', optional(seq('#', $.identifier))),
+      ']',
+    ),
+
+    lambda: $ => seq(
+      'fn',
+      '[',
+      field('arg', repeat($.match_pattern)),
+      field('rest', optional(seq('#', $.identifier))),
+      ']',
+      field('body', $.expression),
+    ),
+    match_pattern: $ => choice(
+      $.identifier,
+      $.literal,
+      $.match_list_pattern,
+      '_',
+    ),
+    match_list_pattern: $ => seq(
+      '[',
+      repeat($.match_pattern),
+      optional(seq('#', $.identifier)),
+      ']',
+    ),
+
+    literal: $ => choice(
+      $.string,
+      $.number
+    ),
+
+    string: $ => choice(
+      $.symbol_string,
+      $.quoted_string
+    ),
+
+    symbol_string: $ => seq(
+      ':',
+      $.symbol_string_content,
+    ),
+
+    quoted_string: $ => seq(
+      '"',
+      repeat(choice(
+        $.string_content,
+        $.escape_sequence,
+        $.interpolation
+      )),
+      '"'
+    ),
+    string_content: $ => token.immediate(prec(1, /[^"\\{]+/)),
+    symbol_string_content: $ => token.immediate(prec(1, /[^\s\t\n\(\{\[\]\}\)]+/)),
+    escape_sequence: $ => token.immediate(choice(
+      /\\x[0-9a-fA-F]{2}/,
+      /\\u\{[0-9a-fA-F]+\}/,
+      /\\./,
+    )),
+    interpolation: $ => seq(
+      '{',
+      $.expression,
+      '}'
+    ),
+
+    number: $ => prec.dynamic(1, token(seq(
+      optional('-'),
+      /\d+/,
+      optional(seq('.', /\d+/))
+    ))),
+
+    identifier: $ => /[\p{L}\p{N}!@%^&*\-_=+|?<>$.][\p{L}\p{N}!@#%^&*\-_=+'|?<>$.]*/u,
+  }
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "tree-sitter-shik",
+  "version": "1.0.0",
+  "description": "scripting language",
+  "repository": "https://github.com/PunGy/shik-treesitter",
+  "license": "MIT",
+  "author": {
+    "name": "pungy",
+    "email": "max.yakovlev555@gmail.com",
+    "url": "https://pungy.me/"
+  },
+  "main": "bindings/node",
+  "types": "bindings/node",
+  "keywords": [
+    "incremental",
+    "parsing",
+    "tree-sitter",
+    "shik"
+  ],
+  "files": [
+    "grammar.js",
+    "tree-sitter.json",
+    "binding.gyp",
+    "prebuilds/**",
+    "bindings/node/*",
+    "queries/*",
+    "src/**",
+    "*.wasm",
+    "shik.tmLanguage.json"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.5.0",
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "prebuildify": "^6.0.1",
+    "tree-sitter": "^0.22.4",
+    "tree-sitter-cli": "^0.25.10"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.22.4"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "install": "node-gyp-build || true",
+    "prestart": "tree-sitter build --wasm",
+    "start": "tree-sitter playground",
+    "test": "node --test bindings/node/*_test.js"
+  }
+}

package/queries/shik/highlights.scm

@@ -0,0 +1,119 @@
+; Comments
+(line_comment) @comment
+(block_comment) @comment
+
+
+; === Punctuation ===
+"[" @punctuation.bracket
+"]" @punctuation.bracket
+"{" @punctuation.bracket
+"}" @punctuation.bracket
+"(" @punctuation.bracket
+")" @punctuation.bracket
+"'(" @punctuation.special
+"#(" @punctuation.special
+(interpolation
+  "{" @punctuation.special
+  "}" @punctuation.special) @embedded
+
+
+; === Binary operators ===
+"$>" @keyword
+"$"  @keyword
+"#>" @keyword
+
+
+; === Literals ===
+(number) @number
+(quoted_string) @string
+(escape_sequence) @string.escape
+(symbol_string ":" @punctuation.special)
+(symbol_string_content) @string
+
+
+; === Built-in functions ===
+; Module-qualified names (string.upper, list.map, file.read, etc.)
+; These come before generic @function captures so they take priority.
+((identifier) @function.builtin
+  (#match? @function.builtin "^(string|list|object|file|shell|number|process|fn|var)\\."))
+
+; Common standalone built-ins
+((identifier) @function.builtin
+  (#any-of? @function.builtin
+    "print" "bool" "string" "at" "iterate" "or?" "invoke"))
+
+
+; === Function position highlighting ===
+(application
+  fn: (expression
+    (primary
+      (identifier) @function)))
+
+(pipe_expression
+  right: (expression
+    (primary
+      (identifier) @function)))
+
+(chain_expression
+  left: (expression
+    (primary
+      (identifier) @function)))
+
+(flow_expression
+  left: (expression
+    (primary
+      (identifier) @function))
+  right: (expression
+    (primary
+      (identifier) @function)))
+
+
+; === Object keys ===
+(object_items
+  key: (primary) @property)
+
+
+; === Lambda / let parameters ===
+(lambda
+  (match_pattern (identifier) @variable.parameter))
+(lambda
+  rest: (identifier) @variable.parameter)
+(match_pattern (match_list_pattern (match_pattern (identifier) @variable.parameter)))
+
+(let_pattern (identifier) @variable.parameter)
+(let_list_pattern
+  rest: (identifier) @variable.parameter)
+(let_pattern (let_list_pattern (let_pattern (identifier) @variable.parameter)))
+
+
+; === Keywords ===
+"fn"    @keyword
+"let$"  @keyword
+"match" @keyword
+
+((identifier) @keyword
+  (#any-of? @keyword
+    "if"
+    "let" "set" "set+" "set-"
+    "while"))
+
+; The '#' prefix in rest params and named wildcards: #rest, #name
+"#" @punctuation.special
+
+; Named wildcard in match patterns: #name
+(match_arm
+  name: (identifier) @variable.parameter)
+
+; Rest identifier in match list patterns [a b #rest]
+; (bare identifier child, pattern identifiers are wrapped in match_pattern)
+(match_list_pattern (identifier) @variable.parameter)
+
+
+; === Constants ===
+((identifier) @boolean
+  (#any-of? @boolean "true" "false"))
+
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin "null"))
+
+"_" @constant.builtin

package/queries/shik/locals.scm

@@ -0,0 +1,26 @@
+; Scopes — each lambda/block/lazy introduces a new local scope
+(lambda) @local.scope
+(block) @local.scope
+(lazy) @local.scope
+
+; Definitions — lambda parameters
+(lambda
+  (match_pattern (identifier) @local.definition))
+(lambda
+  rest: (identifier) @local.definition)
+(match_list_pattern (identifier) @local.definition)
+
+; Definitions — let bindings
+(let_expression
+  name: (let_pattern (identifier) @local.definition))
+(let_list_pattern
+  rest: (identifier) @local.definition)
+(let_pattern
+  (let_list_pattern (let_pattern (identifier) @local.definition)))
+
+; Definitions — match arm named wildcards (#name)
+(match_arm
+  name: (identifier) @local.definition)
+
+; References — all other identifier usages
+(identifier) @local.reference

package/shik.tmLanguage.json

@@ -0,0 +1,118 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "Shik",
+  "scopeName": "source.shik",
+  "fileTypes": ["shk"],
+  "patterns": [
+    { "include": "#block-comment" },
+    { "include": "#line-comment" },
+    { "include": "#quoted-string" },
+    { "include": "#symbol-string" },
+    { "include": "#number" },
+    { "include": "#keyword" },
+    { "include": "#operator" },
+    { "include": "#special-bracket" },
+    { "include": "#constant" }
+  ],
+  "repository": {
+    "block-comment": {
+      "name": "comment.block.shik",
+      "begin": "\\{\\*",
+      "end": "\\*\\}",
+      "beginCaptures": { "0": { "name": "punctuation.definition.comment.shik" } },
+      "endCaptures":   { "0": { "name": "punctuation.definition.comment.shik" } }
+    },
+    "line-comment": {
+      "name": "comment.line.shik",
+      "match": ";.*$"
+    },
+    "quoted-string": {
+      "name": "string.quoted.double.shik",
+      "begin": "\"",
+      "end": "\"",
+      "beginCaptures": { "0": { "name": "punctuation.definition.string.begin.shik" } },
+      "endCaptures":   { "0": { "name": "punctuation.definition.string.end.shik" } },
+      "patterns": [
+        { "include": "#escape-sequence" },
+        { "include": "#interpolation" }
+      ]
+    },
+    "escape-sequence": {
+      "name": "constant.character.escape.shik",
+      "match": "\\\\(?:x[0-9a-fA-F]{2}|u\\{[0-9a-fA-F]+\\}|.)"
+    },
+    "interpolation": {
+      "name": "meta.embedded.line.shik",
+      "contentName": "source.shik",
+      "begin": "\\{",
+      "end": "\\}",
+      "beginCaptures": { "0": { "name": "punctuation.section.embedded.begin.shik" } },
+      "endCaptures":   { "0": { "name": "punctuation.section.embedded.end.shik" } },
+      "patterns": [{ "include": "$self" }]
+    },
+    "symbol-string": {
+      "name": "string.unquoted.shik",
+      "match": ":[^\\s\\t\\n(){}\\[\\]]+"
+    },
+    "number": {
+      "name": "constant.numeric.shik",
+      "match": "-?\\d+(?:\\.\\d+)?"
+    },
+    "keyword": {
+      "patterns": [
+        {
+          "comment": "let$ and set+/set- before their bare counterparts",
+          "name": "keyword.other.shik",
+          "match": "(?<![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])(?:let\\$|set[+\\-])(?![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])"
+        },
+        {
+          "name": "keyword.other.function.shik",
+          "match": "(?<![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])fn(?![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])"
+        },
+        {
+          "name": "keyword.control.shik",
+          "match": "(?<![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])(?:if|while|match)(?![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])"
+        },
+        {
+          "name": "keyword.other.shik",
+          "match": "(?<![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])(?:let|set)(?![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])"
+        }
+      ]
+    },
+    "operator": {
+      "patterns": [
+        {
+          "name": "keyword.operator.shik",
+          "match": "\\$>|#>"
+        },
+        {
+          "comment": "$ as chain operator — only valid surrounded by whitespace",
+          "name": "keyword.operator.shik",
+          "match": "(?<=\\s)\\$(?=\\s|$)"
+        }
+      ]
+    },
+    "special-bracket": {
+      "patterns": [
+        { "name": "punctuation.section.block.shik", "match": "'\\(" },
+        { "name": "punctuation.section.lazy.shik",  "match": "#\\(" }
+      ]
+    },
+    "constant": {
+      "patterns": [
+        {
+          "name": "constant.language.boolean.shik",
+          "match": "(?<![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])(?:true|false)(?![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])"
+        },
+        {
+          "name": "constant.language.null.shik",
+          "match": "(?<![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])null(?![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])"
+        },
+        {
+          "name": "constant.language.wildcard.shik",
+          "match": "(?<![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])_(?![A-Za-z0-9!@%^&*\\-_=+|?<>$.#'])"
+        }
+      ]
+    }
+  }
+}