mt-lang 0.2.0

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

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LowererDeclarations
+    private
+
+      def expanded_declarations
+        @ctx.ast.declarations.flat_map do |decl|
+          case decl
+          when AST::WhenStmt
+            val = compile_time_const_value(decl.discriminant)
+            next [decl] if val.nil?
+
+            chosen = decl.branches.find { |b| val == compile_time_const_value(b.pattern) }
+            body = chosen ? chosen.body : (decl.else_body || [])
+            body
+          else
+            [decl]
+          end
+        end
+      end
+
+      def lower_constants
+        expanded_declarations.grep(AST::ConstDecl).filter_map do |decl|
+          type = @ctx.values.fetch(decl.name).type
+          const_value = @ctx.values.fetch(decl.name).const_value
+
+          next if type == Types::BUILTIN_TYPE_META_TYPE
+
+          if const_value && (decl.value.is_a?(AST::Call) || decl.value.is_a?(AST::Specialization))
+            value = lower_const_value_literal(type, const_value)
+          elsif const_value && (decl.block_body || decl.value.is_a?(AST::ExpressionList))
+            if const_value.is_a?(Array) && const_value.empty? && decl.value.is_a?(AST::ExpressionList) && !decl.value.elements.empty?
+              value = lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
+            else
+              value = lower_const_value_literal(type, const_value)
+            end
+          elsif decl.block_body || decl.value.is_a?(AST::ExpressionList)
+            raise LoweringError.new("constant #{decl.name} has no compile-time value", line: decl.line, column: decl.column)
+          else
+            value = lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
+          end
+
+          IR::Constant.new(name: decl.name, linkage_name: value_c_name(decl.name), type:, value:)
+        end
+      end
+
+      def lower_const_value_literal(type, const_value)
+        case const_value
+        when Integer
+          value = if type.respond_to?(:integer_width) && (width = type.integer_width) && width < 64
+                    mask = (1 << width) - 1
+                    masked = const_value & mask
+                    if type.respond_to?(:unsigned_integer?) && !type.unsigned_integer? && masked >= (1 << (width - 1))
+                      masked - (1 << width)
+                    else
+                      masked
+                    end
+                  else
+                    const_value
+                  end
+          IR::IntegerLiteral.new(value:, type:)
+        when Float
+          IR::FloatLiteral.new(value: const_value, type:)
+        when String
+          IR::StringLiteral.new(value: const_value, type:, cstring: false)
+        when TrueClass, FalseClass
+          IR::BooleanLiteral.new(value: const_value, type:)
+        when Array
+          element_type = type.respond_to?(:arguments) ? type.arguments.first : @ctx.types["int"]
+          elements = const_value.map do |element|
+            lower_const_value_literal(element_type, element)
+          end
+          IR::ArrayLiteral.new(type:, elements:)
+        else
+          IR::IntegerLiteral.new(value: 0, type:)
+        end
+      end
+
+      def lower_globals
+        expanded_declarations.filter_map do |decl|
+          next unless decl.is_a?(AST::VarDecl) || decl.is_a?(AST::EventDecl)
+
+          type = @ctx.values.fetch(decl.name).type
+          ensure_event_runtime(type) if type.is_a?(Types::Event)
+          value = if decl.is_a?(AST::VarDecl) && decl.value
+                    lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
+                  else
+                    IR::ZeroInit.new(type: type)
+                  end
+          IR::Global.new(name: decl.name, linkage_name: value_c_name(decl.name), type:, value:)
+        end
+      end
+
+      def lower_opaques
+        expanded_declarations.grep(AST::OpaqueDecl).map do |decl|
+          opaque_type = @ctx.opaque_types.fetch(decl.name)
+          IR::OpaqueDecl.new(
+            name: decl.name,
+            linkage_name: opaque_c_type_name(opaque_type),
+            forward_declarable: opaque_forward_declarable?(opaque_type),
+            source_module: @ctx.module_name,
+          )
+        end
+      end
+
+      def lower_imported_external_opaques
+        each_raw_module_analysis.flat_map do |analysis|
+          analysis.ast.declarations.grep(AST::OpaqueDecl).filter_map do |decl|
+            opaque_type = analysis.types.fetch(decl.name)
+            next unless forward_declarable_external_opaque?(opaque_type)
+
+            IR::OpaqueDecl.new(name: decl.name, linkage_name: opaque_c_type_name(opaque_type), forward_declarable: true, source_module: analysis.module_name)
+          end
+        end.uniq { |decl| decl.linkage_name }
+      end
+
+      def lower_static_asserts
+        expanded_declarations.grep(AST::StaticAssert).map do |statement|
+          lower_static_assert(statement, env: empty_env)
+        end
+      end
+
+      def lower_static_assert(statement, env:)
+        condition_value = compile_time_const_value(statement.condition, env:)
+        raise LoweringError, "static_assert condition must lower to a compile-time bool constant" unless condition_value == true || condition_value == false
+
+        IR::StaticAssert.new(
+          condition: IR::BooleanLiteral.new(value: condition_value, type: @ctx.types.fetch("bool")),
+          message: lower_expression(statement.message, env:, expected_type: @ctx.types.fetch("str")),
+        )
+      end
+
+      def lower_structs
+        expanded_declarations.grep(AST::StructDecl).filter_map do |decl|
+          next unless decl.type_params.empty?
+
+          results = []
+          lower_one_struct(decl, decl.name, results)
+          results
+        end.flatten
+      end
+
+      def lower_one_struct(decl, qualified_name, results)
+        struct_type = @ctx.struct_types.fetch(qualified_name)
+        fields = decl.fields.map do |field|
+          IR::Field.new(name: field.name, type: struct_type.field(field.name))
+        end
+        decl.events.each do |event_decl|
+          event_type = struct_type.event(event_decl.name)
+          ensure_event_runtime(event_type)
+          fields << IR::Field.new(name: event_type.hidden_field_name, type: event_type)
+        end
+
+        results << IR::StructDecl.new(name: decl.name, linkage_name: c_type_name(struct_type), fields:, packed: decl.packed, alignment: decl.alignment, source_module: @ctx.module_name)
+
+        decl.nested_types.each do |nested|
+          lower_one_struct(nested, "#{qualified_name}.#{nested.name}", results)
+        end
+      end
+
+      def lower_unions
+        expanded_declarations.grep(AST::UnionDecl).map do |decl|
+          union_type = @ctx.union_types.fetch(decl.name)
+          fields = decl.fields.map do |field|
+            IR::Field.new(name: field.name, type: union_type.field(field.name))
+          end
+          IR::UnionDecl.new(name: decl.name, linkage_name: c_type_name(union_type), fields:, source_module: @ctx.module_name)
+        end
+      end
+
+      def lower_enums
+        expanded_declarations.filter_map do |decl|
+          case decl
+          when AST::EnumDecl, AST::FlagsDecl
+            enum_type = @ctx.types.fetch(decl.name)
+            backing_type = enum_type.backing_type
+            members = decl.members.map do |member|
+              value = lower_expression(member.value, env: empty_env, expected_type: backing_type)
+              IR::EnumMember.new(name: member.name, linkage_name: enum_member_c_name(enum_type, member.name), value:)
+            end
+
+            IR::EnumDecl.new(
+              name: decl.name,
+              linkage_name: c_type_name(enum_type),
+              backing_type:,
+              members:,
+              flags: decl.is_a?(AST::FlagsDecl),
+            )
+          end
+        end
+      end
+
+      def lower_variants
+        expanded_declarations.filter_map do |decl|
+          next unless decl.is_a?(AST::VariantDecl)
+
+          variant_type = @ctx.types.fetch(decl.name)
+          next if variant_type.is_a?(Types::GenericVariantDefinition)
+
+          outer_c = c_type_name(variant_type)
+          arms = decl.arms.map do |arm|
+            arm_c = "#{outer_c}_#{arm.name}"
+            fields = arm.fields.map do |field|
+              field_type = variant_type.arm(arm.name).fetch(field.name)
+              IR::Field.new(name: field.name, type: field_type)
+            end
+            IR::VariantArm.new(name: arm.name, linkage_name: arm_c, fields:)
+          end
+          IR::VariantDecl.new(name: decl.name, linkage_name: outer_c, arms:, source_module: @ctx.module_name)
+        end
+      end
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LowererDyn
+    private
+
+    def lower_adapt_call(expression, env:, type:, interface:)
+      argument = expression.arguments.fetch(0)
+      arg_value = lower_expression(argument.value, env:)
+      arg_type = infer_expression_type(argument.value, env:)
+      concrete_type = ref_type?(arg_type) ? referenced_type(arg_type) : arg_type
+
+      @dyn_vtables ||= {}
+      key = [concrete_type, interface.name]
+      return @dyn_vtables[key] unless @dyn_vtables[key].nil?
+
+      vtable_struct_full = dyn_vtable_struct_type(interface)
+      vtable_c_name = ensure_dyn_vtable(interface, concrete_type)
+
+      void_ptr = Types::Registry.generic_instance("ptr", [@ctx.types.fetch("void")])
+      vtable_field = IR::Cast.new(
+        target_type: void_ptr,
+        expression: IR::AddressOf.new(
+          expression: IR::Name.new(name: vtable_c_name, type: vtable_struct_full, pointer: false),
+          type: Types::Registry.generic_instance("ptr", [vtable_struct_full]),
+        ),
+        type: void_ptr,
+      )
+
+      result = IR::AggregateLiteral.new(
+        type:,
+        fields: [
+          IR::AggregateField.new(name: "data", value: IR::Cast.new(target_type: void_ptr, expression: arg_value, type: void_ptr)),
+          IR::AggregateField.new(name: "vtable", value: vtable_field),
+        ],
+      )
+      @dyn_vtables[key] = result
+      result
+    end
+
+    def lower_dyn_method_call(expression, receiver, method_binding, env:, type:)
+      ir_expr = lower_expression(receiver, env:)
+      void_ptr = Types::Registry.generic_instance("ptr", [@ctx.types.fetch("void")])
+      dyn_type = infer_expression_type(receiver, env:)
+      interface = dyn_type.interface_binding
+
+      data_ptr = IR::Member.new(receiver: ir_expr, member: "data", type: void_ptr)
+      vtable_field = IR::Member.new(receiver: ir_expr, member: "vtable", type: void_ptr)
+
+      vtable_full = dyn_vtable_struct_type(interface)
+      vtable_ptr_type = Types::Registry.generic_instance("ptr", [vtable_full])
+      vtable_cast = IR::Cast.new(target_type: vtable_ptr_type, expression: vtable_field, type: vtable_ptr_type)
+
+      fn_type = vtable_full.field(method_binding.name)
+      vtable_method = IR::Member.new(receiver: vtable_cast, member: method_binding.name, type: fn_type)
+
+      arguments = [data_ptr, *lower_call_arguments(expression.arguments, method_binding, env:)]
+      IR::Call.new(callee: vtable_method, arguments:, type:)
+    end
+
+    def dyn_vtable_struct_type(interface)
+      void_ptr = Types::Registry.generic_instance("ptr", [@ctx.types.fetch("void")])
+      fields = {}
+      interface.methods.each do |method_name, method_binding|
+        fn_params = [Types::Registry.parameter("data", void_ptr), *method_binding.params]
+        fn_type = Types::Registry.function(nil, params: fn_params, return_type: method_binding.return_type)
+        fields[method_name] = fn_type
+      end
+      Types::DynVtable.new(interface.name, fields)
+    end
+
+    def ensure_dyn_vtable(interface, concrete_type)
+      concrete_type_name = sanitize_identifier(concrete_type.to_s)
+      vtable_c_name = "mt_vtable_#{concrete_type_name}_#{interface.name}"
+      return vtable_c_name if @dyn_generated_vtables&.key?(vtable_c_name)
+      @dyn_generated_vtables ||= {}
+
+      ensure_dyn_vtable_struct(interface)
+      wrappers = gen_dyn_vtable_wrappers(concrete_type, interface)
+      gen_dyn_vtable_constant(concrete_type, interface, vtable_c_name, wrappers)
+      @dyn_generated_vtables[vtable_c_name] = true
+      vtable_c_name
+    end
+
+    def ensure_dyn_vtable_struct(interface)
+      vtable_c_name = "mt_vtable_#{interface.name}"
+      return if @artifacts.synthetic_structs.any? { |s| s.linkage_name == vtable_c_name }
+
+      void_ptr = Types::Registry.generic_instance("ptr", [Types::Registry.primitive("void")])
+      fields = interface.methods.map do |method_name, method_binding|
+        fn_params = [Types::Registry.parameter("data", void_ptr), *method_binding.params]
+        fn_type = Types::Registry.function(nil, params: fn_params, return_type: method_binding.return_type)
+        IR::Field.new(name: method_name, type: fn_type)
+      end
+
+      @artifacts.synthetic_structs << IR::StructDecl.new(
+        name: "vtable_#{interface.name}",
+        linkage_name: vtable_c_name,
+        fields:,
+        packed: false,
+        alignment: nil,
+      )
+    end
+
+    def gen_dyn_vtable_wrappers(concrete_type, interface)
+      void_ptr = Types::Registry.generic_instance("ptr", [Types::Registry.primitive("void")])
+      wrappers = {}
+      concrete_type_name = sanitize_identifier(concrete_type.to_s)
+      ptr_to_concrete = Types::Registry.generic_instance("ptr", [concrete_type])
+
+      interface.methods.each do |method_name, method_binding|
+        method_info = @method_definitions[[concrete_type, method_name]]
+        raise LoweringError, "no method #{method_name} for #{concrete_type}" unless method_info
+
+        method_analysis, method_ast = method_info
+        method_key = method_ast.kind == :static ? "static:#{method_ast.name}" : method_ast.name
+        real_binding = method_analysis.methods.fetch(concrete_type).fetch(method_key)
+        real_c_name = function_binding_c_name(real_binding, module_name: method_analysis.module_name, receiver_type: concrete_type)
+        wrapper_c_name = "__dyn_#{concrete_type_name}_#{method_name}"
+        is_editable = method_ast.kind == :editable
+
+        params = [
+          IR::Param.new(name: "data", linkage_name: "data", type: void_ptr, pointer: false),
+          *method_binding.params.map.with_index { |p, i| IR::Param.new(name: p.name, linkage_name: p.name || "arg#{i}", type: p.type, pointer: false) },
+        ]
+
+        body = if is_editable
+                 [
+                   IR::ReturnStmt.new(value: IR::Call.new(
+                     callee: real_c_name,
+                     arguments: [
+                       IR::Cast.new(target_type: ptr_to_concrete, expression: IR::Name.new(name: "data", type: void_ptr, pointer: false), type: ptr_to_concrete),
+                       *method_binding.params.map.with_index { |p, i| IR::Name.new(name: p.name || "arg#{i}", type: p.type, pointer: false) },
+                     ],
+                     type: method_binding.return_type,
+                   )),
+                 ]
+               else
+                  if method_ast.kind == :static
+                    [
+                      IR::ReturnStmt.new(value: IR::Call.new(
+                        callee: real_c_name,
+                        arguments: method_binding.params.map.with_index { |p, i| IR::Name.new(name: p.name || "arg#{i}", type: p.type, pointer: false) },
+                        type: method_binding.return_type,
+                      )),
+                    ]
+                  elsif receiver_type_uses_pointer_lowering?(concrete_type)
+                    [
+                      IR::ReturnStmt.new(value: IR::Call.new(
+                        callee: real_c_name,
+                        arguments: [
+                          IR::Cast.new(target_type: ptr_to_concrete, expression: IR::Name.new(name: "data", type: void_ptr, pointer: false), type: ptr_to_concrete),
+                          *method_binding.params.map.with_index { |p, i| IR::Name.new(name: p.name || "arg#{i}", type: p.type, pointer: false) },
+                        ],
+                        type: method_binding.return_type,
+                      )),
+                    ]
+                  else
+                    # The receiver is always passed here; the C backend's
+                    # omitted-receiver call logic drops it when the target
+                    # method's unused receiver parameter was omitted (the same
+                    # single source of truth every ordinary method call uses,
+                    # which requires a String callee).
+                    [
+                      IR::ReturnStmt.new(value: IR::Call.new(
+                        callee: real_c_name,
+                        arguments: [
+                          IR::Unary.new(operator: "*", operand: IR::Cast.new(target_type: ptr_to_concrete, expression: IR::Name.new(name: "data", type: void_ptr, pointer: false), type: ptr_to_concrete), type: concrete_type),
+                          *method_binding.params.map.with_index { |p, i| IR::Name.new(name: p.name || "arg#{i}", type: p.type, pointer: false) },
+                        ],
+                        type: method_binding.return_type,
+                      )),
+                    ]
+                  end
+               end
+
+        @artifacts.synthetic_functions << IR::Function.new(
+          name: "__dyn_#{concrete_type_name}_#{method_name}",
+          linkage_name: wrapper_c_name,
+          params:,
+          return_type: method_binding.return_type,
+          body:,
+          entry_point: false,
+        )
+        wrappers[method_name] = wrapper_c_name
+      end
+
+      wrappers
+    end
+
+    def gen_dyn_vtable_constant(concrete_type, interface, vtable_c_name, wrappers)
+      vtable_full = dyn_vtable_struct_type(interface)
+      fields = interface.methods.map do |method_name, _|
+        wrapper_c_name = wrappers[method_name]
+        field_type = vtable_full.field(method_name)
+        IR::AggregateField.new(name: method_name, value: IR::Name.new(name: wrapper_c_name, type: field_type || @error_type, pointer: false))
+      end
+      @artifacts.synthetic_constants << IR::Constant.new(
+        name: vtable_c_name,
+        linkage_name: vtable_c_name,
+        type: vtable_full,
+        value: IR::AggregateLiteral.new(type: vtable_full, fields:),
+      )
+    end
+  end
+end