mt-lang 0.3.16 → 0.3.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5cd3c1ef5e380b8d0c5d4e20f829400d01c6fdfd3e495e8c98050f4af8b59ba
-  data.tar.gz: 0e083d1780c9d591b996604a8b489726fa0f0c6fb85b8dc03da87b681383d5ca
+  metadata.gz: 83f7a9e4ec79d81bd7d2e64ebb469871fecb5e4b3f888c932061d5fa265b7544
+  data.tar.gz: c08d508785143d338a6a47adfcedcf605b30e8e9990913a44178344643944178
 SHA512:
-  metadata.gz: 44f866e7d6bf6fc4998e0a9054bf898b27ed47ef38149de1881baf1d810e845b94e3d1f3ff304486654ea339329d726a10d969bcff4021943cc98b03bfe3fe01
-  data.tar.gz: 0fa7237c14aa9e038b4d51ae08a5971430d0e47b97fb19caf619aeb80a5e562de99aae1cf342a11ffea41e3b2268a128454bbf022b3e9182ddd94ff2ff0aff45
+  metadata.gz: 95818de5161127d240aacd92b2f8a727e29d1962c11bd9161faa0f0286ac701d2b328352d7ac51bdab23ed2b76a8ccaa7e698490c4bbe5b99edb9452de76cbac
+  data.tar.gz: 0d188ebbabd4f175a201ea61c7cde3393a93b9deed991fbb639935b125e565b3b679f16c0fb72c4f96939475d8b6a199362e66920d65e49dd60e6dbc248df372

data/docs/language-design.md

@@ -521,7 +521,6 @@ The type system must stay simple, explicit, and close to C.
 ### Primitive types
 
 - `bool`
-- `byte`
 - `char`
 - `byte`, `short`, `int`, `long`
 - `ubyte`, `ushort`, `uint`, `ulong`
@@ -587,7 +586,7 @@ Notes:
 - If low-level code needs to validate raw `array[char, N]` storage as text, that conversion belongs in an explicit helper or imported boundary, not as a built-in method family on raw arrays.
 - Addressable `str_buffer[N]` values also coerce to `span[char]`, so writable foreign text APIs can still accept builders directly when they do not want a second application-facing text abstraction.
 - `str_buffer[N]` is not an ABI type. Raw bindings still spell writable text as `ptr[char]` or `span[char]`; `str_buffer[N]` is the caller-side text object.
-- `str_buffer[N]` has a built-in text surface: `.clear()`, `.assign(str)`, `.append(str)`, `.len()`, `.capacity()`, `.as_str()`, and `.as_cstr()`.
+- `str_buffer[N]` has a built-in text surface: `.clear()`, `.assign(str)`, `.append(str)`, `.assign_format(str)`, `.append_format(str)`, `.len()`, `.capacity()`, `.as_str()`, and `.as_cstr()`.
 - `.assign(...)` replaces the current contents and traps at runtime if the new text exceeds capacity.
 - `.append(...)` extends the current contents and traps at runtime if the appended text would exceed capacity.
 - `.len()` returns the tracked text length, revalidating UTF-8 and rescanning for the trailing NUL if the builder was passed through a writable `span[char]` or `ptr[char]` alias.
@@ -650,7 +649,7 @@ joins the path with underscores (e.g., `module_Rectangle_Edge`).
 
 #### Enums
 
-Enums always have an explicit backing type.
+Enums use an integer backing type, defaulting to `int` when omitted; members auto-increment from 0 or the previous explicit value.
 
 ```mt
 enum WeaponKind: ubyte
@@ -661,7 +660,7 @@ enum WeaponKind: ubyte
 
 #### Flags
 
-Flags are named bitmasks with a fixed integer backing type.
+Flags are named bitmasks with an integer backing type (defaulting to `int` when omitted).
 
 ```mt
 flags WindowFlags: uint

data/docs/language-manual.md

@@ -1007,7 +1007,7 @@ Rules:
 - `ivec2` `ivec3` `ivec4` — integer vectors with `.x` `.y` `.z` `.w` fields
 - `mat3` `mat4` — column-major matrices; `mat3` has columns `.col0`–`.col2` (each `vec3`), `mat4` has `.col0`–`.col3` (each `vec4`)
 - `quat` — quaternion with `.x` `.y` `.z` `.w` fields; memory-layout compatible with `vec4`
-- `simd[T, N]` — SIMD vector with `N` lanes of numeric primitive type `T`; total width must be 128 or 256 bits. Supports component-wise arithmetic (`+` `-` `*` `/`), bitwise (`&` `|` `^` `~`), shift (`<<` `>>`), and compound assignment. Lane access via compile-time constant index `[i]`. Lowers to GCC/Clang `__attribute__((__vector_size__))`.
+- `simd[T, N]` — SIMD vector with `N` lanes of numeric primitive type `T`; total width must be 128 or 256 bits. Supports component-wise arithmetic (`+` `-` `*` `/`, and `%` for integer lanes), bitwise (`&` `|` `^` `~`), shift (`<<` `>>`), and compound assignment. Lane access via compile-time constant index `[i]`. Lowers to GCC/Clang `__attribute__((__vector_size__))`.
 
 Primitive type names are reserved. They cannot be reused for value bindings, parameters, locals, import aliases, or type parameters.
 
@@ -1043,7 +1043,7 @@ let q = quat(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
 - `Option[T]`
 - `Result[T, E]`
 - `SoA[T, N]` — Structure-of-Arrays: transforms `T`'s fields into separate arrays of length `N`; access as `soa[i].field`
-- `simd[T, N]` — SIMD vector: fixed-width vector of `N` numeric lanes. Constructed with `simd[T, N](lane0, lane1, ...)`. Supports component-wise `+` `-` `*` `/`, bitwise `&` `|` `^` `~`, shift `<<` `>>`, unary `-` `~`, and compound assignment. Lane access via compile-time constant `[i]`. Total width must be 128 or 256 bits. Lowers to GCC/Clang vector extensions.
+- `simd[T, N]` — SIMD vector: fixed-width vector of `N` numeric lanes. Constructed with `simd[T, N](lane0, lane1, ...)`. Supports component-wise `+` `-` `*` `/` (and `%` for integer lanes), bitwise `&` `|` `^` `~`, shift `<<` `>>`, unary `-` `~`, and compound assignment. Lane access via compile-time constant `[i]`. Total width must be 128 or 256 bits. Lowers to GCC/Clang vector extensions.
 - `dyn[InterfaceName]` — runtime interface value (fat pointer: data + vtable). Constructed via `adapt[Interface](value: ref[T])`. @see §3.5.
 - `atomic[T]` — atomic value for lock-free concurrent access. `T` must be a primitive integer or `bool`. Methods: `load() -> T`, `store(value: T)`, `add(value: T) -> T`, `sub(value: T) -> T`, `exchange(value: T) -> T`. All operations use sequential consistency. Lowers to C11 `_Atomic T` with `__atomic_*` builtins. `atomic[T]` is zero-initializable and sendable.
 - `(T, U)` — tuple type. Positional fields auto-named `_0`, `_1`. Named fields use `(x = T, y = U)`. Copy by value, returns supported.
@@ -1054,7 +1054,7 @@ let q = quat(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
 - for pointer-like bases (`ptr[T]`, `const_ptr[T]`, `own[T]`, `cstr`, `fn(...)`, `proc(...)`, opaque), `T?` is a nullable pointer with `null` as the absent value
 - for non-pointer value bases (`int`, `bool`, `float`, structs, ...), `T?` is stored inline by value as a tagged optional (a presence flag plus the value); it copies by value with no hidden heap allocation or pointer aliasing
 - `null` expresses absence in any nullable context; the explicit typed `null[...]` form's target must be pointer-like
-- in nullable pointer-like contexts, use `null` instead of `zero[ptr[T]]`
+- in nullable pointer-like contexts, `zero[ptr[T]]` is rejected; use `null` instead
 - at an FFI boundary (`external` / `foreign function` parameters and returns), only pointer-like `T?` is allowed; a non-pointer value nullable such as `int?` is rejected — use `ptr[T]?` or pass an explicit struct
 
 ### 6.4 Generics

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.16"
+  VERSION = "0.3.20"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/{binding_types.rb → bindings.rb}

@@ -15,4 +15,4 @@ module MilkTea
     def each(&block) = @bindings.each(&block)
     def each_with_object(init, &block) = @bindings.each_with_object(init, &block)
   end
-end
+end

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

@@ -331,11 +331,10 @@ module MilkTea
       end
 
       def emit_cast_operand(expression)
-        case expression
-        when IR::Name, IR::IntegerLiteral, IR::FloatLiteral, IR::StringLiteral, IR::BooleanLiteral, IR::NullLiteral, IR::ZeroInit, IR::Member, IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex, IR::Call, IR::AggregateLiteral, IR::ArrayLiteral, IR::ReinterpretExpr, IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr, IR::AddressOf, IR::Cast, IR::Unary
-          emit_expression(expression)
-        else
+        if expression.is_a?(IR::Binary) || expression.is_a?(IR::Conditional)
           "(#{emit_expression(expression)})"
+        else
+          emit_expression(expression)
         end
       end
 
@@ -425,28 +424,16 @@ module MilkTea
 
       def emit_variant_field_initializer(type, arm_name, field)
         field_type = type.arm(arm_name).fetch(field.name)
+        outer_c = named_type_c_name(type)
+
         if field_type.is_a?(Types::Nullable) && !field.value.type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(field_type.base)
           emit_nullable_some_initializer(field_type, field.value)
         elsif field.value.is_a?(IR::AddressOf) && !field_type.is_a?(Types::Nullable)
-          c_type_name = named_type_c_name(field_type)
-          inner = field.value.expression
-          "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
-        elsif aggregate_field_creates_cycle?(field_type, named_type_c_name(type)) &&
-              array_type?(field_type)
-          elem_c_name = c_type(array_element_type(field_type))
-          elem_count = array_length(field_type)
-          elements = field.value.is_a?(IR::ArrayLiteral) ? field.value.elements.map { |e| emit_initializer(e) }.join(", ") : ""
-          "((#{elem_c_name}*)memcpy(malloc(#{elem_count} * sizeof(#{elem_c_name})), &(#{elem_c_name}[#{elem_count}]){ #{elements} }, #{elem_count} * sizeof(#{elem_c_name})))"
-        elsif aggregate_field_creates_cycle?(field_type, named_type_c_name(type)) &&
-              !field_type.is_a?(Types::GenericInstance)
-          field_c_name = named_type_c_name(field_type)
-          init = emit_initializer(field.value)
-          source_expr = if init.start_with?("{")
-            "&(#{c_type(field_type)})#{init}"
-          else
-            "&(#{init})"
-          end
-          "((#{field_c_name}*)memcpy(malloc(sizeof(#{field_c_name})), #{source_expr}, sizeof(#{field_c_name})))"
+          emit_addressof_field_initializer(field_type, field.value)
+        elsif aggregate_field_creates_cycle?(field_type, outer_c) && array_type?(field_type)
+          emit_cyclic_array_initializer(field_type, field.value)
+        elsif aggregate_field_creates_cycle?(field_type, outer_c) && !field_type.is_a?(Types::GenericInstance)
+          emit_cyclic_struct_initializer(field_type, field.value)
         elsif void_storage_field?(field_type)
           emit_void_field_initializer(field.value)
         else
@@ -454,6 +441,30 @@ module MilkTea
         end
       end
 
+      def emit_addressof_field_initializer(field_type, value)
+        c_type_name = named_type_c_name(field_type)
+        inner = value.expression
+        "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
+      end
+
+      def emit_cyclic_array_initializer(field_type, value)
+        elem_c_name = c_type(array_element_type(field_type))
+        elem_count = array_length(field_type)
+        elements = value.is_a?(IR::ArrayLiteral) ? value.elements.map { |e| emit_initializer(e) }.join(", ") : ""
+        "((#{elem_c_name}*)memcpy(malloc(#{elem_count} * sizeof(#{elem_c_name})), &(#{elem_c_name}[#{elem_count}]){ #{elements} }, #{elem_count} * sizeof(#{elem_c_name})))"
+      end
+
+      def emit_cyclic_struct_initializer(field_type, value)
+        field_c_name = named_type_c_name(field_type)
+        init = emit_initializer(value)
+        source_expr = if init.start_with?("{")
+          "&(#{c_type(field_type)})#{init}"
+        else
+          "&(#{init})"
+        end
+        "((#{field_c_name}*)memcpy(malloc(sizeof(#{field_c_name})), #{source_expr}, sizeof(#{field_c_name})))"
+      end
+
       def emit_void_field_initializer(expression)
         "(#{emit_expression(expression)}, 0)"
       end

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

@@ -342,66 +342,46 @@ module MilkTea
         function.body.any? { |statement| statement_uses_str_equality?(statement) }
       end
 
-      def statement_uses_named_call?(statement, callees)
+      def any_ir_statement?(statement, expression_pred:, **kwargs)
         case statement
         when IR::LocalDecl
-          expression_uses_named_call?(statement.value, callees)
+          statement.value && expression_pred.call(statement.value, **kwargs)
         when IR::Assignment
-          expression_uses_named_call?(statement.target, callees) || expression_uses_named_call?(statement.value, callees)
+          expression_pred.call(statement.target, **kwargs) || expression_pred.call(statement.value, **kwargs)
         when IR::BlockStmt
-          statement.body.any? { |inner| statement_uses_named_call?(inner, callees) }
+          statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) }
         when IR::WhileStmt
-          expression_uses_named_call?(statement.condition, callees) || statement.body.any? { |inner| statement_uses_named_call?(inner, callees) }
+          expression_pred.call(statement.condition, **kwargs) ||
+            statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) }
         when IR::ForStmt
-          statement_uses_named_call?(statement.init, callees) ||
-            expression_uses_named_call?(statement.condition, callees) ||
-            statement.body.any? { |inner| statement_uses_named_call?(inner, callees) } ||
-            statement_uses_named_call?(statement.post, callees)
+          any_ir_statement?(statement.init, expression_pred:, **kwargs) ||
+            expression_pred.call(statement.condition, **kwargs) ||
+            statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } ||
+            any_ir_statement?(statement.post, expression_pred:, **kwargs)
         when IR::IfStmt
-          expression_uses_named_call?(statement.condition, callees) ||
-            statement.then_body.any? { |inner| statement_uses_named_call?(inner, callees) } ||
-            (statement.else_body && statement.else_body.any? { |inner| statement_uses_named_call?(inner, callees) })
+          expression_pred.call(statement.condition, **kwargs) ||
+            statement.then_body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } ||
+            (statement.else_body && statement.else_body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) })
         when IR::SwitchStmt
-          expression_uses_named_call?(statement.expression, callees) || statement.cases.any? { |switch_case| switch_case.body.any? { |inner| statement_uses_named_call?(inner, callees) } }
+          expression_pred.call(statement.expression, **kwargs) ||
+            statement.cases.any? { |switch_case| switch_case.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } }
         when IR::StaticAssert
-          expression_uses_named_call?(statement.condition, callees) || expression_uses_named_call?(statement.message, callees)
+          expression_pred.call(statement.condition, **kwargs) || expression_pred.call(statement.message, **kwargs)
         when IR::ReturnStmt
-          statement.value && expression_uses_named_call?(statement.value, callees)
+          statement.value && expression_pred.call(statement.value, **kwargs)
         when IR::ExpressionStmt
-          expression_uses_named_call?(statement.expression, callees)
+          expression_pred.call(statement.expression, **kwargs)
+        else
+          false
         end
       end
 
+      def statement_uses_named_call?(statement, callees)
+        any_ir_statement?(statement, expression_pred: ->(e) { expression_uses_named_call?(e, callees) })
+      end
+
       def statement_uses_str_equality?(statement)
-        case statement
-        when IR::LocalDecl
-          expression_uses_str_equality?(statement.value)
-        when IR::Assignment
-          expression_uses_str_equality?(statement.target) || expression_uses_str_equality?(statement.value)
-        when IR::BlockStmt
-          statement.body.any? { |inner| statement_uses_str_equality?(inner) }
-        when IR::WhileStmt
-          expression_uses_str_equality?(statement.condition) || statement.body.any? { |inner| statement_uses_str_equality?(inner) }
-        when IR::ForStmt
-          statement_uses_str_equality?(statement.init) ||
-            expression_uses_str_equality?(statement.condition) ||
-            statement.body.any? { |inner| statement_uses_str_equality?(inner) } ||
-            statement_uses_str_equality?(statement.post)
-        when IR::IfStmt
-          expression_uses_str_equality?(statement.condition) ||
-            statement.then_body.any? { |inner| statement_uses_str_equality?(inner) } ||
-            (statement.else_body && statement.else_body.any? { |inner| statement_uses_str_equality?(inner) })
-        when IR::SwitchStmt
-          expression_uses_str_equality?(statement.expression) || statement.cases.any? { |switch_case| switch_case.body.any? { |inner| statement_uses_str_equality?(inner) } }
-        when IR::StaticAssert
-          expression_uses_str_equality?(statement.condition) || expression_uses_str_equality?(statement.message)
-        when IR::ReturnStmt
-          statement.value && expression_uses_str_equality?(statement.value)
-        when IR::ExpressionStmt
-          expression_uses_str_equality?(statement.expression)
-        else
-          false
-        end
+        any_ir_statement?(statement, expression_pred: ->(e) { expression_uses_str_equality?(e) })
       end
 
       def expression_uses_named_call?(expression, callees)

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

@@ -241,21 +241,15 @@ module MilkTea
       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
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_soa_type,
+          expression_walker_method: :collect_soa_type_in_expression,
+          accumulator: soa_types, visited:)
+      end
+
+      def collect_soa_type_in_expression(expression, soa_types, visited)
+        return unless expression.respond_to?(:type)
+        collect_soa_type(expression.type, soa_types, visited)
       end
 
       def collect_soa_type(type, soa_types, visited)
@@ -290,21 +284,15 @@ module MilkTea
       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
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_simd_type,
+          expression_walker_method: :collect_simd_type_in_expression,
+          accumulator: simd_types, visited:)
+      end
+
+      def collect_simd_type_in_expression(expression, simd_types, visited)
+        return unless expression.respond_to?(:type)
+        collect_simd_type(expression.type, simd_types, visited)
       end
 
       def collect_simd_type(type, simd_types, visited)

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

@@ -61,12 +61,6 @@ module MilkTea
         lines
       end
 
-      def variant_self_reference?(type, outer_c)
-        return false unless type.is_a?(Types::Variant) || type.is_a?(Types::VariantInstance)
-
-        named_type_c_name(type) == outer_c
-      end
-
       def emit_variant(variant_decl)
         lines = []
         outer_c = variant_decl.linkage_name

data/lib/milk_tea/core/c_backend.rb

@@ -38,6 +38,20 @@ module MilkTea
     # scanning a 600 KB source file) never trigger a false positive, yet low
     # enough that a genuinely infinite loop fires a clear fatal within ~1 s.
     LOOP_GUARD_MAX_ITERATIONS = 50_000_000
+    EQUALITY_OPERATORS = ["==", "!="].freeze
+
+    include AggregateUtils
+    include TypeSystem
+    include Reachability
+    include FeatureDetection
+    include TypeCollectors
+    include Statements
+    include ControlFlowEmission
+    include RuntimeHelpers
+    include FormatHelpers
+    include TypeDeclaration
+    include Expressions
+    include Reinterpret
 
     def self.emit(program, emit_line_directives: true, debug_guards: false)
       new(program, emit_line_directives:, debug_guards:).emit
@@ -61,11 +75,27 @@ module MilkTea
 
     def emit
       lines = []
+      @cyclic_aggregate_pairs = build_cyclic_aggregate_pairs(
+        emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls +
+        emitted_aggregate_unions +
+        emitted_aggregate_variants + collect_generic_variant_decls
+      )
+
       constants = emitted_constants
-      all_struct_decls = emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls
-      all_variant_decls = emitted_aggregate_variants + collect_generic_variant_decls
-      all_decls_for_cycle = all_struct_decls + emitted_aggregate_unions + all_variant_decls
-      @cyclic_aggregate_pairs = build_cyclic_aggregate_pairs(all_decls_for_cycle)
+
+      emit_preamble(lines)
+      emit_conditional_helpers(lines)
+      emit_type_declarations(lines)
+      emit_function_forward_declarations(lines)
+      emit_globals_and_constants(lines, constants)
+      emit_per_type_helpers(lines)
+      emit_string_literal_constants_section(lines)
+      emit_function_definitions(lines)
+
+      lines.join("\n").rstrip + "\n"
+    end
+
+    def emit_preamble(lines)
       headers = @program.includes.map(&:header)
       if headers.include?("\"fs_support.h\"") || headers.include?("\"tls_support.h\"") || uses_parallel_for_helper? || uses_spawn_all_helper? || uses_detach_helper?
         lines << "#ifndef _GNU_SOURCE"
@@ -89,70 +119,61 @@ module MilkTea
         lines << "#include #{header}"
       end
       lines << ""
+    end
 
+    def emit_conditional_helpers(lines)
       if uses_string_view?
         lines.concat(emit_string_type)
         lines << ""
       end
-
       if uses_vector_math_types?
         lines.concat(emit_vector_math_types)
         lines << ""
       end
-
       if uses_fatal_helper?
         lines.concat(emit_fatal_helper)
         lines << ""
       end
-
       if uses_format_helpers?
         lines.concat(emit_format_helpers)
         lines << ""
       end
-
       if uses_fmt_builder?
         lines.concat(emit_fmt_builder_helpers)
         lines << ""
       end
-
       if uses_str_equality_helper?
         lines.concat(emit_str_equality_helper)
         lines << ""
       end
-
       if uses_text_buffer_helpers?
         lines.concat(emit_text_buffer_helpers)
         lines << ""
       end
-
       if uses_async_memory_helpers?
         lines.concat(emit_async_memory_helpers)
         lines << ""
       end
-
       if uses_parallel_for_helper?
         lines.concat(emit_parallel_for_helper)
         lines << ""
       end
-
       if uses_spawn_all_helper?
         lines.concat(emit_spawn_all_helper)
         lines << ""
       end
-
       if uses_detach_helper?
         lines.concat(emit_detach_helpers)
         lines << ""
       end
+    end
 
-      opaque_decls = @program.opaques
-      aggregate_decls = sort_aggregate_decls(
-        all_struct_decls,
-        emitted_aggregate_unions,
-        all_variant_decls,
-      )
+    def emit_type_declarations(lines)
+      all_struct_decls = emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls
+      all_variant_decls = emitted_aggregate_variants + collect_generic_variant_decls
+      aggregate_decls = sort_aggregate_decls(all_struct_decls, emitted_aggregate_unions, all_variant_decls)
 
-      forward_declarations = emit_forward_declarations(opaque_decls, aggregate_decls)
+      forward_declarations = emit_forward_declarations(@program.opaques, aggregate_decls)
       unless forward_declarations.empty?
         lines.concat(forward_declarations)
         lines << ""
@@ -222,13 +243,17 @@ module MilkTea
         lines.concat(emit_variant_equality_helpers)
         lines << ""
       end
+    end
 
+    def emit_function_forward_declarations(lines)
       function_declarations = emit_function_declarations(emitted_functions)
       unless function_declarations.empty?
         lines.concat(function_declarations)
         lines << ""
       end
+    end
 
+    def emit_globals_and_constants(lines, constants)
       constants.each do |constant|
         @current_line = constant.line if constant.line
         @source_path ||= constant.path if constant.path
@@ -248,66 +273,50 @@ module MilkTea
         lines << emit_static_assert(statement)
       end
       lines << "" unless @program.static_asserts.empty?
+    end
 
-      reinterpret_helpers = collect_reinterpret_helpers
-      reinterpret_helpers.each do |helper|
+    def emit_per_type_helpers(lines)
+      collect_reinterpret_helpers.each do |helper|
         lines.concat(emit_reinterpret_helper(helper))
         lines << ""
       end
 
-      checked_array_index_types = collect_checked_array_index_types
-      checked_array_index_types.each do |type|
+      collect_checked_array_index_types.each do |type|
         lines.concat(emit_checked_array_index_helper(type))
         lines << ""
       end
 
-      checked_span_index_types = collect_checked_span_index_types
-      checked_span_index_types.each do |type|
+      collect_checked_span_index_types.each do |type|
         lines.concat(emit_checked_span_index_helper(type))
         lines << ""
       end
 
-      nullable_array_index_types = collect_checked_array_index_types(nullable_only: true)
-      nullable_array_index_types.each do |type|
+      collect_checked_array_index_types(nullable_only: true).each do |type|
         lines.concat(emit_nullable_array_index_helper(type))
         lines << ""
       end
 
-      nullable_span_index_types = collect_checked_span_index_types(nullable_only: true)
-      nullable_span_index_types.each do |type|
+      collect_checked_span_index_types(nullable_only: true).each do |type|
         lines.concat(emit_nullable_span_index_helper(type))
         lines << ""
       end
+    end
 
+    def emit_string_literal_constants_section(lines)
       str_literals = collect_str_literals
-      unless str_literals.empty?
-        @str_literal_map = {}
-        str_literals.each_with_index { |value, i| @str_literal_map[value] = str_literal_name(i) }
-        lines.concat(emit_str_literal_constants(str_literals))
-        lines << ""
-      end
+      return if str_literals.empty?
 
+      @str_literal_map = {}
+      str_literals.each_with_index { |value, i| @str_literal_map[value] = str_literal_name(i) }
+      lines.concat(emit_str_literal_constants(str_literals))
+      lines << ""
+    end
+
+    def emit_function_definitions(lines)
       emitted_functions.each do |function|
         lines.concat(emit_function(function))
         lines << ""
       end
-
-      lines.join("\n").rstrip + "\n"
     end
-
-    EQUALITY_OPERATORS = ["==", "!="].freeze
-
-    include AggregateUtils
-    include TypeSystem
-    include Reachability
-    include FeatureDetection
-    include TypeCollectors
-    include Statements
-    include ControlFlowEmission
-    include RuntimeHelpers
-    include FormatHelpers
-    include TypeDeclaration
-    include Expressions
-    include Reinterpret
   end
 end