mt-lang 0.3.30 → 0.3.32

data/lib/milk_tea/core/c_backend.rb

@@ -236,17 +236,45 @@ module MilkTea
         lines << ""
       end
 
+      if uses_variant_equality_helper? || uses_struct_equality_helper?
+        lines.concat(emit_aggregate_equality_forward_declarations)
+        lines << ""
+      end
       if uses_variant_equality_helper?
         unless uses_str_equality_helper?
-          variant_needs_str_eq = emitted_aggregate_variants.any? { |v| v.arms.any? { |a| a.fields.any? { |f| f.type.is_a?(Types::StringView) } } }
-          if variant_needs_str_eq
-            lines.concat(emit_string_type) unless uses_string_view?
-            lines.concat(emit_str_equality_helper)
-          end
+          emit_str_equality_support(lines) if aggregate_equality_needs_string_view?
         end
         lines.concat(emit_variant_equality_helpers)
         lines << ""
       end
+      if uses_struct_equality_helper?
+        unless uses_str_equality_helper?
+          emit_str_equality_support(lines) if aggregate_equality_needs_string_view?
+        end
+        lines.concat(emit_struct_equality_helpers)
+        lines << ""
+      end
+    end
+
+    def emit_aggregate_equality_forward_declarations
+      lines = []
+      struct_equality_types.each do |type|
+        c = named_type_c_name(type)
+        lines << "static bool mt_struct_eq_#{c}(struct #{c} left, struct #{c} right);"
+      end
+      variant_equality_types.each do |type|
+        c = named_type_c_name(type)
+        lines << "static bool mt_variant_eq_#{c}(struct #{c} left, struct #{c} right);"
+      end
+      lines
+    end
+
+    def emit_str_equality_support(lines)
+      return if @emitted_aggregate_str_equality_support
+
+      @emitted_aggregate_str_equality_support = true
+      lines.concat(emit_string_type) unless uses_string_view?
+      lines.concat(emit_str_equality_helper)
     end
 
     def emit_function_forward_declarations(lines)

data/lib/milk_tea/core/compile_time.rb

@@ -31,10 +31,35 @@ module MilkTea
       return left == right if left.is_a?(String) && right.is_a?(String)
       return left == right if boolean_value?(left) && boolean_value?(right)
       return left == right if left.is_a?(Types::Base) && right.is_a?(Types::Base)
+      return struct_equality_result(left, right) if left.is_a?(Hash) && right.is_a?(Hash)
+      return variant_equality_result(left, right) if left.is_a?(VariantValue) && right.is_a?(VariantValue)
 
       nil
     end
 
+    # Const-time struct values are represented as {field_name => value} hashes;
+    # compare them field by field, mirroring the runtime struct == semantics.
+    def self.struct_equality_result(left, right)
+      return nil unless left.is_a?(Hash) && right.is_a?(Hash)
+      return nil unless left.keys.sort == right.keys.sort
+
+      left.each do |name, value|
+        field_result = equality_result(value, right[name])
+        return nil if field_result.nil?
+        return false if field_result == false
+      end
+      true
+    end
+
+    # Const-time variant values; fields mirror the runtime arm payload layout.
+    VariantValue = Data.define(:arm, :fields)
+
+    def self.variant_equality_result(left, right)
+      return false unless left.arm == right.arm
+
+      struct_equality_result(left.fields, right.fields)
+    end
+
     def self.boolean_value?(value)
       value == true || value == false
     end

data/lib/milk_tea/core/lexer.rb

@@ -324,7 +324,7 @@ module MilkTea
       newline_start = line_offset + line.length
       newline_end = has_newline ? (newline_start + 1) : newline_start
       if @grouping_depth.zero?
-        if Token::LINE_CONTINUATION_OPERATORS.include?(@tokens.last&.type)
+        if Token::LINE_CONTINUATION_OPERATORS.include?(@tokens.last&.type) && !trailing_is_member_access?
           @continuation_pending = true
         else
           @tokens << build_token(:newline, "\n", nil, line_number, line.length + 1, start_offset: newline_start, end_offset: newline_end)
@@ -345,6 +345,10 @@ module MilkTea
       1
     end
 
+    def trailing_is_member_access?
+      @tokens.last&.type == :is && @tokens[-2]&.type == :dot
+    end
+
     def emit_newline(line, line_number, line_offset, has_newline)
       newline_start = line_offset + line.bytesize
       newline_end = has_newline ? (newline_start + 1) : newline_start

data/lib/milk_tea/core/lowering/declarations.rb

@@ -78,6 +78,14 @@ module MilkTea
             IR::AggregateField.new(name:, value: lower_const_value_literal(field_type, field_value))
           end
           IR::AggregateLiteral.new(type:, fields:)
+        when CompileTime::VariantValue
+          arm_field_types = type.respond_to?(:arm) ? (type.arm(const_value.arm) || {}) : {}
+          fields = const_value.fields.map do |field_name, field_value|
+            field_type = arm_field_types[field_name]
+            raise LoweringError.new("constant variant arm #{const_value.arm} field #{field_name} not found in #{type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless field_type
+            IR::AggregateField.new(name: field_name, value: lower_const_value_literal(field_type, field_value))
+          end
+          IR::VariantLiteral.new(type:, arm_name: const_value.arm, fields:)
         else
           raise LoweringError.new("unsupported const value type #{const_value.class}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end

data/lib/milk_tea/core/parser/declarations.rb

@@ -454,7 +454,7 @@ module MilkTea
         match(:async)
         match(:editable) if check(:editable)
         match(:static) if check(:static)
-        result = check(:function)
+        result = check(:function) && !check_next(:colon)
         @current = saved
         result
       end
@@ -468,11 +468,13 @@ module MilkTea
 
         visibility, visibility_token = parse_visibility
 
-        if match(:event)
+        if check(:event) && !check_next(:colon)
+          advance
           return [:event, parse_event_decl(visibility:, attributes: field_attributes)]
         end
 
-        if match(:struct)
+        if check(:struct) && !check_next(:colon)
+          advance
           return [:nested_type, parse_struct_decl(visibility:, attributes: field_attributes, inline_methods: false)]
         end
 
@@ -741,7 +743,10 @@ module MilkTea
       end
 
       def parse_visibility
-        return [:public, previous] if match(:public)
+        if check(:public) && !check_next(:colon)
+          advance
+          return [:public, previous]
+        end
 
         [:private, nil]
       end

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

@@ -270,10 +270,19 @@ module MilkTea
 
         if expected_type.is_a?(Types::Primitive) && expected_type.integer? &&
            value_fits_integer_type?(expression.value, expected_type)
-          expected_type
-        else
-          @ctx.types.fetch("int")
+          return expected_type
         end
+
+        # A bare literal (no suffix, no fitting expected type) picks the
+        # narrowest fixed-width type that holds its value: int -> long -> ulong.
+        # Falling through to int unconditionally emitted overflowing C
+        # (e.g. `int32_t x = 2147483648;`).
+        ["int", "long", "ulong"].each do |name|
+          candidate = @ctx.types.fetch(name)
+          return candidate if value_fits_integer_type?(expression.value, candidate)
+        end
+
+        raise_sema_error("integer literal #{expression.value} does not fit in any integer type", expression)
       end
 
       INTEGER_SUFFIX_TYPES = {
@@ -300,11 +309,23 @@ module MilkTea
           @ctx.types.fetch("double")
         elsif expected_type.is_a?(Types::Primitive) && expected_type.float?
           expected_type
-        else
+        elsif float_literal_fits_in_float?(expression.value)
           @ctx.types.fetch("float")
+        else
+          # A bare float literal beyond float32 range would silently overflow
+          # to infinity in C (`float x = 1e40`); promote to double instead.
+          @ctx.types.fetch("double")
         end
       end
 
+      FLOAT32_MAX_MAGNITUDE = 3.4028234663852886e+38
+
+      def float_literal_fits_in_float?(value)
+        return false unless value.is_a?(Numeric) && value.finite?
+
+        value.abs <= FLOAT32_MAX_MAGNITUDE
+      end
+
       def infer_identifier(expression, scopes:, expected_type: nil)
         binding = lookup_value(expression.name, scopes)
         if binding
@@ -662,8 +683,16 @@ module MilkTea
         when "==", "!="
           unless c_natively_equality_comparable_type?(left_type) && c_natively_equality_comparable_type?(right_type)
             bad_type = c_natively_equality_comparable_type?(right_type) ? left_type : right_type
-            if struct_instance_type?(bad_type)
-              raise_sema_error("operator #{expression.operator} is not supported for struct type #{bad_type}; use equal[#{bad_type}](...) instead")
+            if bad_type.is_a?(Types::Union)
+              raise_sema_error("operator #{expression.operator} is not supported for union type #{bad_type}; use equal[#{bad_type}](...) instead")
+            elsif bad_type.is_a?(Types::Variant)
+              field = first_non_equality_comparable_variant_field(bad_type)
+              field_hint = field ? " (arm '#{field[0]}' field '#{field[1]}' of type #{field[2]} is not equality-comparable)" : ""
+              raise_sema_error("operator #{expression.operator} is not supported for variant type #{bad_type}#{field_hint}; use equal[#{bad_type}](...) instead")
+            elsif struct_instance_type?(bad_type) && !bad_type.is_a?(Types::Variant)
+              field = first_non_equality_comparable_field(bad_type)
+              field_hint = field ? " (field '#{field.first}' of type #{field.last} is not equality-comparable)" : ""
+              raise_sema_error("operator #{expression.operator} is not supported for struct type #{bad_type}#{field_hint}; use equal[#{bad_type}](...) instead")
             else
               raise_sema_error("operator #{expression.operator} is not supported for type #{bad_type}")
             end

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

@@ -902,23 +902,65 @@ module MilkTea
         type.is_a?(Types::Struct) || type.is_a?(Types::Variant)
       end
 
-      def c_natively_equality_comparable_type?(type)
+      def c_natively_equality_comparable_type?(type, visiting = nil)
         return true if type.is_a?(Types::Primitive)
         return true if type.is_a?(Types::EnumBase)
         return true if type.is_a?(Types::Opaque)
-        return true if type.is_a?(Types::Nullable)
+        return true if type.is_a?(Types::Nullable) && equality_comparable_field_type?(type.base, visiting)
         return true if type.is_a?(Types::Null)
         return true if type.is_a?(Types::Function)
         return true if type.is_a?(Types::Error)
         return true if type.is_a?(Types::StringView)
         return true if pointer_type?(type)
         return true if ref_type?(type)
-        return true if type.is_a?(Types::Variant)
+        return true if type.is_a?(Types::Variant) && equality_comparable_variant_type?(type, visiting)
         return true if type.is_a?(Types::VariantArmPayload)
+        return true if equality_comparable_struct_type?(type, visiting)
+
+        false
+      end
+
+      # A struct value is equality-comparable with ==/!= when every field is
+      # itself equality-comparable. Untagged unions are excluded because their
+      # active-field comparison is ambiguous.
+      def equality_comparable_struct_type?(type, visiting = nil)
+        type.is_a?(Types::Struct) && !type.is_a?(Types::Union) &&
+          type.fields.all? { |_name, field_type| equality_comparable_field_type?(field_type, visiting) }
+      end
+
+      def equality_comparable_field_type?(type, visiting = nil)
+        return true if c_natively_equality_comparable_type?(type, visiting)
+        return true if array_type?(type) && equality_comparable_field_type?(array_element_type(type), visiting)
 
         false
       end
 
+      # A variant is equality-comparable when every arm payload field is itself
+      # equality-comparable. A variant that reaches itself through value fields
+      # (a recursive/cyclic variant) is comparable too: the C backend embeds
+      # cyclic fields as pointers, and those fields compare by pointer identity.
+      def equality_comparable_variant_type?(type, visiting = nil)
+        return true if visiting&.key?(type)
+
+        visiting = (visiting || {}).merge(type => true)
+        type.arm_names.all? do |arm_name|
+          (type.arm(arm_name) || {}).all? { |_field_name, field_type| equality_comparable_field_type?(field_type, visiting) }
+        end
+      end
+
+      def first_non_equality_comparable_field(struct_type)
+        struct_type.fields.find { |_name, field_type| !equality_comparable_field_type?(field_type) }
+      end
+
+      def first_non_equality_comparable_variant_field(variant_type)
+        variant_type.arm_names.each do |arm_name|
+          (variant_type.arm(arm_name) || {}).each do |field_name, field_type|
+            return [arm_name, field_name, field_type] unless equality_comparable_field_type?(field_type)
+          end
+        end
+        nil
+      end
+
       def collection_loop_type(type)
         super
       end

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

@@ -301,7 +301,12 @@ module MilkTea
             end
 
             if (receiver_type = resolve_type_expression(member_access_expression.receiver))
-              next resolve_enum_member_const_value(receiver_type, member_access_expression.member)
+              if receiver_type.is_a?(Types::EnumBase)
+                next resolve_enum_member_const_value(receiver_type, member_access_expression.member)
+              end
+              if receiver_type.is_a?(Types::Variant)
+                next CompileTime::VariantValue.new(arm: member_access_expression.member, fields: {})
+              end
             end
 
             next unless member_access_expression.receiver.is_a?(AST::Identifier)
@@ -321,6 +326,31 @@ module MilkTea
 
       def evaluate_compile_time_call(expression, scopes: nil)
         case expression.callee
+        when AST::MemberAccess
+          if (receiver_type = resolve_type_expression(expression.callee.receiver)) && receiver_type.is_a?(Types::Variant)
+            arm_name = expression.callee.member
+            fields = {}
+            expression.arguments.each do |argument|
+              val = CompileTime.evaluate(argument.value, resolve_identifier: lambda { |id|
+                if scopes
+                  binding = lookup_value(id.name, scopes)
+                  return binding.const_value unless binding&.const_value.nil?
+                end
+                resolve_current_module_const_value(id.name)
+              }, resolve_member_access: lambda { |ma|
+                if (member_receiver_type = resolve_type_expression(ma.receiver))
+                  next resolve_enum_member_const_value(member_receiver_type, ma.member) if member_receiver_type.is_a?(Types::EnumBase)
+                  next CompileTime::VariantValue.new(arm: ma.member, fields: {}) if member_receiver_type.is_a?(Types::Variant)
+                end
+                nil
+              }, resolve_call: lambda { |inner_call|
+                evaluate_compile_time_call(inner_call, scopes:)
+              })
+              return nil unless val
+              fields[argument.name] = val
+            end
+            return CompileTime::VariantValue.new(arm: arm_name, fields: fields)
+          end
         when AST::Identifier
           if (struct_type = @ctx.types[expression.callee.name]) && struct_type.is_a?(Types::Struct)
             fields = {}

data/std/c/box2d.mt

@@ -424,7 +424,7 @@ enum b2BodyType: int
     b2_bodyTypeCount = 3
 
 struct b2BodyDef:
-    type_: b2BodyType
+    type: b2BodyType
     position: b2Vec2
     rotation: b2Rot
     linearVelocity: b2Vec2

data/std/c/cgltf.mt

@@ -44,7 +44,7 @@ struct cgltf_file_options:
     user_data: ptr[void]
 
 struct cgltf_options:
-    type_: cgltf_file_type
+    type: cgltf_file_type
     json_token_count: ptr_uint
     memory: cgltf_memory_options
     file: cgltf_file_options
@@ -186,7 +186,7 @@ struct cgltf_buffer_view:
     offset: ptr_uint
     size: ptr_uint
     stride: ptr_uint
-    type_: cgltf_buffer_view_type
+    type: cgltf_buffer_view_type
     data: ptr[void]
     has_meshopt_compression: int
     meshopt_compression: cgltf_meshopt_compression
@@ -206,7 +206,7 @@ struct cgltf_accessor:
     name: ptr[char]
     component_type: cgltf_component_type
     normalized: int
-    type_: cgltf_type
+    type: cgltf_type
     offset: ptr_uint
     count: ptr_uint
     stride: ptr_uint
@@ -223,7 +223,7 @@ struct cgltf_accessor:
 
 struct cgltf_attribute:
     name: ptr[char]
-    type_: cgltf_attribute_type
+    type: cgltf_attribute_type
     index: int
     data: ptr[cgltf_accessor]
 
@@ -398,7 +398,7 @@ struct cgltf_material:
     extensions: ptr[cgltf_extension]
 
 struct cgltf_material_mapping:
-    variant_: ptr_uint
+    variant: ptr_uint
     material: ptr[cgltf_material]
     extras: cgltf_extras
 
@@ -416,7 +416,7 @@ struct cgltf_mesh_gpu_instancing:
     attributes_count: ptr_uint
 
 struct cgltf_primitive:
-    type_: cgltf_primitive_type
+    type: cgltf_primitive_type
     indices: ptr[cgltf_accessor]
     material: ptr[cgltf_material]
     attributes: ptr[cgltf_attribute]
@@ -471,7 +471,7 @@ struct cgltf_camera_orthographic:
 
 struct cgltf_camera:
     name: ptr[char]
-    type_: cgltf_camera_type
+    type: cgltf_camera_type
     data: cgltf_camera_data
     extras: cgltf_extras
     extensions_count: ptr_uint
@@ -481,7 +481,7 @@ struct cgltf_light:
     name: ptr[char]
     color: array[cgltf_float, 3]
     intensity: float
-    type_: cgltf_light_type
+    type: cgltf_light_type
     range: float
     spot_inner_cone_angle: float
     spot_outer_cone_angle: float

data/std/c/cjson.mt

@@ -8,7 +8,7 @@ struct cJSON:
     next: ptr[cJSON]
     prev: ptr[cJSON]
     child: ptr[cJSON]
-    type_: int
+    type: int
     valuestring: ptr[char]
     valueint: int
     valuedouble: double

data/std/c/curl.mt

@@ -29,7 +29,7 @@ struct curl_header = c"struct curl_header":
 
 struct curl_ws_frame = c"struct curl_ws_frame":
     age: int
-    flags_: int
+    flags: int
     offset: ptr_int
     bytesleft: ptr_int
     len: ptr_uint
@@ -69,7 +69,7 @@ struct curl_httppost = c"struct curl_httppost":
     contenttype: ptr[char]
     contentheader: ptr[curl_slist]
     more: ptr[curl_httppost]
-    flags_: ptr_int
+    flags: ptr_int
     showfilename: ptr[char]
     userp: ptr[void]
     contentlen: ptr_int
@@ -100,7 +100,7 @@ struct curl_fileinfo = c"struct curl_fileinfo":
     size: ptr_int
     hardlinks: ptr_int
     strings: curl_fileinfo_strings
-    flags_: uint
+    flags: uint
     b_data: ptr[char]
     b_size: ptr_uint
     b_used: ptr_uint
@@ -1069,8 +1069,8 @@ external function curl_url_strerror(error: int) -> cstr
 struct curl_easyoption = c"struct curl_easyoption":
     name: cstr
     id: CURLoption
-    type_: int
-    flags_: uint
+    type: int
+    flags: uint
 
 external function curl_easy_option_by_name(name: cstr) -> const_ptr[curl_easyoption]
 external function curl_easy_option_by_id(id: CURLoption) -> const_ptr[curl_easyoption]

data/std/c/enet.mt

@@ -213,7 +213,7 @@ type ENetPacketFreeCallback = fn(arg0: ptr[ENetPacket]) -> void
 
 struct ENetPacket:
     referenceCount: ptr_uint
-    flags_: uint
+    flags: uint
     data: ptr[enet_uint8]
     dataLength: ptr_uint
     freeCallback: fn(arg0: ptr[ENetPacket]) -> void
@@ -327,7 +327,7 @@ struct ENetPeer:
     outgoingSendReliableCommands: ENetList
     outgoingCommands: ENetList
     dispatchedCommands: ENetList
-    flags_: ushort
+    flags: ushort
     reserved: ushort
     incomingUnsequencedGroup: ushort
     outgoingUnsequencedGroup: ushort
@@ -389,7 +389,7 @@ enum ENetEventType: int
     ENET_EVENT_TYPE_RECEIVE = 3
 
 struct ENetEvent:
-    type_: ENetEventType
+    type: ENetEventType
     peer: ptr[ENetPeer]
     channelID: ubyte
     data: uint