automatically implement TrivialClone for closures and tuples

If each of the component types is `TrivialClone`, the closure/tuple itself can be trivially cloned.

Author: joboet

compiler/rustc_hir/src/lang_items.rs

@@ -172,6 +172,7 @@ language_item_table! {
     Clone,                   sym::clone,               clone_trait,                Target::Trait,          GenericRequirement::None;
     CloneFn,                 sym::clone_fn,            clone_fn,                   Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
     UseCloned,               sym::use_cloned,          use_cloned_trait,           Target::Trait,          GenericRequirement::None;
+    TrivialClone,            sym::trivial_clone,       trivial_clone_trait,        Target::Trait,          GenericRequirement::None;
     Sync,                    sym::sync,                sync_trait,                 Target::Trait,          GenericRequirement::Exact(0);
     DiscriminantKind,        sym::discriminant_kind,   discriminant_kind_trait,    Target::Trait,          GenericRequirement::None;
     /// The associated item of the `DiscriminantKind` trait.

compiler/rustc_middle/src/ty/context.rs

@@ -719,6 +719,7 @@ bidirectional_lang_item_map! {
     Poll,
     Sized,
     TransmuteTrait,
+    TrivialClone,
     Tuple,
     Unpin,
     Unsize,

compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -397,9 +397,11 @@ where
         } else {
             match cx.as_lang_item(trait_def_id) {
                 Some(TraitSolverLangItem::Sized) => G::consider_builtin_sized_candidate(self, goal),
-                Some(TraitSolverLangItem::Copy | TraitSolverLangItem::Clone) => {
-                    G::consider_builtin_copy_clone_candidate(self, goal)
-                }
+                Some(
+                    TraitSolverLangItem::Copy
+                    | TraitSolverLangItem::Clone
+                    | TraitSolverLangItem::TrivialClone,
+                ) => G::consider_builtin_copy_clone_candidate(self, goal),
                 Some(TraitSolverLangItem::Fn) => {
                     G::consider_builtin_fn_trait_candidates(self, goal, ty::ClosureKind::Fn)
                 }

compiler/rustc_span/src/symbol.rs

@@ -2082,6 +2082,7 @@ symbols! {
         transparent_enums,
         transparent_unions,
         trivial_bounds,
+        trivial_clone,
         truncf128,
         truncf16,
         truncf32,

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -108,7 +108,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     &mut candidates,
                 );
             } else {
-                if tcx.is_lang_item(def_id, LangItem::Clone) {
+                if tcx.is_lang_item(def_id, LangItem::Clone)
+                    || tcx.is_lang_item(def_id, LangItem::TrivialClone)
+                {
                     // Same builtin conditions as `Copy`, i.e., every type which has builtin support
                     // for `Copy` also has builtin support for `Clone`, and tuples/arrays of `Clone`
                     // types have builtin support for `Clone`.

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -261,6 +261,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 self.copy_clone_conditions(obligation)
             } else if tcx.is_lang_item(trait_def, LangItem::Clone) {
                 self.copy_clone_conditions(obligation)
+            } else if tcx.is_lang_item(trait_def, LangItem::TrivialClone) {
+                self.copy_clone_conditions(obligation)
             } else if tcx.is_lang_item(trait_def, LangItem::FusedIterator) {
                 self.fused_iterator_conditions(obligation)
             } else {

compiler/rustc_type_ir/src/lang_items.rs

@@ -36,6 +36,7 @@ pub enum TraitSolverLangItem {
     Poll,
     Sized,
     TransmuteTrait,
+    TrivialClone,
     Tuple,
     Unpin,
     Unsize,

library/core/src/clone.rs

@@ -194,6 +194,7 @@ pub trait Clone: Sized {
     reason = "this isn't part of any API guarantee",
     issue = "none"
 )]
+#[cfg_attr(not(bootstrap), lang = "trivial_clone")]
 // SAFETY:
 // It is sound to specialize on this because the `clone` implementation cannot be
 // lifetime-dependent. Therefore, if `TrivialClone` is implemented for any lifetime,

tests/ui/functions-closures/trivial-clone-closure.rs

@@ -0,0 +1,13 @@
+//@ run-pass
+// Check that closures implement `TrivialClone`.
+
+#![feature(trivial_clone)]
+
+use std::clone::TrivialClone;
+
+fn require_trivial_clone<T: TrivialClone>(_t: T) {}
+
+fn main() {
+    let some_trivial_clone_value = 42i32;
+    require_trivial_clone(move || some_trivial_clone_value);
+}