mt-lang 0.2.0

data/lib/milk_tea/core/semantic_analyzer/type_declaration.rb

@@ -0,0 +1,851 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class SemanticAnalyzer
+    class Checker
+      private
+
+      def build_analysis
+        Analysis.new(
+          ast: @ctx.ast,
+          module_name: @ctx.module_name,
+          module_kind: @ctx.module_kind,
+          directives: @ctx.ast.directives,
+          imports: @ctx.imports,
+          types: @ctx.types,
+          interfaces: @ctx.interfaces,
+          attributes: snapshot_attributes,
+          attribute_applications: snapshot_attribute_applications,
+          values: @ctx.top_level_values,
+          functions: @ctx.top_level_functions,
+          methods: snapshot_methods,
+          implemented_interfaces: snapshot_implemented_interfaces,
+          local_completion_frames: @local_completion_frames.dup.freeze,
+          binding_resolution: binding_resolution_snapshot,
+          callable_value_identifier_sites: @callable_value_identifier_sites.dup.freeze,
+          callable_value_member_access_sites: @callable_value_member_access_sites.dup.freeze,
+          required_unsafe_lines: @required_unsafe_lines.uniq.freeze,
+          uses_parallel_for: @uses_parallel_for,
+          resolved_expr_types: @resolved_expr_types.dup.freeze,
+          resolved_call_kinds: @resolved_call_kinds.dup.freeze,
+          const_values: @const_values.dup.freeze,
+        )
+      end
+
+      def install_builtin_types
+        INSTALLABLE_BUILTIN_TYPE_NAMES.each do |name|
+          @ctx.types[name] = case name
+                          when "str"
+                            Types::Registry.string_view
+                          when "Subscription"
+                           builtin_subscription_type
+                         when "EventError"
+                           builtin_event_error_type
+                         when "struct_handle"
+                           builtin_struct_handle_type
+                         when "field_handle"
+                           builtin_field_handle_type
+                         when "callable_handle"
+                           builtin_callable_handle_type
+                          when "attribute_handle"
+                            builtin_attribute_handle_type
+                          when "member_handle"
+                            builtin_member_handle_type
+                          when "type"
+                            builtin_type_meta_type
+                          when "vec2"
+                            Types::Vector.new("vec2", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 2)
+                          when "vec3"
+                            Types::Vector.new("vec3", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 3)
+                          when "vec4"
+                            Types::Vector.new("vec4", element_type: Types::BUILTIN_VECTOR_ELEMENT, width: 4)
+                          when "ivec2"
+                            Types::Vector.new("ivec2", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 2)
+                          when "ivec3"
+                            Types::Vector.new("ivec3", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 3)
+                          when "ivec4"
+                            Types::Vector.new("ivec4", element_type: Types::BUILTIN_IVECTOR_ELEMENT, width: 4)
+                          when "mat3"
+                            Types::Matrix.new("mat3", dim: 3)
+                          when "mat4"
+                            Types::Matrix.new("mat4", dim: 4)
+                          when "quat"
+                            Types::Quaternion.new("quat")
+                          else
+                            Types::Registry.primitive(name)
+                         end
+        end
+      end
+
+      def builtin_subscription_type
+        Types::Subscription.new
+      end
+
+      def builtin_event_error_type
+        Types::Enum.new("EventError").define_members(@ctx.types.fetch("int"), ["full"]).define_member_values("full" => 0)
+      end
+
+      def builtin_struct_handle_type
+        Types::BUILTIN_STRUCT_HANDLE_TYPE
+      end
+
+      def builtin_field_handle_type
+        Types::BUILTIN_FIELD_HANDLE_TYPE
+      end
+
+      def builtin_callable_handle_type
+        Types::BUILTIN_CALLABLE_HANDLE_TYPE
+      end
+
+      def builtin_attribute_handle_type
+        Types::BUILTIN_ATTRIBUTE_HANDLE_TYPE
+      end
+
+      def builtin_member_handle_type
+        Types::BUILTIN_MEMBER_HANDLE_TYPE
+      end
+
+      def builtin_type_meta_type
+        Types::BUILTIN_TYPE_META_TYPE
+      end
+
+      def install_builtin_attributes
+        BUILTIN_ATTRIBUTE_NAMES.each do |name|
+          @ctx.attributes[name] = MilkTea.builtin_attribute_binding(name, @ctx.types)
+        end
+      end
+
+      def snapshot_attributes
+        @ctx.attributes.each_with_object({}) do |(name, binding), attributes|
+          next if binding.builtin
+
+          attributes[name] = binding
+        end.freeze
+      end
+
+      def snapshot_attribute_applications
+        @ctx.resolved_attribute_applications.each_with_object({}) do |(target_id, applications), snapshot|
+          snapshot[target_id] = applications
+        end.freeze
+      end
+
+      def snapshot_methods
+        @ctx.methods.each_with_object({}) do |(receiver_type, bindings), methods|
+          methods[receiver_type] = bindings.dup.freeze
+        end.freeze
+      end
+
+      def snapshot_implemented_interfaces
+        @ctx.implemented_interfaces.each_with_object({}) do |(receiver_type, interfaces), snapshot|
+          snapshot[receiver_type] = interfaces.dup.freeze
+        end.freeze
+      end
+
+      def install_imports
+        @ctx.ast.imports.each do |import|
+          with_error_node(import) do
+            alias_name = import.alias_name || import.path.parts.last
+            ensure_non_reserved_import_alias_name!(alias_name, kind_label: "import alias", line: import.line, column: import.column)
+            raise_sema_error("duplicate import alias #{alias_name}") if @ctx.imports.key?(alias_name)
+
+            module_binding = @ctx.imported_modules[import.path.to_s]
+            next if @allow_missing_imports && module_binding.nil?
+            raise_sema_error("unknown import #{import.path}") unless module_binding
+
+            @ctx.imports[alias_name] = module_binding
+          end
+        end
+      end
+
+      PRELUDE_MODULE_PATHS = %w[std.option std.result].freeze
+
+      def install_prelude_types
+        PRELUDE_MODULE_PATHS.each do |module_path|
+          next if module_path == @ctx.module_name
+
+          module_binding = @ctx.imported_modules[module_path]
+          unless module_binding
+            install_fallback_builtin_type(module_path)
+            next
+          end
+
+          module_binding.types.each do |type_name, type|
+            @ctx.types[type_name] = type unless @ctx.types.key?(type_name)
+          end
+
+          already_imported = @ctx.imports.any? { |_, existing_binding| existing_binding == module_binding }
+          @ctx.imports[module_path] = module_binding unless @ctx.imports.key?(module_path) || already_imported
+        end
+      end
+
+      def install_fallback_builtin_type(module_path)
+        case module_path
+        when "std.option"
+          @ctx.types["Option"] = Types::BUILTIN_OPTION_TYPE unless @ctx.types.key?("Option")
+        when "std.result"
+          @ctx.types["Result"] = Types::BUILTIN_RESULT_TYPE unless @ctx.types.key?("Result")
+        end
+      end
+
+      def expanded_declarations
+        Enumerator.new do |yielder|
+          @ctx.ast.declarations.each do |decl|
+            case decl
+            when AST::WhenStmt
+              body = when_chosen_body(decl)
+              if body
+                body.each { |nested| yielder << nested }
+              end
+            else
+              yielder << decl
+            end
+          end
+        end
+      end
+
+      def declare_named_types
+        expanded_declarations.each do |decl|
+          with_error_node(decl) do
+            case decl
+            when AST::StructDecl
+              validate_struct_layout!(decl)
+              validate_explicit_aggregate_c_name!(decl)
+              ensure_available_type_name!(decl.name)
+              @ctx.types[decl.name] = if decl.type_params.empty?
+                                    Types::Struct.new(
+                                      decl.name,
+                                      module_name: @ctx.module_name,
+                                      external: raw_module?,
+                                      packed: decl.packed,
+                                      alignment: decl.alignment,
+                                      linkage_name: decl.c_name,
+                                      lifetime_params: decl.lifetime_params,
+                                    )
+                                  else
+                                    Types::GenericStructDefinition.new(
+                                      decl.name,
+                                      decl.type_params.map(&:name),
+                                      module_name: @ctx.module_name,
+                                      external: raw_module?,
+                                      packed: decl.packed,
+                                      alignment: decl.alignment,
+                                      linkage_name: decl.c_name,
+                                      lifetime_params: decl.lifetime_params,
+                                    )
+                                  end
+              register_nested_struct_types(decl)
+            when AST::UnionDecl
+              validate_explicit_aggregate_c_name!(decl)
+              ensure_available_type_name!(decl.name)
+              @ctx.types[decl.name] = Types::Union.new(decl.name, module_name: @ctx.module_name, external: raw_module?, linkage_name: decl.c_name)
+            when AST::VariantDecl
+              ensure_available_type_name!(decl.name)
+              @ctx.types[decl.name] = if decl.type_params.empty?
+                                    Types::Variant.new(decl.name, module_name: @ctx.module_name)
+                                  else
+                                    Types::GenericVariantDefinition.new(
+                                      decl.name,
+                                      decl.type_params.map(&:name),
+                                      module_name: @ctx.module_name,
+                                    )
+                                  end
+            when AST::EnumDecl
+              ensure_available_type_name!(decl.name)
+              @ctx.types[decl.name] = Types::Enum.new(decl.name, module_name: @ctx.module_name, external: raw_module?)
+            when AST::FlagsDecl
+              ensure_available_type_name!(decl.name)
+              @ctx.types[decl.name] = Types::Flags.new(decl.name, module_name: @ctx.module_name, external: raw_module?)
+            when AST::OpaqueDecl
+              ensure_available_type_name!(decl.name)
+              @ctx.types[decl.name] = Types::Opaque.new(
+                decl.name,
+                module_name: @ctx.module_name,
+                external: raw_module?,
+                linkage_name: decl.c_name,
+              )
+            when AST::InterfaceDecl
+              ensure_available_type_name!(decl.name)
+              @ctx.interfaces[decl.name] = declare_interface_binding(decl)
+            end
+          end
+        rescue SemanticError => e
+          collect_structural_error(e)
+        end
+      end
+
+      def resolve_generic_type_param_constraints
+        expanded_declarations.each do |decl|
+          with_error_node(decl) do
+            next unless decl.is_a?(AST::StructDecl) || decl.is_a?(AST::VariantDecl) || decl.is_a?(AST::InterfaceDecl)
+            next if decl.type_params.empty?
+
+            constraints = resolve_type_param_constraints(decl.type_params)
+            if decl.is_a?(AST::InterfaceDecl)
+              @ctx.interfaces[decl.name] = @ctx.interfaces.fetch(decl.name).with(type_param_constraints: constraints)
+            else
+              @ctx.types.fetch(decl.name).define_type_param_constraints(constraints)
+            end
+          end
+        end
+      end
+
+      def resolve_type_aliases
+        @ctx.ast.declarations.grep(AST::TypeAliasDecl).each do |decl|
+          ensure_available_type_name!(decl.name)
+          @ctx.types[decl.name] = resolve_type_ref(decl.target)
+        rescue SemanticError => e
+          collect_structural_error(e)
+        end
+      end
+
+      def declare_attributes
+        expanded_declarations.grep(AST::AttributeDecl).each do |decl|
+          with_error_node(decl) do
+            raise_sema_error("duplicate attribute #{decl.name}") if @ctx.attributes.key?(decl.name)
+
+            params = []
+            seen = {}
+            decl.params.each do |param|
+              raise_sema_error("duplicate attribute parameter #{decl.name}.#{param.name}") if seen.key?(param.name)
+
+              seen[param.name] = true
+              params << Types::Registry.parameter(param.name, resolve_type_ref(param.type))
+            end
+
+            @ctx.attributes[decl.name] = AttributeBinding.new(
+              name: decl.name,
+              targets: decl.targets.freeze,
+              params: params.freeze,
+              module_name: @ctx.module_name,
+              builtin: false,
+              ast: decl,
+            )
+          end
+        end
+      end
+
+      def declare_interface_binding(decl)
+        if decl.type_params.any?
+          type_param_names = decl.type_params.map(&:name)
+          type_params_map = type_param_names.map { |n| [n, Types::TypeVar.new(n)] }.to_h
+          methods = {}
+
+          decl.methods.each do |method_decl|
+            method = resolve_interface_method_binding(method_decl, type_params: type_params_map, type_param_constraints: {})
+            raise_sema_error("duplicate method #{decl.name}.#{method.name}") if methods.key?(method.name)
+
+            methods[method.name] = method
+          end
+
+          GenericInterfaceBinding.new(
+            name: decl.name,
+            type_params: type_param_names.freeze,
+            type_param_constraints: {},
+            methods: methods.freeze,
+            ast: decl,
+            module_name: @ctx.module_name,
+          )
+        else
+          methods = {}
+
+          decl.methods.each do |method_decl|
+            method = resolve_interface_method_binding(method_decl)
+            raise_sema_error("duplicate method #{decl.name}.#{method.name}") if methods.key?(method.name)
+
+            methods[method.name] = method
+          end
+
+          InterfaceBinding.new(
+            name: decl.name,
+            methods: methods.freeze,
+            ast: decl,
+            module_name: @ctx.module_name,
+          )
+        end
+      end
+
+      def resolve_interface_method_binding(method_decl, type_params: {}, type_param_constraints: {})
+        raise_sema_error("interface method #{method_decl.name} cannot be async") if method_decl.async
+
+        params = []
+        seen = {}
+        method_decl.params.each do |param|
+          raise_sema_error("duplicate parameter #{param.name} in #{method_decl.name}") if seen.key?(param.name)
+
+          seen[param.name] = true
+          type = resolve_type_ref(param.type, type_params:, type_param_constraints:)
+          validate_parameter_ref_type!(type, function_name: method_decl.name, parameter_name: param.name, external: false)
+          validate_parameter_proc_type!(type, function_name: method_decl.name, parameter_name: param.name, external: false, foreign: false)
+          params << Types::Registry.parameter(param.name, type)
+        end
+
+        return_type = method_decl.return_type ? resolve_type_ref(method_decl.return_type, type_params:, type_param_constraints:) : @ctx.types.fetch("void")
+        validate_return_ref_type!(return_type, function_name: method_decl.name)
+        validate_return_proc_type!(return_type, function_name: method_decl.name)
+
+        InterfaceMethodBinding.new(
+          name: method_decl.name,
+          params: params.freeze,
+          return_type: return_type,
+          kind: method_decl.kind,
+          async: method_decl.async,
+          ast: method_decl,
+        )
+      end
+
+      def validate_struct_layout!(decl)
+        return unless decl.alignment
+
+        raise_sema_error("align(...) requires a positive alignment") unless decl.alignment.positive?
+        return if power_of_two?(decl.alignment)
+
+        raise_sema_error("align(...) requires a power-of-two alignment, got #{decl.alignment}")
+      end
+
+      def validate_explicit_aggregate_c_name!(decl)
+        return unless decl.c_name
+
+        raise_sema_error("explicit C names are only allowed on external structs and unions") unless raw_module?
+        return if !decl.respond_to?(:type_params) || decl.type_params.empty?
+
+        raise_sema_error("explicit C names are not supported on generic external structs")
+      end
+
+      def resolve_event_decl_type(decl, type_params: {}, type_param_constraints: {}, owner_type_name: nil, nested_types: nil)
+        raise_sema_error("event #{decl.name} capacity must be positive") unless decl.capacity.is_a?(Integer) && decl.capacity.positive?
+
+        payload_type = decl.payload_type ? resolve_type_ref(decl.payload_type, type_params:, type_param_constraints:, nested_types:) : nil
+        if payload_type
+          raise_sema_error("event #{decl.name} payload cannot be ref[T] in v1") if ref_type?(payload_type)
+          validate_stored_ref_type!(payload_type, "event #{decl.name} payload")
+          raise_sema_error("event #{decl.name} payload uses unsupported proc nesting") unless proc_storage_supported_type?(payload_type)
+          raise_sema_error("event #{decl.name} payload cannot use event storage type #{payload_type}") if noncopyable_event_storage_type?(payload_type)
+        end
+
+        Types::Event.new(
+          decl.name,
+          capacity: decl.capacity,
+          payload_type: payload_type,
+          module_name: @ctx.module_name,
+          visibility: decl.visibility,
+          owner_type_name: owner_type_name,
+        )
+      end
+
+      def resolve_aggregate_fields
+        expanded_declarations.each do |decl|
+          with_error_node(decl) do
+            next unless decl.is_a?(AST::StructDecl) || decl.is_a?(AST::UnionDecl)
+
+            struct_type = @ctx.types.fetch(decl.name)
+            struct_type.ast_declaration = decl if struct_type.respond_to?(:ast_declaration=)
+            type_params = if struct_type.is_a?(Types::GenericStructDefinition)
+                             seen = {}
+                             struct_type.type_params.each_with_object({}) do |name, params|
+                               raise_sema_error("duplicate type parameter #{decl.name}[#{name}]") if seen.key?(name)
+
+                               seen[name] = true
+                               params[name] = Types::TypeVar.new(name)
+                             end
+                           else
+                             {}
+                           end
+            decl.lifetime_params.each do |lt|
+              type_params[lt] = Types::LifetimeRef.new(lt)
+            end if decl.respond_to?(:lifetime_params)
+            type_param_constraints = struct_type.is_a?(Types::GenericStructDefinition) ? struct_type.type_param_constraints : {}
+            fields = {}
+            events = {}
+            field_errors = []
+
+            auto_lifetimes = []
+
+            nested_scope = decl.is_a?(AST::StructDecl) ? resolve_nested_type_bindings(decl) : {}
+            if decl.is_a?(AST::StructDecl) && struct_type.respond_to?(:define_nested_types)
+              struct_type.define_nested_types(nested_scope)
+              define_nested_type_bindings_recursive(decl, parent_name: decl.name)
+            end
+
+            decl.fields.each do |field|
+              raise_sema_error("duplicate field #{decl.name}.#{field.name}") if fields.key?(field.name)
+              raise_sema_error("duplicate member #{decl.name}.#{field.name}") if events.key?(field.name)
+              unless raw_module?
+                ensure_non_reserved_type_binding_name!(
+                  field.name,
+                  kind_label: "field #{decl.name}",
+                  line: field.respond_to?(:line) ? field.line : decl.line,
+                  column: field.respond_to?(:column) ? field.column : nil,
+                )
+              end
+
+              begin
+                field_type = resolve_type_ref(field.type, type_params:, type_param_constraints:, nested_types: nested_scope)
+
+                # Auto-generate implicit lifetimes for bare ref[T] in struct fields
+                if ref_type_without_lifetime?(field_type)
+                  auto_lt_name = "@_mt_#{auto_lifetimes.length}"
+                  auto_lifetimes << auto_lt_name
+                  type_params[auto_lt_name] = Types::LifetimeRef.new(auto_lt_name)
+                  field_type = Types::Registry.generic_instance("ref", [auto_lt_name] + field_type.arguments)
+                end
+                if decl.respond_to?(:lifetime_params) && (lt = ref_lifetime(field_type))
+                  unless decl.lifetime_params.include?(lt) || auto_lifetimes.include?(lt)
+                    raise_sema_error("field #{decl.name}.#{field.name} uses lifetime #{lt} not declared on struct")
+                  end
+                end
+                allow_lts = decl.respond_to?(:lifetime_params) ? (decl.lifetime_params + auto_lifetimes) : []
+                validate_stored_ref_type!(field_type, "field #{decl.name}.#{field.name}", allow_lifetimes: allow_lts)
+                unless proc_storage_supported_type?(field_type)
+                  raise_sema_error("field #{decl.name}.#{field.name} uses unsupported proc nesting")
+                end
+                fields[field.name] = field_type
+              rescue SemanticError => e
+                fields[field.name] = @error_type
+                field_errors << e
+                @structural_errors << e if @structural_errors
+              end
+            end
+
+            unless field_errors.empty?
+              struct_type.define_fields(fields)
+              raise field_errors.first
+            end
+
+            if decl.is_a?(AST::StructDecl)
+              decl.events.each do |event_decl|
+                raise_sema_error("duplicate event #{decl.name}.#{event_decl.name}") if events.key?(event_decl.name)
+                raise_sema_error("duplicate member #{decl.name}.#{event_decl.name}") if fields.key?(event_decl.name)
+                unless raw_module?
+                  ensure_non_reserved_type_binding_name!(
+                    event_decl.name,
+                    kind_label: "event #{decl.name}",
+                    line: event_decl.line,
+                    column: event_decl.column,
+                  )
+                end
+
+                begin
+                  events[event_decl.name] = resolve_event_decl_type(
+                    event_decl,
+                    type_params:,
+                    type_param_constraints:,
+                    owner_type_name: decl.name,
+                    nested_types: nested_scope,
+                  )
+                rescue SemanticError => e
+                  collect_structural_error(e)
+                end
+              end
+            end
+
+            if decl.is_a?(AST::StructDecl)
+              resolve_nested_struct_fields(decl, type_params:, type_param_constraints:, external_nested_scope: nested_scope)
+            end
+            struct_type.define_fields(fields)
+            struct_type.define_events(events) if struct_type.respond_to?(:define_events)
+          end
+        rescue SemanticError => e
+          collect_structural_error(e)
+        end
+      end
+
+      def resolve_enum_members
+        expanded_declarations.each do |decl|
+          with_error_node(decl) do
+            next unless decl.is_a?(AST::EnumDecl) || decl.is_a?(AST::FlagsDecl)
+
+            enum_type = @ctx.types.fetch(decl.name)
+            backing_type = resolve_type_ref(decl.backing_type)
+            unless backing_type.is_a?(Types::Primitive) && backing_type.integer?
+              raise_sema_error("#{decl.name} backing type must be an integer primitive, got #{backing_type}")
+            end
+
+            member_names = []
+            decl.members.each do |member|
+              raise_sema_error("duplicate member #{decl.name}.#{member.name}") if member_names.include?(member.name)
+              unless raw_module?
+                ensure_non_reserved_type_binding_name!(
+                  member.name,
+                  kind_label: "member #{decl.name}",
+                  line: member.respond_to?(:line) ? member.line : decl.line,
+                  column: member.respond_to?(:column) ? member.column : nil,
+                )
+              end
+
+              member_names << member.name
+            end
+
+            enum_type.define_members(backing_type, member_names)
+
+            member_values = {}
+
+            decl.members.each do |member|
+              begin
+                actual_type = infer_expression(member.value, scopes: [], expected_type: backing_type)
+                const_value = evaluate_enum_member_const_value(member.value, enum_type:, member_values:)
+
+                compatible = types_compatible?(actual_type, backing_type, expression: member.value, scopes: [])
+                compatible ||= actual_type.is_a?(Types::EnumBase) && types_compatible?(actual_type.backing_type, backing_type, expression: member.value, scopes: [])
+                compatible ||= const_value.is_a?(Integer) && numeric_constant_fits_type?(const_value, backing_type)
+                raise_sema_error("member #{decl.name}.#{member.name} expects #{backing_type}, got #{actual_type}", member) unless compatible
+
+                raise_sema_error("member #{decl.name}.#{member.name} must be a compile-time integer constant", member) unless const_value.is_a?(Integer)
+
+                member_values[member.name] = const_value
+              rescue SemanticError => e
+                collect_structural_error(e)
+              end
+            end
+
+            enum_type.define_member_values(member_values)
+          end
+        rescue SemanticError => e
+          collect_structural_error(e)
+        end
+      end
+
+      def resolve_variant_arms
+        expanded_declarations.each do |decl|
+          with_error_node(decl) do
+            next unless decl.is_a?(AST::VariantDecl)
+
+            variant_type = @ctx.types.fetch(decl.name)
+            type_params = if variant_type.is_a?(Types::GenericVariantDefinition)
+                            seen = {}
+                            variant_type.type_params.each_with_object({}) do |name, params|
+                              raise_sema_error("duplicate type parameter #{decl.name}[#{name}]") if seen.key?(name)
+
+                              seen[name] = true
+                              params[name] = Types::TypeVar.new(name)
+                            end
+                          else
+                            {}
+                          end
+            type_param_constraints = variant_type.is_a?(Types::GenericVariantDefinition) ? variant_type.type_param_constraints : {}
+            seen_arms = []
+            arms_hash = {}
+            decl.arms.each do |arm|
+              begin
+                raise_sema_error("duplicate arm #{decl.name}.#{arm.name}") if seen_arms.include?(arm.name)
+                unless raw_module?
+                  ensure_non_reserved_type_binding_name!(
+                    arm.name,
+                    kind_label: "arm #{decl.name}",
+                    line: arm.respond_to?(:line) ? arm.line : decl.line,
+                    column: arm.respond_to?(:column) ? arm.column : nil,
+                  )
+                end
+
+                seen_arms << arm.name
+                field_types = {}
+                seen_fields = []
+                arm_field_errors = []
+                arm.fields.each do |field|
+                  begin
+                    raise_sema_error("duplicate field #{arm.name}.#{field.name}") if seen_fields.include?(field.name)
+                    unless raw_module?
+                      ensure_non_reserved_type_binding_name!(
+                        field.name,
+                        kind_label: "field #{decl.name}.#{arm.name}",
+                        line: field.respond_to?(:line) ? field.line : decl.line,
+                        column: field.respond_to?(:column) ? field.column : nil,
+                      )
+                    end
+
+                    seen_fields << field.name
+                    field_type = resolve_type_ref(field.type, type_params:, type_param_constraints:)
+                    validate_stored_ref_type!(field_type, "field #{decl.name}.#{arm.name}.#{field.name}")
+                    unless proc_storage_supported_type?(field_type)
+                      raise_sema_error("field #{decl.name}.#{arm.name}.#{field.name} uses unsupported proc nesting")
+                    end
+                    field_types[field.name] = field_type
+                  rescue SemanticError => e
+                    field_types[field.name] = @error_type
+                    arm_field_errors << e
+                    @structural_errors << e if @structural_errors
+                  end
+                end
+
+                raise arm_field_errors.first unless arm_field_errors.empty?
+                arms_hash[arm.name] = field_types
+              rescue SemanticError => e
+                collect_structural_error(e)
+              end
+            end
+
+            variant_type.define_arms(arms_hash)
+          end
+        rescue SemanticError => e
+          collect_structural_error(e)
+        end
+      end
+
+      PRELUDE_TYPE_DEFINING_MODULES = {
+        "Option" => "std.option",
+        "Result" => "std.result",
+      }.freeze
+
+      def ensure_available_type_name!(name, line: nil, column: nil, length: nil)
+        unless raw_module? || (PRELUDE_TYPE_DEFINING_MODULES[name] == @ctx.module_name)
+          ensure_non_reserved_type_binding_name!(name, kind_label: "type", line:, column:, length:)
+        end
+        raise_sema_error("duplicate type #{name}") if @ctx.types.key?(name) || @ctx.interfaces.key?(name)
+      end
+
+      def ensure_available_value_name!(name, kind_label: "value", line: nil, column: nil, length: nil)
+        ensure_non_reserved_value_type_name!(name, kind_label:, line:, column:, length:)
+        raise_sema_error("duplicate value #{name}") if @ctx.top_level_values.key?(name) || @ctx.top_level_functions.key?(name)
+      end
+
+      def ensure_non_reserved_name!(name, reserved_names, kind_label:, line: nil, column: nil, length: nil)
+        return unless reserved_names.include?(name)
+
+        raise_sema_error("#{kind_label} #{name} uses reserved built-in type name #{name}", line:, column:, length:)
+      end
+
+      def ensure_non_reserved_value_type_name!(name, kind_label:, line: nil, column: nil, length: nil)
+        ensure_non_reserved_name!(name, Types::RESERVED_VALUE_TYPE_NAMES, kind_label:, line:, column:, length:)
+      end
+
+      def ensure_non_reserved_import_alias_name!(name, kind_label:, line: nil, column: nil, length: nil)
+        ensure_non_reserved_name!(name, Types::RESERVED_IMPORT_ALIAS_NAMES, kind_label:, line:, column:, length:)
+      end
+
+      def ensure_non_reserved_type_binding_name!(name, kind_label:, line: nil, column: nil, length: nil)
+        ensure_non_reserved_name!(name, Types::RESERVED_TYPE_BINDING_NAMES, kind_label:, line:, column:, length:)
+      end
+
+      def declare_top_level_values
+        expanded_declarations.each do |decl|
+          with_error_node(decl) do
+            case decl
+            when AST::ConstDecl
+              begin
+                ensure_available_value_name!(decl.name, kind_label: "constant", line: decl.line, column: decl.respond_to?(:column) ? decl.column : nil)
+                type = resolve_type_ref(decl.type)
+                validate_stored_ref_type!(type, "constant #{decl.name}")
+                raise_sema_error("constant #{decl.name} cannot store proc values") if contains_proc_type?(type)
+                @ctx.top_level_values[decl.name] = value_binding(
+                  name: decl.name,
+                  type: type,
+                  mutable: false,
+                  kind: :const,
+                )
+              rescue SemanticError => e
+                collect_structural_error(e)
+                @ctx.top_level_values[decl.name] = value_binding(
+                  name: decl.name,
+                  type: @error_type,
+                  mutable: false,
+                  kind: :const,
+                ) unless @ctx.top_level_values.key?(decl.name)
+              end
+            when AST::VarDecl
+              ensure_available_value_name!(decl.name, kind_label: "module variable", line: decl.line, column: decl.respond_to?(:column) ? decl.column : nil)
+              raise_sema_error("module variable #{decl.name} requires an explicit type") unless decl.type
+
+              type = resolve_type_ref(decl.type)
+              validate_stored_ref_type!(type, "module variable #{decl.name}")
+              @ctx.top_level_values[decl.name] = value_binding(
+                name: decl.name,
+                type: type,
+                mutable: true,
+                kind: :var,
+              )
+            when AST::EventDecl
+              ensure_available_value_name!(decl.name, kind_label: "event", line: decl.line, column: decl.column)
+              @ctx.top_level_values[decl.name] = value_binding(
+                name: decl.name,
+                type: resolve_event_decl_type(decl),
+                mutable: false,
+                kind: :event,
+              )
+            end
+          end
+        rescue SemanticError => e
+          collect_structural_error(e)
+        end
+      end
+
+      def ensure_non_reserved_primitive_name!(name, kind_label:, line: nil, column: nil, length: nil)
+        ensure_non_reserved_value_type_name!(name, kind_label:, line:, column:, length:)
+      end
+
+
+      def define_nested_type_bindings_recursive(parent_decl, parent_name: parent_decl.name)
+        parent_decl.nested_types.each do |nested|
+          qualified_name = "#{parent_name}.#{nested.name}"
+          nested_type = @ctx.types[qualified_name]
+          next unless nested_type.is_a?(Types::Struct)
+          nested_scope = resolve_nested_type_bindings(nested, parent_name: qualified_name)
+          nested_type.define_nested_types(nested_scope)
+          define_nested_type_bindings_recursive(nested, parent_name: qualified_name)
+        end
+      end
+
+      def resolve_nested_struct_fields(parent_decl, parent_name: parent_decl.name, type_params:, type_param_constraints:, external_nested_scope: {})
+        parent_decl.nested_types.each do |nested|
+          next unless nested.type_params.empty?
+          qualified_name = "#{parent_name}.#{nested.name}"
+          nested_type = @ctx.types[qualified_name]
+          next unless nested_type.is_a?(Types::Struct)
+          nested_type.ast_declaration = nested
+          nested_scope = nested_type.nested_types.merge(external_nested_scope)
+          fields = {}
+          nested.fields.each do |field|
+            raise_sema_error("duplicate field #{qualified_name}.#{field.name}") if fields.key?(field.name)
+            begin
+              field_type = resolve_type_ref(field.type, type_params:, type_param_constraints:, nested_types: nested_scope)
+              validate_stored_ref_type!(field_type, "field #{qualified_name}.#{field.name}")
+              fields[field.name] = field_type
+            rescue SemanticError => e
+              fields[field.name] = @error_type
+              @structural_errors << e if @structural_errors
+            end
+          end
+          nested_type.define_fields(fields)
+          nested_events = {}
+          nested.events.each do |event_decl|
+            raise_sema_error("duplicate event #{qualified_name}.#{event_decl.name}") if nested_events.key?(event_decl.name)
+            begin
+              nested_events[event_decl.name] = resolve_event_decl_type(event_decl, type_params:, type_param_constraints:, owner_type_name: qualified_name, nested_types: nested_scope)
+            rescue SemanticError => e
+              collect_structural_error(e)
+            end
+          end
+          nested_type.define_events(nested_events)
+          resolve_nested_struct_fields(nested, parent_name: qualified_name, type_params:, type_param_constraints:, external_nested_scope: nested_scope)
+        end
+      end
+
+      def resolve_nested_type_bindings(parent_decl, parent_name: parent_decl.name)
+        bindings = {}
+        parent_decl.nested_types.each do |nested|
+          qualified_name = "#{parent_name}.#{nested.name}"
+          nested_type = @ctx.types[qualified_name]
+          bindings[nested.name] = nested_type if nested_type
+        end
+        bindings
+      end
+
+      def register_nested_struct_types(parent_decl, parent_name: parent_decl.name)
+        parent_decl.nested_types.each do |nested|
+          qualified_name = "#{parent_name}.#{nested.name}"
+          ensure_available_type_name!(qualified_name)
+          nested_c_name = if @ctx.module_name && !raw_module?
+                            "#{@ctx.module_name.to_s.tr('.', '_')}_#{qualified_name.tr('.', '_')}"
+                          else
+                            qualified_name.tr('.', '_')
+                          end
+          if nested.type_params.empty?
+            @ctx.types[qualified_name] = Types::Struct.new(nested.name, module_name: @ctx.module_name, external: raw_module?, packed: nested.packed, alignment: nested.alignment, linkage_name: nested_c_name, lifetime_params: nested.lifetime_params)
+          else
+            @ctx.types[qualified_name] = Types::GenericStructDefinition.new(nested.name, nested.type_params.map(&:name), module_name: @ctx.module_name, external: raw_module?, packed: nested.packed, alignment: nested.alignment, linkage_name: nested_c_name, lifetime_params: nested.lifetime_params)
+          end
+          register_nested_struct_types(nested, parent_name: qualified_name)
+        end
+      end
+    end
+  end
+end
+