mt-lang 0.2.0

data/lib/milk_tea/core/c_backend.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require_relative "c_backend/aggregate_utils"
+require_relative "c_backend/type_system"
+require_relative "c_backend/reachability"
+require_relative "c_backend/feature_detection"
+require_relative "c_backend/type_collectors"
+require_relative "c_backend/statements"
+require_relative "c_backend/control_flow_emission"
+require_relative "c_backend/runtime_helpers"
+require_relative "c_backend/type_declaration"
+require_relative "c_backend/expressions"
+require_relative "c_backend/reinterpret"
+
+module MilkTea
+  class CBackendError < StandardError
+    attr_reader :line, :column, :path
+
+    def initialize(msg = nil, line: nil, column: nil, path: nil)
+      super(msg)
+      @line = line
+      @column = column
+      @path = path
+    end
+
+    def code
+      "backend/internal"
+    end
+  end
+
+  class CBackend
+    INDENT = "  "
+    ARRAY_OUT_PARAM_NAME = "__mt_out"
+
+    # Max iterations for loop guard counters before aborting.
+    # Set high enough that legitimate data-bound loops (e.g. is_valid_utf8
+    # scanning a 600 KB source file) never trigger a false positive, yet low
+    # enough that a genuinely infinite loop fires a clear fatal within ~1 s.
+    LOOP_GUARD_MAX_ITERATIONS = 50_000_000
+
+    def self.emit(program, emit_line_directives: true, debug_guards: false)
+      new(program, emit_line_directives:, debug_guards:).emit
+    end
+
+    def self.generate_c(ir_program, emit_line_directives: true, debug_guards: false)
+      emit(ir_program, emit_line_directives:, debug_guards:)
+    end
+
+    def initialize(program, emit_line_directives: true, debug_guards: false)
+      @program = program
+      @emit_line_directives = emit_line_directives
+      @debug_guards = debug_guards
+      @checked_index_alias_stack = []
+      @checked_index_alias_id = 0
+      @loop_guard_id = 0
+      @emitted_span_type_names = Set.new
+    end
+
+    def emit
+      lines = []
+      constants = emitted_constants
+      headers = @program.includes.map(&:header)
+      if headers.include?("\"fs_support.h\"") || headers.include?("\"tls_support.h\"") || uses_parallel_for_helper? || uses_spawn_all_helper? || uses_detach_helper?
+        lines << "#ifndef _GNU_SOURCE"
+        lines << "#define _GNU_SOURCE"
+        lines << "#endif"
+        lines << "#ifndef _POSIX_C_SOURCE"
+        lines << "#define _POSIX_C_SOURCE 200809L"
+        lines << "#endif"
+        lines << ""
+      end
+      if uses_fatal_helper? || uses_format_helpers?
+        headers << "<stdio.h>"
+      end
+      if uses_fatal_helper? || uses_format_helpers? || uses_async_memory_helpers? || uses_foreign_temp_cstr_helpers? || uses_detach_helper?
+        headers << "<stdlib.h>"
+      end
+      if uses_parallel_for_helper? || uses_spawn_all_helper? || uses_detach_helper?
+        headers << "\"uv.h\""
+      end
+      headers.uniq.each do |header|
+        lines << "#include #{header}"
+      end
+      lines << ""
+
+      if uses_string_view?
+        lines.concat(emit_string_type)
+        lines << ""
+      end
+
+      if uses_vector_math_types?
+        lines.concat(emit_vector_math_types)
+        lines << ""
+      end
+
+      if uses_fatal_helper?
+        lines.concat(emit_fatal_helper)
+        lines << ""
+      end
+
+      if uses_format_helpers?
+        lines.concat(emit_format_helpers)
+        lines << ""
+      end
+
+      if uses_fmt_builder?
+        lines.concat(emit_fmt_builder_helpers)
+        lines << ""
+      end
+
+      if uses_str_equality_helper?
+        lines.concat(emit_str_equality_helper)
+        lines << ""
+      end
+
+      if uses_text_buffer_helpers?
+        lines.concat(emit_text_buffer_helpers)
+        lines << ""
+      end
+
+      if uses_async_memory_helpers?
+        lines.concat(emit_async_memory_helpers)
+        lines << ""
+      end
+
+      if uses_parallel_for_helper?
+        lines.concat(emit_parallel_for_helper)
+        lines << ""
+      end
+
+      if uses_spawn_all_helper?
+        lines.concat(emit_spawn_all_helper)
+        lines << ""
+      end
+
+      if uses_detach_helper?
+        lines.concat(emit_detach_helpers)
+        lines << ""
+      end
+
+      opaque_decls = @program.opaques
+      aggregate_decls = sort_aggregate_decls(
+        emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls,
+        emitted_aggregate_unions,
+        emitted_aggregate_variants + collect_generic_variant_decls,
+      )
+
+      forward_declarations = emit_forward_declarations(opaque_decls, aggregate_decls)
+      unless forward_declarations.empty?
+        lines.concat(forward_declarations)
+        lines << ""
+      end
+
+      @program.enums.each do |enum_decl|
+        lines.concat(emit_enum(enum_decl))
+        lines << ""
+      end
+
+      collect_span_types.each do |type|
+        span_name = span_type_name(type)
+        next if @emitted_span_type_names.include?(span_name)
+        @emitted_span_type_names.add(span_name)
+        lines.concat(emit_span_type(type))
+        lines << ""
+      end
+
+      collect_soa_types.each do |type|
+        lines.concat(emit_soa_type(type))
+        lines << ""
+      end
+
+      if uses_entrypoint_argv_helpers?
+        lines.concat(emit_entrypoint_argv_helpers)
+        lines << ""
+      end
+
+      if uses_foreign_temp_cstr_helpers?
+        lines.concat(emit_foreign_temp_cstr_helpers)
+        lines << ""
+      end
+
+      if uses_str_buffer_helpers?
+        lines.concat(emit_str_buffer_helpers)
+        lines << ""
+      end
+
+      aggregate_decls.each do |aggregate_decl|
+        case aggregate_decl
+        when IR::StructDecl
+          lines.concat(emit_struct(aggregate_decl))
+        when IR::UnionDecl
+          lines.concat(emit_union(aggregate_decl))
+        when IR::VariantDecl
+          lines.concat(emit_variant(aggregate_decl))
+        end
+        lines << ""
+      end
+
+      if uses_variant_equality_helper?
+        lines.concat(emit_str_equality_helper) unless uses_str_equality_helper?
+        lines.concat(emit_variant_equality_helpers)
+        lines << ""
+      end
+
+      function_declarations = emit_function_declarations(emitted_functions)
+      unless function_declarations.empty?
+        lines.concat(function_declarations)
+        lines << ""
+      end
+
+      constants.each do |constant|
+        lines << "#{constant_storage(constant.type)} #{c_declaration(constant.type, constant.linkage_name)} = #{emit_initializer(constant.value)};"
+      end
+      @program.globals.each do |global|
+        next unless emitted_globals.include?(global)
+        lines << "#{global_storage(global.type)} #{c_declaration(global.type, global.linkage_name)} = #{emit_initializer(global.value)};"
+      end
+      lines << "" unless constants.empty? && @program.globals.empty?
+
+      @program.static_asserts.each do |statement|
+        lines << emit_static_assert(statement)
+      end
+      lines << "" unless @program.static_asserts.empty?
+
+      reinterpret_helpers = collect_reinterpret_helpers
+      reinterpret_helpers.each do |helper|
+        lines.concat(emit_reinterpret_helper(helper))
+        lines << ""
+      end
+
+      checked_array_index_types = collect_checked_array_index_types
+      checked_array_index_types.each do |type|
+        lines.concat(emit_checked_array_index_helper(type))
+        lines << ""
+      end
+
+      checked_span_index_types = collect_checked_span_index_types
+      checked_span_index_types.each do |type|
+        lines.concat(emit_checked_span_index_helper(type))
+        lines << ""
+      end
+
+      nullable_array_index_types = collect_checked_array_index_types(nullable_only: true)
+      nullable_array_index_types.each do |type|
+        lines.concat(emit_nullable_array_index_helper(type))
+        lines << ""
+      end
+
+      nullable_span_index_types = collect_checked_span_index_types(nullable_only: true)
+      nullable_span_index_types.each do |type|
+        lines.concat(emit_nullable_span_index_helper(type))
+        lines << ""
+      end
+
+      str_literals = collect_str_literals
+      unless str_literals.empty?
+        @str_literal_map = {}
+        str_literals.each_with_index { |value, i| @str_literal_map[value] = str_literal_name(i) }
+        lines.concat(emit_str_literal_constants(str_literals))
+        lines << ""
+      end
+
+      emitted_functions.each do |function|
+        lines.concat(emit_function(function))
+        lines << ""
+      end
+
+      lines.join("\n").rstrip + "\n"
+    end
+
+    private
+
+    EQUALITY_OPERATORS = ["==", "!="].freeze
+
+    include AggregateUtils
+    include TypeSystem
+    include Reachability
+    include FeatureDetection
+    include TypeCollectors
+    include Statements
+    include ControlFlowEmission
+    include RuntimeHelpers
+    include TypeDeclaration
+    include Expressions
+    include Reinterpret
+  end
+end

data/lib/milk_tea/core/compatibility_helpers.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "types/predicates"
+
+module MilkTea
+  module CompatibilityHelpers
+    include TypePredicates
+
+    BUILTIN_CSTR = Types::Registry.primitive("cstr")
+
+    EVENT_METHOD_KINDS = {
+      "subscribe" => :event_subscribe,
+      "subscribe_once" => :event_subscribe_once,
+      "unsubscribe" => :event_unsubscribe,
+      "emit" => :event_emit,
+      "wait" => :event_wait,
+    }.freeze
+
+    EVENT_METHOD_NAMES = EVENT_METHOD_KINDS.invert.freeze
+
+    STR_BUFFER_METHOD_KINDS = {
+      "clear" => :str_buffer_clear,
+      "assign" => :str_buffer_assign,
+      "append" => :str_buffer_append,
+      "assign_format" => :str_buffer_assign_format,
+      "append_format" => :str_buffer_append_format,
+      "len" => :str_buffer_len,
+      "capacity" => :str_buffer_capacity,
+      "as_str" => :str_buffer_as_str,
+      "as_cstr" => :str_buffer_as_cstr,
+    }.freeze
+
+    STR_BUFFER_METHOD_NAMES = STR_BUFFER_METHOD_KINDS.invert.freeze
+
+    ATOMIC_METHOD_KINDS = {
+      "load" => :atomic_load,
+      "store" => :atomic_store,
+      "add" => :atomic_add,
+      "sub" => :atomic_sub,
+      "exchange" => :atomic_exchange,
+      "compare_exchange" => :atomic_compare_exchange,
+    }.freeze
+
+    def type_ref_from_specialization(expression)
+      case expression.callee
+      when AST::Identifier
+        return nil if %w[zero default reinterpret].include?(expression.callee.name)
+
+        AST::TypeRef.new(name: AST::QualifiedName.new(parts: [expression.callee.name]), arguments: expression.arguments, nullable: false)
+      when AST::MemberAccess
+        return nil unless expression.callee.receiver.is_a?(AST::Identifier)
+
+        AST::TypeRef.new(
+          name: AST::QualifiedName.new(parts: [expression.callee.receiver.name, expression.callee.member]),
+          arguments: expression.arguments,
+          nullable: false,
+        )
+      end
+    end
+
+    def event_subscription_result_type
+      @ctx.types.fetch("Result").instantiate([@ctx.types.fetch("Subscription"), @ctx.types.fetch("EventError")])
+    end
+
+    def event_wait_result_type(event_type)
+      @ctx.types.fetch("Result").instantiate([event_type.payload_type || @ctx.types.fetch("void"), @ctx.types.fetch("EventError")])
+    end
+
+    def range_expr?(expression)
+      expression.is_a?(AST::RangeExpr)
+    end
+
+    private
+
+    def string_literal_cstr_compatibility?(expression, expected_type)
+      expression.is_a?(AST::StringLiteral) && !expression.cstring && expected_type == BUILTIN_CSTR
+    end
+  end
+end

data/lib/milk_tea/core/compile_time/const_eval.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "../types/layout"
+
+module MilkTea
+  module ConstEval
+    module_function
+
+    def evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
+      Evaluator.new(
+        resolve_identifier:,
+        resolve_member_access:,
+        resolve_type_ref:,
+        resolve_call:,
+      ).evaluate(expression)
+    end
+
+    def equality_result(left, right)
+      return left == right if left.is_a?(Numeric) && right.is_a?(Numeric)
+      return left == right if left.is_a?(String) && right.is_a?(String)
+      return left == right if boolean_value?(left) && boolean_value?(right)
+      return left == right if left.is_a?(Types::Base) && right.is_a?(Types::Base)
+
+      nil
+    end
+
+    def boolean_value?(value)
+      value == true || value == false
+    end
+
+    class Evaluator
+      include Layout
+
+      def initialize(resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
+        @resolve_identifier = resolve_identifier
+        @resolve_member_access = resolve_member_access
+        @resolve_type_ref = resolve_type_ref
+        @resolve_call = resolve_call
+      end
+
+      def evaluate(expression)
+        case expression
+        when AST::ErrorExpr
+          nil
+        when AST::ExpressionList
+          expression.elements.filter_map { |element| evaluate(element) }
+        when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral
+          expression.value
+        when AST::StringLiteral
+          expression.value
+        when AST::Identifier
+          @resolve_identifier&.call(expression)
+        when AST::MemberAccess
+          @resolve_member_access&.call(expression)
+        when AST::Call
+          @resolve_call&.call(expression)
+        when AST::Specialization
+          @resolve_call&.call(expression)
+        when AST::SizeofExpr
+          type = resolve_layout_type(expression.type)
+          type && size_of(type)
+        when AST::AlignofExpr
+          type = resolve_layout_type(expression.type)
+          type && alignment_of(type)
+        when AST::OffsetofExpr
+          type = resolve_layout_type(expression.type)
+          if type
+            result = offset_of(type, expression.field)
+            return result if result
+
+            id_expr = AST::Identifier.new(name: expression.field)
+            value = @resolve_identifier&.call(id_expr)
+            if value.is_a?(Types::FieldHandle)
+              return offset_of(type, value.field_name)
+            end
+          end
+          nil
+        when AST::UnaryOp
+          evaluate_unary(expression)
+        when AST::BinaryOp
+          evaluate_binary(expression)
+        when AST::IfExpr
+          condition = evaluate(expression.condition)
+          return unless ConstEval.boolean_value?(condition)
+
+          evaluate(condition ? expression.then_expression : expression.else_expression)
+        else
+          nil
+        end
+      end
+
+      private
+
+      def resolve_layout_type(type_ref)
+        return unless @resolve_type_ref
+
+        @resolve_type_ref.call(type_ref)
+      end
+
+      def evaluate_unary(expression)
+        operand = evaluate(expression.operand)
+
+        case expression.operator
+        when "+"
+          operand.is_a?(Numeric) ? operand : nil
+        when "-"
+          operand.is_a?(Numeric) ? -operand : nil
+        when "~"
+          operand.is_a?(Integer) ? ~operand : nil
+        when "not"
+          ConstEval.boolean_value?(operand) ? !operand : nil
+        end
+      end
+
+      def evaluate_binary(expression)
+        left = evaluate(expression.left)
+
+        case expression.operator
+        when "and"
+          return unless ConstEval.boolean_value?(left)
+          return false if left == false
+
+          right = evaluate(expression.right)
+          return right if ConstEval.boolean_value?(right)
+
+          return nil
+        when "or"
+          return unless ConstEval.boolean_value?(left)
+          return true if left == true
+
+          right = evaluate(expression.right)
+          return right if ConstEval.boolean_value?(right)
+
+          return nil
+        end
+
+        right = evaluate(expression.right)
+
+        case expression.operator
+        when "=="
+          ConstEval.equality_result(left, right)
+        when "!="
+          result = ConstEval.equality_result(left, right)
+          result.nil? ? nil : !result
+        when "+"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
+        when "-"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
+        when "*"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left * right : nil
+        when "/"
+          return unless left.is_a?(Numeric) && right.is_a?(Numeric)
+          raise CompileTime::Error, "division by zero" if zero_numeric?(right)
+
+          left / right
+        when "%"
+          return unless left.is_a?(Integer) && right.is_a?(Integer)
+          raise CompileTime::Error, "modulo by zero" if right.zero?
+
+          left % right
+        when "<<"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left << right : nil
+        when ">>"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left >> right : nil
+        when "&"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left & right : nil
+        when "|"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left | right : nil
+        when "^"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left ^ right : nil
+        when "<"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left < right : nil
+        when "<="
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left <= right : nil
+        when ">"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left > right : nil
+        when ">="
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left >= right : nil
+        end
+      end
+
+      def zero_numeric?(value)
+        (value.is_a?(Integer) && value.zero?) || (value.is_a?(Float) && value.zero?)
+      end
+    end
+  end
+end