wehub-resource-sync
1294 lines
43 KiB
Diff
1294 lines
43 KiB
Diff
diff --git a/grammar.js b/grammar.js
|
|
index 21c8523..00bf2b1 100644
|
|
--- a/grammar.js
|
|
+++ b/grammar.js
|
|
@@ -21,10 +21,14 @@ const PRECEDENCE = {
|
|
|
|
module.exports = grammar({
|
|
name: "vbnet",
|
|
+ word: ($) => $._identifier_token,
|
|
+
|
|
+ externals: ($) => [$._query_clause_continuation, $.xml_literal],
|
|
+
|
|
extras: $ => [
|
|
$.comment,
|
|
$.preprocessor_directive,
|
|
- /[ \t\v\f]+/,
|
|
+ /[ \t\v\f\uFEFF]+/,
|
|
/\r?\n/,
|
|
/_[ \t]*\r?\n/,
|
|
],
|
|
@@ -38,17 +42,14 @@ module.exports = grammar({
|
|
$._type,
|
|
],
|
|
conflicts: ($) => [
|
|
+ [$.binary_expression, $.assignment_expression, $.inline_assignment_statement],
|
|
[$.simple_name, $.generic_name],
|
|
[$.await_expression, $.with_expression],
|
|
[$._name_reference, $._type],
|
|
[$.object_creation_expression, $.array_creation_expression, $.array_type],
|
|
- [$.string_literal, $.character_literal],
|
|
[$._primary_expression, $.variable_declarator],
|
|
- [$.lambda_expression, $.with_expression],
|
|
- [$.lambda_expression],
|
|
[$.binary_expression, $.assignment_expression],
|
|
[$._primary_expression, $.select_element],
|
|
- [$.with_expression, $.select_element],
|
|
[$.select_clause],
|
|
[$._primary_expression, $.group_element],
|
|
[$._terminator, $._block_terminator],
|
|
@@ -66,7 +67,6 @@ module.exports = grammar({
|
|
[$.aggregate_element, $.into_element],
|
|
[$.group_by_clause],
|
|
[$.else_clause],
|
|
- [$.if_statement],
|
|
[$.case_else_clause],
|
|
[$.case_clause],
|
|
[$.elseif_clause],
|
|
@@ -75,7 +75,6 @@ module.exports = grammar({
|
|
[$._primary_expression, $.simple_name, $.generic_name],
|
|
[$._primary_expression, $.variable_declarator, $.labeled_statement],
|
|
[$._statement, $.with_statement],
|
|
- [$.dictionary_initializer, $.collection_initializer],
|
|
[
|
|
$.class_declaration,
|
|
$.structure_declaration,
|
|
@@ -89,7 +88,6 @@ module.exports = grammar({
|
|
],
|
|
],
|
|
|
|
- word: ($) => $._identifier_token,
|
|
|
|
rules: {
|
|
source_file: ($) =>
|
|
@@ -157,13 +155,14 @@ module.exports = grammar({
|
|
),
|
|
|
|
_terminator: ($) =>
|
|
- choice(seq(optional(":"), choice("\n", "\r\n")), $._eof),
|
|
+ prec.right(choice(seq(optional(":"), choice("\n", "\r\n")), prec(-1, ":"), $._eof)),
|
|
|
|
- _block_terminator: ($) => prec.right(repeat1(choice("\n", "\r\n", $._eof))),
|
|
+ _block_terminator: ($) => prec.right(repeat1(choice("\n", "\r\n", ":", $._eof))),
|
|
|
|
_eof: ($) => token(prec(-10, "$")),
|
|
|
|
- _identifier_token: ($) => token(prec(-1, /[a-zA-Z_][a-zA-Z0-9_]*/)),
|
|
+ _identifier_token: ($) =>
|
|
+ token(prec(-1, /[\p{L}\p{Nl}_][\p{L}\p{Nl}\p{Nd}\p{Mn}\p{Pc}]*[%$&!#@]?/u)),
|
|
|
|
identifier: ($) =>
|
|
choice(
|
|
@@ -194,7 +193,6 @@ module.exports = grammar({
|
|
ci("MustInherit"),
|
|
ci("NotInheritable"),
|
|
ci("Overrides"),
|
|
- ci("MustOverride"),
|
|
ci("NotOverridable"),
|
|
ci("Overridable"),
|
|
ci("Overloads"),
|
|
@@ -225,43 +223,6 @@ module.exports = grammar({
|
|
$._statement // Fallback to regular statements
|
|
),
|
|
|
|
- _non_statement_identifier: $ => choice(
|
|
- // Match identifiers that don't start with statement keywords
|
|
- token(prec(1, seq(
|
|
- negative_lookahead(seq(
|
|
- choice(
|
|
- /[Tt][Rr][Yy]/,
|
|
- /[Ss][Ee][Ll][Ee][Cc][Tt]/,
|
|
- /[Ii][Ff]/,
|
|
- /[Ww][Hh][Ii][Ll][Ee]/,
|
|
- /[Dd][Oo]/,
|
|
- /[Ff][Oo][Rr]/,
|
|
- /[Uu][Ss][Ii][Nn][Gg]/,
|
|
- /[Ww][Ii][Tt][Hh]/,
|
|
- /[Tt][Hh][Rr][Oo][Ww]/,
|
|
- /[Rr][Ee][Tt][Uu][Rr][Nn]/,
|
|
- /[Ee][Xx][Ii][Tt]/,
|
|
- /[Cc][Oo][Nn][Tt][Ii][Nn][Uu][Ee]/,
|
|
- /[Ss][Tt][Oo][Pp]/,
|
|
- /[Ee][Nn][Dd]/,
|
|
- /[Gg][Oo][Tt][Oo]/,
|
|
- /[Rr][Ee][Ss][Uu][Mm][Ee]/,
|
|
- /[Ee][Rr][Rr][Oo][Rr]/,
|
|
- /[Oo][Nn]/,
|
|
- /[Rr][Ee][Dd][Ii][Mm]/,
|
|
- /[Ee][Rr][Aa][Ss][Ee]/,
|
|
- /[Ss][Yy][Nn][Cc][Ll][Oo][Cc][Kk]/,
|
|
- /[Rr][Aa][Ii][Ss][Ee][Ee][Vv][Ee][Nn][Tt]/,
|
|
- /[Aa][Dd][Dd][Hh][Aa][Nn][Dd][Ll][Ee][Rr]/,
|
|
- /[Rr][Ee][Mm][Oo][Vv][Ee][Hh][Aa][Nn][Dd][Ll][Ee][Rr]/
|
|
- ),
|
|
- choice(/\s/, /\r/, /\n/, /$/)
|
|
- )),
|
|
- /[a-zA-Z_][a-zA-Z0-9_]*/
|
|
- ))),
|
|
- seq("[", /[^\]]+/, "]") // Bracketed identifier can be anything
|
|
- ),
|
|
-
|
|
local_declaration_modifier: ($) =>
|
|
choice(ci("Dim"), ci("Const"), ci("Static")),
|
|
|
|
@@ -300,6 +261,8 @@ module.exports = grammar({
|
|
_primary_expression: ($) =>
|
|
choice(
|
|
$._literal,
|
|
+ $.array_literal,
|
|
+ $.tuple_expression,
|
|
$.identifier,
|
|
$.parenthesized_expression,
|
|
$.generic_invocation_expression, // Add this before regular invocation
|
|
@@ -320,17 +283,26 @@ module.exports = grammar({
|
|
),
|
|
|
|
generic_invocation_expression: ($) =>
|
|
- prec(
|
|
- PRECEDENCE.INVOCATION + 1,
|
|
+ prec.right(
|
|
+ PRECEDENCE.INVOCATION + 1,
|
|
seq(
|
|
field("function", $._expression),
|
|
field("type_arguments", $.type_argument_list),
|
|
- field("arguments", $.argument_list)
|
|
+ optional(field("arguments", $.argument_list))
|
|
)
|
|
),
|
|
|
|
parenthesized_expression: ($) => seq("(", $._expression, ")"),
|
|
|
|
+ tuple_expression: ($) =>
|
|
+ seq(
|
|
+ "(",
|
|
+ choice($._expression, seq(field("name", $.identifier), ":=", $._expression)),
|
|
+ ",",
|
|
+ commaSep1(choice($._expression, seq(field("name", $.identifier), ":=", $._expression))),
|
|
+ ")"
|
|
+ ),
|
|
+
|
|
member_access_expression: ($) =>
|
|
prec.left(
|
|
PRECEDENCE.MEMBER_ACCESS,
|
|
@@ -350,20 +322,23 @@ module.exports = grammar({
|
|
)
|
|
),
|
|
|
|
- argument_list: ($) => seq("(", optional(commaSep1($._argument)), ")"),
|
|
+ argument_list: ($) => seq("(", optional($._arguments), ")"),
|
|
|
|
- _argument: ($) =>
|
|
- choice($._expression, $.named_argument, $.omitted_argument),
|
|
+ // Argument slots may be omitted between commas (`f(a,, b)`, `f(, x)`) —
|
|
+ // VB passes Optional parameters positionally by leaving the slot empty.
|
|
+ _arguments: ($) =>
|
|
+ seq($._argument, repeat(seq(",", optional($._argument)))),
|
|
|
|
- omitted_argument: ($) => token(prec(1, ",")),
|
|
+ _argument: ($) => choice($._expression, $.named_argument),
|
|
|
|
array_access_expression: ($) =>
|
|
prec(
|
|
PRECEDENCE.ARRAY_ACCESS,
|
|
seq(
|
|
field("array", $._expression),
|
|
+ optional("?"),
|
|
"(",
|
|
- field("indices", commaSep1($._expression)),
|
|
+ field("indices", $._arguments),
|
|
")"
|
|
)
|
|
),
|
|
@@ -471,16 +446,53 @@ module.exports = grammar({
|
|
),
|
|
|
|
lambda_expression: ($) =>
|
|
- seq(
|
|
- choice(ci("Function"), ci("Sub")),
|
|
- field("parameters", $.lambda_parameter_list),
|
|
- field("body", choice($._expression, $._statement_block))
|
|
+ choice(
|
|
+ prec.right(
|
|
+ seq(
|
|
+ optional(choice(ci("Async"), ci("Iterator"))),
|
|
+ choice(ci("Function"), ci("Sub")),
|
|
+ field("parameters", $.lambda_parameter_list),
|
|
+ field(
|
|
+ "body",
|
|
+ choice(
|
|
+ $._expression,
|
|
+ alias($.inline_if_statement, $.if_statement),
|
|
+ alias($.inline_throw_statement, $.throw_statement)
|
|
+ )
|
|
+ )
|
|
+ )
|
|
+ ),
|
|
+ seq(
|
|
+ optional(choice(ci("Async"), ci("Iterator"))),
|
|
+ ci("Function"),
|
|
+ field("parameters", $.lambda_parameter_list),
|
|
+ optional($.as_clause),
|
|
+ $._block_terminator,
|
|
+ repeat($._statement),
|
|
+ ci("End"), ci("Function")
|
|
+ ),
|
|
+ seq(
|
|
+ optional(choice(ci("Async"), ci("Iterator"))),
|
|
+ ci("Sub"),
|
|
+ field("parameters", $.lambda_parameter_list),
|
|
+ $._block_terminator,
|
|
+ repeat($._statement),
|
|
+ ci("End"), ci("Sub")
|
|
+ )
|
|
),
|
|
|
|
lambda_parameter_list: ($) => seq("(", commaSep($.lambda_parameter), ")"),
|
|
|
|
lambda_parameter: ($) =>
|
|
- seq(field("name", $.identifier), optional($.as_clause)),
|
|
+ seq(
|
|
+ optional(field("modifiers", repeat1(choice(ci("ByVal"), ci("ByRef"))))),
|
|
+ field("name", $.identifier),
|
|
+ optional(choice(
|
|
+ $.array_rank_specifier,
|
|
+ seq("(", field("bounds", commaSep1($._expression)), ")")
|
|
+ )),
|
|
+ optional($.as_clause)
|
|
+ ),
|
|
|
|
typeof_is_expression: ($) =>
|
|
prec.left(
|
|
@@ -488,7 +500,7 @@ module.exports = grammar({
|
|
seq(
|
|
ci("TypeOf"),
|
|
field("expression", $._expression),
|
|
- ci("Is"),
|
|
+ choice(seq(ci("Is"), ci("Not")), token(prec(12, ci("IsNot"))), ci("Is")),
|
|
field("type", $._type)
|
|
)
|
|
),
|
|
@@ -504,29 +516,12 @@ module.exports = grammar({
|
|
"initializer",
|
|
choice(
|
|
$.object_initializer,
|
|
- $.collection_initializer,
|
|
- $.dictionary_initializer // Add this new option
|
|
+ $.collection_initializer
|
|
)
|
|
)
|
|
)
|
|
),
|
|
|
|
- dictionary_initializer: ($) =>
|
|
- seq(
|
|
- ci("From"),
|
|
- "{",
|
|
- commaSep($.dictionary_element),
|
|
- "}"
|
|
- ),
|
|
-
|
|
- dictionary_element: ($) =>
|
|
- seq(
|
|
- "{",
|
|
- field("key", $._expression),
|
|
- ",",
|
|
- field("value", $._expression),
|
|
- "}"
|
|
- ),
|
|
|
|
|
|
object_initializer: ($) =>
|
|
@@ -551,6 +546,8 @@ module.exports = grammar({
|
|
collection_initializer: ($) =>
|
|
seq(ci("From"), "{", commaSep($._expression), "}"),
|
|
|
|
+ array_literal: ($) => seq("{", commaSep($._expression), "}"),
|
|
+
|
|
|
|
array_creation_expression: ($) =>
|
|
seq(
|
|
@@ -646,6 +643,9 @@ module.exports = grammar({
|
|
seq(field("object", $._expression), "!", field("member", $.identifier)),
|
|
_literal: ($) =>
|
|
choice(
|
|
+ $.xml_literal,
|
|
+ $.interpolated_string_literal,
|
|
+ $.date_literal,
|
|
$.string_literal,
|
|
$.character_literal,
|
|
$.integer_literal,
|
|
@@ -654,16 +654,49 @@ module.exports = grammar({
|
|
$.nothing_literal,
|
|
$.date_literal
|
|
),
|
|
- string_literal: ($) => seq('"', repeat(choice(/[^"\n]+/, '""')), '"'),
|
|
- character_literal: ($) => seq('"', choice(/[^"\n]/, '""'), '"', "c"),
|
|
+ string_literal: ($) => token(seq('"', repeat(choice(/[^"]/, '""')), '"')),
|
|
+ interpolated_string_literal: ($) =>
|
|
+ seq(
|
|
+ '$"',
|
|
+ repeat(
|
|
+ choice(
|
|
+ token.immediate(prec(101, /[^"{}]+/)),
|
|
+ token.immediate(prec(101, '""')),
|
|
+ token.immediate(prec(101, "{{")),
|
|
+ token.immediate(prec(101, "}}")),
|
|
+ $.interpolation
|
|
+ )
|
|
+ ),
|
|
+ token.immediate('"')
|
|
+ ),
|
|
+ interpolation: ($) =>
|
|
+ seq(
|
|
+ token.immediate(prec(101, "{")),
|
|
+ $._expression,
|
|
+ optional(seq(",", /-?\d+/)),
|
|
+ optional(seq(":", /[^}"\r\n]+/)),
|
|
+ "}"
|
|
+ ),
|
|
+ date_literal: ($) => token(prec(2, /#[ \t]*\d[^#\r\n]*#/)),
|
|
+ character_literal: ($) => token(seq('"', choice(/[^"\r\n]/, '""'), '"', /[cC]/)),
|
|
integer_literal: ($) =>
|
|
- token(seq(/\d+/, optional(choice("I", "UI", "L", "UL", "S", "US")))),
|
|
+ token(
|
|
+ seq(
|
|
+ choice(
|
|
+ /\d+(_+\d+)*/,
|
|
+ /&[Hh][0-9A-Fa-f]+(_+[0-9A-Fa-f]+)*/,
|
|
+ /&[Oo][0-7]+(_+[0-7]+)*/,
|
|
+ /&[Bb][01]+(_+[01]+)*/
|
|
+ ),
|
|
+ optional(choice(/[Uu][SsIiLl]/, /[SsIiLl]/, "%", "&"))
|
|
+ )
|
|
+ ),
|
|
floating_point_literal: ($) =>
|
|
token(
|
|
seq(
|
|
choice(seq(/\d+/, ".", /\d+/), seq(".", /\d+/), /\d+/),
|
|
optional(/[eE][+-]?\d+/),
|
|
- optional(choice("F", "D", "R"))
|
|
+ optional(/[FfRrDd!#@]/)
|
|
)
|
|
),
|
|
boolean_literal: ($) => choice(ci("True"), ci("False")),
|
|
@@ -672,7 +705,7 @@ module.exports = grammar({
|
|
|
|
// Names and types
|
|
_name_reference: ($) =>
|
|
- choice($.simple_name, $.qualified_name, $.global_qualified_name),
|
|
+ choice($.simple_name, $.generic_name, $.qualified_name, $.global_qualified_name),
|
|
|
|
simple_name: ($) => $.identifier,
|
|
|
|
@@ -682,7 +715,7 @@ module.exports = grammar({
|
|
seq(
|
|
field("qualifier", $._name_reference),
|
|
".",
|
|
- field("name", $.simple_name)
|
|
+ field("name", choice($.simple_name, $.generic_name))
|
|
)
|
|
),
|
|
global_qualified_name: ($) =>
|
|
@@ -694,6 +727,7 @@ module.exports = grammar({
|
|
$.simple_name,
|
|
$.qualified_name,
|
|
$.generic_name,
|
|
+ $.global_qualified_name,
|
|
$.predefined_type,
|
|
$.array_type,
|
|
$.tuple_type
|
|
@@ -720,7 +754,8 @@ module.exports = grammar({
|
|
),
|
|
|
|
generic_name: ($) => seq(field("name", $.identifier), $.type_argument_list),
|
|
- type_argument_list: ($) => seq("(", ci("Of"), commaSep1($._type), ")"),
|
|
+ type_argument_list: ($) =>
|
|
+ seq("(", ci("Of"), optional($._type), repeat(seq(",", optional($._type))), ")"),
|
|
array_type: ($) =>
|
|
seq(field("element_type", $._type), $.array_rank_specifier),
|
|
array_rank_specifier: ($) => seq("(", repeat(","), ")"),
|
|
@@ -742,10 +777,14 @@ module.exports = grammar({
|
|
field("type", $._type)
|
|
),
|
|
|
|
- as_clause: ($) => seq(
|
|
- ci("As"),
|
|
- field("declared_type", $._type)
|
|
- ),
|
|
+ as_clause: ($) =>
|
|
+ seq(
|
|
+ ci("As"),
|
|
+ choice(
|
|
+ $.object_creation_expression,
|
|
+ field("declared_type", $._type)
|
|
+ )
|
|
+ ),
|
|
|
|
implements_member_clause: ($) =>
|
|
seq(ci("Implements"), commaSep1($._name_reference)),
|
|
@@ -856,7 +895,7 @@ module.exports = grammar({
|
|
|
|
enum_member_declaration: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
field("name", $.identifier),
|
|
optional(seq("=", field("value", $._expression))),
|
|
$._terminator
|
|
@@ -882,6 +921,10 @@ module.exports = grammar({
|
|
prec(10, $.inherits_statement),
|
|
prec(10, $.implements_statement),
|
|
prec(100, $.constructor_declaration),
|
|
+ prec(150, $.external_method_declaration),
|
|
+ prec(160, $.custom_event_declaration),
|
|
+ prec(170, $.abstract_method_declaration),
|
|
+ prec(171, $.abstract_property_declaration),
|
|
// Explicitly add statements that can appear at class level
|
|
prec(200, $.try_statement), // Very high precedence
|
|
prec(200, $.select_statement), // Very high precedence
|
|
@@ -936,33 +979,21 @@ module.exports = grammar({
|
|
variable_declarator: ($) =>
|
|
seq(
|
|
field("name", $.identifier),
|
|
+ optional("?"),
|
|
optional(choice(
|
|
// Array bounds specification
|
|
seq("(", field("bounds", commaSep1($._expression)), ")"),
|
|
// Array rank specification
|
|
$.array_rank_specifier
|
|
)),
|
|
- optional(choice(
|
|
- // Regular type declaration
|
|
- $.as_clause,
|
|
- seq(
|
|
- ci("As"),
|
|
- ci("New"),
|
|
- field("type", $._type),
|
|
- optional(field("arguments", $.argument_list)),
|
|
- optional(field("initializer", choice(
|
|
- $.object_initializer,
|
|
- $.collection_initializer
|
|
- )))
|
|
- )
|
|
- )),
|
|
+ optional($.as_clause),
|
|
optional(seq("=", field("initializer", $._expression)))
|
|
),
|
|
|
|
|
|
field_declaration: ($) =>
|
|
prec.dynamic(-100, seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))),
|
|
commaSep1($.variable_declarator),
|
|
$._terminator
|
|
@@ -970,7 +1001,8 @@ module.exports = grammar({
|
|
|
|
field_variable_declarator: ($) =>
|
|
seq(
|
|
- field("name", $._non_statement_identifier),
|
|
+ field("name", $.identifier),
|
|
+ optional("?"),
|
|
optional($.array_rank_specifier),
|
|
optional($.as_clause),
|
|
optional(seq("=", field("initializer", $._expression)))
|
|
@@ -978,12 +1010,13 @@ module.exports = grammar({
|
|
|
|
property_declaration: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))), // Changed
|
|
ci("Property"),
|
|
field("name", $.identifier),
|
|
optional(field("parameters", $.parameter_list)),
|
|
- $.as_clause,
|
|
+ optional($.as_clause),
|
|
+ optional(seq("=", field("initializer", $._expression))),
|
|
optional($.implements_member_clause),
|
|
optional(seq("=", field("initializer", $._expression))),
|
|
choice(
|
|
@@ -1001,7 +1034,7 @@ module.exports = grammar({
|
|
|
|
property_getter: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))),
|
|
ci("Get"),
|
|
$._block_terminator,
|
|
@@ -1013,7 +1046,7 @@ module.exports = grammar({
|
|
|
|
property_setter: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))),
|
|
ci("Set"),
|
|
optional(seq("(", field("parameter", $.parameter), ")")),
|
|
@@ -1028,7 +1061,7 @@ module.exports = grammar({
|
|
prec(
|
|
1,
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))),
|
|
choice(
|
|
seq(
|
|
@@ -1063,7 +1096,7 @@ module.exports = grammar({
|
|
prec(
|
|
100,
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))),
|
|
$._sub_new,
|
|
optional(field("parameters", $.parameter_list)),
|
|
@@ -1087,7 +1120,7 @@ module.exports = grammar({
|
|
|
|
event_declaration: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))), // Changed
|
|
ci("Event"),
|
|
field("name", $.identifier),
|
|
@@ -1098,7 +1131,7 @@ module.exports = grammar({
|
|
|
|
operator_declaration: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))), // Changed
|
|
ci("Operator"),
|
|
field(
|
|
@@ -1152,7 +1185,7 @@ module.exports = grammar({
|
|
|
|
interface_method_declaration: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))), // Changed
|
|
choice(ci("Sub"), ci("Function")),
|
|
field("name", $.identifier),
|
|
@@ -1164,7 +1197,7 @@ module.exports = grammar({
|
|
|
|
interface_property_declaration: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))), // Changed
|
|
ci("Property"),
|
|
field("name", $.identifier),
|
|
@@ -1175,7 +1208,7 @@ module.exports = grammar({
|
|
|
|
interface_event_declaration: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(field("modifiers", repeat1($.member_modifier))), // Changed
|
|
ci("Event"),
|
|
field("name", $.identifier),
|
|
@@ -1209,7 +1242,7 @@ module.exports = grammar({
|
|
|
|
parameter: ($) =>
|
|
seq(
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
optional(
|
|
field(
|
|
"modifiers",
|
|
@@ -1273,7 +1306,7 @@ module.exports = grammar({
|
|
|
|
declaration_statement: ($) =>
|
|
prec(1, seq( // Add precedence
|
|
- optional(field("attributes", $.attribute_list)),
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
field("modifiers", choice(
|
|
$.local_declaration_modifier,
|
|
repeat1($.local_declaration_modifier)
|
|
@@ -1282,6 +1315,65 @@ module.exports = grammar({
|
|
$._terminator
|
|
)),
|
|
|
|
+ _inline_statements: ($) =>
|
|
+ prec.right(seq($._inline_statement, repeat(seq(":", $._inline_statement)))),
|
|
+
|
|
+ _inline_statement: ($) =>
|
|
+ choice(
|
|
+ alias($.inline_if_statement, $.if_statement),
|
|
+ alias($.inline_assignment_statement, $.assignment_statement),
|
|
+ alias($.inline_return_statement, $.return_statement),
|
|
+ alias($.inline_throw_statement, $.throw_statement),
|
|
+ alias($.inline_goto_statement, $.goto_statement),
|
|
+ alias($.inline_exit_statement, $.exit_statement),
|
|
+ alias($.inline_continue_statement, $.continue_statement),
|
|
+ alias($.inline_call_statement, $.call_statement),
|
|
+ alias($.inline_raiseevent_statement, $.raiseevent_statement),
|
|
+ alias($.inline_expression_statement, $.expression_statement)
|
|
+ ),
|
|
+
|
|
+ inline_assignment_statement: ($) =>
|
|
+ prec.right(
|
|
+ PRECEDENCE.ASSIGNMENT + 1,
|
|
+ seq(
|
|
+ field("left", choice(
|
|
+ $.identifier,
|
|
+ $.member_access_expression,
|
|
+ $.array_access_expression
|
|
+ )),
|
|
+ field(
|
|
+ "operator",
|
|
+ choice("=", "+=", "-=", "*=", "/=", "\\=", "^=", "&=", "<<=", ">>=")
|
|
+ ),
|
|
+ field("right", $._expression)
|
|
+ )
|
|
+ ),
|
|
+ inline_return_statement: ($) => prec.right(1, seq(ci("Return"), optional($._expression))),
|
|
+ inline_throw_statement: ($) => prec.right(1, seq(ci("Throw"), optional($._expression))),
|
|
+ inline_goto_statement: ($) => seq(ci("GoTo"), field("label", $.identifier)),
|
|
+ inline_exit_statement: ($) =>
|
|
+ seq(
|
|
+ ci("Exit"),
|
|
+ choice(ci("Do"), ci("For"), ci("While"), ci("Select"), ci("Sub"), ci("Function"), ci("Property"), ci("Try"))
|
|
+ ),
|
|
+ inline_continue_statement: ($) =>
|
|
+ seq(ci("Continue"), choice(ci("Do"), ci("For"), ci("While"))),
|
|
+ inline_call_statement: ($) => prec.right(1, seq(ci("Call"), $._expression)),
|
|
+ inline_raiseevent_statement: ($) =>
|
|
+ prec.right(1, seq(ci("RaiseEvent"), field("event", $.identifier), optional(field("arguments", $.argument_list)))),
|
|
+ inline_expression_statement: ($) => prec.right(1, $._expression),
|
|
+
|
|
+ inline_if_statement: ($) =>
|
|
+ prec.right(
|
|
+ seq(
|
|
+ ci("If"),
|
|
+ field("condition", $._expression),
|
|
+ ci("Then"),
|
|
+ field("then_statement", $._inline_statements),
|
|
+ optional(seq(ci("Else"), field("else_statement", $._inline_statements)))
|
|
+ )
|
|
+ ),
|
|
+
|
|
expression_statement: ($) => seq($._expression, $._terminator),
|
|
|
|
assignment_statement: ($) =>
|
|
@@ -1301,21 +1393,96 @@ module.exports = grammar({
|
|
$._terminator
|
|
)
|
|
),
|
|
+ custom_event_declaration: ($) =>
|
|
+ seq(
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
+ optional(field("modifiers", repeat1($.member_modifier))),
|
|
+ ci("Custom"),
|
|
+ ci("Event"),
|
|
+ field("name", $.identifier),
|
|
+ $.as_clause,
|
|
+ optional($.implements_member_clause),
|
|
+ $._block_terminator,
|
|
+ repeat($.event_accessor),
|
|
+ ci("End"), ci("Event"),
|
|
+ $._terminator
|
|
+ ),
|
|
+
|
|
+ event_accessor: ($) =>
|
|
+ seq(
|
|
+ choice(ci("AddHandler"), ci("RemoveHandler"), ci("RaiseEvent")),
|
|
+ optional(field("parameters", $.parameter_list)),
|
|
+ $._block_terminator,
|
|
+ repeat($._statement),
|
|
+ ci("End"),
|
|
+ choice(ci("AddHandler"), ci("RemoveHandler"), ci("RaiseEvent")),
|
|
+ $._terminator
|
|
+ ),
|
|
+
|
|
+ _mustoverride_token: ($) => token(prec(11, ci("MustOverride"))),
|
|
+
|
|
+ abstract_method_declaration: ($) =>
|
|
+ seq(
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
+ optional(field("modifiers", repeat1($.member_modifier))),
|
|
+ $._mustoverride_token,
|
|
+ optional(field("modifiers", repeat1($.member_modifier))),
|
|
+ choice(ci("Sub"), ci("Function")),
|
|
+ field("name", $.identifier),
|
|
+ optional(field("type_parameters", $.type_parameter_list)),
|
|
+ optional(field("parameters", $.parameter_list)),
|
|
+ optional($.as_clause),
|
|
+ optional($.implements_member_clause),
|
|
+ $._terminator
|
|
+ ),
|
|
+
|
|
+ abstract_property_declaration: ($) =>
|
|
+ seq(
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
+ optional(field("modifiers", repeat1($.member_modifier))),
|
|
+ $._mustoverride_token,
|
|
+ optional(field("modifiers", repeat1($.member_modifier))),
|
|
+ ci("Property"),
|
|
+ field("name", $.identifier),
|
|
+ optional(field("parameters", $.parameter_list)),
|
|
+ optional($.as_clause),
|
|
+ optional($.implements_member_clause),
|
|
+ $._terminator
|
|
+ ),
|
|
+
|
|
+ external_method_declaration: ($) =>
|
|
+ seq(
|
|
+ repeat(field("attributes", $.attribute_list)),
|
|
+ optional(field("modifiers", repeat1($.member_modifier))),
|
|
+ ci("Declare"),
|
|
+ optional(choice(ci("Auto"), ci("Ansi"), ci("Unicode"))),
|
|
+ choice(ci("Sub"), ci("Function")),
|
|
+ field("name", $.identifier),
|
|
+ ci("Lib"),
|
|
+ field("library", $.string_literal),
|
|
+ optional(seq(ci("Alias"), field("alias", $.string_literal))),
|
|
+ optional(field("parameters", $.parameter_list)),
|
|
+ optional($.as_clause),
|
|
+ $._terminator
|
|
+ ),
|
|
+
|
|
call_statement: ($) => seq(ci("Call"), $._expression, $._terminator),
|
|
|
|
if_statement: ($) =>
|
|
seq(
|
|
ci("If"),
|
|
field("condition", $._expression),
|
|
- ci("Then"),
|
|
choice(
|
|
- // Single-line if
|
|
+ // Single-line if: inline statements, optional Else, one terminator
|
|
seq(
|
|
- field("then_statement", $._statement),
|
|
- optional(seq(ci("Else"), field("else_statement", $._statement)))
|
|
+ ci("Then"),
|
|
+ field("then_statement", $._inline_statements),
|
|
+ optional(seq(ci("Else"), field("else_statement", $._inline_statements))),
|
|
+ $._terminator
|
|
),
|
|
// Multi-line if
|
|
seq(
|
|
+ optional(ci("Then")),
|
|
$._block_terminator,
|
|
field("then_branch", repeat($._statement)),
|
|
repeat($.elseif_clause),
|
|
@@ -1331,7 +1498,7 @@ module.exports = grammar({
|
|
seq(
|
|
ci("ElseIf"),
|
|
field("condition", $._expression),
|
|
- ci("Then"),
|
|
+ optional(ci("Then")),
|
|
$._block_terminator,
|
|
field("body", repeat($._statement))
|
|
),
|
|
@@ -1445,7 +1612,7 @@ module.exports = grammar({
|
|
using_statement: ($) =>
|
|
seq(
|
|
ci("Using"),
|
|
- field("resource", choice($.variable_declarator, $._expression)),
|
|
+ commaSep1(field("resource", choice($.variable_declarator, $._expression))),
|
|
$._block_terminator,
|
|
field("body", repeat($._statement)),
|
|
ci("End"),
|
|
@@ -1590,14 +1757,25 @@ module.exports = grammar({
|
|
$._terminator
|
|
), // LINQ Query expressions
|
|
query_expression: ($) =>
|
|
- seq($.from_clause, repeat($.query_body_clause), $.select_or_group_clause),
|
|
- from_clause: ($) => seq(ci("From"), commaSep1($.collection_range_variable)),
|
|
+ prec.right(
|
|
+ choice(
|
|
+ seq(
|
|
+ $.from_clause,
|
|
+ repeat(seq(optional($._query_clause_continuation), $.query_body_clause)),
|
|
+ optional(seq(optional($._query_clause_continuation), $.select_or_group_clause))
|
|
+ ),
|
|
+ $.aggregate_clause
|
|
+ )
|
|
+ ),
|
|
+ from_clause: ($) => prec.right(seq(ci("From"), commaSep1($.collection_range_variable))),
|
|
collection_range_variable: ($) =>
|
|
- seq(
|
|
- field("variable", $.identifier),
|
|
- optional($.as_clause),
|
|
- ci("In"),
|
|
- field("collection", $._expression)
|
|
+ prec.right(
|
|
+ seq(
|
|
+ field("variable", $.identifier),
|
|
+ optional($.as_clause),
|
|
+ ci("In"),
|
|
+ field("collection", $._expression)
|
|
+ )
|
|
),
|
|
query_body_clause: ($) =>
|
|
choice(
|
|
@@ -1606,48 +1784,62 @@ module.exports = grammar({
|
|
$.where_clause,
|
|
$.join_clause,
|
|
$.order_by_clause,
|
|
- $.aggregate_clause
|
|
- ),
|
|
- let_clause: ($) => seq(ci("Let"), commaSep1($.expression_range_variable)),
|
|
+ $.aggregate_clause,
|
|
+ $.distinct_clause,
|
|
+ $.skip_take_clause
|
|
+ ),
|
|
+ distinct_clause: ($) => ci("Distinct"),
|
|
+ skip_take_clause: ($) =>
|
|
+ prec.right(seq(choice(ci("Skip"), ci("Take")), optional(ci("While")), $._expression)),
|
|
+ let_clause: ($) => prec.right(seq(ci("Let"), commaSep1($.expression_range_variable))),
|
|
expression_range_variable: ($) =>
|
|
- seq(
|
|
+ prec.right(seq(
|
|
field("variable", $.identifier),
|
|
"=",
|
|
field("expression", $._expression)
|
|
- ),
|
|
- where_clause: ($) => seq(ci("Where"), field("condition", $._expression)),
|
|
+ )),
|
|
+ where_clause: ($) =>
|
|
+ prec.right(seq(ci("Where"), field("condition", $._expression))),
|
|
join_clause: ($) =>
|
|
- seq(
|
|
- ci("Join"),
|
|
- $.collection_range_variable,
|
|
- ci("On"),
|
|
- commaSep1($.join_condition)
|
|
+ prec.right(
|
|
+ seq(
|
|
+ ci("Join"),
|
|
+ $.collection_range_variable,
|
|
+ optional($._query_clause_continuation),
|
|
+ ci("On"),
|
|
+ commaSep1($.join_condition)
|
|
+ )
|
|
),
|
|
join_condition: ($) =>
|
|
- seq(
|
|
+ prec.right(seq(
|
|
field("left", $._expression),
|
|
ci("Equals"),
|
|
field("right", $._expression)
|
|
- ),
|
|
- order_by_clause: ($) => seq(ci("Order"), ci("By"), commaSep1($.ordering)),
|
|
+ )),
|
|
+ order_by_clause: ($) => prec.right(seq(ci("Order"), ci("By"), commaSep1($.ordering))),
|
|
ordering: ($) =>
|
|
- seq(
|
|
- field("expression", $._expression),
|
|
- optional(choice(ci("Ascending"), ci("Descending")))
|
|
+ prec.right(
|
|
+ seq(
|
|
+ field("expression", $._expression),
|
|
+ optional(choice(ci("Ascending"), ci("Descending")))
|
|
+ )
|
|
),
|
|
aggregate_clause: ($) =>
|
|
- seq(
|
|
- ci("Aggregate"),
|
|
- $.collection_range_variable,
|
|
- repeat($.query_body_clause),
|
|
- ci("Into"),
|
|
- commaSep1($.aggregate_element)
|
|
+ prec.right(
|
|
+ seq(
|
|
+ ci("Aggregate"),
|
|
+ $.collection_range_variable,
|
|
+ repeat(seq(optional($._query_clause_continuation), $.query_body_clause)),
|
|
+ optional($._query_clause_continuation),
|
|
+ ci("Into"),
|
|
+ commaSep1($.aggregate_element)
|
|
+ )
|
|
),
|
|
aggregate_element: ($) =>
|
|
- seq(
|
|
+ prec.right(seq(
|
|
optional(seq(field("name", $.identifier), "=")),
|
|
field("function", $.aggregate_function)
|
|
- ),
|
|
+ )),
|
|
aggregate_function: ($) =>
|
|
seq(
|
|
field(
|
|
@@ -1668,42 +1860,44 @@ module.exports = grammar({
|
|
select_or_group_clause: ($) => choice($.select_clause, $.group_by_clause),
|
|
select_clause: ($) => seq(ci("Select"), commaSep1($.select_element)),
|
|
select_element: ($) =>
|
|
- choice(
|
|
+ prec.right(choice(
|
|
$._expression,
|
|
seq(
|
|
field("name", $.identifier),
|
|
"=",
|
|
field("expression", $._expression)
|
|
)
|
|
- ),
|
|
+ )),
|
|
group_by_clause: ($) =>
|
|
- seq(
|
|
- ci("Group"),
|
|
- commaSep1($.group_element),
|
|
- ci("By"),
|
|
- commaSep1($.by_element),
|
|
- ci("Into"),
|
|
- commaSep1($.into_element)
|
|
+ prec.right(
|
|
+ seq(
|
|
+ ci("Group"),
|
|
+ commaSep1($.group_element),
|
|
+ ci("By"),
|
|
+ commaSep1($.by_element),
|
|
+ ci("Into"),
|
|
+ commaSep1($.into_element)
|
|
+ )
|
|
),
|
|
group_element: ($) =>
|
|
- choice(
|
|
+ prec.right(choice(
|
|
$._expression,
|
|
seq(
|
|
field("name", $.identifier),
|
|
"=",
|
|
field("expression", $._expression)
|
|
)
|
|
- ),
|
|
+ )),
|
|
by_element: ($) =>
|
|
- choice(
|
|
+ prec.right(choice(
|
|
$._expression,
|
|
seq(
|
|
field("name", $.identifier),
|
|
"=",
|
|
field("expression", $._expression)
|
|
)
|
|
- ),
|
|
- into_element: ($) => choice($.identifier, $.aggregate_element),
|
|
+ )),
|
|
+ into_element: ($) => prec.right(choice($.identifier, $.aggregate_element)),
|
|
|
|
// Comments
|
|
comment: ($) => token(prec(100, choice(
|
|
@@ -1714,7 +1908,7 @@ module.exports = grammar({
|
|
))),
|
|
|
|
// Preprocessor Directives
|
|
- preprocessor_directive: ($) => token(seq("#", /[^\r\n]*/)),
|
|
+ preprocessor_directive: ($) => token(seq("#", /[ \t]*[A-Za-z][^\r\n]*/)),
|
|
},
|
|
});
|
|
|
|
diff --git a/src/scanner.c b/src/scanner.c
|
|
new file mode 100644
|
|
index 0000000..8334fdb
|
|
--- /dev/null
|
|
+++ b/src/scanner.c
|
|
@@ -0,0 +1,303 @@
|
|
+#include "tree_sitter/parser.h"
|
|
+#include <string.h>
|
|
+#include <wctype.h>
|
|
+
|
|
+// External tokens for the two constructs that are not LR(1)-parseable with
|
|
+// tree-sitter's newline-as-extra treatment:
|
|
+//
|
|
+// 1. QUERY_CLAUSE_CONTINUATION — a newline run that CONTINUES a LINQ query
|
|
+// (`From x In xs` ↵ `Where …`). At a clause boundary the parser cannot
|
|
+// know from the newline alone whether the query ends (newline = statement
|
|
+// terminator) or continues (newline = insignificant, next line starts with
|
|
+// a query keyword). The scanner looks past the newline at the next word
|
|
+// and only emits the token when it is a query-clause keyword — so the
|
|
+// terminator/continuation choice is made by the lexer, not the LR table.
|
|
+//
|
|
+// 2. XML_LITERAL — a whole VB XML literal (`<Tags><Tag/></Tags>`, including
|
|
+// `<%= expr %>` embedded expressions, comments, CDATA) consumed as one
|
|
+// opaque token. Only valid where a literal can begin an expression, so a
|
|
+// relational `<` (which always FOLLOWS an expression) can never collide.
|
|
+
|
|
+enum TokenType {
|
|
+ QUERY_CLAUSE_CONTINUATION,
|
|
+ XML_LITERAL,
|
|
+};
|
|
+
|
|
+void *tree_sitter_vbnet_external_scanner_create(void) { return NULL; }
|
|
+void tree_sitter_vbnet_external_scanner_destroy(void *payload) { (void)payload; }
|
|
+unsigned tree_sitter_vbnet_external_scanner_serialize(void *payload, char *buffer) {
|
|
+ (void)payload; (void)buffer;
|
|
+ return 0; // stateless
|
|
+}
|
|
+void tree_sitter_vbnet_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
|
|
+ (void)payload; (void)buffer; (void)length;
|
|
+}
|
|
+
|
|
+static inline void advance(TSLexer *lexer) { lexer->advance(lexer, false); }
|
|
+static inline void skip_ws(TSLexer *lexer) { lexer->advance(lexer, true); }
|
|
+
|
|
+// Read one alphabetic word (advancing past it), lowercased into buf.
|
|
+// Returns its length (0 if the next char is not a letter).
|
|
+static int read_word(TSLexer *lexer, char *buf, int cap) {
|
|
+ int n = 0;
|
|
+ while (iswalpha((wint_t)lexer->lookahead)) {
|
|
+ if (n < cap - 1) buf[n] = (char)towlower((wint_t)lexer->lookahead);
|
|
+ n++;
|
|
+ advance(lexer);
|
|
+ }
|
|
+ buf[n < cap - 1 ? n : cap - 1] = 0;
|
|
+ return n;
|
|
+}
|
|
+
|
|
+static bool is_query_keyword(const char *w) {
|
|
+ static const char *kws[] = {
|
|
+ "where", "select", "order", "group", "join", "let", "skip",
|
|
+ "take", "distinct", "aggregate", "from", "into", "on", NULL,
|
|
+ };
|
|
+ for (int i = 0; kws[i]; i++)
|
|
+ if (strcmp(w, kws[i]) == 0) return true;
|
|
+ return false;
|
|
+}
|
|
+
|
|
+// [ \t\r]* '\n' [ \t\r\n]* followed by a query-clause keyword.
|
|
+// The token covers only the whitespace/newline run (mark_end before the
|
|
+// keyword lookahead), so the clause keyword itself lexes normally after it.
|
|
+static bool scan_query_continuation(TSLexer *lexer) {
|
|
+ bool saw_newline = false;
|
|
+ for (;;) {
|
|
+ int32_t c = lexer->lookahead;
|
|
+ if (c == ' ' || c == '\t' || c == '\r') {
|
|
+ advance(lexer);
|
|
+ } else if (c == '\n') {
|
|
+ saw_newline = true;
|
|
+ advance(lexer);
|
|
+ } else {
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ if (!saw_newline) return false;
|
|
+ lexer->mark_end(lexer);
|
|
+
|
|
+ char w[12];
|
|
+ int n = read_word(lexer, w, sizeof w);
|
|
+ if (n == 0 || n >= (int)(sizeof w)) return false;
|
|
+ if (!is_query_keyword(w)) return false;
|
|
+
|
|
+ // `Select Case` opens a statement, never a select clause.
|
|
+ if (strcmp(w, "select") == 0) {
|
|
+ while (lexer->lookahead == ' ' || lexer->lookahead == '\t') advance(lexer);
|
|
+ char w2[8];
|
|
+ int m = read_word(lexer, w2, sizeof w2);
|
|
+ if (m > 0 && m < (int)(sizeof w2) && strcmp(w2, "case") == 0) return false;
|
|
+ }
|
|
+
|
|
+ lexer->result_symbol = QUERY_CLAUSE_CONTINUATION;
|
|
+ return true;
|
|
+}
|
|
+
|
|
+// Consume a VB string inside an embedded `<%= … %>` region ("" escapes).
|
|
+static void consume_vb_string(TSLexer *lexer) {
|
|
+ advance(lexer); // opening quote
|
|
+ for (;;) {
|
|
+ if (lexer->lookahead == 0) return;
|
|
+ if (lexer->lookahead == '"') {
|
|
+ advance(lexer);
|
|
+ if (lexer->lookahead != '"') return; // closing (not an escaped "")
|
|
+ // escaped quote: fall through, keep consuming
|
|
+ }
|
|
+ advance(lexer);
|
|
+ }
|
|
+}
|
|
+
|
|
+// Consume `<%= … %>` starting at the '%' (the '<' is already consumed).
|
|
+// Embedded expressions NEST (`<%= From t In ts Select <Tag><%= t.Name %></Tag> %>`,
|
|
+// the staxrip WriteTagfile shape), so track <% / %> depth.
|
|
+static bool consume_embedded_expression(TSLexer *lexer) {
|
|
+ advance(lexer); // '%'
|
|
+ int depth = 1;
|
|
+ for (;;) {
|
|
+ int32_t c = lexer->lookahead;
|
|
+ if (c == 0) return false;
|
|
+ if (c == '"') { consume_vb_string(lexer); continue; }
|
|
+ if (c == '<') {
|
|
+ advance(lexer);
|
|
+ if (lexer->lookahead == '%') { depth++; advance(lexer); }
|
|
+ continue;
|
|
+ }
|
|
+ if (c == '%') {
|
|
+ advance(lexer);
|
|
+ if (lexer->lookahead == '>') {
|
|
+ advance(lexer);
|
|
+ if (--depth == 0) return true;
|
|
+ }
|
|
+ continue;
|
|
+ }
|
|
+ advance(lexer);
|
|
+ }
|
|
+}
|
|
+
|
|
+// Consume `<!-- … -->` / `<![CDATA[ … ]]>` / `<!DOCTYPE …>` starting at '!'.
|
|
+static bool consume_bang_construct(TSLexer *lexer) {
|
|
+ advance(lexer); // '!'
|
|
+ if (lexer->lookahead == '-') {
|
|
+ // comment: to -->
|
|
+ int dashes = 0;
|
|
+ for (;;) {
|
|
+ int32_t c = lexer->lookahead;
|
|
+ if (c == 0) return false;
|
|
+ if (c == '-') { dashes++; advance(lexer); continue; }
|
|
+ if (c == '>' && dashes >= 2) { advance(lexer); return true; }
|
|
+ dashes = 0;
|
|
+ advance(lexer);
|
|
+ }
|
|
+ }
|
|
+ if (lexer->lookahead == '[') {
|
|
+ // CDATA: to ]]>
|
|
+ int brackets = 0;
|
|
+ for (;;) {
|
|
+ int32_t c = lexer->lookahead;
|
|
+ if (c == 0) return false;
|
|
+ if (c == ']') { brackets++; advance(lexer); continue; }
|
|
+ if (c == '>' && brackets >= 2) { advance(lexer); return true; }
|
|
+ brackets = 0;
|
|
+ advance(lexer);
|
|
+ }
|
|
+ }
|
|
+ // DOCTYPE-ish: to bare >
|
|
+ for (;;) {
|
|
+ int32_t c = lexer->lookahead;
|
|
+ if (c == 0) return false;
|
|
+ if (c == '>') { advance(lexer); return true; }
|
|
+ advance(lexer);
|
|
+ }
|
|
+}
|
|
+
|
|
+// Consume `<? … ?>` starting at the '?'.
|
|
+static bool consume_processing_instruction(TSLexer *lexer) {
|
|
+ advance(lexer); // '?'
|
|
+ for (;;) {
|
|
+ int32_t c = lexer->lookahead;
|
|
+ if (c == 0) return false;
|
|
+ if (c == '?') {
|
|
+ advance(lexer);
|
|
+ if (lexer->lookahead == '>') { advance(lexer); return true; }
|
|
+ continue;
|
|
+ }
|
|
+ advance(lexer);
|
|
+ }
|
|
+}
|
|
+
|
|
+static bool is_name_start(int32_t c) {
|
|
+ return iswalpha((wint_t)c) || c == '_';
|
|
+}
|
|
+
|
|
+static bool scan_xml_literal(TSLexer *lexer) {
|
|
+ // Only same-line blanks are skipped: a leading newline must stay unconsumed
|
|
+ // so it can serve as a statement/block terminator (a successful scan would
|
|
+ // otherwise swallow it as trivia). XML on a continuation line still works:
|
|
+ // the newline is consumed as an extra first, then the scanner re-runs.
|
|
+ while (lexer->lookahead == ' ' || lexer->lookahead == '\t') skip_ws(lexer);
|
|
+ if (lexer->lookahead != '<') return false;
|
|
+ advance(lexer);
|
|
+ // Only element-start markup opens an XML literal here; comments/PIs as the
|
|
+ // outermost construct (`Dim d = <?xml …`) are rare enough to leave alone,
|
|
+ // and a bare `<` (comparison) never begins an expression.
|
|
+ if (!is_name_start(lexer->lookahead)) return false;
|
|
+
|
|
+ int depth = 0; // open (unclosed) elements
|
|
+ bool in_tag = true; // inside <...> of an element tag
|
|
+ bool closing = false;
|
|
+ int32_t quote = 0;
|
|
+
|
|
+ for (;;) {
|
|
+ int32_t c = lexer->lookahead;
|
|
+ if (c == 0) return false; // unterminated: let the normal parser error
|
|
+
|
|
+ if (in_tag) {
|
|
+ if (quote) {
|
|
+ if (c == quote) quote = 0;
|
|
+ advance(lexer);
|
|
+ continue;
|
|
+ }
|
|
+ if (c == '"' || c == '\'') { quote = c; advance(lexer); continue; }
|
|
+ if (c == '<') {
|
|
+ advance(lexer);
|
|
+ if (lexer->lookahead == '%') {
|
|
+ // attribute value embedded expression: attr=<%= x %>
|
|
+ if (!consume_embedded_expression(lexer)) return false;
|
|
+ continue;
|
|
+ }
|
|
+ continue; // stray < in a tag: malformed, keep consuming
|
|
+ }
|
|
+ if (c == '/') {
|
|
+ advance(lexer);
|
|
+ if (lexer->lookahead == '>') {
|
|
+ // self-closing tag
|
|
+ advance(lexer);
|
|
+ in_tag = false;
|
|
+ if (depth == 0) break; // single self-closed root: done
|
|
+ continue;
|
|
+ }
|
|
+ continue;
|
|
+ }
|
|
+ if (c == '>') {
|
|
+ advance(lexer);
|
|
+ if (closing) {
|
|
+ depth--;
|
|
+ if (depth <= 0) break; // root element closed: done
|
|
+ } else {
|
|
+ depth++;
|
|
+ }
|
|
+ in_tag = false;
|
|
+ continue;
|
|
+ }
|
|
+ advance(lexer);
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ // text content between tags
|
|
+ if (c == '<') {
|
|
+ advance(lexer);
|
|
+ int32_t d = lexer->lookahead;
|
|
+ if (d == '/') { advance(lexer); closing = true; in_tag = true; continue; }
|
|
+ if (d == '%') {
|
|
+ if (!consume_embedded_expression(lexer)) return false;
|
|
+ continue;
|
|
+ }
|
|
+ if (d == '!') {
|
|
+ if (!consume_bang_construct(lexer)) return false;
|
|
+ continue;
|
|
+ }
|
|
+ if (d == '?') {
|
|
+ if (!consume_processing_instruction(lexer)) return false;
|
|
+ continue;
|
|
+ }
|
|
+ closing = false;
|
|
+ in_tag = true; // opening tag
|
|
+ continue;
|
|
+ }
|
|
+ advance(lexer);
|
|
+ }
|
|
+
|
|
+ lexer->mark_end(lexer);
|
|
+ lexer->result_symbol = XML_LITERAL;
|
|
+ return true;
|
|
+}
|
|
+
|
|
+bool tree_sitter_vbnet_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
|
|
+ (void)payload;
|
|
+ int32_t c = lexer->lookahead;
|
|
+ bool ws = (c == ' ' || c == '\t' || c == '\n' || c == '\r');
|
|
+
|
|
+ // A scan attempt advances the lexer, so exactly ONE attempt runs per
|
|
+ // invocation — never chain a second attempt after a failed first (its
|
|
+ // reads would start mid-stream). The leading character picks the branch;
|
|
+ // a false return discards the attempt entirely.
|
|
+ if (valid_symbols[QUERY_CLAUSE_CONTINUATION] && ws) {
|
|
+ return scan_query_continuation(lexer);
|
|
+ }
|
|
+ if (valid_symbols[XML_LITERAL] && (c == '<' || ws)) {
|
|
+ return scan_xml_literal(lexer);
|
|
+ }
|
|
+ return false;
|
|
+}
|