mt-lang 0.3.23 → 0.3.25

data/lib/milk_tea/core/lexer/strings.rb

@@ -58,14 +58,14 @@ module MilkTea
         start_offset = line_offset + index
         if consumed_lines == 1
           lexeme = line[index...segment.next_index]
-          @tokens << token(cstring ? :cstring : :string, lexeme, value, line_number, index + 1, start_offset:, end_offset: line_offset + segment.next_index)
+          @tokens << build_token(cstring ? :cstring : :string, lexeme, value, line_number, index + 1, start_offset:, end_offset: line_offset + segment.next_index)
           return StringLexResult.new(consumed_lines:, next_index: segment.next_index)
         end
 
         end_offset = last_line_offset + last_segment_end
         lexeme = @source.byteslice(start_offset, end_offset - start_offset)
-        @tokens << token(cstring ? :cstring : :string, lexeme, value, line_number, index + 1, start_offset:, end_offset:)
-        emit_line_newline(last_line, last_line_number, last_line_offset, last_line_has_newline)
+        @tokens << build_token(cstring ? :cstring : :string, lexeme, value, line_number, index + 1, start_offset:, end_offset:)
+        emit_newline(last_line, last_line_number, last_line_offset, last_line_has_newline)
         StringLexResult.new(consumed_lines:, next_index: last_segment_end)
       end
 
@@ -144,7 +144,7 @@ module MilkTea
         index += 1
 
         lexeme = line[start...index]
-        @tokens << token(:char_literal, lexeme, value, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index)
+        @tokens << build_token(:char_literal, lexeme, value, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index)
         index
       end
 

data/lib/milk_tea/core/lexer/symbols.rb

@@ -9,14 +9,14 @@ module MilkTea
         lexeme = line[index, 3]
         if lexeme && THREE_CHAR_TOKENS.key?(lexeme)
           type = THREE_CHAR_TOKENS.fetch(lexeme)
-          @tokens << token(type, lexeme, nil, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index + 3)
+          @tokens << build_token(type, lexeme, nil, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index + 3)
           return index + 3
         end
 
         lexeme = line[index, 2]
         if lexeme && TWO_CHAR_TOKENS.key?(lexeme)
           type = TWO_CHAR_TOKENS.fetch(lexeme)
-          @tokens << token(type, lexeme, nil, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index + 2)
+          @tokens << build_token(type, lexeme, nil, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index + 2)
           adjust_grouping_depth(type, line_number, start + 1)
           return index + 2
         end
@@ -37,7 +37,7 @@ module MilkTea
           raise LexError.new("unexpected character #{lexeme.inspect}", line: line_number, column: start + 1, path: @path)
         end
 
-        @tokens << token(type, lexeme, nil, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index + 1)
+        @tokens << build_token(type, lexeme, nil, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index + 1)
         adjust_grouping_depth(type, line_number, start + 1)
         index + 1
       end

data/lib/milk_tea/core/lexer/trivia.rb

@@ -9,7 +9,7 @@ module MilkTea
         @mode == :with_trivia
       end
 
-      def register_detached_line_trivia(kind, line, line_number, line_offset, has_newline:)
+      def record_line_trivia(kind, line, line_number, line_offset, has_newline:)
         return unless with_trivia?
 
         text = has_newline ? (line + "\n") : line
@@ -21,17 +21,17 @@ module MilkTea
           start_offset: line_offset,
           end_offset: line_offset + text.bytesize,
         )
-        push_pending_leading_trivia(trivia)
+        push_leading_trivia(trivia)
       end
 
-      def push_pending_leading_trivia(trivia)
+      def push_leading_trivia(trivia)
         return unless with_trivia?
 
         @trivia << trivia
         @pending_leading_trivia << trivia
       end
 
-      def append_trailing_or_pending(trivia)
+      def attach_trivia(trivia)
         return unless with_trivia?
 
         @trivia << trivia

data/lib/milk_tea/core/lexer.rb

@@ -171,10 +171,10 @@ module MilkTea
 
       while @indent_stack.length > 1
         @indent_stack.pop
-        @tokens << token(:dedent, "", nil, @line_count, 1, start_offset: @source.bytesize, end_offset: @source.bytesize)
+        @tokens << build_token(:dedent, "", nil, @line_count, 1, start_offset: @source.bytesize, end_offset: @source.bytesize)
       end
 
-      @tokens << token(:eof, "", nil, @line_count + 1, 1, start_offset: @source.bytesize, end_offset: @source.bytesize)
+      @tokens << build_token(:eof, "", nil, @line_count + 1, 1, start_offset: @source.bytesize, end_offset: @source.bytesize)
       return LexResult.new(tokens: @tokens, trivia: @trivia) if with_trivia?
 
       @tokens
@@ -193,12 +193,12 @@ module MilkTea
       end
 
       if line.strip.empty?
-        register_detached_line_trivia(:blank_line, line, line_number, line_offset, has_newline:)
+        record_line_trivia(:blank_line, line, line_number, line_offset, has_newline:)
         return 1
       end
 
       if line.lstrip.start_with?("#")
-        register_detached_line_trivia(:comment, line, line_number, line_offset, has_newline:)
+        record_line_trivia(:comment, line, line_number, line_offset, has_newline:)
         return 1
       end
 
@@ -206,11 +206,11 @@ module MilkTea
       if @recovery_errors && @grouping_depth.positive? && index.zero? && top_level_resync_line?(line)
         @recovery_errors << LexError.new("unclosed grouping delimiter", line: @grouping_start_line, column: @grouping_start_column, path: @path)
         @grouping_depth = 0
-        @tokens << token(:newline, "\n", nil, line_number, 1, start_offset: line_offset, end_offset: line_offset)
+        @tokens << build_token(:newline, "\n", nil, line_number, 1, start_offset: line_offset, end_offset: line_offset)
       end
 
       if with_trivia? && index.positive?
-        push_pending_leading_trivia(
+        push_leading_trivia(
           TriviaToken.new(
             kind: :space,
             text: line[0...index],
@@ -244,7 +244,7 @@ module MilkTea
           if with_trivia?
             span_start = index
             index += 1 while index < line.length && line[index] == " "
-            push_pending_leading_trivia(
+            push_leading_trivia(
               TriviaToken.new(
                 kind: :space,
                 text: line[span_start...index],
@@ -265,7 +265,7 @@ module MilkTea
           if with_trivia?
             comment_end = line.length
             comment_text = line[index...comment_end]
-            append_trailing_or_pending(
+            attach_trivia(
               TriviaToken.new(
                 kind: :comment,
                 text: comment_text,
@@ -280,7 +280,7 @@ module MilkTea
         end
 
         if (char == "c" || char == "f")
-          result = dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+          result = dispatch_prefixed_literal(char, line, index, line_number, line_offset, lines:, line_index:)
           if result
             if result[0] == :return
               return result[1]
@@ -327,10 +327,10 @@ module MilkTea
         if Token::LINE_CONTINUATION_OPERATORS.include?(@tokens.last&.type)
           @continuation_pending = true
         else
-          @tokens << token(:newline, "\n", nil, line_number, line.length + 1, start_offset: newline_start, end_offset: newline_end)
+          @tokens << build_token(:newline, "\n", nil, line_number, line.length + 1, start_offset: newline_start, end_offset: newline_end)
         end
       elsif with_trivia? && has_newline
-        append_trailing_or_pending(
+        attach_trivia(
           TriviaToken.new(
             kind: :newline,
             text: "\n",
@@ -345,14 +345,14 @@ module MilkTea
       1
     end
 
-    def emit_line_newline(line, line_number, line_offset, has_newline)
+    def emit_newline(line, line_number, line_offset, has_newline)
       newline_start = line_offset + line.bytesize
       newline_end = has_newline ? (newline_start + 1) : newline_start
 
       if @grouping_depth.zero?
-        @tokens << token(:newline, "\n", nil, line_number, line.bytesize + 1, start_offset: newline_start, end_offset: newline_end)
+        @tokens << build_token(:newline, "\n", nil, line_number, line.bytesize + 1, start_offset: newline_start, end_offset: newline_end)
       elsif with_trivia? && has_newline
-        append_trailing_or_pending(
+        attach_trivia(
           TriviaToken.new(
             kind: :newline,
             text: "\n",
@@ -365,7 +365,7 @@ module MilkTea
       end
     end
 
-    def dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+    def dispatch_prefixed_literal(char, line, index, line_number, line_offset, lines:, line_index:)
       return nil unless char == "c" || char == "f"
 
       is_c = char == "c"
@@ -377,7 +377,7 @@ module MilkTea
       end
 
       if line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
-        error = LexError.new("expected '<<-' for heredoc string; did you mean '#{char}<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
+        error = LexError.new("expected '<<-' for heredoc string; did you mean '#{char}<<-#{extract_identifier_at(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
         if @recovery_errors
           @recovery_errors << error
         else
@@ -402,7 +402,7 @@ module MilkTea
       nil
     end
 
-    def token(type, lexeme, literal, line, column, start_offset:, end_offset:)
+    def build_token(type, lexeme, literal, line, column, start_offset:, end_offset:)
       Token.new(
         type:,
         lexeme:,

data/lib/milk_tea/core/lowering/async/analysis.rb

@@ -1,237 +1,239 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module LowererAsync
-    def analyze_async_function(binding, statements)
-      env = empty_env
-      void_ptr = pointer_to(@ctx.types.fetch("void"))
-      wake_type = Types::Registry.function(
-        nil,
-        params: [Types::Registry.parameter("frame", void_ptr)],
-        return_type: @ctx.types.fetch("void"),
-      )
-      param_fields = {}
-      local_fields = {}
-      await_fields = {}
-      await_counter = 0
-
-      binding.body_params.each do |param_binding|
-        pointer = binding.type.receiver_type && binding.type.receiver_editable && param_binding.name == "this"
-        field_type = pointer ? pointer_to(param_binding.type) : param_binding.type
-        field_name = "param_#{param_binding.name}"
-        param_fields[param_binding.name] = {
-          field_name:,
-          type: field_type,
-          param_type: param_binding.type,
-          mutable: param_binding.mutable,
-          pointer:,
-        }
-        env[:scopes].last[param_binding.name] = local_binding(
-          type: param_binding.type,
-          linkage_name: field_name,
-          mutable: param_binding.mutable,
-          pointer:,
+  module Lowering
+    module Async
+      def analyze_async_function(binding, statements)
+        env = empty_env
+        void_ptr = pointer_to(@ctx.types.fetch("void"))
+        wake_type = Types::Registry.function(
+          nil,
+          params: [Types::Registry.parameter("frame", void_ptr)],
+          return_type: @ctx.types.fetch("void"),
         )
+        param_fields = {}
+        local_fields = {}
+        await_fields = {}
+        await_counter = 0
+
+        binding.body_params.each do |param_binding|
+          pointer = binding.type.receiver_type && binding.type.receiver_editable && param_binding.name == "this"
+          field_type = pointer ? pointer_to(param_binding.type) : param_binding.type
+          field_name = "param_#{param_binding.name}"
+          param_fields[param_binding.name] = {
+            field_name:,
+            type: field_type,
+            param_type: param_binding.type,
+            mutable: param_binding.mutable,
+            pointer:,
+          }
+          env[:scopes].last[param_binding.name] = local_binding(
+            type: param_binding.type,
+            linkage_name: field_name,
+            mutable: param_binding.mutable,
+            pointer:,
+          )
+        end
+        env[:return_context] = {
+          return_type: binding.body_return_type,
+          active_defers: [],
+          local_defers: [],
+          allow_return: true,
+        }
+
+        await_counter = analyze_async_statements!(statements, await_counter, env, param_fields, local_fields, await_fields)
+
+        {
+          task_type: binding.type.return_type,
+          result_type: binding.body_return_type,
+          void_ptr:,
+          wake_type:,
+          param_fields:,
+          local_fields:,
+          await_fields:,
+          format_str_fields: {},
+        }
       end
-      env[:return_context] = {
-        return_type: binding.body_return_type,
-        active_defers: [],
-        local_defers: [],
-        allow_return: true,
-      }
-
-      await_counter = analyze_async_statements!(statements, await_counter, env, param_fields, local_fields, await_fields)
-
-      {
-        task_type: binding.type.return_type,
-        result_type: binding.body_return_type,
-        void_ptr:,
-        wake_type:,
-        param_fields:,
-        local_fields:,
-        await_fields:,
-        format_str_fields: {},
-      }
-    end
 
-    # Recursively scan nested statement bodies for await slots, assigning state IDs.
-    # Returns the updated await_counter.
-    def analyze_async_statements!(statements, await_counter, env, param_fields, local_fields, await_fields)
-      statements.each do |statement|
-        case statement
-        when AST::LocalDecl
-          type, storage_type = async_local_decl_types(statement, env:)
-          local_field_key = async_local_decl_field_key(statement)
-          local_fields[local_field_key] ||= { field_name: async_local_decl_field_name(statement), type:, storage_type:, mutable: statement.kind == :var }
-          if statement.value.is_a?(AST::AwaitExpr)
-            await_fields[statement.value.object_id] = build_async_await_field_info(statement.value, await_counter, env:, param_fields:, local_fields:)
-            await_counter += 1
-          end
-          if bind_let_else_local?(statement)
-            env[:scopes].last[statement.name] = local_binding(
-              type:,
-              storage_type:,
-              linkage_name: statement.name,
-              mutable: statement.kind == :var,
-              pointer: false,
-              const_value: statement.else_body ? nil : statement.kind == :let && statement.value ? compile_time_const_value(statement.value, env:) : nil,
-            )
-          end
-          await_counter = analyze_async_statements!(statement.else_body, await_counter, env, param_fields, local_fields, await_fields) if statement.else_body
-        when AST::Assignment
-          if statement.value.is_a?(AST::AwaitExpr)
-            await_fields[statement.value.object_id] = build_async_await_field_info(statement.value, await_counter, env:, param_fields:, local_fields:)
-            await_counter += 1
-          end
-        when AST::ExpressionStmt
-          if statement.expression.is_a?(AST::AwaitExpr)
-            await_fields[statement.expression.object_id] = build_async_await_field_info(statement.expression, await_counter, env:, param_fields:, local_fields:)
-            await_counter += 1
-          end
-        when AST::ReturnStmt
-          if statement.value&.is_a?(AST::AwaitExpr)
-            await_fields[statement.value.object_id] = build_async_await_field_info(statement.value, await_counter, env:, param_fields:, local_fields:)
-            await_counter += 1
-          end
-        when AST::IfStmt
-          statement.branches.each do |branch|
-            await_counter = analyze_async_statements!(branch.body, await_counter, env, param_fields, local_fields, await_fields)
-          end
-          await_counter = analyze_async_statements!(statement.else_body, await_counter, env, param_fields, local_fields, await_fields) if statement.else_body
-        when AST::WhileStmt
-          await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
-        when AST::ForStmt
-          if range_iterable?(statement.iterable)
-            loop_type = infer_range_loop_type(statement.iterable, env:)
-            local_fields[statement.name] ||= { field_name: "local_#{statement.name}", type: loop_type, storage_type: loop_type, mutable: true }
-            stop_field_name = "local_#{statement.name}_stop"
-            local_fields[stop_field_name] ||= { field_name: stop_field_name, type: loop_type, storage_type: loop_type, mutable: true }
-          else
-            statement.bindings.each_with_index do |binding, index|
-              iterable_type = infer_expression_type(statement.iterables[index], env:)
-              element_type = collection_loop_type(iterable_type)
-              binding_type = collection_loop_binding_type(iterable_type, element_type) || element_type
-              local_fields[binding.name] ||= { field_name: "local_#{binding.name}", type: binding_type, storage_type: binding_type, mutable: true }
-              iterable_field_name = async_collection_iterable_field_name(statement, index)
-              iterable_field_key = async_collection_iterable_field_key(statement, index)
-              local_fields[iterable_field_key] ||= { field_name: iterable_field_name, type: iterable_type, storage_type: iterable_type, mutable: true }
+      # Recursively scan nested statement bodies for await slots, assigning state IDs.
+      # Returns the updated await_counter.
+      def analyze_async_statements!(statements, await_counter, env, param_fields, local_fields, await_fields)
+        statements.each do |statement|
+          case statement
+          when AST::LocalDecl
+            type, storage_type = async_local_decl_types(statement, env:)
+            local_field_key = async_local_decl_field_key(statement)
+            local_fields[local_field_key] ||= { field_name: async_local_decl_field_name(statement), type:, storage_type:, mutable: statement.kind == :var }
+            if statement.value.is_a?(AST::AwaitExpr)
+              await_fields[statement.value.object_id] = build_async_await_field_info(statement.value, await_counter, env:, param_fields:, local_fields:)
+              await_counter += 1
             end
-            index_field_name = async_collection_index_field_name(statement)
-            index_field_key = async_collection_index_field_key(statement)
-            local_fields[index_field_key] ||= { field_name: index_field_name, type: @ctx.types.fetch("ptr_uint"), storage_type: @ctx.types.fetch("ptr_uint"), mutable: true }
-          end
-          await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
-        when AST::MatchStmt
-          scrutinee_type = infer_expression_type(statement.expression, env:)
-          statement.arms.each do |arm|
-            arm_env = duplicate_env(env)
-            bind_async_variant_match_arm_env!(arm_env, scrutinee_type, arm)
-            arm_await_count = await_counter
-            await_counter = analyze_async_statements!(arm.body, await_counter, arm_env, param_fields, local_fields, await_fields)
-            if arm.binding_name && await_counter > arm_await_count
-              field_key = async_match_binding_field_key(arm)
-              unless local_fields.key?(field_key)
-                arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-                if arm_name
-                  arm_binding = arm_env[:scopes].last[arm.binding_name]
-                  payload_type = arm_binding && arm_binding[:type]
-                  if payload_type
-                    local_fields[field_key] = { field_name: async_match_binding_field_name(arm), type: payload_type, storage_type: payload_type, mutable: false }
+            if bind_let_else_local?(statement)
+              env[:scopes].last[statement.name] = local_binding(
+                type:,
+                storage_type:,
+                linkage_name: statement.name,
+                mutable: statement.kind == :var,
+                pointer: false,
+                const_value: statement.else_body ? nil : statement.kind == :let && statement.value ? compile_time_const_value(statement.value, env:) : nil,
+              )
+            end
+            await_counter = analyze_async_statements!(statement.else_body, await_counter, env, param_fields, local_fields, await_fields) if statement.else_body
+          when AST::Assignment
+            if statement.value.is_a?(AST::AwaitExpr)
+              await_fields[statement.value.object_id] = build_async_await_field_info(statement.value, await_counter, env:, param_fields:, local_fields:)
+              await_counter += 1
+            end
+          when AST::ExpressionStmt
+            if statement.expression.is_a?(AST::AwaitExpr)
+              await_fields[statement.expression.object_id] = build_async_await_field_info(statement.expression, await_counter, env:, param_fields:, local_fields:)
+              await_counter += 1
+            end
+          when AST::ReturnStmt
+            if statement.value&.is_a?(AST::AwaitExpr)
+              await_fields[statement.value.object_id] = build_async_await_field_info(statement.value, await_counter, env:, param_fields:, local_fields:)
+              await_counter += 1
+            end
+          when AST::IfStmt
+            statement.branches.each do |branch|
+              await_counter = analyze_async_statements!(branch.body, await_counter, env, param_fields, local_fields, await_fields)
+            end
+            await_counter = analyze_async_statements!(statement.else_body, await_counter, env, param_fields, local_fields, await_fields) if statement.else_body
+          when AST::WhileStmt
+            await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
+          when AST::ForStmt
+            if range_iterable?(statement.iterable)
+              loop_type = infer_range_loop_type(statement.iterable, env:)
+              local_fields[statement.name] ||= { field_name: "local_#{statement.name}", type: loop_type, storage_type: loop_type, mutable: true }
+              stop_field_name = "local_#{statement.name}_stop"
+              local_fields[stop_field_name] ||= { field_name: stop_field_name, type: loop_type, storage_type: loop_type, mutable: true }
+            else
+              statement.bindings.each_with_index do |binding, index|
+                iterable_type = infer_expression_type(statement.iterables[index], env:)
+                element_type = collection_loop_type(iterable_type)
+                binding_type = collection_loop_binding_type(iterable_type, element_type) || element_type
+                local_fields[binding.name] ||= { field_name: "local_#{binding.name}", type: binding_type, storage_type: binding_type, mutable: true }
+                iterable_field_name = async_collection_iterable_field_name(statement, index)
+                iterable_field_key = async_collection_iterable_field_key(statement, index)
+                local_fields[iterable_field_key] ||= { field_name: iterable_field_name, type: iterable_type, storage_type: iterable_type, mutable: true }
+              end
+              index_field_name = async_collection_index_field_name(statement)
+              index_field_key = async_collection_index_field_key(statement)
+              local_fields[index_field_key] ||= { field_name: index_field_name, type: @ctx.types.fetch("ptr_uint"), storage_type: @ctx.types.fetch("ptr_uint"), mutable: true }
+            end
+            await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
+          when AST::MatchStmt
+            scrutinee_type = infer_expression_type(statement.expression, env:)
+            statement.arms.each do |arm|
+              arm_env = duplicate_env(env)
+              bind_async_variant_match_arm_env!(arm_env, scrutinee_type, arm)
+              arm_await_count = await_counter
+              await_counter = analyze_async_statements!(arm.body, await_counter, arm_env, param_fields, local_fields, await_fields)
+              if arm.binding_name && await_counter > arm_await_count
+                field_key = async_match_binding_field_key(arm)
+                unless local_fields.key?(field_key)
+                  arm_name = variant_match_arm_name_from_pattern(arm.pattern)
+                  if arm_name
+                    arm_binding = arm_env[:scopes].last[arm.binding_name]
+                    payload_type = arm_binding && arm_binding[:type]
+                    if payload_type
+                      local_fields[field_key] = { field_name: async_match_binding_field_name(arm), type: payload_type, storage_type: payload_type, mutable: false }
+                    end
                   end
                 end
               end
             end
+          when AST::UnsafeStmt
+            await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
+          when AST::DeferStmt
+            cleanup_env = duplicate_env(env)
+            cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
+            await_counter = analyze_async_statements!(statement.body, await_counter, cleanup_env, param_fields, local_fields, await_fields)
+          else
+            nil
           end
-        when AST::UnsafeStmt
-          await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
-        when AST::DeferStmt
-          cleanup_env = duplicate_env(env)
-          cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
-          await_counter = analyze_async_statements!(statement.body, await_counter, cleanup_env, param_fields, local_fields, await_fields)
-        else
-          nil
         end
+        await_counter
       end
-      await_counter
-    end
 
-    def async_local_decl_types(statement, env:)
-      storage_type = if statement.else_body
-                       infer_expression_type(statement.value, env:)
-                     elsif statement.type
-                       resolve_type_ref(statement.type)
-                     else
-                       infer_expression_type(statement.value, env:)
-                     end
-      type = if statement.else_body
-               statement.type ? resolve_type_ref(statement.type) : let_else_success_type(storage_type)
-             else
-               storage_type
-             end
-
-      [type, storage_type]
-    end
+      def async_local_decl_types(statement, env:)
+        storage_type = if statement.else_body
+                        infer_expression_type(statement.value, env:)
+                      elsif statement.type
+                        resolve_type_ref(statement.type)
+                      else
+                        infer_expression_type(statement.value, env:)
+                      end
+        type = if statement.else_body
+                statement.type ? resolve_type_ref(statement.type) : let_else_success_type(storage_type)
+              else
+                storage_type
+              end
 
-    def async_collection_iterable_field_key(statement, index = 0)
-      "__async_for_iterable_#{statement.line}_#{index}"
-    end
+        [type, storage_type]
+      end
 
-    def async_collection_iterable_field_name(statement, index = 0)
-      "for_iterable_#{statement.line}_#{index}"
-    end
+      def async_collection_iterable_field_key(statement, index = 0)
+        "__async_for_iterable_#{statement.line}_#{index}"
+      end
 
-    def async_collection_index_field_key(statement)
-      "__async_for_index_#{statement.line}"
-    end
+      def async_collection_iterable_field_name(statement, index = 0)
+        "for_iterable_#{statement.line}_#{index}"
+      end
 
-    def async_collection_index_field_name(statement)
-      "for_index_#{statement.line}"
-    end
+      def async_collection_index_field_key(statement)
+        "__async_for_index_#{statement.line}"
+      end
 
-    def build_async_await_field_info(await_expression, await_counter, env:, param_fields:, local_fields:)
-      task_expression = await_expression.expression
-      reused_field_name = reusable_async_await_task_field_name(task_expression, param_fields:, local_fields:)
-      {
-        field_name: reused_field_name || "await_#{await_counter}",
-        task_type: infer_expression_type(task_expression, env:),
-        result_type: infer_expression_type(await_expression, env:),
-        state: await_counter + 1,
-        reuse_existing_storage: !reused_field_name.nil?,
-      }
-    end
+      def async_collection_index_field_name(statement)
+        "for_index_#{statement.line}"
+      end
 
-    def reusable_async_await_task_field_name(task_expression, param_fields:, local_fields:)
-      return unless task_expression.is_a?(AST::Identifier)
-      return local_fields.fetch(task_expression.name)[:field_name] if local_fields.key?(task_expression.name)
-      return param_fields.fetch(task_expression.name)[:field_name] if param_fields.key?(task_expression.name)
+      def build_async_await_field_info(await_expression, await_counter, env:, param_fields:, local_fields:)
+        task_expression = await_expression.expression
+        reused_field_name = reusable_async_await_task_field_name(task_expression, param_fields:, local_fields:)
+        {
+          field_name: reused_field_name || "await_#{await_counter}",
+          task_type: infer_expression_type(task_expression, env:),
+          result_type: infer_expression_type(await_expression, env:),
+          state: await_counter + 1,
+          reuse_existing_storage: !reused_field_name.nil?,
+        }
+      end
 
-      nil
-    end
+      def reusable_async_await_task_field_name(task_expression, param_fields:, local_fields:)
+        return unless task_expression.is_a?(AST::Identifier)
+        return local_fields.fetch(task_expression.name)[:field_name] if local_fields.key?(task_expression.name)
+        return param_fields.fetch(task_expression.name)[:field_name] if param_fields.key?(task_expression.name)
 
-    def build_async_frame_type(frame_linkage_name, async_info)
-      fields = {
-        "ready" => @ctx.types.fetch("bool"),
-        "cancelled" => @ctx.types.fetch("bool"),
-        "waiter_frame" => async_info[:void_ptr],
-        "waiter" => async_info[:wake_type],
-      }
-      fields["state"] = @ctx.types.fetch("int") unless async_info[:await_fields].empty?
-      unless async_info[:result_type] == @ctx.types.fetch("void")
-        fields["result"] = async_info[:result_type]
-      end
-      async_info[:param_fields].each_value do |field_info|
-        fields[field_info[:field_name]] = field_info[:type]
+        nil
       end
-      async_info[:local_fields].each_value do |field_info|
-        fields[field_info[:field_name]] = field_info[:storage_type]
-      end
-      async_info[:await_fields].each_value do |field_info|
-        next if fields.key?(field_info[:field_name])
 
-        fields[field_info[:field_name]] = field_info[:task_type]
-      end
+      def build_async_frame_type(frame_linkage_name, async_info)
+        fields = {
+          "ready" => @ctx.types.fetch("bool"),
+          "cancelled" => @ctx.types.fetch("bool"),
+          "waiter_frame" => async_info[:void_ptr],
+          "waiter" => async_info[:wake_type],
+        }
+        fields["state"] = @ctx.types.fetch("int") unless async_info[:await_fields].empty?
+        unless async_info[:result_type] == @ctx.types.fetch("void")
+          fields["result"] = async_info[:result_type]
+        end
+        async_info[:param_fields].each_value do |field_info|
+          fields[field_info[:field_name]] = field_info[:type]
+        end
+        async_info[:local_fields].each_value do |field_info|
+          fields[field_info[:field_name]] = field_info[:storage_type]
+        end
+        async_info[:await_fields].each_value do |field_info|
+          next if fields.key?(field_info[:field_name])
 
-      Types::Struct.new(frame_linkage_name).define_fields(fields)
+          fields[field_info[:field_name]] = field_info[:task_type]
+        end
+
+        Types::Struct.new(frame_linkage_name).define_fields(fields)
+      end
     end
   end
 end