mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/core/c_backend/type_collectors.rb

@@ -3,1439 +3,1437 @@
 module MilkTea
   class CBackend
     module TypeCollectors
-      private
-
-          def collect_checked_array_index_types(nullable_only: false)
-            array_types = []
-            emitted_functions.each do |function|
-              collect_checked_array_index_types_from_statements(function.body, array_types, nullable_only:)
-            end
-            array_types.uniq
-          end
-
-          def collect_checked_span_index_types(nullable_only: false)
-            span_types = []
-            emitted_functions.each do |function|
-              collect_checked_span_index_types_from_statements(function.body, span_types, nullable_only:)
-            end
-            span_types.uniq
-          end
-
-          def collect_checked_array_index_types_from_statements(statements, array_types, nullable_only: false)
-            statements.each do |statement|
-              case statement
-              when IR::LocalDecl
-                collect_checked_array_index_types_from_expression(statement.value, array_types, nullable_only:)
-              when IR::Assignment
-                collect_checked_array_index_types_from_expression(statement.target, array_types, nullable_only:)
-                collect_checked_array_index_types_from_expression(statement.value, array_types, nullable_only:)
-              when IR::BlockStmt
-                collect_checked_array_index_types_from_statements(statement.body, array_types, nullable_only:)
-              when IR::WhileStmt
-                collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
-                collect_checked_array_index_types_from_statements(statement.body, array_types, nullable_only:)
-              when IR::ForStmt
-                collect_checked_array_index_types_from_statements([statement.init], array_types, nullable_only:)
-                collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
-                collect_checked_array_index_types_from_statements(statement.body, array_types, nullable_only:)
-                collect_checked_array_index_types_from_statements([statement.post], array_types, nullable_only:)
-              when IR::IfStmt
-                collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
-                collect_checked_array_index_types_from_statements(statement.then_body, array_types, nullable_only:)
-                collect_checked_array_index_types_from_statements(statement.else_body, array_types, nullable_only:) if statement.else_body
-              when IR::SwitchStmt
-                collect_checked_array_index_types_from_expression(statement.expression, array_types, nullable_only:)
-                statement.cases.each do |switch_case|
-                  collect_checked_array_index_types_from_statements(switch_case.body, array_types, nullable_only:)
-                end
-              when IR::StaticAssert
-                collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
-                collect_checked_array_index_types_from_expression(statement.message, array_types, nullable_only:)
-              when IR::ReturnStmt
-                collect_checked_array_index_types_from_expression(statement.value, array_types, nullable_only:) if statement.value
-              when IR::ExpressionStmt
-                collect_checked_array_index_types_from_expression(statement.expression, array_types, nullable_only:)
-              end
-            end
+      def collect_checked_array_index_types(nullable_only: false)
+        array_types = []
+        emitted_functions.each do |function|
+          collect_checked_array_index_types_from_statements(function.body, array_types, nullable_only:)
+        end
+        array_types.uniq
+      end
+
+      def collect_checked_span_index_types(nullable_only: false)
+        span_types = []
+        emitted_functions.each do |function|
+          collect_checked_span_index_types_from_statements(function.body, span_types, nullable_only:)
+        end
+        span_types.uniq
+      end
+
+      def collect_checked_array_index_types_from_statements(statements, array_types, nullable_only: false)
+        statements.each do |statement|
+          case statement
+          when IR::LocalDecl
+            collect_checked_array_index_types_from_expression(statement.value, array_types, nullable_only:)
+          when IR::Assignment
+            collect_checked_array_index_types_from_expression(statement.target, array_types, nullable_only:)
+            collect_checked_array_index_types_from_expression(statement.value, array_types, nullable_only:)
+          when IR::BlockStmt
+            collect_checked_array_index_types_from_statements(statement.body, array_types, nullable_only:)
+          when IR::WhileStmt
+            collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
+            collect_checked_array_index_types_from_statements(statement.body, array_types, nullable_only:)
+          when IR::ForStmt
+            collect_checked_array_index_types_from_statements([statement.init], array_types, nullable_only:)
+            collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
+            collect_checked_array_index_types_from_statements(statement.body, array_types, nullable_only:)
+            collect_checked_array_index_types_from_statements([statement.post], array_types, nullable_only:)
+          when IR::IfStmt
+            collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
+            collect_checked_array_index_types_from_statements(statement.then_body, array_types, nullable_only:)
+            collect_checked_array_index_types_from_statements(statement.else_body, array_types, nullable_only:) if statement.else_body
+          when IR::SwitchStmt
+            collect_checked_array_index_types_from_expression(statement.expression, array_types, nullable_only:)
+            statement.cases.each do |switch_case|
+              collect_checked_array_index_types_from_statements(switch_case.body, array_types, nullable_only:)
+            end
+          when IR::StaticAssert
+            collect_checked_array_index_types_from_expression(statement.condition, array_types, nullable_only:)
+            collect_checked_array_index_types_from_expression(statement.message, array_types, nullable_only:)
+          when IR::ReturnStmt
+            collect_checked_array_index_types_from_expression(statement.value, array_types, nullable_only:) if statement.value
+          when IR::ExpressionStmt
+            collect_checked_array_index_types_from_expression(statement.expression, array_types, nullable_only:)
           end
-
-          def collect_checked_array_index_types_from_expression(expression, array_types, nullable_only: false)
-            case expression
-            when IR::Member
-              collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
-            when IR::Index
-              collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
-              collect_checked_array_index_types_from_expression(expression.index, array_types, nullable_only:)
-            when IR::CheckedIndex
-              array_types << expression.receiver_type unless nullable_only
-              collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
-              collect_checked_array_index_types_from_expression(expression.index, array_types, nullable_only:)
-            when IR::NullableIndex
-              array_types << expression.receiver_type
-              collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
-              collect_checked_array_index_types_from_expression(expression.index, array_types, nullable_only:)
-            when IR::Call
-              collect_checked_array_index_types_from_expression(expression.callee, array_types, nullable_only:) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_checked_array_index_types_from_expression(argument, array_types, nullable_only:) }
-            when IR::Unary
-              collect_checked_array_index_types_from_expression(expression.operand, array_types, nullable_only:)
-            when IR::Binary
-              collect_checked_array_index_types_from_expression(expression.left, array_types, nullable_only:)
-              collect_checked_array_index_types_from_expression(expression.right, array_types, nullable_only:)
-            when IR::Conditional
-              collect_checked_array_index_types_from_expression(expression.condition, array_types, nullable_only:)
-              collect_checked_array_index_types_from_expression(expression.then_expression, array_types, nullable_only:)
-              collect_checked_array_index_types_from_expression(expression.else_expression, array_types, nullable_only:)
-            when IR::ReinterpretExpr
-              collect_checked_array_index_types_from_expression(expression.expression, array_types, nullable_only:)
-            when IR::AddressOf
-              collect_checked_array_index_types_from_expression(expression.expression, array_types, nullable_only:)
-            when IR::Cast
-              collect_checked_array_index_types_from_expression(expression.expression, array_types, nullable_only:)
-            when IR::AggregateLiteral
-              expression.fields.each { |field| collect_checked_array_index_types_from_expression(field.value, array_types, nullable_only:) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_checked_array_index_types_from_expression(element, array_types, nullable_only:) }
-            when IR::VariantLiteral
-              expression.fields.each { |field| collect_checked_array_index_types_from_expression(field.value, array_types, nullable_only:) }
-            end
+        end
+      end
+
+      def collect_checked_array_index_types_from_expression(expression, array_types, nullable_only: false)
+        case expression
+        when IR::Member
+          collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
+        when IR::Index
+          collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
+          collect_checked_array_index_types_from_expression(expression.index, array_types, nullable_only:)
+        when IR::CheckedIndex
+          array_types << expression.receiver_type unless nullable_only
+          collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
+          collect_checked_array_index_types_from_expression(expression.index, array_types, nullable_only:)
+        when IR::NullableIndex
+          array_types << expression.receiver_type
+          collect_checked_array_index_types_from_expression(expression.receiver, array_types, nullable_only:)
+          collect_checked_array_index_types_from_expression(expression.index, array_types, nullable_only:)
+        when IR::Call
+          collect_checked_array_index_types_from_expression(expression.callee, array_types, nullable_only:) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_checked_array_index_types_from_expression(argument, array_types, nullable_only:) }
+        when IR::Unary
+          collect_checked_array_index_types_from_expression(expression.operand, array_types, nullable_only:)
+        when IR::Binary
+          collect_checked_array_index_types_from_expression(expression.left, array_types, nullable_only:)
+          collect_checked_array_index_types_from_expression(expression.right, array_types, nullable_only:)
+        when IR::Conditional
+          collect_checked_array_index_types_from_expression(expression.condition, array_types, nullable_only:)
+          collect_checked_array_index_types_from_expression(expression.then_expression, array_types, nullable_only:)
+          collect_checked_array_index_types_from_expression(expression.else_expression, array_types, nullable_only:)
+        when IR::ReinterpretExpr
+          collect_checked_array_index_types_from_expression(expression.expression, array_types, nullable_only:)
+        when IR::AddressOf
+          collect_checked_array_index_types_from_expression(expression.expression, array_types, nullable_only:)
+        when IR::Cast
+          collect_checked_array_index_types_from_expression(expression.expression, array_types, nullable_only:)
+        when IR::AggregateLiteral
+          expression.fields.each { |field| collect_checked_array_index_types_from_expression(field.value, array_types, nullable_only:) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_checked_array_index_types_from_expression(element, array_types, nullable_only:) }
+        when IR::VariantLiteral
+          expression.fields.each { |field| collect_checked_array_index_types_from_expression(field.value, array_types, nullable_only:) }
+        end
+      end
+
+      def collect_checked_span_index_types_from_statements(statements, span_types, nullable_only: false)
+        statements.each do |statement|
+          case statement
+          when IR::LocalDecl
+            collect_checked_span_index_types_from_expression(statement.value, span_types, nullable_only:)
+          when IR::Assignment
+            collect_checked_span_index_types_from_expression(statement.target, span_types, nullable_only:)
+            collect_checked_span_index_types_from_expression(statement.value, span_types, nullable_only:)
+          when IR::BlockStmt
+            collect_checked_span_index_types_from_statements(statement.body, span_types, nullable_only:)
+          when IR::WhileStmt
+            collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
+            collect_checked_span_index_types_from_statements(statement.body, span_types, nullable_only:)
+          when IR::ForStmt
+            collect_checked_span_index_types_from_statements([statement.init], span_types, nullable_only:)
+            collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
+            collect_checked_span_index_types_from_statements(statement.body, span_types, nullable_only:)
+            collect_checked_span_index_types_from_statements([statement.post], span_types, nullable_only:)
+          when IR::IfStmt
+            collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
+            collect_checked_span_index_types_from_statements(statement.then_body, span_types, nullable_only:)
+            collect_checked_span_index_types_from_statements(statement.else_body, span_types, nullable_only:) if statement.else_body
+          when IR::SwitchStmt
+            collect_checked_span_index_types_from_expression(statement.expression, span_types, nullable_only:)
+            statement.cases.each do |switch_case|
+              collect_checked_span_index_types_from_statements(switch_case.body, span_types, nullable_only:)
+            end
+          when IR::StaticAssert
+            collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
+            collect_checked_span_index_types_from_expression(statement.message, span_types, nullable_only:)
+          when IR::ReturnStmt
+            collect_checked_span_index_types_from_expression(statement.value, span_types, nullable_only:) if statement.value
+          when IR::ExpressionStmt
+            collect_checked_span_index_types_from_expression(statement.expression, span_types, nullable_only:)
           end
-
-          def collect_checked_span_index_types_from_statements(statements, span_types, nullable_only: false)
-            statements.each do |statement|
-              case statement
-              when IR::LocalDecl
-                collect_checked_span_index_types_from_expression(statement.value, span_types, nullable_only:)
-              when IR::Assignment
-                collect_checked_span_index_types_from_expression(statement.target, span_types, nullable_only:)
-                collect_checked_span_index_types_from_expression(statement.value, span_types, nullable_only:)
-              when IR::BlockStmt
-                collect_checked_span_index_types_from_statements(statement.body, span_types, nullable_only:)
-              when IR::WhileStmt
-                collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
-                collect_checked_span_index_types_from_statements(statement.body, span_types, nullable_only:)
-              when IR::ForStmt
-                collect_checked_span_index_types_from_statements([statement.init], span_types, nullable_only:)
-                collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
-                collect_checked_span_index_types_from_statements(statement.body, span_types, nullable_only:)
-                collect_checked_span_index_types_from_statements([statement.post], span_types, nullable_only:)
-              when IR::IfStmt
-                collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
-                collect_checked_span_index_types_from_statements(statement.then_body, span_types, nullable_only:)
-                collect_checked_span_index_types_from_statements(statement.else_body, span_types, nullable_only:) if statement.else_body
-              when IR::SwitchStmt
-                collect_checked_span_index_types_from_expression(statement.expression, span_types, nullable_only:)
-                statement.cases.each do |switch_case|
-                  collect_checked_span_index_types_from_statements(switch_case.body, span_types, nullable_only:)
-                end
-              when IR::StaticAssert
-                collect_checked_span_index_types_from_expression(statement.condition, span_types, nullable_only:)
-                collect_checked_span_index_types_from_expression(statement.message, span_types, nullable_only:)
-              when IR::ReturnStmt
-                collect_checked_span_index_types_from_expression(statement.value, span_types, nullable_only:) if statement.value
-              when IR::ExpressionStmt
-                collect_checked_span_index_types_from_expression(statement.expression, span_types, nullable_only:)
-              end
-            end
+        end
+      end
+
+      def collect_checked_span_index_types_from_expression(expression, span_types, nullable_only: false)
+        case expression
+        when IR::Member
+          collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
+        when IR::Index, IR::CheckedIndex, IR::NullableIndex
+          collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
+          collect_checked_span_index_types_from_expression(expression.index, span_types, nullable_only:)
+        when IR::CheckedSpanIndex
+          span_types << expression.receiver_type unless nullable_only
+          collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
+          collect_checked_span_index_types_from_expression(expression.index, span_types, nullable_only:)
+        when IR::NullableSpanIndex
+          span_types << expression.receiver_type
+          collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
+          collect_checked_span_index_types_from_expression(expression.index, span_types, nullable_only:)
+        when IR::Call
+          collect_checked_span_index_types_from_expression(expression.callee, span_types, nullable_only:) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_checked_span_index_types_from_expression(argument, span_types, nullable_only:) }
+        when IR::Unary
+          collect_checked_span_index_types_from_expression(expression.operand, span_types, nullable_only:)
+        when IR::Binary
+          collect_checked_span_index_types_from_expression(expression.left, span_types, nullable_only:)
+          collect_checked_span_index_types_from_expression(expression.right, span_types, nullable_only:)
+        when IR::Conditional
+          collect_checked_span_index_types_from_expression(expression.condition, span_types, nullable_only:)
+          collect_checked_span_index_types_from_expression(expression.then_expression, span_types, nullable_only:)
+          collect_checked_span_index_types_from_expression(expression.else_expression, span_types, nullable_only:)
+        when IR::ReinterpretExpr
+          collect_checked_span_index_types_from_expression(expression.expression, span_types, nullable_only:)
+        when IR::AddressOf
+          collect_checked_span_index_types_from_expression(expression.expression, span_types, nullable_only:)
+        when IR::Cast
+          collect_checked_span_index_types_from_expression(expression.expression, span_types, nullable_only:)
+        when IR::AggregateLiteral
+          expression.fields.each { |field| collect_checked_span_index_types_from_expression(field.value, span_types, nullable_only:) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_checked_span_index_types_from_expression(element, span_types, nullable_only:) }
+        when IR::VariantLiteral
+          expression.fields.each { |field| collect_checked_span_index_types_from_expression(field.value, span_types, nullable_only:) }
+        end
+      end
+
+      def collect_span_types
+        span_types = []
+        visited = {}
+
+        all_emitted_top_level_values.each do |value|
+          collect_span_type(value.type, span_types, visited)
+        end
+
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_span_type(field.type, span_types, visited)
           end
+        end
 
-          def collect_checked_span_index_types_from_expression(expression, span_types, nullable_only: false)
-            case expression
-            when IR::Member
-              collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
-            when IR::Index, IR::CheckedIndex, IR::NullableIndex
-              collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
-              collect_checked_span_index_types_from_expression(expression.index, span_types, nullable_only:)
-            when IR::CheckedSpanIndex
-              span_types << expression.receiver_type unless nullable_only
-              collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
-              collect_checked_span_index_types_from_expression(expression.index, span_types, nullable_only:)
-            when IR::NullableSpanIndex
-              span_types << expression.receiver_type
-              collect_checked_span_index_types_from_expression(expression.receiver, span_types, nullable_only:)
-              collect_checked_span_index_types_from_expression(expression.index, span_types, nullable_only:)
-            when IR::Call
-              collect_checked_span_index_types_from_expression(expression.callee, span_types, nullable_only:) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_checked_span_index_types_from_expression(argument, span_types, nullable_only:) }
-            when IR::Unary
-              collect_checked_span_index_types_from_expression(expression.operand, span_types, nullable_only:)
-            when IR::Binary
-              collect_checked_span_index_types_from_expression(expression.left, span_types, nullable_only:)
-              collect_checked_span_index_types_from_expression(expression.right, span_types, nullable_only:)
-            when IR::Conditional
-              collect_checked_span_index_types_from_expression(expression.condition, span_types, nullable_only:)
-              collect_checked_span_index_types_from_expression(expression.then_expression, span_types, nullable_only:)
-              collect_checked_span_index_types_from_expression(expression.else_expression, span_types, nullable_only:)
-            when IR::ReinterpretExpr
-              collect_checked_span_index_types_from_expression(expression.expression, span_types, nullable_only:)
-            when IR::AddressOf
-              collect_checked_span_index_types_from_expression(expression.expression, span_types, nullable_only:)
-            when IR::Cast
-              collect_checked_span_index_types_from_expression(expression.expression, span_types, nullable_only:)
-            when IR::AggregateLiteral
-              expression.fields.each { |field| collect_checked_span_index_types_from_expression(field.value, span_types, nullable_only:) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_checked_span_index_types_from_expression(element, span_types, nullable_only:) }
-            when IR::VariantLiteral
-              expression.fields.each { |field| collect_checked_span_index_types_from_expression(field.value, span_types, nullable_only:) }
-            end
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_span_type(field.type, span_types, visited)
           end
+        end
 
-          def collect_span_types
-            span_types = []
-            visited = {}
-
-            all_emitted_top_level_values.each do |value|
-              collect_span_type(value.type, span_types, visited)
-            end
-
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_span_type(field.type, span_types, visited)
-              end
-            end
-
-            @program.unions.each do |union_decl|
-              union_decl.fields.each do |field|
-                collect_span_type(field.type, span_types, visited)
-              end
-            end
-
-            each_variant_arm_field_type do |field_type|
-              collect_span_type(field_type, span_types, visited)
-            end
+        each_variant_arm_field_type do |field_type|
+          collect_span_type(field_type, span_types, visited)
+        end
 
-            emitted_functions.each do |function|
-              collect_span_type(function.return_type, span_types, visited)
-              function.params.each do |param|
-                collect_span_type(param.type, span_types, visited)
-              end
-              collect_span_types_from_statements(function.body, span_types, visited)
-            end
-
-            @program.static_asserts.each do |statement|
-              collect_span_types_from_expression(statement.condition, span_types, visited)
-              collect_span_types_from_expression(statement.message, span_types, visited)
-            end
-
-            span_types.uniq
+        emitted_functions.each do |function|
+          collect_span_type(function.return_type, span_types, visited)
+          function.params.each do |param|
+            collect_span_type(param.type, span_types, visited)
           end
+          collect_span_types_from_statements(function.body, span_types, visited)
+        end
 
-          def collect_soa_types
-            soa_types = []
-            visited = {}
-
-            emitted_functions.each do |function|
-              collect_soa_type(function.return_type, soa_types, visited)
-              function.params.each do |param|
-                collect_soa_type(param.type, soa_types, visited)
-              end
-              collect_soa_from_statements(function.body, soa_types, visited)
-            end
-
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_soa_type(field.type, soa_types, visited)
-              end
-            end
+        @program.static_asserts.each do |statement|
+          collect_span_types_from_expression(statement.condition, span_types, visited)
+          collect_span_types_from_expression(statement.message, span_types, visited)
+        end
 
-            soa_types.uniq
-          end
-
-          def collect_soa_from_statements(statements, soa_types, visited)
-            statements.each do |stmt|
-              case stmt
-              when IR::LocalDecl
-                collect_soa_type(stmt.type, soa_types, visited)
-              when IR::BlockStmt
-                collect_soa_from_statements(stmt.body, soa_types, visited)
-              when IR::IfStmt
-                collect_soa_from_statements(stmt.then_body || [], soa_types, visited)
-                collect_soa_from_statements(stmt.else_body || [], soa_types, visited)
-              when IR::WhileStmt
-                collect_soa_from_statements(stmt.body || [], soa_types, visited)
-              when IR::ForStmt
-                collect_soa_from_statements(stmt.body || [], soa_types, visited)
-              end
-            end
-          end
+        span_types.uniq
+      end
 
-          def collect_soa_type(type, soa_types, visited)
-            return unless type
-            return if visited[type]
+      def collect_soa_types
+        soa_types = []
+        visited = {}
 
-            if type.is_a?(Types::SoA)
-              soa_types << type
-              visited[type] = true
-            end
+        emitted_functions.each do |function|
+          collect_soa_type(function.return_type, soa_types, visited)
+          function.params.each do |param|
+            collect_soa_type(param.type, soa_types, visited)
           end
+          collect_soa_from_statements(function.body, soa_types, visited)
+        end
 
-          def collect_simd_types
-            simd_types = []
-            visited = {}
-
-            emitted_functions.each do |function|
-              collect_simd_type(function.return_type, simd_types, visited)
-              function.params.each do |param|
-                collect_simd_type(param.type, simd_types, visited)
-              end
-              collect_simd_from_statements(function.body, simd_types, visited)
-            end
-
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_simd_type(field.type, simd_types, visited)
-              end
-            end
-
-            simd_types.uniq
-          end
-
-          def collect_simd_from_statements(statements, simd_types, visited)
-            statements.each do |stmt|
-              case stmt
-              when IR::LocalDecl
-                collect_simd_type(stmt.type, simd_types, visited)
-              when IR::BlockStmt
-                collect_simd_from_statements(stmt.body, simd_types, visited)
-              when IR::IfStmt
-                collect_simd_from_statements(stmt.then_body || [], simd_types, visited)
-                collect_simd_from_statements(stmt.else_body || [], simd_types, visited)
-              when IR::WhileStmt
-                collect_simd_from_statements(stmt.body || [], simd_types, visited)
-              when IR::ForStmt
-                collect_simd_from_statements(stmt.body || [], simd_types, visited)
-              end
-            end
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_soa_type(field.type, soa_types, visited)
           end
-
-          def collect_simd_type(type, simd_types, visited)
-            return unless type
-            return if visited[type]
-
-            if type.is_a?(Types::Simd)
-              simd_types << type
-              visited[type] = true
-            end
+        end
+
+        soa_types.uniq
+      end
+
+      def collect_soa_from_statements(statements, soa_types, visited)
+        statements.each do |stmt|
+          case stmt
+          when IR::LocalDecl
+            collect_soa_type(stmt.type, soa_types, visited)
+          when IR::BlockStmt
+            collect_soa_from_statements(stmt.body, soa_types, visited)
+          when IR::IfStmt
+            collect_soa_from_statements(stmt.then_body || [], soa_types, visited)
+            collect_soa_from_statements(stmt.else_body || [], soa_types, visited)
+          when IR::WhileStmt
+            collect_soa_from_statements(stmt.body || [], soa_types, visited)
+          when IR::ForStmt
+            collect_soa_from_statements(stmt.body || [], soa_types, visited)
           end
-
-          def collect_generic_struct_decls
-            collect_generic_struct_types.map do |type|
-              fields = type.fields.map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) }
-              if type.respond_to?(:events)
-                type.events.each_value do |event_type|
-                  fields << IR::Field.new(name: event_type.hidden_field_name, type: event_type)
-                end
-              end
-              IR::StructDecl.new(
-                name: type.to_s,
-                linkage_name: named_type_c_name(type),
-                fields:,
-                packed: type.packed,
-                alignment: type.alignment,
-              )
-            end
+        end
+      end
+
+      def collect_soa_type(type, soa_types, visited)
+        return unless type
+        return if visited[type]
+
+        if type.is_a?(Types::SoA)
+          soa_types << type
+          visited[type] = true
+        end
+      end
+
+      def collect_simd_types
+        simd_types = []
+        visited = {}
+
+        emitted_functions.each do |function|
+          collect_simd_type(function.return_type, simd_types, visited)
+          function.params.each do |param|
+            collect_simd_type(param.type, simd_types, visited)
           end
+          collect_simd_from_statements(function.body, simd_types, visited)
+        end
 
-          def collect_task_decls
-            collect_task_types.map do |type|
-              IR::StructDecl.new(
-                name: type.to_s,
-                linkage_name: task_type_name(type),
-                fields: type.fields.map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) },
-                packed: false,
-                alignment: nil,
-              )
-            end
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_simd_type(field.type, simd_types, visited)
           end
-
-          def collect_proc_decls
-            collect_proc_types.map do |type|
-              IR::StructDecl.new(
-                name: type.to_s,
-                linkage_name: proc_type_name(type),
-                fields: proc_field_types(type).map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) },
-                packed: false,
-                alignment: nil,
-              )
-            end
+        end
+
+        simd_types.uniq
+      end
+
+      def collect_simd_from_statements(statements, simd_types, visited)
+        statements.each do |stmt|
+          case stmt
+          when IR::LocalDecl
+            collect_simd_type(stmt.type, simd_types, visited)
+          when IR::BlockStmt
+            collect_simd_from_statements(stmt.body, simd_types, visited)
+          when IR::IfStmt
+            collect_simd_from_statements(stmt.then_body || [], simd_types, visited)
+            collect_simd_from_statements(stmt.else_body || [], simd_types, visited)
+          when IR::WhileStmt
+            collect_simd_from_statements(stmt.body || [], simd_types, visited)
+          when IR::ForStmt
+            collect_simd_from_statements(stmt.body || [], simd_types, visited)
           end
-
-          def proc_field_types(type)
-            void_ptr = Types::Registry.generic_instance("ptr", [Types::Registry.primitive("void")])
-
-            {
-              "env" => void_ptr,
-              "invoke" => Types::Registry.function(nil, params: [Types::Registry.parameter("env", void_ptr)] + type.params, return_type: type.return_type),
-              "release" => Types::Registry.function(nil, params: [Types::Registry.parameter("env", void_ptr)], return_type: Types::Registry.primitive("void")),
-              "retain" => Types::Registry.function(nil, params: [Types::Registry.parameter("env", void_ptr)], return_type: Types::Registry.primitive("void")),
-            }
-          end
-
-          def collect_str_buffer_decls
-            collect_str_buffer_types.map do |type|
-              IR::StructDecl.new(
-                name: type.to_s,
-                linkage_name: str_buffer_type_name(type),
-                fields: [
-                  IR::Field.new(name: "data", type: Types::Registry.generic_instance("array", [Types::Registry.primitive("char"), Types::LiteralTypeArg.new(str_buffer_storage_capacity(type))])),
-                  IR::Field.new(name: "len", type: Types::Registry.primitive("ptr_uint")),
-                  IR::Field.new(name: "dirty", type: Types::Registry.primitive("bool")),
-                ],
-                packed: false,
-                alignment: nil,
-              )
+        end
+      end
+
+      def collect_simd_type(type, simd_types, visited)
+        return unless type
+        return if visited[type]
+
+        if type.is_a?(Types::Simd)
+          simd_types << type
+          visited[type] = true
+        end
+      end
+
+      def collect_generic_struct_decls
+        collect_generic_struct_types.map do |type|
+          fields = type.fields.map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) }
+          if type.respond_to?(:events)
+            type.events.each_value do |event_type|
+              fields << IR::Field.new(name: event_type.hidden_field_name, type: event_type)
             end
           end
-
-          def collect_generic_variant_decls
-            collect_generic_variant_types.map do |type|
-              outer_c = named_type_c_name(type)
-              arms = type.arm_names.map do |arm_name|
-                fields = type.arm(arm_name)
-                IR::VariantArm.new(
-                  name: arm_name,
-                  linkage_name: "#{outer_c}_#{arm_name}",
-                  fields: fields.map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) },
-                )
-              end
-              IR::VariantDecl.new(name: type.to_s, linkage_name: outer_c, arms:)
-            end
+          IR::StructDecl.new(
+            name: type.to_s,
+            linkage_name: named_type_c_name(type),
+            fields:,
+            packed: type.packed,
+            alignment: type.alignment,
+          )
+        end
+      end
+
+      def collect_task_decls
+        collect_task_types.map do |type|
+          IR::StructDecl.new(
+            name: type.to_s,
+            linkage_name: task_type_name(type),
+            fields: type.fields.map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) },
+            packed: false,
+            alignment: nil,
+          )
+        end
+      end
+
+      def collect_proc_decls
+        collect_proc_types.map do |type|
+          IR::StructDecl.new(
+            name: type.to_s,
+            linkage_name: proc_type_name(type),
+            fields: proc_field_types(type).map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) },
+            packed: false,
+            alignment: nil,
+          )
+        end
+      end
+
+      def proc_field_types(type)
+        void_ptr = Types::Registry.generic_instance("ptr", [Types::Registry.primitive("void")])
+
+        {
+          "env" => void_ptr,
+          "invoke" => Types::Registry.function(nil, params: [Types::Registry.parameter("env", void_ptr)] + type.params, return_type: type.return_type),
+          "release" => Types::Registry.function(nil, params: [Types::Registry.parameter("env", void_ptr)], return_type: Types::Registry.primitive("void")),
+          "retain" => Types::Registry.function(nil, params: [Types::Registry.parameter("env", void_ptr)], return_type: Types::Registry.primitive("void")),
+        }
+      end
+
+      def collect_str_buffer_decls
+        collect_str_buffer_types.map do |type|
+          IR::StructDecl.new(
+            name: type.to_s,
+            linkage_name: str_buffer_type_name(type),
+            fields: [
+              IR::Field.new(name: "data", type: Types::Registry.generic_instance("array", [Types::Registry.primitive("char"), Types::LiteralTypeArg.new(str_buffer_storage_capacity(type))])),
+              IR::Field.new(name: "len", type: Types::Registry.primitive("ptr_uint")),
+              IR::Field.new(name: "dirty", type: Types::Registry.primitive("bool")),
+            ],
+            packed: false,
+            alignment: nil,
+          )
+        end
+      end
+
+      def collect_generic_variant_decls
+        collect_generic_variant_types.map do |type|
+          outer_c = named_type_c_name(type)
+          arms = type.arm_names.map do |arm_name|
+            fields = type.arm(arm_name)
+            IR::VariantArm.new(
+              name: arm_name,
+              linkage_name: "#{outer_c}_#{arm_name}",
+              fields: fields.map { |field_name, field_type| IR::Field.new(name: field_name, type: field_type) },
+            )
           end
+          IR::VariantDecl.new(name: type.to_s, linkage_name: outer_c, arms:)
+        end
+      end
 
-          def collect_task_types
-            task_types = []
-            visited = {}
-
-            all_emitted_top_level_values.each do |value|
-              collect_task_type(value.type, task_types, visited)
-            end
-
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_task_type(field.type, task_types, visited)
-              end
-            end
-
-            @program.unions.each do |union_decl|
-              union_decl.fields.each do |field|
-                collect_task_type(field.type, task_types, visited)
-              end
-            end
-
-            each_variant_arm_field_type do |field_type|
-              collect_task_type(field_type, task_types, visited)
-            end
+      def collect_task_types
+        task_types = []
+        visited = {}
 
-            emitted_functions.each do |function|
-              collect_task_type(function.return_type, task_types, visited)
-              function.params.each do |param|
-                collect_task_type(param.type, task_types, visited)
-              end
-              collect_task_types_from_statements(function.body, task_types, visited)
-            end
-
-            @program.static_asserts.each do |statement|
-              collect_task_types_from_expression(statement.condition, task_types, visited)
-              collect_task_types_from_expression(statement.message, task_types, visited)
-            end
+        all_emitted_top_level_values.each do |value|
+          collect_task_type(value.type, task_types, visited)
+        end
 
-            task_types
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_task_type(field.type, task_types, visited)
           end
+        end
 
-          def collect_proc_types
-            proc_types = []
-            visited = {}
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_task_type(field.type, task_types, visited)
+          end
+        end
 
-            all_emitted_top_level_values.each do |value|
-              collect_proc_type(value.type, proc_types, visited)
-            end
+        each_variant_arm_field_type do |field_type|
+          collect_task_type(field_type, task_types, visited)
+        end
 
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_proc_type(field.type, proc_types, visited)
-              end
-            end
+        emitted_functions.each do |function|
+          collect_task_type(function.return_type, task_types, visited)
+          function.params.each do |param|
+            collect_task_type(param.type, task_types, visited)
+          end
+          collect_task_types_from_statements(function.body, task_types, visited)
+        end
 
-            @program.unions.each do |union_decl|
-              union_decl.fields.each do |field|
-                collect_proc_type(field.type, proc_types, visited)
-              end
-            end
+        @program.static_asserts.each do |statement|
+          collect_task_types_from_expression(statement.condition, task_types, visited)
+          collect_task_types_from_expression(statement.message, task_types, visited)
+        end
 
-            each_variant_arm_field_type do |field_type|
-              collect_proc_type(field_type, proc_types, visited)
-            end
+        task_types
+      end
 
-            emitted_functions.each do |function|
-              collect_proc_type(function.return_type, proc_types, visited)
-              function.params.each do |param|
-                collect_proc_type(param.type, proc_types, visited)
-              end
-              collect_proc_types_from_statements(function.body, proc_types, visited)
-            end
+      def collect_proc_types
+        proc_types = []
+        visited = {}
 
-            @program.static_asserts.each do |statement|
-              collect_proc_types_from_expression(statement.condition, proc_types, visited)
-              collect_proc_types_from_expression(statement.message, proc_types, visited)
-            end
+        all_emitted_top_level_values.each do |value|
+          collect_proc_type(value.type, proc_types, visited)
+        end
 
-            proc_types
-          end
-
-          def each_ir_statement_for_type_collection(statements, type_collector_method:, expression_walker_method:, accumulator:, visited:)
-            statements.each do |stmt|
-              case stmt
-              when IR::LocalDecl
-                send(type_collector_method, stmt.type, accumulator, visited)
-                send(expression_walker_method, stmt.value, accumulator, visited) if stmt.value
-              when IR::Assignment
-                send(expression_walker_method, stmt.target, accumulator, visited)
-                send(expression_walker_method, stmt.value, accumulator, visited)
-              when IR::BlockStmt
-                each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
-              when IR::WhileStmt
-                send(expression_walker_method, stmt.condition, accumulator, visited)
-                each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
-              when IR::ForStmt
-                each_ir_statement_for_type_collection([stmt.init], type_collector_method:, expression_walker_method:, accumulator:, visited:)
-                send(expression_walker_method, stmt.condition, accumulator, visited)
-                each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
-                each_ir_statement_for_type_collection([stmt.post], type_collector_method:, expression_walker_method:, accumulator:, visited:)
-              when IR::IfStmt
-                send(expression_walker_method, stmt.condition, accumulator, visited)
-                each_ir_statement_for_type_collection(stmt.then_body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
-                each_ir_statement_for_type_collection(stmt.else_body, type_collector_method:, expression_walker_method:, accumulator:, visited:) if stmt.else_body
-              when IR::SwitchStmt
-                send(expression_walker_method, stmt.expression, accumulator, visited)
-                stmt.cases.each do |switch_case|
-                  each_ir_statement_for_type_collection(switch_case.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
-                end
-              when IR::StaticAssert
-                send(expression_walker_method, stmt.condition, accumulator, visited)
-                send(expression_walker_method, stmt.message, accumulator, visited)
-              when IR::ReturnStmt
-                send(expression_walker_method, stmt.value, accumulator, visited) if stmt.value
-              when IR::ExpressionStmt
-                send(expression_walker_method, stmt.expression, accumulator, visited)
-              end
-            end
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_proc_type(field.type, proc_types, visited)
           end
+        end
 
-          def collect_proc_types_from_statements(statements, proc_types, visited)
-            each_ir_statement_for_type_collection(statements,
-              type_collector_method: :collect_proc_type,
-              expression_walker_method: :collect_proc_types_from_expression,
-              accumulator: proc_types, visited:)
-          end
-
-          def collect_proc_types_from_expression(expression, proc_types, visited)
-            case expression
-            when IR::Member
-              collect_proc_types_from_expression(expression.receiver, proc_types, visited)
-            when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
-              collect_proc_types_from_expression(expression.receiver, proc_types, visited)
-              collect_proc_types_from_expression(expression.index, proc_types, visited)
-            when IR::Call
-              collect_proc_type(expression.type, proc_types, visited)
-              collect_proc_types_from_expression(expression.callee, proc_types, visited) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_proc_types_from_expression(argument, proc_types, visited) }
-            when IR::Unary
-              collect_proc_types_from_expression(expression.operand, proc_types, visited)
-            when IR::Binary
-              collect_proc_types_from_expression(expression.left, proc_types, visited)
-              collect_proc_types_from_expression(expression.right, proc_types, visited)
-            when IR::Conditional
-              collect_proc_types_from_expression(expression.condition, proc_types, visited)
-              collect_proc_types_from_expression(expression.then_expression, proc_types, visited)
-              collect_proc_types_from_expression(expression.else_expression, proc_types, visited)
-            when IR::ReinterpretExpr
-              collect_proc_type(expression.target_type, proc_types, visited)
-              collect_proc_type(expression.source_type, proc_types, visited)
-              collect_proc_types_from_expression(expression.expression, proc_types, visited)
-            when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
-              collect_proc_type(expression.target_type, proc_types, visited)
-            when IR::AddressOf, IR::Cast
-              collect_proc_types_from_expression(expression.expression, proc_types, visited)
-            when IR::AggregateLiteral
-              collect_proc_type(expression.type, proc_types, visited)
-              expression.fields.each { |field| collect_proc_types_from_expression(field.value, proc_types, visited) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_proc_types_from_expression(element, proc_types, visited) }
-            when IR::VariantLiteral
-              collect_proc_type(expression.type, proc_types, visited)
-              expression.fields.each { |field| collect_proc_types_from_expression(field.value, proc_types, visited) }
-            end
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_proc_type(field.type, proc_types, visited)
           end
+        end
 
-          def collect_proc_type(type, proc_types, visited)
-            return unless type
-            return if visited[type]
-
-            visited[type] = true
+        each_variant_arm_field_type do |field_type|
+          collect_proc_type(field_type, proc_types, visited)
+        end
 
-            case type
-            when Types::Nullable
-              collect_proc_type(type.base, proc_types, visited)
-            when Types::Task
-              collect_proc_type(type.result_type, proc_types, visited)
-            when Types::Proc
-              proc_types << type
-              type.params.each do |param|
-                collect_proc_type(param.type, proc_types, visited)
-              end
-              collect_proc_type(type.return_type, proc_types, visited)
-            when Types::Span
-              collect_proc_type(type.element_type, proc_types, visited)
-            when Types::StructInstance
-              type.arguments.each do |argument|
-                collect_proc_type(argument, proc_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-              type.fields.each_value do |field_type|
-                collect_proc_type(field_type, proc_types, visited)
-              end
-            when Types::GenericInstance
-              type.arguments.each do |argument|
-                collect_proc_type(argument, proc_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-            when Types::Function
-              type.params.each do |param|
-                collect_proc_type(param.type, proc_types, visited)
-              end
-              collect_proc_type(type.return_type, proc_types, visited)
-            when Types::Struct, Types::Union
-              type.fields.each_value do |field_type|
-                collect_proc_type(field_type, proc_types, visited)
-              end
-            when Types::Variant
-              type.arm_names.each do |arm_name|
-                type.arm(arm_name).each_value do |field_type|
-                  collect_proc_type(field_type, proc_types, visited)
-                end
-              end
+        emitted_functions.each do |function|
+          collect_proc_type(function.return_type, proc_types, visited)
+          function.params.each do |param|
+            collect_proc_type(param.type, proc_types, visited)
+          end
+          collect_proc_types_from_statements(function.body, proc_types, visited)
+        end
+
+        @program.static_asserts.each do |statement|
+          collect_proc_types_from_expression(statement.condition, proc_types, visited)
+          collect_proc_types_from_expression(statement.message, proc_types, visited)
+        end
+
+        proc_types
+      end
+
+      def each_ir_statement_for_type_collection(statements, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+        statements.each do |stmt|
+          case stmt
+          when IR::LocalDecl
+            send(type_collector_method, stmt.type, accumulator, visited)
+            send(expression_walker_method, stmt.value, accumulator, visited) if stmt.value
+          when IR::Assignment
+            send(expression_walker_method, stmt.target, accumulator, visited)
+            send(expression_walker_method, stmt.value, accumulator, visited)
+          when IR::BlockStmt
+            each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+          when IR::WhileStmt
+            send(expression_walker_method, stmt.condition, accumulator, visited)
+            each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+          when IR::ForStmt
+            each_ir_statement_for_type_collection([stmt.init], type_collector_method:, expression_walker_method:, accumulator:, visited:)
+            send(expression_walker_method, stmt.condition, accumulator, visited)
+            each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+            each_ir_statement_for_type_collection([stmt.post], type_collector_method:, expression_walker_method:, accumulator:, visited:)
+          when IR::IfStmt
+            send(expression_walker_method, stmt.condition, accumulator, visited)
+            each_ir_statement_for_type_collection(stmt.then_body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+            each_ir_statement_for_type_collection(stmt.else_body, type_collector_method:, expression_walker_method:, accumulator:, visited:) if stmt.else_body
+          when IR::SwitchStmt
+            send(expression_walker_method, stmt.expression, accumulator, visited)
+            stmt.cases.each do |switch_case|
+              each_ir_statement_for_type_collection(switch_case.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+            end
+          when IR::StaticAssert
+            send(expression_walker_method, stmt.condition, accumulator, visited)
+            send(expression_walker_method, stmt.message, accumulator, visited)
+          when IR::ReturnStmt
+            send(expression_walker_method, stmt.value, accumulator, visited) if stmt.value
+          when IR::ExpressionStmt
+            send(expression_walker_method, stmt.expression, accumulator, visited)
+          end
+        end
+      end
+
+      def collect_proc_types_from_statements(statements, proc_types, visited)
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_proc_type,
+          expression_walker_method: :collect_proc_types_from_expression,
+          accumulator: proc_types, visited:)
+      end
+
+      def collect_proc_types_from_expression(expression, proc_types, visited)
+        case expression
+        when IR::Member
+          collect_proc_types_from_expression(expression.receiver, proc_types, visited)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_proc_types_from_expression(expression.receiver, proc_types, visited)
+          collect_proc_types_from_expression(expression.index, proc_types, visited)
+        when IR::Call
+          collect_proc_type(expression.type, proc_types, visited)
+          collect_proc_types_from_expression(expression.callee, proc_types, visited) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_proc_types_from_expression(argument, proc_types, visited) }
+        when IR::Unary
+          collect_proc_types_from_expression(expression.operand, proc_types, visited)
+        when IR::Binary
+          collect_proc_types_from_expression(expression.left, proc_types, visited)
+          collect_proc_types_from_expression(expression.right, proc_types, visited)
+        when IR::Conditional
+          collect_proc_types_from_expression(expression.condition, proc_types, visited)
+          collect_proc_types_from_expression(expression.then_expression, proc_types, visited)
+          collect_proc_types_from_expression(expression.else_expression, proc_types, visited)
+        when IR::ReinterpretExpr
+          collect_proc_type(expression.target_type, proc_types, visited)
+          collect_proc_type(expression.source_type, proc_types, visited)
+          collect_proc_types_from_expression(expression.expression, proc_types, visited)
+        when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
+          collect_proc_type(expression.target_type, proc_types, visited)
+        when IR::AddressOf, IR::Cast
+          collect_proc_types_from_expression(expression.expression, proc_types, visited)
+        when IR::AggregateLiteral
+          collect_proc_type(expression.type, proc_types, visited)
+          expression.fields.each { |field| collect_proc_types_from_expression(field.value, proc_types, visited) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_proc_types_from_expression(element, proc_types, visited) }
+        when IR::VariantLiteral
+          collect_proc_type(expression.type, proc_types, visited)
+          expression.fields.each { |field| collect_proc_types_from_expression(field.value, proc_types, visited) }
+        end
+      end
+
+      def collect_proc_type(type, proc_types, visited)
+        return unless type
+        return if visited[type]
+
+        visited[type] = true
+
+        case type
+        when Types::Nullable
+          collect_proc_type(type.base, proc_types, visited)
+        when Types::Task
+          collect_proc_type(type.result_type, proc_types, visited)
+        when Types::Proc
+          proc_types << type
+          type.params.each do |param|
+            collect_proc_type(param.type, proc_types, visited)
+          end
+          collect_proc_type(type.return_type, proc_types, visited)
+        when Types::Span
+          collect_proc_type(type.element_type, proc_types, visited)
+        when Types::StructInstance
+          type.arguments.each do |argument|
+            collect_proc_type(argument, proc_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+          type.fields.each_value do |field_type|
+            collect_proc_type(field_type, proc_types, visited)
+          end
+        when Types::GenericInstance
+          type.arguments.each do |argument|
+            collect_proc_type(argument, proc_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        when Types::Function
+          type.params.each do |param|
+            collect_proc_type(param.type, proc_types, visited)
+          end
+          collect_proc_type(type.return_type, proc_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_proc_type(field_type, proc_types, visited)
+          end
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
+              collect_proc_type(field_type, proc_types, visited)
             end
           end
-
-          def collect_task_types_from_statements(statements, task_types, visited)
-            each_ir_statement_for_type_collection(statements,
-              type_collector_method: :collect_task_type,
-              expression_walker_method: :collect_task_types_from_expression,
-              accumulator: task_types, visited:)
-          end
-
-          def collect_task_types_from_expression(expression, task_types, visited)
-            case expression
-            when IR::Member
-              collect_task_types_from_expression(expression.receiver, task_types, visited)
-            when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
-              collect_task_types_from_expression(expression.receiver, task_types, visited)
-              collect_task_types_from_expression(expression.index, task_types, visited)
-            when IR::Call
-              collect_task_type(expression.type, task_types, visited)
-              collect_task_types_from_expression(expression.callee, task_types, visited) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_task_types_from_expression(argument, task_types, visited) }
-            when IR::Unary
-              collect_task_types_from_expression(expression.operand, task_types, visited)
-            when IR::Binary
-              collect_task_types_from_expression(expression.left, task_types, visited)
-              collect_task_types_from_expression(expression.right, task_types, visited)
-            when IR::Conditional
-              collect_task_types_from_expression(expression.condition, task_types, visited)
-              collect_task_types_from_expression(expression.then_expression, task_types, visited)
-              collect_task_types_from_expression(expression.else_expression, task_types, visited)
-            when IR::ReinterpretExpr
-              collect_task_type(expression.target_type, task_types, visited)
-              collect_task_type(expression.source_type, task_types, visited)
-              collect_task_types_from_expression(expression.expression, task_types, visited)
-            when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
-              collect_task_type(expression.target_type, task_types, visited)
-            when IR::AddressOf, IR::Cast
-              collect_task_types_from_expression(expression.expression, task_types, visited)
-            when IR::AggregateLiteral
-              collect_task_type(expression.type, task_types, visited)
-              expression.fields.each { |field| collect_task_types_from_expression(field.value, task_types, visited) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_task_types_from_expression(element, task_types, visited) }
-            when IR::VariantLiteral
-              collect_task_type(expression.type, task_types, visited)
-              expression.fields.each { |field| collect_task_types_from_expression(field.value, task_types, visited) }
+        end
+      end
+
+      def collect_task_types_from_statements(statements, task_types, visited)
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_task_type,
+          expression_walker_method: :collect_task_types_from_expression,
+          accumulator: task_types, visited:)
+      end
+
+      def collect_task_types_from_expression(expression, task_types, visited)
+        case expression
+        when IR::Member
+          collect_task_types_from_expression(expression.receiver, task_types, visited)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_task_types_from_expression(expression.receiver, task_types, visited)
+          collect_task_types_from_expression(expression.index, task_types, visited)
+        when IR::Call
+          collect_task_type(expression.type, task_types, visited)
+          collect_task_types_from_expression(expression.callee, task_types, visited) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_task_types_from_expression(argument, task_types, visited) }
+        when IR::Unary
+          collect_task_types_from_expression(expression.operand, task_types, visited)
+        when IR::Binary
+          collect_task_types_from_expression(expression.left, task_types, visited)
+          collect_task_types_from_expression(expression.right, task_types, visited)
+        when IR::Conditional
+          collect_task_types_from_expression(expression.condition, task_types, visited)
+          collect_task_types_from_expression(expression.then_expression, task_types, visited)
+          collect_task_types_from_expression(expression.else_expression, task_types, visited)
+        when IR::ReinterpretExpr
+          collect_task_type(expression.target_type, task_types, visited)
+          collect_task_type(expression.source_type, task_types, visited)
+          collect_task_types_from_expression(expression.expression, task_types, visited)
+        when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
+          collect_task_type(expression.target_type, task_types, visited)
+        when IR::AddressOf, IR::Cast
+          collect_task_types_from_expression(expression.expression, task_types, visited)
+        when IR::AggregateLiteral
+          collect_task_type(expression.type, task_types, visited)
+          expression.fields.each { |field| collect_task_types_from_expression(field.value, task_types, visited) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_task_types_from_expression(element, task_types, visited) }
+        when IR::VariantLiteral
+          collect_task_type(expression.type, task_types, visited)
+          expression.fields.each { |field| collect_task_types_from_expression(field.value, task_types, visited) }
+        end
+      end
+
+      def collect_task_type(type, task_types, visited)
+        return unless type
+        return if visited[type]
+
+        visited[type] = true
+
+        case type
+        when Types::Nullable
+          collect_task_type(type.base, task_types, visited)
+        when Types::Task
+          task_types << type
+          collect_task_type(type.result_type, task_types, visited)
+        when Types::Span
+          collect_task_type(type.element_type, task_types, visited)
+        when Types::StructInstance
+          type.arguments.each do |argument|
+            collect_task_type(argument, task_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+          type.fields.each_value do |field_type|
+            collect_task_type(field_type, task_types, visited)
+          end
+        when Types::GenericInstance
+          type.arguments.each do |argument|
+            collect_task_type(argument, task_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        when Types::Function
+          type.params.each do |param|
+            collect_task_type(param.type, task_types, visited)
+          end
+          collect_task_type(type.return_type, task_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_task_type(field_type, task_types, visited)
+          end
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
+              collect_task_type(field_type, task_types, visited)
             end
           end
+        end
+      end
 
-          def collect_task_type(type, task_types, visited)
-            return unless type
-            return if visited[type]
+      def collect_generic_variant_types
+        generic_variant_types = []
+        visited = {}
 
-            visited[type] = true
+        all_emitted_top_level_values.each do |value|
+          collect_generic_variant_type(value.type, generic_variant_types, visited)
+        end
 
-            case type
-            when Types::Nullable
-              collect_task_type(type.base, task_types, visited)
-            when Types::Task
-              task_types << type
-              collect_task_type(type.result_type, task_types, visited)
-            when Types::Span
-              collect_task_type(type.element_type, task_types, visited)
-            when Types::StructInstance
-              type.arguments.each do |argument|
-                collect_task_type(argument, task_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-              type.fields.each_value do |field_type|
-                collect_task_type(field_type, task_types, visited)
-              end
-            when Types::GenericInstance
-              type.arguments.each do |argument|
-                collect_task_type(argument, task_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-            when Types::Function
-              type.params.each do |param|
-                collect_task_type(param.type, task_types, visited)
-              end
-              collect_task_type(type.return_type, task_types, visited)
-            when Types::Struct, Types::Union
-              type.fields.each_value do |field_type|
-                collect_task_type(field_type, task_types, visited)
-              end
-            when Types::Variant
-              type.arm_names.each do |arm_name|
-                type.arm(arm_name).each_value do |field_type|
-                  collect_task_type(field_type, task_types, visited)
-                end
-              end
-            end
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_generic_variant_type(field.type, generic_variant_types, visited)
           end
+        end
 
-          def collect_generic_variant_types
-            generic_variant_types = []
-            visited = {}
-
-            all_emitted_top_level_values.each do |value|
-              collect_generic_variant_type(value.type, generic_variant_types, visited)
-            end
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_generic_variant_type(field.type, generic_variant_types, visited)
+          end
+        end
 
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_generic_variant_type(field.type, generic_variant_types, visited)
-              end
-            end
+        each_variant_arm_field_type do |field_type|
+          collect_generic_variant_type(field_type, generic_variant_types, visited)
+        end
 
-            @program.unions.each do |union_decl|
-              union_decl.fields.each do |field|
-                collect_generic_variant_type(field.type, generic_variant_types, visited)
-              end
-            end
-
-            each_variant_arm_field_type do |field_type|
+        emitted_functions.each do |function|
+          collect_generic_variant_type(function.return_type, generic_variant_types, visited)
+          function.params.each do |param|
+            collect_generic_variant_type(param.type, generic_variant_types, visited)
+          end
+          collect_generic_variant_types_from_statements(function.body, generic_variant_types, visited)
+        end
+
+        @program.static_asserts.each do |statement|
+          collect_generic_variant_types_from_expression(statement.condition, generic_variant_types, visited)
+          collect_generic_variant_types_from_expression(statement.message, generic_variant_types, visited)
+        end
+
+        generic_variant_types
+      end
+
+      def collect_generic_variant_types_from_statements(statements, generic_variant_types, visited)
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_generic_variant_type,
+          expression_walker_method: :collect_generic_variant_types_from_expression,
+          accumulator: generic_variant_types, visited:)
+      end
+
+      def collect_generic_variant_types_from_expression(expression, generic_variant_types, visited)
+        case expression
+        when IR::Member
+          collect_generic_variant_types_from_expression(expression.receiver, generic_variant_types, visited)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_generic_variant_types_from_expression(expression.receiver, generic_variant_types, visited)
+          collect_generic_variant_types_from_expression(expression.index, generic_variant_types, visited)
+        when IR::Call
+          collect_generic_variant_type(expression.type, generic_variant_types, visited)
+          collect_generic_variant_types_from_expression(expression.callee, generic_variant_types, visited) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_generic_variant_types_from_expression(argument, generic_variant_types, visited) }
+        when IR::Unary
+          collect_generic_variant_types_from_expression(expression.operand, generic_variant_types, visited)
+        when IR::Binary
+          collect_generic_variant_types_from_expression(expression.left, generic_variant_types, visited)
+          collect_generic_variant_types_from_expression(expression.right, generic_variant_types, visited)
+        when IR::Conditional
+          collect_generic_variant_types_from_expression(expression.condition, generic_variant_types, visited)
+          collect_generic_variant_types_from_expression(expression.then_expression, generic_variant_types, visited)
+          collect_generic_variant_types_from_expression(expression.else_expression, generic_variant_types, visited)
+        when IR::ReinterpretExpr
+          collect_generic_variant_type(expression.target_type, generic_variant_types, visited)
+          collect_generic_variant_type(expression.source_type, generic_variant_types, visited)
+          collect_generic_variant_types_from_expression(expression.expression, generic_variant_types, visited)
+        when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
+          collect_generic_variant_type(expression.target_type, generic_variant_types, visited)
+        when IR::AddressOf, IR::Cast
+          collect_generic_variant_types_from_expression(expression.expression, generic_variant_types, visited)
+        when IR::AggregateLiteral
+          collect_generic_variant_type(expression.type, generic_variant_types, visited)
+          expression.fields.each { |field| collect_generic_variant_types_from_expression(field.value, generic_variant_types, visited) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_generic_variant_types_from_expression(element, generic_variant_types, visited) }
+        when IR::VariantLiteral
+          collect_generic_variant_type(expression.type, generic_variant_types, visited)
+          expression.fields.each { |field| collect_generic_variant_types_from_expression(field.value, generic_variant_types, visited) }
+        end
+      end
+
+      def collect_generic_variant_type(type, generic_variant_types, visited)
+        return unless type
+        return if visited[type]
+
+        visited[type] = true
+
+        case type
+        when Types::Nullable
+          collect_generic_variant_type(type.base, generic_variant_types, visited)
+        when Types::Task
+          collect_generic_variant_type(type.result_type, generic_variant_types, visited)
+        when Types::Span
+          collect_generic_variant_type(type.element_type, generic_variant_types, visited)
+        when Types::VariantInstance
+          type.arguments.each do |argument|
+            collect_generic_variant_type(argument, generic_variant_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
               collect_generic_variant_type(field_type, generic_variant_types, visited)
             end
-
-            emitted_functions.each do |function|
-              collect_generic_variant_type(function.return_type, generic_variant_types, visited)
-              function.params.each do |param|
-                collect_generic_variant_type(param.type, generic_variant_types, visited)
-              end
-              collect_generic_variant_types_from_statements(function.body, generic_variant_types, visited)
-            end
-
-            @program.static_asserts.each do |statement|
-              collect_generic_variant_types_from_expression(statement.condition, generic_variant_types, visited)
-              collect_generic_variant_types_from_expression(statement.message, generic_variant_types, visited)
-            end
-
-            generic_variant_types
-          end
-
-          def collect_generic_variant_types_from_statements(statements, generic_variant_types, visited)
-            each_ir_statement_for_type_collection(statements,
-              type_collector_method: :collect_generic_variant_type,
-              expression_walker_method: :collect_generic_variant_types_from_expression,
-              accumulator: generic_variant_types, visited:)
-          end
-
-          def collect_generic_variant_types_from_expression(expression, generic_variant_types, visited)
-            case expression
-            when IR::Member
-              collect_generic_variant_types_from_expression(expression.receiver, generic_variant_types, visited)
-            when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
-              collect_generic_variant_types_from_expression(expression.receiver, generic_variant_types, visited)
-              collect_generic_variant_types_from_expression(expression.index, generic_variant_types, visited)
-            when IR::Call
-              collect_generic_variant_type(expression.type, generic_variant_types, visited)
-              collect_generic_variant_types_from_expression(expression.callee, generic_variant_types, visited) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_generic_variant_types_from_expression(argument, generic_variant_types, visited) }
-            when IR::Unary
-              collect_generic_variant_types_from_expression(expression.operand, generic_variant_types, visited)
-            when IR::Binary
-              collect_generic_variant_types_from_expression(expression.left, generic_variant_types, visited)
-              collect_generic_variant_types_from_expression(expression.right, generic_variant_types, visited)
-            when IR::Conditional
-              collect_generic_variant_types_from_expression(expression.condition, generic_variant_types, visited)
-              collect_generic_variant_types_from_expression(expression.then_expression, generic_variant_types, visited)
-              collect_generic_variant_types_from_expression(expression.else_expression, generic_variant_types, visited)
-            when IR::ReinterpretExpr
-              collect_generic_variant_type(expression.target_type, generic_variant_types, visited)
-              collect_generic_variant_type(expression.source_type, generic_variant_types, visited)
-              collect_generic_variant_types_from_expression(expression.expression, generic_variant_types, visited)
-            when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
-              collect_generic_variant_type(expression.target_type, generic_variant_types, visited)
-            when IR::AddressOf, IR::Cast
-              collect_generic_variant_types_from_expression(expression.expression, generic_variant_types, visited)
-            when IR::AggregateLiteral
-              collect_generic_variant_type(expression.type, generic_variant_types, visited)
-              expression.fields.each { |field| collect_generic_variant_types_from_expression(field.value, generic_variant_types, visited) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_generic_variant_types_from_expression(element, generic_variant_types, visited) }
-            when IR::VariantLiteral
-              collect_generic_variant_type(expression.type, generic_variant_types, visited)
-              expression.fields.each { |field| collect_generic_variant_types_from_expression(field.value, generic_variant_types, visited) }
+          end
+          generic_variant_types << type
+        when Types::StructInstance
+          type.arguments.each do |argument|
+            collect_generic_variant_type(argument, generic_variant_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+          type.fields.each_value do |field_type|
+            collect_generic_variant_type(field_type, generic_variant_types, visited)
+          end
+        when Types::GenericInstance
+          type.arguments.each do |argument|
+            collect_generic_variant_type(argument, generic_variant_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        when Types::Function, Types::Proc
+          type.params.each do |param|
+            collect_generic_variant_type(param.type, generic_variant_types, visited)
+          end
+          collect_generic_variant_type(type.return_type, generic_variant_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_generic_variant_type(field_type, generic_variant_types, visited)
+          end
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
+              collect_generic_variant_type(field_type, generic_variant_types, visited)
             end
           end
+        end
+      end
 
-          def collect_generic_variant_type(type, generic_variant_types, visited)
-            return unless type
-            return if visited[type]
+      def collect_generic_struct_types
+        generic_struct_types = []
+        visited = {}
 
-            visited[type] = true
+        all_emitted_top_level_values.each do |value|
+          collect_generic_struct_type(value.type, generic_struct_types, visited)
+        end
 
-            case type
-            when Types::Nullable
-              collect_generic_variant_type(type.base, generic_variant_types, visited)
-            when Types::Task
-              collect_generic_variant_type(type.result_type, generic_variant_types, visited)
-            when Types::Span
-              collect_generic_variant_type(type.element_type, generic_variant_types, visited)
-            when Types::VariantInstance
-              type.arguments.each do |argument|
-                collect_generic_variant_type(argument, generic_variant_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-              type.arm_names.each do |arm_name|
-                type.arm(arm_name).each_value do |field_type|
-                  collect_generic_variant_type(field_type, generic_variant_types, visited)
-                end
-              end
-              generic_variant_types << type
-            when Types::StructInstance
-              type.arguments.each do |argument|
-                collect_generic_variant_type(argument, generic_variant_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-              type.fields.each_value do |field_type|
-                collect_generic_variant_type(field_type, generic_variant_types, visited)
-              end
-            when Types::GenericInstance
-              type.arguments.each do |argument|
-                collect_generic_variant_type(argument, generic_variant_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-            when Types::Function, Types::Proc
-              type.params.each do |param|
-                collect_generic_variant_type(param.type, generic_variant_types, visited)
-              end
-              collect_generic_variant_type(type.return_type, generic_variant_types, visited)
-            when Types::Struct, Types::Union
-              type.fields.each_value do |field_type|
-                collect_generic_variant_type(field_type, generic_variant_types, visited)
-              end
-            when Types::Variant
-              type.arm_names.each do |arm_name|
-                type.arm(arm_name).each_value do |field_type|
-                  collect_generic_variant_type(field_type, generic_variant_types, visited)
-                end
-              end
-            end
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_generic_struct_type(field.type, generic_struct_types, visited)
           end
+        end
 
-          def collect_generic_struct_types
-            generic_struct_types = []
-            visited = {}
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_generic_struct_type(field.type, generic_struct_types, visited)
+          end
+        end
 
-            all_emitted_top_level_values.each do |value|
-              collect_generic_struct_type(value.type, generic_struct_types, visited)
-            end
+        each_variant_arm_field_type do |field_type|
+          collect_generic_struct_type(field_type, generic_struct_types, visited)
+        end
 
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_generic_struct_type(field.type, generic_struct_types, visited)
-              end
-            end
+        emitted_functions.each do |function|
+          collect_generic_struct_type(function.return_type, generic_struct_types, visited)
+          function.params.each do |param|
+            collect_generic_struct_type(param.type, generic_struct_types, visited)
+          end
+          collect_generic_struct_types_from_statements(function.body, generic_struct_types, visited)
+        end
 
-            @program.unions.each do |union_decl|
-              union_decl.fields.each do |field|
-                collect_generic_struct_type(field.type, generic_struct_types, visited)
-              end
-            end
+        @program.static_asserts.each do |statement|
+          collect_generic_struct_types_from_expression(statement.condition, generic_struct_types, visited)
+          collect_generic_struct_types_from_expression(statement.message, generic_struct_types, visited)
+        end
 
-            each_variant_arm_field_type do |field_type|
-              collect_generic_struct_type(field_type, generic_struct_types, visited)
-            end
+        generic_struct_types
+      end
 
-            emitted_functions.each do |function|
-              collect_generic_struct_type(function.return_type, generic_struct_types, visited)
-              function.params.each do |param|
-                collect_generic_struct_type(param.type, generic_struct_types, visited)
-              end
-              collect_generic_struct_types_from_statements(function.body, generic_struct_types, visited)
-            end
+      def collect_str_buffer_types
+        str_buffer_types = []
+        visited = {}
 
-            @program.static_asserts.each do |statement|
-              collect_generic_struct_types_from_expression(statement.condition, generic_struct_types, visited)
-              collect_generic_struct_types_from_expression(statement.message, generic_struct_types, visited)
-            end
+        all_emitted_top_level_values.each do |value|
+          collect_str_buffer_type(value.type, str_buffer_types, visited)
+        end
 
-            generic_struct_types
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_str_buffer_type(field.type, str_buffer_types, visited)
           end
+        end
 
-          def collect_str_buffer_types
-            str_buffer_types = []
-            visited = {}
-
-            all_emitted_top_level_values.each do |value|
-              collect_str_buffer_type(value.type, str_buffer_types, visited)
-            end
-
-            @program.structs.each do |struct_decl|
-              struct_decl.fields.each do |field|
-                collect_str_buffer_type(field.type, str_buffer_types, visited)
-              end
-            end
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_str_buffer_type(field.type, str_buffer_types, visited)
+          end
+        end
 
-            @program.unions.each do |union_decl|
-              union_decl.fields.each do |field|
-                collect_str_buffer_type(field.type, str_buffer_types, visited)
-              end
-            end
+        each_variant_arm_field_type do |field_type|
+          collect_str_buffer_type(field_type, str_buffer_types, visited)
+        end
 
-            each_variant_arm_field_type do |field_type|
+        emitted_functions.each do |function|
+          collect_str_buffer_type(function.return_type, str_buffer_types, visited)
+          function.params.each do |param|
+            collect_str_buffer_type(param.type, str_buffer_types, visited)
+          end
+          collect_str_buffer_types_from_statements(function.body, str_buffer_types, visited)
+        end
+
+        @program.static_asserts.each do |statement|
+          collect_str_buffer_types_from_expression(statement.condition, str_buffer_types, visited)
+          collect_str_buffer_types_from_expression(statement.message, str_buffer_types, visited)
+        end
+
+        str_buffer_types
+      end
+
+      def collect_str_buffer_types_from_statements(statements, str_buffer_types, visited)
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_str_buffer_type,
+          expression_walker_method: :collect_str_buffer_types_from_expression,
+          accumulator: str_buffer_types, visited:)
+      end
+
+      def collect_str_buffer_types_from_expression(expression, str_buffer_types, visited)
+        case expression
+        when IR::Member
+          collect_str_buffer_types_from_expression(expression.receiver, str_buffer_types, visited)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_str_buffer_types_from_expression(expression.receiver, str_buffer_types, visited)
+          collect_str_buffer_types_from_expression(expression.index, str_buffer_types, visited)
+        when IR::Call
+          collect_str_buffer_type(expression.type, str_buffer_types, visited)
+          collect_str_buffer_types_from_expression(expression.callee, str_buffer_types, visited) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_str_buffer_types_from_expression(argument, str_buffer_types, visited) }
+        when IR::Unary
+          collect_str_buffer_types_from_expression(expression.operand, str_buffer_types, visited)
+        when IR::Binary
+          collect_str_buffer_types_from_expression(expression.left, str_buffer_types, visited)
+          collect_str_buffer_types_from_expression(expression.right, str_buffer_types, visited)
+        when IR::Conditional
+          collect_str_buffer_types_from_expression(expression.condition, str_buffer_types, visited)
+          collect_str_buffer_types_from_expression(expression.then_expression, str_buffer_types, visited)
+          collect_str_buffer_types_from_expression(expression.else_expression, str_buffer_types, visited)
+        when IR::ReinterpretExpr
+          collect_str_buffer_type(expression.target_type, str_buffer_types, visited)
+          collect_str_buffer_type(expression.source_type, str_buffer_types, visited)
+          collect_str_buffer_types_from_expression(expression.expression, str_buffer_types, visited)
+        when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
+          collect_str_buffer_type(expression.target_type, str_buffer_types, visited)
+        when IR::AddressOf, IR::Cast
+          collect_str_buffer_types_from_expression(expression.expression, str_buffer_types, visited)
+        when IR::AggregateLiteral
+          collect_str_buffer_type(expression.type, str_buffer_types, visited)
+          expression.fields.each { |field| collect_str_buffer_types_from_expression(field.value, str_buffer_types, visited) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_str_buffer_types_from_expression(element, str_buffer_types, visited) }
+        when IR::VariantLiteral
+          collect_str_buffer_type(expression.type, str_buffer_types, visited)
+          expression.fields.each { |field| collect_str_buffer_types_from_expression(field.value, str_buffer_types, visited) }
+        end
+      end
+
+      def collect_str_buffer_type(type, str_buffer_types, visited)
+        return unless type
+        return if visited[type]
+
+        visited[type] = true
+
+        case type
+        when Types::Nullable
+          collect_str_buffer_type(type.base, str_buffer_types, visited)
+        when Types::Span
+          collect_str_buffer_type(type.element_type, str_buffer_types, visited)
+        when Types::StructInstance
+          type.arguments.each do |argument|
+            collect_str_buffer_type(argument, str_buffer_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+          type.fields.each_value do |field_type|
+            collect_str_buffer_type(field_type, str_buffer_types, visited)
+          end
+        when Types::GenericInstance
+          str_buffer_types << type if str_buffer_type?(type)
+          type.arguments.each do |argument|
+            collect_str_buffer_type(argument, str_buffer_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        when Types::Function
+          type.params.each do |param|
+            collect_str_buffer_type(param.type, str_buffer_types, visited)
+          end
+          collect_str_buffer_type(type.return_type, str_buffer_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_str_buffer_type(field_type, str_buffer_types, visited)
+          end
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
               collect_str_buffer_type(field_type, str_buffer_types, visited)
             end
-
-            emitted_functions.each do |function|
-              collect_str_buffer_type(function.return_type, str_buffer_types, visited)
-              function.params.each do |param|
-                collect_str_buffer_type(param.type, str_buffer_types, visited)
-              end
-              collect_str_buffer_types_from_statements(function.body, str_buffer_types, visited)
-            end
-
-            @program.static_asserts.each do |statement|
-              collect_str_buffer_types_from_expression(statement.condition, str_buffer_types, visited)
-              collect_str_buffer_types_from_expression(statement.message, str_buffer_types, visited)
-            end
-
-            str_buffer_types
-          end
-
-          def collect_str_buffer_types_from_statements(statements, str_buffer_types, visited)
-            each_ir_statement_for_type_collection(statements,
-              type_collector_method: :collect_str_buffer_type,
-              expression_walker_method: :collect_str_buffer_types_from_expression,
-              accumulator: str_buffer_types, visited:)
-          end
-
-          def collect_str_buffer_types_from_expression(expression, str_buffer_types, visited)
-            case expression
-            when IR::Member
-              collect_str_buffer_types_from_expression(expression.receiver, str_buffer_types, visited)
-            when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
-              collect_str_buffer_types_from_expression(expression.receiver, str_buffer_types, visited)
-              collect_str_buffer_types_from_expression(expression.index, str_buffer_types, visited)
-            when IR::Call
-              collect_str_buffer_type(expression.type, str_buffer_types, visited)
-              collect_str_buffer_types_from_expression(expression.callee, str_buffer_types, visited) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_str_buffer_types_from_expression(argument, str_buffer_types, visited) }
-            when IR::Unary
-              collect_str_buffer_types_from_expression(expression.operand, str_buffer_types, visited)
-            when IR::Binary
-              collect_str_buffer_types_from_expression(expression.left, str_buffer_types, visited)
-              collect_str_buffer_types_from_expression(expression.right, str_buffer_types, visited)
-            when IR::Conditional
-              collect_str_buffer_types_from_expression(expression.condition, str_buffer_types, visited)
-              collect_str_buffer_types_from_expression(expression.then_expression, str_buffer_types, visited)
-              collect_str_buffer_types_from_expression(expression.else_expression, str_buffer_types, visited)
-            when IR::ReinterpretExpr
-              collect_str_buffer_type(expression.target_type, str_buffer_types, visited)
-              collect_str_buffer_type(expression.source_type, str_buffer_types, visited)
-              collect_str_buffer_types_from_expression(expression.expression, str_buffer_types, visited)
-            when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
-              collect_str_buffer_type(expression.target_type, str_buffer_types, visited)
-            when IR::AddressOf, IR::Cast
-              collect_str_buffer_types_from_expression(expression.expression, str_buffer_types, visited)
-            when IR::AggregateLiteral
-              collect_str_buffer_type(expression.type, str_buffer_types, visited)
-              expression.fields.each { |field| collect_str_buffer_types_from_expression(field.value, str_buffer_types, visited) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_str_buffer_types_from_expression(element, str_buffer_types, visited) }
-            when IR::VariantLiteral
-              collect_str_buffer_type(expression.type, str_buffer_types, visited)
-              expression.fields.each { |field| collect_str_buffer_types_from_expression(field.value, str_buffer_types, visited) }
-            end
           end
-
-          def collect_str_buffer_type(type, str_buffer_types, visited)
-            return unless type
-            return if visited[type]
-
-            visited[type] = true
-
-            case type
-            when Types::Nullable
-              collect_str_buffer_type(type.base, str_buffer_types, visited)
-            when Types::Span
-              collect_str_buffer_type(type.element_type, str_buffer_types, visited)
-            when Types::StructInstance
-              type.arguments.each do |argument|
-                collect_str_buffer_type(argument, str_buffer_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-              type.fields.each_value do |field_type|
-                collect_str_buffer_type(field_type, str_buffer_types, visited)
-              end
-            when Types::GenericInstance
-              str_buffer_types << type if str_buffer_type?(type)
-              type.arguments.each do |argument|
-                collect_str_buffer_type(argument, str_buffer_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-            when Types::Function
-              type.params.each do |param|
-                collect_str_buffer_type(param.type, str_buffer_types, visited)
-              end
-              collect_str_buffer_type(type.return_type, str_buffer_types, visited)
-            when Types::Struct, Types::Union
-              type.fields.each_value do |field_type|
-                collect_str_buffer_type(field_type, str_buffer_types, visited)
-              end
-            when Types::Variant
-              type.arm_names.each do |arm_name|
-                type.arm(arm_name).each_value do |field_type|
-                  collect_str_buffer_type(field_type, str_buffer_types, visited)
-                end
-              end
-            end
+        end
+      end
+
+      def collect_generic_struct_types_from_statements(statements, generic_struct_types, visited)
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_generic_struct_type,
+          expression_walker_method: :collect_generic_struct_types_from_expression,
+          accumulator: generic_struct_types, visited:)
+      end
+
+      def collect_generic_struct_types_from_expression(expression, generic_struct_types, visited)
+        case expression
+        when IR::Member
+          collect_generic_struct_types_from_expression(expression.receiver, generic_struct_types, visited)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_generic_struct_types_from_expression(expression.receiver, generic_struct_types, visited)
+          collect_generic_struct_types_from_expression(expression.index, generic_struct_types, visited)
+        when IR::Call
+          collect_generic_struct_type(expression.type, generic_struct_types, visited)
+          collect_generic_struct_types_from_expression(expression.callee, generic_struct_types, visited) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_generic_struct_types_from_expression(argument, generic_struct_types, visited) }
+        when IR::Unary
+          collect_generic_struct_types_from_expression(expression.operand, generic_struct_types, visited)
+        when IR::Binary
+          collect_generic_struct_types_from_expression(expression.left, generic_struct_types, visited)
+          collect_generic_struct_types_from_expression(expression.right, generic_struct_types, visited)
+        when IR::Conditional
+          collect_generic_struct_types_from_expression(expression.condition, generic_struct_types, visited)
+          collect_generic_struct_types_from_expression(expression.then_expression, generic_struct_types, visited)
+          collect_generic_struct_types_from_expression(expression.else_expression, generic_struct_types, visited)
+        when IR::ReinterpretExpr
+          collect_generic_struct_type(expression.target_type, generic_struct_types, visited)
+          collect_generic_struct_type(expression.source_type, generic_struct_types, visited)
+          collect_generic_struct_types_from_expression(expression.expression, generic_struct_types, visited)
+        when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
+          collect_generic_struct_type(expression.target_type, generic_struct_types, visited)
+        when IR::AddressOf
+          collect_generic_struct_types_from_expression(expression.expression, generic_struct_types, visited)
+        when IR::Cast
+          collect_generic_struct_types_from_expression(expression.expression, generic_struct_types, visited)
+        when IR::AggregateLiteral
+          collect_generic_struct_type(expression.type, generic_struct_types, visited)
+          expression.fields.each { |field| collect_generic_struct_types_from_expression(field.value, generic_struct_types, visited) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_generic_struct_types_from_expression(element, generic_struct_types, visited) }
+        when IR::VariantLiteral
+          collect_generic_struct_type(expression.type, generic_struct_types, visited)
+          expression.fields.each { |field| collect_generic_struct_types_from_expression(field.value, generic_struct_types, visited) }
+        end
+      end
+
+      def collect_generic_struct_type(type, generic_struct_types, visited)
+        return unless type
+        return if visited[type]
+
+        visited[type] = true
+
+        case type
+        when Types::Nullable
+          collect_generic_struct_type(type.base, generic_struct_types, visited)
+        when Types::Span
+          collect_generic_struct_type(type.element_type, generic_struct_types, visited)
+        when Types::StructInstance
+          generic_struct_types << type
+          type.arguments.each do |argument|
+            collect_generic_struct_type(argument, generic_struct_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
           end
-
-          def collect_generic_struct_types_from_statements(statements, generic_struct_types, visited)
-            each_ir_statement_for_type_collection(statements,
-              type_collector_method: :collect_generic_struct_type,
-              expression_walker_method: :collect_generic_struct_types_from_expression,
-              accumulator: generic_struct_types, visited:)
-          end
-
-          def collect_generic_struct_types_from_expression(expression, generic_struct_types, visited)
-            case expression
-            when IR::Member
-              collect_generic_struct_types_from_expression(expression.receiver, generic_struct_types, visited)
-            when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
-              collect_generic_struct_types_from_expression(expression.receiver, generic_struct_types, visited)
-              collect_generic_struct_types_from_expression(expression.index, generic_struct_types, visited)
-            when IR::Call
-              collect_generic_struct_type(expression.type, generic_struct_types, visited)
-              collect_generic_struct_types_from_expression(expression.callee, generic_struct_types, visited) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_generic_struct_types_from_expression(argument, generic_struct_types, visited) }
-            when IR::Unary
-              collect_generic_struct_types_from_expression(expression.operand, generic_struct_types, visited)
-            when IR::Binary
-              collect_generic_struct_types_from_expression(expression.left, generic_struct_types, visited)
-              collect_generic_struct_types_from_expression(expression.right, generic_struct_types, visited)
-            when IR::Conditional
-              collect_generic_struct_types_from_expression(expression.condition, generic_struct_types, visited)
-              collect_generic_struct_types_from_expression(expression.then_expression, generic_struct_types, visited)
-              collect_generic_struct_types_from_expression(expression.else_expression, generic_struct_types, visited)
-            when IR::ReinterpretExpr
-              collect_generic_struct_type(expression.target_type, generic_struct_types, visited)
-              collect_generic_struct_type(expression.source_type, generic_struct_types, visited)
-              collect_generic_struct_types_from_expression(expression.expression, generic_struct_types, visited)
-            when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
-              collect_generic_struct_type(expression.target_type, generic_struct_types, visited)
-            when IR::AddressOf
-              collect_generic_struct_types_from_expression(expression.expression, generic_struct_types, visited)
-            when IR::Cast
-              collect_generic_struct_types_from_expression(expression.expression, generic_struct_types, visited)
-            when IR::AggregateLiteral
-              collect_generic_struct_type(expression.type, generic_struct_types, visited)
-              expression.fields.each { |field| collect_generic_struct_types_from_expression(field.value, generic_struct_types, visited) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_generic_struct_types_from_expression(element, generic_struct_types, visited) }
-            when IR::VariantLiteral
-              collect_generic_struct_type(expression.type, generic_struct_types, visited)
-              expression.fields.each { |field| collect_generic_struct_types_from_expression(field.value, generic_struct_types, visited) }
-            end
+          type.fields.each_value do |field_type|
+            collect_generic_struct_type(field_type, generic_struct_types, visited)
           end
-
-          def collect_generic_struct_type(type, generic_struct_types, visited)
-            return unless type
-            return if visited[type]
-
-            visited[type] = true
-
-            case type
-            when Types::Nullable
-              collect_generic_struct_type(type.base, generic_struct_types, visited)
-            when Types::Span
-              collect_generic_struct_type(type.element_type, generic_struct_types, visited)
-            when Types::StructInstance
-              generic_struct_types << type
-              type.arguments.each do |argument|
-                collect_generic_struct_type(argument, generic_struct_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-              type.fields.each_value do |field_type|
-                collect_generic_struct_type(field_type, generic_struct_types, visited)
-              end
-            when Types::GenericInstance
-              type.arguments.each do |argument|
-                collect_generic_struct_type(argument, generic_struct_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-            when Types::Function
-              type.params.each do |param|
-                collect_generic_struct_type(param.type, generic_struct_types, visited)
-              end
-              collect_generic_struct_type(type.return_type, generic_struct_types, visited)
-            when Types::Struct, Types::Union
-              type.fields.each_value do |field_type|
-                collect_generic_struct_type(field_type, generic_struct_types, visited)
-              end
-            when Types::Variant
-              type.arm_names.each do |arm_name|
-                type.arm(arm_name).each_value do |field_type|
-                  collect_generic_struct_type(field_type, generic_struct_types, visited)
-                end
-              end
-            end
+        when Types::GenericInstance
+          type.arguments.each do |argument|
+            collect_generic_struct_type(argument, generic_struct_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
           end
-
-          def collect_span_types_from_statements(statements, span_types, visited)
-            each_ir_statement_for_type_collection(statements,
-              type_collector_method: :collect_span_type,
-              expression_walker_method: :collect_span_types_from_expression,
-              accumulator: span_types, visited:)
-          end
-
-          def collect_span_types_from_expression(expression, span_types, visited)
-            case expression
-            when IR::Member
-              collect_span_types_from_expression(expression.receiver, span_types, visited)
-            when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
-              collect_span_types_from_expression(expression.receiver, span_types, visited)
-              collect_span_types_from_expression(expression.index, span_types, visited)
-            when IR::Call
-              collect_span_type(expression.type, span_types, visited)
-              collect_span_types_from_expression(expression.callee, span_types, visited) unless expression.callee.is_a?(String)
-              expression.arguments.each { |argument| collect_span_types_from_expression(argument, span_types, visited) }
-            when IR::Unary
-              collect_span_types_from_expression(expression.operand, span_types, visited)
-            when IR::Binary
-              collect_span_types_from_expression(expression.left, span_types, visited)
-              collect_span_types_from_expression(expression.right, span_types, visited)
-            when IR::Conditional
-              collect_span_types_from_expression(expression.condition, span_types, visited)
-              collect_span_types_from_expression(expression.then_expression, span_types, visited)
-              collect_span_types_from_expression(expression.else_expression, span_types, visited)
-            when IR::ReinterpretExpr
-              collect_span_type(expression.target_type, span_types, visited)
-              collect_span_type(expression.source_type, span_types, visited)
-              collect_span_types_from_expression(expression.expression, span_types, visited)
-            when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
-              collect_span_type(expression.target_type, span_types, visited)
-            when IR::AddressOf
-              collect_span_types_from_expression(expression.expression, span_types, visited)
-            when IR::Cast
-              collect_span_types_from_expression(expression.expression, span_types, visited)
-            when IR::AggregateLiteral
-              collect_span_type(expression.type, span_types, visited)
-              expression.fields.each { |field| collect_span_types_from_expression(field.value, span_types, visited) }
-            when IR::ArrayLiteral
-              expression.elements.each { |element| collect_span_types_from_expression(element, span_types, visited) }
-            when IR::VariantLiteral
-              collect_span_type(expression.type, span_types, visited)
-              expression.fields.each { |field| collect_span_types_from_expression(field.value, span_types, visited) }
-            end
+        when Types::Function
+          type.params.each do |param|
+            collect_generic_struct_type(param.type, generic_struct_types, visited)
           end
-
-          def collect_span_type(type, span_types, visited)
-            return unless type
-            return if visited[type]
-
-            visited[type] = true
-
-            case type
-            when Types::Nullable
-              collect_span_type(type.base, span_types, visited)
-            when Types::Span
-              span_types << type
-              collect_span_type(type.element_type, span_types, visited)
-            when Types::GenericInstance
-              type.arguments.each do |argument|
-                collect_span_type(argument, span_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
-              end
-            when Types::Function
-              type.params.each do |param|
-                collect_span_type(param.type, span_types, visited)
-              end
-              collect_span_type(type.return_type, span_types, visited)
-            when Types::Struct, Types::Union
-              type.fields.each_value do |field_type|
-                collect_span_type(field_type, span_types, visited)
-              end
-            when Types::Variant
-              type.arm_names.each do |arm_name|
-                type.arm(arm_name).each_value do |field_type|
-                  collect_span_type(field_type, span_types, visited)
-                end
-              end
-            end
+          collect_generic_struct_type(type.return_type, generic_struct_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_generic_struct_type(field_type, generic_struct_types, visited)
           end
-
-          def collect_dyn_decls
-            void_ptr = Types::Registry.generic_instance("ptr", [Types::Registry.primitive("void")])
-            collect_dyn_types.map do |type|
-              IR::StructDecl.new(
-                name: type.to_s,
-                linkage_name: dyn_type_name(type),
-                fields: [
-                  IR::Field.new(name: "data", type: void_ptr),
-                  IR::Field.new(name: "vtable", type: void_ptr),
-                ],
-                packed: false,
-                alignment: nil,
-              )
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
+              collect_generic_struct_type(field_type, generic_struct_types, visited)
             end
           end
-
-          def collect_dyn_types
-            dyn_types = []
-            seen = []
-
-            collect_type = lambda do |type|
-              return unless type
-              case type
-              when Types::Dyn
-                name = type.interface_binding.name
-                unless seen.include?(name)
-                  seen << name
-                  dyn_types << type
-                end
-              when Types::Nullable
-                collect_type.call(type.base)
-              when Types::GenericInstance
-                type.arguments.each { |arg| collect_type.call(arg) unless arg.is_a?(Types::LiteralTypeArg) }
-              when Types::Span
-                collect_type.call(type.element_type)
-              when Types::Task
-                collect_type.call(type.result_type)
-              when Types::Function
-                type.params.each { |p| collect_type.call(p.type) }
-                collect_type.call(type.return_type)
-              when Types::Proc
-                type.params.each { |p| collect_type.call(p.type) }
-                collect_type.call(type.return_type)
-              when Types::StructInstance
-                type.arguments.each { |arg| collect_type.call(arg) }
-              when Types::VariantInstance
-                type.arguments.each { |arg| collect_type.call(arg) }
-              end
-            end
-
-            collect_in_stmt = lambda do |stmt|
-              case stmt
-              when IR::LocalDecl
-                collect_type.call(stmt.type)
-              when IR::BlockStmt
-                stmt.body.each { |s| collect_in_stmt.call(s) }
-              when IR::IfStmt
-                stmt.then_body.each { |s| collect_in_stmt.call(s) }
-                stmt.else_body&.each { |s| collect_in_stmt.call(s) }
-              when IR::WhileStmt
-                stmt.body.each { |s| collect_in_stmt.call(s) }
-              when IR::ForStmt
-                stmt.body.each { |s| collect_in_stmt.call(s) }
-              when IR::SwitchStmt
-                stmt.cases.each { |c| c.body.each { |s| collect_in_stmt.call(s) } }
-              end
-            end
-
-            if @program
-              @program.constants.each { |c| collect_type.call(c.type) }
-              @program.globals.each { |g| collect_type.call(g.type) }
-              @program.structs.each { |s| s.fields.each { |f| collect_type.call(f.type) } }
-              @program.unions.each { |u| u.fields.each { |f| collect_type.call(f.type) } }
-              @program.functions.each do |f|
-                collect_type.call(f.return_type)
-                f.params.each { |p| collect_type.call(p.type) }
-                body = f.body
-                if body.is_a?(IR::BlockStmt)
-                  body.body.each { |s| collect_in_stmt.call(s) }
-                elsif body.is_a?(Array)
-                  body.each { |s| collect_in_stmt.call(s) }
-                end
-              end
-            end
-
-            dyn_types
-          end
-
-          def collect_nullable_opt_decls
-            collect_nullable_opt_types.map do |type|
-              IR::StructDecl.new(
-                name: type.to_s,
-                linkage_name: nullable_opt_type_name(type),
-                fields: [
-                  IR::Field.new(name: "has_value", type: Types::Registry.primitive("bool")),
-                  IR::Field.new(name: "value", type: type.base),
-                ],
-                packed: false,
-                alignment: nil,
-              )
-            end
+        end
+      end
+
+      def collect_span_types_from_statements(statements, span_types, visited)
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_span_type,
+          expression_walker_method: :collect_span_types_from_expression,
+          accumulator: span_types, visited:)
+      end
+
+      def collect_span_types_from_expression(expression, span_types, visited)
+        case expression
+        when IR::Member
+          collect_span_types_from_expression(expression.receiver, span_types, visited)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_span_types_from_expression(expression.receiver, span_types, visited)
+          collect_span_types_from_expression(expression.index, span_types, visited)
+        when IR::Call
+          collect_span_type(expression.type, span_types, visited)
+          collect_span_types_from_expression(expression.callee, span_types, visited) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_span_types_from_expression(argument, span_types, visited) }
+        when IR::Unary
+          collect_span_types_from_expression(expression.operand, span_types, visited)
+        when IR::Binary
+          collect_span_types_from_expression(expression.left, span_types, visited)
+          collect_span_types_from_expression(expression.right, span_types, visited)
+        when IR::Conditional
+          collect_span_types_from_expression(expression.condition, span_types, visited)
+          collect_span_types_from_expression(expression.then_expression, span_types, visited)
+          collect_span_types_from_expression(expression.else_expression, span_types, visited)
+        when IR::ReinterpretExpr
+          collect_span_type(expression.target_type, span_types, visited)
+          collect_span_type(expression.source_type, span_types, visited)
+          collect_span_types_from_expression(expression.expression, span_types, visited)
+        when IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
+          collect_span_type(expression.target_type, span_types, visited)
+        when IR::AddressOf
+          collect_span_types_from_expression(expression.expression, span_types, visited)
+        when IR::Cast
+          collect_span_types_from_expression(expression.expression, span_types, visited)
+        when IR::AggregateLiteral
+          collect_span_type(expression.type, span_types, visited)
+          expression.fields.each { |field| collect_span_types_from_expression(field.value, span_types, visited) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_span_types_from_expression(element, span_types, visited) }
+        when IR::VariantLiteral
+          collect_span_type(expression.type, span_types, visited)
+          expression.fields.each { |field| collect_span_types_from_expression(field.value, span_types, visited) }
+        end
+      end
+
+      def collect_span_type(type, span_types, visited)
+        return unless type
+        return if visited[type]
+
+        visited[type] = true
+
+        case type
+        when Types::Nullable
+          collect_span_type(type.base, span_types, visited)
+        when Types::Span
+          span_types << type
+          collect_span_type(type.element_type, span_types, visited)
+        when Types::GenericInstance
+          type.arguments.each do |argument|
+            collect_span_type(argument, span_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
           end
-
-          def collect_nullable_opt_types
-            opt_types = []
-            seen = {}
-
-            collect_type = lambda do |type|
-              return unless type
-
-              case type
-              when Types::Nullable
-                unless c_backend_pointer_like_type?(type.base)
-                  name = nullable_opt_type_name(type)
-                  unless seen[name]
-                    seen[name] = true
-                    opt_types << type
-                  end
-                end
-                collect_type.call(type.base)
-              when Types::GenericInstance
-                type.arguments.each { |arg| collect_type.call(arg) unless arg.is_a?(Types::LiteralTypeArg) }
-              when Types::Span
-                collect_type.call(type.element_type)
-              when Types::Task
-                collect_type.call(type.result_type)
-              when Types::Function, Types::Proc
-                type.params.each { |p| collect_type.call(p.type) }
-                collect_type.call(type.return_type)
-              when Types::StructInstance, Types::VariantInstance
-                type.arguments.each { |arg| collect_type.call(arg) }
-              end
-            end
-
-            collect_in_stmt = lambda do |stmt|
-              case stmt
-              when IR::LocalDecl
-                collect_type.call(stmt.type)
-              when IR::BlockStmt
-                stmt.body.each { |s| collect_in_stmt.call(s) }
-              when IR::IfStmt
-                stmt.then_body.each { |s| collect_in_stmt.call(s) }
-                stmt.else_body&.each { |s| collect_in_stmt.call(s) }
-              when IR::WhileStmt
-                stmt.body.each { |s| collect_in_stmt.call(s) }
-              when IR::ForStmt
-                stmt.body.each { |s| collect_in_stmt.call(s) }
-              when IR::SwitchStmt
-                stmt.cases.each { |c| c.body.each { |s| collect_in_stmt.call(s) } }
-              end
-            end
-
-            emitted_aggregate_structs.each { |decl| decl.fields.each { |f| collect_type.call(f.type) } }
-            emitted_aggregate_unions.each { |decl| decl.fields.each { |f| collect_type.call(f.type) } }
-            emitted_aggregate_variants.each do |decl|
-              decl.arms.each { |arm| arm.fields.each { |f| collect_type.call(f.type) } }
-            end
-            emitted_constants.each { |c| collect_type.call(c.type) }
-            emitted_globals.each { |g| collect_type.call(g.type) }
-            emitted_functions.each do |f|
-              collect_type.call(f.return_type)
-              f.params.each { |p| collect_type.call(p.type) }
-              f.body.each { |s| collect_in_stmt.call(s) }
-            end
-
-            opt_types
+        when Types::Function
+          type.params.each do |param|
+            collect_span_type(param.type, span_types, visited)
           end
-
-          def collect_str_literals
-            literals = {}
-            emitted_functions.each do |func|
-              collect_str_literals_from_statements(func.body, literals)
-            end
-            emitted_globals.each do |global|
-              collect_str_literals_from_expression(global.value, literals)
-            end
-            emitted_constants.each do |constant|
-              collect_str_literals_from_expression(constant.value, literals)
-            end
-            literals.keys.sort_by { |k| [k.bytesize, k] }
-          end
-
-          def collect_str_literals_from_statements(statements, literals)
-            statements.each do |stmt|
-              case stmt
-              when IR::LocalDecl
-                collect_str_literals_from_expression(stmt.value, literals) if stmt.value
-              when IR::Assignment
-                collect_str_literals_from_expression(stmt.target, literals)
-                collect_str_literals_from_expression(stmt.value, literals)
-              when IR::BlockStmt
-                collect_str_literals_from_statements(stmt.body, literals)
-              when IR::WhileStmt
-                collect_str_literals_from_expression(stmt.condition, literals)
-                collect_str_literals_from_statements(stmt.body, literals)
-              when IR::ForStmt
-                collect_str_literals_from_statements([stmt.init], literals)
-                collect_str_literals_from_expression(stmt.condition, literals)
-                collect_str_literals_from_statements(stmt.body, literals)
-                collect_str_literals_from_statements([stmt.post], literals)
-              when IR::IfStmt
-                collect_str_literals_from_expression(stmt.condition, literals)
-                collect_str_literals_from_statements(stmt.then_body, literals)
-                collect_str_literals_from_statements(stmt.else_body, literals) if stmt.else_body
-              when IR::SwitchStmt
-                collect_str_literals_from_expression(stmt.expression, literals)
-                stmt.cases.each { |c| collect_str_literals_from_statements(c.body, literals) }
-              when IR::ReturnStmt
-                collect_str_literals_from_expression(stmt.value, literals) if stmt.value
-              when IR::ExpressionStmt
-                collect_str_literals_from_expression(stmt.expression, literals)
-              when IR::StaticAssert
-                collect_str_literals_from_expression(stmt.condition, literals)
-                collect_str_literals_from_expression(stmt.message, literals)
-              end
+          collect_span_type(type.return_type, span_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_span_type(field_type, span_types, visited)
+          end
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
+              collect_span_type(field_type, span_types, visited)
             end
           end
-
-          def collect_str_literals_from_expression(expr, literals)
-            return unless expr
-
-            case expr
-            when IR::StringLiteral
-              literals[expr.value] = true if expr.type.is_a?(Types::StringView)
-            when IR::Member
-              collect_str_literals_from_expression(expr.receiver, literals)
-            when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
-              collect_str_literals_from_expression(expr.receiver, literals)
-              collect_str_literals_from_expression(expr.index, literals)
-            when IR::Call
-              collect_str_literals_from_expression(expr.callee, literals) unless expr.callee.is_a?(String)
-              expr.arguments.each { |arg| collect_str_literals_from_expression(arg, literals) }
-            when IR::Unary
-              collect_str_literals_from_expression(expr.operand, literals)
-            when IR::Binary
-              collect_str_literals_from_expression(expr.left, literals)
-              collect_str_literals_from_expression(expr.right, literals)
-            when IR::Conditional
-              collect_str_literals_from_expression(expr.condition, literals)
-              collect_str_literals_from_expression(expr.then_expression, literals)
-              collect_str_literals_from_expression(expr.else_expression, literals)
-            when IR::ReinterpretExpr
-              collect_str_literals_from_expression(expr.expression, literals)
-            when IR::AddressOf
-              collect_str_literals_from_expression(expr.expression, literals)
-            when IR::Cast
-              collect_str_literals_from_expression(expr.expression, literals)
-            when IR::AggregateLiteral
-              expr.fields.each { |f| collect_str_literals_from_expression(f.value, literals) }
-            when IR::ArrayLiteral
-              expr.elements.each { |e| collect_str_literals_from_expression(e, literals) }
-            when IR::VariantLiteral
-              expr.fields.each { |f| collect_str_literals_from_expression(f.value, literals) }
+        end
+      end
+
+      def collect_dyn_decls
+        void_ptr = Types::Registry.generic_instance("ptr", [Types::Registry.primitive("void")])
+        collect_dyn_types.map do |type|
+          IR::StructDecl.new(
+            name: type.to_s,
+            linkage_name: dyn_type_name(type),
+            fields: [
+              IR::Field.new(name: "data", type: void_ptr),
+              IR::Field.new(name: "vtable", type: void_ptr),
+            ],
+            packed: false,
+            alignment: nil,
+          )
+        end
+      end
+
+      def collect_dyn_types
+        dyn_types = []
+        seen = []
+
+        collect_type = lambda do |type|
+          return unless type
+          case type
+          when Types::Dyn
+            name = type.interface_binding.name
+            unless seen.include?(name)
+              seen << name
+              dyn_types << type
+            end
+          when Types::Nullable
+            collect_type.call(type.base)
+          when Types::GenericInstance
+            type.arguments.each { |arg| collect_type.call(arg) unless arg.is_a?(Types::LiteralTypeArg) }
+          when Types::Span
+            collect_type.call(type.element_type)
+          when Types::Task
+            collect_type.call(type.result_type)
+          when Types::Function
+            type.params.each { |p| collect_type.call(p.type) }
+            collect_type.call(type.return_type)
+          when Types::Proc
+            type.params.each { |p| collect_type.call(p.type) }
+            collect_type.call(type.return_type)
+          when Types::StructInstance
+            type.arguments.each { |arg| collect_type.call(arg) }
+          when Types::VariantInstance
+            type.arguments.each { |arg| collect_type.call(arg) }
+          end
+        end
+
+        collect_in_stmt = lambda do |stmt|
+          case stmt
+          when IR::LocalDecl
+            collect_type.call(stmt.type)
+          when IR::BlockStmt
+            stmt.body.each { |s| collect_in_stmt.call(s) }
+          when IR::IfStmt
+            stmt.then_body.each { |s| collect_in_stmt.call(s) }
+            stmt.else_body&.each { |s| collect_in_stmt.call(s) }
+          when IR::WhileStmt
+            stmt.body.each { |s| collect_in_stmt.call(s) }
+          when IR::ForStmt
+            stmt.body.each { |s| collect_in_stmt.call(s) }
+          when IR::SwitchStmt
+            stmt.cases.each { |c| c.body.each { |s| collect_in_stmt.call(s) } }
+          end
+        end
+
+        if @program
+          @program.constants.each { |c| collect_type.call(c.type) }
+          @program.globals.each { |g| collect_type.call(g.type) }
+          @program.structs.each { |s| s.fields.each { |f| collect_type.call(f.type) } }
+          @program.unions.each { |u| u.fields.each { |f| collect_type.call(f.type) } }
+          @program.functions.each do |f|
+            collect_type.call(f.return_type)
+            f.params.each { |p| collect_type.call(p.type) }
+            body = f.body
+            if body.is_a?(IR::BlockStmt)
+              body.body.each { |s| collect_in_stmt.call(s) }
+            elsif body.is_a?(Array)
+              body.each { |s| collect_in_stmt.call(s) }
             end
           end
+        end
+
+        dyn_types
+      end
+
+      def collect_nullable_opt_decls
+        collect_nullable_opt_types.map do |type|
+          IR::StructDecl.new(
+            name: type.to_s,
+            linkage_name: nullable_opt_type_name(type),
+            fields: [
+              IR::Field.new(name: "has_value", type: Types::Registry.primitive("bool")),
+              IR::Field.new(name: "value", type: type.base),
+            ],
+            packed: false,
+            alignment: nil,
+          )
+        end
+      end
+
+      def collect_nullable_opt_types
+        opt_types = []
+        seen = {}
+
+        collect_type = lambda do |type|
+          return unless type
+
+          case type
+          when Types::Nullable
+            unless c_backend_pointer_like_type?(type.base)
+              name = nullable_opt_type_name(type)
+              unless seen[name]
+                seen[name] = true
+                opt_types << type
+              end
+            end
+            collect_type.call(type.base)
+          when Types::GenericInstance
+            type.arguments.each { |arg| collect_type.call(arg) unless arg.is_a?(Types::LiteralTypeArg) }
+          when Types::Span
+            collect_type.call(type.element_type)
+          when Types::Task
+            collect_type.call(type.result_type)
+          when Types::Function, Types::Proc
+            type.params.each { |p| collect_type.call(p.type) }
+            collect_type.call(type.return_type)
+          when Types::StructInstance, Types::VariantInstance
+            type.arguments.each { |arg| collect_type.call(arg) }
+          end
+        end
+
+        collect_in_stmt = lambda do |stmt|
+          case stmt
+          when IR::LocalDecl
+            collect_type.call(stmt.type)
+          when IR::BlockStmt
+            stmt.body.each { |s| collect_in_stmt.call(s) }
+          when IR::IfStmt
+            stmt.then_body.each { |s| collect_in_stmt.call(s) }
+            stmt.else_body&.each { |s| collect_in_stmt.call(s) }
+          when IR::WhileStmt
+            stmt.body.each { |s| collect_in_stmt.call(s) }
+          when IR::ForStmt
+            stmt.body.each { |s| collect_in_stmt.call(s) }
+          when IR::SwitchStmt
+            stmt.cases.each { |c| c.body.each { |s| collect_in_stmt.call(s) } }
+          end
+        end
+
+        emitted_aggregate_structs.each { |decl| decl.fields.each { |f| collect_type.call(f.type) } }
+        emitted_aggregate_unions.each { |decl| decl.fields.each { |f| collect_type.call(f.type) } }
+        emitted_aggregate_variants.each do |decl|
+          decl.arms.each { |arm| arm.fields.each { |f| collect_type.call(f.type) } }
+        end
+        emitted_constants.each { |c| collect_type.call(c.type) }
+        emitted_globals.each { |g| collect_type.call(g.type) }
+        emitted_functions.each do |f|
+          collect_type.call(f.return_type)
+          f.params.each { |p| collect_type.call(p.type) }
+          f.body.each { |s| collect_in_stmt.call(s) }
+        end
+
+        opt_types
+      end
+
+      def collect_str_literals
+        literals = {}
+        emitted_functions.each do |func|
+          collect_str_literals_from_statements(func.body, literals)
+        end
+        emitted_globals.each do |global|
+          collect_str_literals_from_expression(global.value, literals)
+        end
+        emitted_constants.each do |constant|
+          collect_str_literals_from_expression(constant.value, literals)
+        end
+        literals.keys.sort_by { |k| [k.bytesize, k] }
+      end
+
+      def collect_str_literals_from_statements(statements, literals)
+        statements.each do |stmt|
+          case stmt
+          when IR::LocalDecl
+            collect_str_literals_from_expression(stmt.value, literals) if stmt.value
+          when IR::Assignment
+            collect_str_literals_from_expression(stmt.target, literals)
+            collect_str_literals_from_expression(stmt.value, literals)
+          when IR::BlockStmt
+            collect_str_literals_from_statements(stmt.body, literals)
+          when IR::WhileStmt
+            collect_str_literals_from_expression(stmt.condition, literals)
+            collect_str_literals_from_statements(stmt.body, literals)
+          when IR::ForStmt
+            collect_str_literals_from_statements([stmt.init], literals)
+            collect_str_literals_from_expression(stmt.condition, literals)
+            collect_str_literals_from_statements(stmt.body, literals)
+            collect_str_literals_from_statements([stmt.post], literals)
+          when IR::IfStmt
+            collect_str_literals_from_expression(stmt.condition, literals)
+            collect_str_literals_from_statements(stmt.then_body, literals)
+            collect_str_literals_from_statements(stmt.else_body, literals) if stmt.else_body
+          when IR::SwitchStmt
+            collect_str_literals_from_expression(stmt.expression, literals)
+            stmt.cases.each { |c| collect_str_literals_from_statements(c.body, literals) }
+          when IR::ReturnStmt
+            collect_str_literals_from_expression(stmt.value, literals) if stmt.value
+          when IR::ExpressionStmt
+            collect_str_literals_from_expression(stmt.expression, literals)
+          when IR::StaticAssert
+            collect_str_literals_from_expression(stmt.condition, literals)
+            collect_str_literals_from_expression(stmt.message, literals)
+          end
+        end
+      end
+
+      def collect_str_literals_from_expression(expr, literals)
+        return unless expr
+
+        case expr
+        when IR::StringLiteral
+          literals[expr.value] = true if expr.type.is_a?(Types::StringView)
+        when IR::Member
+          collect_str_literals_from_expression(expr.receiver, literals)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_str_literals_from_expression(expr.receiver, literals)
+          collect_str_literals_from_expression(expr.index, literals)
+        when IR::Call
+          collect_str_literals_from_expression(expr.callee, literals) unless expr.callee.is_a?(String)
+          expr.arguments.each { |arg| collect_str_literals_from_expression(arg, literals) }
+        when IR::Unary
+          collect_str_literals_from_expression(expr.operand, literals)
+        when IR::Binary
+          collect_str_literals_from_expression(expr.left, literals)
+          collect_str_literals_from_expression(expr.right, literals)
+        when IR::Conditional
+          collect_str_literals_from_expression(expr.condition, literals)
+          collect_str_literals_from_expression(expr.then_expression, literals)
+          collect_str_literals_from_expression(expr.else_expression, literals)
+        when IR::ReinterpretExpr
+          collect_str_literals_from_expression(expr.expression, literals)
+        when IR::AddressOf
+          collect_str_literals_from_expression(expr.expression, literals)
+        when IR::Cast
+          collect_str_literals_from_expression(expr.expression, literals)
+        when IR::AggregateLiteral
+          expr.fields.each { |f| collect_str_literals_from_expression(f.value, literals) }
+        when IR::ArrayLiteral
+          expr.elements.each { |e| collect_str_literals_from_expression(e, literals) }
+        when IR::VariantLiteral
+          expr.fields.each { |f| collect_str_literals_from_expression(f.value, literals) }
+        end
+      end
     end
   end
 end