Add Copy interface and use it for making copies. (#6034)

Instead of hardcoding which types are copyable, add a `Core.Copy`
interface to perform copying. Move almost all the current copy support
to that interface. Some remaining pieces are still using builtin logic
after this PR:

* For tuples and structs, builtin logic is used to perform elementwise
copies. This also supports copying *adapters of* tuples and structs,
which seems like it may not be desirable, especially for non-extending
adapters. A `Copy` impl is provided for tuples of at most 2 elements, so
that `Core.Copy` constraints are satisfied, but we can't implement this
generally until we have variadics support, and don't yet have a
mechanism to generalize this to structs.
* For `enum` types imported from C++, builtin logic is used to perform a
copy. This is temporary until we have a mechanism to identify these
types from an impl in the prelude.

One lowering test in `toolchain/lower/testdata/class/generic.carbon` is
disabled for now, as it causes a crash in the lowering code due to an
ABI mismatch between the call signature in the lowered declaration of a
specific function and the call that is generated in the specific callee.
Fixing this is a little involved, and will be done in a separate PR.

---------

Co-authored-by: Geoff Romer <[email protected]>

Author: zygoloid

core/prelude.carbon

@@ -6,6 +6,7 @@
 
 package Core library "prelude";
 
+export import library "prelude/copy";
 export import library "prelude/destroy";
 export import library "prelude/iterate";
 export import library "prelude/operators";

core/prelude/copy.carbon

@@ -0,0 +1,57 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+package Core library "prelude/copy";
+
+// Copying an object, which is a conversion from a value representation to an
+// initializing representation.
+interface Copy {
+  fn Op[self: Self]() -> Self;
+}
+
+private fn Bool() -> type = "bool.make_type";
+private fn CharLiteral() -> type = "char_literal.make_type";
+private fn FloatLiteral() -> type = "float_literal.make_type";
+private fn IntLiteral() -> type = "int_literal.make_type";
+
+impl Bool() as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
+impl CharLiteral() as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
+impl FloatLiteral() as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
+impl IntLiteral() as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
+impl type as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
+impl forall [T:! type] T* as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
+// TODO: Implement tuple copy as a variadic generic impl.
+impl () as Copy {
+  fn Op[self: Self]() -> Self = "no_op";
+}
+
+impl forall [T:! Copy] (T,) as Copy {
+  fn Op[self: Self]() -> Self {
+    return (self.0.Op(),);
+  }
+}
+
+impl forall [T:! Copy, U:! Copy] (T, U) as Copy {
+  fn Op[self: Self]() -> Self {
+    return (self.0.Op(), self.1.Op());
+  }
+}

core/prelude/iterate.carbon

@@ -4,18 +4,20 @@
 
 package Core library "prelude/iterate";
 
+export import library "prelude/copy";
 export import library "prelude/destroy";
 export import library "prelude/types";
 export import library "prelude/operators";
 
 interface Iterate {
-  let ElementType:! type;
+  // TODO: Support iterating ranges of non-copyable values.
+  let ElementType:! Copy;
   let CursorType:! type;
   fn NewCursor[self: Self]() -> CursorType;
   fn Next[self: Self](cursor: CursorType*) -> Optional(ElementType);
 }
 
-impl forall [T:! type, N:! IntLiteral()]
+impl forall [T:! Copy, N:! IntLiteral()]
     array(T, N) as Iterate
     where .ElementType = T and .CursorType = i32 {
   fn NewCursor[self: Self]() -> i32 { return 0; }

core/prelude/types/char.carbon

@@ -4,6 +4,7 @@
 
 package Core library "prelude/types/char";
 
+import library "prelude/copy";
 import library "prelude/destroy";
 import library "prelude/operators";
 import library "prelude/types/uint";
@@ -14,6 +15,10 @@ class Char {
   adapt u8;
 }
 
+impl Char as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
 impl CharLiteral() as ImplicitAs(Char) {
   fn Convert[self: Self]() -> Char = "char.convert_checked";
 }

core/prelude/types/float.carbon

@@ -4,6 +4,7 @@
 
 package Core library "prelude/types/float";
 
+import library "prelude/copy";
 import library "prelude/destroy";
 import library "prelude/operators";
 import library "prelude/types/float_literal";
@@ -15,6 +16,12 @@ class Float(N:! IntLiteral()) {
   adapt MakeFloat(N);
 }
 
+// Copy.
+
+impl forall [N:! IntLiteral()] Float(N) as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
 // Conversions.
 // TODO: Support mixed-size conversions.
 // TODO: Support int-to-float conversions.

core/prelude/types/int.carbon

@@ -4,6 +4,7 @@
 
 package Core library "prelude/types/int";
 
+import library "prelude/copy";
 import library "prelude/destroy";
 import library "prelude/operators";
 import library "prelude/types/int_literal";
@@ -14,6 +15,12 @@ class Int(N:! IntLiteral()) {
   adapt MakeInt(N);
 }
 
+// Copy.
+
+impl forall [N:! IntLiteral()] Int(N) as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
 // Conversions.
 
 impl forall [To:! IntLiteral()] IntLiteral() as ImplicitAs(Int(To)) {

core/prelude/types/optional.carbon

@@ -4,6 +4,7 @@
 
 package Core library "prelude/types/optional";
 
+import library "prelude/copy";
 import library "prelude/destroy";
 import library "prelude/types/bool";
 
@@ -15,7 +16,7 @@ import library "prelude/types/bool";
 //
 // TODO: We don't have an approved design for an `Optional` type yet, but it's
 // used by the design for `Iterate`. The API here is a placeholder.
-class Optional(T:! type) {
+class Optional(T:! Copy) {
   fn None() -> Self {
     returned var me: Self;
     me.has_value = false;

core/prelude/types/uint.carbon

@@ -4,6 +4,7 @@
 
 package Core library "prelude/types/uint";
 
+import library "prelude/copy";
 import library "prelude/destroy";
 import library "prelude/operators";
 import library "prelude/types/int";
@@ -15,6 +16,12 @@ class UInt(N:! IntLiteral()) {
   adapt MakeUInt(N);
 }
 
+// Copy.
+
+impl forall [N:! IntLiteral()] UInt(N) as Copy {
+  fn Op[self: Self]() -> Self = "primitive_copy";
+}
+
 // Conversions.
 
 impl forall [To:! IntLiteral()] IntLiteral() as ImplicitAs(UInt(To)) {

toolchain/check/convert.cpp

@@ -1266,30 +1266,40 @@ static auto PerformBuiltinConversion(
   return value_id;
 }
 
+// Determine whether this is a C++ enum type.
+// TODO: This should be removed once we can properly add a `Copy` impl for C++
+// enum types.
+static auto IsCppEnum(Context& context, SemIR::TypeId type_id) -> bool {
+  auto class_type = context.types().TryGetAs<SemIR::ClassType>(type_id);
+  if (!class_type) {
+    return false;
+  }
+
+  // A C++-imported class type that is an adapter is an enum.
+  auto& class_info = context.classes().Get(class_type->class_id);
+  return class_info.adapt_id.has_value() &&
+         context.name_scopes().Get(class_info.scope_id).is_cpp_scope();
+}
+
 // Given a value expression, form a corresponding initializer that copies from
 // that value, if it is possible to do so.
 static auto PerformCopy(Context& context, SemIR::InstId expr_id, bool diagnose)
     -> SemIR::InstId {
-  auto expr = context.insts().Get(expr_id);
-  auto type_id = expr.type_id();
-  if (type_id == SemIR::ErrorInst::TypeId) {
-    return SemIR::ErrorInst::InstId;
+  // TODO: We don't have a mechanism yet to generate `Copy` impls for each enum
+  // type imported from C++. For now we fake it by providing a direct copy.
+  if (IsCppEnum(context, context.insts().Get(expr_id).type_id())) {
+    return CopyValueToTemporary(context, expr_id);
   }
 
-  if (InitReprIsCopyOfValueRepr(context.sem_ir(), type_id)) {
-    // For simple by-value types, no explicit action is required. Initializing
-    // from a value expression is treated as copying the value.
-    return expr_id;
-  }
-
-  // TODO: We don't yet have rules for whether and when a class type is
-  // copyable, or how to perform the copy.
-  if (diagnose) {
-    CARBON_DIAGNOSTIC(CopyOfUncopyableType, Error,
-                      "cannot copy value of type {0}", TypeOfInstId);
-    context.emitter().Emit(expr_id, CopyOfUncopyableType, expr_id);
-  }
-  return SemIR::ErrorInst::InstId;
+  return BuildUnaryOperator(
+      context, SemIR::LocId(expr_id), {"Copy"}, expr_id, [&] {
+        if (!diagnose) {
+          return context.emitter().BuildSuppressed();
+        }
+        CARBON_DIAGNOSTIC(CopyOfUncopyableType, Error,
+                          "cannot copy value of type {0}", TypeOfInstId);
+        return context.emitter().Build(expr_id, CopyOfUncopyableType, expr_id);
+      });
 }
 
 // Convert a value expression so that it can be used to initialize a C++ thunk
@@ -1310,14 +1320,7 @@ static auto ConvertValueForCppThunkRef(Context& context, SemIR::InstId expr_id,
   // Otherwise, we need a temporary to pass as the thunk argument. Create a copy
   // and initialize a temporary from it.
   expr_id = PerformCopy(context, expr_id, diagnose);
-  if (SemIR::GetExprCategory(context.sem_ir(), expr_id) ==
-      SemIR::ExprCategory::Value) {
-    // If we still have a value expression, then it's a value expression
-    // whose value is being used directly to initialize the object. Copy
-    // it into a temporary to form an ephemeral reference.
-    expr_id = CopyValueToTemporary(context, expr_id);
-  }
-  return expr_id;
+  return MaterializeIfInitializing(context, expr_id);
 }
 
 // Returns the Core interface name to use for a given kind of conversion.

toolchain/check/eval.cpp

@@ -1656,6 +1656,10 @@ static auto MakeConstantForBuiltinCall(EvalContext& eval_context,
           phase);
     }
 
+    case SemIR::BuiltinFunctionKind::PrimitiveCopy: {
+      return context.constant_values().Get(arg_ids[0]);
+    }
+
     case SemIR::BuiltinFunctionKind::PrintChar:
     case SemIR::BuiltinFunctionKind::PrintInt:
     case SemIR::BuiltinFunctionKind::ReadChar: