mt-lang 0.2.19 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '076938689f867b9d3d7f60eab7f4654c03a45ea69b429f1af17c86a3afef51a5'
-  data.tar.gz: 6f01bf9d070e1307666949acf47d99170d6b28c0048c868a6310663f2d55c919
+  metadata.gz: e599b2192dada4fb02cbcefc522482028adce79482a53965f2715895ced1c744
+  data.tar.gz: 2a4b8540ee7050b98707aee9cdd15b6f18504c8f401f9590c03720a49d88de78
 SHA512:
-  metadata.gz: 8141047ac65832b64b8eab1d565b5c3eb3bf8841b5541624605179a1e4bc0479f4dab16a92b3b7055e2eb844e37781aac7acab2aa812b348e53d9a151a16fe97
-  data.tar.gz: e5ead28d45b33a6c7fdb5c46f84cdd9a887e6bca593b841687a1d1124ba904f02ee09bdb1ef8dab87f2b8dcfcd6480190e94cea57e8b3b4853148d06d199f6e6
+  metadata.gz: a308513fd5d5aac4ab32c9707b1bb066851b103b4c3ff9521e880f0bdaf7501968329da6fa6a98487077f532189b0931bb4e715e2a495f359e383320ecc1b212
+  data.tar.gz: d6f99733d6bc1be8eff2d4002b7b2e7d8aa8b1b6a48fe7ca26631a0ffc3780bafadcee2003c73afa473c457d59c736845d3e34f96e0a13ea1b3a48920b294b2c

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.2.19"
+  VERSION = "0.2.21"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

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

@@ -1074,7 +1074,15 @@ module MilkTea
                   lower_expression(prepared_value, env:, expected_type: target.type)
                 end
         update_cstr_metadata_for_assignment!(statement, prepared_value, env)
-        if statement.operator == "=" && contains_proc_storage_type?(target.type)
+        operator = statement.operator
+        if ["+=", "-=", "*=", "/="].include?(operator) &&
+           (target.type.is_a?(Types::Vector) || target.type.is_a?(Types::Matrix) || target.type.is_a?(Types::Quaternion))
+          binary_op = operator[0...-1]
+          expanded = lower_vector_binary_op(binary_op, target, target.type, value, value.type, target.type)
+          value = expanded || IR::Binary.new(operator: binary_op, left: target, right: value, type: target.type)
+          operator = "="
+        end
+        if operator == "=" && contains_proc_storage_type?(target.type)
           rhs_name = fresh_c_temp_name(env, "proc_assign")
           lowered << IR::LocalDecl.new(name: rhs_name, linkage_name: rhs_name, type: target.type, value:)
           rhs = IR::Name.new(name: rhs_name, type: target.type, pointer: false)
@@ -1082,7 +1090,7 @@ module MilkTea
           lowered.concat(lower_proc_contained_guarded_release_statements(target, target.type))
           lowered << IR::Assignment.new(target:, operator: "=", value: rhs)
         else
-          lowered << IR::Assignment.new(target:, operator: statement.operator, value:)
+          lowered << IR::Assignment.new(target:, operator:, value:)
         end
         lowered
       end

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

@@ -211,7 +211,15 @@ module MilkTea
             end
             update_cstr_metadata_for_assignment!(statement, prepared_value, local_env)
             local_defers.concat(suppress_format_releases_for_assignment(prepared_cleanups, target.type))
-            if statement.operator == "=" && contains_proc_storage_type?(target.type)
+            operator = statement.operator
+            if ["+=", "-=", "*=", "/="].include?(operator) &&
+               (target.type.is_a?(Types::Vector) || target.type.is_a?(Types::Matrix) || target.type.is_a?(Types::Quaternion))
+              binary_op = operator[0...-1]
+              expanded = lower_vector_binary_op(binary_op, target, target.type, value, value.type, target.type)
+              value = expanded || IR::Binary.new(operator: binary_op, left: target, right: value, type: target.type)
+              operator = "="
+            end
+            if operator == "=" && contains_proc_storage_type?(target.type)
               # Materialize the RHS to a C temp to avoid evaluating aggregate literals multiple times
               # and to ensure retain/release operate on a stable struct value throughout the sequence.
               rhs_name = fresh_c_temp_name(local_env, "proc_assign")
@@ -224,7 +232,7 @@ module MilkTea
               lowered.concat(lower_proc_contained_guarded_release_statements(target, target.type))
               lowered << IR::Assignment.new(target:, operator: "=", value: rhs)
             else
-              lowered << IR::Assignment.new(target:, operator: statement.operator, value:)
+              lowered << IR::Assignment.new(target:, operator:, value:)
             end
           when AST::IfStmt
             if statement.inline

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

@@ -176,7 +176,11 @@ module MilkTea
             enum_type = @ctx.types.fetch(decl.name)
             backing_type = enum_type.backing_type
             members = decl.members.map do |member|
-              value = lower_expression(member.value, env: empty_env, expected_type: backing_type)
+              value = if member.value
+                        lower_expression(member.value, env: empty_env, expected_type: backing_type)
+                      else
+                        IR::IntegerLiteral.new(value: enum_type.member_value(member.name), type: backing_type)
+                      end
               IR::EnumMember.new(name: member.name, linkage_name: enum_member_c_name(enum_type, member.name), value:)
             end
 

data/lib/milk_tea/core/pretty_printer/ir_formatter.rb

@@ -260,6 +260,8 @@ module MilkTea
           end
         when IR::ArrayLiteral
           "#{expression.type}(#{expression.elements.map { |element| render_expression(element) }.join(', ')})"
+        when IR::Assignment
+          "#{render_expression(expression.target)} #{expression.operator} #{render_expression(expression.value)}"
         else
           raise ArgumentError, "unsupported IR expression #{expression.class.name}"
         end

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

@@ -450,6 +450,21 @@ module MilkTea
           raise_sema_error("safe array indexing requires an addressable array value; bind it to a local first")
         end
 
+        if array_type?(receiver_type) && expression.index.is_a?(AST::IntegerLiteral)
+          length = array_length(receiver_type)
+          index_val = expression.index.value
+          if index_val >= length || index_val < 0
+            raise_sema_error("array index #{index_val} is out of bounds for array[T, #{length}]", expression)
+          end
+        end
+
+        if array_type?(receiver_type) && expression.index.is_a?(AST::UnaryOp) && expression.index.operator == "-" &&
+           expression.index.operand.is_a?(AST::IntegerLiteral)
+          length = array_length(receiver_type)
+          index_val = -expression.index.operand.value
+          raise_sema_error("array index #{index_val} is out of bounds for array[T, #{length}]", expression)
+        end
+
         infer_index_result_type(receiver_type, index_type)
       end
 

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

@@ -185,6 +185,7 @@ module MilkTea
 
             validate_consuming_foreign_expression!(statement.value, scopes:, root_allowed: false) if statement.value
             value_type = statement.value ? infer_expression(statement.value, scopes:, expected_type: return_type) : @ctx.types.fetch("void")
+            check_stack_pointer_escape_in_return(statement.value, scopes:) if statement.value
             ensure_assignable!(
               value_type,
               return_type,
@@ -494,16 +495,21 @@ module MilkTea
             line: statement.line, column: statement.column,
           )
         when "+=", "-=", "*=", "/="
-          raise_sema_error("operator #{statement.operator} requires matching numeric types, got #{target_type} and #{value_type}") unless target_type.numeric? && value_type.numeric?
+          binary_op = statement.operator[0...-1]
+          if (result_type = vector_arithmetic_result(binary_op, target_type, value_type))
+            raise_sema_error("operator #{statement.operator} on #{target_type} and #{value_type} produces #{result_type}, expected #{target_type}") unless result_type == target_type
+          else
+            raise_sema_error("operator #{statement.operator} requires matching numeric types, got #{target_type} and #{value_type}") unless target_type.numeric? && value_type.numeric?
 
-          ensure_assignable!(
-            value_type,
-            target_type,
-            "operator #{statement.operator} requires matching numeric types, got #{target_type} and #{value_type}",
-            expression: statement.value,
-            contextual_int_to_float: contextual_int_to_float_target?(target_type),
-            line: statement.line, column: statement.column,
-          )
+            ensure_assignable!(
+              value_type,
+              target_type,
+              "operator #{statement.operator} requires matching numeric types, got #{target_type} and #{value_type}",
+              expression: statement.value,
+              contextual_int_to_float: contextual_int_to_float_target?(target_type),
+              line: statement.line, column: statement.column,
+            )
+          end
         when "%="
           unless common_integer_type(target_type, value_type) == target_type
             raise_sema_error("operator #{statement.operator} requires compatible integer types, got #{target_type} and #{value_type}")
@@ -1322,6 +1328,64 @@ module MilkTea
         end
       end
 
+      # Walks the returned expression tree to detect ptr_of/ref_of/const_ptr_of
+      # applied to a stack-local variable whose address must not escape the
+      # function. Only flags when the pointer value itself (not a computed
+      # result through a function call) reaches the return.
+      def check_stack_pointer_escape_in_return(expression, scopes:)
+        return unless expression
+
+        if expression.is_a?(AST::Call)
+          check_stack_escape_call(expression, scopes:)
+        elsif expression.is_a?(AST::BinaryOp)
+          check_stack_pointer_escape_in_return(expression.left, scopes:)
+          check_stack_pointer_escape_in_return(expression.right, scopes:)
+        elsif expression.is_a?(AST::UnaryOp)
+          check_stack_pointer_escape_in_return(expression.operand, scopes:)
+        end
+      end
+
+      def check_stack_escape_call(expression, scopes:)
+        callee = expression.callee
+        return unless callee.is_a?(AST::Identifier)
+        return unless %w[ptr_of ref_of const_ptr_of].include?(callee.name)
+        return if expression.arguments.empty?
+
+        arg = expression.arguments.first
+        source = arg.respond_to?(:value) ? arg.value : arg
+        check_stack_local_source(source, scopes:, builtin: callee.name)
+      end
+
+      def check_stack_local_source(expression, scopes:, builtin:)
+        case expression
+        when AST::Identifier
+          binding = lookup_local_binding(expression.name, scopes)
+          return unless binding
+          return unless %i[let var param].include?(binding.kind)
+          return if stack_safe_pointer_source?(binding)
+          raise_sema_error(
+            "#{builtin}(#{expression.name}) cannot be returned: pointer to function-local storage",
+            expression,
+          )
+        when AST::MemberAccess
+          check_stack_local_source(expression.receiver, scopes:, builtin:)
+        when AST::IndexAccess
+          check_stack_local_source(expression.receiver, scopes:, builtin:)
+        end
+      end
+
+      def lookup_local_binding(name, scopes)
+        scopes.reverse_each do |scope|
+          return scope[name] if scope.key?(name)
+        end
+        nil
+      end
+
+      def stack_safe_pointer_source?(binding)
+        return false unless binding.type
+        ref_type?(binding.type) || own_type?(binding.type) || (binding.mutable && binding.kind == :param)
+      end
+
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.2.21
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -586,7 +586,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.2.19 installed!
+  Milk Tea 0.2.21 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH