tree-sitter-bsl 0.1.6 → 0.1.7

package/README.md

@@ -2,17 +2,202 @@
 
 [![CI][ci]](https://github.com/alkoleft/tree-sitter-bsl/actions/workflows/ci.yml)
 [![npm][npm]](https://www.npmjs.com/package/tree-sitter-bsl)
+[![crates.io][crates]](https://crates.io/crates/tree-sitter-bsl)
+[![PyPI][pypi]](https://pypi.org/project/tree-sitter-bsl/)
 
-Грамматика 1C (BSL) Language в формате [tree-sitter](https://github.com/tree-sitter/tree-sitter).
+Грамматика 1C BSL в формате [tree-sitter](https://github.com/tree-sitter/tree-sitter).
+Пакет также содержит отдельную грамматику `sdbl` для языка запросов 1C.
 
 [Попробовать](https://alkoleft.github.io/tree-sitter-bsl/)
 
 ![playground](playground.png)
 
-#### References
+## Что входит
+
+- `bsl`: грамматика исходных файлов BSL (`.bsl`, `.osl`).
+- `sdbl`: грамматика самостоятельных текстов запросов 1C (`.sdbl`).
+- Query-файлы tree-sitter для подсветки BSL/SDBL и внедрения статических
+  строковых литералов BSL, начинающихся с `ВЫБРАТЬ`, `SELECT`, `УНИЧТОЖИТЬ`
+  или `DROP`, как `sdbl`.
+- Локальное dev-расширение Zed в [`editors/zed-bsl`](editors/zed-bsl) для
+  проверки подсветки BSL, самостоятельного SDBL и внедренного SDBL.
+
+BSL и SDBL остаются разными контрактами парсера. Грамматика BSL не встраивает
+SDBL в AST строковых литералов; разбор встроенных запросов выполняется через
+tree-sitter injections и композицию на стороне редактора.
+
+## Локальная разработка
+
+Локальный tree-sitter playground запускается отдельно для каждой грамматики:
+
+```sh
+npm start
+npm run start:bsl
+npm run start:sdbl
+```
+
+`npm start` является псевдонимом для BSL playground. `npm run start:sdbl`
+запускает playground самостоятельной грамматики SDBL. При необходимости можно
+собрать оба WASM-парсера:
+
+```sh
+npm run build:wasm
+```
+
+Быстрая проверка дерева разбора:
+
+```sh
+npm run parse:bsl -- examples/playground/basic.bsl
+npm run parse:sdbl -- examples/playground/select.sdbl
+```
+
+Небольшие примеры для playground лежат в
+[`examples/playground`](examples/playground):
+
+- [`basic.bsl`](examples/playground/basic.bsl) для синтаксиса исходных файлов
+  BSL;
+- [`select.sdbl`](examples/playground/select.sdbl) и
+  [`query-package.sdbl`](examples/playground/query-package.sdbl) для синтаксиса
+  самостоятельных SDBL-запросов.
+
+SDBL-примеры разбираются самостоятельной грамматикой SDBL. BSL-строки с
+текстом запроса остаются узлами строк BSL; разбор встроенного запроса относится
+к отдельному контракту injection/composition.
+
+Основные команды проверки:
+
+```sh
+npm run test:corpus
+npm test
+npm run test:all
+```
+
+`npm run test:corpus` использует локальный для пакета `tree-sitter-cli` и
+проверяет оба набора corpus-тестов. Для системного `tree-sitter` CLI, который
+поддерживает `-p`, эквивалентные команды:
+
+```sh
+tree-sitter test -p grammars/bsl
+tree-sitter test -p grammars/sdbl
+```
+
+## Использование
+
+### Rust
+
+Добавьте зависимость в [`Cargo.toml`](Cargo.toml):
+
+```toml
+[dependencies]
+tree-sitter = "0.25"
+tree-sitter-bsl = "0.1"
+```
+
+```rust
+use tree_sitter::Parser;
+
+fn main() {
+    let mut parser = Parser::new();
+    parser
+        .set_language(&tree_sitter_bsl::LANGUAGE.into())
+        .expect("Error loading BSL grammar");
+
+    let source = r#"
+        Процедура Привет()
+            Сообщить("Привет, мир!");
+        КонецПроцедуры
+    "#;
+
+    let tree = parser.parse(source, None).unwrap();
+    println!("{}", tree.root_node().to_sexp());
+}
+```
+
+### Node.js
+
+Установите пакет:
+
+```sh
+npm install tree-sitter-bsl tree-sitter
+```
+
+```js
+const Parser = require("tree-sitter");
+const BSL = require("tree-sitter-bsl");
+
+const parser = new Parser();
+parser.setLanguage(BSL);
+
+const sourceCode = `
+Процедура Привет()
+    Сообщить("Привет, мир!");
+КонецПроцедуры
+`;
+
+const tree = parser.parse(sourceCode);
+console.log(tree.rootNode.toString());
+```
+
+### Python
+
+Установите пакет:
+
+```sh
+pip install tree-sitter-bsl tree-sitter
+```
+
+```python
+import tree_sitter_bsl as tsbsl
+from tree_sitter import Language, Parser
+
+BSL_LANGUAGE = Language(tsbsl.language())
+parser = Parser(BSL_LANGUAGE)
+
+source = """
+Процедура Привет()
+    Сообщить("Привет, мир!");
+КонецПроцедуры
+""".encode()
+
+tree = parser.parse(source)
+print(tree.root_node.sexp())
+```
+
+### Грамматика запросов SDBL
+
+Пакет также экспортирует самостоятельную грамматику языка запросов SDBL:
+
+- Node.js: `require("tree-sitter-bsl").sdbl`;
+- Rust: `tree_sitter_bsl::SDBL_LANGUAGE`;
+- Python: `tree_sitter_bsl.SDBLLanguage()` или низкоуровневая капсула
+  `tree_sitter_bsl.sdbl_language()`;
+- Go: `tree_sitter_bsl.SDBLLanguage()`;
+- C: `tree_sitter_sdbl()` из `tree-sitter-bsl.h` и той же библиотеки.
+
+Существующие точки входа BSL остаются языком пакета по умолчанию.
+
+Пакет включает query-файлы tree-sitter для интеграций с редакторами:
+
+- `grammars/bsl/queries/highlights.scm` для подсветки BSL;
+- `grammars/bsl/queries/injections.scm` для внедрения статических строковых
+  литералов BSL, начинающихся с ключевых слов SDBL-выражений, как `sdbl`;
+- `grammars/sdbl/queries/highlights.scm` для подсветки самостоятельного SDBL и
+  текста запросов, внедренного из BSL.
+
+Для Zed используется локальное dev extension:
+[`editors/zed-bsl`](editors/zed-bsl). Оно регистрирует BSL, SDBL и
+специальную для Zed грамматику-носитель `sdbl_embedded`, чтобы исходный текст
+внедренной BSL-строки подсвечивался без изменения контракта самостоятельной
+грамматики `.sdbl`.
+
+## Ссылки
 
 - Грамматика основана на правилах [BSL Parser](https://github.com/1c-syntax/bsl-parser)
+- Архитектурные решения: [`docs/decisions`](docs/decisions)
+- Активный список parser-задач: [`spec/IMPLEMENTATION_TODO.md`](spec/IMPLEMENTATION_TODO.md)
+- Контракт грамматики SDBL: [`spec/sdbl-query-language.md`](spec/sdbl-query-language.md)
 
 [ci]: https://img.shields.io/github/actions/workflow/status/alkoleft/tree-sitter-bsl/ci.yml?logo=github&label=CI
 [npm]: https://img.shields.io/npm/v/tree-sitter-bsl?logo=npm
-[telegram]: https://img.shields.io/badge/Telegram-2CA5E0?style=Flat-square&logo=telegram&logoColor=white
+[crates]: https://img.shields.io/crates/v/tree-sitter-bsl?logo=rust
+[pypi]: https://img.shields.io/pypi/v/tree-sitter-bsl?logo=python

package/binding.gyp

@@ -6,18 +6,20 @@
         "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except",
       ],
       "include_dirs": [
-        "src",
+        "grammars/bsl/src",
+        "grammars/sdbl/src",
       ],
       "sources": [
         "bindings/node/binding.cc",
-        "src/parser.c",
+        "grammars/bsl/src/parser.c",
+        "grammars/sdbl/src/parser.c",
       ],
       "variables": {
-        "has_scanner": "<!(node -p \"fs.existsSync('src/scanner.c')\")"
+        "has_scanner": "<!(node -p \"fs.existsSync('grammars/bsl/src/scanner.c')\")"
       },
       "conditions": [
         ["has_scanner=='true'", {
-          "sources+": ["src/scanner.c"],
+          "sources+": ["grammars/bsl/src/scanner.c"],
         }],
         ["OS!='win'", {
           "cflags_c": [

package/bindings/node/binding.cc

@@ -3,16 +3,30 @@
 typedef struct TSLanguage TSLanguage;
 
 extern "C" TSLanguage *tree_sitter_bsl();
+extern "C" TSLanguage *tree_sitter_sdbl();
 
 // "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_bsl());
+Napi::External<TSLanguage> CreateLanguage(Napi::Env env, TSLanguage *language_fn()) {
+    auto language = Napi::External<TSLanguage>::New(env, language_fn());
     language.TypeTag(&LANGUAGE_TYPE_TAG);
+    return language;
+}
+
+Napi::Object CreateLanguageObject(Napi::Env env, TSLanguage *language_fn()) {
+    auto language = CreateLanguage(env, language_fn);
+    auto object = Napi::Object::New(env);
+    object["language"] = language;
+    return object;
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    auto language = CreateLanguage(env, tree_sitter_bsl);
     exports["language"] = language;
+    exports["sdbl"] = CreateLanguageObject(env, tree_sitter_sdbl);
     return exports;
 }
 

package/bindings/node/binding_test.js

@@ -3,7 +3,21 @@ const { test } = require("node:test");
 
 const Parser = require("tree-sitter");
 
-test("can load grammar", () => {
+test("can load BSL grammar", () => {
   const parser = new Parser();
-  assert.doesNotThrow(() => parser.setLanguage(require(".")));
+  const BSL = require(".");
+  assert.doesNotThrow(() => parser.setLanguage(BSL));
+
+  const tree = parser.parse("Процедура Проверка()\nКонецПроцедуры");
+  assert.equal(tree.rootNode.hasError, false);
+});
+
+test("can load SDBL grammar", () => {
+  const parser = new Parser();
+  const { sdbl } = require(".");
+  assert.ok(sdbl);
+  assert.doesNotThrow(() => parser.setLanguage(sdbl));
+
+  const tree = parser.parse("ВЫБРАТЬ\n    *");
+  assert.equal(tree.rootNode.hasError, false);
 });

package/bindings/node/index.d.ts

@@ -21,6 +21,7 @@ type NodeInfo =
 type Language = {
   language: unknown;
   nodeTypeInfo: NodeInfo[];
+  sdbl?: Language;
 };
 
 declare const language: Language;

package/bindings/node/index.js

@@ -7,5 +7,6 @@ module.exports =
     : require("node-gyp-build")(root);
 
 try {
-  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+  module.exports.nodeTypeInfo = require("../../grammars/bsl/src/node-types.json");
+  module.exports.sdbl.nodeTypeInfo = require("../../grammars/sdbl/src/node-types.json");
 } catch (_) {}

package/{grammar.js → grammars/bsl/grammar.js}

@@ -110,19 +110,43 @@ function reservedKeywords($) {
   return Object.keys(buildKeywords()).map((k) => $[k]);
 }
 
+/**
+ * Формирует список ключевых слов, допустимых как имена членов после доступа
+ *
+ * @param {*} $ grammar object
+ */
+function memberNameKeywords($) {
+  return [
+    ...CORE_KEYWORDS.map(([, eng]) => $[`${eng.toUpperCase()}_KEYWORD`]),
+    $.NULL_KEYWORD,
+  ];
+}
+
 const Preprocessor = {
   preprocessor: ($) => {
-    const region = [
-      seq($.PREPROC_REGION_KEYWORD, $.identifier),
+    const region = seq(
+      $.PREPROC_REGION_KEYWORD,
+      field('name', $.identifier),
+      repeat($._definition),
       $.PREPROC_ENDREGION_KEYWORD,
-    ];
+    );
 
-    const preproc_if = [
-      seq($.PREPROC_IF_KEYWORD, $.expression, $.THEN_KEYWORD),
-      seq($.PREPROC_ELSIF_KEYWORD, $.expression, $.THEN_KEYWORD),
-      $.PREPROC_ELSE_KEYWORD,
+    const preproc_if = seq(
+      $.PREPROC_IF_KEYWORD,
+      $.expression,
+      $.THEN_KEYWORD,
+      repeat($._definition),
+      repeat(
+        seq(
+          $.PREPROC_ELSIF_KEYWORD,
+          $.expression,
+          $.THEN_KEYWORD,
+          repeat($._definition),
+        ),
+      ),
+      optional(seq($.PREPROC_ELSE_KEYWORD, repeat($._definition))),
       $.PREPROC_ENDIF_KEYWORD,
-    ];
+    );
 
     const preproc_change = [
       'Вставка',
@@ -169,8 +193,8 @@ const Preprocessor = {
       alias(token(caseInsensitive('&' + annotation)), $.annotation),
     );
     return choice(
-      ...region,
-      ...preproc_if,
+      region,
+      preproc_if,
       ...preproc_change,
       ...annotations,
       ...compilation_directives,
@@ -187,7 +211,9 @@ module.exports = grammar({
 
   inline: ($) => [],
 
-  conflicts: ($) => [],
+  conflicts: ($) => [
+    [$._plain_variable_spec, $._exported_variable_spec],
+  ],
 
   word: ($) => $.identifier,
 
@@ -228,15 +254,41 @@ module.exports = grammar({
       ),
 
     var_definition: ($) =>
-      prec(
+      prec.right(
         1,
         seq(
           $.VAR_KEYWORD,
-          sepBy1(',', field('var_name', $.identifier)),
+          $._var_definition_variables,
           optional(field('export', $.EXPORT_KEYWORD)),
           optional(';'),
         ),
       ),
+    _var_definition_variables: ($) =>
+      seq(
+        repeat(
+          choice(
+            seq(
+              field('variable', alias($._exported_variable_spec, $.variable_spec)),
+              ',',
+            ),
+            seq(
+              field('variable', alias($._plain_variable_spec, $.variable_spec)),
+              ',',
+            ),
+          ),
+        ),
+        field('variable', alias($._plain_variable_spec, $.variable_spec)),
+      ),
+    _plain_variable_spec: ($) =>
+      prec(2, seq(field('name', $.identifier))),
+    _exported_variable_spec: ($) =>
+      prec(
+        2,
+        seq(
+          field('name', $.identifier),
+          field('export', $.EXPORT_KEYWORD),
+        ),
+      ),
     parameters: ($) => seq('(', commaSep(field('parameter', $.parameter)), ')'),
 
     parameter: ($) =>
@@ -249,6 +301,7 @@ module.exports = grammar({
     // Statements
     _statement: ($) =>
       choice(
+        $._empty_statement,
         $.execute_statement,
         $.call_statement,
         $.assignment_statement,
@@ -270,42 +323,52 @@ module.exports = grammar({
         $.await_statement,
       ),
 
+    _empty_statement: ($) => prec(-1, ';'),
+
     call_statement: ($) =>
-      seq(choice($.method_call, $.call_expression), optional(';')),
+      prec.right(seq(choice($.method_call, $.call_expression), optional(';'))),
 
     assignment_statement: ($) =>
-      seq(
+      prec.right(seq(
         field('left', $._assignment_member),
         '=',
         field('right', $.expression),
         optional(';'),
-      ),
+      )),
 
     return_statement: ($) =>
       prec.right(seq($.RETURN_KEYWORD, field('result', optional($.expression)), optional(';'))),
 
     try_statement: ($) =>
-      seq(
+      prec.right(seq(
         $.TRY_KEYWORD,
         repeat($._statement),
         $.EXCEPT_KEYWORD,
-        repeat($._statement),
+        repeat($._exception_statement),
         $.ENDTRY_KEYWORD,
         optional(';'),
+      )),
+
+    _exception_statement: ($) =>
+      choice(
+        alias($._rise_error_rethrow_statement, $.rise_error_statement),
+        $._statement,
       ),
 
+    _rise_error_rethrow_statement: ($) => seq($.RAISE_KEYWORD, ';'),
+
     rise_error_statement: ($) =>
-      seq($.RAISE_KEYWORD, choice($.arguments, $.expression), optional(';')),
+      prec.right(seq($.RAISE_KEYWORD, choice(prec(1, $.arguments), $.expression), optional(';'))),
 
     var_statement: ($) =>
-      seq(
+      prec.right(seq(
         $.VAR_KEYWORD,
         sepBy1(',', field('var_name', $.identifier)),
         optional(';'),
-      ),
+      )),
 
     if_statement: ($) =>
-      seq(
+      prec.right(seq(
         $.IF_KEYWORD,
         $.expression,
         $.THEN_KEYWORD,
@@ -314,7 +377,7 @@ module.exports = grammar({
         optional($.else_clause),
         $.ENDIF_KEYWORD,
         optional(';'),
-      ),
+      )),
 
     elseif_clause: ($) =>
       seq($.ELSIF_KEYWORD, $.expression, $.THEN_KEYWORD, repeat($._statement)),
@@ -331,7 +394,7 @@ module.exports = grammar({
       ),
 
     for_statement: ($) =>
-      seq(
+      prec.right(seq(
         $.FOR_KEYWORD,
         $.identifier,
         '=',
@@ -342,10 +405,10 @@ module.exports = grammar({
         repeat($._statement),
         $.ENDDO_KEYWORD,
         optional(';'),
-      ),
+      )),
 
     for_each_statement: ($) =>
-      seq(
+      prec.right(seq(
         $.FOR_KEYWORD,
         $.EACH_KEYWORD,
         $.identifier,
@@ -355,40 +418,41 @@ module.exports = grammar({
         repeat($._statement),
         $.ENDDO_KEYWORD,
         optional(';'),
-      ),
+      )),
 
-    continue_statement: ($) => seq($.CONTINUE_KEYWORD, optional(';')),
+    continue_statement: ($) => prec.right(seq($.CONTINUE_KEYWORD, optional(';'))),
 
-    break_statement: ($) => seq($.BREAK_KEYWORD, optional(';')),
+    break_statement: ($) => prec.right(seq($.BREAK_KEYWORD, optional(';'))),
 
     execute_statement: ($) => choice(
-      seq(keyword('выполнить', 'execute'), $.expression, optional(';')),
-      seq(keyword('выполнить', 'execute'), '(', $.expression, ')', optional(';')),
+      prec.right(seq(keyword('выполнить', 'execute'), $.expression, optional(';'))),
+      prec.right(1, seq(keyword('выполнить', 'execute'), '(', $.expression, ')', optional(';'))),
     ),
 
     goto_statement: ($) =>
-      seq($.GOTO_KEYWORD, '~', $.identifier, optional(';')),
+      prec.right(seq($.GOTO_KEYWORD, '~', $.identifier, optional(';'))),
 
-    label_statement: ($) => seq('~', $.identifier, ':', optional(';')),
+    label_statement: ($) => prec.right(seq('~', $.identifier, ':', optional(';'))),
 
     add_handler_statement: ($) =>
-      seq($.ADDHANDLER_KEYWORD, $.expression, ',', $.expression, optional(';')),
+      prec.right(seq($.ADDHANDLER_KEYWORD, $.expression, ',', $.expression, optional(';'))),
 
     remove_handler_statement: ($) =>
-      seq(
+      prec.right(seq(
         $.REMOVEHANDLER_KEYWORD,
         $.expression,
         ',',
         $.expression,
         optional(';'),
-      ),
-    await_statement: ($) => seq($.await_expression, optional(';')),
+      )),
+    await_statement: ($) => prec.right(seq($.await_expression, optional(';'))),
 
     // Expressions
     expression: ($) =>
       choice(
         alias($._const_value, $.const_expression),
         $.identifier,
+        $.parenthesized_expression,
         $.unary_expression,
         $.binary_expression,
         $.ternary_expression,
@@ -409,6 +473,8 @@ module.exports = grammar({
         ),
       ),
 
+    parenthesized_expression: ($) => seq('(', $.expression, ')'),
+
     binary_expression: ($) => {
       const operations = [
         [PREC.LOGICAL_AND, $.AND_KEYWORD],
@@ -456,7 +522,12 @@ module.exports = grammar({
     new_expression_method: ($) =>
       prec.right(
         PREC.NEW,
-        seq($.NEW_KEYWORD, '(', field('type', $.expression), optional(seq(',', field('arguments', $.expression), ')')))),
+        seq(
+          $.NEW_KEYWORD,
+          '(',
+          field('type', $.expression),
+          choice(seq(',', field('arguments', $.expression), ')'), ')'),
+        )),
 
     call_expression: ($) => prec(PREC.CALL - 1, $._access_call),
 
@@ -479,10 +550,20 @@ module.exports = grammar({
           $.method_call,
         ),
       ),
-    _access_call: ($) => seq($.access, '.', $.method_call),
+    _access_call: ($) => choice(
+      seq($.access, '.', alias($._access_method_call, $.method_call)),
+      seq(choice($._access_index, $._access_call), $.arguments),
+    ),
     _access_index: ($) => seq($.access, '[', alias($.expression, $.index), ']'),
     _access_property: ($) =>
-      seq($.access, '.', alias($.identifier, $.property)),
+      seq(
+        $.access,
+        '.',
+        choice(
+          alias($.identifier, $.property),
+          alias($._member_keyword, $.property),
+        ),
+      ),
 
     method_call: ($) =>
       prec(
@@ -490,7 +571,36 @@ module.exports = grammar({
         seq(field('name', $.identifier), field('arguments', $.arguments)),
       ),
 
-    arguments: ($) => seq('(', sepBy(',', optional($.expression)), ')'),
+    _access_method_call: ($) =>
+      prec(
+        PREC.CALL,
+        seq(
+          field('name', choice($.identifier, alias($._member_keyword, $.identifier))),
+          field('arguments', $.arguments),
+        ),
+      ),
+
+    _member_keyword: ($) => choice(...memberNameKeywords($)),
+
+    arguments: ($) =>
+      prec(
+        1,
+        seq(
+          '(',
+          optional($._argument_list),
+          ')',
+        ),
+      ),
+    _argument_list: ($) =>
+      prec.right(
+        1,
+        choice(
+          $.expression,
+          seq($.expression, ',', $._argument_list),
+          seq($.expression, alias(',', $.omitted_argument)),
+          seq(alias(',', $.omitted_argument), optional($._argument_list)),
+        ),
+      ),
 
     // Primitive
     ...buildKeywords(),
@@ -511,7 +621,8 @@ module.exports = grammar({
     null: ($) => $.NULL_KEYWORD,
 
     number: ($) => /\d+(\.\d+)?/,
-    date: ($) => /'\d{8,14}'/,
+    date: ($) =>
+      /'\d{4}[^0-9'\r\n]*\d{2}[^0-9'\r\n]*\d{2}([^0-9'\r\n]*\d{2}[^0-9'\r\n]*\d{2}([^0-9'\r\n]*\d{2})?)?'/,
     string: ($) =>
       seq(
         '"',
@@ -536,7 +647,6 @@ module.exports = grammar({
   },
 });
 
-
 /**
  * Creates a rule to optionally match one or more of the rules separated by a comma
  *