Implemented string indexing for Core.String (#6270)

Author: ammaralassal

core/prelude/types/string.carbon

@@ -8,6 +8,13 @@ import library "prelude/copy";
 import library "prelude/destroy";
 import library "prelude/types/char";
 import library "prelude/types/uint";
+import library "prelude/operators/index";
+import library "prelude/types/int";
+
+class String;
+
+// Forward declaration for builtin function
+fn StringAt(s: String, index: i32) -> Char;
 
 class String {
   fn Size[self: Self]() -> u64 { return self.size; }
@@ -16,8 +23,15 @@ class String {
     fn Op[self: Self]() -> Self { return {.ptr = self.ptr, .size = self.size}; }
   }
 
+  impl as IndexWith(i32) where .ElementType = Char {
+    fn At[self: Self](subscript: i32) -> Char {
+      return StringAt(self, subscript);
+    }
+  }
   // TODO: This should be an array iterator.
   private var ptr: Char*;
   // TODO: This should be a word-sized integer.
   private var size: u64;
 }
+
+fn StringAt(s: String, index: i32) -> Char = "string.at";

toolchain/check/eval.cpp

@@ -1689,6 +1689,76 @@ static auto MakeConstantForBuiltinCall(EvalContext& eval_context,
 
     case SemIR::BuiltinFunctionKind::PrintChar:
     case SemIR::BuiltinFunctionKind::PrintInt:
+    case SemIR::BuiltinFunctionKind::StringAt:{
+      //We need both the string and index to be constant
+      Phase phase = Phase::Concrete;
+      auto str_id = GetConstantValue(eval_context, arg_ids[0], &phase);
+      auto index_id = GetConstantValue(eval_context, arg_ids[1], &phase);
+      //If either isnt constant, we can't evaluate it at compile time
+      if (!str_id.has_value() || !index_id.has_value()) {
+        return MakeNonConstantResult(phase);
+      }
+
+      auto str_struct = eval_context.insts().TryGetAs<SemIR::StructValue>(str_id);
+      if(!str_struct) {
+        return MakeNonConstantResult(phase);
+      }
+
+      auto elements = eval_context.inst_blocks().Get(str_struct->elements_id);
+      if (elements.size() != 2) {
+        return MakeNonConstantResult(phase);
+      }
+
+      auto ptr_const_id = eval_context.constant_values().Get(elements[0]);
+      auto string_literal = eval_context.insts().TryGetAs<SemIR::StringLiteral>(
+        eval_context.constant_values().GetInstId(ptr_const_id));
+      if (!string_literal){
+        return MakeNonConstantResult(phase);
+      }
+      
+      auto string_value = eval_context.sem_ir().string_literal_values().Get(
+        string_literal->string_literal_id);
+      //Get index value
+      auto index_inst = eval_context.insts().TryGetAs<SemIR::IntValue>(index_id);
+      if (!index_inst) {
+        CARBON_CHECK(phase != Phase::Concrete, "Concrete constant integer should be a literal");
+        return MakeNonConstantResult(phase);
+      }
+
+      const auto& index_val = eval_context.ints().Get(index_inst->int_id);
+
+      //Check bounds
+      if (index_val.isNegative()){
+        CARBON_DIAGNOSTIC(ArrayIndexNegative, Error, "index `{0}` is negative",
+                          TypedInt);
+        eval_context.emitter().Emit(
+          eval_context.GetDiagnosticLoc(index_id), ArrayIndexNegative,
+          {.type = eval_context.insts().Get(index_id).type_id(),
+          .value = index_val});
+        return SemIR::ErrorInst::ConstantId;
+      }
+
+      //Check for out of bounds
+      if (index_val.getActiveBits() > 64 ||
+          index_val.getZExtValue() >= string_value.size()) {
+        CARBON_DIAGNOSTIC(ArrayIndexOutOfBounds, Error,
+                          "string index `{0}` is past the end of the string",
+                          TypedInt);
+        eval_context.emitter().Emit(
+            eval_context.GetDiagnosticLoc(index_id), ArrayIndexOutOfBounds,
+            {.type = eval_context.insts().Get(index_id).type_id(),
+             .value = index_val});
+        return SemIR::ErrorInst::ConstantId;
+      }
+
+      auto char_value = static_cast<uint8_t>(string_value[index_val.getZExtValue()]);
+
+      auto int_id = eval_context.ints().Add(llvm::APSInt(llvm::APInt(32, char_value), /*isUnsigned=*/false));
+      return MakeConstantResult(eval_context.context(),
+        SemIR::IntValue{.type_id = call.type_id, .int_id = int_id},
+        phase);
+
+    }
     case SemIR::BuiltinFunctionKind::ReadChar:
     case SemIR::BuiltinFunctionKind::FloatAddAssign:
     case SemIR::BuiltinFunctionKind::FloatSubAssign:

toolchain/diagnostics/diagnostic_kind.def

@@ -397,6 +397,7 @@ CARBON_DIAGNOSTIC_KIND(AddrOnNonSelfParam)
 CARBON_DIAGNOSTIC_KIND(AddrOnNonPointerType)
 CARBON_DIAGNOSTIC_KIND(ArrayBoundTooLarge)
 CARBON_DIAGNOSTIC_KIND(ArrayBoundNegative)
+CARBON_DIAGNOSTIC_KIND(ArrayIndexNegative)
 CARBON_DIAGNOSTIC_KIND(ArrayIndexOutOfBounds)
 CARBON_DIAGNOSTIC_KIND(ArrayInitFromLiteralArgCountMismatch)
 CARBON_DIAGNOSTIC_KIND(ArrayInitFromExprArgCountMismatch)

toolchain/lower/handle_call.cpp

@@ -318,6 +318,49 @@ static auto HandleBuiltinCall(FunctionContext& context, SemIR::InstId inst_id,
       return;
     }
 
+    case SemIR::BuiltinFunctionKind::StringAt: {
+      // Get the string argument  
+      auto string_inst_id = arg_ids[0];
+      auto* string_arg = context.GetValue(string_inst_id);
+      
+      // Check if this is a pointer to a String or a String value
+      // If it's a pointer (from a reference), load it first
+      llvm::Value* string_value;
+      if (string_arg->getType()->isPointerTy()) {
+        // Load the struct from the pointer
+        auto string_type_id = context.GetTypeIdOfInst(string_inst_id);
+        auto* string_type = context.GetType(string_type_id);
+        string_value = context.builder().CreateLoad(
+            string_type, string_arg, "string.load");
+      } else {
+        // Already have the struct value
+        string_value = string_arg;
+      }
+      
+      // String is a struct with ptr and size fields
+      // Extract the pointer field (field 0)
+      auto* string_ptr_field = context.builder().CreateExtractValue(
+          string_value, {0}, "string.ptr");
+      
+      // Get the index value
+      auto* index_value = context.GetValue(arg_ids[1]);
+      
+      // Compute the address of the character at the given index
+      auto* char_ptr = context.builder().CreateInBoundsGEP(
+          llvm::Type::getInt8Ty(context.llvm_context()),
+          string_ptr_field, index_value, "string.char_ptr");
+      
+      // Load the character
+      auto* char_i8 = context.builder().CreateLoad(
+          llvm::Type::getInt8Ty(context.llvm_context()),
+          char_ptr, "string.char");
+      
+      // Extend to i32 (Char type in Carbon)
+      context.SetLocal(inst_id, context.builder().CreateZExt(
+          char_i8, context.GetTypeOfInst(inst_id), "string.char.zext"));
+      return;
+    }
+
     case SemIR::BuiltinFunctionKind::TypeAnd: {
       context.SetLocal(inst_id, context.GetTypeAsValue());
       return;

toolchain/sem_ir/builtin_function_kind.cpp

@@ -322,6 +322,10 @@ constexpr BuiltinInfo PrintInt = {
 constexpr BuiltinInfo ReadChar = {"read.char",
                                   ValidateSignature<auto()->AnySizedInt>};
 
+// Gets a character from a string at the given index.
+constexpr BuiltinInfo StringAt = {
+    "string.at", ValidateSignature<auto(AnyType, AnySizedInt)->AnySizedInt>};
+
 // Returns the `Core.CharLiteral` type.
 constexpr BuiltinInfo CharLiteralMakeType = {"char_literal.make_type",
                                              ValidateSignature<auto()->Type>};

toolchain/sem_ir/builtin_function_kind.def

@@ -30,6 +30,7 @@ CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(PrimitiveCopy)
 CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(PrintChar)
 CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(PrintInt)
 CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(ReadChar)
+CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(StringAt)
 
 // Type factories.
 CARBON_SEM_IR_BUILTIN_FUNCTION_KIND(CharLiteralMakeType)