mt-lang 0.2.0

data/lib/milk_tea/core/ast.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module AST
+    class QualifiedName < Data.define(:parts, :type_arguments, :line, :column)
+      def initialize(parts:, type_arguments: [], line: nil, column: nil) = super
+      def to_s
+        parts.join(".")
+      end
+    end
+
+    TypeParamConstraint = Data.define(:kind, :interface_ref) do
+      def initialize(kind:, interface_ref: nil) = super
+    end
+
+    TypeParam = Data.define(:name, :constraints, :line, :column, :length) do
+      def initialize(name:, constraints: [], line: nil, column: nil, length: nil) = super
+    end
+    ValueTypeParam = Data.define(:name, :type, :line, :column, :length) do
+      def initialize(name:, type:, line: nil, column: nil, length: nil) = super
+    end
+    TypeArgument = Data.define(:value)
+    class TypeRef < Data.define(:name, :arguments, :nullable, :lifetime, :line, :column, :length)
+      def initialize(name:, arguments:, nullable:, lifetime: nil, line: nil, column: nil, length: nil) = super
+
+      def to_s
+        text = name.to_s
+        args = []
+        args << lifetime if lifetime
+        args.concat(arguments.map do |argument|
+          value = argument.value
+          case value
+          when IntegerLiteral, FloatLiteral then value.lexeme
+          else value.to_s
+          end
+        end)
+        unless args.empty?
+          text += "[#{args.join(', ')}]"
+        end
+        nullable ? "#{text}?" : text
+      end
+    end
+    FunctionType = Data.define(:params, :return_type)
+    ProcType = Data.define(:params, :return_type)
+    TupleType = Data.define(:element_types, :nullable) do
+      def initialize(element_types:, nullable: false) = super
+    end
+    DynType = Data.define(:interface, :nullable, :line, :column, :length) do
+      def initialize(interface:, nullable: false, line: nil, column: nil, length: nil) = super
+    end
+    SourceFile = Data.define(:module_name, :module_kind, :imports, :directives, :declarations, :line, :node_ids, :node_path_ids) do
+      def initialize(module_name:, module_kind:, imports:, directives:, declarations:, line: nil, node_ids: {}, node_path_ids: {}) = super
+    end
+    Import = Data.define(:path, :alias_name, :line, :column, :length) do
+      def initialize(path:, alias_name:, line: nil, column: nil, length: nil) = super
+    end
+    LinkDirective = Data.define(:value)
+    IncludeDirective = Data.define(:value)
+    CompilerFlagDirective = Data.define(:value)
+    ConstDecl = Data.define(:name, :type, :value, :block_body, :visibility, :attributes, :line, :column) do
+      def initialize(name:, type:, value:, block_body: nil, visibility:, attributes: [], line: nil, column: nil) = super
+    end
+    VarDecl = Data.define(:name, :type, :value, :visibility, :line, :column) do
+      def initialize(name:, type:, value:, visibility:, line: nil, column: nil) = super
+    end
+    EventDecl = Data.define(:name, :capacity, :payload_type, :visibility, :attributes, :line, :column) do
+      def initialize(name:, capacity:, payload_type: nil, visibility:, attributes: [], line: nil, column: nil) = super
+    end
+    TypeAliasDecl = Data.define(:name, :target, :visibility, :line, :column) do
+      def initialize(name:, target:, visibility:, line: nil, column: nil) = super
+    end
+    AttributeDecl = Data.define(:name, :targets, :params, :visibility, :line, :column) do
+      def initialize(name:, targets:, params:, visibility:, line: nil, column: nil) = super
+    end
+    AttributeApplication = Data.define(:name, :arguments, :line, :column) do
+      def initialize(name:, arguments:, line: nil, column: nil) = super
+    end
+    StructDecl = Data.define(:name, :type_params, :implements, :c_name, :fields, :events, :nested_types, :attributes, :packed, :alignment, :visibility, :lifetime_params, :line, :column) do
+      def initialize(name:, type_params:, implements:, c_name:, fields:, events: [], nested_types: [], attributes: [], packed:, alignment:, visibility:, lifetime_params: [], line: nil, column: nil) = super
+    end
+    UnionDecl = Data.define(:name, :c_name, :fields, :visibility, :attributes, :line, :column) do
+      def initialize(name:, c_name:, fields:, visibility:, attributes: [], line: nil, column: nil) = super
+    end
+    Field = Data.define(:name, :type, :attributes, :line, :column) do
+      def initialize(name:, type:, attributes: [], line: nil, column: nil) = super
+    end
+    EnumDecl = Data.define(:name, :backing_type, :members, :visibility, :attributes, :line, :column) do
+      def initialize(name:, backing_type:, members:, visibility:, attributes: [], line: nil, column: nil) = super
+    end
+    FlagsDecl = Data.define(:name, :backing_type, :members, :visibility, :attributes, :line, :column) do
+      def initialize(name:, backing_type:, members:, visibility:, attributes: [], line: nil, column: nil) = super
+    end
+    EnumMember = Data.define(:name, :value, :line, :column) do
+      def initialize(name:, value:, line: nil, column: nil) = super
+    end
+    OpaqueDecl = Data.define(:name, :implements, :c_name, :visibility, :line, :column) do
+      def initialize(name:, implements:, c_name:, visibility:, line: nil, column: nil) = super
+    end
+    InterfaceDecl = Data.define(:name, :type_params, :methods, :visibility, :line, :column) do
+      def initialize(name:, type_params: [], methods:, visibility:, line: nil, column: nil) = super
+    end
+    ExtendingBlock = Data.define(:type_name, :methods, :line, :column) do
+      def initialize(type_name:, methods:, line: nil, column: nil) = super
+    end
+    InterfaceMethodDecl = Data.define(:name, :params, :return_type, :kind, :async, :attributes, :line, :column) do
+      def initialize(name:, params:, return_type:, kind:, async:, attributes: [], line: nil, column: nil) = super
+    end
+    FunctionDef = Data.define(:name, :type_params, :params, :return_type, :body, :visibility, :async, :const, :attributes, :line, :column) do
+      def initialize(name:, type_params:, params:, return_type:, body:, visibility:, async:, const: false, attributes: [], line: nil, column: nil) = super
+    end
+    MethodDef = Data.define(:name, :type_params, :params, :return_type, :body, :kind, :visibility, :async, :attributes, :line, :column) do
+      def initialize(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, attributes: [], line: nil, column: nil) = super
+    end
+    ExternFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :attributes, :line, :mapping) do
+      def initialize(name:, type_params:, params:, return_type:, variadic:, attributes: [], line: nil, mapping: nil) = super
+    end
+    ForeignFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :mapping, :visibility, :attributes, :line) do
+      def initialize(name:, type_params:, params:, return_type:, variadic:, mapping:, visibility:, attributes: [], line: nil) = super
+    end
+    Param = Data.define(:name, :type, :line, :column) do
+      def initialize(name:, type:, line: nil, column: nil) = super
+    end
+    ForeignParam = Data.define(:name, :type, :mode, :boundary_type)
+    LocalDecl = Data.define(:kind, :name, :type, :value, :else_binding, :else_body, :line, :column, :recovered_else, :destructure_bindings, :destructure_type_name) do
+      def initialize(kind:, name:, type:, value:, else_binding: nil, else_body: nil, line: nil, column: nil, recovered_else: false, destructure_bindings: nil, destructure_type_name: nil) = super
+    end
+    Assignment = Data.define(:target, :operator, :value, :line, :column) do
+      def initialize(target:, operator:, value:, line: nil, column: nil) = super
+    end
+    IfBranch = Data.define(:condition, :body, :line, :column, :length) do
+      def initialize(condition:, body:, line: nil, column: nil, length: nil) = super
+    end
+    IfStmt = Data.define(:branches, :else_body, :inline, :line, :else_line, :else_column) do
+      def initialize(branches:, else_body:, inline: false, line: nil, else_line: nil, else_column: nil) = super
+    end
+    VariantDecl = Data.define(:name, :type_params, :arms, :visibility, :attributes, :line, :column) do
+      def initialize(name:, type_params:, arms:, visibility:, attributes: [], line: nil, column: nil) = super
+    end
+    VariantArm = Data.define(:name, :fields)
+    MatchArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    end
+    MatchStmt = Data.define(:expression, :arms, :inline, :line, :column, :length) do
+      def initialize(expression:, arms:, inline: false, line: nil, column: nil, length: nil) = super
+    end
+    MatchExprArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :value) do
+      def initialize(pattern:, binding_name:, value:, binding_line: nil, binding_column: nil) = super
+    end
+    WhenBranch = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    end
+    WhenStmt = Data.define(:discriminant, :branches, :else_body, :line, :column, :length) do
+      def initialize(discriminant:, branches:, else_body:, line: nil, column: nil, length: nil) = super
+    end
+    UnsafeStmt = Data.define(:body, :line, :column, :length) do
+      def initialize(body:, line: nil, column: nil, length: nil) = super
+    end
+    StaticAssert = Data.define(:condition, :message, :line) do
+      def initialize(condition:, message:, line: nil) = super
+    end
+    EmitStmt = Data.define(:declaration, :line, :column) do
+      def initialize(declaration:, line: nil, column: nil) = super
+    end
+    ForBinding = Data.define(:name, :line, :column) do
+      def initialize(name:, line: nil, column: nil) = super
+    end
+    ForStmt = Data.define(:bindings, :iterables, :body, :inline, :threaded, :line, :column) do
+      def initialize(bindings:, iterables:, body:, inline: false, threaded: false, line: nil, column: nil) = super
+      def name = bindings.first.name
+      def names = bindings.map(&:name)
+      def binding = bindings.first
+      def iterable = iterables.first
+      def parallel? = bindings.length > 1 || iterables.length > 1
+    end
+    ParallelBlockStmt = Data.define(:bodies, :line, :column) do
+      def initialize(bodies:, line: nil, column: nil) = super
+    end
+    DetachExpr = Data.define(:body, :line, :column) do
+      def initialize(body:, line: nil, column: nil) = super
+    end
+    GatherStmt = Data.define(:handles, :line, :column) do
+      def initialize(handles:, line: nil, column: nil) = super
+    end
+    WhileStmt = Data.define(:condition, :body, :inline, :line, :column, :length) do
+      def initialize(condition:, body:, inline: false, line: nil, column: nil, length: nil) = super
+    end
+    BreakStmt = Data.define(:line, :column, :length) do
+      def initialize(line: nil, column: nil, length: nil) = super
+    end
+    ContinueStmt = Data.define(:line, :column, :length) do
+      def initialize(line: nil, column: nil, length: nil) = super
+    end
+    PassStmt = Data.define(:line, :column, :length) do
+      def initialize(line: nil, column: nil, length: nil) = super
+    end
+    ReturnStmt = Data.define(:value, :line, :column, :length) do
+      def initialize(value:, line: nil, column: nil, length: nil) = super
+    end
+    DeferStmt = Data.define(:expression, :body, :line, :column, :length) do
+      def initialize(expression:, body:, line: nil, column: nil, length: nil) = super
+    end
+    ErrorBlockStmt = Data.define(:body, :line, :column, :length, :message, :header_type, :header_expression, :header_bindings, :header_iterables) do
+      def initialize(body:, line: nil, column: nil, length: nil, message: nil, header_type: nil, header_expression: nil, header_bindings: nil, header_iterables: nil) = super
+    end
+    ErrorStmt = Data.define(:line, :column, :length, :message) do
+      def initialize(line: nil, column: nil, length: nil, message: nil) = super
+    end
+    ErrorExpr = Data.define(:line, :column, :length, :message) do
+      def initialize(line: nil, column: nil, length: nil, message: nil) = super
+    end
+    ExpressionStmt = Data.define(:expression, :line) do
+      def initialize(expression:, line: nil) = super
+    end
+
+    Identifier = Data.define(:name, :line, :column) do
+      def initialize(name:, line: nil, column: nil) = super
+    end
+    MemberAccess = Data.define(:receiver, :member, :line, :column) do
+      def initialize(receiver:, member:, line: nil, column: nil) = super
+    end
+    IndexAccess = Data.define(:receiver, :index)
+    Specialization = Data.define(:callee, :arguments)
+    Call = Data.define(:callee, :arguments)
+    Argument = Data.define(:name, :value)
+    UnaryOp = Data.define(:operator, :operand)
+    BinaryOp = Data.define(:operator, :left, :right)
+    RangeExpr = Data.define(:start_expr, :end_expr, :line, :column)
+    ExpressionList = Data.define(:elements, :line, :column)
+    IfExpr = Data.define(:condition, :then_expression, :else_expression)
+    MatchExpr = Data.define(:expression, :arms, :line, :column, :length) do
+      def initialize(expression:, arms:, line: nil, column: nil, length: nil) = super
+    end
+    UnsafeExpr = Data.define(:expression, :line, :column, :length) do
+      def initialize(expression:, line: nil, column: nil, length: nil) = super
+    end
+    ProcExpr = Data.define(:params, :return_type, :body)
+    AwaitExpr = Data.define(:expression)
+    SizeofExpr = Data.define(:type)
+    AlignofExpr = Data.define(:type)
+    OffsetofExpr = Data.define(:type, :field)
+    IntegerLiteral = Data.define(:lexeme, :value)
+    FloatLiteral = Data.define(:lexeme, :value)
+    StringLiteral = Data.define(:lexeme, :value, :cstring)
+    FormatString = Data.define(:parts)
+    FormatTextPart = Data.define(:value)
+    FormatExprPart = Data.define(:expression, :format_spec)
+    CharLiteral = Data.define(:lexeme, :value, :line, :column) do
+      def initialize(lexeme:, value:, line: nil, column: nil) = super
+    end
+    BooleanLiteral = Data.define(:value)
+    NullLiteral = Data.define(:type, :line, :column) do
+      def initialize(type:, line: nil, column: nil) = super
+    end
+    PrefixCast = Data.define(:target_type, :expression, :line, :column, :length) do
+      def initialize(target_type:, expression:, line: nil, column: nil, length: nil) = super
+    end
+
+    def self.assign_node_ids(source_file)
+      next_id = 0
+      node_ids = {}
+      path_ids = {}
+
+      visit = ->(node, path = "") do
+        return [next_id, path] unless node.is_a?(::Data)
+
+        node_ids[node.object_id] = (next_id += 1)
+        current_path = path.empty? ? node.class.name.sub(/\AMilkTea::AST::/, "") : path
+        path_ids[current_path] = node_ids[node.object_id]
+
+        if node.respond_to?(:declarations) && node.declarations.is_a?(Array)
+          node.declarations.each_with_index { |d, i| visit.call(d, "#{current_path}.declarations[#{i}]") }
+        end
+
+        if node.respond_to?(:body)
+          visit.call(node.body, "#{current_path}.body")
+        end
+
+        node.class.members.each do |field_name|
+          next if %i[module_name module_kind].include?(field_name)
+
+          value = node.public_send(field_name)
+          next unless value
+
+          field_path = "#{current_path}.#{field_name}"
+
+          case value
+          when ::Data
+            visit.call(value, field_path)
+          when Array
+            value.each_with_index do |v, i|
+              visit.call(v, "#{field_path}[#{i}]") if v.is_a?(::Data)
+            end
+          end
+        end
+      end
+
+      visit.call(source_file)
+      source_file.with(node_ids: node_ids.freeze, node_path_ids: path_ids.freeze)
+    end
+
+    def self.build_chain_from_parts(parts)
+      return nil unless parts.length >= 1
+
+      expr = Identifier.new(name: parts.first)
+      parts[1..].each do |part|
+        expr = MemberAccess.new(receiver: expr, member: part)
+      end
+      expr
+    end
+  end
+end

data/lib/milk_tea/core/async_runtime_installer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class AsyncRuntimeInstaller
+    def initialize(resolve_module_path:, check_block:, bind_block:)
+      @resolve_module_path = resolve_module_path
+      @check_block = check_block
+      @bind_block = bind_block
+    end
+
+    def install_async_runtime_dependency!(ast, modules, importer_path: nil, collecting_errors: false)
+      return if modules.key?("std.async")
+      return unless async_main_declared?(ast)
+
+      import_path = @resolve_module_path.call("std.async", importer_path:)
+      import_analysis = @check_block.call(import_path, collecting_errors)
+      modules["std.async"] = @bind_block.call(import_analysis)
+    end
+
+    private
+
+    def async_main_declared?(ast)
+      ast.declarations.any? do |decl|
+        decl.is_a?(AST::FunctionDef) && decl.name == "main" && decl.async
+      end
+    end
+  end
+end

data/lib/milk_tea/core/binding_types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "bindings/value_binding"
+require_relative "bindings/function_binding"
+require_relative "bindings/module_binding"
+require_relative "bindings/attribute_binding"
+
+module MilkTea
+  class FlowScope
+    def initialize = (@bindings = {})
+    def [](key) = @bindings[key]
+    def []=(key, val); @bindings[key] = val; end
+    def key?(key) = @bindings.key?(key)
+    def empty? = @bindings.empty?
+    def each(&block) = @bindings.each(&block)
+    def each_with_object(init, &block) = @bindings.each_with_object(init, &block)
+  end
+end

data/lib/milk_tea/core/bindings/attribute_binding.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MilkTea
+  AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin, :ast)
+  BUILTIN_ATTRIBUTE_NAMES = %w[packed align deprecated test expect_fatal].freeze
+
+  module_function
+
+  def builtin_attribute_binding(name, types)
+    case name
+    when "packed"
+      AttributeBinding.new(
+        name: "packed",
+        targets: [:struct].freeze,
+        params: [].freeze,
+        module_name: nil,
+        builtin: true,
+        ast: nil,
+      )
+    when "align"
+      AttributeBinding.new(
+        name: "align",
+        targets: [:struct].freeze,
+        params: [Types::Registry.parameter("bytes", types.fetch("ptr_uint"))].freeze,
+        module_name: nil,
+        builtin: true,
+        ast: nil,
+      )
+    when "deprecated"
+      AttributeBinding.new(
+        name: "deprecated",
+        targets: %i[callable struct const enum flags union variant event].freeze,
+        params: [Types::Registry.parameter("message", types.fetch("str"))].freeze,
+        module_name: nil,
+        builtin: true,
+        ast: nil,
+      )
+    when "test"
+      AttributeBinding.new(
+        name: "test",
+        targets: [:callable].freeze,
+        params: [].freeze,
+        module_name: nil,
+        builtin: true,
+        ast: nil,
+      )
+    when "expect_fatal"
+      AttributeBinding.new(
+        name: "expect_fatal",
+        targets: [:callable].freeze,
+        params: [].freeze,
+        module_name: nil,
+        builtin: true,
+        ast: nil,
+      )
+    end
+  end
+end

data/lib/milk_tea/core/bindings/function_binding.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MilkTea
+  FunctionBinding = Data.define(:name, :type, :body_params, :body_return_type, :ast, :external, :async, :type_params, :type_param_constraints, :instances, :type_arguments, :owner, :specialization_owner, :type_substitutions, :declared_receiver_type)
+end

data/lib/milk_tea/core/bindings/module_binding.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MilkTea
+  ModuleBinding = Data.define(:name, :types, :type_declarations, :interfaces, :attributes, :attribute_applications, :values, :functions, :methods, :implemented_interfaces, :imports, :private_types, :private_interfaces, :private_attributes, :private_values, :private_functions, :private_methods, :private_implemented_interfaces) do
+    def private_type?(name)
+      private_types.key?(name)
+    end
+
+    def private_interface?(name)
+      private_interfaces.key?(name)
+    end
+
+    def private_attribute?(name)
+      private_attributes.key?(name)
+    end
+
+    def private_value?(name)
+      private_values.key?(name)
+    end
+
+    def private_function?(name)
+      private_functions.key?(name)
+    end
+
+    def private_method?(receiver_type, name)
+      return true if private_methods.fetch(receiver_type, {}).key?(name)
+
+      if receiver_type.is_a?(Types::GenericInstance)
+        dispatch_receiver_type = Types::Registry.generic_instance(
+          receiver_type.name,
+          receiver_type.arguments.each_with_index.map do |argument, index|
+            argument.is_a?(Types::LiteralTypeArg) ? argument : Types::TypeVar.new("__receiver_arg#{index}")
+          end,
+        )
+        return true if dispatch_receiver_type != receiver_type && private_methods.fetch(dispatch_receiver_type, {}).key?(name)
+      end
+
+      if receiver_type.is_a?(Types::Nullable)
+        dispatch_base_type = receiver_type.base
+        if dispatch_base_type.is_a?(Types::StructInstance)
+          dispatch_base_type = dispatch_base_type.definition
+        elsif dispatch_base_type.is_a?(Types::GenericInstance)
+          dispatch_base_type = Types::Registry.generic_instance(
+            dispatch_base_type.name,
+            dispatch_base_type.arguments.each_with_index.map do |argument, index|
+              argument.is_a?(Types::LiteralTypeArg) ? argument : Types::TypeVar.new("__receiver_arg#{index}")
+            end,
+          )
+        end
+
+        dispatch_receiver_type = Types::Registry.nullable(dispatch_base_type)
+        return true if dispatch_receiver_type != receiver_type && private_methods.fetch(dispatch_receiver_type, {}).key?(name)
+      end
+
+      receiver_type.is_a?(Types::StructInstance) && private_methods.fetch(receiver_type.definition, {}).key?(name)
+    end
+  end
+end

data/lib/milk_tea/core/bindings/value_binding.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MilkTea
+  ValueBinding = Data.define(:id, :name, :storage_type, :flow_type, :mutable, :kind, :const_value) do
+    def type
+      flow_type || storage_type
+    end
+
+    def with_flow_type(refined_type)
+      ValueBinding.new(
+        id:,
+        name:,
+        storage_type:,
+        flow_type: refined_type == storage_type ? nil : refined_type,
+        mutable:,
+        kind:,
+        const_value:,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CBackend
+    module AggregateUtils
+      private
+
+          def each_variant_arm_field_type
+            @program.variants.each do |variant_decl|
+              variant_decl.arms.each do |arm|
+                arm.fields.each do |field|
+                  yield field.type
+                end
+              end
+            end
+          end
+
+          def sort_aggregate_decls(struct_decls, union_decls, variant_decls)
+            aggregate_decls = struct_decls + union_decls + variant_decls
+            by_c_name = aggregate_decls.each_with_object({}) do |aggregate_decl, declarations|
+              declarations[aggregate_decl.linkage_name] = aggregate_decl
+            end
+            variant_decls.each do |variant_decl|
+              variant_decl.arms.each do |arm|
+                next if arm.fields.empty?
+                by_c_name[arm.linkage_name] = variant_decl
+              end
+            end
+            visiting = {}
+            visited = {}
+            sorted = []
+
+            visit = lambda do |aggregate_decl|
+              return if visited[aggregate_decl.linkage_name]
+              raise CBackendError, "cyclic aggregate dependency involving #{aggregate_decl.linkage_name}" if visiting[aggregate_decl.linkage_name]
+
+              visiting[aggregate_decl.linkage_name] = true
+              aggregate_decl_dependencies(aggregate_decl).each do |dependency|
+                next unless by_c_name.key?(dependency)
+
+                visit.call(by_c_name.fetch(dependency))
+              end
+              visiting.delete(aggregate_decl.linkage_name)
+              visited[aggregate_decl.linkage_name] = true
+              sorted << aggregate_decl
+            end
+
+            aggregate_decls.each do |aggregate_decl|
+              visit.call(aggregate_decl)
+            end
+
+            sorted
+          end
+
+          def aggregate_decl_dependencies(aggregate_decl)
+            case aggregate_decl
+            when IR::StructDecl, IR::UnionDecl
+              aggregate_decl.fields.flat_map { |field| aggregate_type_dependencies(field.type) }.uniq
+            when IR::VariantDecl
+              own_name = aggregate_decl.linkage_name
+              aggregate_decl.arms.flat_map { |arm| arm.fields.flat_map { |field| aggregate_type_dependencies(field.type) } }
+                .uniq
+                .reject { |dep| dep == own_name }
+            else
+              []
+            end
+          end
+
+          def aggregate_type_dependencies(type)
+            case type
+            when Types::Nullable
+              if c_backend_pointer_like_type?(type.base)
+                aggregate_type_dependencies(type.base)
+              else
+                [nullable_opt_type_name(type)]
+              end
+            when Types::Task
+              [task_type_name(type)]
+            when Types::Proc
+              [proc_type_name(type)]
+            when Types::GenericInstance
+              if pointer_type?(type)
+                []
+              elsif array_type?(type)
+                aggregate_type_dependencies(array_element_type(type))
+              elsif str_buffer_type?(type)
+                [str_buffer_type_name(type)]
+              else
+                []
+              end
+            when Types::Function
+              []
+            when Types::Struct, Types::StructInstance, Types::Union, Types::Variant, Types::VariantInstance, Types::Event, Types::Subscription
+              [named_type_c_name(type)]
+            when Types::VariantArmPayload
+              [named_type_c_name(type), named_type_c_name(type.variant_type)]
+            else
+              []
+            end
+          end
+    end
+  end
+end