@willbooster/tree-sitter-c-sharp 14.1.1 → 14.1.3

package/grammar.js

@@ -11,7 +11,7 @@
 const { alias, choice, field, grammar, optional, prec, repeat, repeat1, seq, sym, token } =
   /** @type {typeof globalThis & import('@willbooster/web-tree-sitter/dsl').DSL} */ (globalThis);
 
-/** @typedef {'_preproc_expression' | '_top_level_item_no_statement' | '_namespace_body_item' | '_base_list_mixed_type' | '_base_list_mixed_suffix' | '_base_list_trivia' | '_base_list' | '_base_list_type' | '_base_list_suffix' | '_base_list_prefix' | '_base_list_separator' | '_base_list_separator_path' | '_enum_base_clause' | '_enum_base_type' | 'attribute_list' | 'declaration' | 'enum_member_declaration' | 'expression' | 'method_signature' | 'statement'} PreprocContentRule */
+/** @typedef {'_preproc_expression' | '_top_level_item_no_statement' | '_namespace_body_item' | '_base_list_mixed_type' | '_base_list_mixed_suffix' | '_base_list_trivia' | '_base_list' | '_base_list_type' | '_base_list_suffix' | '_base_list_prefix' | '_base_list_separator' | '_base_list_separator_path' | '_enum_base_clause' | '_enum_base_type' | '_dangling_else_if_statement' | '_object_initializer_element' | '_modified_argument' | '_spread_collection_element' | '_object_member_initializers' | 'argument' | 'attribute_list' | 'collection_element' | 'declaration' | 'enum_member_declaration' | 'expression' | 'if_statement' | 'method_signature' | 'statement' | 'switch_expression_arm'} PreprocContentRule */
 
 const PREC = {
   GENERIC: 19,
@@ -143,6 +143,16 @@ module.exports = grammar({
     [$._simple_name, $._definite_cast_name],
     [$._name, $._definite_cast_name],
     [$._object_initializer_expression, $.initializer_expression],
+    [$._object_initializer_element, $.initializer_expression],
+    [$._object_initializer_element, sym('preproc_elif_in_initializer')],
+    [sym('preproc_elif_in_initializer'), sym('preproc_elif_in_object_initializer')],
+    [$._object_initializer_element, sym('preproc_else_in_initializer')],
+    [$._object_initializer_element, sym('preproc_if_in_initializer')],
+    [sym('preproc_else_in_initializer'), sym('preproc_else_in_object_initializer')],
+    [sym('preproc_if_in_initializer'), sym('preproc_if_in_object_initializer')],
+    [sym('preproc_elif_in_top_level'), sym('preproc_elif_in_initializer')],
+    [sym('preproc_else_in_top_level'), sym('preproc_else_in_initializer')],
+    [sym('preproc_if_in_top_level'), sym('preproc_if_in_initializer')],
     [
       $._pattern_primary_expression,
       $._primary_no_conditional_access_expression,
@@ -348,6 +358,7 @@ module.exports = grammar({
     sym('_pragma_text'),
     sym('_expression_generic_end'),
     sym('_definite_expression_generic_end'),
+    sym('_if_alternative_directive'),
   ],
 
   extras: ($) => [
@@ -978,16 +989,20 @@ module.exports = grammar({
 
     constructor_initializer: ($) => seq(':', choice('base', 'this'), $.argument_list),
 
-    argument_list: ($) => seq('(', commaSep($.argument), ')'),
+    argument_list: ($) => seq('(', conditionalList($.argument, 'preproc_if_in_argument_list', false), ')'),
 
     tuple_pattern: ($) => seq('(', commaSep1(choice(field('name', $.identifier), $.discard, $.tuple_pattern)), ')'),
 
-    argument: ($) =>
+    argument: ($) => prec(1, seq(optional(seq(field('name', $.identifier), ':')), argumentValue($))),
+
+    // An argument that a directive branch cannot hold as a bare expression.
+    _modified_argument: ($) =>
       prec(
         1,
-        seq(
-          optional(seq(field('name', $.identifier), ':')),
-          choice(seq(optional(choice('ref', 'out', 'in')), $.expression), seq('out', $.declaration_expression))
+        choice(
+          seq(field('name', $.identifier), ':', argumentValue($)),
+          seq(choice('ref', 'out', 'in'), $.expression),
+          seq('out', $.declaration_expression)
         )
       ),
 
@@ -1456,15 +1471,23 @@ module.exports = grammar({
     if_statement: ($) =>
       prec.right(
         seq(
-          'if',
-          '(',
-          field('condition', $.expression),
-          ')',
-          field('consequence', $.statement),
+          $._if_statement_head,
+          repeat(seq(sym('_if_alternative_directive'), alias(sym('preproc_if_in_if_alternative'), sym('preproc_if')))),
           optional(seq('else', field('alternative', $.statement)))
         )
       ),
 
+    _if_statement_head: ($) => seq('if', '(', field('condition', $.expression), ')', field('consequence', $.statement)),
+
+    // An `else` directly before a conditional directive takes the statement after the directive as its body, which a
+    // tree cannot attach across the directive boundary.
+    _dangling_else_if_statement: ($) =>
+      seq(
+        $._if_statement_head,
+        'else',
+        optional(field('alternative', alias($._dangling_else_if_statement, $.if_statement)))
+      ),
+
     while_statement: ($) => seq('while', '(', field('condition', $.expression), ')', field('body', $.statement)),
 
     local_declaration_statement: ($) =>
@@ -2314,8 +2337,7 @@ module.exports = grammar({
     _switch_expression_body: ($) =>
       seq(
         '{',
-        commaSep($.switch_expression_arm),
-        optional(','),
+        conditionalList($.switch_expression_arm, 'preproc_if_in_switch_expression'),
         choice('}', alias(sym('_nonprimary_expression_end'), '}'))
       ),
 
@@ -2507,26 +2529,25 @@ module.exports = grammar({
 
     implicit_stackalloc_expression: ($) => seq('stackalloc', '[', ']', $.initializer_expression),
 
-    collection_expression: ($) => seq('[', optional(seq(commaSep1($.collection_element), optional(','))), ']'),
+    collection_expression: ($) => seq('[', conditionalList($.collection_element, 'preproc_if_in_collection'), ']'),
 
     collection_element: ($) => choice($.expression_element, $.spread_element),
 
+    _spread_collection_element: ($) => $.spread_element,
+
     expression_element: ($) => prec(1, $.expression),
 
     spread_element: ($) => prec.dynamic(1, prec(PREC.RANGE, seq('..', $.expression))),
 
     _object_initializer_expression: ($) =>
-      seq(
-        '{',
-        commaSep(
-          choice(
-            alias($._object_index_initializer, $.assignment_expression),
-            alias($._object_member_initializer, $.assignment_expression),
-            $.expression
-          )
-        ),
-        optional(','),
-        '}'
+      seq('{', conditionalList($._object_initializer_element, 'preproc_if_in_object_initializer'), '}'),
+
+    _object_initializer_element: ($) => choice($._object_member_initializers, $.expression),
+
+    _object_member_initializers: ($) =>
+      choice(
+        alias($._object_index_initializer, $.assignment_expression),
+        alias($._object_member_initializer, $.assignment_expression)
       ),
 
     _object_initializer_value: ($) =>
@@ -2544,7 +2565,7 @@ module.exports = grammar({
 
     _object_member_initializer: ($) => assignmentExpression($, $.identifier, '=', $._object_initializer_value),
 
-    initializer_expression: ($) => seq('{', commaSep($.expression), optional(','), '}'),
+    initializer_expression: ($) => seq('{', conditionalList($.expression, 'preproc_if_in_initializer'), '}'),
 
     declaration_expression: ($) => prec.dynamic(1, seq(field('type', $.type), field('name', $.identifier))),
 
@@ -2699,8 +2720,31 @@ module.exports = grammar({
     ...preprocIf('_in_base_list_separator', ($) => $._base_list_separator_path, 0, false, true),
     ...preprocIf('_in_base_list_suffix', ($) => $._base_list_suffix, 0, false),
     ...preprocIf('', ($) => $.declaration),
-    ...preprocIf('_in_top_level', ($) => choice($._top_level_item_no_statement, $.statement)),
+    ...preprocIf('_in_top_level', ($) => conditionalStatements($), 0, false, true),
+    ...preprocIf('_in_if_alternative', ($) => seq(optional('else'), conditionalStatements($)), 0, false),
+
     ...preprocIf('_in_expression', ($) => $.expression, -2, false),
+    ...conditionalListDirective('_in_initializer', ($) => $.expression),
+    ...conditionalListDirective(
+      '_in_object_initializer',
+      ($) => $._object_initializer_element,
+      ($) => $._object_member_initializers
+    ),
+    ...conditionalListDirective(
+      '_in_collection',
+      ($) => $.collection_element,
+      ($) => alias($._spread_collection_element, $.collection_element)
+    ),
+    ...conditionalListDirective(
+      '_in_argument_list',
+      ($) => $.argument,
+      ($) => alias($._modified_argument, $.argument)
+    ),
+    ...conditionalListDirective(
+      '_in_switch_expression',
+      ($) => $.switch_expression_arm,
+      ($) => $.switch_expression_arm
+    ),
     ...preprocIf('_in_enum_member_declaration', ($) => $.enum_member_declaration, 0, false),
     ...preprocIf('_in_attribute_list', ($) => $.attribute_list, -1, false),
 
@@ -3110,6 +3154,25 @@ function preprocIf(suffix, content, precedence = 0, rep = true, required = false
   };
 }
 
+/**
+ * @param {import('@willbooster/web-tree-sitter/dsl').GrammarSymbols<'declaration_expression' | 'expression'>} $
+ */
+function argumentValue($) {
+  return choice(seq(optional(choice('ref', 'out', 'in')), $.expression), seq('out', $.declaration_expression));
+}
+
+/**
+ * Statements of a conditional branch, where the last may be an if statement whose `else` body follows the directive.
+ *
+ * @param {import('@willbooster/web-tree-sitter/dsl').GrammarSymbols<PreprocContentRule>} $
+ */
+function conditionalStatements($) {
+  return seq(
+    repeat(choice($._top_level_item_no_statement, $.statement)),
+    optional(alias($._dangling_else_if_statement, $.if_statement))
+  );
+}
+
 /**
  * @param {'if' | 'elif'} command
  * @param {import('@willbooster/web-tree-sitter/dsl').GrammarSymbols<PreprocContentRule>} $
@@ -3306,6 +3369,68 @@ function nullableQuestion() {
   return choice(alias(sym('_question_nullable'), '?'), alias(sym('_question_unknown'), '?'));
 }
 
+/**
+ * Comma-separated elements, optionally with a trailing comma, where conditional directives may enclose whole elements
+ * together with their commas.
+ *
+ * @param {import('@willbooster/web-tree-sitter/dsl').RuleOrLiteral} element
+ * @param {string} directive
+ * @param {boolean} trailingComma
+ */
+function conditionalList(element, directive, trailingComma = true) {
+  const items = repeat(conditionalListItem(element, directive));
+  const conditional = alias(sym(directive), sym('preproc_if'));
+  return trailingComma
+    ? seq(items, optional(element))
+    : optional(seq(items, choice(element, seq(optional(element), conditional))));
+}
+
+/**
+ * @param {import('@willbooster/web-tree-sitter/dsl').RuleOrLiteral} element
+ * @param {string} directive
+ */
+function conditionalListItem(element, directive) {
+  return choice(seq(element, ','), seq(optional(element), alias(sym(directive), sym('preproc_if')), optional(',')));
+}
+
+/**
+ * Conditional directive rules for a comma-separated list. The `#if` branch alone decides between this rule and the
+ * expression-level directive, so only `#elif` and `#else` branches may hold a single expression.
+ *
+ * @param {string} suffix
+ * @param {import('@willbooster/web-tree-sitter/dsl').RuleBuilder<PreprocContentRule>} element
+ * @param {import('@willbooster/web-tree-sitter/dsl').RuleBuilder<PreprocContentRule>} [single]
+ * @returns {Record<string, import('@willbooster/web-tree-sitter/dsl').RuleBuilder<PreprocContentRule>>}
+ */
+function conditionalListDirective(suffix, element, single) {
+  const directive = 'preproc_if' + suffix;
+  const rules = preprocIf(suffix, ($) => conditionalListContent(element($), directive, single?.($)), 0, false);
+  /** @param {import('@willbooster/web-tree-sitter/dsl').GrammarSymbols<PreprocContentRule>} $ */
+  const alternativeContent = ($) => choice(conditionalListContent(element($), directive), element($));
+  const alternatives = Object.entries(preprocIf(suffix, alternativeContent, 0, false)).filter(
+    ([name]) => !name.startsWith('preproc_if')
+  );
+  return { ...rules, ...Object.fromEntries(alternatives) };
+}
+
+/**
+ * The elements of a conditional branch, which may start with the comma after the preceding element and contain nested
+ * conditional groups. A single expression without commas is left to the expression-level directive, which lets an
+ * operator after the directive continue it.
+ *
+ * @param {import('@willbooster/web-tree-sitter/dsl').RuleOrLiteral} element
+ * @param {string} directive
+ * @param {import('@willbooster/web-tree-sitter/dsl').RuleOrLiteral} [single] a single element without commas that cannot be an
+ * expression
+ */
+function conditionalListContent(element, directive, single) {
+  return choice(
+    seq(',', conditionalList(element, directive)),
+    seq(repeat1(conditionalListItem(element, directive)), optional(element)),
+    ...(single ? [single] : [])
+  );
+}
+
 /**
  * @param {import('@willbooster/web-tree-sitter/dsl').Rule} rule
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-c-sharp",
-  "version": "14.1.1",
+  "version": "14.1.3",
   "description": "C# grammar for tree-sitter",
   "keywords": [
     "incremental",

package/queries/highlights.scm

@@ -231,6 +231,13 @@
   (member_binding_expression name: (generic_name (identifier) @variable.member))
 ]
 
+;; Object initializer members inside conditional directives (alternative branches are omitted because each nested
+;; pattern through `preproc_elif` or `preproc_else` adds noticeable query compilation time)
+
+(object_creation_expression initializer: (initializer_expression (preproc_if (assignment_expression left: (identifier) @variable.member))))
+(implicit_object_creation_expression (initializer_expression (preproc_if (assignment_expression left: (identifier) @variable.member))))
+(assignment_expression right: (initializer_expression (preproc_if (assignment_expression left: (identifier) @variable.member))))
+
 ;; Calls
 
 (invocation_expression

package/src/node-types.json

@@ -808,6 +808,10 @@
         {
           "type": "argument",
           "named": true
+        },
+        {
+          "type": "preproc_if",
+          "named": true
         }
       ]
     }
@@ -2089,6 +2093,10 @@
         {
           "type": "collection_element",
           "named": true
+        },
+        {
+          "type": "preproc_if",
+          "named": true
         }
       ]
     }
@@ -4122,6 +4130,16 @@
           }
         ]
       }
+    },
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "preproc_if",
+          "named": true
+        }
+      ]
     }
   },
   {
@@ -6294,6 +6312,10 @@
       "multiple": true,
       "required": false,
       "types": [
+        {
+          "type": "argument",
+          "named": true
+        },
         {
           "type": "argument_list",
           "named": true
@@ -6306,6 +6328,10 @@
           "type": "base_list",
           "named": true
         },
+        {
+          "type": "collection_element",
+          "named": true
+        },
         {
           "type": "declaration",
           "named": true
@@ -6338,6 +6364,10 @@
           "type": "statement",
           "named": true
         },
+        {
+          "type": "switch_expression_arm",
+          "named": true
+        },
         {
           "type": "type_declaration",
           "named": true
@@ -6374,6 +6404,10 @@
       "multiple": true,
       "required": false,
       "types": [
+        {
+          "type": "argument",
+          "named": true
+        },
         {
           "type": "argument_list",
           "named": true
@@ -6386,6 +6420,10 @@
           "type": "base_list",
           "named": true
         },
+        {
+          "type": "collection_element",
+          "named": true
+        },
         {
           "type": "declaration",
           "named": true
@@ -6418,6 +6456,10 @@
           "type": "statement",
           "named": true
         },
+        {
+          "type": "switch_expression_arm",
+          "named": true
+        },
         {
           "type": "type_declaration",
           "named": true
@@ -6535,6 +6577,10 @@
       "multiple": true,
       "required": false,
       "types": [
+        {
+          "type": "argument",
+          "named": true
+        },
         {
           "type": "argument_list",
           "named": true
@@ -6543,6 +6589,10 @@
           "type": "base_list",
           "named": true
         },
+        {
+          "type": "collection_element",
+          "named": true
+        },
         {
           "type": "declaration",
           "named": true
@@ -6575,6 +6625,10 @@
           "type": "statement",
           "named": true
         },
+        {
+          "type": "switch_expression_arm",
+          "named": true
+        },
         {
           "type": "type_declaration",
           "named": true

package/tree-sitter.json

@@ -19,6 +19,7 @@
       "external-files": [
         "src/genericExpressions.h",
         "src/identifierCharacters.h",
+        "src/ifAlternativeDirective.h",
         "src/nullableRank.h",
         "src/nullableTypes.h",
         "src/questionContext.h",
@@ -30,7 +31,7 @@
     }
   ],
   "metadata": {
-    "version": "14.1.1",
+    "version": "14.1.3",
     "license": "MIT",
     "description": "C# grammar for tree-sitter",
     "authors": [