mt-lang 0.3.42 → 0.4.0

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

@@ -213,6 +213,10 @@ module MilkTea
 
         receiver_type = referenced_type(receiver_type) if ref_type?(receiver_type)
 
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("ubyte")
+        end
+
         if array_type?(receiver_type)
           return array_element_type(receiver_type)
         end
@@ -236,6 +240,28 @@ module MilkTea
         raise LoweringError.new("cannot index #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
+      def range_index_result_type(receiver_type)
+        receiver_type = referenced_type(receiver_type) if ref_type?(receiver_type)
+
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("str")
+        end
+
+        if array_type?(receiver_type)
+          return Types::Span.new(array_element_type(receiver_type))
+        end
+
+        if receiver_type.is_a?(Types::Span)
+          return receiver_type
+        end
+
+        raise LoweringError.new("cannot range-index #{receiver_type}; expected str, array[T, N], or span[T]", line: 0, column: 0, path: @ctx.current_analysis_path)
+      end
+
+      def span_slice_callee(span_type)
+        "mt_span_slice_#{sanitize_identifier(span_type.element_type.to_s)}"
+      end
+
       def stored_ref_supported_type?(type, visited = {})
         return true unless type
 

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

@@ -459,6 +459,7 @@ module MilkTea
         match(:async)
         match(:editable) if check(:editable)
         match(:static) if check(:static)
+        match(:const) if check(:const)
         result = check(:function) && !check_next(:colon)
         @current = saved
         result
@@ -657,10 +658,10 @@ module MilkTea
       end
 
       def parse_method_def(attributes: [])
-        visibility, _visibility_token, async, kind, line, name_token = parse_method_head
+        visibility, _visibility_token, async, kind, const, line, name_token = parse_method_head
         name = name_token.lexeme
         type_params, params, return_type, body = parse_callable_signature
-        AST::MethodDef.new(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, attributes:, line:, column: name_token.column)
+        AST::MethodDef.new(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, const:, attributes:, line:, column: name_token.column)
       rescue ParseError => e
         raise unless @recovery_errors
 
@@ -668,11 +669,12 @@ module MilkTea
         name = name_token&.lexeme || "unknown"
         col = name_token&.column || 1
         advance until eof? || check(:function) || check(:dedent)
-        AST::MethodDef.new(name:, type_params: [], params: [], return_type: nil, body: nil, kind: kind || :plain, visibility: visibility || :private, async: async || false, attributes:, line:, column: col)
+        AST::MethodDef.new(name:, type_params: [], params: [], return_type: nil, body: nil, kind: kind || :plain, visibility: visibility || :private, async: async || false, const: const || false, attributes:, line:, column: col)
       end
 
       def parse_interface_method_decl(attributes: [])
-        visibility, visibility_token, async, kind, line, name_token = parse_method_head
+        visibility, visibility_token, async, kind, const, line, name_token = parse_method_head
+        raise error(name_token, "const is not allowed on interface methods") if const
         raise error(visibility_token, "public is not allowed on interface methods") if visibility == :public
 
         name = name_token.lexeme
@@ -689,6 +691,9 @@ module MilkTea
         visibility, visibility_token = parse_visibility
         async = match(:async)
         kind = parse_method_kind
+        const = match(:const)
+        raise error(previous, "editable methods cannot be const") if kind == :editable && const
+        raise error(previous, "async methods cannot be const") if async && const
         if check(:function)
           consume(:function, "expected function declaration")
         elsif check(:identifier)
@@ -699,7 +704,7 @@ module MilkTea
         end
         line = previous.line
         name_token = consume_name("expected function name")
-        [visibility, visibility_token, async, kind, line, name_token]
+        [visibility, visibility_token, async, kind, const, line, name_token]
       end
 
       def parse_method_kind

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

@@ -298,14 +298,16 @@ module MilkTea
 
       def render_function_signature(function, prefix: "")
         signature_prefix = if function.is_a?(AST::MethodDef)
-          case function.kind
-          when :editable
-            "editable function "
-          when :static
-            "static function "
-          else
-            "function "
-          end
+          kind_prefix = case function.kind
+                        when :editable
+                          "editable "
+                        when :static
+                          "static "
+                        else
+                          ""
+                        end
+          const_prefix = function.respond_to?(:const) && function.const ? "const " : ""
+          "#{kind_prefix}#{const_prefix}function "
         elsif function.is_a?(AST::ForeignFunctionDecl)
           "foreign function "
         else

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

@@ -37,6 +37,8 @@ module MilkTea
             allow_span_param_identifier: true,
           )
 
+          raise_sema_error("cannot assign through str index; str is an immutable borrowed view") if receiver_type.is_a?(Types::StringView)
+
           index_type = infer_expression(expression.index, scopes:)
           infer_index_result_type(receiver_type, index_type)
         when AST::Call
@@ -101,6 +103,8 @@ module MilkTea
             require_mutable_pointer:,
             allow_span_param_identifier:,
           )
+          raise_sema_error("cannot index through str as an assignment receiver; str is an immutable borrowed view") if receiver_type.is_a?(Types::StringView)
+
           index_type = infer_expression(expression.index, scopes:)
           infer_index_result_type(receiver_type, index_type)
         when AST::Call
@@ -470,8 +474,17 @@ module MilkTea
 
       def infer_index_access(expression, scopes:)
         receiver_type = infer_expression(expression.receiver, scopes:)
+
+        if expression.index.is_a?(AST::RangeExpr)
+          return infer_range_index_access(expression, receiver_type, scopes:)
+        end
+
         index_type = infer_expression(expression.index, scopes:)
 
+        if receiver_type.is_a?(Types::StringView) && (literal = integer_literal_bound_value(expression.index)) && literal < 0
+          raise_sema_error("str index #{literal} is negative; str indices must be non-negative", expression)
+        end
+
         if soa_type?(receiver_type)
           return receiver_type.element_type
         end

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

@@ -1022,6 +1022,10 @@ module MilkTea
       def infer_index_result_type(receiver_type, index_type)
         raise_sema_error("index must be an integer type, got #{index_type}") unless integer_type?(index_type)
 
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("ubyte")
+        end
+
         if array_type?(receiver_type)
           return array_element_type(receiver_type)
         end
@@ -1047,6 +1051,48 @@ module MilkTea
         raise_sema_error("cannot index #{receiver_type}")
       end
 
+      def infer_range_index_access(expression, receiver_type, scopes:)
+        start_type = infer_expression(expression.index.start_expr, scopes:)
+        stop_type = infer_expression(expression.index.end_expr, scopes:)
+        raise_sema_error("range index bounds must be integer types, got #{start_type} and #{stop_type}") unless start_type.integer? && stop_type.integer?
+
+        if array_type?(receiver_type) && !addressable_storage_expression?(expression.receiver, scopes:)
+          raise_sema_error("array range slice requires an addressable array value; bind it to a local first", expression)
+        end
+
+        if array_type?(receiver_type) && (start_val = integer_literal_bound_value(expression.index.start_expr)) && (stop_val = integer_literal_bound_value(expression.index.end_expr))
+          length = array_length(receiver_type)
+          unless start_val >= 0 && start_val <= stop_val && stop_val <= length
+            raise_sema_error("range index [#{start_val}..#{stop_val}] is out of bounds for array[T, #{length}]", expression)
+          end
+        end
+
+        range_index_result_type(receiver_type)
+      end
+
+      def range_index_result_type(receiver_type)
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("str")
+        end
+
+        if array_type?(receiver_type)
+          return Types::Span.new(array_element_type(receiver_type))
+        end
+
+        if span_type?(receiver_type)
+          return receiver_type
+        end
+
+        raise_sema_error("cannot range-index #{receiver_type}; expected str, array[T, N], or span[T]")
+      end
+
+      def integer_literal_bound_value(expression)
+        return expression.value if expression.is_a?(AST::IntegerLiteral)
+        return -expression.operand.value if expression.is_a?(AST::UnaryOp) && expression.operator == "-" && expression.operand.is_a?(AST::IntegerLiteral)
+
+        nil
+      end
+
       def addressable_storage_expression?(expression, scopes:)
         case expression
         when AST::Identifier

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

@@ -538,6 +538,7 @@ module MilkTea
           require_mutable_pointer: true,
           allow_span_param_identifier: true,
         )
+        raise_sema_error("cannot assign through str index; str is an immutable borrowed view") if receiver_type.is_a?(Types::StringView)
         element_type = infer_index_result_type(receiver_type, @ctx.types.fetch("ptr_uint"))
 
         statement.value.elements.each_with_index do |elem, i|

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

@@ -298,6 +298,33 @@ module MilkTea
             current_type_params[identifier_expression.name] || @ctx.types[identifier_expression.name]
           end,
           resolve_member_access: lambda do |member_access_expression|
+            if (receiver_value = CompileTime.evaluate(
+                  member_access_expression.receiver,
+                  resolve_identifier: lambda do |identifier_expression|
+                    if scopes
+                      binding = lookup_value(identifier_expression.name, scopes)
+                      return binding.const_value unless binding&.const_value.nil?
+                    end
+
+                    resolve_current_module_const_value(identifier_expression.name)
+                  end,
+                  resolve_member_access: lambda { |ma| evaluate_compile_time_const_value(ma, scopes:) },
+                  resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
+                  resolve_call: lambda { |ce| evaluate_compile_time_call(ce, scopes:) },
+                ))
+              case receiver_value
+              when Hash
+                next receiver_value[member_access_expression.member] if receiver_value.key?(member_access_expression.member)
+              when Array
+                if member_access_expression.member =~ /\A_(\d+)\z/
+                  next receiver_value[Regexp.last_match(1).to_i]
+                end
+                next receiver_value.length if member_access_expression.member == "len"
+              when String
+                next receiver_value.length if member_access_expression.member == "len"
+              end
+            end
+
             if member_access_expression.receiver.is_a?(AST::Identifier) && scopes
               binding = lookup_value(member_access_expression.receiver.name, scopes)
               if binding && binding.const_value
@@ -392,6 +419,11 @@ module MilkTea
             end
             return CompileTime::VariantValue.new(arm: arm_name, fields: fields)
           end
+
+          if (method_binding = comptime_method_binding(expression.callee, scopes))
+            receiver_value = comptime_member_receiver_value(expression.callee.receiver, scopes)
+            return comptime_const_method_body(method_binding, expression.arguments, scopes:, receiver_value:)
+          end
         when AST::Identifier
           if (struct_type = @ctx.types[expression.callee.name]) && struct_type.is_a?(Types::Struct)
             fields = {}
@@ -587,7 +619,10 @@ module MilkTea
           initial_vars[param.name] = arg_value
         end
 
-        ctx = CompileTime::BlockContext.new(self, initial_variables: initial_vars)
+        variable_types = func.body_params.each_with_object({}) do |param, acc|
+          acc[param.name] = param.type
+        end
+        ctx = CompileTime::BlockContext.new(self, initial_variables: initial_vars, variable_types: variable_types)
         result = ctx.evaluate_block(func.ast.body, scopes: nil)
         result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
       rescue CompileTime::Error => e
@@ -613,6 +648,40 @@ module MilkTea
         end
       end
 
+      def comptime_methods_map
+        @ctx.methods
+      end
+
+      def comptime_methods_map_by_to_s(_type)
+        nil
+      end
+
+      def comptime_scoped_value_type(name, ctx)
+        return nil unless ctx
+
+        lookup_value(name, ctx)&.type
+      end
+
+      def comptime_value_type(name)
+        @ctx.top_level_values[name]&.type
+      end
+
+      def comptime_const_function(name)
+        @ctx.top_level_functions[name]
+      end
+
+      def comptime_eval(expression, scopes)
+        evaluate_compile_time_const_value(expression, scopes: scopes)
+      end
+
+      def comptime_block_context(initial_vars, variable_types)
+        ::MilkTea::CompileTime::BlockContext.new(self, initial_variables: initial_vars, variable_types: variable_types)
+      end
+
+      def comptime_raise_error(error)
+        raise_sema_error(error.message)
+      end
+
       def evaluate_has_attribute_call(arguments, scopes:)
         target = evaluate_reflection_target_argument(arguments.first.value, scopes:)
         binding = resolve_attribute_name_argument(arguments[1].value)

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -131,6 +131,7 @@ module MilkTea
 
     class Checker
       include Intrinsics
+      include CompileTime::MethodFolding
 
       attr_reader :ctx
 
@@ -222,8 +223,14 @@ module MilkTea
           when AST::WhenStmt
             body = when_chosen_body(decl)
             collect_emit_from_declarations(body) if body
-          when AST::StructDecl, AST::ExtendingBlock
-            # no emit in structs/extending blocks
+          when AST::StructDecl
+            # no emit in structs
+          when AST::ExtendingBlock
+            decl.methods.each do |method|
+              next unless method.respond_to?(:const) && method.const && method.body
+
+              collect_emit_from_statements(method.body)
+            end
           end
         end
       end

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

@@ -21,40 +21,63 @@ module MilkTea
       end
 
       def self.nullable(base)
-        _intern([:nullable, base]) { Nullable.new(base) }
+        _intern([:nullable, type_signature(base)]) { Nullable.new(base) }
       end
 
       def self.generic_instance(name, arguments)
         args = arguments.freeze
-        _intern([:generic, name, args]) { GenericInstance.new(name, args) }
+        _intern([:generic, name, args.map { |a| type_signature(a) }.freeze]) { GenericInstance.new(name, args) }
       end
 
       def self.span(element_type)
-        _intern([:span, element_type]) { Span.new(element_type) }
+        _intern([:span, type_signature(element_type)]) { Span.new(element_type) }
       end
 
       def self.task(result_type)
-        _intern([:task, result_type]) { Task.new(result_type) }
+        _intern([:task, type_signature(result_type)]) { Task.new(result_type) }
       end
 
       def self.string_view
         _intern([:string_view]) { StringView.new }
       end
 
-      # Param signature for intern keys. Parameter#eql? is name-insensitive
-      # (assignability must not depend on parameter names), so arrays of
-      # Parameter objects would conflate fn(value: int) with fn(arg0: int) in
-      # the intern pool. Embedding names here keeps distinct signatures
-      # distinct across independent programs sharing a long-lived pool (the LSP
-      # never resets the registry between checks).
+      # Name-sensitive signature for intern keys. Parameter#eql? is
+      # name-insensitive (assignability must not depend on parameter names), so
+      # Function/Proc objects (and any wrapper containing them) that differ only
+      # in parameter names collide under Hash/==. Pool keys that embed such
+      # types raw therefore conflate fn(value: int) with fn(arg0: int) in a
+      # long-lived pool (the LSP never resets the registry between checks),
+      # leaking one program's parameter names into another's generated C.
+      # Embedding names here keeps distinct signatures distinct.
+      def self.type_signature(type)
+        case type
+        when Function
+          [:function, type.name, param_signature(type.params), type_signature(type.return_type), type_signature(type.receiver_type), type.receiver_editable, type.variadic, type.external]
+        when Proc
+          [:proc, param_signature(type.params), type_signature(type.return_type)]
+        when Nullable
+          [:nullable, type_signature(type.base)]
+        when GenericInstance
+          [:generic, type.name, type.arguments.map { |a| type_signature(a) }]
+        when Tuple
+          [:tuple, type.element_types.map { |t| type_signature(t) }, type.field_names]
+        when Span
+          [:span, type_signature(type.element_type)]
+        when Task
+          [:task, type_signature(type.result_type)]
+        else
+          type
+        end
+      end
+
       def self.param_signature(params)
-        params.map { |p| [p.name, p.type, p.mutable, p.passing_mode, p.boundary_type] }
+        params.map { |p| [p.name, type_signature(p.type), p.mutable, p.passing_mode, p.boundary_type] }
       end
 
       def self.function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
         params_frozen = params.freeze
         param_key = param_signature(params_frozen)
-        _intern([:function, name, param_key, return_type, receiver_type, receiver_editable, variadic, external]) {
+        _intern([:function, name, param_key, type_signature(return_type), type_signature(receiver_type), receiver_editable, variadic, external]) {
           Function.new(name, params: params_frozen, return_type: return_type, receiver_type: receiver_type, receiver_editable: receiver_editable, variadic: variadic, external: external)
         }
       end
@@ -62,7 +85,7 @@ module MilkTea
       def self.proc(params:, return_type:)
         params_frozen = params.freeze
         param_key = param_signature(params_frozen)
-        _intern([:proc, param_key, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
+        _intern([:proc, param_key, type_signature(return_type)]) { Proc.new(params: params_frozen, return_type: return_type) }
       end
 
       def self.parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)
@@ -74,15 +97,15 @@ module MilkTea
       def self.tuple(element_types, field_names: nil)
         et_frozen = element_types.freeze
         fn_frozen = field_names&.freeze
-        _intern([:tuple, et_frozen, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
+        _intern([:tuple, et_frozen.map { |t| type_signature(t) }.freeze, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
       end
 
       def self.soa(element_type, count:)
-        _intern([:soa, element_type, count]) { SoA.new(element_type, count: count) }
+        _intern([:soa, type_signature(element_type), count]) { SoA.new(element_type, count: count) }
       end
 
       def self.simd(element_type, lane_count:)
-        _intern([:simd, element_type, lane_count]) { Simd.new(element_type, lane_count: lane_count) }
+        _intern([:simd, type_signature(element_type), lane_count]) { Simd.new(element_type, lane_count: lane_count) }
       end
 
       def self.lifetime_ref(name)

data/lib/milk_tea/lsp/server/hover.rb

@@ -1330,7 +1330,6 @@ module MilkTea
           end
           return nil unless idx && tokens[idx].type == :identifier
 
-          type_name = tokens[idx].lexeme
           type = resolve_arm_receiver_type(facts, tokens, idx)
 
           arm = if type.respond_to?(:arm)

data/lib/milk_tea/lsp/server/text_documents.rb

@@ -86,7 +86,7 @@ module MilkTea
           rescue StandardError
             nil
           end
-          clear_shared_module_cache if previous_content != disk_content
+          @workspace.clear_shared_module_cache if previous_content != disk_content
           unless defined?(@pull_diagnostics_active) && @pull_diagnostics_active
             @protocol.write_notification('textDocument/publishDiagnostics', {
               uri: uri,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.42
+  version: 0.4.0
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -205,6 +205,7 @@ files:
 - lib/milk_tea/core/c_backend/type_declaration.rb
 - lib/milk_tea/core/c_backend/type_system.rb
 - lib/milk_tea/core/compile_time.rb
+- lib/milk_tea/core/compile_time/method_folding.rb
 - lib/milk_tea/core/control_flow.rb
 - lib/milk_tea/core/control_flow/builder.rb
 - lib/milk_tea/core/control_flow/constant_propagation.rb
@@ -628,7 +629,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.42 installed!
+  Milk Tea 0.4.0 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH