mt-lang 0.3.28 → 0.3.31

data/lib/milk_tea/core/c_backend.rb

@@ -146,6 +146,10 @@ module MilkTea
         lines.concat(emit_str_equality_helper)
         lines << ""
       end
+      if uses_str_concat_helper?
+        lines.concat(emit_str_concat_helper)
+        lines << ""
+      end
       if uses_str_buffer_helpers?
         lines.concat(emit_utf8_validation_helpers)
         lines << ""
@@ -232,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/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/lowering/expressions.rb

@@ -1387,6 +1387,10 @@ module MilkTea
           left = cast_expression(left, operand_type) if operand_type
           right = cast_expression(right, operand_type) if operand_type
 
+          if expression.operator == "+" && left_type == @ctx.types.fetch("str") && right_type == @ctx.types.fetch("str")
+            return IR::Call.new(callee: "mt_str_concat", arguments: [left, right], type:)
+          end
+
           expanded = lower_vector_binary_operation(expression.operator, left, left_type, right, right_type, type)
           return expanded if expanded
 

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
@@ -612,8 +633,8 @@ module MilkTea
 
           left_type
         when "+", "-", "*", "/"
-          if expression.operator == "+" && (string_like_type?(left_type) || string_like_type?(right_type))
-            raise_sema_error("operator + does not support str/cstr concatenation; use continued string literals for static text or string.String/str_buffer for dynamic text")
+          if expression.operator == "+" && left_type == @ctx.types.fetch("str") && right_type == @ctx.types.fetch("str")
+            return left_type
           end
 
           pointer_result = pointer_arithmetic_result(expression.operator, left_type, right_type)
@@ -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 = {}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.28
+  version: 0.3.31
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -149,7 +149,6 @@ files:
 - docs/index.html
 - docs/language-design.md
 - docs/language-manual.md
-- docs/self-hosted-compiler-plan.md
 - lib/milk_tea.rb
 - lib/milk_tea/base.rb
 - lib/milk_tea/bindings.rb
@@ -625,7 +624,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.28 installed!
+  Milk Tea 0.3.31 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH