mt-lang 0.3.9 → 0.3.10

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def check_top_level_values
         expanded_declarations.each do |decl|
           with_error_node(decl) do
@@ -477,16 +475,16 @@ module MilkTea
         func.ast.params.each_with_index do |param, idx|
           arg_expr = arguments[idx].value
           arg_value = if scopes
-                        evaluate_compile_time_const_value(arg_expr, scopes:)
-                      else
-                        CompileTime.evaluate(
-                          arg_expr,
-                          resolve_identifier: lambda { |id| resolve_current_module_const_value(id.name) },
-                          resolve_member_access: nil,
-                          resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
-                          resolve_call: nil,
-                        )
-                      end
+            evaluate_compile_time_const_value(arg_expr, scopes:)
+          else
+            CompileTime.evaluate(
+              arg_expr,
+              resolve_identifier: lambda { |id| resolve_current_module_const_value(id.name) },
+              resolve_member_access: nil,
+              resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
+              resolve_call: nil,
+            )
+          end
           return nil unless arg_value
 
           initial_vars[param.name] = arg_value

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def call_argument_compatible?(actual_type, expected_type, scopes:, external:, expression: nil)
         return true if array_to_span_call_argument_compatible?(actual_type, expected_type, expression:, scopes:)
         return true if argument_types_compatible?(actual_type, expected_type, external:, expression:, scopes:, contextual_int_to_float: !external)
@@ -223,8 +221,6 @@ module MilkTea
         nil
       end
 
-    private
-
       def simd_op_result(operator, left_type, right_type)
         if simd_type?(left_type) && simd_type?(right_type) && left_type.element_type == right_type.element_type && left_type.lane_count == right_type.lane_count
           return left_type if operator == "+" || operator == "-" || operator == "*" || operator == "/"
@@ -337,8 +333,6 @@ module MilkTea
       def function_pointer_type?(type)
         type.is_a?(Types::Function)
       end
-
-
     end
   end
 end

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

@@ -3,8 +3,6 @@
 module MilkTea
   class SemanticAnalyzer
     class Checker
-      private
-
       def build_analysis
         Analysis.new(
           ast: @ctx.ast,
@@ -35,45 +33,45 @@ module MilkTea
       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
+          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
 
@@ -226,27 +224,27 @@ module MilkTea
               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
+                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)
@@ -255,14 +253,14 @@ module MilkTea
             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
+                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?)
@@ -454,16 +452,16 @@ module MilkTea
             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
+              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)
@@ -487,8 +485,8 @@ module MilkTea
                 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,
+                  line: field.line || decl.line,
+                  column: field.column,
                 )
               end
 
@@ -581,8 +579,8 @@ module MilkTea
                 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,
+                  line: member.line || decl.line,
+                  column: member.column,
                 )
               end
 
@@ -630,16 +628,16 @@ module MilkTea
 
             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
+              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 = {}
@@ -650,8 +648,8 @@ module MilkTea
                   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,
+                    line: arm.line || decl.line,
+                    column: arm.column,
                   )
                 end
 
@@ -666,8 +664,8 @@ module MilkTea
                       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,
+                        line: field.line || decl.line,
+                        column: field.column,
                       )
                     end
 
@@ -740,7 +738,7 @@ module MilkTea
             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)
+                ensure_available_value_name!(decl.name, kind_label: "constant", line: decl.line, column: decl.column)
                 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)
@@ -760,7 +758,7 @@ module MilkTea
                 ) 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)
+              ensure_available_value_name!(decl.name, kind_label: "module variable", line: decl.line, column: decl.column)
               raise_sema_error("module variable #{decl.name} requires an explicit type") unless decl.type
 
               type = resolve_type_ref(decl.type)
@@ -852,10 +850,10 @@ module MilkTea
           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
+            "#{@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
@@ -867,4 +865,3 @@ module MilkTea
     end
   end
 end
-

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -184,7 +184,7 @@ module MilkTea
         @return_context_stack = []
       end
 
-      STRUCTURAL_PHASES = %i[
+      def check
         install_builtin_types
         install_builtin_attributes
         install_imports
@@ -201,10 +201,6 @@ module MilkTea
         check_attribute_applications
         declare_functions
         check_interface_conformances
-      ].freeze
-
-      def check
-        STRUCTURAL_PHASES.each { |phase| send(phase) }
         check_top_level_values
         finalize_top_level_const_values
         check_top_level_static_asserts
@@ -279,7 +275,22 @@ module MilkTea
         @collecting_errors = true
         @structural_errors = []
 
-        STRUCTURAL_PHASES.each { |phase| catch_structural { send(phase) } }
+        catch_structural { install_builtin_types }
+        catch_structural { install_builtin_attributes }
+        catch_structural { install_imports }
+        catch_structural { install_prelude_types }
+        catch_structural { declare_named_types }
+        catch_structural { resolve_generic_type_param_constraints }
+        catch_structural { resolve_type_aliases }
+        catch_structural { declare_attributes }
+        catch_structural { resolve_aggregate_fields }
+        catch_structural { resolve_enum_members }
+        catch_structural { resolve_variant_arms }
+        catch_structural { collect_emit_declarations }
+        catch_structural { declare_top_level_values }
+        catch_structural { check_attribute_applications }
+        catch_structural { declare_functions }
+        catch_structural { check_interface_conformances }
 
         errors = @structural_errors.dup
 
@@ -320,8 +331,6 @@ module MilkTea
 
         @structural_errors << error
       end
-
-
     end
   end
 end

data/lib/milk_tea/core/types/layout.rb

@@ -5,19 +5,18 @@ require_relative "types"
 
 module MilkTea
   module Layout
-    module_function
 
     POINTER_SIZE = Fiddle::SIZEOF_VOIDP
 
-    def size_of(type)
+    def self.size_of(type)
       size_and_alignment(type, {})&.first
     end
 
-    def alignment_of(type)
+    def self.alignment_of(type)
       size_and_alignment(type, {})&.last
     end
 
-    def offset_of(type, field_name)
+    def self.offset_of(type, field_name)
       case type
       when Types::Struct, Types::StructInstance, Types::Span, Types::StringView, Types::Task
         fields = ordered_fields(type)
@@ -38,7 +37,7 @@ module MilkTea
       end
     end
 
-    def size_and_alignment(type, stack)
+    def self.size_and_alignment(type, stack)
       case type
       when Types::Primitive
         primitive_layout(type)
@@ -82,7 +81,7 @@ module MilkTea
       end
     end
 
-    def primitive_layout(type)
+    def self.primitive_layout(type)
       case type.name
       when "bool", "byte", "ubyte", "char"
         [1, 1]
@@ -99,7 +98,7 @@ module MilkTea
       end
     end
 
-    def generic_layout(type, stack)
+    def self.generic_layout(type, stack)
       case type.name
       when "ptr", "const_ptr", "own", "ref"
         [POINTER_SIZE, POINTER_SIZE]
@@ -120,7 +119,7 @@ module MilkTea
       end
     end
 
-    def variant_layout(type, stack:)
+    def self.variant_layout(type, stack:)
       payload_layouts = type.arm_names.filter_map do |arm_name|
         fields = type.arm(arm_name)
         next if fields.nil? || fields.empty?
@@ -134,7 +133,7 @@ module MilkTea
       struct_layout_from_infos(field_infos, packed: false, alignment: nil)
     end
 
-    def struct_layout(fields, packed:, alignment:, stack:)
+    def self.struct_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |field_name, field_type|
         field_layout = size_and_alignment(field_type, stack)
         return nil unless field_layout
@@ -145,7 +144,7 @@ module MilkTea
       struct_layout_from_infos(field_infos, packed:, alignment:)
     end
 
-    def union_layout(fields, packed:, alignment:, stack:)
+    def self.union_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |_field_name, field_type|
         field_layout = size_and_alignment(field_type, stack)
         return nil unless field_layout
@@ -156,7 +155,7 @@ module MilkTea
       union_layout_from_layouts(field_infos.map { |size, field_alignment| { size:, alignment: field_alignment } }, packed:, alignment:)
     end
 
-    def struct_layout_from_infos(field_infos, packed:, alignment:)
+    def self.struct_layout_from_infos(field_infos, packed:, alignment:)
       offsets = {}
       offset = 0
       natural_alignment = 1
@@ -177,7 +176,7 @@ module MilkTea
       }
     end
 
-    def union_layout_from_layouts(layouts, packed:, alignment:)
+    def self.union_layout_from_layouts(layouts, packed:, alignment:)
       natural_alignment = packed ? 1 : (layouts.map { |layout| layout[:alignment] }.max || 1)
       overall_alignment = [natural_alignment, alignment || 1].max
       size = layouts.map { |layout| layout[:size] }.max || 0
@@ -188,27 +187,27 @@ module MilkTea
       }
     end
 
-    def ordered_fields(type)
+    def self.ordered_fields(type)
       type.fields
     end
 
-    def packed_layout?(type)
+    def self.packed_layout?(type)
       type.respond_to?(:packed) && type.packed
     end
 
-    def explicit_alignment(type)
+    def self.explicit_alignment(type)
       type.respond_to?(:alignment) ? type.alignment : nil
     end
 
-    def array_type?(type)
+    def self.array_type?(type)
       type.arguments.length == 2 && type.arguments[1].is_a?(Types::LiteralTypeArg) && type.arguments[1].value.is_a?(Integer)
     end
 
-    def str_buffer_type?(type)
+    def self.str_buffer_type?(type)
       type.arguments.length == 1 && type.arguments.first.is_a?(Types::LiteralTypeArg) && type.arguments.first.value.is_a?(Integer)
     end
 
-    def str_buffer_fields(type)
+    def self.str_buffer_fields(type)
       storage_capacity = type.arguments.first.value + 1
       {
         "data" => Types::Registry.generic_instance("array", [Types::Registry.primitive("char"), Types::LiteralTypeArg.new(storage_capacity)]),
@@ -217,28 +216,28 @@ module MilkTea
       }
     end
 
-    def layout_pointer_like_nullable_base?(base)
+    def self.layout_pointer_like_nullable_base?(base)
       return true if base.is_a?(Types::Function) || base.is_a?(Types::Proc) || base.is_a?(Types::Opaque)
       return true if base.is_a?(Types::Primitive) && base.name == "cstr"
 
       base.is_a?(Types::GenericInstance) && %w[ptr const_ptr own ref].include?(base.name)
     end
 
-    def nullable_opt_layout_fields(base)
+    def self.nullable_opt_layout_fields(base)
       {
         "has_value" => Types::Registry.primitive("bool"),
         "value" => base,
       }
     end
 
-    def align_up(value, alignment)
+    def self.align_up(value, alignment)
       return value if alignment <= 1
 
       remainder = value % alignment
       remainder.zero? ? value : value + alignment - remainder
     end
 
-    def with_stack(type, stack)
+    def self.with_stack(type, stack)
       return if stack[type]
 
       stack[type] = true

data/lib/milk_tea/core/types/predicates.rb

@@ -615,8 +615,6 @@ module MilkTea
         end
       end
 
-      private
-
       def char_array_text_type?(type)
         return false unless array_type?(type)