mt-lang 0.3.9 → 0.3.10

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

@@ -2,8 +2,6 @@
 
 module MilkTea
   module LowererResolve
-    private
-
     PASS_THROUGH_BUILTINS = {
       "fatal"         => :fatal,
       "ref_of"        => :ref_of,
@@ -18,2577 +16,2577 @@ module MilkTea
     ].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)
+    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
+      function_type_matches_proc_type?(actual_type, expected_type)
+    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 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)
+        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)
+        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
+        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)
+        callable_kind, binding, = callable_resolution
+        callable_kind == :function && !foreign_function_binding?(binding)
+      else
+        false
+      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 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
-          false
+          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
 
-      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 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),
-              ),
-            ),
-            IR::AggregateField.new(
-              name: "len",
-              value: IR::IntegerLiteral.new(value: array_length(array_type), type: @ctx.types.fetch("ptr_uint")),
-            ),
-          ],
-        )
-      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_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::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),
             ),
-            IR::AggregateField.new(
-              name: "len",
-              value: IR::IntegerLiteral.new(value: str_buffer_storage_capacity(expression.type), type: @ctx.types.fetch("ptr_uint")),
+          ),
+          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),
             ),
-          ],
-        )
-      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)
-
+          ),
+          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)
+
+      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
         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
-          false
-        end
-      rescue LoweringError
+    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
         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
-          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)
+
+      cstr_list_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 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
 
-        cstr_list_backed_expression?(expression, env)
+        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
 
-      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
+      return unless statement.target.is_a?(AST::IndexAccess) && statement.target.receiver.is_a?(AST::Identifier)
 
-          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
+      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
 
-        return unless statement.target.is_a?(AST::IndexAccess) && statement.target.receiver.is_a?(AST::Identifier)
+    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?
 
-        binding = lookup_value(statement.target.receiver.name, env)
-        return unless binding && cstr_list_trackable_type?(binding[:type])
+      trackable_binding_names(env).each do |name|
+        binding = lookup_value(name, env)
+        next unless binding
 
-        replace_binding_cstr_metadata!(statement.target.receiver.name, env, cstr_backed: binding_cstr_backed?(binding), cstr_list_backed: false)
+        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
 
-      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 cstr_metadata_exit_envs_for_if_statement(statement, env)
+      false_refinements = {}
+      exit_envs = []
 
-        trackable_binding_names(env).each do |name|
-          binding = lookup_value(name, env)
-          next unless binding
+      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
 
-          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
+      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
 
-      def cstr_metadata_exit_envs_for_if_statement(statement, env)
-        false_refinements = {}
-        exit_envs = []
+      exit_envs
+    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
+    def simulate_cstr_metadata_block(statements, env:)
+      simulated_env = duplicate_env(env)
 
-        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
-
-      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,
-              )
-            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
+      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,
+            )
           end
-        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
 
-        simulated_env
+          copy_cstr_metadata!(simulated_env, nested_env)
+        when AST::ReturnStmt, AST::BreakStmt, AST::ContinueStmt
+          return nil
+        end
       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
+      simulated_env
+    end
 
-          replace_binding_cstr_metadata!(
-            name,
-            target_env,
-            cstr_backed: binding_cstr_backed?(source_binding),
-            cstr_list_backed: binding_cstr_list_backed?(source_binding),
-          )
-        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
+
+        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
 
-      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
-        end
+        scope[name] = scope.fetch(name).merge(cstr_backed:, cstr_list_backed:)
+        return
       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)
-          end
+          names << name unless names.include?(name)
         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
-        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
       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)
-        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)
       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])
-
-          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
+    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])
 
-        if (kind = PASS_THROUGH_BUILTINS[callee.name])
-          return [kind, nil, nil, nil]
-        end
+        raise LoweringError.new("#{callee.name} is not callable", line: 0, column: 0, path: @ctx.current_analysis_path)
+      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 @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
 
-        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 (kind = PASS_THROUGH_BUILTINS[callee.name])
+        return [kind, nil, nil, nil]
+      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 COMPILE_TIME_BUILTINS.include?(callee.name)
+        return [:compile_time_builtin, callee.name, nil, compile_time_builtin_function_type(callee.name, arguments, env)]
+      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]
-        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
 
-        raise LoweringError.new("unknown callee #{callee.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      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
 
-      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)
+      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
 
-          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
+      raise LoweringError.new("unknown callee #{callee.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+    end
 
-            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
+    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_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_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_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
+          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 (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
-
-          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
+        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
 
-          raise LoweringError.new("unknown associated function #{type_expr}.#{callee.member}", line: 0, column: 0, path: @ctx.current_analysis_path)
+        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
 
-        resolved_receiver_type = infer_method_receiver_type(callee.receiver, env:, member_name: callee.member)
+      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 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]
+        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
 
-        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
+        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_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
-            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)]
+          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
 
-        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
+        raise LoweringError.new("unknown associated function #{type_expr}.#{callee.member}", line: 0, column: 0, path: @ctx.current_analysis_path)
+      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
+      resolved_receiver_type = infer_method_receiver_type(callee.receiver, env:, member_name: callee.member)
 
-        if (atomic_method = atomic_method_kind(resolved_receiver_type, 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(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
+          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 atomic_method
+          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 [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
-
-      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
-
-        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
-
-          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]
+          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
-
-        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
-
-        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)
+      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
 
-      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
-
-        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)
-
-          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
-
-            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
-
-          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 (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
 
-          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
+      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
 
-          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 (simd_method = simd_method_kind(resolved_receiver_type, callee.member))
+        ret = case simd_method
+              when :simd_lane_with then resolved_receiver_type
               end
-            end
-            infer_expression_type(arm.value, env: arm_env, expected_type: expected_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
 
-          if expected_type && arm_types.all? { |arm_type| if_expression_branch_compatible?(arm_type, expected_type) }
-            return expected_type
-          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)
 
-          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
-        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
-            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 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
-          env
+          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 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)
+      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
 
-        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)
+        if function_binding.external
+          return [:function, external_function_c_name(function_binding), nil, function_binding.type, function_binding]
         end
 
-        [left_type, right_type]
+        return [:function, function_binding_c_name(function_binding, module_name: function_binding.owner.module_name), nil, function_binding.type, function_binding]
       end
 
-      def float_literal_expression?(expression)
-        expression.is_a?(AST::FloatLiteral) ||
-          (expression.is_a?(AST::UnaryOp) && ["+", "-"].include?(expression.operator) && float_literal_expression?(expression.operand))
+      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
 
-      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
+      raise LoweringError.new("unsupported specialization callee", line: 0, column: 0, path: @ctx.current_analysis_path)
+    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 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)
 
-        [left_type, right_type]
-      end
+      raise LoweringError.new("unsupported callee #{callee.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+    end
 
-      def integer_literal_expression?(expression)
-        expression.is_a?(AST::IntegerLiteral)
+    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
 
-      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
+      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)
 
-        nil
-      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
 
-      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)
+          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
-
-      def cast_expression(expression, target_type)
-        return expression if expression.type == target_type
-
-        IR::Cast.new(target_type:, expression:, type: target_type)
-      end
-
-      def pointer_lowered_sync_method_receiver?(binding)
-        return false if binding.async
-
-        pointer_lowered_method_receiver?(binding.type, binding)
-      end
 
-      def pointer_lowered_method_receiver?(callee_type, callee_binding)
-        return true if callee_type.receiver_editable
+        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
 
-        receiver_type_uses_pointer_lowering?(callee_type.receiver_type) && !callee_binding&.async
-      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 == "?"
 
-      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)
+        operand_type = infer_expression_type(expression.operand, env:, expected_type:)
+        case expression.operator
+        when "not"
+          @ctx.types.fetch("bool")
         else
-          false
+          operand_type
         end
-      end
-
-      def type_contains_array_storage?(type, visited = Set.new)
-        visitor = ContainsArrayStorageVisitor.new
-        visitor.visit(type)
-        visitor.found?
-      end
-
-      def reinterpret_expression(expression, target_type)
-        return expression if expression.type == target_type
+      when AST::BinaryOp
+        left_type, right_type = infer_binary_operand_types(expression, env:, expected_type: expected_type)
 
-        IR::ReinterpretExpr.new(target_type:, source_type: expression.type, expression:, type: target_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
+
+        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
+
+        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
+      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
+          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 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
+        env
+      end
+    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
+
+      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
+
+      [left_type, right_type]
+    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
+
+    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 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)
-
-        if foreign_identity_projection_reinterpret_compatible?(expression.type, target_type)
-          record_external_layout_assertion(expression.type, target_type)
-          return reinterpret_expression(expression, target_type)
+      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
-
-        nil
       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
+      [left_type, right_type]
+    end
 
-        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]
+    def integer_literal_expression?(expression)
+      expression.is_a?(AST::IntegerLiteral)
+    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,
-          ),
-        )
+    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
 
-      def ffi_external_layout_root_type(type)
-        type = type.base while type.is_a?(Types::Nullable)
-        return pointee_type(type) if pointer_type?(type)
+      nil
+    end
 
-        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
 
-      def infer_null_literal_type(expression, expected_type)
-        return Types::Null.new(resolve_type_ref(expression.type)) if expression.type
+    def cast_expression(expression, target_type)
+      return expression if expression.type == target_type
 
-        expected_type || null_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?
+      IR::Cast.new(target_type:, expression:, type: target_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 pointer_lowered_sync_method_receiver?(binding)
+      return false if binding.async
 
-        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?
+      pointer_lowered_method_receiver?(binding.type, binding)
+    end
 
-        float_type
-      end
+    def pointer_lowered_method_receiver?(callee_type, callee_binding)
+      return true if callee_type.receiver_editable
 
-      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 unless left_type.signed_integer? == right_type.signed_integer?
+      receiver_type_uses_pointer_lowering?(callee_type.receiver_type) && !callee_binding&.async
+    end
 
-        left_type.integer_width >= right_type.integer_width ? left_type : right_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
+
+    def type_contains_array_storage?(type, visited = Set.new)
+      visitor = ContainsArrayStorageVisitor.new
+      visitor.visit(type)
+      visitor.found?
+    end
 
-      def wider_float_type(left_type, right_type)
-        left_type.float_width >= right_type.float_width ? left_type : right_type
-      end
+    def reinterpret_expression(expression, target_type)
+      return expression if expression.type == target_type
 
-      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
+      IR::ReinterpretExpr.new(target_type:, source_type: expression.type, expression:, type: target_type)
+    end
 
-        scalar_result = aggregate_scalar_result(left_type, right_type)
-        return scalar_result if scalar_result
+    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)
 
-        case operator
-        when "+", "-"
-          nil
-        when "*", "/"
-          aggregate_scalar_result(right_type, left_type)
-        else
-          nil
-        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 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?
+      nil
+    end
 
-        aggregate_type
-      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 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)
+      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]
 
-        nil
-      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 resolve_type_expression(expression)
-        case expression
-        when AST::Identifier
-          return current_type_params[expression.name] if current_type_params.key?(expression.name)
+    def ffi_external_layout_root_type(type)
+      type = type.base while type.is_a?(Types::Nullable)
+      return pointee_type(type) if pointer_type?(type)
 
-          @ctx.types[expression.name]
-        when AST::MemberAccess
-          return nil unless expression.receiver.is_a?(AST::Identifier)
-
-          if @ctx.imports.key?(expression.receiver.name)
-            return @ctx.imports.fetch(expression.receiver.name).types[expression.member]
-          end
+      type
+    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)
+    def infer_null_literal_type(expression, expected_type)
+      return Types::Null.new(resolve_type_ref(expression.type)) if expression.type
 
-          nil
-        when AST::Specialization
-          type_ref = type_ref_from_specialization(expression)
-          return nil unless type_ref
+      expected_type || null_type
+    end
 
-          resolve_type_ref(type_ref)
-        end
-      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 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
+      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 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)
+      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?
 
-        binding.type
-      end
+      float_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
-                        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
+    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 unless left_type.signed_integer? == right_type.signed_integer?
 
-        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
+      left_type.integer_width >= right_type.integer_width ? left_type : right_type
+    end
 
-      def resolve_default_specialization(expression, env:)
-        target_type = resolve_type_ref(expression.arguments.fetch(0).value)
+    def wider_float_type(left_type, right_type)
+      left_type.float_width >= right_type.float_width ? left_type : right_type
+    end
 
-        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)
+    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
 
-      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
+      scalar_result = aggregate_scalar_result(left_type, right_type)
+      return scalar_result if scalar_result
 
-        HashResolution.new(target_type:, binding: explicit_hash.binding, callee_name: explicit_hash.callee_name)
+      case operator
+      when "+", "-"
+        nil
+      when "*", "/"
+        aggregate_scalar_result(right_type, left_type)
+      else
+        nil
       end
+    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 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?
 
-        EqualResolution.new(target_type:, binding: explicit_equal.binding, callee_name: explicit_equal.callee_name)
-      end
+      aggregate_type
+    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 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)
 
-        OrderResolution.new(target_type:, binding: explicit_order.binding, callee_name: explicit_order.callee_name)
-      end
+      nil
+    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)
-          end
-        end
-      end
+    def resolve_type_expression(expression)
+      case expression
+      when AST::Identifier
+        return current_type_params[expression.name] if current_type_params.key?(expression.name)
 
-      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
+        @ctx.types[expression.name]
+      when AST::MemberAccess
+        return nil unless expression.receiver.is_a?(AST::Identifier)
 
-      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
+        if @ctx.imports.key?(expression.receiver.name)
+          return @ctx.imports.fetch(expression.receiver.name).types[expression.member]
         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)
-          end
-        end
-      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)
 
-      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:)
+        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)
+      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)
+
+      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
+                      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 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
+      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
 
-        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
+    def resolve_default_specialization(expression, env:)
+      target_type = resolve_type_ref(expression.arguments.fetch(0).value)
 
-        nil
-      end
+      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
 
-      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
+      DefaultResolution.new(target_type:, binding: explicit_default.binding, callee_name: explicit_default.callee_name)
+    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)
-          end
-        end
-      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 method_analysis_key(method_ast)
-        method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name
-      end
+      HashResolution.new(target_type:, binding: explicit_hash.binding, callee_name: explicit_hash.callee_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]]
-        end
-        return nil unless method_entry
+    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
 
-        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?
+      EqualResolution.new(target_type:, binding: explicit_equal.binding, callee_name: explicit_equal.callee_name)
+    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
+    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
 
-        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
+      OrderResolution.new(target_type:, binding: explicit_order.binding, callee_name: explicit_order.callee_name)
+    end
 
-        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)
+    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
 
-      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]]
+    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
-        return nil unless method_entry
+        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
 
-        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_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
+
+    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
 
-        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
+    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:)
 
-        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
+      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
 
-        {
-          binding: method_binding,
-          callee_name: callee_name,
-        }
+      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
 
-      def resolve_specialization_type_arguments(expression)
-        expression.arguments.map do |argument|
-          resolve_type_argument(argument.value)
+      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)
         end
       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
-          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_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
 
-      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)
-
-        resolve_type_ref(type_ref, type_params:)
-      rescue LoweringError => error
-        literal_type_argument = resolve_named_literal_type_argument(type_ref)
-        return literal_type_argument if literal_type_argument
+    def method_analysis_key(method_ast)
+      method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name
+    end
 
-        raise error
+    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
 
-      def literal_type_argument_name_candidate?(type_ref)
-        type_ref.arguments.empty? && !type_ref.nullable
-      end
+      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_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
+      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
+
+      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
 
-        return unless value.is_a?(Integer) || value.is_a?(Float)
+      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
+
+    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_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?
+
+      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
+
+      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
 
-        Types::LiteralTypeArg.new(value)
-      end
+      {
+        binding: method_binding,
+        callee_name: callee_name,
+      }
+    end
+
+    def resolve_specialization_type_arguments(expression)
+      expression.arguments.map do |argument|
+        resolve_type_argument(argument.value)
+      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
+        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
+
+    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)
+
+      resolve_type_ref(type_ref, type_params:)
+    rescue LoweringError => error
+      literal_type_argument = resolve_named_literal_type_argument(type_ref)
+      return literal_type_argument if literal_type_argument
+
+      raise error
+    end
+
+    def literal_type_argument_name_candidate?(type_ref)
+      type_ref.arguments.empty? && !type_ref.nullable
+    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 resolve_current_module_const_value(name)
-        binding = @ctx.values[name]
-        return unless binding&.kind == :const
+      return unless value.is_a?(Integer) || value.is_a?(Float)
 
-        binding.const_value
-      end
+      Types::LiteralTypeArg.new(value)
+    end
 
-      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
+    def resolve_current_module_const_value(name)
+      binding = @ctx.values[name]
+      return unless binding&.kind == :const
 
-        binding = imported_module.values[value_name]
-        return unless binding&.kind == :const
+      binding.const_value
+    end
 
-        binding.const_value
+    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
 
-      def resolve_type_member_const_value(expression)
-        type = resolve_type_expression(expression.receiver)
-        return unless type.is_a?(Types::EnumBase)
+      binding = imported_module.values[value_name]
+      return unless binding&.kind == :const
 
-        type.member_value(expression.member)
-      end
+      binding.const_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 resolve_type_member_const_value(expression)
+      type = resolve_type_expression(expression.receiver)
+      return unless type.is_a?(Types::EnumBase)
 
-      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
+      type.member_value(expression.member)
+    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
+
+          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
 
-            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
+          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?
 
-      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:)
+          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)
           else
-            func = @ctx.functions[expression.callee.name]
+            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]
             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
-          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
+            evaluate_type_returning_call(expression, env:)
           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
+    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
+      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]
-          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]
         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,
+        [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,
             target,
-            attribute_binding.params,
+            application.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
+        initial_vars[param.name] = arg_value
       end
 
-      class ConstFnLowerEvaluator
-        def initialize(lowerer)
-          @lowerer = lowerer
-        end
-
-        def types
-          @lowerer.instance_variable_get(:@ctx).types
-        end
-
-        def evaluate_compile_time_const_value(expression, scopes: nil)
-          @lowerer.send(:compile_time_const_value, expression, env: @lowerer.send(:empty_env))
-        end
-
-        def top_level_function(name)
-          @lowerer.instance_variable_get(:@ctx).functions&.[](name)
-        end
+      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 raise_sema_error(message)
-          raise CompileTime::Error, message
-        end
+    class ConstFnLowerEvaluator
+      def initialize(lowerer)
+        @lowerer = lowerer
       end
 
-      def evaluate_reflection_target_argument(expression, env:)
-        struct_handle = resolve_struct_handle_argument(expression, env:)
-        return struct_handle if struct_handle
+      def types
+        @lowerer.instance_variable_get(:@ctx).types
+      end
 
-        value = compile_time_const_value(expression, env:)
-        return value if value.is_a?(Types::FieldHandle) || value.is_a?(Types::CallableHandle)
+      def evaluate_compile_time_const_value(expression, scopes: nil)
+        @lowerer.compile_time_const_value(expression, env: @lowerer.empty_env)
+      end
 
-        nil
+      def top_level_function(name)
+        @lowerer.instance_variable_get(:@ctx).functions&.[](name)
       end
 
-      def reflection_positional_arguments?(arguments, expected_length)
-        arguments.length == expected_length && arguments.none?(&:name)
+      def raise_sema_error(message)
+        raise CompileTime::Error, message
       end
+    end
 
-      def resolve_struct_handle_argument(expression, env:)
-        type = reflection_type_from_expression(expression, env:)
-        return nil unless type
+    def evaluate_reflection_target_argument(expression, env:)
+      struct_handle = resolve_struct_handle_argument(expression, env:)
+      return struct_handle if struct_handle
 
-        struct_handle_for_type(type)
-      end
+      value = compile_time_const_value(expression, env:)
+      return value if value.is_a?(Types::FieldHandle) || value.is_a?(Types::CallableHandle)
 
-      def reflection_type_from_expression(expression, env:)
-        case expression
-        when AST::Identifier
-          return nil if env && lookup_value(expression.name, env)
+      nil
+    end
 
-          current_type_params[expression.name] || @ctx.types[expression.name]
-        when AST::MemberAccess
-          return nil unless expression.receiver.is_a?(AST::Identifier)
+    def reflection_positional_arguments?(arguments, expected_length)
+      arguments.length == expected_length && arguments.none?(&:name)
+    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
+    def resolve_struct_handle_argument(expression, env:)
+      type = reflection_type_from_expression(expression, env:)
+      return nil unless type
 
-          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)
+      struct_handle_for_type(type)
+    end
 
-          nil
-        else
-          nil
+    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)
+
+        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)
+
+        nil
+      else
+        nil
       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
-          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
         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
-        end
+        Types::CallableHandle.new("#{expression.receiver.name}.#{expression.member}", binding.ast)
+      else
+        nil
       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
-        end
+        imported_module.attributes[expression.member]
+      else
+        nil
       end
+    end
 
-      def reflection_identifier_name(expression)
-        expression.is_a?(AST::Identifier) ? expression.name : nil
-      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 attribute_binding_supports_target?(binding, target)
-        binding && target && binding.targets.include?(attribute_target_kind(target))
+    def attribute_target_kind(target)
+      case target
+      when Types::StructHandle then :struct
+      when Types::FieldHandle then :field
+      when Types::CallableHandle then :callable
       end
+    end
 
-      def attribute_target_kind(target)
-        case target
-        when Types::StructHandle then :struct
-        when Types::FieldHandle then :field
-        when Types::CallableHandle then :callable
-        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
       end
+      return [] unless target_id
 
-      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
+      applications = @ctx.attribute_applications[target_id]
+      return applications if applications
 
-        applications = @ctx.attribute_applications[target_id]
+      @ctx.imports.each_value do |imported_module|
+        applications = imported_module.attribute_applications[target_id]
         return applications if applications
+      end
 
-        @ctx.imports.each_value do |imported_module|
-          applications = imported_module.attribute_applications[target_id]
-          return applications if applications
-        end
+      []
+    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 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 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 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
 
-      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
 
-        type_arguments = infer_function_type_arguments(binding, arguments, env, receiver_type:)
-        instantiate_function_binding(binding, type_arguments)
+    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_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
+      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
 
-        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
+      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 = 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
+      end
 
-          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
 
-        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
+        inferred
+      end
 
-          inferred
-        end
+      instantiate_function_binding(binding, type_arguments)
+    end
 
-        instantiate_function_binding(binding, type_arguments)
+    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 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
+      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
+      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)
+      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
+      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
 
-      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 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
 
-          constraints.interfaces.each do |interface|
-            next if type_implements_interface?(actual_type, interface)
+        constraints.interfaces.each do |interface|
+          next if type_implements_interface?(actual_type, interface)
 
-            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
+          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
 
 
-      def interface_implementation_key(type)
-        return type.definition if type.is_a?(Types::StructInstance)
-
-        type
-      end
+    def interface_implementation_key(type)
+      return type.definition if type.is_a?(Types::StructInstance)
 
-      def type_implements_interface?(type, interface)
-        key = interface_implementation_key(type)
-        return true if @ctx.implemented_interfaces.fetch(key, []).include?(interface)
+      type
+    end
 
-        @ctx.imports.each_value do |module_binding|
-          return true if module_binding.implemented_interfaces.fetch(key, []).include?(interface)
-        end
+    def type_implements_interface?(type, interface)
+      key = interface_implementation_key(type)
+      return true if @ctx.implemented_interfaces.fetch(key, []).include?(interface)
 
-        false
+      @ctx.imports.each_value do |module_binding|
+        return true if module_binding.implemented_interfaces.fetch(key, []).include?(interface)
       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
+      false
+    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
+    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
 
-          inferred
-        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
 
+      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
+      end
+    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)
-        end
 
-        nil
+    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
 
-      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
-
-          value.name.parts.first
-        end
+      nil
+    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
+    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
 
-        expected_names
+        value.name.parts.first
       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
+      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
 
-          value.name.parts.first
-        end
+      expected_names
+    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 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
 
-        names
+        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)
-          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?)
 
-          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)
+      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)
-          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
 
-          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)
+        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)
 
-          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
+        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
 
-          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
+        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)
 
-          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)
+        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::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
+        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
+
+        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
-          substitutions
-        else
-          {}
         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)
+
+        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
+
+    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
+        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
+        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
 
-          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
+        return unless actual_type.is_a?(Types::GenericInstance)
+        return unless actual_type.name == pattern_type.name && actual_type.arguments.length == pattern_type.arguments.length
 
-          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
+        pattern_type.arguments.zip(actual_type.arguments).each do |expected_argument, actual_argument|
+          next if expected_argument.is_a?(Types::LiteralTypeArg)
 
-          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(expected_argument, actual_argument, substitutions, function_name)
+        end
+      when Types::Span
+        return unless actual_type.is_a?(Types::Span)
 
-          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.element_type, actual_type.element_type, substitutions, function_name)
+      when Types::Task
+        return unless actual_type.is_a?(Types::Task)
 
-            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
+        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)
-          end
-          collect_type_substitutions(pattern_type.return_type, actual_type.return_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
+    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)
+      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)
+      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 || {}
+    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:))
+        end
+        return Types::Registry.function(nil, params:, return_type: resolve_type_ref(type_ref.return_type, type_params:))
       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:))
-          end
-          return Types::Registry.function(nil, params:, return_type: resolve_type_ref(type_ref.return_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
 
-        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::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:)
           end
-          return Types::Registry.proc(params:, return_type: resolve_type_ref(type_ref.return_type, type_params:))
         end
+        has_named = names.any?
+        return Types::Registry.tuple(element_types, field_names: has_named ? names : nil)
+      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
+      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
 
-        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:)
+              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
-              names << nil
-              element_types << resolve_type_ref(et, type_params:)
+              raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
             end
           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)
-                 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
-
-               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
-
-         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
-
-      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
-        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]
-            return type if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
-          end
+
+          type
+        else
+          raise LoweringError.new("unknown type #{type_ref.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
 
-        nil
-      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)
 
-      # 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"
+        type_ref.nullable ? Types::Registry.nullable(base) : base
+    end
 
-        binding = lookup_value(parts.first, @type_resolution_env)
-        handle = binding && binding[:const_value]
-        return nil unless handle.is_a?(Types::FieldHandle)
+    def resolve_nested_type_ref(parts)
+      current = @ctx.types[parts.first]
+      return nil unless current.is_a?(Types::Struct) || current.is_a?(Types::GenericStructDefinition)
 
-        # 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)
+      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
 
-      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
+    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
 
-      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
+      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"
+
+      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
+
+    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
       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
+    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
 
-        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
+    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