tree-sitter-angular-codemod 0.6.5

/**
 * @file Angular Grammar for tree-sitter
 * @author Dennis van den Berg <dennis@vdberg.dev>
 * @license MIT
 */

/* eslint-disable-next-line spaced-comment */
/// <reference types="tree-sitter-cli/dsl" />

const HTML = require('tree-sitter-html/grammar');

const PREC = {
  CALL: 1,
  ALIAS: 2,
  PIPE: 3,
  NULLISH: 4,
  INTERPOLATION: 5,
};

module.exports = grammar(HTML, {
  name: 'angular',

  externals: ($, original) =>
    original.concat([
      $._interpolation_start,
      $._interpolation_end,
      // $._control_flow_start,
      $.if_start,
      $.else_start,
      $.for_start,
      $.switch_start,
      $.case_start,
      $.default_start,
      $.defer_start,
      $.let_start,
      $.empty_start,
      $.placeholder_start,
      $.loading_start,
      $.error_start,
      $.else_if_start,
      $.at_sign,
    ]),

  rules: {
    // ---------- Root ---------
    _node: ($, original) =>
      choice(
        prec(1, $.icu_expression),
        prec(1, $.interpolation),
        prec(1, $._any_statement),
        $.at_sign,
        original,
      ),

    // ---------- Overrides ----------
    attribute_name: (_) => /[^<>\*.\[\]\(\)"'=\s]+/,
    text: (_) => /[^<>{}&@\s]([^<>{}&@]*[^<>{}&@\s])?/,

    // ----------- Statement block --------
    statement_block: ($) => prec.right(seq('{', repeat($._node), '}')),

    // ---------- Statements ----------
    _any_statement: ($) =>
      choice(
        $.if_statement,
        $.for_statement,
        $.defer_statement,
        $.switch_statement,
        $.let_statement,
        $._alternative_statement,
      ),

    _alternative_statement: ($) =>
      choice(
        field('alternative', $.else_statement),
        field('alternative_condition', $.else_if_statement),
        field('empty', $.empty_statement),
        field('placeholder', $.placeholder_statement),
        field('loading', $.loading_statement),
        field('error', $.error_statement),
      ),

    // ---------- Let Statement ----------
    let_statement: ($) =>
      prec.left(seq(alias($.let_start, $.control_keyword), $.assignment_expression, ';')),

    // ---------- Switch Statement ----------

    switch_statement: ($) =>
      prec.right(
        seq(
          alias($.switch_start, $.control_keyword),
          '(',
          field('value', $.expression),
          ')',
          field('body', $.switch_body),
        ),
      ),

    switch_body: ($) =>
      seq('{', repeat1(choice($.case_statement, $.default_statement)), '}'),

    case_statement: ($) =>
      seq(
        alias($.case_start, $.control_keyword),
        '(',
        field('value', $._any_expression),
        ')',
        field('body', $.statement_block),
      ),

    default_statement: ($) =>
      seq(alias($.default_start, $.control_keyword), field('body', $.statement_block)),

    // ---------- Defer Statement ----------

    defer_statement: ($) =>
      prec.left(
        seq(
          alias($.defer_start, $.control_keyword),
          optional($.defer_trigger),
          field('body', $.statement_block),
        ),
      ),

    placeholder_statement: ($) =>
      prec.left(
        seq(
          alias($.placeholder_start, $.control_keyword),
          optional($.placeholder_minimum),
          field('body', $.statement_block),
        ),
      ),

    loading_statement: ($) =>
      prec.left(
        seq(
          alias($.loading_start, $.control_keyword),
          optional($.loading_condition),
          field('body', $.statement_block),
        ),
      ),

    error_statement: ($) =>
      seq(alias($.error_start, $.control_keyword), field('body', $.statement_block)),

    defer_trigger: ($) =>
      seq(
        '(',
        field('condition', $.defer_trigger_condition),
        optional(repeat(seq(';', field('condition', $.defer_trigger_condition)))),
        ')',
      ),

    placeholder_minimum: ($) => seq('(', field('minimum', $.timed_expression), ')'),

    loading_condition: ($) =>
      seq(
        '(',
        field('condition', $.timed_expression),
        optional(seq(';', field('condition', $.timed_expression))),
        ')',
      ),

    defer_trigger_condition: ($) =>
      seq(
        optional(alias('prefetch', $.prefetch_keyword)),
        choice(
          seq(alias('when', $.special_keyword), field('trigger', $._any_expression)),
          seq(alias('on', $.special_keyword), field('trigger', $._primitive)),
        ),
      ),

    timed_expression: ($) =>
      seq(alias(choice('after', 'minimum'), $.special_keyword), field('value', $.number)),

    // ---------- For Statement ----------
    for_statement: ($) =>
      prec.left(
        seq(
          alias($.for_start, $.control_keyword),
          '(',
          field('declaration', $.for_declaration),
          optional(field('references', $.for_references)),
          ')',
          field('body', $.statement_block),
        ),
      ),

    empty_statement: ($) =>
      seq(alias($.empty_start, $.control_keyword), field('body', $.statement_block)),

    for_declaration: ($) =>
      seq(
        field('name', $.identifier),
        alias('of', $.special_keyword),
        field('value', $.expression),
        ';',
        alias('track', $.special_keyword),
        field('track', $._any_expression),
      ),

    for_references: ($) =>
      seq(
        ';',
        field('reference', $.for_reference),
        repeat(seq(';', field('reference', $.for_reference))),
      ),

    for_reference: ($) =>
      seq(
        alias('let', $.special_keyword),
        field('alias', $.assignment_expression),
        repeat(seq(',', field('alias', $.assignment_expression))),
      ),

    // ---------- If Statement ----------
    if_statement: ($) =>
      prec.right(
        seq(
          alias($.if_start, $.control_keyword),
          '(',
          field('condition', $.if_condition),
          optional(field('reference', $.if_reference)),
          ')',
          field('consequence', $.statement_block),
          optional(repeat($._alternative_statement)),
        ),
      ),

    else_if_statement: ($) =>
      prec.right(
        seq(
          alias($.else_if_start, $.control_keyword),
          '(',
          field('condition', $.if_condition),
          optional(field('reference', $.if_reference)),
          ')',
          field('consequence', $.statement_block),
        ),
      ),

    else_statement: ($) =>
      prec.right(
        seq(alias($.else_start, $.control_keyword), field('body', $.statement_block)),
      ),

    if_condition: ($) => prec.right(PREC.CALL, $._any_expression),
    if_reference: ($) => seq(';', alias('as', $.special_keyword), $.identifier),

    // ---------- Expressions -----------
    _any_expression: ($) =>
      choice(
        $.binary_expression,
        $.unary_expression,
        $.expression,
        $.ternary_expression,
        $.nullish_coalescing_expression,
        prec(3, $.conditional_expression),
      ),

    assignment_expression: ($) =>
      seq(field('name', $.identifier), '=', field('value', $._any_expression)),

    // -------- ICU expressions ---------
    icu_expression: ($) =>
      seq(
        '{',
        choice($._any_expression),
        ',',
        $.icu_clause,
        ',',
        repeat1($.icu_case),
        '}',
      ),

    icu_clause: () => choice('plural', 'select'),

    icu_case: ($) => seq($.icu_category, '{', repeat1($._node), '}'),

    icu_category: () => /[^{}]+/i,

    // ---------- Interpolation ---------
    interpolation: ($) =>
      prec.right(
        PREC.INTERPOLATION,
        seq(
          alias($._interpolation_start, '{{'),
          choice($._any_expression),
          alias($._interpolation_end, '}}'),
        ),
      ),

    // ---------- Property Binding ---------
    attribute: ($) =>
      choice(
        prec(1, $.property_binding),
        prec(1, $.two_way_binding),
        prec(1, $.animation_binding),
        prec(1, $.event_binding),
        prec(1, $.structural_directive),
        $._normal_attribute, // <-- This needs to be hidden from syntax tree
      ),

    // ---------- Structural Directives ---------
    structural_directive: ($) =>
      seq(
        '*',
        $.identifier,
        optional(
          seq(
            '=',
            $._double_quote,
            choice($.structural_declaration, $.structural_expression),
            $._double_quote,
          ),
        ),
      ),

    structural_expression: ($) =>
      seq(
        $._any_expression,
        optional($._alias),
        choice(
          $._structural_let_expression,
          seq(
            optional($._then_template_expression),
            optional($._else_template_expression),
          ),
          optional($._context_expression),
        ),
      ),

    structural_declaration: ($) =>
      seq(
        alias('let', $.special_keyword),
        seq(
          $.structural_assignment,
          repeat(seq(choice(';', ','), $.structural_assignment)),
        ),
      ),

    structural_assignment: ($) =>
      choice(
        seq(field('name', $.identifier), ':', field('value', $.identifier)),
        prec.left(
          PREC.ALIAS,
          seq(
            optional(alias('let', $.special_keyword)),
            field('name', $.identifier),
            optional(
              seq(
                field('operator', choice('=', 'of')),
                field('value', $.expression),
                optional($._alias),
              ),
            ),
          ),
        ),
        seq(field('name', $.identifier), optional($._alias)),
      ),

    _alias: ($) => seq(alias('as', $.special_keyword), field('alias', $.identifier)),
    _then_template_expression: ($) =>
      seq(';', alias('then', $.special_keyword), $.identifier),
    _else_template_expression: ($) =>
      seq(';', alias('else', $.special_keyword), $.identifier),
    _context_expression: ($) =>
      seq(
        ';',
        choice(alias('context', $.special_keyword), field('named', $.identifier)),
        ':',
        $._any_expression,
      ),

    _structural_let_expression: ($) =>
      seq(
        ';',
        alias('let', $.special_keyword),
        field('name', $.identifier),
        optional($._alias),
      ),

    // ---------- Bindings ----------
    property_binding: ($) => seq('[', $.binding_name, ']', $._binding_assignment),
    event_binding: ($) => seq('(', $.binding_name, ')', $._binding_assignment),
    two_way_binding: ($) => seq('[(', $.binding_name, ')]', $._binding_assignment),
    animation_binding: ($) =>
      seq('[@', $.binding_name, ']', optional(field('trigger', $._binding_assignment))),

    _binding_assignment: ($) =>
      seq(
        '=',
        $._double_quote,
        optional(choice($._any_expression, $.assignment_expression)),
        repeat(seq(';', optional(choice($._any_expression, $.assignment_expression)))),
        $._double_quote,
      ),

    binding_name: ($) => seq(choice($.identifier, $.member_expression)),

    _attribute_node: ($) =>
      choice(
        repeat(choice(token.immediate(/[^"]/), $._escape_sequence)),
        prec(1, $.interpolation),
      ),

    _normal_attribute: ($) =>
      seq(
        $.attribute_name,
        optional(
          seq(
            '=',
            choice(
              seq(
                $._double_quote,
                repeat(
                  choice(
                    alias(token.immediate(/[^"{]+/), $.string_content),
                    $._escape_sequence,
                    $.interpolation,
                  ),
                ),
                $._double_quote,
              ),
              seq(
                $._single_quote,
                repeat(
                  choice(
                    alias(token.immediate(/[^'{]+/), $.string_content),
                    $._escape_sequence,
                    $.interpolation,
                  ),
                ),
                $._single_quote,
              ),
            ),
          ),
        ),
      ),

    // ---------- Expressions ---------
    // Expression
    expression: ($) =>
      prec.left(seq($._primitive, optional(field('pipes', $.pipe_sequence)))),

    // Unary expression
    unary_expression: ($) =>
      seq(
        field('operator', alias('!', $.unary_operator)),
        field('value', choice($.expression, $.unary_expression)),
      ),

    // Binary expression
    binary_expression: ($) =>
      prec.left(
        PREC.CALL + 1, // Increase precedence slightly above CALL to ensure nesting
        seq(
          field('left', choice($.expression, $.binary_expression)),
          field('operator', $._binary_op),
          field('right', $.expression),
        ),
      ),

    // Ternary expression
    ternary_expression: ($) =>
      prec.right(
        PREC.CALL,
        seq(
          field('condition', $._any_expression),
          alias('?', $.ternary_operator),
          field('consequence', choice($.group, $._any_expression)),
          alias(':', $.ternary_operator),
          field('alternative', choice($.group, $._any_expression)),
        ),
      ),

    // Nullish coalescing expression
    nullish_coalescing_expression: ($) =>
      prec.right(
        PREC.NULLISH,
        seq(
          field('condition', $._any_expression),
          alias('??', $.coalescing_operator),
          field('default', $._primitive),
        ),
      ),

    // Conditional expression
    conditional_expression: ($) =>
      prec.right(
        PREC.CALL,
        seq(
          field('left', choice($._primitive, $.unary_expression, $.binary_expression)),
          alias(choice('||', '&&'), $.conditional_operator),
          field(
            'right',
            choice(
              $.expression,
              $.unary_expression,
              $.binary_expression,
              $.conditional_expression,
            ),
          ),
        ),
      ),

    // ---------- Pipes ---------
    pipe_sequence: ($) =>
      prec.left(PREC.PIPE, repeat1(seq(alias('|', $.pipe_operator), $.pipe_call))),

    pipe_call: ($) =>
      prec.left(
        PREC.PIPE,
        seq(field('name', $.identifier), optional(field('arguments', $.pipe_arguments))),
      ),

    pipe_arguments: ($) =>
      prec.left(
        PREC.PIPE,
        seq(
          ':',
          field('argument', $._any_expression), // Use _any_expression to allow full expression parsing
          repeat(seq(':', field('argument', $._any_expression))), // Allow multiple arguments
        ),
      ),

    // ---------- Primitives ----------
    _primitive: ($) =>
      choice(
        $.object,
        $.array,
        $.identifier,
        $.string,
        $.number,
        $.group,
        $.call_expression,
        $.member_expression,
        $.bracket_expression,
      ),

    // Object
    object: ($) => seq('{', commaSep($.pair), optional(','), '}'),
    pair: ($) =>
      seq(
        field('key', choice($.identifier, $.string)),
        optional(seq(':', field('value', $._any_expression))),
      ),

    // Array
    array: ($) => seq('[', commaSep($._any_expression), optional(','), ']'),

    // Identifier
    identifier: () => /[a-zA-Z_\$][a-zA-Z_0-9\-\$]*/,

    _escape_sequence: (_) =>
      token.immediate(
        seq(
          '\\',
          choice(
            /[^xu0-7]/,
            /[0-7]{1,3}/,
            /x[0-9a-fA-F]{2}/,
            /u[0-9a-fA-F]{4}/,
            /u\{[0-9a-fA-F]+\}/,
            /[\r?][\n\u2028\u2029]/,
          ),
        ),
      ),

    // String
    string: ($) =>
      choice(
        seq(
          $._double_quote,
          repeat(choice(token.immediate(/[^"]/), $._escape_sequence)),
          $._double_quote,
        ),
        seq(
          $._single_quote,
          repeat(choice(token.immediate(/[^']/), $._escape_sequence)),
          $._single_quote,
        ),
      ),

    // Number
    number_fragment: () => /\-?[0-9]+\.?[0-9]*/,

    number: ($) =>
      choice($.number_fragment, seq($.number_fragment, alias(choice('ms', 's'), $.unit))),

    // Group
    group: ($) => seq('(', $._any_expression, ')'),

    // Call expression
    call_expression: ($) =>
      prec.left(
        PREC.CALL,
        seq(
          field('function', $.identifier),
          '(',
          optional(field('arguments', $.arguments)),
          ')',
        ),
      ),
    arguments: ($) =>
      commaSep1(choice($.expression, $.binary_expression, $.unary_expression)),

    // Member expression
    member_expression: ($) =>
      seq(
        field('object', $._primitive),
        choice(
          seq(
            choice('.', '?.', '!.'),
            choice(field('property', $.identifier), field('call', $.call_expression)),
          ),
        ),
      ),

    // Bracket expression
    bracket_expression: ($) =>
      prec.left(
        PREC.CALL,
        seq(
          field('object', $._primitive),
          optional(choice('?.', '!')),
          '[',
          field(
            'property',
            choice(
              $.identifier,
              $.static_member_expression,
              $.bracket_expression,
              $.member_expression,
            ),
          ),
          ']',
        ),
      ),

    static_member_expression: ($) => $._any_expression,

    // ---------- Base ----------
    _closing_bracket: (_) => token(prec(-1, '}')),
    // eslint-disable-next-line quotes
    _single_quote: () => "'",
    _double_quote: () => '"',
    _binary_op: () =>
      choice(
        '+',
        '-',
        '/',
        '*',
        '%',
        '==',
        '===',
        '!=',
        '!==',
        '&&',
        '||',
        '<',
        '<=',
        '>',
        '>=',
      ),
  },
});

/**
 * Creates a rule to match one or more of the rules separated by a comma
 *
 * @param {Rule} rule
 *
 * @return {SeqRule}
 */
function commaSep1(rule) {
  return seq(rule, repeat(seq(',', rule)));
}

/**
 * Creates a rule to optionally match one or more of the rules separated by a comma
 *
 * @param {Rule} rule
 *
 * @return {ChoiceRule}
 */
function commaSep(rule) {
  return optional(commaSep1(rule));
}