mt-lang 0.2.0

data/lib/milk_tea/core/lexer.rb

@@ -0,0 +1,430 @@
+# frozen_string_literal: true
+
+require_relative "lexer/character_classes"
+require_relative "lexer/trivia"
+require_relative "lexer/indentation"
+require_relative "lexer/numbers"
+require_relative "lexer/strings"
+require_relative "lexer/heredocs"
+require_relative "lexer/format_strings"
+require_relative "lexer/symbols"
+require_relative "lexer/recovery"
+
+module MilkTea
+  class LexError < StandardError
+    attr_reader :line, :column, :path
+
+    def initialize(message, line:, column:, path: nil)
+      @line = line
+      @column = column
+      @path = path
+
+      location = [path, "#{line}:#{column}"].compact.join(":")
+      super(location.empty? ? message : "#{message} at #{location}")
+    end
+
+    def code
+      "lex/error"
+    end
+  end
+
+  class Lexer
+    LexResult = Data.define(:tokens, :trivia)
+    StringLexResult = Data.define(:consumed_lines, :next_index)
+    StringSegment = Data.define(:next_index, :value, :recovered) do
+      def initialize(next_index:, value:, recovered: false)
+        super(next_index:, value:, recovered:)
+      end
+    end
+
+    TOP_LEVEL_RESYNC_PREFIXES = %w[
+      attribute const enum external flags foreign function include import interface
+      link opaque public static_assert struct type union var variant extending event
+    ].freeze
+
+    LINE_CONTINUATION_OPERATORS = %i[
+      dot_dot
+      plus minus star slash percent
+      pipe amp caret
+      or and
+      equal_equal bang_equal
+      less less_equal greater greater_equal
+      shift_left shift_right
+    ].freeze
+
+    THREE_CHAR_TOKENS = {
+      "..." => :ellipsis,
+      "<<=" => :shift_left_equal,
+      ">>=" => :shift_right_equal,
+    }.freeze
+
+    TWO_CHAR_TOKENS = {
+      "->" => :arrow,
+      ".." => :dot_dot,
+      "<<" => :shift_left,
+      ">>" => :shift_right,
+      "+=" => :plus_equal,
+      "-=" => :minus_equal,
+      "*=" => :star_equal,
+      "/=" => :slash_equal,
+      "%=" => :percent_equal,
+      "&=" => :amp_equal,
+      "|=" => :pipe_equal,
+      "^=" => :caret_equal,
+      "==" => :equal_equal,
+      "!=" => :bang_equal,
+      "<=" => :less_equal,
+      ">=" => :greater_equal,
+    }.freeze
+
+    ONE_CHAR_TOKENS = {
+      "&" => :amp,
+      "@" => :at,
+      ":" => :colon,
+      "," => :comma,
+      "^" => :caret,
+      "." => :dot,
+      "(" => :lparen,
+      ")" => :rparen,
+      "|" => :pipe,
+      "[" => :lbracket,
+      "]" => :rbracket,
+      "?" => :question,
+      "=" => :equal,
+      "+" => :plus,
+      "-" => :minus,
+      "*" => :star,
+      "/" => :slash,
+      "%" => :percent,
+      "<" => :less,
+      ">" => :greater,
+      "~" => :tilde,
+    }.freeze
+
+    INTEGER_SUFFIX_STRINGS = %w[ub us ul iz b s i u l z].sort_by { |s| -s.length }.freeze
+
+    # Byte-classification lookup tables (indexed 0..255). Scanning by raw byte
+    # via String#getbyte avoids allocating a one-character String and running
+    # the regex engine for every source character, which dominated lexing.
+    IDENT_START_BYTE = Array.new(256) { |b| b.chr.match?(/[A-Za-z_]/) }.freeze
+    IDENT_PART_BYTE = Array.new(256) { |b| b.chr.match?(/[A-Za-z0-9_]/) }.freeze
+    DIGIT_BYTE = Array.new(256) { |b| b.chr.match?(/[0-9]/) }.freeze
+    NUMERIC_PART_BYTE = Array.new(256) { |b| b.chr.match?(/[0-9_]/) }.freeze
+    HEX_DIGIT_BYTE = Array.new(256) { |b| b.chr.match?(/[0-9a-fA-F_]/) }.freeze
+    BIN_DIGIT_BYTE = Array.new(256) { |b| b.chr.match?(/[01_]/) }.freeze
+    SPACE_BYTE = " ".ord
+
+    def self.lex(source, path: nil, mode: :syntax_only, recovery_errors: nil)
+      result = new(source, path: path, mode:, recovery_errors:).lex
+      mode == :with_trivia ? result.tokens : result
+    end
+
+    def self.lex_with_trivia(source, path: nil)
+      new(source, path: path, mode: :with_trivia).lex
+    end
+
+    def initialize(source, path: nil, mode: :syntax_only, recovery_errors: nil)
+      @source = source.gsub(/\r\n?/, "\n")
+      @path = path
+      @mode = mode
+      @recovery_errors = recovery_errors
+      @tokens = []
+      @trivia = []
+      @pending_leading_trivia = []
+      @indent_stack = [0]
+      @grouping_depth = 0
+      @grouping_start_line = 0
+      @grouping_start_column = 0
+      @line_count = @source.empty? ? 1 : @source.lines.count
+      @continuation_pending = false
+    end
+
+    def lex
+      lines = @source.each_line.to_a
+      line_offset = 0
+      line_number = 1
+      line_index = 0
+
+      while line_index < lines.length
+        raw_line = lines[line_index]
+        has_newline = raw_line.end_with?("\n")
+        line = raw_line.delete_suffix("\n").b
+        consumed_lines = lex_line(lines, line_index, line, line_number, line_offset, has_newline:)
+
+        consumed_lines.times do |delta|
+          line_offset += lines.fetch(line_index + delta).bytesize
+        end
+        line_number += consumed_lines
+        line_index += consumed_lines
+      end
+
+      if @grouping_depth.positive?
+        if @recovery_errors
+          @recovery_errors << LexError.new("unclosed grouping delimiter", line: @grouping_start_line, column: @grouping_start_column, path: @path)
+          @grouping_depth = 0
+        else
+          raise LexError.new("unclosed grouping delimiter", line: @line_count, column: 1, path: @path)
+        end
+      end
+
+      while @indent_stack.length > 1
+        @indent_stack.pop
+        @tokens << 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)
+      return LexResult.new(tokens: @tokens, trivia: @trivia) if with_trivia?
+
+      @tokens
+    end
+
+    private
+
+    include CharacterClasses
+    include Trivia
+    include Indentation
+    include Numbers
+    include Strings
+    include Heredocs
+    include FormatStrings
+    include Symbols
+    include Recovery
+
+    def lex_line(lines, line_index, line, line_number, line_offset, has_newline:)
+      tab_index = line.index("\t")
+      if tab_index
+        error = LexError.new("tabs are not allowed; use 4 spaces for indentation", line: line_number, column: tab_index + 1, path: @path)
+        if @recovery_errors
+          @recovery_errors << error
+          line = line.gsub("\t", "    ")
+        else
+          raise error
+        end
+      end
+
+      if line.strip.empty?
+        register_detached_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:)
+        return 1
+      end
+
+      index = leading_space_count(line)
+      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)
+      end
+
+      if with_trivia? && index.positive?
+        push_pending_leading_trivia(
+          TriviaToken.new(
+            kind: :space,
+            text: line[0...index],
+            line: line_number,
+            column: 1,
+            start_offset: line_offset,
+            end_offset: line_offset + index,
+          ),
+        )
+      end
+
+      if @grouping_depth.zero?
+        if @continuation_pending
+        elsif @recovery_errors
+          begin
+            emit_indentation(index, line_number, line_offset)
+          rescue LexError => e
+            @recovery_errors << e
+            recover_indentation(index, line_number, line_offset)
+          end
+        else
+          emit_indentation(index, line_number, line_offset)
+        end
+      end
+      @continuation_pending = false
+
+      while index < line.length
+        char = line[index]
+
+        if char == " "
+          if with_trivia?
+            span_start = index
+            index += 1 while index < line.length && line[index] == " "
+            push_pending_leading_trivia(
+              TriviaToken.new(
+                kind: :space,
+                text: line[span_start...index],
+                line: line_number,
+                column: span_start + 1,
+                start_offset: line_offset + span_start,
+                end_offset: line_offset + index,
+              ),
+            )
+            next
+          end
+
+          index += 1
+          next
+        end
+
+        if char == "#"
+          if with_trivia?
+            comment_end = line.length
+            comment_text = line[index...comment_end]
+            append_trailing_or_pending(
+              TriviaToken.new(
+                kind: :comment,
+                text: comment_text,
+                line: line_number,
+                column: index + 1,
+                start_offset: line_offset + index,
+                end_offset: line_offset + comment_end,
+              ),
+            )
+          end
+          break
+        end
+
+        if char == "c" && heredoc_start?(line, index, cstring: true)
+          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: true)
+        end
+
+        if char == "c" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
+          error = LexError.new("expected '<<-' for heredoc string; did you mean 'c<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
+          if @recovery_errors
+            @recovery_errors << error
+          else
+            raise error
+          end
+        end
+        if char == "c" && line[index + 1] == '"'
+          result = lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: true)
+          return result.consumed_lines if result.consumed_lines > 1
+
+          index = result.next_index
+          next
+        end
+
+        if char == "f" && heredoc_start?(line, index, format: true)
+          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false, format: true)
+        end
+
+        if char == "f" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
+          error = LexError.new("expected '<<-' for heredoc string; did you mean 'f<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
+          if @recovery_errors
+            @recovery_errors << error
+          else
+            raise error
+          end
+        end
+
+        if char == "f" && line[index + 1] == '"'
+          index = lex_format_string(line, index, line_number, line_offset:)
+          next
+        end
+
+        if char == "<" && heredoc_start?(line, index)
+          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false)
+        end
+
+        if char == '"'
+          result = lex_string(lines, line_index, line, index, line_number, line_offset:)
+          return result.consumed_lines if result.consumed_lines > 1
+
+          index = result.next_index
+          next
+        end
+
+        if char == "'"
+          index = lex_char_literal(line, index, line_number, line_offset:)
+          next
+        end
+
+        if identifier_start?(char)
+          index = lex_identifier(line, index, line_number, line_offset:)
+          next
+        end
+
+        if digit?(char)
+          index = lex_number(line, index, line_number, line_offset:)
+          next
+        end
+
+        index = lex_symbol(line, index, line_number, line_offset:)
+      end
+
+      newline_start = line_offset + line.length
+      newline_end = has_newline ? (newline_start + 1) : newline_start
+      if @grouping_depth.zero?
+        if 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)
+        end
+      elsif with_trivia? && has_newline
+        append_trailing_or_pending(
+          TriviaToken.new(
+            kind: :newline,
+            text: "\n",
+            line: line_number,
+            column: line.length + 1,
+            start_offset: newline_start,
+            end_offset: newline_end,
+          ),
+        )
+      end
+
+      1
+    end
+
+    # ── newline emission ────────────────────────────────────────────
+
+    def emit_line_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)
+      elsif with_trivia? && has_newline
+        append_trailing_or_pending(
+          TriviaToken.new(
+            kind: :newline,
+            text: "\n",
+            line: line_number,
+            column: line.bytesize + 1,
+            start_offset: newline_start,
+            end_offset: newline_end,
+          ),
+        )
+      end
+    end
+
+    # ── token construction ──────────────────────────────────────────
+
+    def token(type, lexeme, literal, line, column, start_offset:, end_offset:)
+      Token.new(
+        type:,
+        lexeme:,
+        literal:,
+        line:,
+        column:,
+        start_offset:,
+        end_offset:,
+        leading_trivia: consume_pending_leading_trivia,
+        trailing_trivia: [],
+      )
+    end
+
+    def consume_pending_leading_trivia
+      return [] unless with_trivia?
+
+      trivia = @pending_leading_trivia
+      @pending_leading_trivia = []
+      trivia
+    end
+  end
+end

data/lib/milk_tea/core/lowering/artifacts.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class Lowerer
+    class Artifacts
+      attr_accessor :synthetic_structs, :synthetic_enums, :synthetic_functions, :synthetic_constants
+      attr_accessor :emitted_declarations, :external_layout_assertions, :emitted_external_layout_pairs
+      attr_accessor :lowered_function_linkage_names, :event_runtime_infos
+      attr_accessor :subscription_runtime_emitted, :event_error_enum_emitted
+
+      def initialize
+        @synthetic_structs = []
+        @synthetic_enums = []
+        @synthetic_functions = []
+        @synthetic_constants = []
+        @emitted_declarations = []
+        @external_layout_assertions = []
+        @emitted_external_layout_pairs = {}
+        @lowered_function_linkage_names = {}
+        @event_runtime_infos = {}
+        @subscription_runtime_emitted = false
+        @event_error_enum_emitted = false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LowererAsync
+    private
+
+    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
+
+    # 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 }
+            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
+          if statement.body
+            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)
+          end
+          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
+        else
+          nil
+        end
+      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_collection_iterable_field_key(statement, index = 0)
+      "__async_for_iterable_#{statement.line}_#{index}"
+    end
+
+    def async_collection_iterable_field_name(statement, index = 0)
+      "for_iterable_#{statement.line}_#{index}"
+    end
+
+    def async_collection_index_field_key(statement)
+      "__async_for_index_#{statement.line}"
+    end
+
+    def async_collection_index_field_name(statement)
+      "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 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)
+
+      nil
+    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])
+
+        fields[field_info[:field_name]] = field_info[:task_type]
+      end
+
+      Types::Struct.new(frame_linkage_name).define_fields(fields)
+    end
+  end
+end