Switch the prelude to use ref instead of addr (#6359)

Author: geoffromer

core/prelude/destroy.carbon

@@ -13,13 +13,13 @@ package Core library "prelude/destroy";
 // it does not deallocate memory.
 interface Destroy {
   // TODO: This should be `final fn Op[ref self: Self]() = "type.destroy"`.
-  fn Op[addr self: Self*]();
+  fn Op[ref self: Self]();
 }
 
 // Returns a constraint that matches all types that should have a `Destroy` impl.
 private fn CanDestroy() -> type = "type.can_destroy";
 
 // Destroys an instance of `DestroyT`. This is also used for trivial types.
 final impl forall [DestroyT:! CanDestroy()] DestroyT as Destroy {
-  fn Op[addr self: Self*]() = "type.destroy";
+  fn Op[ref self: Self]() = "type.destroy";
 }

core/prelude/operators/arithmetic.carbon

@@ -26,12 +26,12 @@ interface AddWith(Other:! type) {
 
 // Addition with assignment: `a += b`.
 interface AddAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Increment: `++a`.
 interface Inc {
-  fn Op[addr self: Self*]();
+  fn Op[ref self: Self]();
 }
 
 // Negation: `-a`.
@@ -48,12 +48,12 @@ interface SubWith(Other:! type) {
 
 // Subtraction with assignment: `a -= b`.
 interface SubAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Decrement: `--a`.
 interface Dec {
-  fn Op[addr self: Self*]();
+  fn Op[ref self: Self]();
 }
 
 // Multiplication: `a * b`.
@@ -64,7 +64,7 @@ interface MulWith(Other:! type) {
 
 // Multiplication with assignment: `a *= b`.
 interface MulAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Division: `a / b`.
@@ -75,7 +75,7 @@ interface DivWith(Other:! type) {
 
 // Division with assignment: `a /= b`.
 interface DivAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Modulo: `a % b`.
@@ -86,7 +86,7 @@ interface ModWith(Other:! type) {
 
 // Modulo with assignment: `a %= b`.
 interface ModAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 

core/prelude/operators/bitwise.carbon

@@ -32,7 +32,7 @@ interface BitAndWith(Other:! type) {
 
 // Bitwise AND with assignment: `a &= b`.
 interface BitAndAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Bitwise OR: `a | b`.
@@ -43,7 +43,7 @@ interface BitOrWith(Other:! type) {
 
 // Bitwise OR with assignment: `a |= b`.
 interface BitOrAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Bitwise XOR: `a ^ b`.
@@ -54,7 +54,7 @@ interface BitXorWith(Other:! type) {
 
 // Bitwise XOR with assignment: `a ^= b`.
 interface BitXorAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Left shift: `a << b`.
@@ -65,7 +65,7 @@ interface LeftShiftWith(Other:! type) {
 
 // Left shift with assignment: `a <<= b`.
 interface LeftShiftAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 // Right shift: `a >> b`.
@@ -76,7 +76,7 @@ interface RightShiftWith(Other:! type) {
 
 // Right shift with assignment: `a >>= b`.
 interface RightShiftAssignWith(Other:! type) {
-  fn Op[addr self: Self*](other: Other);
+  fn Op[ref self: Self](other: Other);
 }
 
 

core/prelude/types/float.carbon

@@ -77,20 +77,20 @@ final impl forall [N:! IntLiteral()]
 // Compound assignments.
 final impl forall [N:! IntLiteral()]
     Float(N) as AddAssignWith(Self) {
-  fn Op[addr self: Self*](other: Self) = "float.add_assign";
+  fn Op[ref self: Self](other: Self) = "float.add_assign";
 }
 
 final impl forall [N:! IntLiteral()]
     Float(N) as DivAssignWith(Self) {
-  fn Op[addr self: Self*](other: Self) = "float.div_assign";
+  fn Op[ref self: Self](other: Self) = "float.div_assign";
 }
 
 final impl forall [N:! IntLiteral()]
     Float(N) as MulAssignWith(Self) {
-  fn Op[addr self: Self*](other: Self) = "float.mul_assign";
+  fn Op[ref self: Self](other: Self) = "float.mul_assign";
 }
 
 final impl forall [N:! IntLiteral()]
     Float(N) as SubAssignWith(Self) {
-  fn Op[addr self: Self*](other: Self) = "float.sub_assign";
+  fn Op[ref self: Self](other: Self) = "float.sub_assign";
 }

core/prelude/types/int.carbon

@@ -272,72 +272,72 @@ impl forall [N:! IntLiteral(), T:! ImplicitAs(Int(N))]
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as AddAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.sadd_assign";
+  fn Op[ref self: Self](other: Self) = "int.sadd_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as BitAndAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.and_assign";
+  fn Op[ref self: Self](other: Self) = "int.and_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as BitOrAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.or_assign";
+  fn Op[ref self: Self](other: Self) = "int.or_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as BitXorAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.xor_assign";
+  fn Op[ref self: Self](other: Self) = "int.xor_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as DivAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.sdiv_assign";
+  fn Op[ref self: Self](other: Self) = "int.sdiv_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as LeftShiftAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.left_shift_assign";
+  fn Op[ref self: Self](other: Self) = "int.left_shift_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as ModAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.smod_assign";
+  fn Op[ref self: Self](other: Self) = "int.smod_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as MulAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.smul_assign";
+  fn Op[ref self: Self](other: Self) = "int.smul_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as RightShiftAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.right_shift_assign";
+  fn Op[ref self: Self](other: Self) = "int.right_shift_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(Int(N))]
     Int(N) as SubAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.ssub_assign";
+  fn Op[ref self: Self](other: Self) = "int.ssub_assign";
 }
 
 // Increment and decrement.
 
 // TODO: Add builtins for these to avoid emitting a call.
 
 impl forall [N:! IntLiteral()] Int(N) as Dec {
-  fn Op[addr self: Self*]() {
-    // TODO: `*self -= 1;` should work, but fails because the `impl IntLiteral
+  fn Op[ref self: Self]() {
+    // TODO: `self -= 1;` should work, but fails because the `impl IntLiteral
     // as ImplicitAs(Int(N))` is not final, which causes us to not attempt the
     // conversion from `1` to `Int(N)` until runtime, when we've lost the
     // constant value.
     fn AsInt(n: IntLiteral()) -> Int(N) = "int.convert_checked";
-    *self -= AsInt(1);
+    self -= AsInt(1);
   }
 }
 
 impl forall [N:! IntLiteral()] Int(N) as Inc {
-  fn Op[addr self: Self*]() {
+  fn Op[ref self: Self]() {
     fn AsInt(n: IntLiteral()) -> Int(N) = "int.convert_checked";
-    *self += AsInt(1);
+    self += AsInt(1);
   }
 }

core/prelude/types/uint.carbon

@@ -313,72 +313,72 @@ impl forall [N:! IntLiteral(), T:! ImplicitAs(UInt(N))]
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as AddAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.uadd_assign";
+  fn Op[ref self: Self](other: Self) = "int.uadd_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as BitAndAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.and_assign";
+  fn Op[ref self: Self](other: Self) = "int.and_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as BitOrAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.or_assign";
+  fn Op[ref self: Self](other: Self) = "int.or_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as BitXorAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.xor_assign";
+  fn Op[ref self: Self](other: Self) = "int.xor_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as DivAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.udiv_assign";
+  fn Op[ref self: Self](other: Self) = "int.udiv_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as LeftShiftAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.left_shift_assign";
+  fn Op[ref self: Self](other: Self) = "int.left_shift_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as ModAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.umod_assign";
+  fn Op[ref self: Self](other: Self) = "int.umod_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as MulAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.umul_assign";
+  fn Op[ref self: Self](other: Self) = "int.umul_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as RightShiftAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.right_shift_assign";
+  fn Op[ref self: Self](other: Self) = "int.right_shift_assign";
 }
 
 impl forall [N:! IntLiteral(), U:! ImplicitAs(UInt(N))]
     UInt(N) as SubAssignWith(U) {
-  fn Op[addr self: Self*](other: Self) = "int.usub_assign";
+  fn Op[ref self: Self](other: Self) = "int.usub_assign";
 }
 
 // Increment and decrement.
 
 // TODO: Add builtins for these to avoid emitting a call.
 
 impl forall [N:! IntLiteral()] UInt(N) as Dec {
-  fn Op[addr self: Self*]() {
-    // TODO: `*self -= 1;` should work, but fails because the `impl IntLiteral
+  fn Op[ref self: Self]() {
+    // TODO: `self -= 1;` should work, but fails because the `impl IntLiteral
     // as ImplicitAs(Int(N))` is not final, which causes us to not attempt the
     // conversion from `1` to `Int(N)` until runtime, when we've lost the
     // constant value.
     fn AsUInt(n: IntLiteral()) -> UInt(N) = "int.convert_checked";
-    *self -= AsUInt(1);
+    self -= AsUInt(1);
   }
 }
 
 impl forall [N:! IntLiteral()] UInt(N) as Inc {
-  fn Op[addr self: Self*]() {
+  fn Op[ref self: Self]() {
     fn AsUInt(n: IntLiteral()) -> UInt(N) = "int.convert_checked";
-    *self += AsUInt(1);
+    self += AsUInt(1);
   }
 }

toolchain/check/handle_function.cpp

@@ -616,22 +616,13 @@ static auto IsValidBuiltinDeclaration(Context& context,
     call_params.consume_back();
   }
 
-  // Form the list of parameter types for the declaration.
-  llvm::SmallVector<SemIR::TypeId> param_type_ids;
-  param_type_ids.reserve(call_params.size());
-  for (auto param_id : call_params) {
-    // TODO: We also need to track whether the parameter is declared with
-    // `var`.
-    param_type_ids.push_back(context.insts().Get(param_id).type_id());
-  }
-
   // Get the return type. This is `()` if none was specified.
   auto return_type_id = function.GetDeclaredReturnType(context.sem_ir());
   if (!return_type_id.has_value()) {
     return_type_id = GetTupleType(context, {});
   }
 
-  return builtin_kind.IsValidType(context.sem_ir(), param_type_ids,
+  return builtin_kind.IsValidType(context.sem_ir(), call_params,
                                   return_type_id);
 }