mt-lang 0.3.24 → 0.3.26

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

@@ -1,2622 +1,2624 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module LowererResolve
-    PASS_THROUGH_BUILTINS = {
-      "fatal"         => :fatal,
-      "ref_of"        => :ref_of,
-      "const_ptr_of"   => :const_ptr_of,
-      "read"          => :read,
-      "ptr_of"        => :ptr_of,
-      "get"           => :get,
-    }.freeze
-
-    COMPILE_TIME_BUILTINS = %w[
-      field_of callable_of has_attribute attribute_of
-    ].freeze
-
-
-    def direct_function_to_proc_contextual_compatibility?(expression, actual_type, env:, expected_type:)
-      return false unless actual_type.is_a?(Types::Function) && proc_type?(expected_type)
-      return false unless direct_function_identity_expression?(expression, env)
-
-      function_type_matches_proc_type?(actual_type, expected_type)
-    end
+  module Lowering
+    module Resolve
+      PASS_THROUGH_BUILTINS = {
+        "fatal"         => :fatal,
+        "ref_of"        => :ref_of,
+        "const_ptr_of"   => :const_ptr_of,
+        "read"          => :read,
+        "ptr_of"        => :ptr_of,
+        "get"           => :get,
+      }.freeze
 
-    def direct_function_identity_expression?(expression, env)
-      case expression
-      when AST::Identifier
-        return false if lookup_value(expression.name, env)
-        return false unless @ctx.functions.key?(expression.name)
-
-        binding = @ctx.functions.fetch(expression.name)
-        !binding.type_params.any? && !foreign_function_binding?(binding)
-      when AST::MemberAccess
-        return false unless expression.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.receiver.name)
-
-        imported_module = @ctx.imports.fetch(expression.receiver.name)
-        return false unless imported_module.functions.key?(expression.member)
-
-        binding = imported_module.functions.fetch(expression.member)
-        !binding.type_params.any? && !foreign_function_binding?(binding)
-      when AST::Specialization
-        callable_resolution = resolve_specialized_callable_binding(expression, env:)
-        return false unless callable_resolution
-
-        callable_kind, binding, = callable_resolution
-        callable_kind == :function && !foreign_function_binding?(binding)
-      else
-        false
+      COMPILE_TIME_BUILTINS = %w[
+        field_of callable_of has_attribute attribute_of
+      ].freeze
+
+
+      def direct_function_to_proc_contextual_compatibility?(expression, actual_type, env:, expected_type:)
+        return false unless actual_type.is_a?(Types::Function) && proc_type?(expected_type)
+        return false unless direct_function_identity_expression?(expression, env)
+
+        function_type_matches_proc_type?(actual_type, expected_type)
       end
-    end
 
-    def lower_direct_function_to_proc_expression(source_expression, source_function, env:, expected_type:)
-      raise LoweringError.new("function-to-proc coercion requires a direct function name", line: 0, column: 0, path: @ctx.current_analysis_path) unless source_function.is_a?(IR::Name)
-
-      proc_id = fresh_proc_symbol
-      invoke_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__invoke"
-      release_linkage_name = "#{@ctx.module_prefix}__proc_#{proc_id}__release"
-      retain_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__retain"
-
-      @artifacts.synthetic_functions << build_direct_function_proc_invoke_function(source_expression, source_function.name, source_function.type, expected_type, invoke_c_name)
-      @artifacts.synthetic_functions << build_proc_noop_release_function(release_linkage_name)
-      @artifacts.synthetic_functions << build_proc_noop_retain_function(retain_c_name)
-
-      IR::AggregateLiteral.new(
-        type: expected_type,
-        fields: [
-          IR::AggregateField.new(name: "env", value: IR::NullLiteral.new(type: proc_env_pointer_type)),
-          IR::AggregateField.new(name: "invoke", value: IR::Name.new(name: invoke_c_name, type: proc_invoke_function_type(expected_type), pointer: false)),
-          IR::AggregateField.new(name: "release", value: IR::Name.new(name: release_linkage_name, type: proc_release_function_type, pointer: false)),
-          IR::AggregateField.new(name: "retain", value: IR::Name.new(name: retain_c_name, type: proc_retain_function_type, pointer: false)),
-        ],
-      )
-    end
+      def direct_function_identity_expression?(expression, env)
+        case expression
+        when AST::Identifier
+          return false if lookup_value(expression.name, env)
+          return false unless @ctx.functions.key?(expression.name)
 
-    def build_direct_function_proc_invoke_function(source_expression, function_c_name, function_type, proc_type, invoke_c_name)
-      env = empty_env
-      params = [IR::Param.new(name: "env", linkage_name: "__mt_proc_env", type: proc_env_pointer_type, pointer: false)]
-      parameter_setup = []
-      call_arguments = []
-
-      proc_type.params.each_with_index do |param, index|
-        linkage_name = c_local_name(param.name || "arg#{index}")
-        if array_type?(param.type)
-          input_linkage_name = "#{linkage_name}_input"
-          params << IR::Param.new(name: param.name || "arg#{index}", linkage_name: input_linkage_name, type: param.type, pointer: false)
-          env[:scopes].last[param.name || "arg#{index}"] = local_binding(type: param.type, linkage_name:, mutable: param.mutable, pointer: false)
-          parameter_setup << IR::LocalDecl.new(
-            name: param.name || "arg#{index}",
-            linkage_name:,
-            type: param.type,
-            value: IR::Name.new(name: input_linkage_name, type: param.type, pointer: false),
-          )
-          call_arguments << IR::Name.new(name: linkage_name, type: param.type, pointer: false)
+          binding = @ctx.functions.fetch(expression.name)
+          !binding.type_params.any? && !foreign_function_binding?(binding)
+        when AST::MemberAccess
+          return false unless expression.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.receiver.name)
+
+          imported_module = @ctx.imports.fetch(expression.receiver.name)
+          return false unless imported_module.functions.key?(expression.member)
+
+          binding = imported_module.functions.fetch(expression.member)
+          !binding.type_params.any? && !foreign_function_binding?(binding)
+        when AST::Specialization
+          callable_resolution = resolve_specialized_callable_binding(expression, env:)
+          return false unless callable_resolution
+
+          callable_kind, binding, = callable_resolution
+          callable_kind == :function && !foreign_function_binding?(binding)
         else
-          env[:scopes].last[param.name || "arg#{index}"] = local_binding(type: param.type, linkage_name:, mutable: param.mutable, pointer: false)
-          params << IR::Param.new(name: param.name || "arg#{index}", linkage_name:, type: param.type, pointer: false)
-          call_arguments << IR::Name.new(name: linkage_name, type: param.type, pointer: false)
+          false
         end
       end
 
-      call = IR::Call.new(callee: function_c_name, arguments: call_arguments, type: proc_type.return_type)
-      body = if proc_type.return_type == @ctx.types.fetch("void")
-                parameter_setup + [IR::ExpressionStmt.new(expression: call), IR::ReturnStmt.new(value: nil)]
-              else
-                parameter_setup + [IR::ReturnStmt.new(value: call)]
-              end
+      def lower_fn_to_proc_expression(source_expression, source_function, env:, expected_type:)
+        raise LoweringError.new("function-to-proc coercion requires a direct function name", line: 0, column: 0, path: @ctx.current_analysis_path) unless source_function.is_a?(IR::Name)
 
-      IR::Function.new(name: invoke_c_name, linkage_name: invoke_c_name, params:, return_type: proc_type.return_type, body:, entry_point: false)
-    end
+        proc_id = fresh_proc_symbol
+        invoke_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__invoke"
+        release_linkage_name = "#{@ctx.module_prefix}__proc_#{proc_id}__release"
+        retain_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__retain"
 
-    def lower_array_to_span_expression(expression, target_type)
-      array_type = expression.type
-      array_type = referenced_type(array_type) if ref_type?(array_type)
-
-      IR::AggregateLiteral.new(
-        type: target_type,
-        fields: [
-          IR::AggregateField.new(
-            name: "data",
-            value: IR::AddressOf.new(
-              expression: IR::Index.new(
-                receiver: expression,
-                index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
-                type: target_type.element_type,
+        @artifacts.synthetic_functions << build_direct_function_proc_invoke_function(source_expression, source_function.name, source_function.type, expected_type, invoke_c_name)
+        @artifacts.synthetic_functions << build_proc_noop_release_function(release_linkage_name)
+        @artifacts.synthetic_functions << build_proc_noop_retain_function(retain_c_name)
+
+        IR::AggregateLiteral.new(
+          type: expected_type,
+          fields: [
+            IR::AggregateField.new(name: "env", value: IR::NullLiteral.new(type: proc_env_pointer_type)),
+            IR::AggregateField.new(name: "invoke", value: IR::Name.new(name: invoke_c_name, type: proc_invoke_function_type(expected_type), pointer: false)),
+            IR::AggregateField.new(name: "release", value: IR::Name.new(name: release_linkage_name, type: proc_release_function_type, pointer: false)),
+            IR::AggregateField.new(name: "retain", value: IR::Name.new(name: retain_c_name, type: proc_retain_function_type, pointer: false)),
+          ],
+        )
+      end
+
+      def build_direct_function_proc_invoke_function(source_expression, function_c_name, function_type, proc_type, invoke_c_name)
+        env = empty_env
+        params = [IR::Param.new(name: "env", linkage_name: "__mt_proc_env", type: proc_env_pointer_type, pointer: false)]
+        parameter_setup = []
+        call_arguments = []
+
+        proc_type.params.each_with_index do |param, index|
+          linkage_name = c_local_name(param.name || "arg#{index}")
+          if array_type?(param.type)
+            input_linkage_name = "#{linkage_name}_input"
+            params << IR::Param.new(name: param.name || "arg#{index}", linkage_name: input_linkage_name, type: param.type, pointer: false)
+            env[:scopes].last[param.name || "arg#{index}"] = local_binding(type: param.type, linkage_name:, mutable: param.mutable, pointer: false)
+            parameter_setup << IR::LocalDecl.new(
+              name: param.name || "arg#{index}",
+              linkage_name:,
+              type: param.type,
+              value: IR::Name.new(name: input_linkage_name, type: param.type, pointer: false),
+            )
+            call_arguments << IR::Name.new(name: linkage_name, type: param.type, pointer: false)
+          else
+            env[:scopes].last[param.name || "arg#{index}"] = local_binding(type: param.type, linkage_name:, mutable: param.mutable, pointer: false)
+            params << IR::Param.new(name: param.name || "arg#{index}", linkage_name:, type: param.type, pointer: false)
+            call_arguments << IR::Name.new(name: linkage_name, type: param.type, pointer: false)
+          end
+        end
+
+        call = IR::Call.new(callee: function_c_name, arguments: call_arguments, type: proc_type.return_type)
+        body = if proc_type.return_type == @ctx.types.fetch("void")
+                  parameter_setup + [IR::ExpressionStmt.new(expression: call), IR::ReturnStmt.new(value: nil)]
+                else
+                  parameter_setup + [IR::ReturnStmt.new(value: call)]
+                end
+
+        IR::Function.new(name: invoke_c_name, linkage_name: invoke_c_name, params:, return_type: proc_type.return_type, body:, entry_point: false)
+      end
+
+      def lower_array_to_span_expression(expression, target_type)
+        array_type = expression.type
+        array_type = referenced_type(array_type) if ref_type?(array_type)
+
+        IR::AggregateLiteral.new(
+          type: target_type,
+          fields: [
+            IR::AggregateField.new(
+              name: "data",
+              value: IR::AddressOf.new(
+                expression: IR::Index.new(
+                  receiver: expression,
+                  index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
+                  type: target_type.element_type,
+                ),
+                type: pointer_to(target_type.element_type),
               ),
-              type: pointer_to(target_type.element_type),
             ),
-          ),
-          IR::AggregateField.new(
-            name: "len",
-            value: IR::IntegerLiteral.new(value: array_length(array_type), type: @ctx.types.fetch("ptr_uint")),
-          ),
-        ],
-      )
-    end
+            IR::AggregateField.new(
+              name: "len",
+              value: IR::IntegerLiteral.new(value: array_length(array_type), type: @ctx.types.fetch("ptr_uint")),
+            ),
+          ],
+        )
+      end
 
-    def lower_str_buffer_to_span_expression(expression, target_type)
-      IR::AggregateLiteral.new(
-        type: target_type,
-        fields: [
-          IR::AggregateField.new(
-            name: "data",
-            value: IR::Call.new(
-              callee: "mt_str_buffer_prepare_write",
-              arguments: [
-                lower_str_buffer_data_pointer_from_lowered(expression),
-                IR::IntegerLiteral.new(value: str_buffer_capacity(expression.type), type: @ctx.types.fetch("ptr_uint")),
-                lower_str_buffer_dirty_pointer_from_lowered(expression),
-              ],
-              type: pointer_to(target_type.element_type),
+      def lower_str_buffer_to_span_expression(expression, target_type)
+        IR::AggregateLiteral.new(
+          type: target_type,
+          fields: [
+            IR::AggregateField.new(
+              name: "data",
+              value: IR::Call.new(
+                callee: "mt_str_buffer_prepare_write",
+                arguments: [
+                  lower_str_buffer_data_pointer_from_lowered(expression),
+                  IR::IntegerLiteral.new(value: str_buffer_capacity(expression.type), type: @ctx.types.fetch("ptr_uint")),
+                  lower_str_buffer_dirty_pointer_from_lowered(expression),
+                ],
+                type: pointer_to(target_type.element_type),
+              ),
             ),
-          ),
-          IR::AggregateField.new(
-            name: "len",
-            value: IR::IntegerLiteral.new(value: str_buffer_storage_capacity(expression.type), type: @ctx.types.fetch("ptr_uint")),
-          ),
-        ],
-      )
-    end
+            IR::AggregateField.new(
+              name: "len",
+              value: IR::IntegerLiteral.new(value: str_buffer_storage_capacity(expression.type), type: @ctx.types.fetch("ptr_uint")),
+            ),
+          ],
+        )
+      end
 
-    def contextual_numeric_compatibility?(expression, actual_type, expected_type, env:, external_numeric: false, contextual_int_to_float: false)
-      return true if exact_compile_time_numeric_compatibility?(actual_type, expression, expected_type, env:)
-      return true if integer_to_char_compatibility?(actual_type, expected_type)
-      return true if external_numeric && external_numeric_compatibility?(actual_type, expected_type)
-      return true if contextual_int_to_float && contextual_int_to_float_compatibility?(actual_type, expected_type)
+      def contextual_numeric_compatibility?(expression, actual_type, expected_type, env:, external_numeric: false, contextual_int_to_float: false)
+        return true if exact_compile_time_numeric_compatibility?(actual_type, expression, expected_type, env:)
+        return true if integer_to_char_compatibility?(actual_type, expected_type)
+        return true if external_numeric && external_numeric_compatibility?(actual_type, expected_type)
+        return true if contextual_int_to_float && contextual_int_to_float_compatibility?(actual_type, expected_type)
 
-      false
-    end
+        false
+      end
 
-    def cstr_backed_expression?(expression, env)
-      return true if infer_expression_type(expression, env:) == @ctx.types.fetch("cstr")
-
-      case expression
-      when AST::StringLiteral
-        true
-      when AST::Identifier
-        binding_cstr_backed?(lookup_value(expression.name, env))
-      when AST::IfExpr
-        then_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: true, env:))
-        else_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: false, env:))
-        cstr_backed_expression?(expression.then_expression, then_env) &&
-          cstr_backed_expression?(expression.else_expression, else_env)
-      when AST::UnsafeExpr
-        cstr_backed_expression?(expression.expression, env)
-      else
+      def cstr_backed_expression?(expression, env)
+        return true if infer_expression_type(expression, env:) == @ctx.types.fetch("cstr")
+
+        case expression
+        when AST::StringLiteral
+          true
+        when AST::Identifier
+          binding_cstr_backed?(lookup_value(expression.name, env))
+        when AST::IfExpr
+          then_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: true, env:))
+          else_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: false, env:))
+          cstr_backed_expression?(expression.then_expression, then_env) &&
+            cstr_backed_expression?(expression.else_expression, else_env)
+        when AST::UnsafeExpr
+          cstr_backed_expression?(expression.expression, env)
+        else
+          false
+        end
+      rescue LoweringError
         false
       end
-    rescue LoweringError
-      false
-    end
 
-    def cstr_list_backed_expression?(expression, env)
-      actual_type = infer_expression_type(expression, env:)
-      return false unless array_type?(actual_type)
-
-      element_type = array_element_type(actual_type)
-      return false unless element_type == @ctx.types.fetch("str") || element_type == @ctx.types.fetch("cstr")
-
-      case expression
-      when AST::Identifier
-        binding_cstr_list_backed?(lookup_value(expression.name, env))
-      when AST::Call
-        expression.arguments.all? { |argument| cstr_backed_expression?(argument.value, env) }
-      when AST::IfExpr
-        then_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: true, env:))
-        else_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: false, env:))
-        cstr_list_backed_expression?(expression.then_expression, then_env) &&
-          cstr_list_backed_expression?(expression.else_expression, else_env)
-      when AST::UnsafeExpr
-        cstr_list_backed_expression?(expression.expression, env)
-      else
+      def cstr_list_backed_expression?(expression, env)
+        actual_type = infer_expression_type(expression, env:)
+        return false unless array_type?(actual_type)
+
+        element_type = array_element_type(actual_type)
+        return false unless element_type == @ctx.types.fetch("str") || element_type == @ctx.types.fetch("cstr")
+
+        case expression
+        when AST::Identifier
+          binding_cstr_list_backed?(lookup_value(expression.name, env))
+        when AST::Call
+          expression.arguments.all? { |argument| cstr_backed_expression?(argument.value, env) }
+        when AST::IfExpr
+          then_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: true, env:))
+          else_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: false, env:))
+          cstr_list_backed_expression?(expression.then_expression, then_env) &&
+            cstr_list_backed_expression?(expression.else_expression, else_env)
+        when AST::UnsafeExpr
+          cstr_list_backed_expression?(expression.expression, env)
+        else
+          false
+        end
+      rescue LoweringError
         false
       end
-    rescue LoweringError
-      false
-    end
 
-    def cstr_backed_storage_value?(type, expression, env)
-      return false unless expression
-      return true if type == @ctx.types.fetch("cstr")
-      return false unless type == @ctx.types.fetch("str")
+      def cstr_backed_storage_value?(type, expression, env)
+        return false unless expression
+        return true if type == @ctx.types.fetch("cstr")
+        return false unless type == @ctx.types.fetch("str")
 
-      cstr_backed_expression?(expression, env)
-    end
+        cstr_backed_expression?(expression, env)
+      end
 
-    def cstr_list_backed_storage_value?(type, expression, env)
-      return false unless expression
-      return false unless cstr_list_trackable_type?(type)
+      def cstr_list_backed_storage_value?(type, expression, env)
+        return false unless expression
+        return false unless cstr_list_trackable_type?(type)
 
-      cstr_list_backed_expression?(expression, env)
-    end
+        cstr_list_backed_expression?(expression, env)
+      end
 
-    def update_cstr_metadata_for_assignment!(statement, prepared_value, env)
-      if statement.target.is_a?(AST::Identifier)
-        binding = lookup_value(statement.target.name, env)
-        return unless binding
+      def update_cstr_metadata_for_assignment!(statement, prepared_value, env)
+        if statement.target.is_a?(AST::Identifier)
+          binding = lookup_value(statement.target.name, env)
+          return unless binding
 
-        replace_binding_cstr_metadata!(
-          statement.target.name,
-          env,
-          cstr_backed: statement.operator == "=" ? cstr_backed_storage_value?(binding[:type], prepared_value, env) : false,
-          cstr_list_backed: statement.operator == "=" ? cstr_list_backed_storage_value?(binding[:type], prepared_value, env) : false,
-        )
-        return
-      end
+          replace_binding_cstr_metadata!(
+            statement.target.name,
+            env,
+            cstr_backed: statement.operator == "=" ? cstr_backed_storage_value?(binding[:type], prepared_value, env) : false,
+            cstr_list_backed: statement.operator == "=" ? cstr_list_backed_storage_value?(binding[:type], prepared_value, env) : false,
+          )
+          return
+        end
 
-      return unless statement.target.is_a?(AST::IndexAccess) && statement.target.receiver.is_a?(AST::Identifier)
+        return unless statement.target.is_a?(AST::IndexAccess) && statement.target.receiver.is_a?(AST::Identifier)
 
-      binding = lookup_value(statement.target.receiver.name, env)
-      return unless binding && cstr_list_trackable_type?(binding[:type])
+        binding = lookup_value(statement.target.receiver.name, env)
+        return unless binding && cstr_list_trackable_type?(binding[:type])
 
-      replace_binding_cstr_metadata!(statement.target.receiver.name, env, cstr_backed: binding_cstr_backed?(binding), cstr_list_backed: false)
-    end
+        replace_binding_cstr_metadata!(statement.target.receiver.name, env, cstr_backed: binding_cstr_backed?(binding), cstr_list_backed: false)
+      end
 
-    def merge_cstr_metadata_after_if_statement!(statement, env)
-      exit_envs = cstr_metadata_exit_envs_for_if_statement(statement, env)
-      return if exit_envs.empty?
+      def merge_cstr_metadata_after_if_statement!(statement, env)
+        exit_envs = cstr_metadata_exit_envs_for_if_statement(statement, env)
+        return if exit_envs.empty?
 
-      trackable_binding_names(env).each do |name|
-        binding = lookup_value(name, env)
-        next unless binding
+        trackable_binding_names(env).each do |name|
+          binding = lookup_value(name, env)
+          next unless binding
 
-        replace_binding_cstr_metadata!(
-          name,
-          env,
-          cstr_backed: cstr_trackable_type?(binding[:type]) && exit_envs.all? { |exit_env| binding_cstr_backed?(lookup_value(name, exit_env)) },
-          cstr_list_backed: cstr_list_trackable_type?(binding[:type]) && exit_envs.all? { |exit_env| binding_cstr_list_backed?(lookup_value(name, exit_env)) },
-        )
+          replace_binding_cstr_metadata!(
+            name,
+            env,
+            cstr_backed: cstr_trackable_type?(binding[:type]) && exit_envs.all? { |exit_env| binding_cstr_backed?(lookup_value(name, exit_env)) },
+            cstr_list_backed: cstr_list_trackable_type?(binding[:type]) && exit_envs.all? { |exit_env| binding_cstr_list_backed?(lookup_value(name, exit_env)) },
+          )
+        end
       end
-    end
 
-    def cstr_metadata_exit_envs_for_if_statement(statement, env)
-      false_refinements = {}
-      exit_envs = []
+      def cstr_metadata_exit_envs_for_if_statement(statement, env)
+        false_refinements = {}
+        exit_envs = []
 
-      statement.branches.each do |branch|
-        branch_env = env_with_refinements(env, false_refinements)
-        true_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: true, env: branch_env))
-        simulated = simulate_cstr_metadata_block(branch.body, env: env_with_refinements(env, true_refinements))
-        exit_envs << simulated if simulated
-        false_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: false, env: branch_env))
-      end
+        statement.branches.each do |branch|
+          branch_env = env_with_refinements(env, false_refinements)
+          true_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: true, env: branch_env))
+          simulated = simulate_cstr_metadata_block(branch.body, env: env_with_refinements(env, true_refinements))
+          exit_envs << simulated if simulated
+          false_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: false, env: branch_env))
+        end
 
-      if statement.else_body
-        simulated = simulate_cstr_metadata_block(statement.else_body, env: env_with_refinements(env, false_refinements))
-        exit_envs << simulated if simulated
-      else
-        exit_envs << env
-      end
+        if statement.else_body
+          simulated = simulate_cstr_metadata_block(statement.else_body, env: env_with_refinements(env, false_refinements))
+          exit_envs << simulated if simulated
+        else
+          exit_envs << env
+        end
 
-      exit_envs
-    end
+        exit_envs
+      end
 
-    def simulate_cstr_metadata_block(statements, env:)
-      simulated_env = duplicate_env(env)
+      def simulate_cstr_metadata_block(statements, env:)
+        simulated_env = duplicate_env(env)
 
-      statements.each do |statement|
-        case statement
-        when AST::LocalDecl
-          storage_type = if statement.else_body
-                            infer_expression_type(statement.value, env: simulated_env)
-                          elsif statement.type
-                            resolve_type_ref(statement.type)
-                          else
-                            infer_expression_type(statement.value, env: simulated_env)
-                          end
-          type = if statement.else_body
-                    statement.type ? resolve_type_ref(statement.type) : let_else_success_type(storage_type)
-                  else
-                    storage_type
-                  end
-          unless let_else_discard_binding_syntax?(statement)
-            current_actual_scope(simulated_env[:scopes])[statement.name] = local_binding(
-              type:,
-              storage_type:,
-              linkage_name: c_local_name(statement.name),
-              mutable: statement.kind == :var,
-              pointer: false,
-              projection: statement.else_body ? let_else_binding_projection(storage_type) : nil,
-              cstr_backed: cstr_backed_storage_value?(storage_type, statement.value, simulated_env),
-              cstr_list_backed: cstr_list_backed_storage_value?(storage_type, statement.value, simulated_env),
-              const_value: statement.else_body ? nil : statement.kind == :let && statement.value ? compile_time_const_value(statement.value, env: simulated_env) : nil,
-            )
+        statements.each do |statement|
+          case statement
+          when AST::LocalDecl
+            storage_type = if statement.else_body
+                              infer_expression_type(statement.value, env: simulated_env)
+                            elsif statement.type
+                              resolve_type_ref(statement.type)
+                            else
+                              infer_expression_type(statement.value, env: simulated_env)
+                            end
+            type = if statement.else_body
+                      statement.type ? resolve_type_ref(statement.type) : let_else_success_type(storage_type)
+                    else
+                      storage_type
+                    end
+            unless let_else_discards_binding?(statement)
+              current_actual_scope(simulated_env[:scopes])[statement.name] = local_binding(
+                type:,
+                storage_type:,
+                linkage_name: c_local_name(statement.name),
+                mutable: statement.kind == :var,
+                pointer: false,
+                projection: statement.else_body ? let_else_binding_projection(storage_type) : nil,
+                cstr_backed: cstr_backed_storage_value?(storage_type, statement.value, simulated_env),
+                cstr_list_backed: cstr_list_backed_storage_value?(storage_type, statement.value, simulated_env),
+                const_value: statement.else_body ? nil : statement.kind == :let && statement.value ? compile_time_const_value(statement.value, env: simulated_env) : nil,
+              )
+            end
+          when AST::Assignment
+            update_cstr_metadata_for_assignment!(statement, statement.value, simulated_env)
+          when AST::IfStmt
+            merge_cstr_metadata_after_if_statement!(statement, simulated_env)
+          when AST::UnsafeStmt
+            nested_env = simulate_cstr_metadata_block(statement.body, env: simulated_env)
+            return nil unless nested_env
+
+            copy_cstr_metadata!(simulated_env, nested_env)
+          when AST::ReturnStmt, AST::BreakStmt, AST::ContinueStmt
+            return nil
           end
-        when AST::Assignment
-          update_cstr_metadata_for_assignment!(statement, statement.value, simulated_env)
-        when AST::IfStmt
-          merge_cstr_metadata_after_if_statement!(statement, simulated_env)
-        when AST::UnsafeStmt
-          nested_env = simulate_cstr_metadata_block(statement.body, env: simulated_env)
-          return nil unless nested_env
-
-          copy_cstr_metadata!(simulated_env, nested_env)
-        when AST::ReturnStmt, AST::BreakStmt, AST::ContinueStmt
-          return nil
         end
+
+        simulated_env
       end
 
-      simulated_env
-    end
+      def copy_cstr_metadata!(target_env, source_env)
+        trackable_binding_names(target_env).each do |name|
+          binding = lookup_value(name, target_env)
+          source_binding = lookup_value(name, source_env)
+          next unless binding && source_binding
 
-    def copy_cstr_metadata!(target_env, source_env)
-      trackable_binding_names(target_env).each do |name|
-        binding = lookup_value(name, target_env)
-        source_binding = lookup_value(name, source_env)
-        next unless binding && source_binding
-
-        replace_binding_cstr_metadata!(
-          name,
-          target_env,
-          cstr_backed: binding_cstr_backed?(source_binding),
-          cstr_list_backed: binding_cstr_list_backed?(source_binding),
-        )
+          replace_binding_cstr_metadata!(
+            name,
+            target_env,
+            cstr_backed: binding_cstr_backed?(source_binding),
+            cstr_list_backed: binding_cstr_list_backed?(source_binding),
+          )
+        end
       end
-    end
 
-    def replace_binding_cstr_metadata!(name, env, cstr_backed:, cstr_list_backed:)
-      env[:scopes].reverse_each do |scope|
-        next if scope.is_a?(FlowScope)
-        next unless scope.key?(name)
+      def replace_binding_cstr_metadata!(name, env, cstr_backed:, cstr_list_backed:)
+        env[:scopes].reverse_each do |scope|
+          next if scope.is_a?(FlowScope)
+          next unless scope.key?(name)
 
-        scope[name] = scope.fetch(name).merge(cstr_backed:, cstr_list_backed:)
-        return
+          scope[name] = scope.fetch(name).merge(cstr_backed:, cstr_list_backed:)
+          return
+        end
       end
-    end
 
-    def trackable_binding_names(env)
-      env[:scopes].each_with_object([]) do |scope, names|
-        next if scope.is_a?(FlowScope)
+      def trackable_binding_names(env)
+        env[:scopes].each_with_object([]) do |scope, names|
+          next if scope.is_a?(FlowScope)
 
-        scope.each do |name, binding|
-          next unless cstr_trackable_type?(binding[:type]) || cstr_list_trackable_type?(binding[:type])
+          scope.each do |name, binding|
+            next unless cstr_trackable_type?(binding[:type]) || cstr_list_trackable_type?(binding[:type])
 
-          names << name unless names.include?(name)
+            names << name unless names.include?(name)
+          end
         end
       end
-    end
 
-    def binding_cstr_backed?(binding)
-      binding && binding[:cstr_backed]
-    end
+      def binding_cstr_backed?(binding)
+        binding && binding[:cstr_backed]
+      end
 
-    def binding_cstr_list_backed?(binding)
-      binding && binding[:cstr_list_backed]
-    end
+      def binding_cstr_list_backed?(binding)
+        binding && binding[:cstr_list_backed]
+      end
 
-    def exact_compile_time_numeric_compatibility?(actual_type, expression, expected_type, env: nil)
-      return false unless expected_type.is_a?(Types::Primitive) && expected_type.numeric?
-      return false if actual_type.is_a?(Types::EnumBase)
+      def exact_compile_time_numeric_compatibility?(actual_type, expression, expected_type, env: nil)
+        return false unless expected_type.is_a?(Types::Primitive) && expected_type.numeric?
+        return false if actual_type.is_a?(Types::EnumBase)
 
-      value = compile_time_const_value(expression, env:)
-      return false unless value.is_a?(Numeric)
+        value = compile_time_const_value(expression, env:)
+        return false unless value.is_a?(Numeric)
 
-      numeric_constant_fits_type?(value, expected_type)
-    end
+        numeric_constant_fits_type?(value, expected_type)
+      end
 
-    def external_numeric_assignment_target?(expression, env:)
-      case expression
-      when AST::MemberAccess
-        receiver_type = infer_field_receiver_type(expression.receiver, env:)
-        receiver_type.respond_to?(:external) && receiver_type.external
-      else
-        false
+      def external_numeric_assignment_target?(expression, env:)
+        case expression
+        when AST::MemberAccess
+          receiver_type = infer_field_receiver_type(expression.receiver, env:)
+          receiver_type.respond_to?(:external) && receiver_type.external
+        else
+          false
+        end
       end
-    end
 
-    def resolve_callee(callee, env, arguments: nil)
-      case callee
-      when AST::Identifier
-        resolve_identifier_callee(callee, env, arguments)
-      when AST::MemberAccess
-        resolve_member_access_callee(callee, env, arguments)
-      when AST::Specialization
-        resolve_specialization_callee(callee, env)
-      else
-        resolve_expression_callee(callee, env)
+      def resolve_callee(callee, env, arguments: nil)
+        case callee
+        when AST::Identifier
+          resolve_identifier_callee(callee, env, arguments)
+        when AST::MemberAccess
+          resolve_member_access_callee(callee, env, arguments)
+        when AST::Specialization
+          resolve_specialization_callee(callee, env)
+        else
+          resolve_expression_callee(callee, env)
+        end
       end
-    end
 
-    def resolve_identifier_callee(callee, env, arguments)
-      if (binding = lookup_value(callee.name, env))
-        return [:callable_value, nil, nil, binding[:type], nil] if callable_type?(binding[:type])
+      def resolve_identifier_callee(callee, env, arguments)
+        if (binding = lookup_value(callee.name, env))
+          return [:callable_value, nil, nil, binding[:type], nil] if callable_type?(binding[:type])
 
-        raise LoweringError.new("#{callee.name} is not callable", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
+          raise LoweringError.new("#{callee.name} is not callable", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-      if @ctx.functions.key?(callee.name)
-        binding = specialize_function_binding(@ctx.functions.fetch(callee.name), arguments, env)
-        callee_name = if binding.external
-                        external_function_c_name(binding)
-                      else
-                        function_binding_c_name(binding, module_name: @ctx.module_name)
-                      end
-        return [:function, callee_name, nil, binding.type, binding]
-      end
+        if @ctx.functions.key?(callee.name)
+          binding = specialize_function_binding(@ctx.functions.fetch(callee.name), arguments, env)
+          callee_name = if binding.external
+                          external_function_c_name(binding)
+                        else
+                          function_binding_c_name(binding, module_name: @ctx.module_name)
+                        end
+          return [:function, callee_name, nil, binding.type, binding]
+        end
 
-      if (kind = PASS_THROUGH_BUILTINS[callee.name])
-        return [kind, nil, nil, nil]
-      end
+        if (kind = PASS_THROUGH_BUILTINS[callee.name])
+          return [kind, nil, nil, nil]
+        end
 
-      if COMPILE_TIME_BUILTINS.include?(callee.name)
-        return [:compile_time_builtin, callee.name, nil, compile_time_builtin_function_type(callee.name, arguments, env)]
-      end
+        if COMPILE_TIME_BUILTINS.include?(callee.name)
+          return [:compile_time_builtin, callee.name, nil, compile_time_builtin_function_type(callee.name, arguments, env)]
+        end
 
-      type = @ctx.types[callee.name]
-      if type.is_a?(Types::Struct) || type.is_a?(Types::StringView) || task_type?(type) || type.is_a?(Types::Vector) || type.is_a?(Types::Matrix) || type.is_a?(Types::Quaternion)
-        return [:struct_literal, nil, nil, type]
-      end
+        type = @ctx.types[callee.name]
+        if type.is_a?(Types::Struct) || type.is_a?(Types::StringView) || task_type?(type) || type.is_a?(Types::Vector) || type.is_a?(Types::Matrix) || type.is_a?(Types::Quaternion)
+          return [:struct_literal, nil, nil, type]
+        end
 
-      if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
-        raise LoweringError.new("generic type #{callee.name} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
+        if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+          raise LoweringError.new("generic type #{callee.name} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-      emit_fn = @artifacts.emitted_declarations.find { |d| d.is_a?(IR::Function) && d.name == callee.name }
-      if emit_fn
-        return [:function, emit_fn.linkage_name, nil, emit_fn.return_type, nil]
+        emit_fn = @artifacts.emitted_declarations.find { |d| d.is_a?(IR::Function) && d.name == callee.name }
+        if emit_fn
+          return [:function, emit_fn.linkage_name, nil, emit_fn.return_type, nil]
+        end
+
+        raise LoweringError.new("unknown callee #{callee.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
-      raise LoweringError.new("unknown callee #{callee.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
-    end
+      def resolve_member_access_callee(callee, env, arguments)
+        if callee.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(callee.receiver.name)
+          imported_module = @ctx.imports.fetch(callee.receiver.name)
 
-    def resolve_member_access_callee(callee, env, arguments)
-      if callee.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(callee.receiver.name)
-        imported_module = @ctx.imports.fetch(callee.receiver.name)
+          if imported_module.functions.key?(callee.member)
+            binding = specialize_function_binding(imported_module.functions.fetch(callee.member), arguments, env)
+            unless binding.owner
+              binding = binding.with(owner: imported_module.respond_to?(:analysis) ? imported_module.analysis : imported_module)
+            end
+            return [:function, function_binding_c_name(binding, module_name: imported_module.name), nil, binding.type, binding] unless binding.external
 
-        if imported_module.functions.key?(callee.member)
-          binding = specialize_function_binding(imported_module.functions.fetch(callee.member), arguments, env)
-          unless binding.owner
-            binding = binding.with(owner: imported_module.respond_to?(:analysis) ? imported_module.analysis : imported_module)
+            return [:function, external_function_c_name(binding), nil, binding.type, binding]
+          end
+          imported_type = imported_module.types[callee.member]
+          if imported_type.is_a?(Types::GenericStructDefinition) || imported_type.is_a?(Types::GenericVariantDefinition)
+            raise LoweringError.new("generic type #{callee.receiver.name}.#{callee.member} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
-          return [:function, function_binding_c_name(binding, module_name: imported_module.name), nil, binding.type, binding] unless binding.external
 
-          return [:function, external_function_c_name(binding), nil, binding.type, binding]
-        end
-        imported_type = imported_module.types[callee.member]
-        if imported_type.is_a?(Types::GenericStructDefinition) || imported_type.is_a?(Types::GenericVariantDefinition)
-          raise LoweringError.new("generic type #{callee.receiver.name}.#{callee.member} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
+          if imported_type.is_a?(Types::Struct) || imported_type.is_a?(Types::StringView) || task_type?(imported_type) || imported_type.is_a?(Types::Vector) || imported_type.is_a?(Types::Matrix) || imported_type.is_a?(Types::Quaternion)
+            return [:struct_literal, nil, nil, imported_module.types.fetch(callee.member)]
+          end
 
-        if imported_type.is_a?(Types::Struct) || imported_type.is_a?(Types::StringView) || task_type?(imported_type) || imported_type.is_a?(Types::Vector) || imported_type.is_a?(Types::Matrix) || imported_type.is_a?(Types::Quaternion)
-          return [:struct_literal, nil, nil, imported_module.types.fetch(callee.member)]
+          if imported_type.is_a?(Types::Variant) && imported_type.arm_names.include?(callee.member)
+            arm_name = callee.member
+            return [:variant_arm_ctor, nil, nil, imported_type, [imported_type, arm_name]]
+          end
         end
 
-        if imported_type.is_a?(Types::Variant) && imported_type.arm_names.include?(callee.member)
-          arm_name = callee.member
-          return [:variant_arm_ctor, nil, nil, imported_type, [imported_type, arm_name]]
-        end
-      end
+        if (type_expr = resolve_type_expression(callee.receiver))
+          if type_expr.is_a?(Types::Variant) && type_expr.arm_names.include?(callee.member)
+            arm_name = callee.member
+            return [:variant_arm_ctor, nil, nil, type_expr, [type_expr, arm_name]]
+          end
+
+          if type_expr.respond_to?(:nested_types) && type_expr.nested_types.key?(callee.member)
+            return [:struct_literal, nil, nil, type_expr.nested_types[callee.member]]
+          end
 
-      if (type_expr = resolve_type_expression(callee.receiver))
-        if type_expr.is_a?(Types::Variant) && type_expr.arm_names.include?(callee.member)
-          arm_name = callee.member
-          return [:variant_arm_ctor, nil, nil, type_expr, [type_expr, arm_name]]
+          dispatch_receiver_type = method_dispatch_receiver_type(type_expr)
+          method_entry_receiver_type = type_expr
+          method_entry = @method_definitions[[type_expr, callee.member]]
+          method_entry ||= @method_definitions[[type_expr, "static:#{callee.member}"]]
+          unless method_entry || dispatch_receiver_type == type_expr
+            method_entry_receiver_type = dispatch_receiver_type
+            method_entry = @method_definitions[[dispatch_receiver_type, callee.member]]
+            method_entry ||= @method_definitions[[dispatch_receiver_type, "static:#{callee.member}"]]
+          end
+          if method_entry
+            method_analysis, method_ast = method_entry
+            method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
+            if method_binding.type.receiver_type.nil?
+              method_binding = specialize_function_binding(method_binding, arguments, env, receiver_type: type_expr) if method_binding.type_params.any?
+              return [:associated_method, function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type), nil, method_binding.type, method_binding]
+            end
+          end
+
+          raise LoweringError.new("unknown associated function #{type_expr}.#{callee.member}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
-        if type_expr.respond_to?(:nested_types) && type_expr.nested_types.key?(callee.member)
-          return [:struct_literal, nil, nil, type_expr.nested_types[callee.member]]
+        resolved_receiver_type = infer_method_receiver_type(callee.receiver, env:, member_name: callee.member)
+
+        if dyn_type?(resolved_receiver_type)
+          interface = resolved_receiver_type.interface_binding
+          method_binding = interface.methods[callee.member]
+          raise LoweringError.new("no method '#{callee.member}' on interface #{interface.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding
+          return [:dyn_method, nil, callee.receiver, method_binding, nil]
         end
 
-        dispatch_receiver_type = method_dispatch_receiver_type(type_expr)
-        method_entry_receiver_type = type_expr
-        method_entry = @method_definitions[[type_expr, callee.member]]
-        method_entry ||= @method_definitions[[type_expr, "static:#{callee.member}"]]
-        unless method_entry || dispatch_receiver_type == type_expr
+        dispatch_receiver_type = method_dispatch_receiver_type(resolved_receiver_type)
+        method_entry_receiver_type = resolved_receiver_type
+        method_entry = @method_definitions[[resolved_receiver_type, callee.member]]
+        unless method_entry || dispatch_receiver_type == resolved_receiver_type
           method_entry_receiver_type = dispatch_receiver_type
           method_entry = @method_definitions[[dispatch_receiver_type, callee.member]]
-          method_entry ||= @method_definitions[[dispatch_receiver_type, "static:#{callee.member}"]]
         end
         if method_entry
           method_analysis, method_ast = method_entry
-          method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
-          if method_binding.type.receiver_type.nil?
-            method_binding = specialize_function_binding(method_binding, arguments, env, receiver_type: type_expr) if method_binding.type_params.any?
-            return [:associated_method, function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type), nil, method_binding.type, method_binding]
-          end
+          method_analysis_key = method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name
+          method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key)
+          method_binding = specialize_function_binding(method_binding, arguments, env, receiver_type: resolved_receiver_type)
+          return [
+            :method,
+            function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type),
+            callee.receiver,
+            method_binding.type,
+            method_binding,
+          ]
         end
 
-        raise LoweringError.new("unknown associated function #{type_expr}.#{callee.member}", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
-
-      resolved_receiver_type = infer_method_receiver_type(callee.receiver, env:, member_name: callee.member)
+        if callee.member == "with" && struct_with_target_type?(resolved_receiver_type)
+          return [:struct_with, nil, callee.receiver, resolved_receiver_type]
+        end
+
+        if (precomputed = @ctx.resolved_call_kinds[@ctx.ast.node_ids[callee.object_id]])
+          case precomputed
+          when :str_buffer_clear, :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format,
+              :str_buffer_len, :str_buffer_capacity, :str_buffer_as_str, :str_buffer_as_cstr
+            return [precomputed, nil, callee.receiver, str_buffer_method_type(precomputed, resolved_receiver_type)]
+          when :event_subscribe, :event_subscribe_once, :event_unsubscribe, :event_emit, :event_wait
+            event_type = infer_expression_type(callee.receiver, env:)
+            return [precomputed, nil, callee.receiver, event_method_type(precomputed, event_type)]
+          when :atomic_load, :atomic_store, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_compare_exchange
+            elem = atomic_element_type(resolved_receiver_type)
+            ret = case precomputed
+                  when :atomic_load, :atomic_add, :atomic_sub, :atomic_exchange then elem
+                  when :atomic_store then @ctx.types.fetch("void")
+                  when :atomic_compare_exchange then @ctx.types.fetch("bool")
+                  end
+            return [precomputed, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
+          when :simd_lane_with
+            return [precomputed, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: resolved_receiver_type)]
+          end
+        end
 
-      if dyn_type?(resolved_receiver_type)
-        interface = resolved_receiver_type.interface_binding
-        method_binding = interface.methods[callee.member]
-        raise LoweringError.new("no method '#{callee.member}' on interface #{interface.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding
-        return [:dyn_method, nil, callee.receiver, method_binding, nil]
-      end
+        if (str_buffer_method = str_buffer_method_kind(resolved_receiver_type, callee.member))
+          return [str_buffer_method, nil, callee.receiver, str_buffer_method_type(str_buffer_method, resolved_receiver_type)]
+        end
 
-      dispatch_receiver_type = method_dispatch_receiver_type(resolved_receiver_type)
-      method_entry_receiver_type = resolved_receiver_type
-      method_entry = @method_definitions[[resolved_receiver_type, callee.member]]
-      unless method_entry || dispatch_receiver_type == resolved_receiver_type
-        method_entry_receiver_type = dispatch_receiver_type
-        method_entry = @method_definitions[[dispatch_receiver_type, callee.member]]
-      end
-      if method_entry
-        method_analysis, method_ast = method_entry
-        method_analysis_key = method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name
-        method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key)
-        method_binding = specialize_function_binding(method_binding, arguments, env, receiver_type: resolved_receiver_type)
-        return [
-          :method,
-          function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type),
-          callee.receiver,
-          method_binding.type,
-          method_binding,
-        ]
-      end
-
-      if callee.member == "with" && struct_with_target_type?(resolved_receiver_type)
-        return [:struct_with, nil, callee.receiver, resolved_receiver_type]
-      end
-
-      if (precomputed = @ctx.resolved_call_kinds[@ctx.ast.node_ids[callee.object_id]])
-        case precomputed
-        when :str_buffer_clear, :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format,
-            :str_buffer_len, :str_buffer_capacity, :str_buffer_as_str, :str_buffer_as_cstr
-          return [precomputed, nil, callee.receiver, str_buffer_method_type(precomputed, resolved_receiver_type)]
-        when :event_subscribe, :event_subscribe_once, :event_unsubscribe, :event_emit, :event_wait
+        if (event_method = event_method_kind(resolved_receiver_type, callee.member))
           event_type = infer_expression_type(callee.receiver, env:)
-          return [precomputed, nil, callee.receiver, event_method_type(precomputed, event_type)]
-        when :atomic_load, :atomic_store, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_compare_exchange
+          return [event_method, nil, callee.receiver, event_method_type(event_method, event_type)]
+        end
+
+        if (atomic_method = atomic_method_kind(resolved_receiver_type, callee.member))
           elem = atomic_element_type(resolved_receiver_type)
-          ret = case precomputed
+          ret = case atomic_method
                 when :atomic_load, :atomic_add, :atomic_sub, :atomic_exchange then elem
                 when :atomic_store then @ctx.types.fetch("void")
                 when :atomic_compare_exchange then @ctx.types.fetch("bool")
                 end
-          return [precomputed, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
-        when :simd_lane_with
-          return [precomputed, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: resolved_receiver_type)]
+          return [atomic_method, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
         end
-      end
-
-      if (str_buffer_method = str_buffer_method_kind(resolved_receiver_type, callee.member))
-        return [str_buffer_method, nil, callee.receiver, str_buffer_method_type(str_buffer_method, resolved_receiver_type)]
-      end
-
-      if (event_method = event_method_kind(resolved_receiver_type, callee.member))
-        event_type = infer_expression_type(callee.receiver, env:)
-        return [event_method, nil, callee.receiver, event_method_type(event_method, event_type)]
-      end
-
-      if (atomic_method = atomic_method_kind(resolved_receiver_type, callee.member))
-        elem = atomic_element_type(resolved_receiver_type)
-        ret = case atomic_method
-              when :atomic_load, :atomic_add, :atomic_sub, :atomic_exchange then elem
-              when :atomic_store then @ctx.types.fetch("void")
-              when :atomic_compare_exchange then @ctx.types.fetch("bool")
-              end
-        return [atomic_method, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
-      end
-
-      if (simd_method = simd_method_kind(resolved_receiver_type, callee.member))
-        ret = case simd_method
-              when :simd_lane_with then resolved_receiver_type
-              end
-        return [simd_method, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
-      end
-
-      field_receiver_type = infer_field_receiver_type(callee.receiver, env:)
-      if array_type?(field_receiver_type) && callee.member == "as_span"
-        return [:array_as_span, nil, callee.receiver, Types::Registry.span(array_element_type(field_receiver_type))]
-      end
-
-      member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
-      member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
-      return [:callable_value, nil, nil, member_type, nil] if callable_type?(member_type)
 
-      raise LoweringError.new("unknown callee #{callee.receiver}.#{callee.member}", line: 0, column: 0, path: @ctx.current_analysis_path)
-    end
+        if (simd_method = simd_method_kind(resolved_receiver_type, callee.member))
+          ret = case simd_method
+                when :simd_lane_with then resolved_receiver_type
+                end
+          return [simd_method, nil, callee.receiver, Types::Registry.function(nil, params: [], return_type: ret)]
+        end
+
+        field_receiver_type = infer_field_receiver_type(callee.receiver, env:)
+        if array_type?(field_receiver_type) && callee.member == "as_span"
+          return [:array_as_span, nil, callee.receiver, Types::Registry.span(array_element_type(field_receiver_type))]
+        end
+
+        member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
+        member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
+        return [:callable_value, nil, nil, member_type, nil] if callable_type?(member_type)
+
+        raise LoweringError.new("unknown callee #{callee.receiver}.#{callee.member}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      end
+
+      def resolve_specialization_callee(callee, env)
+        if callee.callee.is_a?(AST::Identifier)
+          case callee.callee.name
+          when "reinterpret"
+            target_type = resolve_type_ref(callee.arguments.fetch(0).value)
+            return [:reinterpret, nil, nil, Types::Registry.function("reinterpret", params: [Types::Registry.parameter("value", target_type)], return_type: target_type)]
+          when "array"
+            array_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["array"]), arguments: callee.arguments, nullable: false))
+            return [:array, nil, nil, array_type]
+          when "simd"
+            simd_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["simd"]), arguments: callee.arguments, nullable: false))
+            return [:simd, nil, nil, simd_type]
+          when "span"
+            span_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["span"]), arguments: callee.arguments, nullable: false))
+            return [:struct_literal, nil, nil, span_type]
+          when "zero"
+            target_type = resolve_type_ref(callee.arguments.fetch(0).value)
+            return [:zero, nil, nil, Types::Registry.function("zero", params: [], return_type: target_type)]
+          when "hash"
+            resolution = resolve_hash_specialization(callee, env:)
+            return [:hash, resolution.callee_name, nil, Types::Registry.function("hash", params: [Types::Registry.parameter("value", resolution.target_type)], return_type: @ctx.types.fetch("uint")), resolution.binding]
+          when "equal"
+            resolution = resolve_equal_specialization(callee, env:)
+            params = [
+              Types::Registry.parameter("left", resolution.target_type),
+              Types::Registry.parameter("right", resolution.target_type),
+            ]
+            return [:equal, resolution.callee_name, nil, Types::Registry.function("equal", params:, return_type: @ctx.types.fetch("bool")), resolution.binding]
+          when "order"
+            resolution = resolve_order_specialization(callee, env:)
+            params = [
+              Types::Registry.parameter("left", resolution.target_type),
+              Types::Registry.parameter("right", resolution.target_type),
+            ]
+            return [:order, resolution.callee_name, nil, Types::Registry.function("order", params:, return_type: @ctx.types.fetch("int")), resolution.binding]
+          when "attribute_arg"
+            return [:compile_time_builtin, "attribute_arg", nil, compile_time_builtin_specialization_function_type(callee)]
+          when "adapt"
+            raise LoweringError.new("adapt requires exactly one type argument", line: 0, column: 0, path: @ctx.current_analysis_path) unless callee.arguments.length == 1
+
+            type_arg = callee.arguments.first.value
+            raise LoweringError.new("adapt type argument must be a type", line: 0, column: 0, path: @ctx.current_analysis_path) unless type_arg.is_a?(AST::TypeRef)
+
+            parts = type_arg.name.parts
+            type_args = type_arg.arguments.map { |a| a.value }
+            interface = resolve_interface_ref(AST::QualifiedName.new(parts:, type_arguments: type_args))
+            dyn_type = Types::Dyn.new(interface, interface.respond_to?(:type_arguments) ? (interface.type_arguments || []) : [])
+            return [:adapt, nil, nil, dyn_type, interface]
+          end
+        end
 
-    def resolve_specialization_callee(callee, env)
-      if callee.callee.is_a?(AST::Identifier)
-        case callee.callee.name
-        when "reinterpret"
-          target_type = resolve_type_ref(callee.arguments.fetch(0).value)
-          return [:reinterpret, nil, nil, Types::Registry.function("reinterpret", params: [Types::Registry.parameter("value", target_type)], return_type: target_type)]
-        when "array"
-          array_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["array"]), arguments: callee.arguments, nullable: false))
-          return [:array, nil, nil, array_type]
-        when "simd"
-          simd_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["simd"]), arguments: callee.arguments, nullable: false))
-          return [:simd, nil, nil, simd_type]
-        when "span"
-          span_type = resolve_type_ref(AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["span"]), arguments: callee.arguments, nullable: false))
-          return [:struct_literal, nil, nil, span_type]
-        when "zero"
-          target_type = resolve_type_ref(callee.arguments.fetch(0).value)
-          return [:zero, nil, nil, Types::Registry.function("zero", params: [], return_type: target_type)]
-        when "hash"
-          resolution = resolve_hash_specialization(callee, env:)
-          return [:hash, resolution.callee_name, nil, Types::Registry.function("hash", params: [Types::Registry.parameter("value", resolution.target_type)], return_type: @ctx.types.fetch("uint")), resolution.binding]
-        when "equal"
-          resolution = resolve_equal_specialization(callee, env:)
-          params = [
-            Types::Registry.parameter("left", resolution.target_type),
-            Types::Registry.parameter("right", resolution.target_type),
-          ]
-          return [:equal, resolution.callee_name, nil, Types::Registry.function("equal", params:, return_type: @ctx.types.fetch("bool")), resolution.binding]
-        when "order"
-          resolution = resolve_order_specialization(callee, env:)
-          params = [
-            Types::Registry.parameter("left", resolution.target_type),
-            Types::Registry.parameter("right", resolution.target_type),
-          ]
-          return [:order, resolution.callee_name, nil, Types::Registry.function("order", params:, return_type: @ctx.types.fetch("int")), resolution.binding]
-        when "attribute_arg"
-          return [:compile_time_builtin, "attribute_arg", nil, compile_time_builtin_specialization_function_type(callee)]
-        when "adapt"
-          raise LoweringError.new("adapt requires exactly one type argument", line: 0, column: 0, path: @ctx.current_analysis_path) unless callee.arguments.length == 1
+        if (callable_resolution = resolve_specialized_callable_binding(callee, env:))
+          callable_kind, function_binding, receiver, method_entry_receiver_type = callable_resolution
+          if callable_kind == :method
+            return [
+              :method,
+              function_binding_c_name(function_binding, module_name: function_binding.owner.module_name, receiver_type: method_entry_receiver_type),
+              receiver,
+              function_binding.type,
+              function_binding,
+            ]
+          end
 
-          type_arg = callee.arguments.first.value
-          raise LoweringError.new("adapt type argument must be a type", line: 0, column: 0, path: @ctx.current_analysis_path) unless type_arg.is_a?(AST::TypeRef)
+          if function_binding.external
+            return [:function, external_function_c_name(function_binding), nil, function_binding.type, function_binding]
+          end
 
-          parts = type_arg.name.parts
-          type_args = type_arg.arguments.map { |a| a.value }
-          interface = resolve_interface_ref(AST::QualifiedName.new(parts:, type_arguments: type_args))
-          dyn_type = Types::Dyn.new(interface, interface.respond_to?(:type_arguments) ? (interface.type_arguments || []) : [])
-          return [:adapt, nil, nil, dyn_type, interface]
+          return [:function, function_binding_c_name(function_binding, module_name: function_binding.owner.module_name), nil, function_binding.type, function_binding]
         end
-      end
 
-      if (callable_resolution = resolve_specialized_callable_binding(callee, env:))
-        callable_kind, function_binding, receiver, method_entry_receiver_type = callable_resolution
-        if callable_kind == :method
-          return [
-            :method,
-            function_binding_c_name(function_binding, module_name: function_binding.owner.module_name, receiver_type: method_entry_receiver_type),
-            receiver,
-            function_binding.type,
-            function_binding,
-          ]
+        if (type_ref = type_ref_from_specialization(callee))
+          specialized_type = resolve_type_ref(type_ref)
+          return [:struct_literal, nil, nil, specialized_type] if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion) || specialized_type.is_a?(Types::Simd)
         end
 
-        if function_binding.external
-          return [:function, external_function_c_name(function_binding), nil, function_binding.type, function_binding]
-        end
-
-        return [:function, function_binding_c_name(function_binding, module_name: function_binding.owner.module_name), nil, function_binding.type, function_binding]
-      end
-
-      if (type_ref = type_ref_from_specialization(callee))
-        specialized_type = resolve_type_ref(type_ref)
-        return [:struct_literal, nil, nil, specialized_type] if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion) || specialized_type.is_a?(Types::Simd)
+        raise LoweringError.new("unsupported specialization callee", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
-      raise LoweringError.new("unsupported specialization callee", line: 0, column: 0, path: @ctx.current_analysis_path)
-    end
-
-    def resolve_expression_callee(callee, env)
-      callee_type = infer_expression_type(callee, env:)
-      return [:callable_value, nil, nil, callee_type, nil] if callable_type?(callee_type)
-
-      raise LoweringError.new("unsupported callee #{callee.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
-    end
+      def resolve_expression_callee(callee, env)
+        callee_type = infer_expression_type(callee, env:)
+        return [:callable_value, nil, nil, callee_type, nil] if callable_type?(callee_type)
 
-    def infer_expression_type(expression, env:, expected_type: nil)
-      if !@bypass_sema_type_cache && expected_type.nil? && (id = @ctx.ast.node_ids[expression.object_id]) && (resolved = @ctx.resolved_expr_types[id])
-        return resolved
+        raise LoweringError.new("unsupported callee #{callee.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
-      case expression
-      when AST::AwaitExpr
-        task_type = infer_expression_type(expression.expression, env:)
-        raise LoweringError.new("await requires a Task value, got #{task_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless task_type.is_a?(Types::Task)
+      def infer_expression_type(expression, env:, expected_type: nil)
+        if !@bypass_sema_type_cache && expected_type.nil? && (id = @ctx.ast.node_ids[expression.object_id]) && (resolved = @ctx.resolved_expr_types[id])
+          return resolved
+        end
 
-        task_type.result_type
-      when AST::IntegerLiteral
-        if expected_type.is_a?(Types::Primitive) && expected_type.integer?
-          expected_type
-        else
-          @ctx.types.fetch("int")
-        end
-      when AST::CharLiteral
-        @ctx.types.fetch("ubyte")
-      when AST::FloatLiteral
-        if expression.lexeme.end_with?("f")
-          @ctx.types.fetch("float")
-        elsif expression.lexeme.end_with?("d")
-          @ctx.types.fetch("double")
-        elsif expected_type.is_a?(Types::Primitive) && expected_type.float?
-          expected_type
-        else
-          @ctx.types.fetch("float")
-        end
-      when AST::SizeofExpr, AST::AlignofExpr, AST::OffsetofExpr
-        @ctx.types.fetch("ptr_uint")
-      when AST::StringLiteral
-        @ctx.types.fetch(expression.cstring ? "cstr" : "str")
-      when AST::FormatString
-        @ctx.types.fetch("str")
-      when AST::BooleanLiteral
-        @ctx.types.fetch("bool")
-      when AST::NullLiteral
-        infer_null_literal_type(expression, expected_type)
-      when AST::Identifier
-        binding = lookup_value(expression.name, env)
-        return binding[:type] if binding
-          return function_type_for_name(expression.name) if @ctx.functions.key?(expression.name)
-
-          raise LoweringError.new("unknown identifier #{expression.name}", line: expression.line, column: expression.column)
-      when AST::MemberAccess
-        if (type_expr = resolve_type_expression(expression.receiver))
-          member_type = resolve_type_member(type_expr, expression.member)
-          return member_type if member_type
+        case expression
+        when AST::AwaitExpr
+          task_type = infer_expression_type(expression.expression, env:)
+          raise LoweringError.new("await requires a Task value, got #{task_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless task_type.is_a?(Types::Task)
 
-          dispatch_receiver_type = method_dispatch_receiver_type(type_expr)
-          method_entry_receiver_type = type_expr
-          method_entry = @method_definitions[[type_expr, expression.member]]
-          method_entry ||= @method_definitions[[type_expr, "static:#{expression.member}"]]
-          unless method_entry || dispatch_receiver_type == type_expr
-            method_entry_receiver_type = dispatch_receiver_type
-            method_entry = @method_definitions[[dispatch_receiver_type, expression.member]]
-            method_entry ||= @method_definitions[[dispatch_receiver_type, "static:#{expression.member}"]]
+          task_type.result_type
+        when AST::IntegerLiteral
+          if expected_type.is_a?(Types::Primitive) && expected_type.integer?
+            expected_type
+          else
+            @ctx.types.fetch("int")
           end
-          if method_entry
-            method_analysis, method_ast = method_entry
-            method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
-            return method_binding.type if method_binding.type.receiver_type.nil?
+        when AST::CharLiteral
+          @ctx.types.fetch("ubyte")
+        when AST::FloatLiteral
+          if expression.lexeme.end_with?("f")
+            @ctx.types.fetch("float")
+          elsif expression.lexeme.end_with?("d")
+            @ctx.types.fetch("double")
+          elsif expected_type.is_a?(Types::Primitive) && expected_type.float?
+            expected_type
+          else
+            @ctx.types.fetch("float")
+          end
+        when AST::SizeofExpr, AST::AlignofExpr, AST::OffsetofExpr
+          @ctx.types.fetch("ptr_uint")
+        when AST::StringLiteral
+          @ctx.types.fetch(expression.cstring ? "cstr" : "str")
+        when AST::FormatString
+          @ctx.types.fetch("str")
+        when AST::BooleanLiteral
+          @ctx.types.fetch("bool")
+        when AST::NullLiteral
+          infer_null_literal_type(expression, expected_type)
+        when AST::Identifier
+          binding = lookup_value(expression.name, env)
+          return binding[:type] if binding
+            return function_type_for_name(expression.name) if @ctx.functions.key?(expression.name)
+
+            raise LoweringError.new("unknown identifier #{expression.name}", line: expression.line, column: expression.column)
+        when AST::MemberAccess
+          if (type_expr = resolve_type_expression(expression.receiver))
+            member_type = resolve_type_member(type_expr, expression.member)
+            return member_type if member_type
+
+            dispatch_receiver_type = method_dispatch_receiver_type(type_expr)
+            method_entry_receiver_type = type_expr
+            method_entry = @method_definitions[[type_expr, expression.member]]
+            method_entry ||= @method_definitions[[type_expr, "static:#{expression.member}"]]
+            unless method_entry || dispatch_receiver_type == type_expr
+              method_entry_receiver_type = dispatch_receiver_type
+              method_entry = @method_definitions[[dispatch_receiver_type, expression.member]]
+              method_entry ||= @method_definitions[[dispatch_receiver_type, "static:#{expression.member}"]]
+            end
+            if method_entry
+              method_analysis, method_ast = method_entry
+              method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
+              return method_binding.type if method_binding.type.receiver_type.nil?
+            end
+          end
+          if expression.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.receiver.name)
+            imported_module = @ctx.imports.fetch(expression.receiver.name)
+            return imported_module.values.fetch(expression.member).type if imported_module.values.key?(expression.member)
+            return imported_module.functions.fetch(expression.member).type if imported_module.functions.key?(expression.member)
+          end
+          receiver_type = infer_field_receiver_type(expression.receiver, env:)
+          if (event_type = event_member_from_owner_type(receiver_type, expression.member))
+            return event_type
           end
-        end
-        if expression.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.receiver.name)
-          imported_module = @ctx.imports.fetch(expression.receiver.name)
-          return imported_module.values.fetch(expression.member).type if imported_module.values.key?(expression.member)
-          return imported_module.functions.fetch(expression.member).type if imported_module.functions.key?(expression.member)
-        end
-        receiver_type = infer_field_receiver_type(expression.receiver, env:)
-        if (event_type = event_member_from_owner_type(receiver_type, expression.member))
-          return event_type
-        end
 
-        if receiver_type == @ctx.types["field_handle"]
-          return infer_field_handle_member_type(expression)
-        end
-        if receiver_type == @ctx.types["member_handle"]
-          return infer_member_handle_member_type(expression)
-        end
+          if receiver_type == @ctx.types["field_handle"]
+            return infer_field_handle_member_type(expression)
+          end
+          if receiver_type == @ctx.types["member_handle"]
+            return infer_member_handle_member_type(expression)
+          end
 
-        return receiver_type.field(expression.member) if receiver_type.respond_to?(:field)
-        raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column)
-      when AST::IndexAccess
-        receiver_type = infer_expression_type(expression.receiver, env:)
-        index_type = infer_expression_type(expression.index, env:)
-        infer_index_result_type(receiver_type, index_type)
-      when AST::UnaryOp
-        return infer_result_propagation_type(expression, env:) if expression.operator == "?"
+          return receiver_type.field(expression.member) if receiver_type.respond_to?(:field)
+          raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column)
+        when AST::IndexAccess
+          receiver_type = infer_expression_type(expression.receiver, env:)
+          index_type = infer_expression_type(expression.index, env:)
+          infer_index_result_type(receiver_type, index_type)
+        when AST::UnaryOp
+          return infer_result_propagation_type(expression, env:) if expression.operator == "?"
+
+          operand_type = infer_expression_type(expression.operand, env:, expected_type:)
+          case expression.operator
+          when "not"
+            @ctx.types.fetch("bool")
+          else
+            operand_type
+          end
+        when AST::BinaryOp
+          left_type, right_type = infer_binary_operand_types(expression, env:, expected_type: expected_type)
+
+          case expression.operator
+          when "and", "or", "<", "<=", ">", ">=", "==", "!="
+            @ctx.types.fetch("bool")
+          when "+", "-", "*", "/"
+            aggregate_arithmetic_result_type(expression.operator, left_type, right_type) || pointer_arithmetic_result_type(expression.operator, left_type, right_type) || common_numeric_type(left_type, right_type) || left_type
+          when "%"
+            common_integer_type(left_type, right_type) || left_type
+          else
+            left_type
+          end
+        when AST::IfExpr
+          then_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: true, env:))
+          else_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: false, env:))
+          then_type = infer_expression_type(expression.then_expression, env: then_env, expected_type: expected_type)
+          else_type = infer_expression_type(expression.else_expression, env: else_env, expected_type: expected_type)
+
+          if expected_type &&
+              if_expression_branch_compatible?(then_type, expected_type) &&
+              if_expression_branch_compatible?(else_type, expected_type)
+            return expected_type
+          end
 
-        operand_type = infer_expression_type(expression.operand, env:, expected_type:)
-        case expression.operator
-        when "not"
-          @ctx.types.fetch("bool")
-        else
-          operand_type
-        end
-      when AST::BinaryOp
-        left_type, right_type = infer_binary_operand_types(expression, env:, expected_type: expected_type)
+          conditional_common_type(then_type, else_type) || raise(LoweringError, "if expression branches require compatible types, got #{then_type} and #{else_type}")
+        when AST::MatchExpr
+          scrutinee_type = infer_expression_type(expression.expression, env:)
+          arm_types = expression.arms.map do |arm|
+            arm_env = duplicate_env(env)
+            if scrutinee_type.is_a?(Types::Variant) && arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
+              arm_name = variant_match_arm_name_from_pattern(arm.pattern)
+              if arm_name && scrutinee_type.has_payload?(arm_name)
+                fields = scrutinee_type.arm(arm_name)
+                payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
+                arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: c_local_name(arm.binding_name), mutable: false, pointer: false)
+              end
+            end
+            infer_expression_type(arm.value, env: arm_env, expected_type: expected_type)
+          end
 
-        case expression.operator
-        when "and", "or", "<", "<=", ">", ">=", "==", "!="
-          @ctx.types.fetch("bool")
-        when "+", "-", "*", "/"
-          aggregate_arithmetic_result_type(expression.operator, left_type, right_type) || pointer_arithmetic_result_type(expression.operator, left_type, right_type) || common_numeric_type(left_type, right_type) || left_type
-        when "%"
-          common_integer_type(left_type, right_type) || left_type
-        else
-          left_type
-        end
-      when AST::IfExpr
-        then_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: true, env:))
-        else_env = env_with_refinements(env, flow_refinements(expression.condition, truthy: false, env:))
-        then_type = infer_expression_type(expression.then_expression, env: then_env, expected_type: expected_type)
-        else_type = infer_expression_type(expression.else_expression, env: else_env, expected_type: expected_type)
-
-        if expected_type &&
-            if_expression_branch_compatible?(then_type, expected_type) &&
-            if_expression_branch_compatible?(else_type, expected_type)
-          return expected_type
-        end
-
-        conditional_common_type(then_type, else_type) || raise(LoweringError, "if expression branches require compatible types, got #{then_type} and #{else_type}")
-      when AST::MatchExpr
-        scrutinee_type = infer_expression_type(expression.expression, env:)
-        arm_types = expression.arms.map do |arm|
-          arm_env = duplicate_env(env)
-          if scrutinee_type.is_a?(Types::Variant) && arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
-            arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-            if arm_name && scrutinee_type.has_payload?(arm_name)
-              fields = scrutinee_type.arm(arm_name)
-              payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
-              arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: c_local_name(arm.binding_name), mutable: false, pointer: false)
+          if expected_type && arm_types.all? { |arm_type| if_expression_branch_compatible?(arm_type, expected_type) }
+            return expected_type
+          end
+
+          common_type = arm_types.first
+          arm_types.drop(1).each do |arm_type|
+            common_type = conditional_common_type(common_type, arm_type) || raise(LoweringError, "match expression arms require compatible types, got #{common_type} and #{arm_type}")
+          end
+          common_type
+        when AST::UnsafeExpr
+          infer_expression_type(expression.expression, env:, expected_type:)
+        when AST::ProcExpr
+          resolve_type_ref(AST::ProcType.new(params: expression.params, return_type: expression.return_type))
+        when AST::Call
+          kind, _callee_name, _receiver, callee_type = resolve_callee(expression.callee, env, arguments: expression.arguments)
+          case kind
+          when :function, :method, :associated_method, :callable_value,
+            :str_buffer_clear, :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format,
+            :str_buffer_len, :str_buffer_capacity, :str_buffer_as_str, :str_buffer_as_cstr,
+            :event_subscribe, :event_subscribe_once, :event_unsubscribe, :event_emit, :event_wait,
+            :compile_time_builtin,
+            :reinterpret, :zero, :hash, :equal, :order,
+            :dyn_method
+            callee_type.return_type
+          when :struct_literal, :struct_with, :array, :simd, :variant_arm_ctor, :adapt
+            callee_type
+          when :ref_of
+            argument_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
+            Types::Registry.generic_instance("ref", [argument_type])
+          when :const_ptr_of
+            argument_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
+            Types::Registry.generic_instance("const_ptr", [argument_type])
+          when :read
+            infer_value_type(expression.arguments.fetch(0).value, env:)
+          when :ptr_of
+            argument_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
+            if ref_type?(argument_type)
+              Types::Registry.generic_instance("ptr", [referenced_type(argument_type)])
+            else
+              Types::Registry.generic_instance("ptr", [infer_expression_type(expression.arguments.fetch(0).value, env:, expected_type: expected_type && pointer_type?(expected_type) ? pointee_type(expected_type) : nil)])
             end
+          when :array_as_span
+            callee_type
+          when :fatal
+            @ctx.types.fetch("void")
+          when :get
+            receiver_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
+            elem_type = if array_type?(receiver_type)
+                          array_element_type(receiver_type)
+                        else
+                          receiver_type.element_type
+                        end
+            Types::Registry.nullable(Types::Registry.generic_instance("ptr", [elem_type]))
+          when :atomic_load, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_store, :atomic_compare_exchange,
+            :simd_lane_with
+            callee_type.return_type
+          else
+            raise LoweringError.new("unsupported call kind #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
-          infer_expression_type(arm.value, env: arm_env, expected_type: expected_type)
-        end
-
-        if expected_type && arm_types.all? { |arm_type| if_expression_branch_compatible?(arm_type, expected_type) }
-          return expected_type
-        end
-
-        common_type = arm_types.first
-        arm_types.drop(1).each do |arm_type|
-          common_type = conditional_common_type(common_type, arm_type) || raise(LoweringError, "match expression arms require compatible types, got #{common_type} and #{arm_type}")
-        end
-        common_type
-      when AST::UnsafeExpr
-        infer_expression_type(expression.expression, env:, expected_type:)
-      when AST::ProcExpr
-        resolve_type_ref(AST::ProcType.new(params: expression.params, return_type: expression.return_type))
-      when AST::Call
-        kind, _callee_name, _receiver, callee_type = resolve_callee(expression.callee, env, arguments: expression.arguments)
-        case kind
-        when :function, :method, :associated_method, :callable_value,
-          :str_buffer_clear, :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format,
-          :str_buffer_len, :str_buffer_capacity, :str_buffer_as_str, :str_buffer_as_cstr,
-          :event_subscribe, :event_subscribe_once, :event_unsubscribe, :event_emit, :event_wait,
-          :compile_time_builtin,
-          :reinterpret, :zero, :hash, :equal, :order,
-          :dyn_method
-          callee_type.return_type
-        when :struct_literal, :struct_with, :array, :simd, :variant_arm_ctor, :adapt
-          callee_type
-        when :ref_of
-          argument_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
-          Types::Registry.generic_instance("ref", [argument_type])
-        when :const_ptr_of
-          argument_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
-          Types::Registry.generic_instance("const_ptr", [argument_type])
-        when :read
-          infer_value_type(expression.arguments.fetch(0).value, env:)
-        when :ptr_of
-          argument_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
-          if ref_type?(argument_type)
-            Types::Registry.generic_instance("ptr", [referenced_type(argument_type)])
+        when AST::PrefixCast
+          resolve_type_ref(expression.target_type)
+        when AST::Specialization
+          if expression.callee.is_a?(AST::Identifier) && expression.callee.name == "zero"
+            _, _, _, function_type = resolve_callee(expression, env, arguments: [])
+            function_type.return_type
+          elsif expression.callee.is_a?(AST::Identifier) && expression.callee.name == "default"
+            resolve_default_specialization(expression, env:).target_type
+          elsif (callable_resolution = resolve_specialized_callable_binding(expression, env:))
+            callable_kind, function_binding, = callable_resolution
+            raise LoweringError.new("specialized method must be called", line: 0, column: 0, path: @ctx.current_analysis_path) if callable_kind == :method
+
+            function_binding.type
           else
-            Types::Registry.generic_instance("ptr", [infer_expression_type(expression.arguments.fetch(0).value, env:, expected_type: expected_type && pointer_type?(expected_type) ? pointee_type(expected_type) : nil)])
-          end
-        when :array_as_span
-          callee_type
-        when :fatal
-          @ctx.types.fetch("void")
-        when :get
-          receiver_type = infer_expression_type(expression.arguments.fetch(0).value, env:)
-          elem_type = if array_type?(receiver_type)
-                        array_element_type(receiver_type)
-                      else
-                        receiver_type.element_type
-                      end
-          Types::Registry.nullable(Types::Registry.generic_instance("ptr", [elem_type]))
-        when :atomic_load, :atomic_add, :atomic_sub, :atomic_exchange, :atomic_store, :atomic_compare_exchange,
-          :simd_lane_with
-          callee_type.return_type
+            raise LoweringError.new("unsupported specialization", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+        when AST::RangeExpr
+          raise LoweringError.new("range expression is not valid in this context; use it as a for-loop iterable", line: 0, column: 0, path: @ctx.current_analysis_path)
+        when AST::ExpressionList
+          names = []
+          element_types = []
+          expression.elements.each do |element|
+            if element.is_a?(AST::Argument)
+              names << element.name
+              element_types << infer_expression_type(element.value, env:)
+            else
+              names << nil
+              element_types << infer_expression_type(element, env:)
+            end
+          end
+          has_named = names.any?
+          Types::Registry.tuple(element_types, field_names: has_named ? names : nil)
+        when AST::DetachExpr
+          Types::Handle.new
         else
-          raise LoweringError.new("unsupported call kind #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-      when AST::PrefixCast
-        resolve_type_ref(expression.target_type)
-      when AST::Specialization
-        if expression.callee.is_a?(AST::Identifier) && expression.callee.name == "zero"
-          _, _, _, function_type = resolve_callee(expression, env, arguments: [])
-          function_type.return_type
-        elsif expression.callee.is_a?(AST::Identifier) && expression.callee.name == "default"
-          resolve_default_specialization(expression, env:).target_type
-        elsif (callable_resolution = resolve_specialized_callable_binding(expression, env:))
-          callable_kind, function_binding, = callable_resolution
-          raise LoweringError.new("specialized method must be called", line: 0, column: 0, path: @ctx.current_analysis_path) if callable_kind == :method
-
-          function_binding.type
+          raise LoweringError.new("unsupported expression type #{expression.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
+      end
+
+      def infer_binary_operand_types(expression, env:, expected_type: nil)
+        propagated_type = propagating_expected_type(expression.operator, expected_type)
+        left_type = infer_expression_type(expression.left, env:, expected_type: propagated_type)
+        right_env = binary_right_env(expression, env)
+        right_expected_type = case expression.operator
+                              when "<<", ">>"
+                                propagated_type || left_type
+                              when "+", "-", "*", "/", "%"
+                                propagated_type || left_type
+                              when "|", "&", "^"
+                                left_type
+                              else
+                                left_type
+                              end
+        right_type = infer_expression_type(expression.right, env: right_env, expected_type: right_expected_type)
+        left_type, right_type = harmonize_binary_float_literal_types(expression.left, expression.right, left_type, right_type, env: right_env)
+        harmonize_binary_integer_literal_types(expression.left, expression.right, left_type, right_type, env: right_env)
+      end
+
+      def binary_right_env(expression, env)
+        case expression.operator
+        when "and"
+          env_with_refinements(env, flow_refinements(expression.left, truthy: true, env:))
+        when "or"
+          env_with_refinements(env, flow_refinements(expression.left, truthy: false, env:))
         else
-          raise LoweringError.new("unsupported specialization", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-      when AST::RangeExpr
-        raise LoweringError.new("range expression is not valid in this context; use it as a for-loop iterable", line: 0, column: 0, path: @ctx.current_analysis_path)
-      when AST::ExpressionList
-        names = []
-        element_types = []
-        expression.elements.each do |element|
-          if element.is_a?(AST::Argument)
-            names << element.name
-            element_types << infer_expression_type(element.value, env:)
-          else
-            names << nil
-            element_types << infer_expression_type(element, env:)
-          end
+          env
         end
-        has_named = names.any?
-        Types::Registry.tuple(element_types, field_names: has_named ? names : nil)
-      when AST::DetachExpr
-        Types::Handle.new
-      else
-        raise LoweringError.new("unsupported expression type #{expression.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
-    end
 
-    def infer_binary_operand_types(expression, env:, expected_type: nil)
-      propagated_type = propagating_expected_type(expression.operator, expected_type)
-      left_type = infer_expression_type(expression.left, env:, expected_type: propagated_type)
-      right_env = binary_right_env(expression, env)
-      right_expected_type = case expression.operator
-                            when "<<", ">>"
-                              propagated_type || left_type
-                            when "+", "-", "*", "/", "%"
-                              propagated_type || left_type
-                            when "|", "&", "^"
-                              left_type
-                            else
-                              left_type
-                            end
-      right_type = infer_expression_type(expression.right, env: right_env, expected_type: right_expected_type)
-      left_type, right_type = harmonize_binary_float_literal_types(expression.left, expression.right, left_type, right_type, env: right_env)
-      harmonize_binary_integer_literal_types(expression.left, expression.right, left_type, right_type, env: right_env)
-    end
+      def harmonize_binary_float_literal_types(left_expression, right_expression, left_type, right_type, env:)
+        if float_literal_expression?(left_expression) && right_type.is_a?(Types::Primitive) && right_type.float?
+          left_type = infer_expression_type(left_expression, env:, expected_type: right_type)
+        end
 
-    def binary_right_env(expression, env)
-      case expression.operator
-      when "and"
-        env_with_refinements(env, flow_refinements(expression.left, truthy: true, env:))
-      when "or"
-        env_with_refinements(env, flow_refinements(expression.left, truthy: false, env:))
-      else
-        env
-      end
-    end
+        if float_literal_expression?(right_expression) && left_type.is_a?(Types::Primitive) && left_type.float?
+          right_type = infer_expression_type(right_expression, env:, expected_type: left_type)
+        end
 
-    def harmonize_binary_float_literal_types(left_expression, right_expression, left_type, right_type, env:)
-      if float_literal_expression?(left_expression) && right_type.is_a?(Types::Primitive) && right_type.float?
-        left_type = infer_expression_type(left_expression, env:, expected_type: right_type)
+        [left_type, right_type]
       end
 
-      if float_literal_expression?(right_expression) && left_type.is_a?(Types::Primitive) && left_type.float?
-        right_type = infer_expression_type(right_expression, env:, expected_type: left_type)
+      def float_literal_expression?(expression)
+        expression.is_a?(AST::FloatLiteral) ||
+          (expression.is_a?(AST::UnaryOp) && ["+", "-"].include?(expression.operator) && float_literal_expression?(expression.operand))
       end
 
-      [left_type, right_type]
-    end
+      def harmonize_binary_integer_literal_types(left_expression, right_expression, left_type, right_type, env:)
+        if integer_literal_expression?(left_expression) && right_type.is_a?(Types::Primitive) && right_type.integer?
+          if exact_compile_time_numeric_compatibility?(left_type, left_expression, right_type, env:)
+            left_type = infer_expression_type(left_expression, env:, expected_type: right_type)
+          end
+        end
 
-    def float_literal_expression?(expression)
-      expression.is_a?(AST::FloatLiteral) ||
-        (expression.is_a?(AST::UnaryOp) && ["+", "-"].include?(expression.operator) && float_literal_expression?(expression.operand))
-    end
+        if integer_literal_expression?(right_expression) && left_type.is_a?(Types::Primitive) && left_type.integer?
+          if exact_compile_time_numeric_compatibility?(right_type, right_expression, left_type, env:)
+            right_type = infer_expression_type(right_expression, env:, expected_type: left_type)
+          end
+        end
 
-    def harmonize_binary_integer_literal_types(left_expression, right_expression, left_type, right_type, env:)
-      if integer_literal_expression?(left_expression) && right_type.is_a?(Types::Primitive) && right_type.integer?
-        if exact_compile_time_numeric_compatibility?(left_type, left_expression, right_type, env:)
-          left_type = infer_expression_type(left_expression, env:, expected_type: right_type)
+        [left_type, right_type]
+      end
+
+      def integer_literal_expression?(expression)
+        expression.is_a?(AST::IntegerLiteral)
+      end
+
+      def propagating_expected_type(operator, expected_type)
+        case operator
+        when "+", "-", "*", "/", "%", "<<", ">>"
+          return expected_type if expected_type.is_a?(Types::Primitive) && expected_type.numeric?
+        when "|", "&", "^"
+          return expected_type if expected_type.is_a?(Types::Primitive) && expected_type.integer?
+          return expected_type if expected_type.is_a?(Types::Flags)
         end
+
+        nil
       end
 
-      if integer_literal_expression?(right_expression) && left_type.is_a?(Types::Primitive) && left_type.integer?
-        if exact_compile_time_numeric_compatibility?(right_type, right_expression, left_type, env:)
-          right_type = infer_expression_type(right_expression, env:, expected_type: left_type)
+      def promoted_binary_operand_type(operator, left_type, right_type)
+        case operator
+        when "+", "-", "*", "/", "<", "<=", ">", ">=", "==", "!="
+          common_numeric_type(left_type, right_type)
+        when "%"
+          common_integer_type(left_type, right_type)
         end
       end
 
-      [left_type, right_type]
-    end
+      def cast_expression(expression, target_type)
+        return expression if expression.type == target_type
 
-    def integer_literal_expression?(expression)
-      expression.is_a?(AST::IntegerLiteral)
-    end
+        IR::Cast.new(target_type:, expression:, type: target_type)
+      end
+
+      def pointer_lowered_sync_method_receiver?(binding)
+        return false if binding.async
 
-    def propagating_expected_type(operator, expected_type)
-      case operator
-      when "+", "-", "*", "/", "%", "<<", ">>"
-        return expected_type if expected_type.is_a?(Types::Primitive) && expected_type.numeric?
-      when "|", "&", "^"
-        return expected_type if expected_type.is_a?(Types::Primitive) && expected_type.integer?
-        return expected_type if expected_type.is_a?(Types::Flags)
+        pointer_lowered_method_receiver?(binding.type, binding)
       end
 
-      nil
-    end
+      def pointer_lowered_method_receiver?(callee_type, callee_binding)
+        return true if callee_type.receiver_editable
 
-    def promoted_binary_operand_type(operator, left_type, right_type)
-      case operator
-      when "+", "-", "*", "/", "<", "<=", ">", ">=", "==", "!="
-        common_numeric_type(left_type, right_type)
-      when "%"
-        common_integer_type(left_type, right_type)
+        receiver_type_uses_pointer_lowering?(callee_type.receiver_type) && !callee_binding&.async
       end
-    end
 
-    def cast_expression(expression, target_type)
-      return expression if expression.type == target_type
+      def receiver_type_uses_pointer_lowering?(type)
+        case type
+        when Types::Nullable
+          receiver_type_uses_pointer_lowering?(type.base)
+        when Types::Struct, Types::StructInstance
+          type_contains_array_storage?(type)
+        else
+          false
+        end
+      end
 
-      IR::Cast.new(target_type:, expression:, type: target_type)
-    end
+      def type_contains_array_storage?(type, visited = Set.new)
+        visitor = Types::ContainsArrayStorageVisitor.new
+        visitor.visit(type)
+        visitor.found?
+      end
 
-    def pointer_lowered_sync_method_receiver?(binding)
-      return false if binding.async
+      def reinterpret_expression(expression, target_type)
+        return expression if expression.type == target_type
 
-      pointer_lowered_method_receiver?(binding.type, binding)
-    end
+        IR::ReinterpretExpr.new(target_type:, source_type: expression.type, expression:, type: target_type)
+      end
 
-    def pointer_lowered_method_receiver?(callee_type, callee_binding)
-      return true if callee_type.receiver_editable
+      def foreign_identity_projection_expression(expression, target_type)
+        return expression if expression.type == target_type
+        return cast_expression(expression, target_type) if foreign_identity_projection_cast_compatible?(expression.type, target_type)
 
-      receiver_type_uses_pointer_lowering?(callee_type.receiver_type) && !callee_binding&.async
-    end
+        if foreign_identity_projection_reinterpret_compatible?(expression.type, target_type)
+          record_external_layout_assertion(expression.type, target_type)
+          return reinterpret_expression(expression, target_type)
+        end
 
-    def receiver_type_uses_pointer_lowering?(type)
-      case type
-      when Types::Nullable
-        receiver_type_uses_pointer_lowering?(type.base)
-      when Types::Struct, Types::StructInstance
-        type_contains_array_storage?(type)
-      else
-        false
+        nil
       end
-    end
 
-    def type_contains_array_storage?(type, visited = Set.new)
-      visitor = ContainsArrayStorageVisitor.new
-      visitor.visit(type)
-      visitor.found?
-    end
+      def record_external_layout_assertion(source_type, target_type)
+        source_root = ffi_external_layout_root_type(source_type)
+        target_root = ffi_external_layout_root_type(target_type)
+        return unless source_root && target_root
+        return unless source_root.external && target_root.external
+        return if source_root.module_name == target_root.module_name
 
-    def reinterpret_expression(expression, target_type)
-      return expression if expression.type == target_type
+        pair_key = [[source_root.module_name, source_root.name], [target_root.module_name, target_root.name]].sort.freeze
+        return if @artifacts.emitted_external_layout_pairs[pair_key]
 
-      IR::ReinterpretExpr.new(target_type:, source_type: expression.type, expression:, type: target_type)
-    end
+        @artifacts.emitted_external_layout_pairs[pair_key] = true
+        @artifacts.external_layout_assertions << IR::StaticAssert.new(
+          condition: IR::Binary.new(
+            operator: "==",
+            left: IR::SizeofExpr.new(target_type: source_root, type: @ctx.types.fetch("ptr_uint")),
+            right: IR::SizeofExpr.new(target_type: target_root, type: @ctx.types.fetch("ptr_uint")),
+            type: @ctx.types.fetch("bool"),
+          ),
+          message: IR::StringLiteral.new(
+            value: "FFI layout mismatch: #{source_root} vs #{target_root}",
+            type: @ctx.types.fetch("str"),
+            cstring: false,
+          ),
+        )
+      end
 
-    def foreign_identity_projection_expression(expression, target_type)
-      return expression if expression.type == target_type
-      return cast_expression(expression, target_type) if foreign_identity_projection_cast_compatible?(expression.type, target_type)
+      def ffi_external_layout_root_type(type)
+        type = type.base while type.is_a?(Types::Nullable)
+        return pointee_type(type) if pointer_type?(type)
 
-      if foreign_identity_projection_reinterpret_compatible?(expression.type, target_type)
-        record_external_layout_assertion(expression.type, target_type)
-        return reinterpret_expression(expression, target_type)
+        type
       end
 
-      nil
-    end
+      def infer_null_literal_type(expression, expected_type)
+        return Types::Null.new(resolve_type_ref(expression.type)) if expression.type
 
-    def record_external_layout_assertion(source_type, target_type)
-      source_root = ffi_external_layout_root_type(source_type)
-      target_root = ffi_external_layout_root_type(target_type)
-      return unless source_root && target_root
-      return unless source_root.external && target_root.external
-      return if source_root.module_name == target_root.module_name
-
-      pair_key = [[source_root.module_name, source_root.name], [target_root.module_name, target_root.name]].sort.freeze
-      return if @artifacts.emitted_external_layout_pairs[pair_key]
-
-      @artifacts.emitted_external_layout_pairs[pair_key] = true
-      @artifacts.external_layout_assertions << IR::StaticAssert.new(
-        condition: IR::Binary.new(
-          operator: "==",
-          left: IR::SizeofExpr.new(target_type: source_root, type: @ctx.types.fetch("ptr_uint")),
-          right: IR::SizeofExpr.new(target_type: target_root, type: @ctx.types.fetch("ptr_uint")),
-          type: @ctx.types.fetch("bool"),
-        ),
-        message: IR::StringLiteral.new(
-          value: "FFI layout mismatch: #{source_root} vs #{target_root}",
-          type: @ctx.types.fetch("str"),
-          cstring: false,
-        ),
-      )
-    end
+        expected_type || null_type
+      end
 
-    def ffi_external_layout_root_type(type)
-      type = type.base while type.is_a?(Types::Nullable)
-      return pointee_type(type) if pointer_type?(type)
+      def common_numeric_type(left_type, right_type)
+        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
+        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
+        return left_type if left_type == right_type
+        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
+        return unless left_type.numeric? && right_type.numeric?
 
-      type
-    end
+        return common_integer_type(left_type, right_type) if left_type.integer? && right_type.integer?
+        return wider_float_type(left_type, right_type) if left_type.float? && right_type.float?
 
-    def infer_null_literal_type(expression, expected_type)
-      return Types::Null.new(resolve_type_ref(expression.type)) if expression.type
+        float_type, integer_type = left_type.float? ? [left_type, right_type] : [right_type, left_type]
+        return unless integer_type.integer? && integer_type.fixed_width_integer?
 
-      expected_type || null_type
-    end
+        float_type
+      end
 
-    def common_numeric_type(left_type, right_type)
-      left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-      right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-      return left_type if left_type == right_type
-      return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-      return unless left_type.numeric? && right_type.numeric?
+      def common_integer_type(left_type, right_type)
+        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
+        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
+        return left_type if left_type == right_type
+        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
+        return unless left_type.integer? && right_type.integer?
+        return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
 
-      return common_integer_type(left_type, right_type) if left_type.integer? && right_type.integer?
-      return wider_float_type(left_type, right_type) if left_type.float? && right_type.float?
+        # Mirrors the semantic analyzer's rule: same signedness picks the wider
+        # type; mixed signed/unsigned promotes to the narrowest signed type that
+        # holds both operands' full ranges (a strictly-wider signed type covers
+        # an unsigned operand, otherwise widen to the next signed width). Mixing
+        # with a 64-bit unsigned type has no safe signed common type.
+        if left_type.signed_integer? == right_type.signed_integer?
+          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+        end
 
-      float_type, integer_type = left_type.float? ? [left_type, right_type] : [right_type, left_type]
-      return unless integer_type.integer? && integer_type.fixed_width_integer?
+        signed_type, unsigned_type = if left_type.signed_integer?
+          [left_type, right_type]
+        else
+          [right_type, left_type]
+        end
 
-      float_type
-    end
+        return signed_type if signed_type.integer_width > unsigned_type.integer_width
 
-    def common_integer_type(left_type, right_type)
-      left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-      right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-      return left_type if left_type == right_type
-      return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-      return unless left_type.integer? && right_type.integer?
-      return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
+        signed_type_above_width(unsigned_type.integer_width)
+      end
 
-      # Mirrors the semantic analyzer's rule: same signedness picks the wider
-      # type; mixed signed/unsigned promotes to the narrowest signed type that
-      # holds both operands' full ranges (a strictly-wider signed type covers
-      # an unsigned operand, otherwise widen to the next signed width). Mixing
-      # with a 64-bit unsigned type has no safe signed common type.
-      if left_type.signed_integer? == right_type.signed_integer?
-        return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+      def signed_type_above_width(width)
+        case width
+        when 8 then @ctx.types.fetch("short")
+        when 16 then @ctx.types.fetch("int")
+        when 32 then @ctx.types.fetch("long")
+        end
       end
 
-      signed_type, unsigned_type = if left_type.signed_integer?
-        [left_type, right_type]
-      else
-        [right_type, left_type]
+      def wider_float_type(left_type, right_type)
+        left_type.float_width >= right_type.float_width ? left_type : right_type
       end
 
-      return signed_type if signed_type.integer_width > unsigned_type.integer_width
+      def aggregate_arithmetic_result_type(operator, left_type, right_type)
+        if left_type.is_a?(Types::Vector) && right_type.is_a?(Types::Vector) && left_type.name == right_type.name
+          return left_type
+        end
+        if left_type.is_a?(Types::Matrix) && right_type.is_a?(Types::Matrix) && left_type.name == right_type.name
+          return left_type
+        end
+        if left_type.is_a?(Types::Quaternion) && right_type.is_a?(Types::Quaternion)
+          return left_type
+        end
 
-      signed_type_above_width(unsigned_type.integer_width)
-    end
+        scalar_result = aggregate_scalar_result(left_type, right_type)
+        return scalar_result if scalar_result
 
-    def signed_type_above_width(width)
-      case width
-      when 8 then @ctx.types.fetch("short")
-      when 16 then @ctx.types.fetch("int")
-      when 32 then @ctx.types.fetch("long")
+        case operator
+        when "+", "-"
+          nil
+        when "*", "/"
+          aggregate_scalar_result(right_type, left_type)
+        else
+          nil
+        end
       end
-    end
 
-    def wider_float_type(left_type, right_type)
-      left_type.float_width >= right_type.float_width ? left_type : right_type
-    end
+      def aggregate_scalar_result(aggregate_type, scalar_type)
+        return nil unless aggregate_type.is_a?(Types::Vector) || aggregate_type.is_a?(Types::Matrix)
+        return nil unless scalar_type.is_a?(Types::Primitive) && scalar_type.numeric?
 
-    def aggregate_arithmetic_result_type(operator, left_type, right_type)
-      if left_type.is_a?(Types::Vector) && right_type.is_a?(Types::Vector) && left_type.name == right_type.name
-        return left_type
-      end
-      if left_type.is_a?(Types::Matrix) && right_type.is_a?(Types::Matrix) && left_type.name == right_type.name
-        return left_type
-      end
-      if left_type.is_a?(Types::Quaternion) && right_type.is_a?(Types::Quaternion)
-        return left_type
+        aggregate_type
       end
 
-      scalar_result = aggregate_scalar_result(left_type, right_type)
-      return scalar_result if scalar_result
+      def pointer_arithmetic_result_type(operator, left_type, right_type)
+        return left_type if pointer_type?(left_type) && integer_type?(right_type) && (operator == "+" || operator == "-")
+        return right_type if operator == "+" && integer_type?(left_type) && pointer_type?(right_type)
 
-      case operator
-      when "+", "-"
-        nil
-      when "*", "/"
-        aggregate_scalar_result(right_type, left_type)
-      else
         nil
       end
-    end
 
-    def aggregate_scalar_result(aggregate_type, scalar_type)
-      return nil unless aggregate_type.is_a?(Types::Vector) || aggregate_type.is_a?(Types::Matrix)
-      return nil unless scalar_type.is_a?(Types::Primitive) && scalar_type.numeric?
+      def resolve_type_expression(expression)
+        case expression
+        when AST::Identifier
+          return current_type_params[expression.name] if current_type_params.key?(expression.name)
 
-      aggregate_type
-    end
+          @ctx.types[expression.name]
+        when AST::MemberAccess
+          return nil unless expression.receiver.is_a?(AST::Identifier)
 
-    def pointer_arithmetic_result_type(operator, left_type, right_type)
-      return left_type if pointer_type?(left_type) && integer_type?(right_type) && (operator == "+" || operator == "-")
-      return right_type if operator == "+" && integer_type?(left_type) && pointer_type?(right_type)
-
-      nil
-    end
+          if @ctx.imports.key?(expression.receiver.name)
+            return @ctx.imports.fetch(expression.receiver.name).types[expression.member]
+          end
 
-    def resolve_type_expression(expression)
-      case expression
-      when AST::Identifier
-        return current_type_params[expression.name] if current_type_params.key?(expression.name)
+          parent_type = @ctx.types[expression.receiver.name]
+          return parent_type.nested_types[expression.member] if parent_type.respond_to?(:nested_types) && parent_type.nested_types.key?(expression.member)
 
-        @ctx.types[expression.name]
-      when AST::MemberAccess
-        return nil unless expression.receiver.is_a?(AST::Identifier)
+          nil
+        when AST::Specialization
+          type_ref = type_ref_from_specialization(expression)
+          return nil unless type_ref
 
-        if @ctx.imports.key?(expression.receiver.name)
-          return @ctx.imports.fetch(expression.receiver.name).types[expression.member]
+          resolve_type_ref(type_ref)
         end
-
-        parent_type = @ctx.types[expression.receiver.name]
-        return parent_type.nested_types[expression.member] if parent_type.respond_to?(:nested_types) && parent_type.nested_types.key?(expression.member)
-
-        nil
-      when AST::Specialization
-        type_ref = type_ref_from_specialization(expression)
-        return nil unless type_ref
-
-        resolve_type_ref(type_ref)
       end
-    end
 
-    def resolve_type_member(type, name)
-      case type
-      when Types::Enum, Types::Flags
-        type.member(name)
-      when Types::Variant
-        type if type.arm_names.include?(name)
+      def resolve_type_member(type, name)
+        case type
+        when Types::Enum, Types::Flags
+          type.member(name)
+        when Types::Variant
+          type if type.arm_names.include?(name)
+        end
       end
-    end
 
-    def function_type_for_name(name)
-      binding = @ctx.functions.fetch(name)
-      raise LoweringError.new("generic function #{name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if binding.type_params.any?
-      raise LoweringError.new("foreign function #{name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_function_binding?(binding)
+      def function_type_for_name(name)
+        binding = @ctx.functions.fetch(name)
+        raise LoweringError.new("generic function #{name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if binding.type_params.any?
+        raise LoweringError.new("foreign function #{name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_function_binding?(binding)
 
-      binding.type
-    end
+        binding.type
+      end
 
-    def resolve_specialized_callable_binding(expression, env:)
-      callable_kind = :function
-      receiver = nil
-      receiver_type = nil
-      binding = case expression.callee
-                when AST::Identifier
-                  @ctx.functions[expression.callee.name]
-                when AST::MemberAccess
-                  if expression.callee.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.callee.receiver.name)
-                    @ctx.imports.fetch(expression.callee.receiver.name).functions[expression.callee.member]
-                  elsif (type_expr = resolve_type_expression(expression.callee.receiver))
-                    dispatch_receiver_type = method_dispatch_receiver_type(type_expr)
-                    method_entry_receiver_type = type_expr
-                    method_entry = @method_definitions[[type_expr, expression.callee.member]]
-                    method_entry ||= @method_definitions[[type_expr, "static:#{expression.callee.member}"]]
-                    unless method_entry || dispatch_receiver_type == type_expr
-                      method_entry_receiver_type = dispatch_receiver_type
-                      method_entry = @method_definitions[[dispatch_receiver_type, expression.callee.member]]
-                      method_entry ||= @method_definitions[[dispatch_receiver_type, "static:#{expression.callee.member}"]]
-                    end
-                    if method_entry
-                      method_analysis, method_ast = method_entry
-                      method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
-                      if method_binding.type.receiver_type.nil?
-                        receiver_type = type_expr
-                        method_binding
+      def resolve_specialized_callable_binding(expression, env:)
+        callable_kind = :function
+        receiver = nil
+        receiver_type = nil
+        binding = case expression.callee
+                  when AST::Identifier
+                    @ctx.functions[expression.callee.name]
+                  when AST::MemberAccess
+                    if expression.callee.receiver.is_a?(AST::Identifier) && @ctx.imports.key?(expression.callee.receiver.name)
+                      @ctx.imports.fetch(expression.callee.receiver.name).functions[expression.callee.member]
+                    elsif (type_expr = resolve_type_expression(expression.callee.receiver))
+                      dispatch_receiver_type = method_dispatch_receiver_type(type_expr)
+                      method_entry_receiver_type = type_expr
+                      method_entry = @method_definitions[[type_expr, expression.callee.member]]
+                      method_entry ||= @method_definitions[[type_expr, "static:#{expression.callee.member}"]]
+                      unless method_entry || dispatch_receiver_type == type_expr
+                        method_entry_receiver_type = dispatch_receiver_type
+                        method_entry = @method_definitions[[dispatch_receiver_type, expression.callee.member]]
+                        method_entry ||= @method_definitions[[dispatch_receiver_type, "static:#{expression.callee.member}"]]
+                      end
+                      if method_entry
+                        method_analysis, method_ast = method_entry
+                        method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
+                        if method_binding.type.receiver_type.nil?
+                          receiver_type = type_expr
+                          method_binding
+                        end
+                      end
+                    else
+                      resolved_receiver_type = infer_method_receiver_type(expression.callee.receiver, env:, member_name: expression.callee.member)
+                      dispatch_receiver_type = method_dispatch_receiver_type(resolved_receiver_type)
+                      method_entry_receiver_type = resolved_receiver_type
+                      method_entry = @method_definitions[[resolved_receiver_type, expression.callee.member]]
+                      unless method_entry || dispatch_receiver_type == resolved_receiver_type
+                        method_entry_receiver_type = dispatch_receiver_type
+                        method_entry = @method_definitions[[dispatch_receiver_type, expression.callee.member]]
+                      end
+                      if method_entry
+                        method_analysis, method_ast = method_entry
+                        callable_kind = :method
+                        receiver = expression.callee.receiver
+                        receiver_type = resolved_receiver_type
+                        method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
                       end
-                    end
-                  else
-                    resolved_receiver_type = infer_method_receiver_type(expression.callee.receiver, env:, member_name: expression.callee.member)
-                    dispatch_receiver_type = method_dispatch_receiver_type(resolved_receiver_type)
-                    method_entry_receiver_type = resolved_receiver_type
-                    method_entry = @method_definitions[[resolved_receiver_type, expression.callee.member]]
-                    unless method_entry || dispatch_receiver_type == resolved_receiver_type
-                      method_entry_receiver_type = dispatch_receiver_type
-                      method_entry = @method_definitions[[dispatch_receiver_type, expression.callee.member]]
-                    end
-                    if method_entry
-                      method_analysis, method_ast = method_entry
-                      callable_kind = :method
-                      receiver = expression.callee.receiver
-                      receiver_type = resolved_receiver_type
-                      method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
                     end
                   end
-                end
-      return nil unless binding
+        return nil unless binding
 
-      type_arguments = resolve_specialization_type_arguments(expression)
-      [callable_kind, instantiate_function_binding_with_receiver(binding, type_arguments, receiver_type:), receiver, method_entry_receiver_type]
-    end
+        type_arguments = resolve_specialization_type_arguments(expression)
+        [callable_kind, instantiate_function_binding_with_receiver(binding, type_arguments, receiver_type:), receiver, method_entry_receiver_type]
+      end
 
-    def resolve_default_specialization(expression, env:)
-      target_type = resolve_type_ref(expression.arguments.fetch(0).value)
+      def resolve_default_specialization(expression, env:)
+        target_type = resolve_type_ref(expression.arguments.fetch(0).value)
 
-      explicit_default = resolve_explicit_default_binding(target_type, context: "default[#{target_type}]")
-      raise LoweringError.new("default[#{target_type}] requires associated function #{target_type}.default()", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_default
+        explicit_default = resolve_explicit_default_binding(target_type, context: "default[#{target_type}]")
+        raise LoweringError.new("default[#{target_type}] requires associated function #{target_type}.default()", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_default
 
-      DefaultResolution.new(target_type:, binding: explicit_default.binding, callee_name: explicit_default.callee_name)
-    end
+        DefaultResolution.new(target_type:, binding: explicit_default.binding, callee_name: explicit_default.callee_name)
+      end
 
-    def resolve_hash_specialization(expression, env:)
-      target_type = resolve_type_ref(expression.arguments.fetch(0).value)
-      explicit_hash = resolve_explicit_hash_binding(target_type, context: "hash[#{target_type}]")
-      raise LoweringError.new("hash[#{target_type}] requires associated function #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_hash
+      def resolve_hash_specialization(expression, env:)
+        target_type = resolve_type_ref(expression.arguments.fetch(0).value)
+        explicit_hash = resolve_explicit_hash_binding(target_type, context: "hash[#{target_type}]")
+        raise LoweringError.new("hash[#{target_type}] requires associated function #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_hash
 
-      HashResolution.new(target_type:, binding: explicit_hash.binding, callee_name: explicit_hash.callee_name)
-    end
+        HashResolution.new(target_type:, binding: explicit_hash.binding, callee_name: explicit_hash.callee_name)
+      end
 
-    def resolve_equal_specialization(expression, env:)
-      target_type = resolve_type_ref(expression.arguments.fetch(0).value)
-      explicit_equal = resolve_explicit_equal_binding(target_type, context: "equal[#{target_type}]")
-      raise LoweringError.new("equal[#{target_type}] requires associated function #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_equal
+      def resolve_equal_specialization(expression, env:)
+        target_type = resolve_type_ref(expression.arguments.fetch(0).value)
+        explicit_equal = resolve_explicit_equal_binding(target_type, context: "equal[#{target_type}]")
+        raise LoweringError.new("equal[#{target_type}] requires associated function #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_equal
 
-      EqualResolution.new(target_type:, binding: explicit_equal.binding, callee_name: explicit_equal.callee_name)
-    end
+        EqualResolution.new(target_type:, binding: explicit_equal.binding, callee_name: explicit_equal.callee_name)
+      end
 
-    def resolve_order_specialization(expression, env:)
-      target_type = resolve_type_ref(expression.arguments.fetch(0).value)
-      explicit_order = resolve_explicit_order_binding(target_type, context: "order[#{target_type}]")
-      raise LoweringError.new("order[#{target_type}] requires associated function #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_order
+      def resolve_order_specialization(expression, env:)
+        target_type = resolve_type_ref(expression.arguments.fetch(0).value)
+        explicit_order = resolve_explicit_order_binding(target_type, context: "order[#{target_type}]")
+        raise LoweringError.new("order[#{target_type}] requires associated function #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int", line: 0, column: 0, path: @ctx.current_analysis_path) unless explicit_order
 
-      OrderResolution.new(target_type:, binding: explicit_order.binding, callee_name: explicit_order.callee_name)
-    end
+        OrderResolution.new(target_type:, binding: explicit_order.binding, callee_name: explicit_order.callee_name)
+      end
 
-    def resolve_explicit_default_binding(target_type, context:)
-      requirement_message = "#{context} requires associated function #{target_type}.default()"
-      resolve_explicit_associated_binding(target_type, "default", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
-        raise LoweringError.new("#{context} requires #{target_type}.default() to take 0 arguments", line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding.type.params.empty?
-        unless method_binding.type.return_type == target_type
-          raise LoweringError.new("#{context} requires #{target_type}.default() to return #{target_type}, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def resolve_explicit_default_binding(target_type, context:)
+        requirement_message = "#{context} requires associated function #{target_type}.default()"
+        resolve_explicit_associated_binding(target_type, "default", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
+          raise LoweringError.new("#{context} requires #{target_type}.default() to take 0 arguments", line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding.type.params.empty?
+          unless method_binding.type.return_type == target_type
+            raise LoweringError.new("#{context} requires #{target_type}.default() to return #{target_type}, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
         end
       end
-    end
 
-    def resolve_explicit_hash_binding(target_type, context:)
-      requirement_message = "#{context} requires associated function #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint"
-      resolve_explicit_associated_binding(target_type, "hash", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
-        unless method_binding.type.params.map(&:type) == [const_pointer_to(target_type)]
-          raise LoweringError.new("#{context} requires #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        unless method_binding.type.return_type == @ctx.types.fetch("uint")
-          raise LoweringError.new("#{context} requires #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def resolve_explicit_hash_binding(target_type, context:)
+        requirement_message = "#{context} requires associated function #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint"
+        resolve_explicit_associated_binding(target_type, "hash", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
+          unless method_binding.type.params.map(&:type) == [const_pointer_to(target_type)]
+            raise LoweringError.new("#{context} requires #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          unless method_binding.type.return_type == @ctx.types.fetch("uint")
+            raise LoweringError.new("#{context} requires #{target_type}.hash(value: const_ptr[#{target_type}]) -> uint, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
         end
       end
-    end
 
-    def resolve_explicit_equal_binding(target_type, context:)
-      requirement_message = "#{context} requires associated function #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool"
-      resolve_explicit_associated_binding(target_type, "equal", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
-        expected_param_types = [const_pointer_to(target_type), const_pointer_to(target_type)]
-        unless method_binding.type.params.map(&:type) == expected_param_types
-          raise LoweringError.new("#{context} requires #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        unless method_binding.type.return_type == @ctx.types.fetch("bool")
-          raise LoweringError.new("#{context} requires #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def resolve_explicit_equal_binding(target_type, context:)
+        requirement_message = "#{context} requires associated function #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool"
+        resolve_explicit_associated_binding(target_type, "equal", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
+          expected_param_types = [const_pointer_to(target_type), const_pointer_to(target_type)]
+          unless method_binding.type.params.map(&:type) == expected_param_types
+            raise LoweringError.new("#{context} requires #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          unless method_binding.type.return_type == @ctx.types.fetch("bool")
+            raise LoweringError.new("#{context} requires #{target_type}.equal(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> bool, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
         end
       end
-    end
 
-    def resolve_explicit_order_binding(target_type, context:)
-      requirement_message = "#{context} requires associated function #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int"
-      resolve_explicit_associated_binding(target_type, "order", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
-        expected_param_types = [const_pointer_to(target_type), const_pointer_to(target_type)]
-        unless method_binding.type.params.map(&:type) == expected_param_types
-          raise LoweringError.new("#{context} requires #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        unless method_binding.type.return_type == @ctx.types.fetch("int")
-          raise LoweringError.new("#{context} requires #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def resolve_explicit_order_binding(target_type, context:)
+        requirement_message = "#{context} requires associated function #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int"
+        resolve_explicit_associated_binding(target_type, "order", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
+          expected_param_types = [const_pointer_to(target_type), const_pointer_to(target_type)]
+          unless method_binding.type.params.map(&:type) == expected_param_types
+            raise LoweringError.new("#{context} requires #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          unless method_binding.type.return_type == @ctx.types.fetch("int")
+            raise LoweringError.new("#{context} requires #{target_type}.order(left: const_ptr[#{target_type}], right: const_ptr[#{target_type}]) -> int, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
         end
       end
-    end
 
-    def resolve_explicit_format_binding(target_type, context:)
-      length_binding = resolve_explicit_format_len_binding(target_type, context:)
-      append_binding = resolve_explicit_format_append_binding(target_type, context:)
+      def resolve_explicit_format_binding(target_type, context:)
+        length_binding = resolve_explicit_format_len_binding(target_type, context:)
+        append_binding = resolve_explicit_format_append_binding(target_type, context:)
 
-      return ExplicitFormatBinding.new(
-        length_binding: length_binding.fetch(:binding),
-        length_callee_name: length_binding.fetch(:callee_name),
-        append_binding: append_binding.fetch(:binding),
-        append_callee_name: append_binding.fetch(:callee_name),
-      ) if length_binding && append_binding
+        return ExplicitFormatBinding.new(
+          length_binding: length_binding.fetch(:binding),
+          length_callee_name: length_binding.fetch(:callee_name),
+          append_binding: append_binding.fetch(:binding),
+          append_callee_name: append_binding.fetch(:callee_name),
+        ) if length_binding && append_binding
 
-      if length_binding || append_binding
-        raise LoweringError.new("#{context} requires methods #{target_type}.format_len() -> ptr_uint and #{target_type}.append_format(output: ref[std.string.String]) -> void", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
+        if length_binding || append_binding
+          raise LoweringError.new("#{context} requires methods #{target_type}.format_len() -> ptr_uint and #{target_type}.append_format(output: ref[std.string.String]) -> void", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-      nil
-    end
+        nil
+      end
 
-    def resolve_explicit_format_len_binding(target_type, context:)
-      requirement_message = "#{context} requires method #{target_type}.format_len() -> ptr_uint"
-      resolve_explicit_instance_binding(target_type, "format_len", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
-        raise LoweringError.new("#{context} requires #{target_type}.format_len() to take 0 arguments", line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding.type.params.empty?
-        raise LoweringError.new("#{context} requires #{target_type}.format_len() to be non-editable", line: 0, column: 0, path: @ctx.current_analysis_path) if method_binding.type.receiver_editable
-        unless method_binding.type.return_type == @ctx.types.fetch("ptr_uint")
-          raise LoweringError.new("#{context} requires #{target_type}.format_len() -> ptr_uint, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def resolve_explicit_format_len_binding(target_type, context:)
+        requirement_message = "#{context} requires method #{target_type}.format_len() -> ptr_uint"
+        resolve_explicit_instance_binding(target_type, "format_len", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
+          raise LoweringError.new("#{context} requires #{target_type}.format_len() to take 0 arguments", line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding.type.params.empty?
+          raise LoweringError.new("#{context} requires #{target_type}.format_len() to be non-editable", line: 0, column: 0, path: @ctx.current_analysis_path) if method_binding.type.receiver_editable
+          unless method_binding.type.return_type == @ctx.types.fetch("ptr_uint")
+            raise LoweringError.new("#{context} requires #{target_type}.format_len() -> ptr_uint, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
         end
       end
-    end
 
-    def resolve_explicit_format_append_binding(target_type, context:)
-      requirement_message = "#{context} requires method #{target_type}.append_format(output: ref[std.string.String]) -> void"
-      resolve_explicit_instance_binding(target_type, "append_format", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
-        raise LoweringError.new("#{context} requires #{target_type}.append_format() to be non-editable", line: 0, column: 0, path: @ctx.current_analysis_path) if method_binding.type.receiver_editable
-        unless method_binding.type.params.length == 1 && string_builder_ref_type?(method_binding.type.params.first.type)
-          raise LoweringError.new("#{context} requires #{target_type}.append_format(output: ref[std.string.String]) -> void", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        unless method_binding.type.return_type == @ctx.types.fetch("void")
-          raise LoweringError.new("#{context} requires #{target_type}.append_format(output: ref[std.string.String]) -> void, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def resolve_explicit_format_append_binding(target_type, context:)
+        requirement_message = "#{context} requires method #{target_type}.append_format(output: ref[std.string.String]) -> void"
+        resolve_explicit_instance_binding(target_type, "append_format", requirement_message:) do |method_binding, _method_analysis, _method_entry_receiver_type|
+          raise LoweringError.new("#{context} requires #{target_type}.append_format() to be non-editable", line: 0, column: 0, path: @ctx.current_analysis_path) if method_binding.type.receiver_editable
+          unless method_binding.type.params.length == 1 && string_builder_ref_type?(method_binding.type.params.first.type)
+            raise LoweringError.new("#{context} requires #{target_type}.append_format(output: ref[std.string.String]) -> void", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          unless method_binding.type.return_type == @ctx.types.fetch("void")
+            raise LoweringError.new("#{context} requires #{target_type}.append_format(output: ref[std.string.String]) -> void, got #{method_binding.type.return_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
         end
       end
-    end
 
-    def method_analysis_key(method_ast)
-      method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name
-    end
-
-    def resolve_explicit_associated_binding(target_type, method_name, requirement_message:)
-      dispatch_receiver_type = method_dispatch_receiver_type(target_type)
-      method_entry_receiver_type = target_type
-      static_method_name = "static:#{method_name}"
-      method_entry = @method_definitions[[target_type, static_method_name]]
-      unless method_entry || dispatch_receiver_type == target_type
-        method_entry_receiver_type = dispatch_receiver_type
-        method_entry = @method_definitions[[dispatch_receiver_type, static_method_name]]
+      def method_analysis_key(method_ast)
+        method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name
       end
-      return nil unless method_entry
 
-      method_analysis, method_ast = method_entry
-      method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
-      raise LoweringError.new(requirement_message, line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding.type.receiver_type.nil?
+      def resolve_explicit_associated_binding(target_type, method_name, requirement_message:)
+        dispatch_receiver_type = method_dispatch_receiver_type(target_type)
+        method_entry_receiver_type = target_type
+        static_method_name = "static:#{method_name}"
+        method_entry = @method_definitions[[target_type, static_method_name]]
+        unless method_entry || dispatch_receiver_type == target_type
+          method_entry_receiver_type = dispatch_receiver_type
+          method_entry = @method_definitions[[dispatch_receiver_type, static_method_name]]
+        end
+        return nil unless method_entry
 
-      method_binding = instantiate_function_binding_with_receiver(method_binding, [], receiver_type: target_type) if method_binding.type_params.any?
-      yield method_binding, method_analysis, method_entry_receiver_type
+        method_analysis, method_ast = method_entry
+        method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
+        raise LoweringError.new(requirement_message, line: 0, column: 0, path: @ctx.current_analysis_path) unless method_binding.type.receiver_type.nil?
 
-      callee_name = if method_binding.external
-                      external_function_c_name(method_binding)
-                    else
-                      function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type)
-                    end
+        method_binding = instantiate_function_binding_with_receiver(method_binding, [], receiver_type: target_type) if method_binding.type_params.any?
+        yield method_binding, method_analysis, method_entry_receiver_type
 
-      case method_name
-      when "default"
-        ExplicitDefaultBinding.new(binding: method_binding, callee_name:)
-      when "hash"
-        ExplicitHashBinding.new(binding: method_binding, callee_name:)
-      when "equal"
-        ExplicitEqualBinding.new(binding: method_binding, callee_name:)
-      when "order"
-        ExplicitOrderBinding.new(binding: method_binding, callee_name:)
-      else
-        raise LoweringError.new("unsupported associated hook #{method_name}", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
-    end
+        callee_name = if method_binding.external
+                        external_function_c_name(method_binding)
+                      else
+                        function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type)
+                      end
 
-    def resolve_explicit_instance_binding(target_type, method_name, requirement_message:)
-      dispatch_receiver_type = method_dispatch_receiver_type(target_type)
-      method_entry_receiver_type = target_type
-      method_entry = @method_definitions[[target_type, method_name]]
-      unless method_entry || dispatch_receiver_type == target_type
-        method_entry_receiver_type = dispatch_receiver_type
-        method_entry = @method_definitions[[dispatch_receiver_type, method_name]]
+        case method_name
+        when "default"
+          ExplicitDefaultBinding.new(binding: method_binding, callee_name:)
+        when "hash"
+          ExplicitHashBinding.new(binding: method_binding, callee_name:)
+        when "equal"
+          ExplicitEqualBinding.new(binding: method_binding, callee_name:)
+        when "order"
+          ExplicitOrderBinding.new(binding: method_binding, callee_name:)
+        else
+          raise LoweringError.new("unsupported associated hook #{method_name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
       end
-      return nil unless method_entry
 
-      method_analysis, method_ast = method_entry
-      method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
-      raise LoweringError.new(requirement_message, line: 0, column: 0, path: @ctx.current_analysis_path) if method_binding.type.receiver_type.nil?
+      def resolve_explicit_instance_binding(target_type, method_name, requirement_message:)
+        dispatch_receiver_type = method_dispatch_receiver_type(target_type)
+        method_entry_receiver_type = target_type
+        method_entry = @method_definitions[[target_type, method_name]]
+        unless method_entry || dispatch_receiver_type == target_type
+          method_entry_receiver_type = dispatch_receiver_type
+          method_entry = @method_definitions[[dispatch_receiver_type, method_name]]
+        end
+        return nil unless method_entry
 
-      method_binding = instantiate_function_binding_with_receiver(method_binding, [], receiver_type: target_type) if method_binding.type_params.any?
-      yield method_binding, method_analysis, method_entry_receiver_type
+        method_analysis, method_ast = method_entry
+        method_binding = method_analysis.methods.fetch(method_entry_receiver_type).fetch(method_analysis_key(method_ast))
+        raise LoweringError.new(requirement_message, line: 0, column: 0, path: @ctx.current_analysis_path) if method_binding.type.receiver_type.nil?
 
-      callee_name = if method_binding.external
-                      external_function_c_name(method_binding)
-                    else
-                      function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type)
-                    end
+        method_binding = instantiate_function_binding_with_receiver(method_binding, [], receiver_type: target_type) if method_binding.type_params.any?
+        yield method_binding, method_analysis, method_entry_receiver_type
 
-      {
-        binding: method_binding,
-        callee_name: callee_name,
-      }
-    end
+        callee_name = if method_binding.external
+                        external_function_c_name(method_binding)
+                      else
+                        function_binding_c_name(method_binding, module_name: method_analysis.module_name, receiver_type: method_entry_receiver_type)
+                      end
 
-    def resolve_specialization_type_arguments(expression)
-      expression.arguments.map do |argument|
-        resolve_type_argument(argument.value)
+        {
+          binding: method_binding,
+          callee_name: callee_name,
+        }
       end
-    end
 
-    def resolve_type_argument(argument, type_params: current_type_params)
-      case argument
-      when AST::TypeRef
-        resolve_type_argument_ref(argument, type_params:)
-      when AST::FunctionType, AST::ProcType, AST::TupleType
-        resolve_type_ref(argument, type_params:)
-      when AST::IntegerLiteral, AST::FloatLiteral
-        Types::LiteralTypeArg.new(argument.value)
-      else
-        raise LoweringError.new("unsupported type argument #{argument.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def resolve_specialization_type_arguments(expression)
+        expression.arguments.map do |argument|
+          resolve_type_argument(argument.value)
+        end
       end
-    end
 
-    def resolve_type_argument_ref(type_ref, type_params:)
-      return resolve_type_ref(type_ref, type_params:) unless literal_type_argument_name_candidate?(type_ref)
+      def resolve_type_argument(argument, type_params: current_type_params)
+        case argument
+        when AST::TypeRef
+          resolve_type_argument_ref(argument, type_params:)
+        when AST::FunctionType, AST::ProcType, AST::TupleType
+          resolve_type_ref(argument, type_params:)
+        when AST::IntegerLiteral, AST::FloatLiteral
+          Types::LiteralTypeArg.new(argument.value)
+        else
+          raise LoweringError.new("unsupported type argument #{argument.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
+      end
 
-      result = try_resolve_type_ref(type_ref, type_params:)
-      return result if result
+      def resolve_type_argument_ref(type_ref, type_params:)
+        return resolve_type_ref(type_ref, type_params:) unless literal_type_argument_name_candidate?(type_ref)
 
-      literal_type_argument = resolve_named_literal_type_argument(type_ref)
-      return literal_type_argument if literal_type_argument
+        result = try_resolve_type_ref(type_ref, type_params:)
+        return result if result
 
-      resolve_type_ref(type_ref, type_params:)
-    end
+        literal_type_argument = resolve_named_literal_type_argument(type_ref)
+        return literal_type_argument if literal_type_argument
 
-    def try_resolve_type_ref(type_ref, type_params:)
-      resolve_type_ref(type_ref, type_params:)
-    rescue LoweringError
-      nil
-    end
+        resolve_type_ref(type_ref, type_params:)
+      end
 
-    def literal_type_argument_name_candidate?(type_ref)
-      type_ref.arguments.empty? && !type_ref.nullable
-    end
+      def try_resolve_type_ref(type_ref, type_params:)
+        resolve_type_ref(type_ref, type_params:)
+      rescue LoweringError
+        nil
+      end
 
-    def resolve_named_literal_type_argument(type_ref)
-      value = case type_ref.name.parts.length
-              when 1
-                resolve_current_module_const_value(type_ref.name.parts.first)
-              when 2
-                resolve_imported_module_const_value(type_ref.name.parts.first, type_ref.name.parts.last)
-              end
+      def literal_type_argument_name_candidate?(type_ref)
+        type_ref.arguments.empty? && !type_ref.nullable
+      end
 
-      return unless value.is_a?(Integer) || value.is_a?(Float)
+      def resolve_named_literal_type_argument(type_ref)
+        value = case type_ref.name.parts.length
+                when 1
+                  resolve_current_module_const_value(type_ref.name.parts.first)
+                when 2
+                  resolve_imported_module_const_value(type_ref.name.parts.first, type_ref.name.parts.last)
+                end
 
-      Types::LiteralTypeArg.new(value)
-    end
+        return unless value.is_a?(Integer) || value.is_a?(Float)
 
-    def resolve_current_module_const_value(name)
-      binding = @ctx.values[name]
-      return unless binding&.kind == :const
+        Types::LiteralTypeArg.new(value)
+      end
 
-      binding.const_value
-    end
+      def resolve_current_module_const_value(name)
+        binding = @ctx.values[name]
+        return unless binding&.kind == :const
 
-    def resolve_imported_module_const_value(import_name, value_name)
-      imported_module = @ctx.imports[import_name]
-      return unless imported_module
-      if imported_module.private_value?(value_name)
-        raise LoweringError.new("#{import_name}.#{value_name} is private to module #{imported_module.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        binding.const_value
       end
 
-      binding = imported_module.values[value_name]
-      return unless binding&.kind == :const
+      def resolve_imported_module_const_value(import_name, value_name)
+        imported_module = @ctx.imports[import_name]
+        return unless imported_module
+        if imported_module.private_value?(value_name)
+          raise LoweringError.new("#{import_name}.#{value_name} is private to module #{imported_module.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-      binding.const_value
-    end
+        binding = imported_module.values[value_name]
+        return unless binding&.kind == :const
 
-    def resolve_type_member_const_value(expression)
-      type = resolve_type_expression(expression.receiver)
-      return unless type.is_a?(Types::EnumBase)
+        binding.const_value
+      end
 
-      type.member_value(expression.member)
-    end
+      def resolve_type_member_const_value(expression)
+        type = resolve_type_expression(expression.receiver)
+        return unless type.is_a?(Types::EnumBase)
 
-    def compile_time_numeric_const_expression?(expression, env: nil)
-      value = compile_time_const_value(expression, env:)
-      value.is_a?(Integer) || value.is_a?(Float)
-    end
+        type.member_value(expression.member)
+      end
 
-    def compile_time_const_value(expression, env: nil)
-      CompileTime.evaluate(
-        expression,
-        resolve_identifier: lambda do |identifier_expression|
-          if env
-            binding = lookup_value(identifier_expression.name, env)
-            return binding[:const_value] unless binding&.fetch(:const_value, nil).nil?
-          end
-
-          value = resolve_current_module_const_value(identifier_expression.name)
-          return value if value
-
-          # Resolve a bare type-parameter name (e.g. `T`) to its substituted
-          # concrete type so `inline if T == int` folds during lowering too.
-          current_type_params[identifier_expression.name] || @ctx.types[identifier_expression.name]
-        end,
-        resolve_member_access: lambda do |member_access_expression|
-          if (receiver_value = CompileTime.evaluate(
-                member_access_expression.receiver,
-                resolve_identifier: lambda do |identifier_expression|
-                  if env
-                    binding = lookup_value(identifier_expression.name, env)
-                    return binding[:const_value] unless binding&.fetch(:const_value, nil).nil?
-                  end
-                  resolve_current_module_const_value(identifier_expression.name)
-                end,
-                resolve_member_access: lambda { |ma| nil },
-                resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
-                resolve_call: lambda { |ce| evaluate_compile_time_call(ce, env:) },
-              ))
-            case receiver_value
-            when Types::FieldHandle
-              case member_access_expression.member
-              when "name" then next receiver_value.field_name
-              when "type" then next receiver_value.struct_handle.struct_type.field(receiver_value.field_name)
-              end
-            when Types::MemberHandle
-              case member_access_expression.member
-              when "name" then next receiver_value.member_name
-              when "value" then next receiver_value.member_value
-              end
+      def compile_time_numeric_const_expression?(expression, env: nil)
+        value = compile_time_const_value(expression, env:)
+        value.is_a?(Integer) || value.is_a?(Float)
+      end
+
+      def compile_time_const_value(expression, env: nil)
+        CompileTime.evaluate(
+          expression,
+          resolve_identifier: lambda do |identifier_expression|
+            if env
+              binding = lookup_value(identifier_expression.name, env)
+              return binding[:const_value] unless binding&.fetch(:const_value, nil).nil?
             end
-          end
 
-          value = if member_access_expression.receiver.is_a?(AST::Identifier)
-                    resolve_imported_module_const_value(member_access_expression.receiver.name, member_access_expression.member)
-                  end
-          next value unless value.nil?
+            value = resolve_current_module_const_value(identifier_expression.name)
+            return value if value
+
+            # Resolve a bare type-parameter name (e.g. `T`) to its substituted
+            # concrete type so `inline if T == int` folds during lowering too.
+            current_type_params[identifier_expression.name] || @ctx.types[identifier_expression.name]
+          end,
+          resolve_member_access: lambda do |member_access_expression|
+            if (receiver_value = CompileTime.evaluate(
+                  member_access_expression.receiver,
+                  resolve_identifier: lambda do |identifier_expression|
+                    if env
+                      binding = lookup_value(identifier_expression.name, env)
+                      return binding[:const_value] unless binding&.fetch(:const_value, nil).nil?
+                    end
+                    resolve_current_module_const_value(identifier_expression.name)
+                  end,
+                  resolve_member_access: lambda { |ma| nil },
+                  resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
+                  resolve_call: lambda { |ce| evaluate_compile_time_call(ce, env:) },
+                ))
+              case receiver_value
+              when Types::FieldHandle
+                case member_access_expression.member
+                when "name" then next receiver_value.field_name
+                when "type" then next receiver_value.struct_handle.struct_type.field(receiver_value.field_name)
+                end
+              when Types::MemberHandle
+                case member_access_expression.member
+                when "name" then next receiver_value.member_name
+                when "value" then next receiver_value.member_value
+                end
+              end
+            end
 
-          resolve_type_member_const_value(member_access_expression)
-        end,
-        resolve_type_ref: lambda do |type_ref|
-          resolve_type_ref(type_ref)
-        end,
-        resolve_call: lambda do |call_expression|
-          evaluate_compile_time_call(call_expression, env:)
-        end,
-      )
-    end
+            value = if member_access_expression.receiver.is_a?(AST::Identifier)
+                      resolve_imported_module_const_value(member_access_expression.receiver.name, member_access_expression.member)
+                    end
+            next value unless value.nil?
+
+            resolve_type_member_const_value(member_access_expression)
+          end,
+          resolve_type_ref: lambda do |type_ref|
+            resolve_type_ref(type_ref)
+          end,
+          resolve_call: lambda do |call_expression|
+            evaluate_compile_time_call(call_expression, env:)
+          end,
+        )
+      end
 
-    def evaluate_compile_time_call(expression, env:)
-      case expression.callee
-      when AST::Identifier
-        case expression.callee.name
-        when "field_of"
-          evaluate_field_of_call(expression.arguments, env:)
-        when "fields_of"
-          evaluate_fields_of_call(expression.arguments, env:)
-        when "callable_of"
-          evaluate_callable_of_call(expression.arguments)
-        when "has_attribute"
-          evaluate_has_attribute_call(expression.arguments, env:)
-        when "attribute_of"
-          evaluate_attribute_of_call(expression.arguments, env:)
-        when "members_of"
-          evaluate_members_of_call(expression.arguments, env:)
-        when "attributes_of"
-          evaluate_attributes_of_call(expression.arguments, env:)
-        else
-          func = @ctx.functions[expression.callee.name]
-          if func&.ast&.respond_to?(:const) && func.ast.const
-            evaluate_const_function_body_lower(func, expression.arguments)
+      def evaluate_compile_time_call(expression, env:)
+        case expression.callee
+        when AST::Identifier
+          case expression.callee.name
+          when "field_of"
+            evaluate_field_of_call(expression.arguments, env:)
+          when "fields_of"
+            evaluate_fields_of_call(expression.arguments, env:)
+          when "callable_of"
+            evaluate_callable_of_call(expression.arguments)
+          when "has_attribute"
+            evaluate_has_attribute_call(expression.arguments, env:)
+          when "attribute_of"
+            evaluate_attribute_of_call(expression.arguments, env:)
+          when "members_of"
+            evaluate_members_of_call(expression.arguments, env:)
+          when "attributes_of"
+            evaluate_attributes_of_call(expression.arguments, env:)
           else
-            evaluate_type_returning_call(expression, env:)
-          end
-        end
-      when AST::Specialization
-        if expression.callee.callee.is_a?(AST::Identifier) && expression.callee.callee.name == "attribute_arg"
-          evaluate_attribute_arg_call(expression.arguments, env:)
-        else
-          callee_name = expression.callee.callee.is_a?(AST::Identifier) ? expression.callee.callee.name : nil
-          if callee_name
-            func = @ctx.functions[callee_name]
+            func = @ctx.functions[expression.callee.name]
             if func&.ast&.respond_to?(:const) && func.ast.const
               evaluate_const_function_body_lower(func, expression.arguments)
             else
               evaluate_type_returning_call(expression, env:)
             end
-          else
-            evaluate_type_returning_call(expression, env:)
+          end
+        when AST::Specialization
+          if expression.callee.callee.is_a?(AST::Identifier) && expression.callee.callee.name == "attribute_arg"
+            evaluate_attribute_arg_call(expression.arguments, env:)
+          else
+            callee_name = expression.callee.callee.is_a?(AST::Identifier) ? expression.callee.callee.name : nil
+            if callee_name
+              func = @ctx.functions[callee_name]
+              if func&.ast&.respond_to?(:const) && func.ast.const
+                evaluate_const_function_body_lower(func, expression.arguments)
+              else
+                evaluate_type_returning_call(expression, env:)
+              end
+            else
+              evaluate_type_returning_call(expression, env:)
+            end
           end
         end
       end
-    end
 
-    def evaluate_type_returning_call(expression, env:)
-      callee_name, type_args = extract_type_callee_info(expression)
-      return nil unless callee_name
-
-      CompileTime::Reflection.core_evaluate_type_returning(
-        callee_name, type_args,
-        evaluate_value: ->(v) { compile_time_const_value(v, env:) },
-        resolve_type_ref: ->(tr) { resolve_type_ref(tr) },
-        pointer_to: ->(t) { pointer_to(t) },
-        const_pointer_to: ->(t) { const_pointer_to(t) },
-        top_level_functions: ->(name) { nil },
-        evaluate_type_returning_function_body: nil,
-      )
-    end
+      def evaluate_type_returning_call(expression, env:)
+        callee_name, type_args = extract_type_callee_info(expression)
+        return nil unless callee_name
+
+        CompileTime::Reflection.core_evaluate_type_returning(
+          callee_name, type_args,
+          evaluate_value: ->(v) { compile_time_const_value(v, env:) },
+          resolve_type_ref: ->(tr) { resolve_type_ref(tr) },
+          pointer_to: ->(t) { pointer_to(t) },
+          const_pointer_to: ->(t) { const_pointer_to(t) },
+          top_level_functions: ->(name) { nil },
+          evaluate_type_returning_function_body: nil,
+        )
+      end
 
-    def extract_type_callee_info(expression)
-      if expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier)
-        [expression.callee.name, nil]
-      elsif expression.is_a?(AST::Specialization)
-        if expression.callee.is_a?(AST::Identifier)
-          [expression.callee.name, expression.arguments]
-        elsif expression.callee.is_a?(AST::Specialization) && expression.callee.callee.is_a?(AST::Identifier)
-          [expression.callee.callee.name, expression.callee.arguments]
+      def extract_type_callee_info(expression)
+        if expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier)
+          [expression.callee.name, nil]
+        elsif expression.is_a?(AST::Specialization)
+          if expression.callee.is_a?(AST::Identifier)
+            [expression.callee.name, expression.arguments]
+          elsif expression.callee.is_a?(AST::Specialization) && expression.callee.callee.is_a?(AST::Identifier)
+            [expression.callee.callee.name, expression.callee.arguments]
+          end
         end
       end
-    end
 
-    def evaluate_field_of_call(arguments, env:)
-      return nil unless reflection_positional_arguments?(arguments, 2)
+      def evaluate_field_of_call(arguments, env:)
+        return nil unless reflection_positional_arguments?(arguments, 2)
 
-      struct_handle = resolve_struct_handle_argument(arguments.first.value, env:)
-      return nil unless struct_handle
+        struct_handle = resolve_struct_handle_argument(arguments.first.value, env:)
+        return nil unless struct_handle
 
-      field_name = reflection_identifier_name(arguments[1].value)
-      return nil unless field_name
+        field_name = reflection_identifier_name(arguments[1].value)
+        return nil unless field_name
 
-      CompileTime::Reflection.core_field_handle(struct_handle, field_name)
-    end
+        CompileTime::Reflection.core_field_handle(struct_handle, field_name)
+      end
 
-    def evaluate_fields_of_call(arguments, env:)
-      return nil unless reflection_positional_arguments?(arguments, 1)
+      def evaluate_fields_of_call(arguments, env:)
+        return nil unless reflection_positional_arguments?(arguments, 1)
 
-      struct_handle = resolve_struct_handle_argument(arguments.first.value, env:)
-      return nil unless struct_handle
+        struct_handle = resolve_struct_handle_argument(arguments.first.value, env:)
+        return nil unless struct_handle
 
-      CompileTime::Reflection.core_field_handles(struct_handle)
-    end
+        CompileTime::Reflection.core_field_handles(struct_handle)
+      end
 
-    def evaluate_members_of_call(arguments, env:)
-      return nil unless reflection_positional_arguments?(arguments, 1)
+      def evaluate_members_of_call(arguments, env:)
+        return nil unless reflection_positional_arguments?(arguments, 1)
 
-      type = resolve_type_expression(arguments.first.value)
-      return nil unless type
+        type = resolve_type_expression(arguments.first.value)
+        return nil unless type
 
-      return nil unless type.is_a?(Types::Enum) || type.is_a?(Types::Flags)
+        return nil unless type.is_a?(Types::Enum) || type.is_a?(Types::Flags)
 
-      CompileTime::Reflection.core_member_handles(type)
-    end
+        CompileTime::Reflection.core_member_handles(type)
+      end
 
-    def evaluate_attributes_of_call(arguments, env:)
-      return nil unless reflection_positional_arguments?(arguments, 1) || reflection_positional_arguments?(arguments, 2)
+      def evaluate_attributes_of_call(arguments, env:)
+        return nil unless reflection_positional_arguments?(arguments, 1) || reflection_positional_arguments?(arguments, 2)
 
-      target = evaluate_reflection_target_argument(arguments.first.value, env:)
-      return nil unless target
+        target = evaluate_reflection_target_argument(arguments.first.value, env:)
+        return nil unless target
 
-      if arguments.length == 2
-        attribute_binding = resolve_attribute_name_argument(arguments[1].value)
-        application = find_attribute_application(target, attribute_binding)
-        return [] unless application
+        if arguments.length == 2
+          attribute_binding = resolve_attribute_name_argument(arguments[1].value)
+          application = find_attribute_application(target, attribute_binding)
+          return [] unless application
 
-        [Types::AttributeHandle.new(
-          attribute_binding.name,
-          attribute_binding.module_name,
-          target,
-          attribute_binding.params,
-          application.argument_values,
-        )]
-      else
-        resolved_attribute_applications_for_target(target).map do |application|
-          Types::AttributeHandle.new(
-            application.binding.name,
-            application.binding.module_name,
+          [Types::AttributeHandle.new(
+            attribute_binding.name,
+            attribute_binding.module_name,
             target,
-            application.binding.params,
+            attribute_binding.params,
             application.argument_values,
-          )
+          )]
+        else
+          resolved_attribute_applications_for_target(target).map do |application|
+            Types::AttributeHandle.new(
+              application.binding.name,
+              application.binding.module_name,
+              target,
+              application.binding.params,
+              application.argument_values,
+            )
+          end
         end
       end
-    end
-
-    def evaluate_callable_of_call(arguments)
-      return nil unless reflection_positional_arguments?(arguments, 1)
 
-      resolve_callable_handle_argument(arguments.first.value)
-    end
+      def evaluate_callable_of_call(arguments)
+        return nil unless reflection_positional_arguments?(arguments, 1)
 
-    def evaluate_has_attribute_call(arguments, env:)
-      return nil unless reflection_positional_arguments?(arguments, 2)
+        resolve_callable_handle_argument(arguments.first.value)
+      end
 
-      target = evaluate_reflection_target_argument(arguments.first.value, env:)
-      binding = resolve_attribute_name_argument(arguments[1].value)
-      return nil unless attribute_binding_supports_target?(binding, target)
+      def evaluate_has_attribute_call(arguments, env:)
+        return nil unless reflection_positional_arguments?(arguments, 2)
 
-      !find_attribute_application(target, binding).nil?
-    end
+        target = evaluate_reflection_target_argument(arguments.first.value, env:)
+        binding = resolve_attribute_name_argument(arguments[1].value)
+        return nil unless attribute_binding_supports_target?(binding, target)
 
-    def evaluate_attribute_of_call(arguments, env:)
-      return nil unless reflection_positional_arguments?(arguments, 2)
+        !find_attribute_application(target, binding).nil?
+      end
 
-      target = evaluate_reflection_target_argument(arguments.first.value, env:)
-      binding = resolve_attribute_name_argument(arguments[1].value)
-      return nil unless attribute_binding_supports_target?(binding, target)
+      def evaluate_attribute_of_call(arguments, env:)
+        return nil unless reflection_positional_arguments?(arguments, 2)
 
-      application = find_attribute_application(target, binding)
-      return nil unless application
+        target = evaluate_reflection_target_argument(arguments.first.value, env:)
+        binding = resolve_attribute_name_argument(arguments[1].value)
+        return nil unless attribute_binding_supports_target?(binding, target)
 
-      Types::AttributeHandle.new(
-        binding.name,
-        binding.module_name,
-        target,
-        binding.params,
-        application.argument_values,
-      )
-    end
+        application = find_attribute_application(target, binding)
+        return nil unless application
 
-    def evaluate_attribute_arg_call(arguments, env:)
-      return nil unless reflection_positional_arguments?(arguments, 2)
+        Types::AttributeHandle.new(
+          binding.name,
+          binding.module_name,
+          target,
+          binding.params,
+          application.argument_values,
+        )
+      end
 
-      attribute_handle = compile_time_const_value(arguments.first.value, env:)
-      return nil unless attribute_handle.is_a?(Types::AttributeHandle)
+      def evaluate_attribute_arg_call(arguments, env:)
+        return nil unless reflection_positional_arguments?(arguments, 2)
 
-      param_name = reflection_identifier_name(arguments[1].value)
-      return nil unless param_name && attribute_handle.argument_values
+        attribute_handle = compile_time_const_value(arguments.first.value, env:)
+        return nil unless attribute_handle.is_a?(Types::AttributeHandle)
 
-      attribute_handle.argument_values[param_name]
-    end
+        param_name = reflection_identifier_name(arguments[1].value)
+        return nil unless param_name && attribute_handle.argument_values
 
-    def evaluate_const_function_body_lower(func, arguments)
-      return nil unless func.ast.params.length == arguments.length
+        attribute_handle.argument_values[param_name]
+      end
 
-      initial_vars = {}
-      func.ast.params.each_with_index do |param, idx|
-        arg_expr = arguments[idx].value
-        arg_value = compile_time_const_value(arg_expr, env: empty_env)
-        return nil unless arg_value
+      def evaluate_const_function_body_lower(func, arguments)
+        return nil unless func.ast.params.length == arguments.length
 
-        initial_vars[param.name] = arg_value
-      end
+        initial_vars = {}
+        func.ast.params.each_with_index do |param, idx|
+          arg_expr = arguments[idx].value
+          arg_value = compile_time_const_value(arg_expr, env: empty_env)
+          return nil unless arg_value
 
-      evaluator = ConstFnLowerEvaluator.new(self)
-      ctx = CompileTime::BlockContext.new(evaluator, initial_variables: initial_vars)
-      ctx.evaluate_block(func.ast.body, scopes: nil)
-    rescue CompileTime::ReturnValue => e
-      e.value
-    end
+          initial_vars[param.name] = arg_value
+        end
 
-    class ConstFnLowerEvaluator
-      def initialize(lowerer)
-        @lowerer = lowerer
+        evaluator = ConstFnLowerEvaluator.new(self)
+        ctx = CompileTime::BlockContext.new(evaluator, initial_variables: initial_vars)
+        ctx.evaluate_block(func.ast.body, scopes: nil)
+      rescue CompileTime::ReturnValue => e
+        e.value
       end
 
-      def types
-        @lowerer.instance_variable_get(:@ctx).types
-      end
+      class ConstFnLowerEvaluator
+        def initialize(lowerer)
+          @lowerer = lowerer
+        end
 
-      def evaluate_compile_time_const_value(expression, scopes: nil)
-        @lowerer.compile_time_const_value(expression, env: @lowerer.empty_env)
-      end
+        def types
+          @lowerer.instance_variable_get(:@ctx).types
+        end
 
-      def top_level_function(name)
-        @lowerer.instance_variable_get(:@ctx).functions&.[](name)
-      end
+        def evaluate_compile_time_const_value(expression, scopes: nil)
+          @lowerer.compile_time_const_value(expression, env: @lowerer.empty_env)
+        end
+
+        def top_level_function(name)
+          @lowerer.instance_variable_get(:@ctx).functions&.[](name)
+        end
 
-      def raise_sema_error(message)
-        raise CompileTime::Error, message
+        def raise_sema_error(message)
+          raise CompileTime::Error, message
+        end
       end
-    end
 
-    def evaluate_reflection_target_argument(expression, env:)
-      struct_handle = resolve_struct_handle_argument(expression, env:)
-      return struct_handle if struct_handle
+      def evaluate_reflection_target_argument(expression, env:)
+        struct_handle = resolve_struct_handle_argument(expression, env:)
+        return struct_handle if struct_handle
 
-      value = compile_time_const_value(expression, env:)
-      return value if value.is_a?(Types::FieldHandle) || value.is_a?(Types::CallableHandle)
+        value = compile_time_const_value(expression, env:)
+        return value if value.is_a?(Types::FieldHandle) || value.is_a?(Types::CallableHandle)
 
-      nil
-    end
+        nil
+      end
 
-    def reflection_positional_arguments?(arguments, expected_length)
-      arguments.length == expected_length && arguments.none?(&:name)
-    end
+      def reflection_positional_arguments?(arguments, expected_length)
+        arguments.length == expected_length && arguments.none?(&:name)
+      end
 
-    def resolve_struct_handle_argument(expression, env:)
-      type = reflection_type_from_expression(expression, env:)
-      return nil unless type
+      def resolve_struct_handle_argument(expression, env:)
+        type = reflection_type_from_expression(expression, env:)
+        return nil unless type
 
-      struct_handle_for_type(type)
-    end
+        struct_handle_for_type(type)
+      end
 
-    def reflection_type_from_expression(expression, env:)
-      case expression
-      when AST::Identifier
-        return nil if env && lookup_value(expression.name, env)
+      def reflection_type_from_expression(expression, env:)
+        case expression
+        when AST::Identifier
+          return nil if env && lookup_value(expression.name, env)
 
-        current_type_params[expression.name] || @ctx.types[expression.name]
-      when AST::MemberAccess
-        return nil unless expression.receiver.is_a?(AST::Identifier)
+          current_type_params[expression.name] || @ctx.types[expression.name]
+        when AST::MemberAccess
+          return nil unless expression.receiver.is_a?(AST::Identifier)
 
-        if @ctx.imports.key?(expression.receiver.name)
-          imported_module = @ctx.imports[expression.receiver.name]
-          return nil if imported_module.private_type?(expression.member)
-          return imported_module.types[expression.member]
-        end
+          if @ctx.imports.key?(expression.receiver.name)
+            imported_module = @ctx.imports[expression.receiver.name]
+            return nil if imported_module.private_type?(expression.member)
+            return imported_module.types[expression.member]
+          end
 
-        parent_type = @ctx.types[expression.receiver.name]
-        return parent_type.nested_types[expression.member] if parent_type.respond_to?(:nested_types) && parent_type.nested_types.key?(expression.member)
+          parent_type = @ctx.types[expression.receiver.name]
+          return parent_type.nested_types[expression.member] if parent_type.respond_to?(:nested_types) && parent_type.nested_types.key?(expression.member)
 
-        nil
-      else
-        nil
+          nil
+        else
+          nil
+        end
       end
-    end
 
-    def struct_handle_for_type(type)
-      base_type = type.is_a?(Types::StructInstance) ? type.definition : type
-      return nil unless base_type.is_a?(Types::Struct) || base_type.is_a?(Types::GenericStructDefinition)
-      return nil unless base_type.respond_to?(:module_name)
+      def struct_handle_for_type(type)
+        base_type = type.is_a?(Types::StructInstance) ? type.definition : type
+        return nil unless base_type.is_a?(Types::Struct) || base_type.is_a?(Types::GenericStructDefinition)
+        return nil unless base_type.respond_to?(:module_name)
 
-      analysis = analysis_for_module(base_type.module_name)
-      declaration = find_struct_decl_by_name(analysis.ast.declarations, base_type.name)
-      return nil unless declaration
+        analysis = analysis_for_module(base_type.module_name)
+        declaration = find_struct_decl_by_name(analysis.ast.declarations, base_type.name)
+        return nil unless declaration
 
-      Types::StructHandle.new(base_type, declaration)
-    end
+        Types::StructHandle.new(base_type, declaration)
+      end
 
-    def find_struct_decl_by_name(declarations, name)
-      declarations.each do |decl|
-        next unless decl.is_a?(AST::StructDecl)
-        return decl if decl.name == name
-        if decl.nested_types&.any?
-          found = find_struct_decl_by_name(decl.nested_types, name)
-          return found if found
+      def find_struct_decl_by_name(declarations, name)
+        declarations.each do |decl|
+          next unless decl.is_a?(AST::StructDecl)
+          return decl if decl.name == name
+          if decl.nested_types&.any?
+            found = find_struct_decl_by_name(decl.nested_types, name)
+            return found if found
+          end
         end
+        nil
       end
-      nil
-    end
 
-    def resolve_callable_handle_argument(expression)
-      case expression
-      when AST::Identifier
-        binding = @ctx.functions[expression.name]
-        return nil unless binding&.ast
+      def resolve_callable_handle_argument(expression)
+        case expression
+        when AST::Identifier
+          binding = @ctx.functions[expression.name]
+          return nil unless binding&.ast
 
-        Types::CallableHandle.new(expression.name, binding.ast)
-      when AST::MemberAccess
-        return nil unless expression.receiver.is_a?(AST::Identifier)
+          Types::CallableHandle.new(expression.name, binding.ast)
+        when AST::MemberAccess
+          return nil unless expression.receiver.is_a?(AST::Identifier)
 
-        imported_module = @ctx.imports[expression.receiver.name]
-        return nil unless imported_module
-        return nil if imported_module.private_function?(expression.member)
+          imported_module = @ctx.imports[expression.receiver.name]
+          return nil unless imported_module
+          return nil if imported_module.private_function?(expression.member)
 
-        binding = imported_module.functions[expression.member]
-        return nil unless binding&.ast
+          binding = imported_module.functions[expression.member]
+          return nil unless binding&.ast
 
-        Types::CallableHandle.new("#{expression.receiver.name}.#{expression.member}", binding.ast)
-      else
-        nil
+          Types::CallableHandle.new("#{expression.receiver.name}.#{expression.member}", binding.ast)
+        else
+          nil
+        end
       end
-    end
 
-    def resolve_attribute_name_argument(expression)
-      case expression
-      when AST::Identifier
-        @ctx.attributes[expression.name] || builtin_attribute_binding(expression.name)
-      when AST::MemberAccess
-        return nil unless expression.receiver.is_a?(AST::Identifier)
+      def resolve_attribute_name_argument(expression)
+        case expression
+        when AST::Identifier
+          @ctx.attributes[expression.name] || builtin_attribute_binding(expression.name)
+        when AST::MemberAccess
+          return nil unless expression.receiver.is_a?(AST::Identifier)
 
-        imported_module = @ctx.imports[expression.receiver.name]
-        return nil unless imported_module
-        return nil if imported_module.private_attribute?(expression.member)
+          imported_module = @ctx.imports[expression.receiver.name]
+          return nil unless imported_module
+          return nil if imported_module.private_attribute?(expression.member)
 
-        imported_module.attributes[expression.member]
-      else
-        nil
+          imported_module.attributes[expression.member]
+        else
+          nil
+        end
       end
-    end
 
-    def reflection_identifier_name(expression)
-      expression.is_a?(AST::Identifier) ? expression.name : nil
-    end
-
-    def attribute_binding_supports_target?(binding, target)
-      binding && target && binding.targets.include?(attribute_target_kind(target))
-    end
+      def reflection_identifier_name(expression)
+        expression.is_a?(AST::Identifier) ? expression.name : nil
+      end
 
-    def attribute_target_kind(target)
-      case target
-      when Types::StructHandle then :struct
-      when Types::FieldHandle then :field
-      when Types::CallableHandle then :callable
+      def attribute_binding_supports_target?(binding, target)
+        binding && target && binding.targets.include?(attribute_target_kind(target))
       end
-    end
 
-    def resolved_attribute_applications_for_target(target)
-      target_id = case target
-      when Types::StructHandle then target.declaration.object_id
-      when Types::FieldHandle then target.field_declaration.object_id
-      when Types::CallableHandle then target.declaration.object_id
+      def attribute_target_kind(target)
+        case target
+        when Types::StructHandle then :struct
+        when Types::FieldHandle then :field
+        when Types::CallableHandle then :callable
+        end
       end
-      return [] unless target_id
 
-      applications = @ctx.attribute_applications[target_id]
-      return applications if applications
+      def resolved_attribute_applications_for_target(target)
+        target_id = case target
+        when Types::StructHandle then target.declaration.object_id
+        when Types::FieldHandle then target.field_declaration.object_id
+        when Types::CallableHandle then target.declaration.object_id
+        end
+        return [] unless target_id
 
-      @ctx.imports.each_value do |imported_module|
-        applications = imported_module.attribute_applications[target_id]
+        applications = @ctx.attribute_applications[target_id]
         return applications if applications
-      end
 
-      []
-    end
+        @ctx.imports.each_value do |imported_module|
+          applications = imported_module.attribute_applications[target_id]
+          return applications if applications
+        end
 
-    def find_attribute_application(target, binding)
-      resolved_attribute_applications_for_target(target).find do |application|
-        same_attribute_binding?(application.binding, binding)
+        []
       end
-    end
-
-    def same_attribute_binding?(left, right)
-      left.name == right.name && left.module_name == right.module_name
-    end
-
-    def builtin_attribute_binding(name)
-      MilkTea.builtin_attribute_binding(name, @ctx.types)
-    end
-
-    def specialize_function_binding(binding, arguments, env, receiver_type: nil)
-      return binding if binding.type_params.empty?
-      raise LoweringError.new("generic function #{binding.name} must be called", line: 0, column: 0, path: @ctx.current_analysis_path) unless arguments
 
-      type_arguments = infer_function_type_arguments(binding, arguments, env, receiver_type:)
-      instantiate_function_binding(binding, type_arguments)
-    end
-
-    def instantiate_function_binding_with_receiver(binding, explicit_type_arguments, receiver_type: nil)
-      if binding.type_params.empty?
-        raise LoweringError.new("function #{binding.name} is not generic and cannot be specialized", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def find_attribute_application(target, binding)
+        resolved_attribute_applications_for_target(target).find do |application|
+          same_attribute_binding?(application.binding, binding)
+        end
       end
 
-      receiver_substitutions = infer_receiver_type_substitutions(binding, receiver_type)
-      remaining_type_params = binding.type_params.reject { |name| receiver_substitutions.key?(name) }
-      unless remaining_type_params.length == explicit_type_arguments.length
-        raise LoweringError.new("function #{binding.name} expects #{remaining_type_params.length} type arguments, got #{explicit_type_arguments.length}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def same_attribute_binding?(left, right)
+        left.name == right.name && left.module_name == right.module_name
       end
 
-      substitutions = receiver_substitutions.dup
-      remaining_type_params.zip(explicit_type_arguments).each do |name, type_argument|
-        raise LoweringError.new("generic function #{binding.name} cannot be instantiated with ref types", line: 0, column: 0, path: @ctx.current_analysis_path) if contains_ref_type?(type_argument)
-
-        substitutions[name] = type_argument
+      def builtin_attribute_binding(name)
+        Bindings.builtin_attribute_binding(name, @ctx.types)
       end
 
-      type_arguments = binding.type_params.map do |name|
-        inferred = substitutions[name]
-        raise LoweringError.new("cannot infer type argument #{name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless inferred
+      def specialize_function_binding(binding, arguments, env, receiver_type: nil)
+        return binding if binding.type_params.empty?
+        raise LoweringError.new("generic function #{binding.name} must be called", line: 0, column: 0, path: @ctx.current_analysis_path) unless arguments
 
-        inferred
+        type_arguments = infer_function_type_arguments(binding, arguments, env, receiver_type:)
+        instantiate_function_binding(binding, type_arguments)
       end
 
-      instantiate_function_binding(binding, type_arguments)
-    end
+      def instantiate_function_binding_with_receiver(binding, explicit_type_arguments, receiver_type: nil)
+        if binding.type_params.empty?
+          raise LoweringError.new("function #{binding.name} is not generic and cannot be specialized", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-    def instantiate_function_binding(binding, type_arguments)
-      if binding.type_params.empty?
-        raise LoweringError.new("function #{binding.name} is not generic and cannot be specialized", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
-
-      unless binding.type_params.length == type_arguments.length
-        raise LoweringError.new("function #{binding.name} expects #{binding.type_params.length} type arguments, got #{type_arguments.length}", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
-
-      if type_arguments.any? { |type_argument| contains_ref_type?(type_argument) }
-        raise LoweringError.new("generic function #{binding.name} cannot be instantiated with ref types", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
-
-      key = type_arguments.freeze
-      return binding.instances.fetch(key) if binding.instances.key?(key)
-
-      substitutions = binding.type_params.zip(type_arguments).to_h
-      validate_function_type_param_constraints!(binding, substitutions)
-      instance = FunctionBinding.new(
-        name: binding.name,
-        type: substitute_type(binding.type, substitutions),
-        body_params: binding.body_params.map { |param| substitute_value_binding(param, substitutions) },
-        body_return_type: substitute_type(binding.body_return_type, substitutions),
-        ast: binding.ast,
-        external: binding.external,
-        async: binding.async,
-        type_params: [].freeze,
-        type_param_constraints: {}.freeze,
-        instances: {},
-        type_arguments: key,
-        owner: binding.owner,
-        specialization_owner: nil,
-        type_substitutions: substitutions.freeze,
-        declared_receiver_type: binding.declared_receiver_type ? substitute_type(binding.declared_receiver_type, substitutions) : nil,
-      )
-      binding.instances[key] = instance
-    end
+        receiver_substitutions = infer_receiver_type_substitutions(binding, receiver_type)
+        remaining_type_params = binding.type_params.reject { |name| receiver_substitutions.key?(name) }
+        unless remaining_type_params.length == explicit_type_arguments.length
+          raise LoweringError.new("function #{binding.name} expects #{remaining_type_params.length} type arguments, got #{explicit_type_arguments.length}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-    def validate_function_type_param_constraints!(binding, substitutions)
-      binding.type_param_constraints.each do |name, constraints|
-        actual_type = substitutions[name]
-        raise LoweringError.new("cannot infer type argument #{name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless actual_type
+        substitutions = receiver_substitutions.dup
+        remaining_type_params.zip(explicit_type_arguments).each do |name, type_argument|
+          raise LoweringError.new("generic function #{binding.name} cannot be instantiated with ref types", line: 0, column: 0, path: @ctx.current_analysis_path) if contains_ref_type?(type_argument)
 
-        constraints.interfaces.each do |interface|
-          next if type_implements_interface?(actual_type, interface)
+          substitutions[name] = type_argument
+        end
+
+        type_arguments = binding.type_params.map do |name|
+          inferred = substitutions[name]
+          raise LoweringError.new("cannot infer type argument #{name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless inferred
 
-          raise LoweringError.new("type #{actual_type} does not implement interface #{interface.name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          inferred
         end
+
+        instantiate_function_binding(binding, type_arguments)
       end
-    end
 
+      def instantiate_function_binding(binding, type_arguments)
+        if binding.type_params.empty?
+          raise LoweringError.new("function #{binding.name} is not generic and cannot be specialized", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-    def interface_implementation_key(type)
-      return type.definition if type.is_a?(Types::StructInstance)
+        unless binding.type_params.length == type_arguments.length
+          raise LoweringError.new("function #{binding.name} expects #{binding.type_params.length} type arguments, got #{type_arguments.length}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-      type
-    end
+        if type_arguments.any? { |type_argument| contains_ref_type?(type_argument) }
+          raise LoweringError.new("generic function #{binding.name} cannot be instantiated with ref types", line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
 
-    def type_implements_interface?(type, interface)
-      key = interface_implementation_key(type)
-      return true if @ctx.implemented_interfaces.fetch(key, []).include?(interface)
+        key = type_arguments.freeze
+        return binding.instances.fetch(key) if binding.instances.key?(key)
 
-      @ctx.imports.each_value do |module_binding|
-        return true if module_binding.implemented_interfaces.fetch(key, []).include?(interface)
+        substitutions = binding.type_params.zip(type_arguments).to_h
+        validate_function_type_param_constraints!(binding, substitutions)
+        instance = Bindings::FunctionBinding.new(
+          name: binding.name,
+          type: substitute_type(binding.type, substitutions),
+          body_params: binding.body_params.map { |param| substitute_value_binding(param, substitutions) },
+          body_return_type: substitute_type(binding.body_return_type, substitutions),
+          ast: binding.ast,
+          external: binding.external,
+          async: binding.async,
+          type_params: [].freeze,
+          type_param_constraints: {}.freeze,
+          instances: {},
+          type_arguments: key,
+          owner: binding.owner,
+          specialization_owner: nil,
+          type_substitutions: substitutions.freeze,
+          declared_receiver_type: binding.declared_receiver_type ? substitute_type(binding.declared_receiver_type, substitutions) : nil,
+        )
+        binding.instances[key] = instance
       end
 
-      false
-    end
+      def validate_function_type_param_constraints!(binding, substitutions)
+        binding.type_param_constraints.each do |name, constraints|
+          actual_type = substitutions[name]
+          raise LoweringError.new("cannot infer type argument #{name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless actual_type
 
-    def infer_function_type_arguments(binding, arguments, env, receiver_type: nil)
-      expected_params = binding.type.params
-      unless call_arity_matches?(binding.type, arguments.length)
-        raise LoweringError.new(arity_error_message(binding.type, binding.name, arguments.length), line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
+          constraints.interfaces.each do |interface|
+            next if type_implements_interface?(actual_type, interface)
 
-      substitutions = infer_receiver_type_substitutions(binding, receiver_type)
-      expected_params.each_with_index do |parameter, index|
-        argument = arguments.fetch(index)
-        candidate_type = substitute_type(parameter.type, substitutions)
-        expected_argument_type = if callable_type?(candidate_type)
-                                    candidate_type
-                                  elsif contains_type_var?(candidate_type)
-                                    nil
-                                  else
-                                    candidate_type
-                                  end
-        actual_type = infer_expression_type(argument.value, env:, expected_type: expected_argument_type)
-        collect_type_substitutions(parameter.type, actual_type, substitutions, binding.name)
+            raise LoweringError.new("type #{actual_type} does not implement interface #{interface.name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+        end
       end
 
-      binding.type_params.map do |name|
-        inferred = substitutions[name]
-        raise LoweringError.new("cannot infer type argument #{name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless inferred
 
-        inferred
+      def interface_implementation_key(type)
+        return type.definition if type.is_a?(Types::StructInstance)
+
+        type
       end
-    end
 
+      def type_implements_interface?(type, interface)
+        key = interface_implementation_key(type)
+        return true if @ctx.implemented_interfaces.fetch(key, []).include?(interface)
 
+        @ctx.imports.each_value do |module_binding|
+          return true if module_binding.implemented_interfaces.fetch(key, []).include?(interface)
+        end
 
-    def resolve_named_generic_type_for_analysis(analysis, parts)
-      if parts.length == 1
-        type = analysis.types[parts.first]
-        return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
-      elsif parts.length == 2 && analysis.imports.key?(parts.first)
-        type = analysis.imports.fetch(parts.first).types[parts.last]
-        return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+        false
       end
 
-      nil
-    end
+      def infer_function_type_arguments(binding, arguments, env, receiver_type: nil)
+        expected_params = binding.type.params
+        unless call_arity_matches?(binding.type, arguments.length)
+          raise LoweringError.new(arity_error_message(binding.type, binding.name, arguments.length), line: 0, column: 0, path: @ctx.current_analysis_path)
+        end
+
+        substitutions = infer_receiver_type_substitutions(binding, receiver_type)
+        expected_params.each_with_index do |parameter, index|
+          argument = arguments.fetch(index)
+          candidate_type = substitute_type(parameter.type, substitutions)
+          expected_argument_type = if callable_type?(candidate_type)
+                                      candidate_type
+                                    elsif contains_type_var?(candidate_type)
+                                      nil
+                                    else
+                                      candidate_type
+                                    end
+          actual_type = infer_expression_type(argument.value, env:, expected_type: expected_argument_type)
+          collect_type_substitutions(parameter.type, actual_type, substitutions, binding.name)
+        end
 
-    def validate_methods_receiver_type_arguments!(type_ref, generic_type)
-      names = type_ref.arguments.map do |argument|
-        value = argument.value
-        next unless value.is_a?(AST::TypeRef)
-        next unless value.arguments.empty? && !value.nullable && value.name.parts.length == 1
+        binding.type_params.map do |name|
+          inferred = substitutions[name]
+          raise LoweringError.new("cannot infer type argument #{name} for function #{binding.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless inferred
 
-        value.name.parts.first
+          inferred
+        end
       end
 
-      expected_names = generic_type.type_params
-      unless names == expected_names
-        raise LoweringError.new("extending target #{type_ref} must use the receiver type parameters directly", line: 0, column: 0, path: @ctx.current_analysis_path)
-      end
 
-      expected_names
-    end
 
-    def methods_receiver_type_argument_names!(type_ref)
-      names = type_ref.arguments.map do |argument|
-        value = argument.value
-        next unless value.is_a?(AST::TypeRef)
-        next unless value.arguments.empty? && !value.nullable && value.name.parts.length == 1
+      def resolve_named_generic_type_for_analysis(analysis, parts)
+        if parts.length == 1
+          type = analysis.types[parts.first]
+          return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+        elsif parts.length == 2 && analysis.imports.key?(parts.first)
+          type = analysis.imports.fetch(parts.first).types[parts.last]
+          return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+        end
 
-        value.name.parts.first
+        nil
       end
 
-      raise LoweringError.new("extending target #{type_ref} must use the receiver type parameters directly", line: 0, column: 0, path: @ctx.current_analysis_path) if names.any?(&:nil?)
+      def validate_methods_receiver_type_arguments!(type_ref, generic_type)
+        names = type_ref.arguments.map do |argument|
+          value = argument.value
+          next unless value.is_a?(AST::TypeRef)
+          next unless value.arguments.empty? && !value.nullable && value.name.parts.length == 1
 
-      names
-    end
+          value.name.parts.first
+        end
 
-    def infer_receiver_type_substitutions(binding, receiver_type)
-      declared_receiver_type = binding.declared_receiver_type
-      return {} unless declared_receiver_type
-      case declared_receiver_type
-      when Types::Nullable
-        unless receiver_type.is_a?(Types::Nullable)
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        expected_names = generic_type.type_params
+        unless names == expected_names
+          raise LoweringError.new("extending target #{type_ref} must use the receiver type parameters directly", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
-        infer_receiver_type_substitutions(
-          binding.with(declared_receiver_type: declared_receiver_type.base),
-          receiver_type.base,
-        )
-      when Types::StructInstance
-        return {} unless declared_receiver_type.definition.is_a?(Types::GenericStructDefinition)
+        expected_names
+      end
 
-        unless receiver_type.is_a?(Types::StructInstance) && receiver_type.definition == declared_receiver_type.definition
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      def methods_receiver_type_argument_names!(type_ref)
+        names = type_ref.arguments.map do |argument|
+          value = argument.value
+          next unless value.is_a?(AST::TypeRef)
+          next unless value.arguments.empty? && !value.nullable && value.name.parts.length == 1
+
+          value.name.parts.first
         end
 
-        declared_receiver_type.definition.type_params.zip(receiver_type.arguments).to_h
-      when Types::VariantInstance
-        return {} unless declared_receiver_type.definition.is_a?(Types::GenericVariantDefinition)
+        raise LoweringError.new("extending target #{type_ref} must use the receiver type parameters directly", line: 0, column: 0, path: @ctx.current_analysis_path) if names.any?(&:nil?)
 
-        unless receiver_type.is_a?(Types::VariantInstance) && receiver_type.definition == declared_receiver_type.definition
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
+        names
+      end
 
-        declared_receiver_type.definition.type_params.zip(receiver_type.arguments).to_h
-      when Types::GenericInstance
-        unless receiver_type.is_a?(Types::GenericInstance) && receiver_type.name == declared_receiver_type.name && receiver_type.arguments.length == declared_receiver_type.arguments.length
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
+      def infer_receiver_type_substitutions(binding, receiver_type)
+        declared_receiver_type = binding.declared_receiver_type
+        return {} unless declared_receiver_type
+        case declared_receiver_type
+        when Types::Nullable
+          unless receiver_type.is_a?(Types::Nullable)
+            raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+
+          infer_receiver_type_substitutions(
+            binding.with(declared_receiver_type: declared_receiver_type.base),
+            receiver_type.base,
+          )
+        when Types::StructInstance
+          return {} unless declared_receiver_type.definition.is_a?(Types::GenericStructDefinition)
 
-        declared_receiver_type.arguments.zip(receiver_type.arguments).each_with_object({}) do |(declared_argument, actual_argument), substitutions|
-          if declared_argument.is_a?(Types::TypeVar)
-            substitutions[declared_argument.name] = actual_argument
-          elsif declared_argument != actual_argument
+          unless receiver_type.is_a?(Types::StructInstance) && receiver_type.definition == declared_receiver_type.definition
             raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
           end
-        end
-      when Types::Span
-        return {} unless receiver_type.is_a?(Types::Span)
 
-        substitutions = {}
-        if declared_receiver_type.element_type.is_a?(Types::TypeVar)
-          substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
-        elsif declared_receiver_type.element_type != receiver_type.element_type
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        substitutions
-      when Types::Task
-        return {} unless receiver_type.is_a?(Types::Task)
+          declared_receiver_type.definition.type_params.zip(receiver_type.arguments).to_h
+        when Types::VariantInstance
+          return {} unless declared_receiver_type.definition.is_a?(Types::GenericVariantDefinition)
 
-        substitutions = {}
-        if declared_receiver_type.result_type.is_a?(Types::TypeVar)
-          substitutions[declared_receiver_type.result_type.name] = receiver_type.result_type
-        elsif declared_receiver_type.result_type != receiver_type.result_type
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        substitutions
-      when Types::SoA
-        return {} unless receiver_type.is_a?(Types::SoA)
+          unless receiver_type.is_a?(Types::VariantInstance) && receiver_type.definition == declared_receiver_type.definition
+            raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
 
-        substitutions = {}
-        if declared_receiver_type.element_type.is_a?(Types::TypeVar)
-          substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
-        elsif declared_receiver_type.element_type != receiver_type.element_type
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        substitutions
-      when Types::Simd
-        return {} unless receiver_type.is_a?(Types::Simd)
+          declared_receiver_type.definition.type_params.zip(receiver_type.arguments).to_h
+        when Types::GenericInstance
+          unless receiver_type.is_a?(Types::GenericInstance) && receiver_type.name == declared_receiver_type.name && receiver_type.arguments.length == declared_receiver_type.arguments.length
+            raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
 
-        substitutions = {}
-        if declared_receiver_type.element_type.is_a?(Types::TypeVar)
-          substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
-        elsif declared_receiver_type.element_type != receiver_type.element_type
-          raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-        substitutions
-      else
-        {}
-      end
-    end
+          declared_receiver_type.arguments.zip(receiver_type.arguments).each_with_object({}) do |(declared_argument, actual_argument), substitutions|
+            if declared_argument.is_a?(Types::TypeVar)
+              substitutions[declared_argument.name] = actual_argument
+            elsif declared_argument != actual_argument
+              raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+            end
+          end
+        when Types::Span
+          return {} unless receiver_type.is_a?(Types::Span)
 
-    def collect_type_substitutions(pattern_type, actual_type, substitutions, function_name)
-      case pattern_type
-      when Types::TypeVar
-        existing = substitutions[pattern_type.name]
-        if existing && existing != actual_type
-          raise LoweringError.new("conflicting type argument #{pattern_type.name} for function #{function_name}: got #{existing} and #{actual_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-
-        substitutions[pattern_type.name] ||= actual_type
-      when Types::Nullable
-        candidate = actual_type.is_a?(Types::Nullable) ? actual_type.base : actual_type
-        collect_type_substitutions(pattern_type.base, candidate, substitutions, function_name)
-      when Types::GenericInstance
-        if ref_type?(pattern_type) && !ref_type?(actual_type)
-          collect_type_substitutions(referenced_type(pattern_type), actual_type, substitutions, function_name)
-          return
+          substitutions = {}
+          if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+          elsif declared_receiver_type.element_type != receiver_type.element_type
+            raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          substitutions
+        when Types::Task
+          return {} unless receiver_type.is_a?(Types::Task)
+
+          substitutions = {}
+          if declared_receiver_type.result_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.result_type.name] = receiver_type.result_type
+          elsif declared_receiver_type.result_type != receiver_type.result_type
+            raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          substitutions
+        when Types::SoA
+          return {} unless receiver_type.is_a?(Types::SoA)
+
+          substitutions = {}
+          if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+          elsif declared_receiver_type.element_type != receiver_type.element_type
+            raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          substitutions
+        when Types::Simd
+          return {} unless receiver_type.is_a?(Types::Simd)
+
+          substitutions = {}
+          if declared_receiver_type.element_type.is_a?(Types::TypeVar)
+            substitutions[declared_receiver_type.element_type.name] = receiver_type.element_type
+          elsif declared_receiver_type.element_type != receiver_type.element_type
+            raise LoweringError.new("cannot use method #{binding.name} with receiver #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
+          substitutions
+        else
+          {}
         end
+      end
 
-        if own_type?(actual_type) && (mutable_pointer_type?(pattern_type) || const_pointer_type?(pattern_type))
-          collect_type_substitutions(pointee_type(pattern_type), owned_referent_type(actual_type), substitutions, function_name)
-          return
-        end
+      def collect_type_substitutions(pattern_type, actual_type, substitutions, function_name)
+        case pattern_type
+        when Types::TypeVar
+          existing = substitutions[pattern_type.name]
+          if existing && existing != actual_type
+            raise LoweringError.new("conflicting type argument #{pattern_type.name} for function #{function_name}: got #{existing} and #{actual_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
 
-        return unless actual_type.is_a?(Types::GenericInstance)
-        return unless actual_type.name == pattern_type.name && actual_type.arguments.length == pattern_type.arguments.length
+          substitutions[pattern_type.name] ||= actual_type
+        when Types::Nullable
+          candidate = actual_type.is_a?(Types::Nullable) ? actual_type.base : actual_type
+          collect_type_substitutions(pattern_type.base, candidate, substitutions, function_name)
+        when Types::GenericInstance
+          if ref_type?(pattern_type) && !ref_type?(actual_type)
+            collect_type_substitutions(referenced_type(pattern_type), actual_type, substitutions, function_name)
+            return
+          end
 
-        pattern_type.arguments.zip(actual_type.arguments).each do |expected_argument, actual_argument|
-          next if expected_argument.is_a?(Types::LiteralTypeArg)
+          if own_type?(actual_type) && (mutable_pointer_type?(pattern_type) || const_pointer_type?(pattern_type))
+            collect_type_substitutions(pointee_type(pattern_type), owned_referent_type(actual_type), substitutions, function_name)
+            return
+          end
 
-          collect_type_substitutions(expected_argument, actual_argument, substitutions, function_name)
-        end
-      when Types::Span
-        return unless actual_type.is_a?(Types::Span)
+          return unless actual_type.is_a?(Types::GenericInstance)
+          return unless actual_type.name == pattern_type.name && actual_type.arguments.length == pattern_type.arguments.length
 
-        collect_type_substitutions(pattern_type.element_type, actual_type.element_type, substitutions, function_name)
-      when Types::Task
-        return unless actual_type.is_a?(Types::Task)
+          pattern_type.arguments.zip(actual_type.arguments).each do |expected_argument, actual_argument|
+            next if expected_argument.is_a?(Types::LiteralTypeArg)
 
-        collect_type_substitutions(pattern_type.result_type, actual_type.result_type, substitutions, function_name)
-      when Types::Proc
-        if task_root_proc_type?(pattern_type) && actual_type.is_a?(Types::Task)
-          collect_type_substitutions(pattern_type.return_type, actual_type, substitutions, function_name)
-          return
-        end
+            collect_type_substitutions(expected_argument, actual_argument, substitutions, function_name)
+          end
+        when Types::Span
+          return unless actual_type.is_a?(Types::Span)
+
+          collect_type_substitutions(pattern_type.element_type, actual_type.element_type, substitutions, function_name)
+        when Types::Task
+          return unless actual_type.is_a?(Types::Task)
+
+          collect_type_substitutions(pattern_type.result_type, actual_type.result_type, substitutions, function_name)
+        when Types::Proc
+          if task_root_proc_type?(pattern_type) && actual_type.is_a?(Types::Task)
+            collect_type_substitutions(pattern_type.return_type, actual_type, substitutions, function_name)
+            return
+          end
 
-        actual_params = case actual_type
-                        when Types::Proc
-                          return unless actual_type.params.length == pattern_type.params.length
+          actual_params = case actual_type
+                          when Types::Proc
+                            return unless actual_type.params.length == pattern_type.params.length
 
-                          actual_type.params
-                        when Types::Function
-                          return if actual_type.receiver_type || actual_type.variadic
-                          return unless actual_type.params.length == pattern_type.params.length
-                          return unless actual_type.params.zip(pattern_type.params).all? { |actual_param, expected_param| actual_param.mutable == expected_param.mutable }
+                            actual_type.params
+                          when Types::Function
+                            return if actual_type.receiver_type || actual_type.variadic
+                            return unless actual_type.params.length == pattern_type.params.length
+                            return unless actual_type.params.zip(pattern_type.params).all? { |actual_param, expected_param| actual_param.mutable == expected_param.mutable }
 
-                          actual_type.params
-                        else
-                          return
-                        end
+                            actual_type.params
+                          else
+                            return
+                          end
 
-        pattern_type.params.zip(actual_params).each do |expected_param, actual_param|
-          collect_type_substitutions(expected_param.type, actual_param.type, substitutions, function_name)
-        end
-        collect_type_substitutions(pattern_type.return_type, actual_type.return_type, substitutions, function_name)
-      when Types::StructInstance
-        return unless actual_type.is_a?(Types::StructInstance)
-        return unless actual_type.definition == pattern_type.definition && actual_type.arguments.length == pattern_type.arguments.length
+          pattern_type.params.zip(actual_params).each do |expected_param, actual_param|
+            collect_type_substitutions(expected_param.type, actual_param.type, substitutions, function_name)
+          end
+          collect_type_substitutions(pattern_type.return_type, actual_type.return_type, substitutions, function_name)
+        when Types::StructInstance
+          return unless actual_type.is_a?(Types::StructInstance)
+          return unless actual_type.definition == pattern_type.definition && actual_type.arguments.length == pattern_type.arguments.length
 
-        pattern_type.arguments.zip(actual_type.arguments).each do |expected_argument, actual_argument|
-          collect_type_substitutions(expected_argument, actual_argument, substitutions, function_name)
-        end
-      when Types::VariantInstance
-        return unless actual_type.is_a?(Types::VariantInstance)
-        return unless actual_type.definition == pattern_type.definition && actual_type.arguments.length == pattern_type.arguments.length
+          pattern_type.arguments.zip(actual_type.arguments).each do |expected_argument, actual_argument|
+            collect_type_substitutions(expected_argument, actual_argument, substitutions, function_name)
+          end
+        when Types::VariantInstance
+          return unless actual_type.is_a?(Types::VariantInstance)
+          return unless actual_type.definition == pattern_type.definition && actual_type.arguments.length == pattern_type.arguments.length
 
-        pattern_type.arguments.zip(actual_type.arguments).each do |expected_argument, actual_argument|
-          collect_type_substitutions(expected_argument, actual_argument, substitutions, function_name)
-        end
-      when Types::Function
-        return unless actual_type.is_a?(Types::Function)
-        return unless actual_type.params.length == pattern_type.params.length
+          pattern_type.arguments.zip(actual_type.arguments).each do |expected_argument, actual_argument|
+            collect_type_substitutions(expected_argument, actual_argument, substitutions, function_name)
+          end
+        when Types::Function
+          return unless actual_type.is_a?(Types::Function)
+          return unless actual_type.params.length == pattern_type.params.length
 
-        pattern_type.params.zip(actual_type.params).each do |expected_param, actual_param|
-          collect_type_substitutions(expected_param.type, actual_param.type, substitutions, function_name)
+          pattern_type.params.zip(actual_type.params).each do |expected_param, actual_param|
+            collect_type_substitutions(expected_param.type, actual_param.type, substitutions, function_name)
+          end
+          collect_type_substitutions(pattern_type.return_type, actual_type.return_type, substitutions, function_name)
         end
-        collect_type_substitutions(pattern_type.return_type, actual_type.return_type, substitutions, function_name)
       end
-    end
 
-    def substitute_value_binding(binding, substitutions)
-      ValueBinding.new(
-        id: binding.id,
-        name: binding.name,
-        storage_type: substitute_type(binding.storage_type, substitutions),
-        flow_type: binding.flow_type ? substitute_type(binding.flow_type, substitutions) : nil,
-        mutable: binding.mutable,
-        kind: binding.kind,
-        const_value: binding.const_value,
-      )
-    end
+      def substitute_value_binding(binding, substitutions)
+        Bindings::ValueBinding.new(
+          id: binding.id,
+          name: binding.name,
+          storage_type: substitute_type(binding.storage_type, substitutions),
+          flow_type: binding.flow_type ? substitute_type(binding.flow_type, substitutions) : nil,
+          mutable: binding.mutable,
+          kind: binding.kind,
+          const_value: binding.const_value,
+        )
+      end
 
-    def substitute_type(type, substitutions)
-      SubstituteTypeVisitor.new(substitutions).apply(type)
-    end
+      def substitute_type(type, substitutions)
+        Types::SubstituteTypeVisitor.new(substitutions).apply(type)
+      end
 
-    def analysis_for_module(module_name)
-      @program.analyses_by_module_name.fetch(module_name)
-    end
+      def analysis_for_module(module_name)
+        @program.analyses_by_module_name.fetch(module_name)
+      end
 
-    def each_raw_module_analysis(&block)
-      return @program.analyses_by_module_name.each_value.select { |a| a.module_kind == :raw_module }.each unless block
-      @program.analyses_by_module_name.each_value { |a| block.call(a) if a.module_kind == :raw_module }
-    end
+      def each_raw_module_analysis(&block)
+        return @program.analyses_by_module_name.each_value.select { |a| a.module_kind == :raw_module }.each unless block
+        @program.analyses_by_module_name.each_value { |a| block.call(a) if a.module_kind == :raw_module }
+      end
 
-    def each_non_raw_module_analysis(&block)
-      return @program.analyses_by_module_name.each_value.reject { |a| a.module_kind == :raw_module }.each unless block
-      @program.analyses_by_module_name.each_value { |a| block.call(a) unless a.module_kind == :raw_module }
-    end
+      def each_non_raw_module_analysis(&block)
+        return @program.analyses_by_module_name.each_value.reject { |a| a.module_kind == :raw_module }.each unless block
+        @program.analyses_by_module_name.each_value { |a| block.call(a) unless a.module_kind == :raw_module }
+      end
 
-    def types_for_module(module_name)
-      @program.analyses_by_module_name.fetch(module_name).types
-    end
+      def types_for_module(module_name)
+        @program.analyses_by_module_name.fetch(module_name).types
+      end
 
-    def imports_for_module(module_name)
-      @program.analyses_by_module_name.fetch(module_name).imports
-    end
+      def imports_for_module(module_name)
+        @program.analyses_by_module_name.fetch(module_name).imports
+      end
 
-    def const_declaration_for_module(module_name, name)
-      analysis = @program.analyses_by_module_name.fetch(module_name)
-      declaration = analysis.ast.declarations.find { |decl| decl.is_a?(AST::ConstDecl) && decl.name == name }
-      raise LoweringError.new("unknown constant #{analysis.module_name}.#{name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless declaration
+      def const_declaration_for_module(module_name, name)
+        analysis = @program.analyses_by_module_name.fetch(module_name)
+        declaration = analysis.ast.declarations.find { |decl| decl.is_a?(AST::ConstDecl) && decl.name == name }
+        raise LoweringError.new("unknown constant #{analysis.module_name}.#{name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless declaration
 
-      declaration
-    end
+        declaration
+      end
 
-    def resolve_type_ref_for_analysis(type_ref, analysis, type_params: current_type_params)
-      saved = @ctx.save
-      @ctx.install(analysis)
-      @ctx.module_prefix = module_c_prefix(@ctx.module_name)
-      resolve_type_ref(type_ref, type_params:)
-    ensure
-      @ctx.restore(saved)
-    end
+      def resolve_type_ref_for_analysis(type_ref, analysis, type_params: current_type_params)
+        saved = @ctx.save
+        @ctx.install(analysis)
+        @ctx.module_prefix = module_c_prefix(@ctx.module_name)
+        resolve_type_ref(type_ref, type_params:)
+      ensure
+        @ctx.restore(saved)
+      end
 
-    def current_type_params
-      @ctx.current_type_substitutions || {}
-    end
+      def current_type_params
+        @ctx.current_type_substitutions || {}
+      end
 
-    def resolve_type_ref(type_ref, type_params: current_type_params)
-      if type_ref.is_a?(AST::FunctionType)
-        params = type_ref.params.map do |param|
-          Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:))
+      def resolve_type_ref(type_ref, type_params: current_type_params)
+        if type_ref.is_a?(AST::FunctionType)
+          params = type_ref.params.map do |param|
+            Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:))
+          end
+          return Types::Registry.function(nil, params:, return_type: resolve_type_ref(type_ref.return_type, type_params:))
         end
-        return Types::Registry.function(nil, params:, return_type: resolve_type_ref(type_ref.return_type, type_params:))
-      end
 
-      if type_ref.is_a?(AST::ProcType)
-        params = type_ref.params.map do |param|
-          Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:))
+        if type_ref.is_a?(AST::ProcType)
+          params = type_ref.params.map do |param|
+            Types::Registry.parameter(param.name, resolve_type_ref(param.type, type_params:))
+          end
+          return Types::Registry.proc(params:, return_type: resolve_type_ref(type_ref.return_type, type_params:))
         end
-        return Types::Registry.proc(params:, return_type: resolve_type_ref(type_ref.return_type, type_params:))
-      end
 
-      if type_ref.is_a?(AST::DynType)
-        interface = resolve_interface_ref(type_ref.interface)
-        raise LoweringError.new("generic interface requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if interface.respond_to?(:instantiate)
-        type_arguments = interface.respond_to?(:type_arguments) ? (interface.type_arguments || []) : []
-        return Types::Dyn.new(interface, type_arguments)
-      end
+        if type_ref.is_a?(AST::DynType)
+          interface = resolve_interface_ref(type_ref.interface)
+          raise LoweringError.new("generic interface requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if interface.respond_to?(:instantiate)
+          type_arguments = interface.respond_to?(:type_arguments) ? (interface.type_arguments || []) : []
+          return Types::Dyn.new(interface, type_arguments)
+        end
 
-      if type_ref.is_a?(AST::TupleType)
-        names = []
-        element_types = []
-        type_ref.element_types.each do |et|
-          if et.is_a?(AST::Argument)
-            names << et.name
-            element_types << resolve_type_ref(et.value, type_params:)
-          else
-            names << nil
-            element_types << resolve_type_ref(et, type_params:)
+        if type_ref.is_a?(AST::TupleType)
+          names = []
+          element_types = []
+          type_ref.element_types.each do |et|
+            if et.is_a?(AST::Argument)
+              names << et.name
+              element_types << resolve_type_ref(et.value, type_params:)
+            else
+              names << nil
+              element_types << resolve_type_ref(et, type_params:)
+            end
           end
+          has_named = names.any?
+          return Types::Registry.tuple(element_types, field_names: has_named ? names : nil)
         end
-        has_named = names.any?
-        return Types::Registry.tuple(element_types, field_names: has_named ? names : nil)
-      end
 
-      parts = type_ref.name.parts
-      base = if type_ref.arguments.any?
-                name = parts.join(".")
-                args = type_ref.arguments.map { |argument| resolve_type_argument(argument.value, type_params:) }
-                if name != "ref" && args.any? { |argument| contains_ref_type?(argument) && !stored_ref_supported_type?(argument) }
-                  raise LoweringError.new("ref types cannot be nested inside #{name}", line: 0, column: 0, path: @ctx.current_analysis_path)
-                end
-                if name == "Task"
-                  validate_generic_type!(name, args)
-                  Types::Registry.task(args.fetch(0))
-                elsif (generic_type = resolve_named_generic_type(parts))
-                  generic_type.instantiate(args)
-                elsif name == "span"
-                  Types::Registry.span(args.fetch(0))
-                elsif name == "SoA"
-                  validate_generic_type!(name, args)
-                  Types::Registry.soa(args.fetch(0), count: args.fetch(1).value)
-                elsif name == "simd"
-                  validate_generic_type!(name, args)
-                  Types::Registry.simd(args.fetch(0), lane_count: args.fetch(1).value)
-                else
-                  validate_generic_type!(name, args)
-                  args = [type_ref.lifetime] + args if name == "ref" && type_ref.lifetime
-                  Types::Registry.generic_instance(name, args)
+        parts = type_ref.name.parts
+        base = if type_ref.arguments.any?
+                  name = parts.join(".")
+                  args = type_ref.arguments.map { |argument| resolve_type_argument(argument.value, type_params:) }
+                  if name != "ref" && args.any? { |argument| contains_ref_type?(argument) && !stored_ref_supported_type?(argument) }
+                    raise LoweringError.new("ref types cannot be nested inside #{name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+                  end
+                  if name == "Task"
+                    validate_generic_type!(name, args)
+                    Types::Registry.task(args.fetch(0))
+                  elsif (generic_type = resolve_named_generic_type(parts))
+                    generic_type.instantiate(args)
+                  elsif name == "span"
+                    Types::Registry.span(args.fetch(0))
+                  elsif name == "SoA"
+                    validate_generic_type!(name, args)
+                    Types::Registry.soa(args.fetch(0), count: args.fetch(1).value)
+                  elsif name == "simd"
+                    validate_generic_type!(name, args)
+                    Types::Registry.simd(args.fetch(0), lane_count: args.fetch(1).value)
+                  else
+                    validate_generic_type!(name, args)
+                    args = [type_ref.lifetime] + args if name == "ref" && type_ref.lifetime
+                    Types::Registry.generic_instance(name, args)
+                  end
+                elsif parts.length == 1 && type_params.key?(parts.first)
+                  type_params.fetch(parts.first)
+                elsif parts.length == 1
+                  type = @ctx.types[parts.first]
+                  raise LoweringError.new("unknown type #{parts.first}", line: 0, column: 0, path: @ctx.current_analysis_path) unless type
+                  raise LoweringError.new("generic type #{parts.first} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+
+                  type
+          elsif parts.length >= 2
+            type = resolve_nested_type_ref(parts)
+
+            unless type
+              if @ctx.imports.key?(parts.first)
+                imported_module = @ctx.imports.fetch(parts.first)
+                if imported_module.private_type?(parts.last)
+                  raise LoweringError.new("#{parts.first}.#{parts.last} is private to module #{imported_module.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
                 end
-              elsif parts.length == 1 && type_params.key?(parts.first)
-                type_params.fetch(parts.first)
-              elsif parts.length == 1
-                type = @ctx.types[parts.first]
-                raise LoweringError.new("unknown type #{parts.first}", line: 0, column: 0, path: @ctx.current_analysis_path) unless type
-                raise LoweringError.new("generic type #{parts.first} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
-
-                type
-        elsif parts.length >= 2
-          type = resolve_nested_type_ref(parts)
 
-          unless type
-            if @ctx.imports.key?(parts.first)
-              imported_module = @ctx.imports.fetch(parts.first)
-              if imported_module.private_type?(parts.last)
-                raise LoweringError.new("#{parts.first}.#{parts.last} is private to module #{imported_module.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+                type = imported_module.types[parts.last]
+                raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless type
+                raise LoweringError.new("generic type #{type_ref.name} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+              elsif @type_resolution_env && (field_type = resolve_field_handle_type_ref(parts))
+                type = field_type
+              else
+                raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
               end
-
-              type = imported_module.types[parts.last]
-              raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path) unless type
-              raise LoweringError.new("generic type #{type_ref.name} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
-            elsif @type_resolution_env && (field_type = resolve_field_handle_type_ref(parts))
-              type = field_type
-            else
-              raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
             end
-          end
 
-          type
-        else
-          raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
+            type
+          else
+            raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+          end
 
-        raise LoweringError.new("ref types are non-null and cannot be nullable", line: 0, column: 0, path: @ctx.current_analysis_path) if type_ref.nullable && ref_type?(base)
+          raise LoweringError.new("ref types are non-null and cannot be nullable", line: 0, column: 0, path: @ctx.current_analysis_path) if type_ref.nullable && ref_type?(base)
 
-        type_ref.nullable ? Types::Registry.nullable(base) : base
-    end
+          type_ref.nullable ? Types::Registry.nullable(base) : base
+      end
 
-    def resolve_nested_type_ref(parts)
-      current = @ctx.types[parts.first]
-      return nil unless current.is_a?(Types::Struct) || current.is_a?(Types::GenericStructDefinition)
+      def resolve_nested_type_ref(parts)
+        current = @ctx.types[parts.first]
+        return nil unless current.is_a?(Types::Struct) || current.is_a?(Types::GenericStructDefinition)
 
-      parts[1..].each do |part|
-        nested = current.respond_to?(:nested_types) ? current.nested_types[part] : nil
-        return nil unless nested
-        current = nested
+        parts[1..].each do |part|
+          nested = current.respond_to?(:nested_types) ? current.nested_types[part] : nil
+          return nil unless nested
+          current = nested
+        end
+        current
       end
-      current
-    end
 
-    def resolve_named_generic_type(parts)
-      if parts.length == 1
-        type = @ctx.types[parts.first]
-        return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
-      elsif parts.length >= 2
-        type = resolve_nested_type_ref(parts)
-        return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
-        if @ctx.imports.key?(parts.first)
-          type = @ctx.imports.fetch(parts.first).types[parts.last]
+      def resolve_named_generic_type(parts)
+        if parts.length == 1
+          type = @ctx.types[parts.first]
           return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+        elsif parts.length >= 2
+          type = resolve_nested_type_ref(parts)
+          return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+          if @ctx.imports.key?(parts.first)
+            type = @ctx.imports.fetch(parts.first).types[parts.last]
+            return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+          end
         end
-      end
 
-      nil
-    end
+        nil
+      end
 
-    # Resolves a bare dotted reflection type ref `field.type` (where `field` is
-    # a compile-time `field_handle` bound in the active inline-for env) to the
-    # field's concrete type. Mirrors the sema-side `resolve_compile_time_type_ref`.
-    def resolve_field_handle_type_ref(parts)
-      return nil unless parts.length == 2 && parts.last == "type"
+      # Resolves a bare dotted reflection type ref `field.type` (where `field` is
+      # a compile-time `field_handle` bound in the active inline-for env) to the
+      # field's concrete type. Mirrors the sema-side `resolve_compile_time_type_ref`.
+      def resolve_field_handle_type_ref(parts)
+        return nil unless parts.length == 2 && parts.last == "type"
 
-      binding = lookup_value(parts.first, @type_resolution_env)
-      handle = binding && binding[:const_value]
-      return nil unless handle.is_a?(Types::FieldHandle)
+        binding = lookup_value(parts.first, @type_resolution_env)
+        handle = binding && binding[:const_value]
+        return nil unless handle.is_a?(Types::FieldHandle)
 
-      # Use the struct's already-resolved field type (module-independent) rather
-      # than re-resolving the field's declared TypeRef, which would look up a
-      # user struct name in this (std) module's scope and fail.
-      handle.struct_handle.struct_type.field(handle.field_name)
-    end
+        # Use the struct's already-resolved field type (module-independent) rather
+        # than re-resolving the field's declared TypeRef, which would look up a
+        # user struct name in this (std) module's scope and fail.
+        handle.struct_handle.struct_type.field(handle.field_name)
+      end
 
-    def infer_field_handle_member_type(expression)
-      case expression.member
-      when "name" then @ctx.types["str"]
-      when "type"
-        handle = compile_time_const_value(expression.receiver, env: nil)
-        return @error_type unless handle.is_a?(Types::FieldHandle)
+      def infer_field_handle_member_type(expression)
+        case expression.member
+        when "name" then @ctx.types["str"]
+        when "type"
+          handle = compile_time_const_value(expression.receiver, env: nil)
+          return @error_type unless handle.is_a?(Types::FieldHandle)
 
-        resolve_type_ref(handle.field_declaration.type)
-      else
-        @error_type
+          resolve_type_ref(handle.field_declaration.type)
+        else
+          @error_type
+        end
       end
-    end
 
-    def infer_member_handle_member_type(expression)
-      case expression.member
-      when "name" then @ctx.types["str"]
-      when "value" then @ctx.types["int"]
-      else @error_type
+      def infer_member_handle_member_type(expression)
+        case expression.member
+        when "name" then @ctx.types["str"]
+        when "value" then @ctx.types["int"]
+        else @error_type
+        end
       end
-    end
 
-    def resolve_interface_ref(interface_ref)
-      parts = interface_ref.parts
-      interface = if parts.length == 1
-                    @ctx.interfaces[parts.first]
-                  elsif parts.length == 2 && @ctx.imports.key?(parts.first)
-                    @ctx.imports.fetch(parts.first).interfaces[parts.last]
-                  end
-      raise LoweringError.new("unknown interface #{interface_ref}", line: 0, column: 0, path: @ctx.current_analysis_path) unless interface
-
-      if interface_ref.type_arguments.any?
-        raise LoweringError.new("interface #{interface.name} is not generic", line: 0, column: 0, path: @ctx.current_analysis_path) unless interface.respond_to?(:instantiate)
-        type_args = interface_ref.type_arguments.map { |arg| resolve_type_ref(arg) }
-        interface.instantiate(type_args)
-      else
-        interface
+      def resolve_interface_ref(interface_ref)
+        parts = interface_ref.parts
+        interface = if parts.length == 1
+                      @ctx.interfaces[parts.first]
+                    elsif parts.length == 2 && @ctx.imports.key?(parts.first)
+                      @ctx.imports.fetch(parts.first).interfaces[parts.last]
+                    end
+        raise LoweringError.new("unknown interface #{interface_ref}", line: 0, column: 0, path: @ctx.current_analysis_path) unless interface
+
+        if interface_ref.type_arguments.any?
+          raise LoweringError.new("interface #{interface.name} is not generic", line: 0, column: 0, path: @ctx.current_analysis_path) unless interface.respond_to?(:instantiate)
+          type_args = interface_ref.type_arguments.map { |arg| resolve_type_ref(arg) }
+          interface.instantiate(type_args)
+        else
+          interface
+        end
       end
     end
   end