mt-lang 0.3.41 → 0.3.43

data/lib/milk_tea/core/c_backend/runtime_helpers.rb

@@ -51,6 +51,7 @@ module MilkTea
           "",
           "static mt_str mt_str_concat(mt_str a, mt_str b) {",
           "#{INDENT}uintptr_t total = a.len + b.len;",
+          "#{INDENT}if (total > MT_STR_CONCAT_BUF_SIZE) mt_fatal(\"str concatenation exceeds the scratch buffer budget\");",
           "#{INDENT}if (mt_str_concat_offset + total > MT_STR_CONCAT_BUF_SIZE) {",
           "#{INDENT * 2}mt_str_concat_offset = 0;",
           "#{INDENT}}",
@@ -63,6 +64,36 @@ module MilkTea
         ]
       end
 
+      def emit_str_slice_helpers
+        [
+          "static uint8_t mt_str_index(mt_str text, uintptr_t index) {",
+          "#{INDENT}if (index >= text.len) mt_fatal(\"str index out of bounds\");",
+          "#{INDENT}return (uint8_t)text.data[index];",
+          "}",
+          "",
+          "static bool mt_str_utf8_boundary(mt_str text, uintptr_t index) {",
+          "#{INDENT}if (index == 0 || index == text.len) return true;",
+          "#{INDENT}return ((uint8_t)text.data[index] & 0xC0) != 0x80;",
+          "}",
+          "",
+          "static mt_str mt_str_slice(mt_str text, uintptr_t start, uintptr_t stop) {",
+          "#{INDENT}if (start > stop || stop > text.len) mt_fatal(\"str slice out of bounds\");",
+          "#{INDENT}if (!mt_str_utf8_boundary(text, start) || !mt_str_utf8_boundary(text, stop)) mt_fatal(\"str slice bounds must be UTF-8 code-unit boundaries\");",
+          "#{INDENT}return (mt_str){ .data = text.data + start, .len = stop - start };",
+          "}",
+        ]
+      end
+
+      def emit_span_slice_helper(helper_name)
+        span_name = helper_name.sub("mt_span_slice_", "mt_span_")
+        [
+          "static inline #{span_name} #{helper_name}(#{span_name} span, uintptr_t start, uintptr_t stop) {",
+          "#{INDENT}if (start > stop || stop > span.len) mt_fatal(\"span slice out of bounds\");",
+          "#{INDENT}return (#{span_name}){ .data = span.data + start, .len = stop - start };",
+          "}",
+        ]
+      end
+
       def emit_variant_equality_helpers
         variant_decls_by_linkage = (emitted_aggregate_variants + collect_generic_variant_decls).each_with_object({}) { |decl, map| map[decl.linkage_name] = decl }
         variant_equality_types
@@ -297,6 +328,9 @@ module MilkTea
           "#{INDENT}for (int t = 0; t < nworkers; t++) {",
           "#{INDENT * 2}uv_thread_join(&threads[t]);",
           "#{INDENT}}",
+          "#{INDENT}for (int t = nworkers + 1; t < count; t++) {",
+          "#{INDENT * 2}items[t].work(items[t].data);",
+          "#{INDENT}}",
           "}",
         ]
       end
@@ -590,11 +624,11 @@ module MilkTea
 
       def emit_checked_array_index_helper(type)
         helper_name = checked_array_index_helper_name(type)
-        params = [c_declaration(type, '(*array)'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
+        params = [c_declaration(pointer_to(array_element_type(type)), 'array'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
         [
           "static inline #{c_function_declaration(pointer_to(array_element_type(type)), helper_name, params)} {",
           "#{INDENT}if (index >= #{array_length(type)}) mt_fatal(\"array index out of bounds\");",
-          "#{INDENT}return &(*array)[index];",
+          "#{INDENT}return &array[index];",
           "}",
         ]
       end
@@ -612,11 +646,11 @@ module MilkTea
 
       def emit_nullable_array_index_helper(type)
         helper_name = nullable_array_index_helper_name(type)
-        params = [c_declaration(type, '(*array)'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
+        params = [c_declaration(pointer_to(array_element_type(type)), 'array'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
         [
           "static inline #{c_function_declaration(pointer_to(array_element_type(type)), helper_name, params)} {",
           "#{INDENT}if (index >= #{array_length(type)}) return NULL;",
-          "#{INDENT}return &(*array)[index];",
+          "#{INDENT}return &array[index];",
           "}",
         ]
       end

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

@@ -495,7 +495,7 @@ module MilkTea
       def emit_checked_index_pointer(expression)
         case expression
         when IR::CheckedIndex
-          "#{checked_array_index_helper_name(expression.receiver_type)}(#{emit_address_of_operand(expression.receiver)}, #{emit_expression(expression.index)})"
+          "#{checked_array_index_helper_name(expression.receiver_type)}(#{emit_checked_array_index_argument(expression.receiver)}, #{emit_expression(expression.index)})"
         when IR::CheckedSpanIndex
           "#{checked_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)})"
         else

data/lib/milk_tea/core/c_backend/type_collectors.rb

@@ -19,6 +19,80 @@ module MilkTea
         span_types.uniq
       end
 
+      def collect_span_slice_helper_names
+        names = []
+        emitted_functions.each do |function|
+          collect_span_slice_helper_names_from_statements(function.body, names)
+        end
+        names.uniq
+      end
+
+      def collect_span_slice_helper_names_from_statements(statements, names)
+        statements.each do |statement|
+          case statement
+          when IR::LocalDecl
+            collect_span_slice_helper_names_from_expression(statement.value, names)
+          when IR::Assignment
+            collect_span_slice_helper_names_from_expression(statement.target, names)
+            collect_span_slice_helper_names_from_expression(statement.value, names)
+          when IR::BlockStmt
+            collect_span_slice_helper_names_from_statements(statement.body, names)
+          when IR::WhileStmt
+            collect_span_slice_helper_names_from_expression(statement.condition, names)
+            collect_span_slice_helper_names_from_statements(statement.body, names)
+          when IR::ForStmt
+            collect_span_slice_helper_names_from_statements([statement.init], names)
+            collect_span_slice_helper_names_from_expression(statement.condition, names)
+            collect_span_slice_helper_names_from_statements(statement.body, names)
+            collect_span_slice_helper_names_from_statements([statement.post], names)
+          when IR::IfStmt
+            collect_span_slice_helper_names_from_expression(statement.condition, names)
+            collect_span_slice_helper_names_from_statements(statement.then_body, names)
+            collect_span_slice_helper_names_from_statements(statement.else_body, names) if statement.else_body
+          when IR::SwitchStmt
+            collect_span_slice_helper_names_from_expression(statement.expression, names)
+            statement.cases.each { |switch_case| collect_span_slice_helper_names_from_statements(switch_case.body, names) }
+          when IR::ReturnStmt
+            collect_span_slice_helper_names_from_expression(statement.value, names) if statement.value
+          when IR::ExpressionStmt
+            collect_span_slice_helper_names_from_expression(statement.expression, names)
+          end
+        end
+      end
+
+      def collect_span_slice_helper_names_from_expression(expression, names)
+        return unless expression
+
+        case expression
+        when IR::Call
+          names << expression.callee if expression.callee.is_a?(String) && expression.callee.start_with?("mt_span_slice_")
+          collect_span_slice_helper_names_from_expression(expression.callee, names) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_span_slice_helper_names_from_expression(argument, names) }
+        when IR::Member
+          collect_span_slice_helper_names_from_expression(expression.receiver, names)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_span_slice_helper_names_from_expression(expression.receiver, names)
+          collect_span_slice_helper_names_from_expression(expression.index, names)
+        when IR::Unary
+          collect_span_slice_helper_names_from_expression(expression.operand, names)
+        when IR::Binary
+          collect_span_slice_helper_names_from_expression(expression.left, names)
+          collect_span_slice_helper_names_from_expression(expression.right, names)
+        when IR::Conditional
+          collect_span_slice_helper_names_from_expression(expression.condition, names)
+          collect_span_slice_helper_names_from_expression(expression.then_expression, names)
+          collect_span_slice_helper_names_from_expression(expression.else_expression, names)
+        when IR::Cast, IR::AddressOf
+          collect_span_slice_helper_names_from_expression(expression.expression, names)
+        when IR::AggregateLiteral
+          expression.fields.each { |field| collect_span_slice_helper_names_from_expression(field.value, names) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_span_slice_helper_names_from_expression(element, names) }
+        when IR::VariantLiteral
+          expression.fields.each { |field| collect_span_slice_helper_names_from_expression(field.value, names) }
+        end
+      end
+
       def collect_checked_array_index_types_from_statements(statements, array_types, nullable_only: false)
         statements.each do |statement|
           case statement
@@ -223,6 +297,26 @@ module MilkTea
         soa_types = []
         visited = {}
 
+        all_emitted_top_level_values.each do |value|
+          collect_soa_type(value.type, soa_types, visited)
+        end
+
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_soa_type(field.type, soa_types, visited)
+          end
+        end
+
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_soa_type(field.type, soa_types, visited)
+          end
+        end
+
+        each_variant_arm_field_type do |field_type|
+          collect_soa_type(field_type, soa_types, visited)
+        end
+
         emitted_functions.each do |function|
           collect_soa_type(function.return_type, soa_types, visited)
           function.params.each do |param|
@@ -231,10 +325,9 @@ module MilkTea
           collect_soa_from_statements(function.body, soa_types, visited)
         end
 
-        @program.structs.each do |struct_decl|
-          struct_decl.fields.each do |field|
-            collect_soa_type(field.type, soa_types, visited)
-          end
+        @program.static_asserts.each do |statement|
+          collect_soa_type_in_expression(statement.condition, soa_types, visited)
+          collect_soa_type_in_expression(statement.message, soa_types, visited)
         end
 
         soa_types.uniq

data/lib/milk_tea/core/c_backend.rb

@@ -162,6 +162,10 @@ module MilkTea
         lines.concat(emit_str_concat_helper)
         lines << ""
       end
+      if uses_str_slice_helpers?
+        lines.concat(emit_str_slice_helpers)
+        lines << ""
+      end
       if uses_str_buffer_helpers?
         lines.concat(emit_utf8_validation_helpers)
         lines << ""
@@ -335,6 +339,11 @@ module MilkTea
         lines << ""
       end
 
+      collect_span_slice_helper_names.each do |helper_name|
+        lines.concat(emit_span_slice_helper(helper_name))
+        lines << ""
+      end
+
       collect_checked_array_index_types(nullable_only: true).each do |type|
         lines.concat(emit_nullable_array_index_helper(type))
         lines << ""

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

@@ -636,13 +636,9 @@ module MilkTea
                 active_defers: active_defers + local_defers,
                 loop_flow: nested_loop_flow(loop_flow, local_defers),
               )
+              storage_ref = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
               lowered << IR::IfStmt.new(
-                condition: IR::Binary.new(
-                  operator: "==",
-                  left: IR::Name.new(name: linkage_name, type: storage_type, pointer: false),
-                  right: IR::NullLiteral.new(type: storage_type),
-                  type: @ctx.types.fetch("bool"),
-                ),
+                condition: let_else_failure_condition(storage_ref, storage_type),
                 then_body: else_body,
                 else_body: nil,
               )

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

@@ -421,7 +421,8 @@ module MilkTea
         body = [async_frame_cast_declaration(frame_type, async_info)]
 
         not_ready_expr = IR::Unary.new(operator: "not", operand: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")), type: @ctx.types.fetch("bool"))
-        not_ready_return = [IR::ReturnStmt.new(value: nil)]
+        frame_free_stmt = IR::ExpressionStmt.new(expression: IR::Call.new(callee: "mt_async_free", arguments: [raw_frame_expr], type: @ctx.types.fetch("void")))
+        not_ready_return = [frame_free_stmt, IR::ReturnStmt.new(value: nil)]
 
         if async_info[:await_fields].any?
           await_release_stmts = []
@@ -589,11 +590,17 @@ module MilkTea
         )
         body << IR::ExpressionStmt.new(expression: ready_assign)
 
-        waiter_frame_expr = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
+        waiter_frame_field = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
         wake_stmts = [
+          IR::LocalDecl.new(
+            name: "waiter_frame",
+            linkage_name: "__mt_waiter_frame",
+            type: async_info[:void_ptr],
+            value: waiter_frame_field,
+          ),
           IR::ExpressionStmt.new(
             expression: IR::Assignment.new(
-              target: async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr]),
+              target: waiter_frame_field,
               operator: "=",
               value: IR::NullLiteral.new(type: async_info[:void_ptr]),
             ),
@@ -601,13 +608,13 @@ module MilkTea
           IR::ExpressionStmt.new(
             expression: IR::Call.new(
               callee: IR::Name.new(name: async_frame_field_c_name("waiter"), type: async_info[:wake_type], pointer: false),
-              arguments: [waiter_frame_expr],
+              arguments: [IR::Name.new(name: "__mt_waiter_frame", type: async_info[:void_ptr], pointer: false)],
               type: @ctx.types.fetch("void"),
             ),
           ),
         ]
         body << IR::IfStmt.new(
-          condition: waiter_frame_expr,
+          condition: waiter_frame_field,
           then_body: wake_stmts,
           else_body: nil,
         )

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

@@ -364,6 +364,17 @@ module MilkTea
         end
       end
 
+      # Emits a type-name prefix that the semantic re-check of generated proc
+      # roots can actually resolve: bare names for prelude and current-module
+      # types, the qualified module path otherwise.
+      def ast_type_ref_base_parts(type)
+        return [type.name] if type.module_name.nil?
+        return [type.name] if type.module_name == @ctx.module_name
+        return [type.name] if %w[std.option std.result].include?(type.module_name)
+
+        type.module_name.split(".") + [type.name]
+      end
+
       def ast_type_ref_for(type)
         case type
         when Types::Primitive
@@ -389,12 +400,25 @@ module MilkTea
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["span"]), arguments: [AST::TypeArgument.new(value: ast_type_ref_for(type.element_type))], nullable: false)
         when Types::Task
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["Task"]), arguments: [AST::TypeArgument.new(value: ast_type_ref_for(type.result_type))], nullable: false)
+        when Types::StringView
+          AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["str"]), arguments: [], nullable: false)
         when Types::TypeVar
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: [type.name]), arguments: [], nullable: false)
         when Types::StructInstance
-          base_parts = type.module_name ? type.module_name.split(".") + [type.name] : [type.name]
           AST::TypeRef.new(
-            name: AST::QualifiedName.new(parts: base_parts),
+            name: AST::QualifiedName.new(parts: ast_type_ref_base_parts(type)),
+            arguments: type.arguments.map do |argument|
+              if argument.is_a?(Types::LiteralTypeArg)
+                AST::TypeArgument.new(value: AST::IntegerLiteral.new(lexeme: argument.value.to_s, value: argument.value))
+              else
+                AST::TypeArgument.new(value: ast_type_ref_for(argument))
+              end
+            end,
+            nullable: false,
+          )
+        when Types::VariantInstance
+          AST::TypeRef.new(
+            name: AST::QualifiedName.new(parts: ast_type_ref_base_parts(type)),
             arguments: type.arguments.map do |argument|
               if argument.is_a?(Types::LiteralTypeArg)
                 AST::TypeArgument.new(value: AST::IntegerLiteral.new(lexeme: argument.value.to_s, value: argument.value))
@@ -404,9 +428,8 @@ module MilkTea
             end,
             nullable: false,
           )
-        when Types::Struct, Types::Union, Types::Opaque, Types::Enum, Types::Flags
-          parts = type.module_name ? type.module_name.split(".") + [type.name] : [type.name]
-          AST::TypeRef.new(name: AST::QualifiedName.new(parts: parts), arguments: [], nullable: false)
+        when Types::Struct, Types::Union, Types::Opaque, Types::Enum, Types::Flags, Types::Variant
+          AST::TypeRef.new(name: AST::QualifiedName.new(parts: ast_type_ref_base_parts(type)), arguments: [], nullable: false)
         when Types::Function
           AST::FunctionType.new(
             params: type.params.each_with_index.map { |param, i| AST::Param.new(name: param.name || "p#{i}", type: ast_type_ref_for(param.type)) },

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

@@ -1364,13 +1364,19 @@ module MilkTea
         when AST::IndexAccess
           receiver_type = infer_expression_type(expression.receiver, env:)
           receiver = lower_expression(expression.receiver, env:)
-          index = lower_expression(expression.index, env:)
-          if array_type?(receiver_type) && addressable_storage_expression?(expression.receiver)
-            IR::CheckedIndex.new(receiver:, index:, receiver_type:, type:)
-          elsif receiver_type.is_a?(Types::Span)
-            IR::CheckedSpanIndex.new(receiver:, index:, receiver_type:, type:)
+          if expression.index.is_a?(AST::RangeExpr)
+            lower_range_index_access(receiver, receiver_type, expression.index, env:, type:)
           else
-            IR::Index.new(receiver:, index:, type:)
+            index = lower_expression(expression.index, env:)
+            if array_type?(receiver_type) && addressable_storage_expression?(expression.receiver)
+              IR::CheckedIndex.new(receiver:, index:, receiver_type:, type:)
+            elsif receiver_type.is_a?(Types::Span)
+              IR::CheckedSpanIndex.new(receiver:, index:, receiver_type:, type:)
+            elsif receiver_type.is_a?(Types::StringView)
+              IR::Call.new(callee: "mt_str_index", arguments: [receiver, index], type:)
+            else
+              IR::Index.new(receiver:, index:, type:)
+            end
           end
         when AST::UnaryOp
           raise LoweringError.new("propagation expressions must be prepared before direct lowering", line: 0, column: 0, path: @ctx.current_analysis_path) if expression.operator == "?"
@@ -1452,6 +1458,25 @@ module MilkTea
         end
       end
 
+      def lower_range_index_access(receiver, receiver_type, range, env:, type:)
+        start = lower_range_index_bound(range.start_expr, env:)
+        stop = lower_range_index_bound(range.end_expr, env:)
+
+        if receiver_type.is_a?(Types::StringView)
+          return IR::Call.new(callee: "mt_str_slice", arguments: [receiver, start, stop], type:)
+        end
+
+        span_type = range_index_result_type(receiver_type)
+        span_argument = receiver_type.is_a?(Types::Span) ? receiver : lower_array_to_span_expression(receiver, span_type)
+        IR::Call.new(callee: span_slice_callee(span_type), arguments: [span_argument, start, stop], type: span_type)
+      end
+
+      def lower_range_index_bound(bound, env:)
+        ptr_uint = @ctx.types.fetch("ptr_uint")
+        lowered = lower_expression(bound, env:, expected_type: ptr_uint)
+        lowered.type == ptr_uint ? lowered : IR::Cast.new(target_type: ptr_uint, expression: lowered, type: ptr_uint)
+      end
+
       def lower_member_access(expression, env:, type:)
         if (type_expr = resolve_type_expression(expression.receiver))
           if type_expr.is_a?(Types::Variant)

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

@@ -206,6 +206,9 @@ module MilkTea
         when AST::IndexAccess
           collect_proc_captures_from_expression(expression.receiver, env, local_scopes, captures)
           collect_proc_captures_from_expression(expression.index, env, local_scopes, captures)
+        when AST::RangeExpr
+          collect_proc_captures_from_expression(expression.start_expr, env, local_scopes, captures)
+          collect_proc_captures_from_expression(expression.end_expr, env, local_scopes, captures)
         when AST::Specialization
           collect_proc_captures_from_expression(expression.callee, env, local_scopes, captures)
           expression.arguments.each { |argument| collect_proc_captures_from_expression(argument.value, env, local_scopes, captures) }

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

@@ -786,6 +786,9 @@ module MilkTea
           raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
         when AST::IndexAccess
           receiver_type = infer_expression_type(expression.receiver, env:)
+          if expression.index.is_a?(AST::RangeExpr)
+            return range_index_result_type(receiver_type)
+          end
           index_type = infer_expression_type(expression.index, env:)
           infer_index_result_type(receiver_type, index_type)
         when AST::UnaryOp

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/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
@@ -248,7 +252,13 @@ module MilkTea
             raise_sema_error("unsupported expression #{expression.class.name}")
           end
 
-          @resolved_expr_types[@ctx.ast.node_ids[expression.object_id]] = type
+          # Specialized generic-instance bodies share the same AST nodes across
+          # substitutions, so a node-id keyed cache cannot be populated there:
+          # the last-checked instance would overwrite every other instance's
+          # types and leak wrong types to lowering, which reads this cache.
+          # Regular functions carry an empty (but non-nil) substitution hash, so
+          # only a non-empty hash identifies an instance body.
+          @resolved_expr_types[@ctx.ast.node_ids[expression.object_id]] = type unless @current_type_substitutions&.any?
           type
         end
       end
@@ -464,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
@@ -961,7 +980,7 @@ module MilkTea
         callable_kind = resolution.kind
         callable = resolution.value
         receiver = resolution.receiver
-        @resolved_call_kinds[@ctx.ast.node_ids[expression.callee.object_id]] = callable_kind
+        @resolved_call_kinds[@ctx.ast.node_ids[expression.callee.object_id]] = callable_kind unless @current_type_substitutions&.any?
 
         case callable_kind
         when :function

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

@@ -695,7 +695,9 @@ module MilkTea
         offset = CompileTime::Layout.offset_of(type, binding.const_value.field_name)
         return unless offset
 
-        @const_values[@ctx.ast.node_ids[expression.object_id]] = offset
+        # Same node-id key collision as resolved_expr_types: instance bodies
+        # share AST nodes across substitutions, so never cache their values.
+        @const_values[@ctx.ast.node_ids[expression.object_id]] = offset unless @current_type_substitutions&.any?
       end
 
       def infer_offsetof_type(type_ref, field_name, scopes: nil)
@@ -1020,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
@@ -1045,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|