rbs 4.1.0 → 4.2.0

data/src/parser.c

@@ -124,6 +124,7 @@ typedef struct {
     rbs_hash_t *required_keywords;
     rbs_hash_t *optional_keywords;
     rbs_node_t *rest_keywords;
+    rbs_node_t *forwarding;
 } method_params;
 
 /**
@@ -183,7 +184,7 @@ static void parser_advance_no_gap(rbs_parser_t *parser) {
               | {(tUIDENT `::`)*} <tXIDENT>
               | {<tXIDENT>}
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_type_name(rbs_parser_t *parser, TypeNameKind kind, rbs_range_t *rg, rbs_type_name_t **type_name) {
     bool absolute = false;
 
@@ -267,7 +268,7 @@ error_handling: {
   type_list ::= {} type `,` ... <`,`> eol
               | {} type `,` ... `,` <type> eol
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_type_list(rbs_parser_t *parser, enum RBSTokenType eol, rbs_node_list_t *types, bool void_allowed, bool self_allowed, bool classish_allowed) {
     while (true) {
         rbs_node_t *type;
@@ -297,7 +298,7 @@ static bool parse_type_list(rbs_parser_t *parser, enum RBSTokenType eol, rbs_nod
   type_list_with_commas ::= {} type `,` ... <`,`> eol
                           | {} type `,` ... `,` <type> eol
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_type_list_with_commas(rbs_parser_t *parser, enum RBSTokenType eol, rbs_node_list_t *types, rbs_location_range_list_t *comma_locations, bool void_allowed, bool self_allowed, bool classish_allowed) {
     while (true) {
         rbs_node_t *type;
@@ -336,6 +337,7 @@ static bool is_keyword_token(enum RBSTokenType type) {
     case tUIDENT:
     case tULIDENT:
     case tULLIDENT:
+    case tNONASCIIIDENT:
     case tQIDENT:
     case tBANGIDENT:
         KEYWORD_CASES
@@ -345,11 +347,20 @@ static bool is_keyword_token(enum RBSTokenType type) {
     }
 }
 
+/**
+ * Ruby lets a local variable name open with a character outside ASCII, and a
+ * parameter name is a local variable name. Nothing here reads the case of that
+ * character, so both spellings are a name.
+ * */
+static bool is_param_name_token(enum RBSTokenType type) {
+    return type == tLIDENT || type == tNONASCIIIDENT;
+}
+
 /*
   function_param ::= {} <type>
                    | {} type <param>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_function_param(rbs_parser_t *parser, rbs_types_function_param_t **function_param, bool self_allowed, bool classish_allowed) {
     rbs_range_t type_range;
     type_range.start = parser->next_token.range.start;
@@ -401,22 +412,25 @@ static rbs_constant_id_t intern_token_start_end(rbs_parser_t *parser, rbs_token_
   keyword_key ::= {} <keyword> `:`
                 | {} keyword <`?`> `:`
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_keyword_key(rbs_parser_t *parser, rbs_ast_symbol_t **key) {
     rbs_parser_advance(parser);
 
-    rbs_location_range symbol_range = rbs_location_range_current_token(parser);
+    rbs_range_t symbol_range = parser->current_token.range;
 
     if (parser->next_token.type == pQUESTION) {
+        // The `?` is part of the key, so it is part of the location too.
+        symbol_range.end = parser->next_token.range.end;
+
         *key = rbs_ast_symbol_new(
             ALLOCATOR(),
-            symbol_range,
+            RBS_RANGE_LEX2AST(symbol_range),
             &parser->constant_pool,
             intern_token_start_end(parser, parser->current_token, parser->next_token)
         );
         rbs_parser_advance(parser);
     } else {
-        *key = rbs_ast_symbol_new(ALLOCATOR(), symbol_range, &parser->constant_pool, INTERN_TOKEN(parser, parser->current_token));
+        *key = rbs_ast_symbol_new(ALLOCATOR(), RBS_RANGE_LEX2AST(symbol_range), &parser->constant_pool, INTERN_TOKEN(parser, parser->current_token));
     }
 
     return true;
@@ -425,7 +439,7 @@ static bool parse_keyword_key(rbs_parser_t *parser, rbs_ast_symbol_t **key) {
 /*
   keyword ::= {} keyword `:` <function_param>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_keyword(rbs_parser_t *parser, rbs_hash_t *keywords, rbs_hash_t *memo, bool self_allowed, bool classish_allowed) {
     rbs_ast_symbol_t *key = NULL;
     CHECK_PARSE(parse_keyword_key(parser, &key));
@@ -484,10 +498,12 @@ static bool parser_advance_if(rbs_parser_t *parser, enum RBSTokenType type) {
 /*
   params ::= {} `)`
            | {} `?` `)`               -- Untyped function params (assign params.required = nil)
+           | {} `...` `)`             -- Forwarding params
            | <required_params> `)`
            | <required_params> `,` `)`
 
   required_params ::= {} function_param `,` <required_params>
+                    | {} function_param `,` `...`
                     | {} <function_param>
                     | {} <optional_params>
 
@@ -510,8 +526,8 @@ static bool parser_advance_if(rbs_parser_t *parser, enum RBSTokenType type) {
              | {} `?` <optional_keyword>
              | {} `**` <function_param>
 */
-NODISCARD
-static bool parse_params(rbs_parser_t *parser, method_params *params, bool self_allowed, bool classish_allowed) {
+RBS_NODISCARD
+static bool parse_params(rbs_parser_t *parser, method_params *params, bool forwarding_allowed, bool self_allowed, bool classish_allowed) {
     if (parser->next_token.type == pQUESTION && parser->next_token2.type == pRPAREN) {
         params->required_positionals = NULL;
         rbs_parser_advance(parser);
@@ -534,6 +550,24 @@ static bool parse_params(rbs_parser_t *parser, method_params *params, bool self_
         case pRPAREN:
             goto EOP;
 
+        case pDOT3: {
+            if (!forwarding_allowed) {
+                rbs_parser_set_error(parser, parser->next_token, true, "forwarding parameter is not allowed in this context");
+                return false;
+            }
+
+            if (!parser->options.enable_forwarding_params) {
+                rbs_parser_set_error(parser, parser->next_token, true, "forwarding parameter syntax is not enabled");
+                return false;
+            }
+
+            rbs_parser_advance(parser);
+            params->forwarding = (rbs_node_t *) rbs_types_function_forwarding_param_new(
+                ALLOCATOR(),
+                rbs_location_range_current_token(parser)
+            );
+            goto EOP;
+        }
         default:
             if (is_keyword(parser)) {
                 goto PARSE_KEYWORDS;
@@ -645,6 +679,7 @@ PARSE_KEYWORDS:
         case tQIDENT:
         case tULIDENT:
         case tULLIDENT:
+        case tNONASCIIIDENT:
         case tBANGIDENT:
             KEYWORD_CASES
             if (is_keyword(parser)) {
@@ -677,7 +712,7 @@ EOP:
   optional ::= {} <simple_type>
              | {} simple_type <`?`>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_optional(rbs_parser_t *parser, rbs_node_t **optional, bool void_allowed, bool self_allowed, bool classish_allowed) {
     rbs_range_t rg;
     rg.start = parser->next_token.range.start;
@@ -710,6 +745,7 @@ static void initialize_method_params(method_params *params, rbs_allocator_t *all
         .required_keywords = rbs_hash_new(allocator),
         .optional_keywords = rbs_hash_new(allocator),
         .rest_keywords = NULL,
+        .forwarding = NULL,
     };
 }
 
@@ -717,7 +753,7 @@ static void initialize_method_params(method_params *params, rbs_allocator_t *all
   self_type_binding ::= {} <>
                       | {} `[` `self` `:` type <`]`>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_self_type_binding(rbs_parser_t *parser, rbs_node_t **self_type, bool self_allowed, bool classish_allowed) {
     if (parser->next_token.type == pLBRACKET) {
         rbs_parser_advance(parser);
@@ -745,8 +781,8 @@ typedef struct {
              | {} self_type_binding? `{` self_type_binding `->` optional `}` `->` <optional>
              | {} self_type_binding? `->` <optional>
 */
-NODISCARD
-static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool block_allowed, parse_function_result **result, bool self_allowed, bool classish_allowed) {
+RBS_NODISCARD
+static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool block_allowed, bool forwarding_allowed, parse_function_result **result, bool self_allowed, bool classish_allowed) {
     rbs_node_t *function = NULL;
     rbs_types_block_t *block = NULL;
     rbs_node_t *function_self_type = NULL;
@@ -758,7 +794,7 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool
 
     if (parser->next_token.type == pLPAREN) {
         rbs_parser_advance(parser);
-        CHECK_PARSE(parse_params(parser, &params, self_allowed, classish_allowed));
+        CHECK_PARSE(parse_params(parser, &params, forwarding_allowed, self_allowed, classish_allowed));
         ADVANCE_ASSERT(parser, pRPAREN);
     }
 
@@ -776,8 +812,14 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool
 
     bool required = true;
     rbs_range_t block_range;
+    bool has_block = parser->next_token.type == pLBRACE || (parser->next_token.type == pQUESTION && parser->next_token2.type == pLBRACE);
 
-    if (!block_allowed && (parser->next_token.type == pLBRACE || (parser->next_token.type == pQUESTION && parser->next_token2.type == pLBRACE))) {
+    if (params.forwarding && has_block) {
+        rbs_parser_set_error(parser, parser->next_token, true, "method type with forwarding parameter cannot have block");
+        return false;
+    }
+
+    if (!block_allowed && has_block) {
         rbs_parser_set_error(parser, parser->next_token, true, "block is not allowed in this context");
         return false;
     }
@@ -799,7 +841,7 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool
 
         if (parser->next_token.type == pLPAREN) {
             rbs_parser_advance(parser);
-            CHECK_PARSE(parse_params(parser, &block_params, self_allowed, classish_allowed));
+            CHECK_PARSE(parse_params(parser, &block_params, false, self_allowed, classish_allowed));
             ADVANCE_ASSERT(parser, pRPAREN);
         }
 
@@ -828,6 +870,7 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool
                 block_params.required_keywords,
                 block_params.optional_keywords,
                 block_params.rest_keywords,
+                block_params.forwarding,
                 block_return_type
             );
         }
@@ -853,6 +896,7 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool
             params.required_keywords,
             params.optional_keywords,
             params.rest_keywords,
+            params.forwarding,
             type
         );
     }
@@ -866,11 +910,11 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, bool
 /*
   proc_type ::= {`^`} <function>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_proc_type(rbs_parser_t *parser, rbs_types_proc_t **proc, bool self_allowed, bool classish_allowed) {
     rbs_position_t start = parser->current_token.range.start;
     parse_function_result *result = rbs_allocator_alloc(ALLOCATOR(), parse_function_result);
-    CHECK_PARSE(parse_function(parser, true, true, &result, self_allowed, classish_allowed));
+    CHECK_PARSE(parse_function(parser, true, true, false, &result, self_allowed, classish_allowed));
 
     rbs_position_t end = parser->current_token.range.end;
     rbs_location_range range = { .start_char = start.char_pos, .start_byte = start.byte_pos, .end_char = end.char_pos, .end_byte = end.byte_pos };
@@ -894,7 +938,7 @@ static void check_key_duplication(rbs_parser_t *parser, rbs_hash_t *fields, rbs_
   record_attribute ::= {} keyword_token `:` <type>
                      | {} literal_type `=>` <type>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_record_attributes(rbs_parser_t *parser, rbs_hash_t **fields, bool self_allowed, bool classish_allowed) {
     *fields = rbs_hash_new(ALLOCATOR());
 
@@ -964,7 +1008,7 @@ static bool parse_record_attributes(rbs_parser_t *parser, rbs_hash_t **fields, b
 /*
   symbol ::= {<tSYMBOL>}
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_symbol(rbs_parser_t *parser, rbs_location_range location, rbs_types_literal_t **symbol) {
     size_t offset_bytes = parser->lexer->encoding->char_width((const uint8_t *) ":", (size_t) 1);
     size_t bytes = rbs_token_bytes(parser->current_token) - offset_bytes;
@@ -1013,7 +1057,7 @@ static bool parse_symbol(rbs_parser_t *parser, rbs_location_range location, rbs_
  type_args ::= {} <> /empty/
              | {} `[` type_list <`]`>
  */
-NODISCARD
+RBS_NODISCARD
 static bool parse_instance_type(rbs_parser_t *parser, bool parse_alias, rbs_node_t **type) {
     TypeNameKind expected_kind = (TypeNameKind) (INTERFACE_NAME | CLASS_NAME);
     if (parse_alias) {
@@ -1085,7 +1129,7 @@ static bool parse_instance_type(rbs_parser_t *parser, bool parse_alias, rbs_node
 /*
   singleton_type ::= {`singleton`} `(` type_name <`)`> type_args?
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_singleton_type(rbs_parser_t *parser, rbs_types_class_singleton_t **singleton, bool self_allowed, bool classish_allowed) {
     ASSERT_TOKEN(parser, kSINGLETON);
 
@@ -1153,7 +1197,7 @@ static bool parser_typevar_member(rbs_parser_t *parser, rbs_constant_id_t id) {
            | {} `{` record_attributes <`}`>
            | {} `^` <function>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed, bool self_allowed, bool classish_allowed) {
     rbs_parser_advance(parser);
 
@@ -1349,7 +1393,7 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type, bool void_allo
   intersection ::= {} optional `&` ... '&' <optional>
                  | {} <optional>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_intersection(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed, bool self_allowed, bool classish_allowed) {
     rbs_range_t rg;
     rg.start = parser->next_token.range.start;
@@ -1424,7 +1468,7 @@ bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed,
 
   type_param ::= tUIDENT upper_bound? lower_bound? default_type?                           (module_type_params == false)
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_type_params(rbs_parser_t *parser, rbs_range_t *rg, bool module_type_params, rbs_node_list_t **params) {
     *params = rbs_node_list_new(ALLOCATOR());
 
@@ -1564,7 +1608,7 @@ static bool parse_type_params(rbs_parser_t *parser, rbs_range_t *rg, bool module
     return true;
 }
 
-NODISCARD
+RBS_NODISCARD
 static bool parser_pop_typevar_table(rbs_parser_t *parser) {
     id_table *table;
 
@@ -1587,7 +1631,7 @@ static bool parser_pop_typevar_table(rbs_parser_t *parser) {
 /*
   method_type ::= {} type_params <function>
   */
-// TODO: Should this be NODISCARD?
+// TODO: Should this be RBS_NODISCARD?
 bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type, bool require_eof, bool classish_allowed) {
     rbs_parser_push_typevar_table(parser, false);
 
@@ -1602,7 +1646,7 @@ bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type
     type_range.start = parser->next_token.range.start;
 
     parse_function_result *result = rbs_allocator_alloc(ALLOCATOR(), parse_function_result);
-    CHECK_PARSE(parse_function(parser, false, true, &result, true, classish_allowed));
+    CHECK_PARSE(parse_function(parser, false, true, true, &result, true, classish_allowed));
 
     CHECK_PARSE(parser_pop_typevar_table(parser));
 
@@ -1626,7 +1670,7 @@ bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type
 /*
   global_decl ::= {tGIDENT} `:` <type>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_global_decl(rbs_parser_t *parser, rbs_node_list_t *annotations, rbs_ast_declarations_global_t **global) {
     rbs_range_t decl_range;
     decl_range.start = parser->current_token.range.start;
@@ -1651,7 +1695,7 @@ static bool parse_global_decl(rbs_parser_t *parser, rbs_node_list_t *annotations
 /*
   const_decl ::= {const_name} `:` <type>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_const_decl(rbs_parser_t *parser, rbs_node_list_t *annotations, rbs_ast_declarations_constant_t **constant) {
     rbs_range_t decl_range;
 
@@ -1677,7 +1721,7 @@ static bool parse_const_decl(rbs_parser_t *parser, rbs_node_list_t *annotations,
 /*
   type_decl ::= {kTYPE} alias_name `=` <type>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_type_decl(rbs_parser_t *parser, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_ast_declarations_type_alias_t **typealias) {
     rbs_parser_push_typevar_table(parser, true);
 
@@ -1717,7 +1761,7 @@ static bool parse_type_decl(rbs_parser_t *parser, rbs_position_t comment_pos, rb
 /*
   annotation ::= {<tANNOTATION>}
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_annotation(rbs_parser_t *parser, rbs_ast_annotation_t **annotation) {
     rbs_range_t rg = parser->current_token.range;
 
@@ -1777,7 +1821,7 @@ static bool parse_annotation(rbs_parser_t *parser, rbs_ast_annotation_t **annota
   annotations ::= {} annotation ... <annotation>
                 | {<>}
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_annotations(rbs_parser_t *parser, rbs_node_list_t *annotations, rbs_position_t *annot_pos) {
     *annot_pos = NullPosition;
 
@@ -1804,7 +1848,7 @@ static bool parse_annotations(rbs_parser_t *parser, rbs_node_list_t *annotations
   method_name ::= {} <IDENT | keyword>
                 | {} (IDENT | keyword)~<`?`>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_method_name(rbs_parser_t *parser, rbs_range_t *range, rbs_ast_symbol_t **symbol) {
     rbs_parser_advance(parser);
 
@@ -1813,6 +1857,7 @@ static bool parse_method_name(rbs_parser_t *parser, rbs_range_t *range, rbs_ast_
     case tLIDENT:
     case tULIDENT:
     case tULLIDENT:
+    case tNONASCIIIDENT:
         KEYWORD_CASES
         if (parser->next_token.type == pQUESTION && parser->current_token.range.end.byte_pos == parser->next_token.range.start.byte_pos) {
             range->start = parser->current_token.range.start;
@@ -1922,7 +1967,7 @@ static InstanceSingletonKind parse_instance_singleton_kind(rbs_parser_t *parser,
  * @param instance_only `true` to reject singleton method definition.
  * @param accept_overload `true` to accept overloading (...) definition.
  * */
-NODISCARD
+RBS_NODISCARD
 static bool parse_member_def(rbs_parser_t *parser, bool instance_only, bool accept_overload, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_ast_members_method_definition_t **method_definition) {
     rbs_range_t member_range;
     member_range.start = parser->current_token.range.start;
@@ -2070,7 +2115,7 @@ static bool parse_member_def(rbs_parser_t *parser, bool instance_only, bool acce
  *
  * @param kind
  * */
-NODISCARD
+RBS_NODISCARD
 static bool class_instance_name(rbs_parser_t *parser, TypeNameKind kind, rbs_node_list_t *args, rbs_range_t *name_range, rbs_range_t *args_range, rbs_type_name_t **name, bool classish_allowed) {
     rbs_parser_advance(parser);
 
@@ -2098,7 +2143,7 @@ static bool class_instance_name(rbs_parser_t *parser, TypeNameKind kind, rbs_nod
  *
  * @param from_interface `true` when the member is in an interface.
  * */
-NODISCARD
+RBS_NODISCARD
 static bool parse_mixin_member(rbs_parser_t *parser, bool from_interface, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_node_t **mixin_member) {
     rbs_range_t member_range;
     member_range.start = parser->current_token.range.start;
@@ -2189,7 +2234,7 @@ static bool parse_mixin_member(rbs_parser_t *parser, bool from_interface, rbs_po
  *
  * @param[in] instance_only `true` to reject `self.` alias.
  * */
-NODISCARD
+RBS_NODISCARD
 static bool parse_alias_member(rbs_parser_t *parser, bool instance_only, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_ast_members_alias_t **alias_member) {
     rbs_range_t member_range;
     member_range.start = parser->current_token.range.start;
@@ -2240,7 +2285,7 @@ static bool parse_alias_member(rbs_parser_t *parser, bool instance_only, rbs_pos
                     | {kSELF} `.` tAIDENT `:` <type>
                     | {tA2IDENT} `:` <type>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_variable_member(rbs_parser_t *parser, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_node_t **variable_member) {
     if (annotations->length > 0) {
         rbs_parser_set_error(parser, parser->current_token, true, "annotation cannot be given to variable members");
@@ -2344,7 +2389,7 @@ static bool parse_variable_member(rbs_parser_t *parser, rbs_position_t comment_p
   visibility_member ::= {<`public`>}
                       | {<`private`>}
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_visibility_member(rbs_parser_t *parser, rbs_node_list_t *annotations, rbs_node_t **visibility_member) {
     if (annotations->length > 0) {
         rbs_parser_set_error(parser, parser->current_token, true, "annotation cannot be given to visibility members");
@@ -2382,7 +2427,7 @@ static bool parse_visibility_member(rbs_parser_t *parser, rbs_node_list_t *annot
              | `(` tAIDENT `)`    # Ivar name
              | `(` `)`            # No variable
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_attribute_member(rbs_parser_t *parser, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_node_t **attribute_member) {
     rbs_range_t member_range;
 
@@ -2511,7 +2556,7 @@ static bool parse_attribute_member(rbs_parser_t *parser, rbs_position_t comment_
                      | mixin_member   (interface only)
                      | alias_member   (instance only)
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_interface_members(rbs_parser_t *parser, rbs_node_list_t **members) {
     *members = rbs_node_list_new(ALLOCATOR());
 
@@ -2559,7 +2604,7 @@ static bool parse_interface_members(rbs_parser_t *parser, rbs_node_list_t **memb
 /*
   interface_decl ::= {`interface`} interface_name module_type_params interface_members <kEND>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_interface_decl(rbs_parser_t *parser, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_ast_declarations_interface_t **interface_decl) {
     rbs_parser_push_typevar_table(parser, true);
 
@@ -2603,7 +2648,7 @@ static bool parse_interface_decl(rbs_parser_t *parser, rbs_position_t comment_po
   module_self_type ::= <module_name>
                      | module_name `[` type_list <`]`>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_module_self_types(rbs_parser_t *parser, rbs_node_list_t *array) {
     while (true) {
         rbs_parser_advance(parser);
@@ -2642,7 +2687,7 @@ static bool parse_module_self_types(rbs_parser_t *parser, rbs_node_list_t *array
     return true;
 }
 
-NODISCARD
+RBS_NODISCARD
 static bool parse_nested_decl(rbs_parser_t *parser, const char *nested_in, rbs_position_t annot_pos, rbs_node_list_t *annotations, rbs_node_t **decl);
 
 /*
@@ -2656,7 +2701,7 @@ static bool parse_nested_decl(rbs_parser_t *parser, const char *nested_in, rbs_p
                   | `public`
                   | `private`
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_module_members(rbs_parser_t *parser, rbs_node_list_t **members) {
     *members = rbs_node_list_new(ALLOCATOR());
 
@@ -2743,7 +2788,7 @@ static bool parse_module_members(rbs_parser_t *parser, rbs_node_list_t **members
   module_decl ::= {module_name} module_type_params module_members <kEND>
                 | {module_name} module_name module_type_params `:` module_self_types module_members <kEND>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_module_decl0(rbs_parser_t *parser, rbs_range_t keyword_range, rbs_type_name_t *module_name, rbs_range_t name_range, rbs_ast_comment_t *comment, rbs_node_list_t *annotations, rbs_ast_declarations_module_t **module_decl) {
     rbs_parser_push_typevar_table(parser, true);
 
@@ -2791,7 +2836,7 @@ static bool parse_module_decl0(rbs_parser_t *parser, rbs_range_t keyword_range,
                 | {`module`} module_name module_decl0 <kEND>
 
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_module_decl(rbs_parser_t *parser, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_node_t **module_decl) {
     rbs_range_t keyword_range = parser->current_token.range;
 
@@ -2834,7 +2879,7 @@ static bool parse_module_decl(rbs_parser_t *parser, rbs_position_t comment_pos,
   class_decl_super ::= {} `<` <class_instance_name>
                      | {<>}
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_class_decl_super(rbs_parser_t *parser, rbs_range_t *lt_range, rbs_ast_declarations_class_super_t **super) {
     if (parser_advance_if(parser, pLT)) {
         *lt_range = parser->current_token.range;
@@ -2862,7 +2907,7 @@ static bool parse_class_decl_super(rbs_parser_t *parser, rbs_range_t *lt_range,
 /*
   class_decl ::= {class_name} type_params class_decl_super class_members <`end`>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_class_decl0(rbs_parser_t *parser, rbs_range_t keyword_range, rbs_type_name_t *name, rbs_range_t name_range, rbs_ast_comment_t *comment, rbs_node_list_t *annotations, rbs_ast_declarations_class_t **class_decl) {
     rbs_parser_push_typevar_table(parser, true);
 
@@ -2901,7 +2946,7 @@ static bool parse_class_decl0(rbs_parser_t *parser, rbs_range_t keyword_range, r
   class_decl ::= {`class`} class_name `=` <class_name>
                | {`class`} class_name <class_decl0>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_class_decl(rbs_parser_t *parser, rbs_position_t comment_pos, rbs_node_list_t *annotations, rbs_node_t **class_decl) {
     rbs_range_t keyword_range = parser->current_token.range;
 
@@ -2946,7 +2991,7 @@ static bool parse_class_decl(rbs_parser_t *parser, rbs_position_t comment_pos, r
                 | {<module_decl>}
                 | {<class_decl>}
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_nested_decl(rbs_parser_t *parser, const char *nested_in, rbs_position_t annot_pos, rbs_node_list_t *annotations, rbs_node_t **decl) {
     rbs_parser_push_typevar_table(parser, true);
 
@@ -2998,7 +3043,7 @@ static bool parse_nested_decl(rbs_parser_t *parser, const char *nested_in, rbs_p
     return true;
 }
 
-NODISCARD
+RBS_NODISCARD
 static bool parse_decl(rbs_parser_t *parser, rbs_node_t **decl) {
     rbs_node_list_t *annotations = rbs_node_list_new(ALLOCATOR());
     rbs_position_t annot_pos = NullPosition;
@@ -3054,7 +3099,7 @@ static bool parse_decl(rbs_parser_t *parser, rbs_node_t **decl) {
   namespace ::= {} (`::`)? (`tUIDENT` `::`)* `tUIDENT` <`::`>
               | {} <>                                            (empty -- returns empty namespace)
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_namespace(rbs_parser_t *parser, rbs_range_t *rg, rbs_namespace_t **out_ns) {
     bool is_absolute = false;
 
@@ -3097,7 +3142,7 @@ static bool parse_namespace(rbs_parser_t *parser, rbs_range_t *rg, rbs_namespace
                | {} namespace tUIDENT `as` <tUIDENT>
                | {} namespace <tSTAR>
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_use_clauses(rbs_parser_t *parser, rbs_node_list_t *clauses) {
     while (true) {
         rbs_range_t namespace_range = NULL_RANGE;
@@ -3178,7 +3223,7 @@ static bool parse_use_clauses(rbs_parser_t *parser, rbs_node_list_t *clauses) {
 /*
   use_directive ::= {} `use` <clauses>
  */
-NODISCARD
+RBS_NODISCARD
 static bool parse_use_directive(rbs_parser_t *parser, rbs_ast_directives_use_t **use_directive) {
     if (parser->next_token.type == kUSE) {
         rbs_parser_advance(parser);
@@ -3396,7 +3441,7 @@ void rbs_parser_push_typevar_table(rbs_parser_t *parser, bool reset) {
     parser->vars = table;
 }
 
-NODISCARD
+RBS_NODISCARD
 bool rbs_parser_insert_typevar(rbs_parser_t *parser, rbs_constant_id_t id) {
     id_table *table = parser->vars;
 
@@ -3511,21 +3556,36 @@ rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *allocator, rbs_string_t string, cons
         lexer->current_character_bytes = 1;
     }
 
-    if (start_pos > 0) {
-        while (lexer->current.byte_pos < start_pos) {
-            rbs_skip(lexer);
-        }
+    // `rbs_skip` moves a whole character at a time, and moves nothing at all
+    // once the input is spent, so this walk can only ever stand on the first
+    // byte of a character.
+    while (lexer->current.byte_pos < start_pos && lexer->current_code_point != '\0') {
+        rbs_skip(lexer);
     }
 
+    // Stopping anywhere else means `start_pos` is a position the lexer cannot
+    // start from: over it, and the walk stepped across a character that
+    // straddles it; short of it, and the input ran out first.
+    if (lexer->current.byte_pos != start_pos) return NULL;
+
     lexer->start = lexer->current;
 
     return lexer;
 }
 
 rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos) {
+    return rbs_parser_new_with_options(string, encoding, start_pos, end_pos, (rbs_parser_options_t) { 0 });
+}
+
+rbs_parser_t *rbs_parser_new_with_options(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos, rbs_parser_options_t options) {
     rbs_allocator_t *allocator = rbs_allocator_init();
 
     rbs_lexer_t *lexer = rbs_lexer_new(allocator, string, encoding, start_pos, end_pos);
+    if (lexer == NULL) {
+        rbs_allocator_free(allocator);
+        return NULL;
+    }
+
     rbs_parser_t *parser = rbs_allocator_alloc(allocator, rbs_parser_t);
 
     *parser = (rbs_parser_t) {
@@ -3542,6 +3602,8 @@ rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding
         .constant_pool = { 0 },
         .allocator = allocator,
         .error = NULL,
+
+        .options = options,
     };
 
     // The parser's constant pool is mainly used for storing the names of type variables, which usually aren't many.
@@ -3602,7 +3664,7 @@ void rbs_parser_set_error(rbs_parser_t *parser, rbs_token_t tok, bool syntax_err
 /*
   parse_method_overload ::= {} annotations <method_type>
  */
-NODISCARD
+RBS_NODISCARD
 static bool parse_method_overload(rbs_parser_t *parser, rbs_node_list_t *annotations, rbs_method_type_t **method_type) {
     rbs_position_t pos = NullPosition;
 
@@ -3619,7 +3681,7 @@ static bool parse_method_overload(rbs_parser_t *parser, rbs_node_list_t *annotat
                            | {} overload `|` ... `|` `...`        -- returns true (dot3_location is set)
                            | {<>}                                 -- returns false
 */
-NODISCARD
+RBS_NODISCARD
 static bool parse_inline_method_overloads(rbs_parser_t *parser, rbs_node_list_t *overloads, rbs_location_range_list_t *bar_locations, rbs_location_range *dot3_location) {
     while (true) {
         rbs_node_list_t *annotations = rbs_node_list_new(ALLOCATOR());
@@ -3658,7 +3720,7 @@ static bool parse_inline_method_overloads(rbs_parser_t *parser, rbs_node_list_t
     }
 }
 
-NODISCARD
+RBS_NODISCARD
 static bool parse_inline_comment(rbs_parser_t *parser, rbs_location_range *comment_range) {
     if (parser->next_token.type != tINLINECOMMENT) {
         *comment_range = RBS_LOCATION_NULL_RANGE;
@@ -3671,7 +3733,7 @@ static bool parse_inline_comment(rbs_parser_t *parser, rbs_location_range *comme
     return true;
 }
 
-NODISCARD
+RBS_NODISCARD
 static bool parse_inline_param_type_annotation(rbs_parser_t *parser, rbs_ast_ruby_annotations_t **annotation, rbs_range_t rbs_range) {
     rbs_parser_advance(parser);
 
@@ -3711,7 +3773,7 @@ static bool parse_inline_param_type_annotation(rbs_parser_t *parser, rbs_ast_rub
     return true;
 }
 
-NODISCARD
+RBS_NODISCARD
 static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_annotations_t **annotation) {
     switch (parser->next_token.type) {
     case pCOLON: {
@@ -3912,6 +3974,7 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
             return true;
         }
         case tLIDENT:
+        case tNONASCIIIDENT:
             PARAM_NAME_CASES {
                 return parse_inline_param_type_annotation(parser, annotation, rbs_range);
             }
@@ -3920,7 +3983,7 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
             rbs_location_range star_loc = rbs_location_range_current_token(parser);
 
             rbs_location_range name_loc = RBS_LOCATION_NULL_RANGE;
-            if (parser->next_token.type == tLIDENT) {
+            if (is_param_name_token(parser->next_token.type)) {
                 rbs_parser_advance(parser);
                 name_loc = rbs_location_range_current_token(parser);
             }
@@ -3960,7 +4023,7 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
             rbs_location_range star2_loc = rbs_location_range_current_token(parser);
 
             rbs_location_range name_loc = RBS_LOCATION_NULL_RANGE;
-            if (parser->next_token.type == tLIDENT) {
+            if (is_param_name_token(parser->next_token.type)) {
                 rbs_parser_advance(parser);
                 name_loc = rbs_location_range_current_token(parser);
             }
@@ -4000,7 +4063,7 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
             rbs_location_range ampersand_loc = rbs_location_range_current_token(parser);
 
             rbs_location_range name_loc = RBS_LOCATION_NULL_RANGE;
-            if (parser->next_token.type == tLIDENT) {
+            if (is_param_name_token(parser->next_token.type)) {
                 rbs_parser_advance(parser);
                 name_loc = rbs_location_range_current_token(parser);
             }
@@ -4018,7 +4081,7 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
             type_range.start = parser->next_token.range.start;
 
             parse_function_result *result = rbs_allocator_alloc(ALLOCATOR(), parse_function_result);
-            if (!parse_function(parser, true, false, &result, true, true)) {
+            if (!parse_function(parser, true, false, false, &result, true, true)) {
                 return false;
             }
 
@@ -4115,7 +4178,7 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
     }
 }
 
-NODISCARD
+RBS_NODISCARD
 static bool parse_inline_trailing_annotation(rbs_parser_t *parser, rbs_ast_ruby_annotations_t **annotation) {
     rbs_range_t prefix_range = parser->next_token.range;