Change the return type of Ty::kind from TyKind to &TyKind.

This is valid because `TyKind` impls `Copy`, and makes `Ty` consistent
with `Predicate` and `Region`, both of which have `kind` methods that
return a non-reference.

The change removes more than one thousand `&` and `*` sigils, while
requiring the addition of just five! It's clearly moving with the grain
of the existing code.

Almost all of the removed sigils fit one of the following three
patterns.

- Remove the dereference in the match expression:

    `match *ty.kind() { ... }` ->
    `match ty.kind() { ... }`

- Remove the dereference in the match pattern:

    `match ty.kind() { &ty::Foo(foo) => { ... foo ... }` ->
    `match ty.kind() { ty::Foo(foo) => { ... foo ... }`

- Remove the derefernce in the match arm:

    `match ty.kind() { ty::Foo(foo) => { ... *foo ... }` ->
    `match ty.kind() { ty::Foo(foo) => { ... foo ... }`

A couple of other methods had their signatures changed.
- `TypeErrCtxt::cmp_fn_sig`: `&` removed from two args.
- `EncodableWithShorthand::variant`: `&` removed from return type.

Author: nnethercote

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -721,7 +721,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         // borrowing the type, since `&mut F: FnMut` iff `F: FnMut` and similarly for `Fn`.
         // These types seem reasonably opaque enough that they could be instantiated with their
         // borrowed variants in a function body when we see a move error.
-        let borrow_level = match *ty.kind() {
+        let borrow_level = match ty.kind() {
             ty::Param(_) => tcx
                 .explicit_predicates_of(self.mir_def_id().to_def_id())
                 .predicates
@@ -1210,7 +1210,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         } else if let ty::Param(param) = ty.kind()
             && let Some(_clone_trait_def) = self.infcx.tcx.lang_items().clone_trait()
             && let generics = self.infcx.tcx.generics_of(self.mir_def_id())
-            && let generic_param = generics.type_param(*param, self.infcx.tcx)
+            && let generic_param = generics.type_param(param, self.infcx.tcx)
             && let param_span = self.infcx.tcx.def_span(generic_param.def_id)
             && if let Some(UseSpans::FnSelfUse { kind, .. }) = use_spans
                 && let CallKind::FnCall { fn_trait_id, self_ty } = kind
@@ -1358,7 +1358,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             .into_iter()
             .map(|err| match err.obligation.predicate.kind().skip_binder() {
                 PredicateKind::Clause(ty::ClauseKind::Trait(predicate)) => {
-                    match *predicate.self_ty().kind() {
+                    match predicate.self_ty().kind() {
                         ty::Param(param_ty) => Ok((
                             generics.type_param(param_ty, tcx),
                             predicate.trait_ref.print_trait_sugared().to_string(),

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -317,40 +317,37 @@ impl<'tcx> BorrowExplanation<'tcx> {
             let mut has_dyn = false;
             let mut failed = false;
 
-            let elaborated_args =
-                std::iter::zip(*args, &generics.own_params).map(|(arg, param)| {
-                    if let Some(ty::Dynamic(obj, _, ty::Dyn)) = arg.as_type().map(Ty::kind) {
-                        let default = tcx.object_lifetime_default(param.def_id);
-
-                        let re_static = tcx.lifetimes.re_static;
-
-                        let implied_region = match default {
-                            // This is not entirely precise.
-                            ObjectLifetimeDefault::Empty => re_static,
-                            ObjectLifetimeDefault::Ambiguous => {
+            let elaborated_args = std::iter::zip(args, &generics.own_params).map(|(arg, param)| {
+                if let Some(ty::Dynamic(obj, _, ty::Dyn)) = arg.as_type().map(Ty::kind) {
+                    let default = tcx.object_lifetime_default(param.def_id);
+
+                    let re_static = tcx.lifetimes.re_static;
+
+                    let implied_region = match default {
+                        // This is not entirely precise.
+                        ObjectLifetimeDefault::Empty => re_static,
+                        ObjectLifetimeDefault::Ambiguous => {
+                            failed = true;
+                            re_static
+                        }
+                        ObjectLifetimeDefault::Param(param_def_id) => {
+                            let index = generics.param_def_id_to_index[&param_def_id] as usize;
+                            args.get(index).and_then(|arg| arg.as_region()).unwrap_or_else(|| {
                                 failed = true;
                                 re_static
-                            }
-                            ObjectLifetimeDefault::Param(param_def_id) => {
-                                let index = generics.param_def_id_to_index[&param_def_id] as usize;
-                                args.get(index).and_then(|arg| arg.as_region()).unwrap_or_else(
-                                    || {
-                                        failed = true;
-                                        re_static
-                                    },
-                                )
-                            }
-                            ObjectLifetimeDefault::Static => re_static,
-                        };
+                            })
+                        }
+                        ObjectLifetimeDefault::Static => re_static,
+                    };
 
-                        has_dyn = true;
+                    has_dyn = true;
 
-                        Ty::new_dynamic(tcx, obj, implied_region, ty::Dyn).into()
-                    } else {
-                        arg
-                    }
-                });
-            let elaborated_ty = Ty::new_adt(tcx, *def, tcx.mk_args_from_iter(elaborated_args));
+                    Ty::new_dynamic(tcx, obj, implied_region, ty::Dyn).into()
+                } else {
+                    arg
+                }
+            });
+            let elaborated_ty = Ty::new_adt(tcx, def, tcx.mk_args_from_iter(elaborated_args));
 
             if has_dyn && !failed {
                 err.note(format!(