mt-lang 0.2.0

data/lib/milk_tea/bindings/bindgen/emitter.rb

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module Bindgen
+    class Generator
+      module GeneratorEmitter
+        private
+
+        def emitted_name(raw_name)
+          return raw_name unless @strip_leading_underscores
+
+          raw_name.sub(/\A_+/, "")
+        end
+
+        def emit_module(declarations)
+          declarations = synthetic_declarations_for(declarations) + declarations
+
+          lines = []
+          lines << "# generated by mtc bindgen from #{@header_path}"
+          lines << "external"
+          lines << ""
+
+          @module_imports.each do |import|
+            lines << %(import #{import.fetch(:module_name)} as #{import.fetch(:alias)})
+          end
+
+          directives = []
+          @link_libraries.each do |library|
+            directives << %(link #{library.dump})
+          end
+          includes = @include_directives && !@include_directives.empty? ? @include_directives : [File.basename(@header_path)]
+          includes.each do |include_name|
+            directives << %(include #{include_name.dump})
+          end
+          lines.concat(directives)
+
+          declarations.each do |declaration|
+            lines.concat(emit_declaration(declaration))
+          end
+
+          source = lines.join("\n") + "\n"
+          Formatter.format_source(source, path: generated_module_path, mode: :tidy)
+        end
+
+        def generated_module_path
+          "#{@module_name.tr('.', '/')}" + ".mt"
+        end
+
+        def emit_declaration(declaration)
+          case declaration[:kind]
+          when "struct", "union"
+            emit_aggregate_declaration(declaration[:kind], declaration[:name], declaration[:node])
+          when "opaque"
+            name = emitted_name(declaration[:name])
+            line = "opaque #{name}"
+            line += " = c#{declaration[:linkage_name].inspect}" if declaration[:linkage_name]
+            [line]
+          when "enum", "flags"
+            emit_enum_declaration(declaration[:kind], emitted_name(declaration[:name]), declaration[:node])
+          when "type_alias"
+            ["type #{emitted_name(declaration[:name])} = #{declaration[:mapped_type]}"]
+          when "const"
+            ["const #{emitted_name(declaration[:name])}: #{declaration[:type]} = #{declaration[:value]}"]
+          when "function"
+            emit_function_declaration(declaration)
+          else
+            raise BindgenError, "unsupported bindgen declaration kind #{declaration[:kind]}"
+          end
+        end
+
+        def emit_aggregate_declaration(kind, name, node)
+          explicit_c_name = aggregate_explicit_c_name(name, node)
+          stripped = emitted_name(name)
+          header = "#{kind} #{stripped}"
+          header += " = c#{explicit_c_name.inspect}" if explicit_c_name
+          header += ":"
+          lines = [header]
+          fields = Array(node["inner"]).select { |child| child["kind"] == "FieldDecl" }
+          fields.each do |field|
+            field_type = aggregate_field_type(field, owner_name: name, aggregate_node: node)
+            mt_name, = bindgen_field_name(emitted_name(aggregate_field_name(field, aggregate_node: node)))
+            lines << "    #{mt_name}: #{field_type}"
+          end
+          lines
+        end
+
+        def bindgen_field_name(name)
+          name = emitted_name(name)
+          return [name, nil] unless Token::KEYWORDS.key?(name)
+
+          ["#{name}_", nil]
+        end
+
+        def bindgen_param_name(name)
+          name = emitted_name(name)
+          return [name, nil] unless generated_binding_name_conflict?(name)
+
+          ["#{name}_", nil]
+        end
+
+        def generated_binding_name_conflict?(name)
+          Token::KEYWORDS.key?(name) || Types::RESERVED_VALUE_TYPE_NAMES.include?(name)
+        end
+
+        def discover_synthetic_aggregate_dependencies(declarations)
+          pending = declarations.select { |declaration| %w[struct union].include?(declaration[:kind]) }.map do |declaration|
+            [declaration[:name], declaration[:node]]
+          end
+          seen = {}
+
+          until pending.empty?
+            owner_name, aggregate_node = pending.shift
+            key = [owner_name, aggregate_node["id"]]
+            next if seen[key]
+
+            seen[key] = true
+
+            Array(aggregate_node["inner"]).select { |child| child["kind"] == "FieldDecl" }.each do |field|
+              anonymous_record = anonymous_record_decl_for_field(field, aggregate_node)
+              next unless anonymous_record
+
+              synthetic_name = synthetic_aggregate_name(owner_name, field, aggregate_node)
+              unless @synthetic_declarations.any? { |declaration| declaration[:name] == synthetic_name }
+                @synthetic_declarations << { kind: anonymous_record.fetch("tagUsed"), name: synthetic_name, node: anonymous_record }
+                @aggregate_declarations[synthetic_name] = anonymous_record
+              end
+
+              pending << [synthetic_name, anonymous_record]
+            end
+          end
+        end
+
+        def discover_synthetic_field_type_dependencies(declarations)
+          pending = declarations.select { |declaration| %w[struct union].include?(declaration[:kind]) }.map do |declaration|
+            [declaration[:name], declaration[:node]]
+          end
+          pending.concat(
+            @synthetic_declarations.select { |declaration| %w[struct union].include?(declaration[:kind]) }.map do |declaration|
+              [declaration[:name], declaration[:node]]
+            end,
+          )
+          seen = {}
+
+          until pending.empty?
+            owner_name, aggregate_node = pending.shift
+            key = [owner_name, aggregate_node["id"]]
+            next if seen[key]
+
+            seen[key] = true
+
+            Array(aggregate_node["inner"]).select { |child| child["kind"] == "FieldDecl" }.each do |field|
+              aggregate_field_type(field, owner_name:, aggregate_node:)
+
+              anonymous_record = anonymous_record_decl_for_field(field, aggregate_node)
+              next unless anonymous_record
+
+              pending << [synthetic_aggregate_name(owner_name, field, aggregate_node), anonymous_record]
+            end
+          end
+        end
+
+        def aggregate_field_type(field, owner_name:, aggregate_node:)
+          override = field_type_override(owner_name, field["name"])
+          return override if override
+
+          anonymous_record = anonymous_record_decl_for_field(field, aggregate_node)
+          return synthetic_aggregate_name(owner_name, field, aggregate_node) if anonymous_record
+
+          map_type_node(field, context: "field #{owner_name}.#{field["name"]}")
+        end
+
+        def aggregate_field_name(field, aggregate_node:)
+          name = field["name"]
+          return name if name && !name.empty?
+
+          anonymous_record = anonymous_record_decl_for_field(field, aggregate_node)
+          return name unless anonymous_record
+
+          field_index = Array(aggregate_node["inner"]).select { |child| child["kind"] == "FieldDecl" }.index { |child| child["id"] == field["id"] } || 0
+          "anonymous_#{anonymous_record.fetch("tagUsed")}_#{field_index}"
+        end
+
+        def synthetic_aggregate_name(owner_name, field, aggregate_node)
+          "#{owner_name}_#{aggregate_field_name(field, aggregate_node:)}"
+        end
+
+        def anonymous_record_decl_for_field(field, aggregate_node)
+          qual_type = type_qual_type(field)
+          return unless qual_type
+
+          tag_match = qual_type.match(/\A(struct|union)\b/)
+          return unless tag_match
+          return unless qual_type.include?("(unnamed at ") || qual_type.include?("(anonymous at ")
+
+          field_begin = source_location_key(field.dig("range", "begin"))
+          return unless field_begin
+
+          expected_tag = tag_match[1]
+          Array(aggregate_node["inner"]).find do |child|
+            next false unless child["kind"] == "RecordDecl"
+            next false unless child["tagUsed"] == expected_tag
+
+            source_location_key(child["loc"]) == field_begin
+          end
+        end
+
+        def source_location_key(location)
+          return unless location
+
+          [
+            location["offset"],
+            location.dig("includedFrom", "file"),
+            location["file"],
+          ]
+        end
+
+        def emit_enum_declaration(kind, name, node)
+          members = enum_member_values(node)
+          backing_type = if members.empty?
+                           "int"
+                         else
+                           map_c_type(members.first.dig(:node, "type", "qualType"), context: "enum #{name}")
+                         end
+          lines = ["#{kind} #{name}: #{backing_type}"]
+          members.each do |member|
+            lines << "    #{member[:node]["name"]} = #{member[:value]}"
+          end
+          lines
+        end
+
+        def enum_member_values(node)
+          next_value = 0
+
+          Array(node["inner"]).filter_map do |child|
+            next unless child["kind"] == "EnumConstantDecl"
+
+            explicit_value = integer_value(child)
+            value = explicit_value ? Integer(explicit_value, 10) : next_value
+            next_value = value + 1
+            { node: child, value: }
+          end
+        end
+
+        def integer_value(node)
+          constant = Array(node["inner"]).find { |child| child["kind"] == "ConstantExpr" }
+          return constant["value"] if constant && constant.key?("value")
+
+          literal = Array(node["inner"]).find { |child| child["kind"] == "IntegerLiteral" }
+          literal&.[]("value")
+        end
+
+        def emit_function_declaration(declaration)
+          original_name = declaration[:name]
+          stripped_name = emitted_name(original_name)
+          params = declaration[:params].map do |param|
+            param_name, = bindgen_param_name(param[:name])
+            "#{param_name}: #{param[:type]}"
+          end
+          params << "..." if declaration[:variadic]
+          line = "external function #{stripped_name}(#{params.join(', ')}) -> #{declaration[:return_type]}"
+          if stripped_name != original_name
+            line += " = c#{original_name.inspect}"
+          end
+          [line]
+        end
+
+        def lower_constant_expression(node, expected_type:, context:)
+          raise BindgenError, "missing initializer for #{context}" unless node
+
+          case node["kind"]
+          when "IntegerLiteral"
+            integer_value = node.fetch("value")
+            typed_null = pointer_zero_literal(expected_type, integer_value)
+            return typed_null if typed_null
+
+            integer_value
+          when "FloatingLiteral"
+            emit_float_value(node.fetch("value"), expected_type)
+          when "StringLiteral"
+            %(c#{node.fetch("value")})
+          when "ImplicitValueInitExpr"
+            lower_zero_value(expected_type:, context:)
+          when "ImplicitCastExpr", "ConstantExpr", "CompoundLiteralExpr", "ParenExpr"
+            child = Array(node["inner"]).first
+            lower_constant_expression(child, expected_type:, context:)
+          when "UnaryOperator"
+            operator = node["opcode"]
+            operand = lower_constant_expression(Array(node["inner"]).first, expected_type:, context:)
+            "#{operator}#{operand}"
+          when "InitListExpr"
+            lower_init_list_expression(node, expected_type:, context:)
+          else
+            raise BindgenError, "unsupported constant initializer #{node["kind"]} for #{context}"
+          end
+        end
+
+        def lower_init_list_expression(node, expected_type:, context:)
+          values = Array(node["inner"])
+
+          aggregate = @aggregate_declarations[expected_type]
+          return lower_aggregate_init_list(values, aggregate:, expected_type:, context:) if aggregate
+
+          element_type, length = parse_array_type(expected_type)
+          raise BindgenError, "unsupported aggregate constant type #{expected_type} for #{context}" unless element_type
+          raise BindgenError, "initializer field count mismatch for #{context}" if values.length > length
+
+          arguments = (0...length).map do |index|
+            value = values[index]
+            if value
+              lower_constant_expression(value, expected_type: element_type, context: "element #{index} of #{context}")
+            else
+              lower_zero_value(expected_type: element_type, context: "element #{index} of #{context}")
+            end
+          end
+          "#{expected_type}(#{arguments.join(', ')})"
+        end
+
+        def emit_float_value(value, expected_type)
+          value.match?(/[.eE]/) ? value : "#{value}.0"
+        end
+
+        def lower_aggregate_init_list(values, aggregate:, expected_type:, context:)
+          fields = Array(aggregate["inner"]).select { |child| child["kind"] == "FieldDecl" }
+          raise BindgenError, "initializer field count mismatch for #{context}" if values.length > fields.length
+
+          arguments = fields.each_with_index.map do |field, index|
+            field_type = map_type_node(field, context: "field #{expected_type}.#{field["name"]}")
+            value = values[index]
+            lowered = if value
+                        lower_constant_expression(value, expected_type: field_type, context: "field #{field["name"]} of #{context}")
+                      else
+                        lower_zero_value(expected_type: field_type, context: "field #{field["name"]} of #{context}")
+                      end
+            "#{field["name"]} = #{lowered}"
+          end
+          "#{expected_type}(#{arguments.join(', ')})"
+        end
+
+        def lower_zero_value(expected_type:, context:)
+          return "false" if expected_type == "bool"
+          return "0" if %w[char byte ubyte short ushort int uint long ulong ptr_int ptr_uint].include?(expected_type)
+          return "0.0" if %w[float double].include?(expected_type)
+          return "null[ptr[char]]" if expected_type == "cstr"
+          return "null" if expected_type == "cstr?"
+          return "null[#{expected_type}]" if expected_type.start_with?("ptr[") || expected_type.start_with?("const_ptr[")
+
+          if @aggregate_declarations.key?(expected_type)
+            return lower_aggregate_init_list([], aggregate: @aggregate_declarations.fetch(expected_type), expected_type:, context:)
+          end
+
+          element_type, length = parse_array_type(expected_type)
+          if element_type
+            values = Array.new(length) do |index|
+              lower_zero_value(expected_type: element_type, context: "element #{index} of #{context}")
+            end
+            return "#{expected_type}(#{values.join(', ')})"
+          end
+
+          "#{expected_type}<-0"
+        end
+
+        def pointer_zero_literal(expected_type, value)
+          return nil unless Integer(value, 10).zero?
+
+          return "null[ptr[char]]" if expected_type == "cstr"
+          return "null" if expected_type == "cstr?"
+          return "null[#{expected_type}]" if expected_type.start_with?("ptr[") || expected_type.start_with?("const_ptr[")
+
+          nil
+        rescue ArgumentError
+          nil
+        end
+
+        def parse_array_type(type)
+          return [nil, nil] unless type.start_with?("array[") && type.end_with?("]")
+
+          parts = split_top_level_csv(type.delete_prefix("array[").delete_suffix("]"))
+          return [nil, nil] unless parts.length == 2
+
+          [parts[0], Integer(parts[1], 10)]
+        rescue ArgumentError
+          [nil, nil]
+        end
+      end
+    end
+  end
+end

data/lib/milk_tea/bindings/bindgen/overrides.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module Bindgen
+    class Generator
+      module GeneratorOverrides
+        private
+
+        def function_param_type_override(function_name, param_name)
+          @function_param_type_overrides.dig(function_name, param_name)
+        end
+
+        def function_return_type_override(function_name)
+          @function_return_type_overrides[function_name]
+        end
+
+        def field_type_override(type_name, field_name)
+          @field_type_overrides.dig(type_name, field_name)
+        end
+
+        def normalize_function_param_type_overrides(overrides)
+          return {} if overrides.nil?
+
+          raise BindgenError, "function_param_type_overrides must be a hash" unless overrides.is_a?(Hash)
+
+          overrides.each_with_object({}) do |(function_name, param_overrides), normalized|
+            unless function_name.is_a?(String) || function_name.is_a?(Symbol)
+              raise BindgenError, "function_param_type_overrides function names must be strings or symbols"
+            end
+
+            raise BindgenError, "function_param_type_overrides for #{function_name} must be a hash" unless param_overrides.is_a?(Hash)
+
+            normalized[function_name.to_s] = param_overrides.each_with_object({}) do |(param_name, type), params|
+              unless param_name.is_a?(String) || param_name.is_a?(Symbol)
+                raise BindgenError, "function_param_type_overrides parameter names must be strings or symbols"
+              end
+
+              raise BindgenError, "function_param_type_overrides for #{function_name}.#{param_name} must be a non-empty string" unless type.is_a?(String) && !type.empty?
+
+              params[param_name.to_s] = type
+            end.freeze
+          end.freeze
+        end
+
+        def normalize_field_type_overrides(overrides)
+          return {} if overrides.nil?
+
+          raise BindgenError, "field_type_overrides must be a hash" unless overrides.is_a?(Hash)
+
+          overrides.each_with_object({}) do |(type_name, field_overrides), normalized|
+            unless type_name.is_a?(String) || type_name.is_a?(Symbol)
+              raise BindgenError, "field_type_overrides type names must be strings or symbols"
+            end
+
+            raise BindgenError, "field_type_overrides for #{type_name} must be a hash" unless field_overrides.is_a?(Hash)
+
+            normalized[type_name.to_s] = field_overrides.each_with_object({}) do |(field_name, type), fields|
+              unless field_name.is_a?(String) || field_name.is_a?(Symbol)
+                raise BindgenError, "field_type_overrides field names must be strings or symbols"
+              end
+
+              raise BindgenError, "field_type_overrides for #{type_name}.#{field_name} must be a non-empty string" unless type.is_a?(String) && !type.empty?
+
+              fields[field_name.to_s] = type
+            end.freeze
+          end.freeze
+        end
+
+        def normalize_module_imports(imports)
+          return [] if imports.nil?
+          raise BindgenError, "module_imports must be an array" unless imports.is_a?(Array)
+
+          imports.map do |entry|
+            raise BindgenError, "module_imports entries must be hashes" unless entry.is_a?(Hash)
+
+            module_name = entry.fetch(:module_name) { entry.fetch("module_name", nil) }
+            import_alias = entry.fetch(:alias) { entry.fetch("alias", nil) }
+            raise BindgenError, "module_imports module_name must be a non-empty string" unless module_name.is_a?(String) && !module_name.empty?
+            raise BindgenError, "module_imports alias must be a non-empty string" unless import_alias.is_a?(String) && !import_alias.empty?
+
+            { module_name:, alias: import_alias }
+          end.freeze
+        end
+
+        def normalize_type_overrides(overrides)
+          return {} if overrides.nil?
+          raise BindgenError, "type_overrides must be a hash" unless overrides.is_a?(Hash)
+
+          overrides.each_with_object({}) do |(type_name, mapped_type), normalized|
+            unless type_name.is_a?(String) || type_name.is_a?(Symbol)
+              raise BindgenError, "type_overrides type names must be strings or symbols"
+            end
+
+            raise BindgenError, "type_overrides for #{type_name} must be a non-empty string" unless mapped_type.is_a?(String) && !mapped_type.empty?
+
+            normalized[type_name.to_s] = mapped_type
+          end.freeze
+        end
+
+        def normalize_type_name_overrides(overrides)
+          return {} if overrides.nil?
+          raise BindgenError, "type_name_overrides must be a hash" unless overrides.is_a?(Hash)
+
+          overrides.each_with_object({}) do |(type_name, visible_name), normalized|
+            unless type_name.is_a?(String) || type_name.is_a?(Symbol)
+              raise BindgenError, "type_name_overrides type names must be strings or symbols"
+            end
+            unless visible_name.is_a?(String) && !visible_name.empty?
+              raise BindgenError, "type_name_overrides for #{type_name} must be a non-empty string"
+            end
+
+            normalized[type_name.to_s] = visible_name
+          end.freeze
+        end
+
+        def normalize_function_return_type_overrides(overrides)
+          return {} if overrides.nil?
+
+          raise BindgenError, "function_return_type_overrides must be a hash" unless overrides.is_a?(Hash)
+
+          overrides.each_with_object({}) do |(function_name, type), normalized|
+            unless function_name.is_a?(String) || function_name.is_a?(Symbol)
+              raise BindgenError, "function_return_type_overrides function names must be strings or symbols"
+            end
+
+            raise BindgenError, "function_return_type_overrides for #{function_name} must be a non-empty string" unless type.is_a?(String) && !type.empty?
+
+            normalized[function_name.to_s] = type
+          end.freeze
+        end
+      end
+    end
+  end
+end