mt-lang 0.2.0

data/lib/milk_tea/core/lowering.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+# Lowering transforms the SemanticAnalyzer analysis into IR::Program.
+#
+# Contract with SemanticAnalyzer::Analysis — the Lowerer reads these fields:
+#   .ast                    raw parsed AST
+#   .module_name            module identifier string
+#   .module_kind            :module or :raw_module
+#   .directives             compiler/link/include directives
+#   .imports                imported module bindings
+#   .types                  Hash[name → Types::Base]
+#   .interfaces             Hash[name → InterfaceBinding|GenericInterfaceBinding]
+#   .attributes             Hash[name → AttributeBinding]
+#   .attribute_applications Hash[...]
+#   .values                 Hash[name → ValueBinding]
+#   .functions              Hash[name → FunctionBinding]
+#   .methods                Hash[type → Hash[name → FunctionBinding]]
+#   .implemented_interfaces Hash[type → Set[InterfaceBinding]]
+#   .resolved_expr_types   Hash[expression.object_id → Types::Base]
+#   .uses_parallel_for      bool
+#
+# Cross-module access uses analysis_for_module(name) which returns
+# another module's Analysis and its fields as listed above.
+#
+# The output is IR::Program, consumed by CBackend.
+
+require_relative "lowering/scans"
+require_relative "lowering/declarations"
+require_relative "lowering/events"
+require_relative "lowering/functions"
+require_relative "lowering/async/analysis"
+require_relative "lowering/async/normalization"
+require_relative "lowering/async/lowering"
+require_relative "lowering/async"
+require_relative "lowering/block"
+require_relative "lowering/proc"
+require_relative "lowering/loops"
+require_relative "lowering/expressions"
+require_relative "lowering/calls"
+require_relative "lowering/foreign_cstr"
+require_relative "lowering/str_buffer"
+require_relative "lowering/resolve"
+require_relative "lowering/dyn"
+require_relative "lowering/utils"
+require_relative "lowering/artifacts"
+require_relative "lowering/lowering_context"
+
+module MilkTea
+  class LoweringError < 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
+      "lowering/internal"
+    end
+  end
+
+  class Lowering
+    def self.lower(program)
+      lowerer = Lowerer.new(program)
+      ir_program, _modules, _synths = lowerer.lower_and_assemble
+      ir_program
+    end
+
+    def self.lower_incremental(program, cached: nil, cached_synthetics: nil)
+      lowerer = Lowerer.new(program)
+      lowerer.lower_and_assemble(cached:, cached_synthetics:)
+    end
+  end
+
+  ExplicitDefaultBinding = Data.define(:binding, :callee_name)
+  ExplicitHashBinding = Data.define(:binding, :callee_name)
+  ExplicitEqualBinding = Data.define(:binding, :callee_name)
+  ExplicitOrderBinding = Data.define(:binding, :callee_name)
+  ExplicitFormatBinding = Data.define(:length_binding, :length_callee_name, :append_binding, :append_callee_name)
+  DefaultResolution = Data.define(:target_type, :binding, :callee_name)
+  HashResolution = Data.define(:target_type, :binding, :callee_name)
+  EqualResolution = Data.define(:target_type, :binding, :callee_name)
+  OrderResolution = Data.define(:target_type, :binding, :callee_name)
+
+  class Lowerer
+    include CompatibilityHelpers
+
+    attr_accessor :bypass_sema_type_cache
+    attr_reader :recorded_expr_types
+
+    def initialize(program)
+      @program = program
+      @ctx = ModuleContext.new
+      @artifacts = Artifacts.new
+      @synthetic_proc_counter = 0
+      @parallel_for_counter = 0
+      @async_binding_counter = 0
+      @method_definitions = build_method_definitions
+      @bypass_sema_type_cache = false
+    end
+
+    def lower
+      @recorded_expr_types = {} if @bypass_sema_type_cache
+      ir_program, _modules, _synths = lower_and_assemble
+      ir_program
+    end
+
+    def lower_and_assemble(cached: nil, cached_synthetics: nil)
+      modules, per_module_synthetics = lower_modules(cached:, cached_synthetics:)
+      [assemble_modules(modules), modules, per_module_synthetics]
+    end
+
+    def lower_modules(cached: nil, cached_synthetics: nil)
+      if @program.root_analysis.module_kind == :raw_module
+        raise LoweringError, "cannot emit C for external file #{@program.root_analysis.module_name}"
+      end
+
+      per_module_synthetics = {}
+      per_module_funcs = Hash.new { |h, k| h[k] = [] }
+      modules = {}
+
+      cached_synthetics&.each do |_module_name, synths|
+        @artifacts.synthetic_structs.concat(synths[:structs] || [])
+        @artifacts.synthetic_enums.concat(synths[:enums] || [])
+        @artifacts.synthetic_functions.concat(synths[:functions] || [])
+        @artifacts.synthetic_constants.concat(synths[:constants] || [])
+      end
+
+      cached&.each do |module_name, cached_ir|
+        modules[module_name] = cached_ir.with(functions: [])
+        per_module_funcs[module_name] = cached_ir.functions.dup
+        cached_ir.functions.each { |f| @artifacts.lowered_function_linkage_names[f.linkage_name] = true }
+      end
+
+      ordered_analysis_pairs.each do |path, analysis|
+        next if analysis.module_kind == :raw_module
+        next if modules.key?(analysis.module_name)
+
+        prepare_analysis(analysis, source_path: path)
+        collect_structs
+
+        synth_before_s = @artifacts.synthetic_structs.length
+        synth_before_e = @artifacts.synthetic_enums.length
+        synth_before_f = @artifacts.synthetic_functions.length
+        synth_before_c = @artifacts.synthetic_constants.length
+
+        modules[analysis.module_name] = IR::Program.new(
+          module_name: analysis.module_name,
+          includes: [],
+          constants: lower_constants.dup,
+          globals: lower_globals.dup,
+          opaques: lower_opaques.dup,
+          structs: lower_structs.dup,
+          unions: lower_unions.dup,
+          enums: lower_enums.dup,
+          variants: lower_variants.dup,
+          static_asserts: lower_static_asserts.dup,
+          functions: [],
+          source_path: path,
+        )
+        per_module_funcs[analysis.module_name].concat(lower_functions)
+
+        per_module_synthetics[analysis.module_name] = {
+          structs: @artifacts.synthetic_structs[synth_before_s..] || [],
+          enums: @artifacts.synthetic_enums[synth_before_e..] || [],
+          functions: @artifacts.synthetic_functions[synth_before_f..] || [],
+          constants: @artifacts.synthetic_constants[synth_before_c..] || [],
+        }
+      end
+
+      pending = true
+      while pending
+        pending = false
+
+        ordered_analysis_pairs.each do |path, analysis|
+          next if analysis.module_kind == :raw_module
+
+          prepare_analysis(analysis, source_path: path)
+          ensure_events_for_analysis(analysis)
+
+          synth_before_s = @artifacts.synthetic_structs.length
+          synth_before_e = @artifacts.synthetic_enums.length
+          synth_before_f = @artifacts.synthetic_functions.length
+          synth_before_c = @artifacts.synthetic_constants.length
+
+          newly_lowered = lower_functions
+          next if newly_lowered.empty?
+
+          per_module_funcs[analysis.module_name].concat(newly_lowered)
+
+          delta = {
+            structs: @artifacts.synthetic_structs[synth_before_s..] || [],
+            enums: @artifacts.synthetic_enums[synth_before_e..] || [],
+            functions: @artifacts.synthetic_functions[synth_before_f..] || [],
+            constants: @artifacts.synthetic_constants[synth_before_c..] || [],
+          }
+          existing = per_module_synthetics[analysis.module_name]
+          per_module_synthetics[analysis.module_name] = existing ? merge_synthetics(existing, delta) : delta
+
+          pending = true
+        end
+      end
+
+      modules.transform_values! do |fragment|
+        fragment.with(functions: per_module_funcs[fragment.module_name])
+      end
+
+      [modules, per_module_synthetics]
+    end
+
+    def merge_synthetics(a, b)
+      {
+        structs: (a[:structs] || []) + (b[:structs] || []),
+        enums: (a[:enums] || []) + (b[:enums] || []),
+        functions: (a[:functions] || []) + (b[:functions] || []),
+        constants: (a[:constants] || []) + (b[:constants] || []),
+      }
+    end
+
+    def ensure_events_for_analysis(analysis)
+      analysis.ast.declarations.grep(AST::EventDecl).each do |decl|
+        event_type = analysis.values.fetch(decl.name).type
+        ensure_event_runtime(event_type)
+      end
+    end
+
+    def assemble_modules(modules)
+      if @program.root_analysis.module_kind == :raw_module
+        raise LoweringError, "cannot emit C for external file #{@program.root_analysis.module_name}"
+      end
+
+      regenerate_cross_module_synthetics
+
+      includes = collect_includes
+
+      ordered = ordered_module_fragments(modules)
+      all_constants = ordered.flat_map(&:constants)
+      all_constants.concat(@artifacts.synthetic_constants)
+      all_globals = ordered.flat_map(&:globals)
+      all_opaques = ordered.flat_map(&:opaques)
+      all_structs = ordered.flat_map(&:structs)
+      all_unions = ordered.flat_map(&:unions)
+      all_enums = ordered.flat_map(&:enums)
+      all_variants = ordered.flat_map(&:variants)
+      all_static_asserts = ordered.flat_map(&:static_asserts)
+      all_static_asserts.concat(@artifacts.external_layout_assertions)
+      all_functions = ordered.flat_map(&:functions)
+
+      all_opaques.concat(lower_imported_external_opaques)
+      all_structs.concat(@artifacts.synthetic_structs.uniq { |s| s.linkage_name })
+      all_enums.concat(@artifacts.synthetic_enums.uniq { |e| e.linkage_name })
+      all_functions.concat(@artifacts.synthetic_functions.uniq { |f| f.linkage_name })
+
+      # Add emit-generated declarations
+      @artifacts.emitted_declarations.each do |emitted|
+        case emitted
+        when IR::Function
+          all_functions << emitted
+        when IR::StructDecl
+          all_structs << emitted
+        when IR::Constant
+          all_constants << emitted
+        end
+      end
+
+      IR::Program.new(
+        module_name: @program.root_analysis.module_name,
+        includes:,
+        constants: all_constants,
+        globals: all_globals,
+        opaques: all_opaques,
+        structs: all_structs,
+        unions: all_unions,
+        enums: all_enums,
+        variants: all_variants,
+        static_asserts: all_static_asserts,
+        functions: all_functions,
+        source_path: @program.root_path,
+      )
+    end
+
+    def regenerate_cross_module_synthetics
+      ordered_analysis_pairs.each do |path, analysis|
+        next if analysis.module_kind == :raw_module
+
+        prepare_analysis(analysis, source_path: path)
+        analysis.ast.declarations.grep(AST::EventDecl).each do |decl|
+          event_type = analysis.values.fetch(decl.name).type
+          ensure_event_runtime(event_type) if event_type.is_a?(Types::Event)
+        end
+      end
+    end
+
+    # Canonical, deterministic iteration order over the program's analyses so
+    # that lowering — and therefore the emitted C — is byte-identical regardless
+    # of how the analyses were assembled (live ModuleLoader vs. JSON-reconstructed
+    # bundle). Modules are emitted in dependency-first topological order, with
+    # lexicographic module-name order as a stable tiebreaker for independent
+    # modules and as a cycle-breaking fallback.
+    def ordered_analysis_pairs
+      @ordered_analysis_pairs ||= compute_ordered_analysis_pairs
+    end
+
+    def compute_ordered_analysis_pairs
+      pairs = @program.analyses_by_path.to_a
+      by_name = {}
+      pairs.each do |path, analysis|
+        name = analysis.module_name.to_s
+        by_name[name] ||= [path, analysis]
+      end
+
+      present = by_name.keys.to_set
+      deps_of = Hash.new { |hash, key| hash[key] = [] }
+      pairs.each do |_path, analysis|
+        name = analysis.module_name.to_s
+        imported_module_names(analysis).each do |dep|
+          deps_of[name] << dep if present.include?(dep) && dep != name
+        end
+      end
+      deps_of.each_value(&:uniq!)
+
+      canonical_module_names(by_name.keys, deps_of).map { |name| by_name[name] }
+    end
+
+    def imported_module_names(analysis)
+      imports = analysis.respond_to?(:imports) ? analysis.imports : nil
+      return [] unless imports.respond_to?(:values)
+
+      imports.values.filter_map do |binding|
+        binding.name.to_s if binding.respond_to?(:name) && binding.name
+      end
+    end
+
+    def canonical_module_names(names, deps_of)
+      visited = {}
+      on_stack = {}
+      order = []
+      visit = nil
+      visit = lambda do |name|
+        return if visited[name] || on_stack[name]
+
+        on_stack[name] = true
+        (deps_of[name] || []).sort.each { |dep| visit.call(dep) }
+        on_stack.delete(name)
+        visited[name] = true
+        order << name
+      end
+      names.sort.each { |name| visit.call(name) }
+      order
+    end
+
+    def ordered_module_fragments(modules)
+      ordered = ordered_analysis_pairs.filter_map { |_path, analysis| modules[analysis.module_name] }
+      ordered.concat(modules.values - ordered)
+      ordered
+    end
+
+    private
+
+    include LowererScans
+    include LowererDeclarations
+    include LowererEvents
+    include LowererFunctions
+    include LowererAsync
+    include LowererBlock
+    include LowererProc
+    include LowererLoops
+    include LowererExpressions
+    include LowererCalls
+    include LowererForeignCstr
+    include LowererStrBuffer
+    include LowererResolve
+    include LowererDyn
+    include LowererUtils
+  end
+end

data/lib/milk_tea/core/module_binder.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class ModuleBinder
+    def module_binding(analysis)
+      types = {}
+      type_declarations = {}
+      interfaces = {}
+      attributes = {}
+      private_types = {}
+      private_interfaces = {}
+      private_attributes = {}
+      values = {}
+      private_values = {}
+      functions = {}
+      private_functions = {}
+
+      analysis.ast.declarations.each do |declaration|
+        case declaration
+        when AST::StructDecl, AST::UnionDecl, AST::VariantDecl, AST::EnumDecl, AST::FlagsDecl, AST::OpaqueDecl, AST::TypeAliasDecl
+          type_declarations[declaration.name] = declaration
+          target = exported_declaration?(analysis, declaration) ? types : private_types
+          target[declaration.name] = analysis.types.fetch(declaration.name)
+        when AST::InterfaceDecl
+          target = exported_declaration?(analysis, declaration) ? interfaces : private_interfaces
+          target[declaration.name] = analysis.interfaces.fetch(declaration.name)
+        when AST::AttributeDecl
+          target = exported_declaration?(analysis, declaration) ? attributes : private_attributes
+          target[declaration.name] = analysis.attributes.fetch(declaration.name)
+        when AST::ConstDecl, AST::VarDecl, AST::EventDecl
+          target = exported_declaration?(analysis, declaration) ? values : private_values
+          target[declaration.name] = analysis.values.fetch(declaration.name)
+        when AST::FunctionDef, AST::ExternFunctionDecl, AST::ForeignFunctionDecl
+          target = exported_declaration?(analysis, declaration) ? functions : private_functions
+          target[declaration.name] = analysis.functions.fetch(declaration.name)
+        end
+      end
+
+      methods, private_methods = exported_methods(analysis, types)
+      implemented_interfaces, private_implemented_interfaces = exported_interface_implementations(analysis, types, interfaces)
+
+      ModuleBinding.new(
+        name: analysis.module_name,
+        types:,
+        type_declarations:,
+        interfaces:,
+        attributes:,
+        attribute_applications: analysis.attribute_applications,
+        values:,
+        functions:,
+        methods:,
+        implemented_interfaces:,
+        imports: analysis.imports,
+        private_types:,
+        private_interfaces:,
+        private_attributes:,
+        private_values:,
+        private_functions:,
+        private_methods:,
+        private_implemented_interfaces:,
+      )
+    end
+
+    private
+
+    def exported_declaration?(analysis, declaration)
+      return true if analysis.module_kind == :raw_module
+      return false unless declaration.respond_to?(:visibility)
+
+      declaration.visibility == :public
+    end
+
+    def exported_methods(analysis, exported_types)
+      methods = {}
+      private_methods = {}
+
+      analysis.methods.each do |receiver_type, bindings|
+        public_bindings = {}
+        hidden_bindings = {}
+
+        bindings.each do |name, binding|
+          visible = binding.ast.respond_to?(:visibility) &&
+            binding.ast.visibility == :public &&
+            exported_method_receiver?(receiver_type, analysis, exported_types)
+
+          if visible
+            public_bindings[name] = binding
+          else
+            hidden_bindings[name] = binding
+          end
+        end
+
+        methods[receiver_type] = public_bindings unless public_bindings.empty?
+        private_methods[receiver_type] = hidden_bindings unless hidden_bindings.empty?
+      end
+
+      [methods, private_methods]
+    end
+
+    def exported_interface_implementations(analysis, exported_types, exported_interfaces)
+      implemented_interfaces = {}
+      private_implemented_interfaces = {}
+
+      analysis.implemented_interfaces.each do |receiver_type, interfaces|
+        public_interfaces = []
+        hidden_interfaces = []
+
+        interfaces.each do |interface|
+          visible = exported_method_receiver?(receiver_type, analysis, exported_types) &&
+            exported_interface_binding?(interface, analysis, exported_interfaces) &&
+            exported_interface_methods?(receiver_type, interface, analysis, exported_types)
+          if visible
+            public_interfaces << interface
+          else
+            hidden_interfaces << interface
+          end
+        end
+
+        implemented_interfaces[receiver_type] = public_interfaces.freeze unless public_interfaces.empty?
+        private_implemented_interfaces[receiver_type] = hidden_interfaces.freeze unless hidden_interfaces.empty?
+      end
+
+      [implemented_interfaces.freeze, private_implemented_interfaces.freeze]
+    end
+
+    def exported_interface_methods?(receiver_type, interface, analysis, exported_types)
+      return false unless exported_method_receiver?(receiver_type, analysis, exported_types)
+
+      interface.methods.each_key.all? do |method_name|
+        binding = analysis.methods.fetch(receiver_type, {})[method_name]
+        binding && binding.ast.respond_to?(:visibility) && binding.ast.visibility == :public
+      end
+    end
+
+    def exported_interface_binding?(interface, analysis, exported_interfaces)
+      return true if exported_interfaces.value?(interface)
+
+      imported_interface_binding?(interface, analysis.imports)
+    end
+
+    def exported_method_receiver?(receiver_type, analysis, exported_types)
+      return true if receiver_type.is_a?(Types::StringView)
+      return true if receiver_type.is_a?(Types::Primitive)
+      return true if receiver_type.is_a?(Types::Vector)
+      return true if receiver_type.is_a?(Types::Matrix)
+      return true if receiver_type.is_a?(Types::Quaternion)
+      return true if receiver_type.is_a?(Types::SoA)
+      return true if exported_types.value?(receiver_type)
+      return true if imported_receiver_type?(receiver_type, analysis.imports)
+      return exported_method_receiver?(receiver_type.base, analysis, exported_types) if receiver_type.is_a?(Types::Nullable)
+      return receiver_type.arguments.all? { |argument| exported_method_receiver_argument?(argument, analysis, exported_types) } if receiver_type.is_a?(Types::GenericInstance)
+      return exported_types.value?(receiver_type.definition) || imported_receiver_type?(receiver_type.definition, analysis.imports) if receiver_type.is_a?(Types::VariantInstance)
+
+      receiver_type.is_a?(Types::StructInstance) &&
+        (exported_types.value?(receiver_type.definition) || imported_receiver_type?(receiver_type.definition, analysis.imports))
+    end
+
+    def exported_method_receiver_argument?(argument, analysis, exported_types)
+      return true if argument.is_a?(Types::LiteralTypeArg)
+      return true if argument.is_a?(Types::TypeVar)
+
+      exported_method_receiver?(argument, analysis, exported_types)
+    end
+
+    def imported_receiver_type?(receiver_type, imports)
+      imports.each_value do |module_binding|
+        return true if module_binding.types.value?(receiver_type)
+      end
+
+      false
+    end
+
+    def imported_interface_binding?(interface, imports)
+      imports.each_value do |module_binding|
+        return true if module_binding.interfaces.value?(interface)
+      end
+
+      false
+    end
+  end
+end

data/lib/milk_tea/core/module_loader/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class ModuleLoadError < StandardError
+    attr_reader :path
+
+    def initialize(message, path:)
+      @path = path
+      super("#{message}: #{path}")
+    end
+
+    def code
+      "module/error"
+    end
+  end
+
+  class ModuleLoader
+    ImportResolution = Data.define(:modules, :errors)
+    ImportResolutionError = Data.define(:import, :error)
+  end
+end