mt-lang 0.3.8 → 0.3.10

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

@@ -3,482 +3,495 @@
 module MilkTea
   class CBackend
     module Expressions
-      private
-
-
-          def emit_expression(expression)
-            case expression
-            when IR::Name
-              expression.name
-            when IR::Member
-              operator = pointer_member_receiver?(expression.receiver) ? "->" : "."
-              member = "#{wrap_member_receiver(expression.receiver)}#{operator}#{sanitize_c_identifier(expression.member)}"
-              expression.type.is_a?(Types::Primitive) && expression.type.void? ? "((void)(#{member}))" : member
-            when IR::Index
-              "#{wrap_index_receiver(expression.receiver)}[#{emit_expression(expression.index)}]"
-            when IR::CheckedIndex
-              if (alias_name = checked_index_alias(expression))
-                "(*#{alias_name})"
-              else
-                "(*#{checked_array_index_helper_name(expression.receiver_type)}(#{emit_address_of_operand(expression.receiver)}, #{emit_expression(expression.index)}))"
-              end
-            when IR::CheckedSpanIndex
-              if (alias_name = checked_index_alias(expression))
-                "(*#{alias_name})"
-              else
-                "(*#{checked_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)}))"
-              end
-            when IR::NullableIndex
-              "#{nullable_array_index_helper_name(expression.receiver_type)}(#{emit_address_of_operand(expression.receiver)}, #{emit_expression(expression.index)})"
-            when IR::NullableSpanIndex
-              "#{nullable_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)})"
-            when IR::Call
-              if array_type?(expression.type)
-                location = [@source_path, @current_line && "line #{@current_line}"].compact.join(" ")
-                msg = "array-return call must be materialized before C emission"
-                msg += " (#{location})" unless location.empty?
-                raise CBackendError.new(msg, line: @current_line, path: @source_path)
-              end
-
-              emit_call_expression(expression)
-            when IR::Unary
-              if expression.operator == "not"
-                "!#{wrap_expression(expression.operand)}"
-              else
-                "#{expression.operator}#{wrap_expression(expression.operand)}"
-              end
-            when IR::Binary
-              return emit_str_equality_expression(expression) if str_equality_expression?(expression)
-              return emit_variant_equality_expression(expression) if variant_equality_expression?(expression)
-              return emit_nullable_null_comparison(expression) if nullable_null_comparison?(expression)
-
-              emit_binary_expression(expression)
-            when IR::Conditional
-              emit_conditional_expression(expression)
-            when IR::ReinterpretExpr
-              if no_op_reinterpret?(expression.target_type, expression.source_type)
-                emit_expression(expression.expression)
-              else
-                "#{reinterpret_helper_name(expression.target_type, expression.source_type)}(#{emit_expression(expression.expression)})"
-              end
-            when IR::SizeofExpr
-              "sizeof(#{layout_type_expression(expression.target_type)})"
-            when IR::AlignofExpr
-              "_Alignof(#{layout_type_expression(expression.target_type)})"
-            when IR::OffsetofExpr
-              "offsetof(#{layout_type_expression(expression.target_type)}, #{sanitize_c_identifier(expression.field)})"
-            when IR::IntegerLiteral
-              expression.value.to_s
-            when IR::FloatLiteral
-              emit_float_literal(expression)
-            when IR::StringLiteral
-              expression.type.is_a?(Types::StringView) ? emit_str_literal(expression) : expression.value.inspect
-            when IR::BooleanLiteral
-              expression.value ? "true" : "false"
-            when IR::NullLiteral
-              nullable_value_type?(expression.type) ? emit_zero_expression(expression.type) : "NULL"
-            when IR::ZeroInit
-              emit_zero_expression(expression.type)
-            when IR::AddressOf
-              case expression.expression
-              when IR::CheckedIndex
-                alias_name = checked_index_alias(expression.expression)
-                alias_name || "#{checked_array_index_helper_name(expression.expression.receiver_type)}(#{emit_address_of_operand(expression.expression.receiver)}, #{emit_expression(expression.expression.index)})"
-              when IR::CheckedSpanIndex
-                alias_name = checked_index_alias(expression.expression)
-                alias_name || "#{checked_span_index_helper_name(expression.expression.receiver_type)}(#{emit_expression(expression.expression.receiver)}, #{emit_expression(expression.expression.index)})"
-              else
-                emit_address_of_operand(expression.expression)
-              end
-            when IR::Cast
-              if no_op_cast?(expression)
-                emit_expression(expression.expression)
-              else
-                "(#{c_type(expression.target_type)}) #{emit_cast_operand(expression.expression)}"
-              end
-            when IR::AggregateLiteral
-              emit_aggregate_literal(expression)
-            when IR::ArrayLiteral
-              emit_array_compound_literal(expression)
-            when IR::SimdLaneWith
-              emit_simd_lane_with(expression)
-            when IR::VariantLiteral
-              emit_variant_literal(expression)
-            else
-              raise CBackendError.new("unsupported IR expression #{expression.class.name}", line: 0, column: 0, path: @path)
-            end
-          end
-
-          def str_equality_expression?(expression)
-            EQUALITY_OPERATORS.include?(expression.operator) && expression.left.type.is_a?(Types::StringView) && expression.right.type.is_a?(Types::StringView)
-          end
-
-          def emit_binary_expression(expression)
-            parent_precedence = binary_precedence(expression.operator)
-            left = emit_binary_operand(expression.left, parent_precedence, side: :left)
-            right = emit_binary_operand(expression.right, parent_precedence, side: :right)
-            "#{left} #{c_operator(expression.operator)} #{right}"
-          end
-
-          def emit_binary_operand(expression, parent_precedence, side:)
-            text = emit_expression(expression)
-
-            case expression
-            when IR::Conditional
-              "(#{text})"
-            when IR::Binary
-              child_precedence = binary_precedence(expression.operator)
-              if child_precedence < parent_precedence || (side == :right && child_precedence == parent_precedence)
-                "(#{text})"
-              else
-                text
-              end
-            else
-              text
-            end
-          end
-
-          def emit_conditional_expression(expression)
-            condition = emit_conditional_condition(expression.condition)
-            then_expression = emit_expression(expression.then_expression)
-            else_expression = emit_expression(expression.else_expression)
-            "#{condition} ? #{then_expression} : #{else_expression}"
-          end
-
-          def emit_conditional_condition(expression)
-            text = emit_expression(expression)
-            expression.is_a?(IR::Conditional) ? "(#{text})" : text
-          end
-
-          def binary_precedence(operator)
-            case operator
-            when "or" then 1
-            when "and" then 2
-            when "|" then 3
-            when "^" then 4
-            when "&" then 5
-            when "==", "!=" then 6
-            when "<", "<=", ">", ">=" then 7
-            when "<<", ">>" then 8
-            when "+", "-" then 9
-            when "*", "/", "%" then 10
-            else
-              raise CBackendError.new("unsupported binary operator #{operator}", line: 0, column: 0, path: @path)
-            end
-          end
-
-          def emit_str_equality_expression(expression)
-            call = "mt_str_equal(#{emit_expression(expression.left)}, #{emit_expression(expression.right)})"
-            expression.operator == "!=" ? "!#{call}" : call
-          end
-
-          def variant_equality_expression?(expression)
-            EQUALITY_OPERATORS.include?(expression.operator) &&
-              (expression.left.type.is_a?(Types::Variant) || expression.left.type.is_a?(Types::VariantArmPayload))
-          end
-
-          def emit_variant_equality_expression(expression)
-            helper_name = variant_equality_helper_name(expression.left.type)
-            call = "#{helper_name}(#{emit_expression(expression.left)}, #{emit_expression(expression.right)})"
-            expression.operator == "!=" ? "!#{call}" : call
-          end
-
-          def variant_equality_helper_name(type)
-            variant = type.is_a?(Types::VariantArmPayload) ? type.variant_type : type
-            "mt_variant_eq_#{named_type_c_name(variant)}"
-          end
-
-          def nullable_value_type?(type)
-            type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(type.base)
-          end
-
-          def nullable_null_comparison?(expression)
-            return false unless EQUALITY_OPERATORS.include?(expression.operator)
-
-            (nullable_value_type?(expression.left.type) && expression.right.is_a?(IR::NullLiteral)) ||
-              (nullable_value_type?(expression.right.type) && expression.left.is_a?(IR::NullLiteral))
-          end
-
-          def emit_nullable_null_comparison(expression)
-            operand = expression.left.is_a?(IR::NullLiteral) ? expression.right : expression.left
-            access = "#{wrap_member_receiver(operand)}.has_value"
-            expression.operator == "==" ? "!#{access}" : access
-          end
-
-          def emit_initializer(expression)
-            case expression
-            when IR::ArrayLiteral
-              emit_array_initializer(expression)
-            when IR::AggregateLiteral
-              emit_aggregate_initializer(expression)
-            when IR::VariantLiteral
-              emit_variant_initializer(expression)
-            when IR::StringLiteral
-              expression.type.is_a?(Types::StringView) ? emit_str_initializer(expression) : emit_expression(expression)
-            when IR::ZeroInit
-              emit_zero_initializer(expression.type)
-            else
-              emit_expression(expression)
-            end
-          end
-
-          def emit_aggregate_initializer(expression)
-            return emit_zero_initializer(expression.type) if expression.fields.empty?
-
-            fields = expression.fields.map do |field|
-              ".#{sanitize_c_identifier(field.name)} = #{emit_aggregate_field_initializer(expression.type, field)}"
-            end.join(", ")
-            "{ #{fields} }"
-          end
-
-          def emit_variant_initializer(expression)
-            outer_c = named_type_c_name(expression.type)
-            kind_constant = "#{outer_c}_kind_#{expression.arm_name}"
-            if expression.fields.empty?
-              "{ .kind = #{kind_constant} }"
-            else
-              payload_fields = expression.fields.map { |field| ".#{sanitize_c_identifier(field.name)} = #{emit_variant_field_initializer(expression.type, expression.arm_name, field)}" }.join(", ")
-              "{ .kind = #{kind_constant}, .data.#{sanitize_c_identifier(expression.arm_name)} = { #{payload_fields} } }"
-            end
-          end
-
-          def emit_str_initializer(expression)
-            if @str_literal_map && @str_literal_map[expression.value]
-              @str_literal_map[expression.value]
-            else
-              "{ .data = #{expression.value.inspect}, .len = #{expression.value.bytesize} }"
-            end
-          end
-
-          def emit_aggregate_literal(expression)
-            return emit_zero_expression(expression.type) if expression.fields.empty?
-
-            fields = expression.fields.map do |field|
-              ".#{sanitize_c_identifier(field.name)} = #{emit_aggregate_field_initializer(expression.type, field)}"
-            end.join(", ")
-            "(#{c_type(expression.type)}){ #{fields} }"
-          end
-
-          def emit_variant_literal(expression)
-            outer_c = named_type_c_name(expression.type)
-            kind_constant = "#{outer_c}_kind_#{expression.arm_name}"
-            if expression.fields.empty?
-              "(#{outer_c}){ .kind = #{kind_constant} }"
-            else
-              arm_c = "#{outer_c}_#{expression.arm_name}"
-              payload_fields = expression.fields.map { |field| ".#{sanitize_c_identifier(field.name)} = #{emit_variant_field_initializer(expression.type, expression.arm_name, field)}" }.join(", ")
-              "(#{outer_c}){ .kind = #{kind_constant}, .data.#{sanitize_c_identifier(expression.arm_name)} = (struct #{arm_c}){ #{payload_fields} } }"
-            end
-          end
-
-          def emit_call_expression(expression, array_out_argument: nil)
-            callee = expression.callee.is_a?(String) ? expression.callee : emit_call_callee(expression.callee)
-            omit_receiver = omitted_method_receiver_call?(expression)
-            arguments = []
-            arguments << array_out_argument if array_out_argument
-            arguments.concat(expression.arguments.drop(omit_receiver ? 1 : 0).map { |argument| emit_expression(argument) })
-            call = "#{callee}(#{arguments.join(', ')})"
-            return call unless omit_receiver && expression.arguments.any?
-            return call if side_effect_free_expression?(expression.arguments.first)
-
-            "(#{discarded_expression(expression.arguments.first)}, #{call})"
-          end
-
-          def emit_array_call_statement(expression, out_argument, indent)
-            "#{indent}#{emit_call_expression(expression, array_out_argument: out_argument)};"
-          end
-
-          def emit_array_copy_statement(destination, source, indent)
-            "#{indent}memcpy(#{destination}, #{emit_expression(source)}, sizeof(#{destination}));"
-          end
-
-          def emit_array_return(expression, indent)
-            if expression.is_a?(IR::Call) && array_type?(expression.type)
-              return [emit_array_call_statement(expression, ARRAY_OUT_PARAM_NAME, indent), "#{indent}return;"]
-            end
-
-            [
-              emit_array_copy_statement("*#{ARRAY_OUT_PARAM_NAME}", expression, indent),
-              "#{indent}return;",
-            ]
-          end
-
-          def emitted_function_params(function)
-            omitted_method_receiver_function?(function) ? function.params.drop(1) : function.params
-          end
-
-          def omitted_method_receiver_call?(expression)
-            expression.callee.is_a?(String) && omitted_method_receiver_function_names.key?(expression.callee)
-          end
-
-          def omitted_method_receiver_function_names
-            @omitted_method_receiver_function_names ||= emitted_functions.each_with_object({}) do |function, omitted|
-              omitted[function.linkage_name] = true if omitted_method_receiver_function?(function)
-            end
-          end
-
-          def omitted_method_receiver_function?(function)
-            function.method_receiver_param &&
-              function.params.first &&
-              name_reference_count_in_statements(function.body, function.params.first.linkage_name).zero?
-          end
-
-          def discarded_expression(expression)
-            "(void)#{wrap_expression(expression)}"
-          end
-
-          def emit_address_of_operand(expression)
-            return emit_expression(expression.operand) if expression.is_a?(IR::Unary) && expression.operator == "*"
-
-            "&#{wrap_expression(expression)}"
-          end
-
-          def emit_cast_operand(expression)
-            case expression
-            when IR::Name, IR::IntegerLiteral, IR::FloatLiteral, IR::StringLiteral, IR::BooleanLiteral, IR::NullLiteral, IR::ZeroInit, IR::Member, IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex, IR::Call, IR::AggregateLiteral, IR::ArrayLiteral, IR::ReinterpretExpr, IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr, IR::AddressOf, IR::Cast, IR::Unary
-              emit_expression(expression)
-            else
-              "(#{emit_expression(expression)})"
-            end
-          end
-
-          def emit_call_callee(expression)
-            case expression
-            when IR::Name, IR::Member, IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex, IR::Call
-              emit_expression(expression)
-            else
-              wrap_expression(expression)
-            end
-          end
-
-          def emit_array_out_argument(destination)
-            "&#{destination}"
-          end
-
-          def emit_array_initializer(expression)
-            return "{ 0 }" if expression.elements.empty?
-
-            elements = expression.elements.map { |element| emit_initializer(element) }.join(", ")
-            "{ #{elements} }"
-          end
-
-          def emit_array_compound_literal(expression)
-            "(#{c_declaration(expression.type, '')}) #{emit_array_initializer(expression)}"
-          end
-
-          def emit_simd_lane_with(expression)
-            simd_type = expression.type
-            elem_c = primitive_c_type(simd_type.element_type.name)
-            src = wrap_expression(expression.src)
-            idx = emit_expression(expression.index)
-            val = wrap_expression(expression.value)
-            "({ #{c_type(simd_type)} _mt_with = #{src}; ((#{elem_c}*)&_mt_with)[#{idx}] = #{val}; _mt_with; })"
-          end
-
-          def emit_zero_initializer(type)
-            return "{ 0 }" if type.is_a?(Types::StringView)
-            return "{ 0 }" if array_type?(type)
-            return "NULL" if type.is_a?(Types::Nullable) && c_backend_pointer_like_type?(type.base)
-            return "{ 0 }" if type.is_a?(Types::Nullable)
-            return "NULL" if raw_pointer_type?(type) || ref_type?(type)
-            return "NULL" if type.is_a?(Types::Opaque) && !type.external
-            return "false" if type.is_a?(Types::Primitive) && type.boolean?
-            return "0.0" if type.is_a?(Types::Primitive) && type.float?
-            return "0" if type.is_a?(Types::Primitive) && !type.void?
-            return "(#{c_type(type)}) 0" if type.is_a?(Types::EnumBase)
-
-            "{ 0 }"
-          end
-
-          def emit_zero_expression(type)
-            return "(#{c_type(type)}) #{emit_zero_initializer(type)}" if type.is_a?(Types::StringView)
-            return "NULL" if type.is_a?(Types::Nullable) && c_backend_pointer_like_type?(type.base)
-            return "(#{c_type(type)}){ 0 }" if type.is_a?(Types::Nullable)
-            return emit_zero_initializer(type) if type.is_a?(Types::Primitive)
-            return emit_zero_initializer(type) if type.is_a?(Types::EnumBase)
-
-            "(#{c_declaration(type, '')}) #{emit_zero_initializer(type)}"
-          end
-
-          def aggregate_field_type(type, field_name)
-            return proc_field_types(type).fetch(field_name) if type.is_a?(Types::Proc)
-            if type.is_a?(Types::Nullable)
-              return Types::Registry.primitive("bool") if field_name == "has_value"
-              return type.base if field_name == "value"
-            end
-            return type.field(field_name) if type.respond_to?(:field)
-
-            raise CBackendError.new("unsupported aggregate field lookup for #{type}", line: 0, column: 0, path: @path)
-          end
-
-          def emit_aggregate_field_initializer(type, field)
-            field_type = aggregate_field_type(type, field.name)
-            if field_type.is_a?(Types::Nullable) && !field.value.type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(field_type.base)
-              emit_nullable_some_initializer(field_type, field.value)
-            elsif void_storage_field?(field_type)
-              emit_void_field_initializer(field.value)
-            else
-              emit_initializer(field.value)
-            end
-          end
-
-          def emit_nullable_some_initializer(nullable_type, value)
-            "(#{c_type(nullable_type)}){ .has_value = true, .value = #{emit_initializer(value)} }"
-          end
-
-          def emit_variant_field_initializer(type, arm_name, field)
-            field_type = type.arm(arm_name).fetch(field.name)
-            if field_type.is_a?(Types::Nullable) && !field.value.type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(field_type.base)
-              emit_nullable_some_initializer(field_type, field.value)
-            elsif field.value.is_a?(IR::AddressOf) && !field_type.is_a?(Types::Nullable)
-              c_type_name = named_type_c_name(field_type)
-              inner = field.value.expression
-              "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
-            elsif void_storage_field?(field_type)
-              emit_void_field_initializer(field.value)
-            else
-              emit_initializer(field.value)
-            end
-          end
-
-          def emit_void_field_initializer(expression)
-            "(#{emit_expression(expression)}, 0)"
-          end
-
-          def void_storage_field?(type)
-            type.is_a?(Types::Primitive) && type.void?
-          end
-
-          def emit_str_literal(expression)
-            if @str_literal_map && @str_literal_map[expression.value]
-              @str_literal_map[expression.value]
-            else
-              "(mt_str){ .data = #{expression.value.inspect}, .len = #{expression.value.bytesize} }"
-            end
-          end
-
-          def emit_float_literal(expression)
-            value = expression.value
-            literal = if value.finite? && value == value.to_i
-                        format("%.1f", value)
-                      else
-                        value.to_s
-                      end
-            expression.type.name == "float" ? "#{literal}f" : literal
-          end
-
-          def wrap_expression(expression)
-            case expression
-            when IR::Name, IR::IntegerLiteral, IR::FloatLiteral, IR::StringLiteral, IR::BooleanLiteral, IR::NullLiteral, IR::ZeroInit, IR::Member, IR::Index, IR::Call, IR::AggregateLiteral, IR::ArrayLiteral, IR::ReinterpretExpr, IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
-              emit_expression(expression)
-            else
-              "(#{emit_expression(expression)})"
-            end
-          end
-
-          def layout_type_expression(type)
-            c_declaration(type, "")
-          end
+      def emit_expression(expression)
+        case expression
+        when IR::Name
+          expression.name
+        when IR::Member
+          operator = pointer_member_receiver?(expression.receiver) ? "->" : "."
+          member = "#{wrap_member_receiver(expression.receiver)}#{operator}#{sanitize_c_identifier(expression.member)}"
+          expression.type.is_a?(Types::Primitive) && expression.type.void? ? "((void)(#{member}))" : member
+        when IR::Index
+          "#{wrap_index_receiver(expression.receiver)}[#{emit_expression(expression.index)}]"
+        when IR::CheckedIndex
+          if (alias_name = checked_index_alias(expression))
+            "(*#{alias_name})"
+          else
+            "(*#{checked_array_index_helper_name(expression.receiver_type)}(#{emit_address_of_operand(expression.receiver)}, #{emit_expression(expression.index)}))"
+          end
+        when IR::CheckedSpanIndex
+          if (alias_name = checked_index_alias(expression))
+            "(*#{alias_name})"
+          else
+            "(*#{checked_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)}))"
+          end
+        when IR::NullableIndex
+          "#{nullable_array_index_helper_name(expression.receiver_type)}(#{emit_address_of_operand(expression.receiver)}, #{emit_expression(expression.index)})"
+        when IR::NullableSpanIndex
+          "#{nullable_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)})"
+        when IR::Call
+          if array_type?(expression.type)
+            location = [@source_path, @current_line && "line #{@current_line}"].compact.join(" ")
+            msg = "array-return call must be materialized before C emission"
+            msg += " (#{location})" unless location.empty?
+            raise CBackendError.new(msg, line: @current_line, path: @source_path)
+          end
+
+          emit_call_expression(expression)
+        when IR::Unary
+          if expression.operator == "not"
+            "!#{wrap_expression(expression.operand)}"
+          else
+            "#{expression.operator}#{wrap_expression(expression.operand)}"
+          end
+        when IR::Binary
+          return emit_str_equality_expression(expression) if str_equality_expression?(expression)
+          return emit_variant_equality_expression(expression) if variant_equality_expression?(expression)
+          return emit_nullable_null_comparison(expression) if nullable_null_comparison?(expression)
+
+          emit_binary_expression(expression)
+        when IR::Conditional
+          emit_conditional_expression(expression)
+        when IR::ReinterpretExpr
+          if no_op_reinterpret?(expression.target_type, expression.source_type)
+            emit_expression(expression.expression)
+          else
+            "#{reinterpret_helper_name(expression.target_type, expression.source_type)}(#{emit_expression(expression.expression)})"
+          end
+        when IR::SizeofExpr
+          "sizeof(#{layout_type_expression(expression.target_type)})"
+        when IR::AlignofExpr
+          "_Alignof(#{layout_type_expression(expression.target_type)})"
+        when IR::OffsetofExpr
+          "offsetof(#{layout_type_expression(expression.target_type)}, #{sanitize_c_identifier(expression.field)})"
+        when IR::IntegerLiteral
+          expression.value.to_s
+        when IR::FloatLiteral
+          emit_float_literal(expression)
+        when IR::StringLiteral
+          expression.type.is_a?(Types::StringView) ? emit_str_literal(expression) : expression.value.inspect
+        when IR::BooleanLiteral
+          expression.value ? "true" : "false"
+        when IR::NullLiteral
+          nullable_value_type?(expression.type) ? emit_zero_expression(expression.type) : "NULL"
+        when IR::ZeroInit
+          emit_zero_expression(expression.type)
+        when IR::AddressOf
+          case expression.expression
+          when IR::CheckedIndex
+            alias_name = checked_index_alias(expression.expression)
+            alias_name || "#{checked_array_index_helper_name(expression.expression.receiver_type)}(#{emit_address_of_operand(expression.expression.receiver)}, #{emit_expression(expression.expression.index)})"
+          when IR::CheckedSpanIndex
+            alias_name = checked_index_alias(expression.expression)
+            alias_name || "#{checked_span_index_helper_name(expression.expression.receiver_type)}(#{emit_expression(expression.expression.receiver)}, #{emit_expression(expression.expression.index)})"
+          else
+            emit_address_of_operand(expression.expression)
+          end
+        when IR::Cast
+          if no_op_cast?(expression)
+            emit_expression(expression.expression)
+          else
+            "(#{c_type(expression.target_type)}) #{emit_cast_operand(expression.expression)}"
+          end
+        when IR::AggregateLiteral
+          emit_aggregate_literal(expression)
+        when IR::ArrayLiteral
+          emit_array_compound_literal(expression)
+        when IR::SimdLaneWith
+          emit_simd_lane_with(expression)
+        when IR::VariantLiteral
+          emit_variant_literal(expression)
+        else
+          raise CBackendError.new("unsupported IR expression #{expression.class.name}", line: 0, column: 0, path: @path)
+        end
+      end
+
+      def str_equality_expression?(expression)
+        EQUALITY_OPERATORS.include?(expression.operator) && expression.left.type.is_a?(Types::StringView) && expression.right.type.is_a?(Types::StringView)
+      end
+
+      def emit_binary_expression(expression)
+        parent_precedence = binary_precedence(expression.operator)
+        left = emit_binary_operand(expression.left, parent_precedence, side: :left)
+        right = emit_binary_operand(expression.right, parent_precedence, side: :right)
+        "#{left} #{c_operator(expression.operator)} #{right}"
+      end
+
+      def emit_binary_operand(expression, parent_precedence, side:)
+        text = emit_expression(expression)
+
+        case expression
+        when IR::Conditional
+          "(#{text})"
+        when IR::Binary
+          child_precedence = binary_precedence(expression.operator)
+          if child_precedence < parent_precedence || (side == :right && child_precedence == parent_precedence)
+            "(#{text})"
+          else
+            text
+          end
+        else
+          text
+        end
+      end
+
+      def emit_conditional_expression(expression)
+        condition = emit_conditional_condition(expression.condition)
+        then_expression = emit_expression(expression.then_expression)
+        else_expression = emit_expression(expression.else_expression)
+        "#{condition} ? #{then_expression} : #{else_expression}"
+      end
+
+      def emit_conditional_condition(expression)
+        text = emit_expression(expression)
+        expression.is_a?(IR::Conditional) ? "(#{text})" : text
+      end
+
+      def binary_precedence(operator)
+        case operator
+        when "or" then 1
+        when "and" then 2
+        when "|" then 3
+        when "^" then 4
+        when "&" then 5
+        when "==", "!=" then 6
+        when "<", "<=", ">", ">=" then 7
+        when "<<", ">>" then 8
+        when "+", "-" then 9
+        when "*", "/", "%" then 10
+        else
+          raise CBackendError.new("unsupported binary operator #{operator}", line: 0, column: 0, path: @path)
+        end
+      end
+
+      def emit_str_equality_expression(expression)
+        call = "mt_str_equal(#{emit_expression(expression.left)}, #{emit_expression(expression.right)})"
+        expression.operator == "!=" ? "!#{call}" : call
+      end
+
+      def variant_equality_expression?(expression)
+        EQUALITY_OPERATORS.include?(expression.operator) &&
+          (expression.left.type.is_a?(Types::Variant) || expression.left.type.is_a?(Types::VariantArmPayload))
+      end
+
+      def emit_variant_equality_expression(expression)
+        helper_name = variant_equality_helper_name(expression.left.type)
+        call = "#{helper_name}(#{emit_expression(expression.left)}, #{emit_expression(expression.right)})"
+        expression.operator == "!=" ? "!#{call}" : call
+      end
+
+      def variant_equality_helper_name(type)
+        variant = type.is_a?(Types::VariantArmPayload) ? type.variant_type : type
+        "mt_variant_eq_#{named_type_c_name(variant)}"
+      end
+
+      def nullable_value_type?(type)
+        type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(type.base)
+      end
+
+      def nullable_null_comparison?(expression)
+        return false unless EQUALITY_OPERATORS.include?(expression.operator)
+
+        (nullable_value_type?(expression.left.type) && expression.right.is_a?(IR::NullLiteral)) ||
+          (nullable_value_type?(expression.right.type) && expression.left.is_a?(IR::NullLiteral))
+      end
+
+      def emit_nullable_null_comparison(expression)
+        operand = expression.left.is_a?(IR::NullLiteral) ? expression.right : expression.left
+        access = "#{wrap_member_receiver(operand)}.has_value"
+        expression.operator == "==" ? "!#{access}" : access
+      end
+
+      def emit_initializer(expression)
+        case expression
+        when IR::ArrayLiteral
+          emit_array_initializer(expression)
+        when IR::AggregateLiteral
+          emit_aggregate_initializer(expression)
+        when IR::VariantLiteral
+          emit_variant_initializer(expression)
+        when IR::StringLiteral
+          expression.type.is_a?(Types::StringView) ? emit_str_initializer(expression) : emit_expression(expression)
+        when IR::ZeroInit
+          emit_zero_initializer(expression.type)
+        else
+          emit_expression(expression)
+        end
+      end
+
+      def emit_aggregate_initializer(expression)
+        return emit_zero_initializer(expression.type) if expression.fields.empty?
+
+        fields = expression.fields.map do |field|
+          ".#{sanitize_c_identifier(field.name)} = #{emit_aggregate_field_initializer(expression.type, field)}"
+        end.join(", ")
+        "{ #{fields} }"
+      end
+
+      def emit_variant_initializer(expression)
+        outer_c = named_type_c_name(expression.type)
+        kind_constant = "#{outer_c}_kind_#{expression.arm_name}"
+        if expression.fields.empty?
+          "{ .kind = #{kind_constant} }"
+        else
+          payload_fields = expression.fields.map { |field| ".#{sanitize_c_identifier(field.name)} = #{emit_variant_field_initializer(expression.type, expression.arm_name, field)}" }.join(", ")
+          "{ .kind = #{kind_constant}, .data.#{sanitize_c_identifier(expression.arm_name)} = { #{payload_fields} } }"
+        end
+      end
+
+      def emit_str_initializer(expression)
+        if @str_literal_map && @str_literal_map[expression.value]
+          @str_literal_map[expression.value]
+        else
+          "{ .data = #{expression.value.inspect}, .len = #{expression.value.bytesize} }"
+        end
+      end
+
+      def emit_aggregate_literal(expression)
+        return emit_zero_expression(expression.type) if expression.fields.empty?
+
+        fields = expression.fields.map do |field|
+          ".#{sanitize_c_identifier(field.name)} = #{emit_aggregate_field_initializer(expression.type, field)}"
+        end.join(", ")
+        "(#{c_type(expression.type)}){ #{fields} }"
+      end
+
+      def emit_variant_literal(expression)
+        outer_c = named_type_c_name(expression.type)
+        kind_constant = "#{outer_c}_kind_#{expression.arm_name}"
+        if expression.fields.empty?
+          "(#{outer_c}){ .kind = #{kind_constant} }"
+        else
+          arm_c = "#{outer_c}_#{expression.arm_name}"
+          payload_fields = expression.fields.map { |field| ".#{sanitize_c_identifier(field.name)} = #{emit_variant_field_initializer(expression.type, expression.arm_name, field)}" }.join(", ")
+          "(#{outer_c}){ .kind = #{kind_constant}, .data.#{sanitize_c_identifier(expression.arm_name)} = (struct #{arm_c}){ #{payload_fields} } }"
+        end
+      end
+
+      def emit_call_expression(expression, array_out_argument: nil)
+        callee = expression.callee.is_a?(String) ? expression.callee : emit_call_callee(expression.callee)
+        omit_receiver = omitted_method_receiver_call?(expression)
+        arguments = []
+        arguments << array_out_argument if array_out_argument
+        arguments.concat(expression.arguments.drop(omit_receiver ? 1 : 0).map { |argument| emit_expression(argument) })
+        call = "#{callee}(#{arguments.join(', ')})"
+        return call unless omit_receiver && expression.arguments.any?
+        return call if side_effect_free_expression?(expression.arguments.first)
+
+        "(#{discarded_expression(expression.arguments.first)}, #{call})"
+      end
+
+      def emit_array_call_statement(expression, out_argument, indent)
+        "#{indent}#{emit_call_expression(expression, array_out_argument: out_argument)};"
+      end
+
+      def emit_array_copy_statement(destination, source, indent)
+        "#{indent}memcpy(#{destination}, #{emit_expression(source)}, sizeof(#{destination}));"
+      end
+
+      def emit_array_return(expression, indent)
+        if expression.is_a?(IR::Call) && array_type?(expression.type)
+          return [emit_array_call_statement(expression, ARRAY_OUT_PARAM_NAME, indent), "#{indent}return;"]
+        end
+
+        [
+          emit_array_copy_statement("*#{ARRAY_OUT_PARAM_NAME}", expression, indent),
+          "#{indent}return;",
+        ]
+      end
+
+      def emitted_function_params(function)
+        omitted_method_receiver_function?(function) ? function.params.drop(1) : function.params
+      end
+
+      def omitted_method_receiver_call?(expression)
+        expression.callee.is_a?(String) && omitted_method_receiver_function_names.key?(expression.callee)
+      end
+
+      def omitted_method_receiver_function_names
+        @omitted_method_receiver_function_names ||= emitted_functions.each_with_object({}) do |function, omitted|
+          omitted[function.linkage_name] = true if omitted_method_receiver_function?(function)
+        end
+      end
+
+      def omitted_method_receiver_function?(function)
+        function.method_receiver_param &&
+          function.params.first &&
+          name_reference_count_in_statements(function.body, function.params.first.linkage_name).zero?
+      end
+
+      def discarded_expression(expression)
+        "(void)#{wrap_expression(expression)}"
+      end
+
+      def emit_address_of_operand(expression)
+        return emit_expression(expression.operand) if expression.is_a?(IR::Unary) && expression.operator == "*"
+
+        "&#{wrap_expression(expression)}"
+      end
+
+      def emit_cast_operand(expression)
+        case expression
+        when IR::Name, IR::IntegerLiteral, IR::FloatLiteral, IR::StringLiteral, IR::BooleanLiteral, IR::NullLiteral, IR::ZeroInit, IR::Member, IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex, IR::Call, IR::AggregateLiteral, IR::ArrayLiteral, IR::ReinterpretExpr, IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr, IR::AddressOf, IR::Cast, IR::Unary
+          emit_expression(expression)
+        else
+          "(#{emit_expression(expression)})"
+        end
+      end
+
+      def emit_call_callee(expression)
+        case expression
+        when IR::Name, IR::Member, IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex, IR::Call
+          emit_expression(expression)
+        else
+          wrap_expression(expression)
+        end
+      end
+
+      def emit_array_out_argument(destination)
+        "&#{destination}"
+      end
+
+      def emit_array_initializer(expression)
+        return "{ 0 }" if expression.elements.empty?
+
+        elements = expression.elements.map { |element| emit_initializer(element) }.join(", ")
+        "{ #{elements} }"
+      end
+
+      def emit_array_compound_literal(expression)
+        "(#{c_declaration(expression.type, '')}) #{emit_array_initializer(expression)}"
+      end
+
+      def emit_simd_lane_with(expression)
+        simd_type = expression.type
+        elem_c = primitive_c_type(simd_type.element_type.name)
+        src = wrap_expression(expression.src)
+        idx = emit_expression(expression.index)
+        val = wrap_expression(expression.value)
+        "({ #{c_type(simd_type)} _mt_with = #{src}; ((#{elem_c}*)&_mt_with)[#{idx}] = #{val}; _mt_with; })"
+      end
+
+      def emit_zero_initializer(type)
+        return "{ 0 }" if type.is_a?(Types::StringView)
+        return "{ 0 }" if array_type?(type)
+        return "NULL" if type.is_a?(Types::Nullable) && c_backend_pointer_like_type?(type.base)
+        return "{ 0 }" if type.is_a?(Types::Nullable)
+        return "NULL" if raw_pointer_type?(type) || ref_type?(type)
+        return "NULL" if type.is_a?(Types::Opaque) && !type.external
+        return "false" if type.is_a?(Types::Primitive) && type.boolean?
+        return "0.0" if type.is_a?(Types::Primitive) && type.float?
+        return "0" if type.is_a?(Types::Primitive) && !type.void?
+        return "(#{c_type(type)}) 0" if type.is_a?(Types::EnumBase)
+
+        "{ 0 }"
+      end
+
+      def emit_zero_expression(type)
+        return "(#{c_type(type)}) #{emit_zero_initializer(type)}" if type.is_a?(Types::StringView)
+        return "NULL" if type.is_a?(Types::Nullable) && c_backend_pointer_like_type?(type.base)
+        return "(#{c_type(type)}){ 0 }" if type.is_a?(Types::Nullable)
+        return emit_zero_initializer(type) if type.is_a?(Types::Primitive)
+        return emit_zero_initializer(type) if type.is_a?(Types::EnumBase)
+
+        "(#{c_declaration(type, '')}) #{emit_zero_initializer(type)}"
+      end
+
+      def aggregate_field_type(type, field_name)
+        return proc_field_types(type).fetch(field_name) if type.is_a?(Types::Proc)
+        if type.is_a?(Types::Nullable)
+          return Types::Registry.primitive("bool") if field_name == "has_value"
+          return type.base if field_name == "value"
+        end
+        return type.field(field_name) if type.respond_to?(:field)
+
+        raise CBackendError.new("unsupported aggregate field lookup for #{type}", line: 0, column: 0, path: @path)
+      end
+
+      def emit_aggregate_field_initializer(type, field)
+        field_type = aggregate_field_type(type, field.name)
+        if field_type.is_a?(Types::Nullable) && !field.value.type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(field_type.base)
+          emit_nullable_some_initializer(field_type, field.value)
+        elsif void_storage_field?(field_type)
+          emit_void_field_initializer(field.value)
+        else
+          emit_initializer(field.value)
+        end
+      end
+
+      def emit_nullable_some_initializer(nullable_type, value)
+        "(#{c_type(nullable_type)}){ .has_value = true, .value = #{emit_initializer(value)} }"
+      end
+
+      def emit_variant_field_initializer(type, arm_name, field)
+        field_type = type.arm(arm_name).fetch(field.name)
+        if field_type.is_a?(Types::Nullable) && !field.value.type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(field_type.base)
+          emit_nullable_some_initializer(field_type, field.value)
+        elsif field.value.is_a?(IR::AddressOf) && !field_type.is_a?(Types::Nullable)
+          c_type_name = named_type_c_name(field_type)
+          inner = field.value.expression
+          "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
+        elsif aggregate_field_creates_cycle?(field_type, named_type_c_name(type)) &&
+              array_type?(field_type)
+          elem_c_name = c_type(array_element_type(field_type))
+          elem_count = array_length(field_type)
+          elements = field.value.is_a?(IR::ArrayLiteral) ? field.value.elements.map { |e| emit_initializer(e) }.join(", ") : ""
+          "((#{elem_c_name}*)memcpy(malloc(#{elem_count} * sizeof(#{elem_c_name})), &(#{elem_c_name}[#{elem_count}]){ #{elements} }, #{elem_count} * sizeof(#{elem_c_name})))"
+        elsif aggregate_field_creates_cycle?(field_type, named_type_c_name(type)) &&
+              !field_type.is_a?(Types::GenericInstance)
+          field_c_name = named_type_c_name(field_type)
+          init = emit_initializer(field.value)
+          source_expr = if init.start_with?("{")
+            "&(#{c_type(field_type)})#{init}"
+          else
+            "&(#{init})"
+          end
+          "((#{field_c_name}*)memcpy(malloc(sizeof(#{field_c_name})), #{source_expr}, sizeof(#{field_c_name})))"
+        elsif void_storage_field?(field_type)
+          emit_void_field_initializer(field.value)
+        else
+          emit_initializer(field.value)
+        end
+      end
+
+      def emit_void_field_initializer(expression)
+        "(#{emit_expression(expression)}, 0)"
+      end
+
+      def void_storage_field?(type)
+        type.is_a?(Types::Primitive) && type.void?
+      end
+
+      def emit_str_literal(expression)
+        if @str_literal_map && @str_literal_map[expression.value]
+          @str_literal_map[expression.value]
+        else
+          "(mt_str){ .data = #{expression.value.inspect}, .len = #{expression.value.bytesize} }"
+        end
+      end
+
+      def emit_float_literal(expression)
+        value = expression.value
+        literal = if value.finite? && value == value.to_i
+          format("%.1f", value)
+        else
+          value.to_s
+        end
+        expression.type.name == "float" ? "#{literal}f" : literal
+      end
+
+      def wrap_expression(expression)
+        case expression
+        when IR::Name, IR::IntegerLiteral, IR::FloatLiteral, IR::StringLiteral, IR::BooleanLiteral, IR::NullLiteral, IR::ZeroInit, IR::Member, IR::Index, IR::Call, IR::AggregateLiteral, IR::ArrayLiteral, IR::ReinterpretExpr, IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr
+          emit_expression(expression)
+        else
+          "(#{emit_expression(expression)})"
+        end
+      end
+
+      def layout_type_expression(type)
+        c_declaration(type, "")
+      end
     end
   end
 end