rbs 4.0.0.dev.4 → 4.0.0.dev.5

data/src/parser.c

@@ -7,6 +7,7 @@
 #include <string.h>
 
 #include "rbs/defines.h"
+#include "rbs/lexer.h"
 #include "rbs/string.h"
 #include "rbs/util/rbs_unescape.h"
 #include "rbs/util/rbs_buffer.h"
@@ -19,12 +20,12 @@
         strlen(str)                    \
     )
 
-#define INTERN_TOKEN(parser, tok)                                   \
-    rbs_constant_pool_insert_shared_with_encoding(                  \
-        &parser->constant_pool,                                     \
-        (const uint8_t *) rbs_peek_token(parser->rbs_lexer_t, tok), \
-        rbs_token_bytes(tok),                                       \
-        (void *) parser->rbs_lexer_t->encoding                      \
+#define INTERN_TOKEN(parser, tok)                             \
+    rbs_constant_pool_insert_shared_with_encoding(            \
+        &parser->constant_pool,                               \
+        (const uint8_t *) rbs_peek_token(parser->lexer, tok), \
+        rbs_token_bytes(tok),                                 \
+        parser->lexer->encoding                               \
     )
 
 #define KEYWORD_CASES   \
@@ -120,8 +121,8 @@ static rbs_location_t *rbs_location_current_token(rbs_parser_t *parser) {
     return rbs_location_new(ALLOCATOR(), parser->current_token.range);
 }
 
-static bool parse_optional(rbs_parser_t *parser, rbs_node_t **optional);
-static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type);
+static bool parse_optional(rbs_parser_t *parser, rbs_node_t **optional, bool void_allowed, bool self_allowed);
+static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed, bool self_allowed);
 
 /**
  * @returns A borrowed copy of the current token, which does *not* need to be freed.
@@ -129,7 +130,7 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type);
 static rbs_string_t rbs_parser_peek_current_token(rbs_parser_t *parser) {
     rbs_range_t rg = parser->current_token.range;
 
-    const char *start = parser->rbs_lexer_t->string.start + rg.start.byte_pos;
+    const char *start = parser->lexer->string.start + rg.start.byte_pos;
     size_t length = rg.end.byte_pos - rg.start.byte_pos;
 
     return rbs_string_new(start, start + length);
@@ -190,7 +191,7 @@ static bool parse_type_name(rbs_parser_t *parser, TypeNameKind kind, rbs_range_t
         .end = parser->current_token.range.end
     };
     rbs_location_t *loc = rbs_location_new(ALLOCATOR(), namespace_range);
-    rbs_namespace_t *namespace = rbs_namespace_new(ALLOCATOR(), loc, path, absolute);
+    rbs_namespace_t *ns = rbs_namespace_new(ALLOCATOR(), loc, path, absolute);
 
     switch (parser->current_token.type) {
     case tLIDENT:
@@ -216,7 +217,7 @@ success: {
     rbs_location_t *symbolLoc = rbs_location_current_token(parser);
     rbs_constant_id_t name = INTERN_TOKEN(parser, parser->current_token);
     rbs_ast_symbol_t *symbol = rbs_ast_symbol_new(ALLOCATOR(), symbolLoc, &parser->constant_pool, name);
-    *type_name = rbs_type_name_new(ALLOCATOR(), rbs_location_new(ALLOCATOR(), *rg), namespace, symbol);
+    *type_name = rbs_type_name_new(ALLOCATOR(), rbs_location_new(ALLOCATOR(), *rg), ns, symbol);
     return true;
 }
 
@@ -232,7 +233,7 @@ error_handling: {
         ids = "class/module/constant name";
     }
 
-    rbs_assert(ids != NULL, "Unknown kind of type: %i", kind);
+    RBS_ASSERT(ids != NULL, "Unknown kind of type: %i", kind);
 
     rbs_parser_set_error(parser, parser->current_token, true, "expected one of %s", ids);
     return false;
@@ -244,10 +245,10 @@ error_handling: {
               | {} type `,` ... `,` <type> eol
 */
 NODISCARD
-static bool parse_type_list(rbs_parser_t *parser, enum RBSTokenType eol, rbs_node_list_t *types) {
+static bool parse_type_list(rbs_parser_t *parser, enum RBSTokenType eol, rbs_node_list_t *types, bool void_allowed, bool self_allowed) {
     while (true) {
         rbs_node_t *type;
-        CHECK_PARSE(rbs_parse_type(parser, &type));
+        CHECK_PARSE(rbs_parse_type(parser, &type, void_allowed, self_allowed));
         rbs_node_list_append(types, type);
 
         if (parser->next_token.type == pCOMMA) {
@@ -269,6 +270,43 @@ static bool parse_type_list(rbs_parser_t *parser, enum RBSTokenType eol, rbs_nod
     return true;
 }
 
+/*
+  type_list_with_commas ::= {} type `,` ... <`,`> eol
+                          | {} type `,` ... `,` <type> eol
+*/
+NODISCARD
+static bool parse_type_list_with_commas(rbs_parser_t *parser, enum RBSTokenType eol, rbs_node_list_t *types, rbs_location_list_t *comma_locations, bool void_allowed, bool self_allowed) {
+    while (true) {
+        rbs_node_t *type;
+        CHECK_PARSE(rbs_parse_type(parser, &type, void_allowed, self_allowed));
+        rbs_node_list_append(types, type);
+
+        if (parser->next_token.type == pCOMMA) {
+            rbs_location_t *comma_loc = rbs_location_new(ALLOCATOR(), parser->next_token.range);
+            rbs_location_list_append(comma_locations, comma_loc);
+            rbs_parser_advance(parser);
+
+            if (parser->next_token.type == eol) {
+                // Handle trailing comma - for type applications, this is an error
+                if (eol == pRBRACKET) {
+                    rbs_parser_set_error(parser, parser->next_token, true, "unexpected trailing comma");
+                    return false;
+                }
+                break;
+            }
+        } else {
+            if (parser->next_token.type == eol) {
+                break;
+            } else {
+                rbs_parser_set_error(parser, parser->next_token, true, "comma delimited type list is expected");
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
 static bool is_keyword_token(enum RBSTokenType type) {
     switch (type) {
     case tLIDENT:
@@ -289,11 +327,11 @@ static bool is_keyword_token(enum RBSTokenType type) {
                    | {} type <param>
 */
 NODISCARD
-static bool parse_function_param(rbs_parser_t *parser, rbs_types_function_param_t **function_param) {
+static bool parse_function_param(rbs_parser_t *parser, rbs_types_function_param_t **function_param, bool self_allowed) {
     rbs_range_t type_range;
     type_range.start = parser->next_token.range.start;
     rbs_node_t *type;
-    CHECK_PARSE(rbs_parse_type(parser, &type));
+    CHECK_PARSE(rbs_parse_type(parser, &type, false, self_allowed));
     type_range.end = parser->current_token.range.end;
 
     if (parser->next_token.type == pCOMMA || parser->next_token.type == pRPAREN) {
@@ -320,7 +358,7 @@ static bool parse_function_param(rbs_parser_t *parser, rbs_types_function_param_
             return false;
         }
 
-        rbs_string_t unquoted_str = rbs_unquote_string(ALLOCATOR(), rbs_parser_peek_current_token(parser));
+        rbs_string_t unquoted_str = rbs_unquote_string(ALLOCATOR(), rbs_parser_peek_current_token(parser), parser->lexer->encoding);
         rbs_location_t *symbolLoc = rbs_location_current_token(parser);
         rbs_constant_id_t constant_id = rbs_constant_pool_insert_string(&parser->constant_pool, unquoted_str);
         rbs_ast_symbol_t *name = rbs_ast_symbol_new(ALLOCATOR(), symbolLoc, &parser->constant_pool, constant_id);
@@ -337,9 +375,9 @@ static bool parse_function_param(rbs_parser_t *parser, rbs_types_function_param_
 static rbs_constant_id_t intern_token_start_end(rbs_parser_t *parser, rbs_token_t start_token, rbs_token_t end_token) {
     return rbs_constant_pool_insert_shared_with_encoding(
         &parser->constant_pool,
-        (const uint8_t *) rbs_peek_token(parser->rbs_lexer_t, start_token),
+        (const uint8_t *) rbs_peek_token(parser->lexer, start_token),
         end_token.range.end.byte_pos - start_token.range.start.byte_pos,
-        parser->rbs_lexer_t->encoding
+        parser->lexer->encoding
     );
 }
 
@@ -372,7 +410,7 @@ static bool parse_keyword_key(rbs_parser_t *parser, rbs_ast_symbol_t **key) {
   keyword ::= {} keyword `:` <function_param>
 */
 NODISCARD
-static bool parse_keyword(rbs_parser_t *parser, rbs_hash_t *keywords, rbs_hash_t *memo) {
+static bool parse_keyword(rbs_parser_t *parser, rbs_hash_t *keywords, rbs_hash_t *memo, bool self_allowed) {
     rbs_ast_symbol_t *key = NULL;
     CHECK_PARSE(parse_keyword_key(parser, &key));
 
@@ -386,7 +424,7 @@ static bool parse_keyword(rbs_parser_t *parser, rbs_hash_t *keywords, rbs_hash_t
 
     ADVANCE_ASSERT(parser, pCOLON);
     rbs_types_function_param_t *param = NULL;
-    CHECK_PARSE(parse_function_param(parser, &param));
+    CHECK_PARSE(parse_function_param(parser, &param, self_allowed));
 
     rbs_hash_set(keywords, (rbs_node_t *) key, (rbs_node_t *) param);
 
@@ -457,7 +495,7 @@ static bool parser_advance_if(rbs_parser_t *parser, enum RBSTokenType type) {
              | {} `**` <function_param>
 */
 NODISCARD
-static bool parse_params(rbs_parser_t *parser, method_params *params) {
+static bool parse_params(rbs_parser_t *parser, method_params *params, bool self_allowed) {
     if (parser->next_token.type == pQUESTION && parser->next_token2.type == pRPAREN) {
         params->required_positionals = NULL;
         rbs_parser_advance(parser);
@@ -486,7 +524,7 @@ static bool parse_params(rbs_parser_t *parser, method_params *params) {
             }
 
             rbs_types_function_param_t *param = NULL;
-            CHECK_PARSE(parse_function_param(parser, &param));
+            CHECK_PARSE(parse_function_param(parser, &param, self_allowed));
             rbs_node_list_append(params->required_positionals, (rbs_node_t *) param);
 
             break;
@@ -504,13 +542,13 @@ PARSE_OPTIONAL_PARAMS:
             rbs_parser_advance(parser);
 
             if (is_keyword(parser)) {
-                CHECK_PARSE(parse_keyword(parser, params->optional_keywords, memo));
+                CHECK_PARSE(parse_keyword(parser, params->optional_keywords, memo, self_allowed));
                 parser_advance_if(parser, pCOMMA);
                 goto PARSE_KEYWORDS;
             }
 
             rbs_types_function_param_t *param = NULL;
-            CHECK_PARSE(parse_function_param(parser, &param));
+            CHECK_PARSE(parse_function_param(parser, &param, self_allowed));
             rbs_node_list_append(params->optional_positionals, (rbs_node_t *) param);
 
             break;
@@ -527,7 +565,7 @@ PARSE_REST_PARAM:
     if (parser->next_token.type == pSTAR) {
         rbs_parser_advance(parser);
         rbs_types_function_param_t *param = NULL;
-        CHECK_PARSE(parse_function_param(parser, &param));
+        CHECK_PARSE(parse_function_param(parser, &param, self_allowed));
         params->rest_positionals = (rbs_node_t *) param;
 
         if (!parser_advance_if(parser, pCOMMA)) {
@@ -554,7 +592,7 @@ PARSE_TRAILING_PARAMS:
             }
 
             rbs_types_function_param_t *param = NULL;
-            CHECK_PARSE(parse_function_param(parser, &param));
+            CHECK_PARSE(parse_function_param(parser, &param, self_allowed));
             rbs_node_list_append(params->trailing_positionals, (rbs_node_t *) param);
 
             break;
@@ -571,7 +609,7 @@ PARSE_KEYWORDS:
         case pQUESTION:
             rbs_parser_advance(parser);
             if (is_keyword(parser)) {
-                CHECK_PARSE(parse_keyword(parser, params->optional_keywords, memo));
+                CHECK_PARSE(parse_keyword(parser, params->optional_keywords, memo, self_allowed));
             } else {
                 rbs_parser_set_error(parser, parser->next_token, true, "optional keyword argument type is expected");
                 return false;
@@ -581,7 +619,7 @@ PARSE_KEYWORDS:
         case pSTAR2:
             rbs_parser_advance(parser);
             rbs_types_function_param_t *param = NULL;
-            CHECK_PARSE(parse_function_param(parser, &param));
+            CHECK_PARSE(parse_function_param(parser, &param, self_allowed));
             params->rest_keywords = (rbs_node_t *) param;
             break;
 
@@ -593,7 +631,7 @@ PARSE_KEYWORDS:
         case tBANGIDENT:
             KEYWORD_CASES
             if (is_keyword(parser)) {
-                CHECK_PARSE(parse_keyword(parser, params->required_keywords, memo));
+                CHECK_PARSE(parse_keyword(parser, params->required_keywords, memo, self_allowed));
             } else {
                 rbs_parser_set_error(parser, parser->next_token, true, "required keyword argument type is expected");
                 return false;
@@ -623,14 +661,19 @@ EOP:
              | {} simple_type <`?`>
 */
 NODISCARD
-static bool parse_optional(rbs_parser_t *parser, rbs_node_t **optional) {
+static bool parse_optional(rbs_parser_t *parser, rbs_node_t **optional, bool void_allowed, bool self_allowed) {
     rbs_range_t rg;
     rg.start = parser->next_token.range.start;
 
     rbs_node_t *type = NULL;
-    CHECK_PARSE(parse_simple(parser, &type));
+    CHECK_PARSE(parse_simple(parser, &type, void_allowed, self_allowed));
 
     if (parser->next_token.type == pQUESTION) {
+        if (void_allowed && type->type == RBS_TYPES_BASES_VOID) {
+            rbs_parser_set_error(parser, parser->current_token, true, "void type is not allowed here");
+            return false;
+        }
+
         rbs_parser_advance(parser);
         rg.end = parser->current_token.range.end;
         rbs_location_t *location = rbs_location_new(ALLOCATOR(), rg);
@@ -659,13 +702,13 @@ static void initialize_method_params(method_params *params, rbs_allocator_t *all
                       | {} `[` `self` `:` type <`]`>
 */
 NODISCARD
-static bool parse_self_type_binding(rbs_parser_t *parser, rbs_node_t **self_type) {
+static bool parse_self_type_binding(rbs_parser_t *parser, rbs_node_t **self_type, bool self_allowed) {
     if (parser->next_token.type == pLBRACKET) {
         rbs_parser_advance(parser);
         ADVANCE_ASSERT(parser, kSELF);
         ADVANCE_ASSERT(parser, pCOLON);
         rbs_node_t *type;
-        CHECK_PARSE(rbs_parse_type(parser, &type));
+        CHECK_PARSE(rbs_parse_type(parser, &type, false, self_allowed));
         ADVANCE_ASSERT(parser, pRBRACKET);
         *self_type = type;
     }
@@ -687,7 +730,7 @@ typedef struct {
              | {} self_type_binding? `->` <optional>
 */
 NODISCARD
-static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, parse_function_result **result) {
+static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, parse_function_result **result, bool self_allowed) {
     rbs_node_t *function = NULL;
     rbs_types_block_t *block = NULL;
     rbs_node_t *function_self_type = NULL;
@@ -699,13 +742,13 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, parse
 
     if (parser->next_token.type == pLPAREN) {
         rbs_parser_advance(parser);
-        CHECK_PARSE(parse_params(parser, &params));
+        CHECK_PARSE(parse_params(parser, &params, self_allowed));
         ADVANCE_ASSERT(parser, pRPAREN);
     }
 
     // Passing NULL to function_self_type means the function itself doesn't accept self type binding. (== method type)
     if (accept_type_binding) {
-        CHECK_PARSE(parse_self_type_binding(parser, &function_self_type));
+        CHECK_PARSE(parse_self_type_binding(parser, &function_self_type, self_allowed));
     } else {
         if (rbs_is_untyped_params(&params)) {
             if (parser->next_token.type != pARROW) {
@@ -735,16 +778,16 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, parse
 
         if (parser->next_token.type == pLPAREN) {
             rbs_parser_advance(parser);
-            CHECK_PARSE(parse_params(parser, &block_params));
+            CHECK_PARSE(parse_params(parser, &block_params, self_allowed));
             ADVANCE_ASSERT(parser, pRPAREN);
         }
 
         rbs_node_t *self_type = NULL;
-        CHECK_PARSE(parse_self_type_binding(parser, &self_type));
+        CHECK_PARSE(parse_self_type_binding(parser, &self_type, self_allowed));
 
         ADVANCE_ASSERT(parser, pARROW);
         rbs_node_t *block_return_type = NULL;
-        CHECK_PARSE(parse_optional(parser, &block_return_type));
+        CHECK_PARSE(parse_optional(parser, &block_return_type, true, self_allowed));
 
         ADVANCE_ASSERT(parser, pRBRACE);
 
@@ -774,7 +817,7 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, parse
 
     ADVANCE_ASSERT(parser, pARROW);
     rbs_node_t *type = NULL;
-    CHECK_PARSE(parse_optional(parser, &type));
+    CHECK_PARSE(parse_optional(parser, &type, true, self_allowed));
 
     function_range.end = parser->current_token.range.end;
     rbs_location_t *loc = rbs_location_new(ALLOCATOR(), function_range);
@@ -805,10 +848,10 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, parse
   proc_type ::= {`^`} <function>
 */
 NODISCARD
-static bool parse_proc_type(rbs_parser_t *parser, rbs_types_proc_t **proc) {
+static bool parse_proc_type(rbs_parser_t *parser, rbs_types_proc_t **proc, bool self_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, &result));
+    CHECK_PARSE(parse_function(parser, true, &result, self_allowed));
 
     rbs_position_t end = parser->current_token.range.end;
     rbs_location_t *loc = rbs_location_new(ALLOCATOR(), (rbs_range_t) { .start = start, .end = end });
@@ -833,7 +876,7 @@ static void check_key_duplication(rbs_parser_t *parser, rbs_hash_t *fields, rbs_
                      | {} literal_type `=>` <type>
 */
 NODISCARD
-static bool parse_record_attributes(rbs_parser_t *parser, rbs_hash_t **fields) {
+static bool parse_record_attributes(rbs_parser_t *parser, rbs_hash_t **fields, bool self_allowed) {
     *fields = rbs_hash_new(ALLOCATOR());
 
     if (parser->next_token.type == pRBRACE) return true;
@@ -866,7 +909,7 @@ static bool parse_record_attributes(rbs_parser_t *parser, rbs_hash_t **fields) {
             case kTRUE:
             case kFALSE: {
                 rbs_node_t *type = NULL;
-                CHECK_PARSE(parse_simple(parser, &type));
+                CHECK_PARSE(parse_simple(parser, &type, false, self_allowed));
 
                 key = (rbs_ast_symbol_t *) ((rbs_types_literal_t *) type)->literal;
                 break;
@@ -883,7 +926,7 @@ static bool parse_record_attributes(rbs_parser_t *parser, rbs_hash_t **fields) {
         field_range.start = parser->current_token.range.end;
 
         rbs_node_t *type;
-        CHECK_PARSE(rbs_parse_type(parser, &type));
+        CHECK_PARSE(rbs_parse_type(parser, &type, false, self_allowed));
 
         field_range.end = parser->current_token.range.end;
         rbs_location_t *loc = rbs_location_new(ALLOCATOR(), field_range);
@@ -905,7 +948,7 @@ static bool parse_record_attributes(rbs_parser_t *parser, rbs_hash_t **fields) {
 */
 NODISCARD
 static bool parse_symbol(rbs_parser_t *parser, rbs_location_t *location, rbs_types_literal_t **symbol) {
-    size_t offset_bytes = parser->rbs_lexer_t->encoding->char_width((const uint8_t *) ":", (size_t) 1);
+    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;
 
     rbs_ast_symbol_t *literal;
@@ -914,7 +957,7 @@ static bool parse_symbol(rbs_parser_t *parser, rbs_location_t *location, rbs_typ
     case tSYMBOL: {
         rbs_location_t *symbolLoc = rbs_location_current_token(parser);
 
-        char *buffer = rbs_peek_token(parser->rbs_lexer_t, parser->current_token);
+        char *buffer = rbs_peek_token(parser->lexer, parser->current_token);
         rbs_constant_id_t constant_id = rbs_constant_pool_insert_shared(
             &parser->constant_pool,
             (const uint8_t *) buffer + offset_bytes,
@@ -930,7 +973,7 @@ static bool parse_symbol(rbs_parser_t *parser, rbs_location_t *location, rbs_typ
 
         rbs_string_t symbol = rbs_string_new(current_token.start + offset_bytes, current_token.end);
 
-        rbs_string_t unquoted_symbol = rbs_unquote_string(ALLOCATOR(), symbol);
+        rbs_string_t unquoted_symbol = rbs_unquote_string(ALLOCATOR(), symbol, parser->lexer->encoding);
 
         rbs_constant_id_t constant_id = rbs_constant_pool_insert_string(&parser->constant_pool, unquoted_symbol);
 
@@ -954,9 +997,9 @@ static bool parse_symbol(rbs_parser_t *parser, rbs_location_t *location, rbs_typ
  */
 NODISCARD
 static bool parse_instance_type(rbs_parser_t *parser, bool parse_alias, rbs_node_t **type) {
-    TypeNameKind expected_kind = INTERFACE_NAME | CLASS_NAME;
+    TypeNameKind expected_kind = (TypeNameKind) (INTERFACE_NAME | CLASS_NAME);
     if (parse_alias) {
-        expected_kind |= ALIAS_NAME;
+        expected_kind = (TypeNameKind) (expected_kind | ALIAS_NAME);
     }
 
     rbs_range_t name_range;
@@ -990,7 +1033,7 @@ static bool parse_instance_type(rbs_parser_t *parser, bool parse_alias, rbs_node
     if (parser->next_token.type == pLBRACKET) {
         rbs_parser_advance(parser);
         args_range.start = parser->current_token.range.start;
-        CHECK_PARSE(parse_type_list(parser, pRBRACKET, types));
+        CHECK_PARSE(parse_type_list(parser, pRBRACKET, types, true, true));
         ADVANCE_ASSERT(parser, pRBRACKET);
         args_range.end = parser->current_token.range.end;
     } else {
@@ -1077,13 +1120,13 @@ static bool parser_typevar_member(rbs_parser_t *parser, rbs_constant_id_t id) {
            | {} `^` <function>
 */
 NODISCARD
-static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
+static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed, bool self_allowed) {
     rbs_parser_advance(parser);
 
     switch (parser->current_token.type) {
     case pLPAREN: {
         rbs_node_t *lparen_type;
-        CHECK_PARSE(rbs_parse_type(parser, &lparen_type));
+        CHECK_PARSE(rbs_parse_type(parser, &lparen_type, false, self_allowed));
         ADVANCE_ASSERT(parser, pRPAREN);
         *type = lparen_type;
         return true;
@@ -1114,6 +1157,11 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
         return true;
     }
     case kSELF: {
+        if (!self_allowed) {
+            rbs_parser_set_error(parser, parser->current_token, true, "self type is not allowed here");
+            return false;
+        }
+
         rbs_location_t *loc = rbs_location_current_token(parser);
         *type = (rbs_node_t *) rbs_types_bases_self_new(ALLOCATOR(), loc);
         return true;
@@ -1124,6 +1172,11 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
         return true;
     }
     case kVOID: {
+        if (!void_allowed) {
+            rbs_parser_set_error(parser, parser->current_token, true, "void type is not allowed here");
+            return false;
+        }
+
         rbs_location_t *loc = rbs_location_current_token(parser);
         *type = (rbs_node_t *) rbs_types_bases_void_new(ALLOCATOR(), loc);
         return true;
@@ -1162,7 +1215,7 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
     case tDQSTRING: {
         rbs_location_t *loc = rbs_location_current_token(parser);
 
-        rbs_string_t unquoted_str = rbs_unquote_string(ALLOCATOR(), rbs_parser_peek_current_token(parser));
+        rbs_string_t unquoted_str = rbs_unquote_string(ALLOCATOR(), rbs_parser_peek_current_token(parser), parser->lexer->encoding);
         rbs_node_t *literal = (rbs_node_t *) rbs_ast_string_new(ALLOCATOR(), loc, unquoted_str);
         *type = (rbs_node_t *) rbs_types_literal_new(ALLOCATOR(), loc, literal);
         return true;
@@ -1177,7 +1230,7 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
         return true;
     }
     case tUIDENT: {
-        const char *name_str = rbs_peek_token(parser->rbs_lexer_t, parser->current_token);
+        const char *name_str = rbs_peek_token(parser->lexer, parser->current_token);
         size_t name_len = rbs_token_bytes(parser->current_token);
 
         rbs_constant_id_t name = rbs_constant_pool_find(&parser->constant_pool, (const uint8_t *) name_str, name_len);
@@ -1212,7 +1265,7 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
         rg.start = parser->current_token.range.start;
         rbs_node_list_t *types = rbs_node_list_new(ALLOCATOR());
         if (parser->next_token.type != pRBRACKET) {
-            CHECK_PARSE(parse_type_list(parser, pRBRACKET, types));
+            CHECK_PARSE(parse_type_list(parser, pRBRACKET, types, false, self_allowed));
         }
         ADVANCE_ASSERT(parser, pRBRACKET);
         rg.end = parser->current_token.range.end;
@@ -1230,7 +1283,7 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
     case pLBRACE: {
         rbs_position_t start = parser->current_token.range.start;
         rbs_hash_t *fields = NULL;
-        CHECK_PARSE(parse_record_attributes(parser, &fields));
+        CHECK_PARSE(parse_record_attributes(parser, &fields, self_allowed));
         ADVANCE_ASSERT(parser, pRBRACE);
         rbs_position_t end = parser->current_token.range.end;
         rbs_location_t *loc = rbs_location_new(ALLOCATOR(), (rbs_range_t) { .start = start, .end = end });
@@ -1239,7 +1292,7 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
     }
     case pHAT: {
         rbs_types_proc_t *value = NULL;
-        CHECK_PARSE(parse_proc_type(parser, &value));
+        CHECK_PARSE(parse_proc_type(parser, &value, self_allowed));
         *type = (rbs_node_t *) value;
         return true;
     }
@@ -1254,21 +1307,26 @@ static bool parse_simple(rbs_parser_t *parser, rbs_node_t **type) {
                  | {} <optional>
 */
 NODISCARD
-static bool parse_intersection(rbs_parser_t *parser, rbs_node_t **type) {
+static bool parse_intersection(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed, bool self_allowed) {
     rbs_range_t rg;
     rg.start = parser->next_token.range.start;
 
     rbs_node_t *optional = NULL;
-    CHECK_PARSE(parse_optional(parser, &optional));
+    CHECK_PARSE(parse_optional(parser, &optional, void_allowed, self_allowed));
     *type = optional;
 
     rbs_node_list_t *intersection_types = rbs_node_list_new(ALLOCATOR());
 
     rbs_node_list_append(intersection_types, optional);
     while (parser->next_token.type == pAMP) {
+        if (void_allowed && (*type)->type == RBS_TYPES_BASES_VOID) {
+            rbs_parser_set_error(parser, parser->current_token, true, "void type is not allowed here");
+            return false;
+        }
+
         rbs_parser_advance(parser);
         rbs_node_t *type = NULL;
-        CHECK_PARSE(parse_optional(parser, &type));
+        CHECK_PARSE(parse_optional(parser, &type, false, self_allowed));
         rbs_node_list_append(intersection_types, type);
     }
 
@@ -1286,19 +1344,24 @@ static bool parse_intersection(rbs_parser_t *parser, rbs_node_t **type) {
   union ::= {} intersection '|' ... '|' <intersection>
           | {} <intersection>
 */
-bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type) {
+bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed, bool self_allowed) {
     rbs_range_t rg;
     rg.start = parser->next_token.range.start;
     rbs_node_list_t *union_types = rbs_node_list_new(ALLOCATOR());
 
-    CHECK_PARSE(parse_intersection(parser, type));
+    CHECK_PARSE(parse_intersection(parser, type, void_allowed, self_allowed));
 
     rbs_node_list_append(union_types, *type);
 
     while (parser->next_token.type == pBAR) {
+        if (void_allowed && (*type)->type == RBS_TYPES_BASES_VOID) {
+            rbs_parser_set_error(parser, parser->current_token, true, "void type is not allowed here");
+            return false;
+        }
+
         rbs_parser_advance(parser);
         rbs_node_t *intersection = NULL;
-        CHECK_PARSE(parse_intersection(parser, &intersection));
+        CHECK_PARSE(parse_intersection(parser, &intersection, false, self_allowed));
         rbs_node_list_append(union_types, intersection);
     }
 
@@ -1316,9 +1379,9 @@ bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type) {
   type_params ::= {} `[` type_param `,` ... <`]`>
                 | {<>}
 
-  type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT upper_bound? default_type?   (module_type_params == true)
+  type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT upper_bound? lower_bound? default_type?   (module_type_params == true)
 
-  type_param ::= tUIDENT upper_bound? default_type?                           (module_type_params == false)
+  type_param ::= tUIDENT upper_bound? lower_bound? default_type?                           (module_type_params == false)
 */
 NODISCARD
 static bool parse_type_params(rbs_parser_t *parser, rbs_range_t *rg, bool module_type_params, rbs_node_list_t **params) {
@@ -1335,6 +1398,7 @@ static bool parse_type_params(rbs_parser_t *parser, rbs_range_t *rg, bool module
             bool unchecked = false;
             rbs_keyword_t *variance = rbs_keyword_new(ALLOCATOR(), rbs_location_current_token(parser), INTERN("invariant"));
             rbs_node_t *upper_bound = NULL;
+            rbs_node_t *lower_bound = NULL;
             rbs_node_t *default_type = NULL;
 
             rbs_range_t param_range;
@@ -1378,11 +1442,37 @@ static bool parse_type_params(rbs_parser_t *parser, rbs_range_t *rg, bool module
             CHECK_PARSE(rbs_parser_insert_typevar(parser, id));
 
             rbs_range_t upper_bound_range = NULL_RANGE;
-            if (parser->next_token.type == pLT) {
-                rbs_parser_advance(parser);
-                upper_bound_range.start = parser->current_token.range.start;
-                CHECK_PARSE(rbs_parse_type(parser, &upper_bound));
-                upper_bound_range.end = parser->current_token.range.end;
+            rbs_range_t lower_bound_range = NULL_RANGE;
+
+            for (int bound_parse_attempt = 0; bound_parse_attempt < 2; bound_parse_attempt++) {
+                switch (parser->next_token.type) {
+                case pLT:
+                    if (upper_bound != NULL) {
+                        rbs_parser_set_error(parser, parser->next_token, true, "duplicate upper bound ('<') for type parameter");
+                        return false;
+                    }
+
+                    rbs_parser_advance(parser);
+                    upper_bound_range.start = parser->current_token.range.start;
+                    CHECK_PARSE(rbs_parse_type(parser, &upper_bound, false, false));
+                    upper_bound_range.end = parser->current_token.range.end;
+                    break;
+
+                case pGT:
+                    if (lower_bound != NULL) {
+                        rbs_parser_set_error(parser, parser->next_token, true, "duplicate lower bound ('>') for type parameter");
+                        return false;
+                    }
+
+                    rbs_parser_advance(parser);
+                    lower_bound_range.start = parser->current_token.range.start;
+                    CHECK_PARSE(rbs_parse_type(parser, &lower_bound, false, false));
+                    lower_bound_range.end = parser->current_token.range.end;
+                    break;
+
+                default:
+                    break;
+                }
             }
 
             rbs_range_t default_type_range = NULL_RANGE;
@@ -1391,7 +1481,7 @@ static bool parse_type_params(rbs_parser_t *parser, rbs_range_t *rg, bool module
                     rbs_parser_advance(parser);
 
                     default_type_range.start = parser->current_token.range.start;
-                    CHECK_PARSE(rbs_parse_type(parser, &default_type));
+                    CHECK_PARSE(rbs_parse_type(parser, &default_type, true, false));
                     default_type_range.end = parser->current_token.range.end;
 
                     required_param_allowed = false;
@@ -1406,23 +1496,25 @@ static bool parse_type_params(rbs_parser_t *parser, rbs_range_t *rg, bool module
             param_range.end = parser->current_token.range.end;
 
             rbs_location_t *loc = rbs_location_new(ALLOCATOR(), param_range);
-            rbs_loc_alloc_children(ALLOCATOR(), loc, 5);
+            rbs_loc_alloc_children(ALLOCATOR(), loc, 6);
             rbs_loc_add_required_child(loc, INTERN("name"), name_range);
             rbs_loc_add_optional_child(loc, INTERN("variance"), variance_range);
             rbs_loc_add_optional_child(loc, INTERN("unchecked"), unchecked_range);
             rbs_loc_add_optional_child(loc, INTERN("upper_bound"), upper_bound_range);
+            rbs_loc_add_optional_child(loc, INTERN("lower_bound"), lower_bound_range);
             rbs_loc_add_optional_child(loc, INTERN("default"), default_type_range);
 
-            rbs_ast_type_param_t *param = rbs_ast_type_param_new(ALLOCATOR(), loc, name, variance, upper_bound, default_type, unchecked);
+            rbs_ast_type_param_t *param = rbs_ast_type_param_new(ALLOCATOR(), loc, name, variance, upper_bound, lower_bound, default_type, unchecked);
 
             rbs_node_list_append(*params, (rbs_node_t *) param);
 
             if (parser->next_token.type == pCOMMA) {
                 rbs_parser_advance(parser);
-            }
-
-            if (parser->next_token.type == pRBRACKET) {
+            } else if (parser->next_token.type == pRBRACKET) {
                 break;
+            } else {
+                rbs_parser_set_error(parser, parser->next_token, true, "expected ',' or ']' after type parameter, got %s", rbs_token_type_str(parser->next_token.type));
+                return false;
             }
         }
 
@@ -1459,7 +1551,7 @@ static bool parser_pop_typevar_table(rbs_parser_t *parser) {
   method_type ::= {} type_params <function>
   */
 // TODO: Should this be NODISCARD?
-bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type) {
+bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type, bool require_eof) {
     rbs_parser_push_typevar_table(parser, false);
 
     rbs_range_t rg;
@@ -1473,12 +1565,20 @@ 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, &result));
+    CHECK_PARSE(parse_function(parser, false, &result, true));
+
+    CHECK_PARSE(parser_pop_typevar_table(parser));
 
     rg.end = parser->current_token.range.end;
     type_range.end = rg.end;
 
-    CHECK_PARSE(parser_pop_typevar_table(parser));
+    if (require_eof) {
+        rbs_parser_advance(parser);
+        if (parser->current_token.type != pEOF) {
+            rbs_parser_set_error(parser, parser->current_token, true, "expected a token `%s`", rbs_token_type_str(pEOF));
+            return false;
+        }
+    }
 
     rbs_location_t *loc = rbs_location_new(ALLOCATOR(), rg);
     rbs_loc_alloc_children(ALLOCATOR(), loc, 2);
@@ -1508,7 +1608,7 @@ static bool parse_global_decl(rbs_parser_t *parser, rbs_node_list_t *annotations
     rbs_range_t colon_range = parser->current_token.range;
 
     rbs_node_t *type;
-    CHECK_PARSE(rbs_parse_type(parser, &type));
+    CHECK_PARSE(rbs_parse_type(parser, &type, false, false));
     decl_range.end = parser->current_token.range.end;
 
     rbs_location_t *loc = rbs_location_new(ALLOCATOR(), decl_range);
@@ -1538,7 +1638,7 @@ static bool parse_const_decl(rbs_parser_t *parser, rbs_node_list_t *annotations,
     rbs_range_t colon_range = parser->current_token.range;
 
     rbs_node_t *type;
-    CHECK_PARSE(rbs_parse_type(parser, &type));
+    CHECK_PARSE(rbs_parse_type(parser, &type, false, false));
 
     decl_range.end = parser->current_token.range.end;
 
@@ -1578,7 +1678,7 @@ static bool parse_type_decl(rbs_parser_t *parser, rbs_position_t comment_pos, rb
     rbs_range_t eq_range = parser->current_token.range;
 
     rbs_node_t *type;
-    CHECK_PARSE(rbs_parse_type(parser, &type));
+    CHECK_PARSE(rbs_parse_type(parser, &type, false, false));
 
     decl_range.end = parser->current_token.range.end;
 
@@ -1605,14 +1705,16 @@ static bool parse_annotation(rbs_parser_t *parser, rbs_ast_annotation_t **annota
     rbs_range_t rg = parser->current_token.range;
 
     size_t offset_bytes =
-        parser->rbs_lexer_t->encoding->char_width((const uint8_t *) "%", (size_t) 1) +
-        parser->rbs_lexer_t->encoding->char_width((const uint8_t *) "a", (size_t) 1);
+        parser->lexer->encoding->char_width((const uint8_t *) "%", (size_t) 1) +
+        parser->lexer->encoding->char_width((const uint8_t *) "a", (size_t) 1);
 
     rbs_string_t str = rbs_string_new(
-        parser->rbs_lexer_t->string.start + rg.start.byte_pos + offset_bytes,
-        parser->rbs_lexer_t->string.end
+        parser->lexer->string.start + rg.start.byte_pos + offset_bytes,
+        parser->lexer->string.end
     );
-    unsigned int open_char = rbs_utf8_string_to_codepoint(str);
+
+    // Assumes the input is ASCII compatible
+    unsigned int open_char = str.start[0];
 
     unsigned int close_char;
 
@@ -1637,8 +1739,8 @@ static bool parse_annotation(rbs_parser_t *parser, rbs_ast_annotation_t **annota
         return false;
     }
 
-    size_t open_bytes = parser->rbs_lexer_t->encoding->char_width((const uint8_t *) &open_char, (size_t) 1);
-    size_t close_bytes = parser->rbs_lexer_t->encoding->char_width((const uint8_t *) &close_char, (size_t) 1);
+    size_t open_bytes = parser->lexer->encoding->char_width((const uint8_t *) &open_char, (size_t) 1);
+    size_t close_bytes = parser->lexer->encoding->char_width((const uint8_t *) &close_char, (size_t) 1);
 
     rbs_string_t current_token = rbs_parser_peek_current_token(parser);
     size_t total_offset = offset_bytes + open_bytes;
@@ -1702,9 +1804,9 @@ static bool parse_method_name(rbs_parser_t *parser, rbs_range_t *range, rbs_ast_
 
             rbs_constant_id_t constant_id = rbs_constant_pool_insert_shared_with_encoding(
                 &parser->constant_pool,
-                (const uint8_t *) parser->rbs_lexer_t->string.start + range->start.byte_pos,
+                (const uint8_t *) parser->lexer->string.start + range->start.byte_pos,
                 range->end.byte_pos - range->start.byte_pos,
-                parser->rbs_lexer_t->encoding
+                parser->lexer->encoding
             );
 
             rbs_location_t *symbolLoc = rbs_location_new(ALLOCATOR(), *range);
@@ -1725,7 +1827,7 @@ static bool parse_method_name(rbs_parser_t *parser, rbs_range_t *range, rbs_ast_
     }
     case tQIDENT: {
         rbs_string_t string = rbs_parser_peek_current_token(parser);
-        rbs_string_t unquoted_str = rbs_unquote_string(ALLOCATOR(), string);
+        rbs_string_t unquoted_str = rbs_unquote_string(ALLOCATOR(), string, parser->lexer->encoding);
         rbs_constant_id_t constant_id = rbs_constant_pool_insert_string(&parser->constant_pool, unquoted_str);
         rbs_location_t *symbolLoc = rbs_location_current_token(parser);
         *symbol = rbs_ast_symbol_new(ALLOCATOR(), symbolLoc, &parser->constant_pool, constant_id);
@@ -1738,6 +1840,7 @@ static bool parse_method_name(rbs_parser_t *parser, rbs_range_t *range, rbs_ast_
     case pSTAR:
     case pSTAR2:
     case pLT:
+    case pGT:
     case pAREF_OPR:
     case tOPERATOR: {
         *range = parser->current_token.range;
@@ -1886,7 +1989,7 @@ static bool parse_member_def(rbs_parser_t *parser, bool instance_only, bool acce
         case pLBRACKET:
         case pQUESTION: {
             rbs_method_type_t *method_type = NULL;
-            CHECK_PARSE(rbs_parse_method_type(parser, &method_type));
+            CHECK_PARSE(rbs_parse_method_type(parser, &method_type, false));
 
             overload_range.end = parser->current_token.range.end;
             rbs_location_t *loc = rbs_location_new(ALLOCATOR(), overload_range);
@@ -1971,7 +2074,7 @@ static bool class_instance_name(rbs_parser_t *parser, TypeNameKind kind, rbs_nod
     if (parser->next_token.type == pLBRACKET) {
         rbs_parser_advance(parser);
         args_range->start = parser->current_token.range.start;
-        CHECK_PARSE(parse_type_list(parser, pRBRACKET, args));
+        CHECK_PARSE(parse_type_list(parser, pRBRACKET, args, true, false));
         ADVANCE_ASSERT(parser, pRBRACKET);
         args_range->end = parser->current_token.range.end;
     } else {
@@ -2028,7 +2131,7 @@ static bool parse_mixin_member(rbs_parser_t *parser, bool from_interface, rbs_po
     rbs_type_name_t *name = NULL;
     CHECK_PARSE(class_instance_name(
         parser,
-        from_interface ? INTERFACE_NAME : (INTERFACE_NAME | CLASS_NAME),
+        from_interface ? INTERFACE_NAME : (TypeNameKind) (INTERFACE_NAME | CLASS_NAME),
         args,
         &name_range,
         &args_range,
@@ -2146,7 +2249,7 @@ static bool parse_variable_member(rbs_parser_t *parser, rbs_position_t comment_p
         rbs_range_t colon_range = parser->current_token.range;
 
         rbs_node_t *type;
-        CHECK_PARSE(rbs_parse_type(parser, &type));
+        CHECK_PARSE(rbs_parse_type(parser, &type, false, true));
         member_range.end = parser->current_token.range.end;
 
         rbs_location_t *loc = rbs_location_new(ALLOCATOR(), member_range);
@@ -2169,7 +2272,7 @@ static bool parse_variable_member(rbs_parser_t *parser, rbs_position_t comment_p
         rbs_parser_push_typevar_table(parser, true);
 
         rbs_node_t *type;
-        CHECK_PARSE(rbs_parse_type(parser, &type));
+        CHECK_PARSE(rbs_parse_type(parser, &type, false, false));
 
         CHECK_PARSE(parser_pop_typevar_table(parser));
 
@@ -2208,7 +2311,7 @@ static bool parse_variable_member(rbs_parser_t *parser, rbs_position_t comment_p
         rbs_parser_push_typevar_table(parser, true);
 
         rbs_node_t *type;
-        CHECK_PARSE(rbs_parse_type(parser, &type));
+        CHECK_PARSE(rbs_parse_type(parser, &type, false, true));
 
         CHECK_PARSE(parser_pop_typevar_table(parser));
 
@@ -2349,7 +2452,7 @@ static bool parse_attribute_member(rbs_parser_t *parser, rbs_position_t comment_
     rbs_parser_push_typevar_table(parser, is_kind == SINGLETON_KIND);
 
     rbs_node_t *type;
-    CHECK_PARSE(rbs_parse_type(parser, &type));
+    CHECK_PARSE(rbs_parse_type(parser, &type, false, true));
 
     CHECK_PARSE(parser_pop_typevar_table(parser));
 
@@ -2494,7 +2597,7 @@ static bool parse_module_self_types(rbs_parser_t *parser, rbs_node_list_t *array
 
         rbs_range_t name_range;
         rbs_type_name_t *module_name = NULL;
-        CHECK_PARSE(parse_type_name(parser, CLASS_NAME | INTERFACE_NAME, &name_range, &module_name));
+        CHECK_PARSE(parse_type_name(parser, (TypeNameKind) (CLASS_NAME | INTERFACE_NAME), &name_range, &module_name));
         self_range.end = name_range.end;
 
         rbs_node_list_t *args = rbs_node_list_new(ALLOCATOR());
@@ -2502,7 +2605,7 @@ static bool parse_module_self_types(rbs_parser_t *parser, rbs_node_list_t *array
         if (parser->next_token.type == pLBRACKET) {
             rbs_parser_advance(parser);
             args_range.start = parser->current_token.range.start;
-            CHECK_PARSE(parse_type_list(parser, pRBRACKET, args));
+            CHECK_PARSE(parse_type_list(parser, pRBRACKET, args, true, false));
             rbs_parser_advance(parser);
             self_range.end = args_range.end = parser->current_token.range.end;
         }
@@ -2958,7 +3061,7 @@ static bool parse_decl(rbs_parser_t *parser, rbs_node_t **decl) {
               | {} <>                                            (empty -- returns empty namespace)
 */
 NODISCARD
-static bool parse_namespace(rbs_parser_t *parser, rbs_range_t *rg, rbs_namespace_t **namespace) {
+static bool parse_namespace(rbs_parser_t *parser, rbs_range_t *rg, rbs_namespace_t **out_ns) {
     bool is_absolute = false;
 
     if (parser->next_token.type == pCOLON2) {
@@ -2989,7 +3092,7 @@ static bool parse_namespace(rbs_parser_t *parser, rbs_range_t *rg, rbs_namespace
         }
     }
 
-    *namespace = rbs_namespace_new(ALLOCATOR(), rbs_location_new(ALLOCATOR(), *rg), path, is_absolute);
+    *out_ns = rbs_namespace_new(ALLOCATOR(), rbs_location_new(ALLOCATOR(), *rg), path, is_absolute);
     return true;
 }
 
@@ -3004,8 +3107,8 @@ NODISCARD
 static bool parse_use_clauses(rbs_parser_t *parser, rbs_node_list_t *clauses) {
     while (true) {
         rbs_range_t namespace_range = NULL_RANGE;
-        rbs_namespace_t *namespace = NULL;
-        CHECK_PARSE(parse_namespace(parser, &namespace_range, &namespace));
+        rbs_namespace_t *ns = NULL;
+        CHECK_PARSE(parse_namespace(parser, &namespace_range, &ns));
 
         switch (parser->next_token.type) {
         case tLIDENT:
@@ -3019,7 +3122,7 @@ static bool parse_use_clauses(rbs_parser_t *parser, rbs_node_list_t *clauses) {
 
             rbs_location_t *symbolLoc = rbs_location_current_token(parser);
             rbs_ast_symbol_t *symbol = rbs_ast_symbol_new(ALLOCATOR(), symbolLoc, &parser->constant_pool, INTERN_TOKEN(parser, parser->current_token));
-            rbs_type_name_t *type_name = rbs_type_name_new(ALLOCATOR(), rbs_location_new(ALLOCATOR(), type_name_range), namespace, symbol);
+            rbs_type_name_t *type_name = rbs_type_name_new(ALLOCATOR(), rbs_location_new(ALLOCATOR(), type_name_range), ns, symbol);
 
             rbs_range_t keyword_range = NULL_RANGE;
             rbs_range_t new_name_range = NULL_RANGE;
@@ -3062,7 +3165,7 @@ static bool parse_use_clauses(rbs_parser_t *parser, rbs_node_list_t *clauses) {
             rbs_loc_add_required_child(loc, INTERN("namespace"), namespace_range);
             rbs_loc_add_required_child(loc, INTERN("star"), star_range);
 
-            rbs_ast_directives_use_wildcard_clause_t *clause = rbs_ast_directives_use_wildcard_clause_new(ALLOCATOR(), loc, namespace);
+            rbs_ast_directives_use_wildcard_clause_t *clause = rbs_ast_directives_use_wildcard_clause_new(ALLOCATOR(), loc, ns);
             rbs_node_list_append(clauses, (rbs_node_t *) clause);
 
             break;
@@ -3109,23 +3212,25 @@ static bool parse_use_directive(rbs_parser_t *parser, rbs_ast_directives_use_t *
 }
 
 static rbs_ast_comment_t *parse_comment_lines(rbs_parser_t *parser, rbs_comment_t *com) {
-    size_t hash_bytes = parser->rbs_lexer_t->encoding->char_width((const uint8_t *) "#", (size_t) 1);
-    size_t space_bytes = parser->rbs_lexer_t->encoding->char_width((const uint8_t *) " ", (size_t) 1);
+    size_t hash_bytes = parser->lexer->encoding->char_width((const uint8_t *) "#", (size_t) 1);
+    size_t space_bytes = parser->lexer->encoding->char_width((const uint8_t *) " ", (size_t) 1);
 
     rbs_buffer_t rbs_buffer;
     rbs_buffer_init(ALLOCATOR(), &rbs_buffer);
 
-    for (size_t i = 0; i < com->line_count; i++) {
-        rbs_token_t tok = com->tokens[i];
+    for (size_t i = 0; i < com->line_tokens_count; i++) {
+        rbs_token_t tok = com->line_tokens[i];
 
-        const char *comment_start = parser->rbs_lexer_t->string.start + tok.range.start.byte_pos + hash_bytes;
+        const char *comment_start = parser->lexer->string.start + tok.range.start.byte_pos + hash_bytes;
         size_t comment_bytes = RBS_RANGE_BYTES(tok.range) - hash_bytes;
 
         rbs_string_t str = rbs_string_new(
             comment_start,
-            parser->rbs_lexer_t->string.end
+            parser->lexer->string.end
         );
-        unsigned char c = rbs_utf8_string_to_codepoint(str);
+
+        // Assumes the input is ASCII compatible
+        unsigned char c = str.start[0];
 
         if (c == ' ') {
             comment_start += space_bytes;
@@ -3160,42 +3265,43 @@ static rbs_comment_t *comment_get_comment(rbs_comment_t *com, int line) {
 }
 
 static void comment_insert_new_line(rbs_allocator_t *allocator, rbs_comment_t *com, rbs_token_t comment_token) {
-    if (com->line_count == 0) {
-        com->start = comment_token.range.start;
-    }
-
-    if (com->line_count == com->line_size) {
-        com->line_size += 10;
-
-        if (com->tokens) {
-            rbs_token_t *p = com->tokens;
-            com->tokens = rbs_allocator_calloc(allocator, com->line_size, rbs_token_t);
-            memcpy(com->tokens, p, sizeof(rbs_token_t) * com->line_count);
-        } else {
-            com->tokens = rbs_allocator_calloc(allocator, com->line_size, rbs_token_t);
-        }
+    if (com->line_tokens_count == com->line_tokens_capacity) {
+        size_t old_size = com->line_tokens_capacity;
+        size_t new_size = old_size * 2;
+        com->line_tokens_capacity = new_size;
+
+        com->line_tokens = rbs_allocator_realloc(
+            allocator,
+            com->line_tokens,
+            sizeof(rbs_token_t) * old_size,
+            sizeof(rbs_token_t) * new_size,
+            rbs_token_t
+        );
     }
 
-    com->tokens[com->line_count++] = comment_token;
+    com->line_tokens[com->line_tokens_count++] = comment_token;
     com->end = comment_token.range.end;
 }
 
 static rbs_comment_t *alloc_comment(rbs_allocator_t *allocator, rbs_token_t comment_token, rbs_comment_t *last_comment) {
     rbs_comment_t *new_comment = rbs_allocator_alloc(allocator, rbs_comment_t);
 
+    size_t initial_line_capacity = 10;
+
+    rbs_token_t *tokens = rbs_allocator_calloc(allocator, initial_line_capacity, rbs_token_t);
+    tokens[0] = comment_token;
+
     *new_comment = (rbs_comment_t) {
         .start = comment_token.range.start,
         .end = comment_token.range.end,
 
-        .line_size = 0,
-        .line_count = 0,
-        .tokens = NULL,
+        .line_tokens_capacity = initial_line_capacity,
+        .line_tokens_count = 1,
+        .line_tokens = tokens,
 
         .next_comment = last_comment,
     };
 
-    comment_insert_new_line(allocator, new_comment, comment_token);
-
     return new_comment;
 }
 
@@ -3340,7 +3446,7 @@ void rbs_parser_advance(rbs_parser_t *parser) {
             break;
         }
 
-        parser->next_token3 = rbs_lexer_next_token(parser->rbs_lexer_t);
+        parser->next_token3 = rbs_lexer_next_token(parser->lexer);
 
         if (parser->next_token3.type == tCOMMENT) {
             // skip
@@ -3363,6 +3469,14 @@ void rbs_print_token(rbs_token_t tok) {
     );
 }
 
+void rbs_print_lexer(rbs_lexer_t *lexer) {
+    printf("Lexer: (range = %d...%d, encoding = %s\n", lexer->start_pos, lexer->end_pos, lexer->encoding->name);
+    printf("  start = { char_pos = %d, byte_pos = %d }\n", lexer->start.char_pos, lexer->start.byte_pos);
+    printf("  current = { char_pos = %d, byte_pos = %d }\n", lexer->current.char_pos, lexer->current.byte_pos);
+    printf("  character = { code_point = %d (%c), bytes = %zu }\n", lexer->current_code_point, lexer->current_code_point < 256 ? lexer->current_code_point : '?', lexer->current_character_bytes);
+    printf("  first_token_of_line = %s\n", lexer->first_token_of_line ? "true" : "false");
+}
+
 rbs_ast_comment_t *rbs_parser_get_comment(rbs_parser_t *parser, int subject_line) {
     int comment_line = subject_line - 1;
 
@@ -3391,14 +3505,28 @@ rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *allocator, rbs_string_t string, cons
         .end_pos = end_pos,
         .current = start_position,
         .start = { 0 },
-        .first_token_of_line = false,
-        .last_char = 0,
+        .first_token_of_line = true,
+        .current_character_bytes = 0,
+        .current_code_point = '\0',
         .encoding = encoding,
     };
 
-    rbs_skipn(lexer, start_pos);
+    unsigned int codepoint;
+    size_t bytes;
+
+    if (rbs_next_char(lexer, &codepoint, &bytes)) {
+        lexer->current_code_point = codepoint;
+        lexer->current_character_bytes = bytes;
+    } else {
+        lexer->current_code_point = '\0';
+        lexer->current_character_bytes = 1;
+    }
+
+    if (start_pos > 0) {
+        rbs_skipn(lexer, start_pos);
+    }
+
     lexer->start = lexer->current;
-    lexer->first_token_of_line = lexer->current.column == 0;
 
     return lexer;
 }
@@ -3410,7 +3538,7 @@ rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding
     rbs_parser_t *parser = rbs_allocator_alloc(allocator, rbs_parser_t);
 
     *parser = (rbs_parser_t) {
-        .rbs_lexer_t = lexer,
+        .lexer = lexer,
 
         .current_token = NullToken,
         .next_token = NullToken,
@@ -3491,7 +3619,7 @@ static bool parse_method_overload(rbs_parser_t *parser, rbs_node_list_t *annotat
         return false;
     }
 
-    return rbs_parse_method_type(parser, method_type);
+    return rbs_parse_method_type(parser, method_type, false);
 }
 
 /*
@@ -3650,7 +3778,7 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
             rbs_location_t *colon_loc = rbs_location_new(ALLOCATOR(), colon_range);
 
             rbs_node_t *return_type = NULL;
-            if (!rbs_parse_type(parser, &return_type)) {
+            if (!rbs_parse_type(parser, &return_type, true, true)) {
                 return false;
             }
 
@@ -3678,6 +3806,53 @@ static bool parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_a
             );
             return true;
         }
+        case tAIDENT: {
+            // Parse instance variable annotation: @rbs @name: Type
+            rbs_parser_advance(parser);
+
+            rbs_range_t ivar_name_range = parser->current_token.range;
+            rbs_location_t *ivar_name_loc = rbs_location_new(ALLOCATOR(), ivar_name_range);
+
+            // Extract the instance variable name as a symbol
+            rbs_string_t ivar_string = rbs_parser_peek_current_token(parser);
+            rbs_constant_id_t ivar_id = rbs_constant_pool_insert_string(&parser->constant_pool, ivar_string);
+            rbs_ast_symbol_t *ivar_name = rbs_ast_symbol_new(ALLOCATOR(), ivar_name_loc, &parser->constant_pool, ivar_id);
+
+            ADVANCE_ASSERT(parser, pCOLON);
+
+            rbs_range_t colon_range = parser->current_token.range;
+            rbs_location_t *colon_loc = rbs_location_new(ALLOCATOR(), colon_range);
+
+            rbs_node_t *type = NULL;
+            if (!rbs_parse_type(parser, &type, false, true)) {
+                return false;
+            }
+
+            rbs_location_t *comment_loc = NULL;
+            if (!parse_inline_comment(parser, &comment_loc)) {
+                return false;
+            }
+
+            rbs_range_t full_range = {
+                .start = rbs_range.start,
+                .end = parser->current_token.range.end
+            };
+
+            rbs_location_t *full_loc = rbs_location_new(ALLOCATOR(), full_range);
+            rbs_location_t *rbs_loc = rbs_location_new(ALLOCATOR(), rbs_range);
+
+            *annotation = (rbs_ast_ruby_annotations_t *) rbs_ast_ruby_annotations_instance_variable_annotation_new(
+                ALLOCATOR(),
+                full_loc,
+                rbs_loc,
+                ivar_name,
+                ivar_name_loc,
+                colon_loc,
+                type,
+                comment_loc
+            );
+            return true;
+        }
         default: {
             rbs_parser_set_error(parser, parser->next_token, true, "unexpected token for @rbs annotation");
             return false;
@@ -3699,8 +3874,63 @@ static bool parse_inline_trailing_annotation(rbs_parser_t *parser, rbs_ast_ruby_
     case pCOLON: {
         rbs_parser_advance(parser);
 
+        // Check for class-alias or module-alias keywords
+        if (parser->next_token.type == kCLASSALIAS || parser->next_token.type == kMODULEALIAS) {
+            bool is_class_alias = (parser->next_token.type == kCLASSALIAS);
+            rbs_range_t keyword_range = parser->next_token.range;
+            rbs_location_t *keyword_loc = rbs_location_new(ALLOCATOR(), keyword_range);
+            rbs_parser_advance(parser);
+
+            rbs_type_name_t *type_name = NULL;
+            rbs_location_t *type_name_loc = NULL;
+            rbs_range_t full_range;
+
+            // Check if a type name is provided
+            if (parser->next_token.type == tUIDENT || parser->next_token.type == pCOLON2) {
+                rbs_parser_advance(parser);
+
+                rbs_range_t type_name_range;
+                if (!parse_type_name(parser, CLASS_NAME, &type_name_range, &type_name)) {
+                    return false;
+                }
+                // parse_type_name leaves current_token at the last identifier, don't advance
+                type_name_loc = rbs_location_new(ALLOCATOR(), type_name_range);
+                full_range.start = prefix_range.start;
+                full_range.end = type_name_range.end;
+            } else {
+                // No type name provided - will be inferred
+                full_range.start = prefix_range.start;
+                full_range.end = keyword_range.end;
+            }
+
+            rbs_location_t *full_loc = rbs_location_new(ALLOCATOR(), full_range);
+            rbs_location_t *prefix_loc = rbs_location_new(ALLOCATOR(), prefix_range);
+
+            if (is_class_alias) {
+                *annotation = (rbs_ast_ruby_annotations_t *) rbs_ast_ruby_annotations_class_alias_annotation_new(
+                    ALLOCATOR(),
+                    full_loc,
+                    prefix_loc,
+                    keyword_loc,
+                    type_name,
+                    type_name_loc
+                );
+            } else {
+                *annotation = (rbs_ast_ruby_annotations_t *) rbs_ast_ruby_annotations_module_alias_annotation_new(
+                    ALLOCATOR(),
+                    full_loc,
+                    prefix_loc,
+                    keyword_loc,
+                    type_name,
+                    type_name_loc
+                );
+            }
+            return true;
+        }
+
+        // Otherwise, parse as regular type assertion
         rbs_node_t *type = NULL;
-        if (!rbs_parse_type(parser, &type)) {
+        if (!rbs_parse_type(parser, &type, true, true)) {
             return false;
         }
 
@@ -3720,6 +3950,43 @@ static bool parse_inline_trailing_annotation(rbs_parser_t *parser, rbs_ast_ruby_
         );
         return true;
     }
+    case pLBRACKET: {
+        rbs_parser_advance(parser);
+
+        rbs_node_list_t *type_args = rbs_node_list_new(ALLOCATOR());
+        rbs_location_list_t *comma_locations = rbs_location_list_new(ALLOCATOR());
+
+        // Check for empty type args
+        if (parser->next_token.type == pRBRACKET) {
+            rbs_parser_set_error(parser, parser->next_token, true, "type application cannot be empty");
+            return false;
+        }
+
+        // Parse type list with comma tracking
+        CHECK_PARSE(parse_type_list_with_commas(parser, pRBRACKET, type_args, comma_locations, true, true));
+
+        rbs_range_t close_bracket_range = parser->next_token.range;
+        rbs_location_t *close_bracket_loc = rbs_location_new(ALLOCATOR(), close_bracket_range);
+        rbs_parser_advance(parser); // consume ]
+
+        rbs_range_t full_range = {
+            .start = prefix_range.start,
+            .end = close_bracket_range.end
+        };
+
+        rbs_location_t *full_loc = rbs_location_new(ALLOCATOR(), full_range);
+        rbs_location_t *prefix_loc = rbs_location_new(ALLOCATOR(), prefix_range);
+
+        *annotation = (rbs_ast_ruby_annotations_t *) rbs_ast_ruby_annotations_type_application_annotation_new(
+            ALLOCATOR(),
+            full_loc,
+            prefix_loc,
+            type_args,
+            close_bracket_loc,
+            comma_locations
+        );
+        return true;
+    }
     default: {
         rbs_parser_set_error(parser, parser->next_token, true, "unexpected token for inline trailing annotation");
         return false;