submodules: update clippy from 1df5766 to a3c77f6

Changes:
````
s/rustfmt-preview/rustfmt/
Swap if branches
Fix c_void false positive caused by libc refactoring
rustup rust-lang/rust#56502 ( .hir -> .hir() )
typo: emum → enum
Fix format.
Add sysroot gettinh code to dogfood tests.
Add sysroot getting code to tests.
Don't try to determine sysroot. rustc_driver will use default value.
Fix suggestion for multiple derefs
Fix `clone_on_copy` not detecting derefs sometimes
````

Author: matthiaskrgr

.travis.yml

@@ -30,7 +30,7 @@ before_install:
 install:
   - |
     if [ -z ${INTEGRATION} ]; then
-      rustup component add rustfmt-preview || cargo install --git https://github.com/rust-lang/rustfmt/ --force
+      rustup component add rustfmt || cargo install --git https://github.com/rust-lang/rustfmt/ --force
       if [ "$TRAVIS_OS_NAME" == "linux" ]; then
         . $HOME/.nvm/nvm.sh
         nvm install stable

clippy_lints/src/arithmetic.rs

@@ -121,11 +121,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
     }
 
     fn check_body(&mut self, cx: &LateContext<'_, '_>, body: &hir::Body) {
-        let body_owner = cx.tcx.hir.body_owner(body.id());
+        let body_owner = cx.tcx.hir().body_owner(body.id());
 
-        match cx.tcx.hir.body_owner_kind(body_owner) {
+        match cx.tcx.hir().body_owner_kind(body_owner) {
             hir::BodyOwnerKind::Static(_) | hir::BodyOwnerKind::Const => {
-                let body_span = cx.tcx.hir.span(body_owner);
+                let body_span = cx.tcx.hir().span(body_owner);
 
                 if let Some(span) = self.const_span {
                     if span.contains(body_span) {
@@ -139,8 +139,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
     }
 
     fn check_body_post(&mut self, cx: &LateContext<'_, '_>, body: &hir::Body) {
-        let body_owner = cx.tcx.hir.body_owner(body.id());
-        let body_span = cx.tcx.hir.span(body_owner);
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_span = cx.tcx.hir().span(body_owner);
 
         if let Some(span) = self.const_span {
             if span.contains(body_span) {

clippy_lints/src/assign_ops.rs

@@ -144,12 +144,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                                             return; // useless if the trait doesn't exist
                                         };
                                         // check that we are not inside an `impl AssignOp` of this exact operation
-                                        let parent_fn = cx.tcx.hir.get_parent(e.id);
-                                        let parent_impl = cx.tcx.hir.get_parent(parent_fn);
+                                        let parent_fn = cx.tcx.hir().get_parent(e.id);
+                                        let parent_impl = cx.tcx.hir().get_parent(parent_fn);
                                         // the crate node is the only one that is not in the map
                                         if_chain! {
                                             if parent_impl != ast::CRATE_NODE_ID;
-                                            if let hir::Node::Item(item) = cx.tcx.hir.get(parent_impl);
+                                            if let hir::Node::Item(item) = cx.tcx.hir().get(parent_impl);
                                             if let hir::ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) =
                                                 item.node;
                                             if trait_ref.path.def.def_id() == trait_id;

clippy_lints/src/attrs.rs

@@ -354,15 +354,15 @@ fn check_clippy_lint_names(cx: &LateContext<'_, '_>, items: &[NestedMetaItem]) {
 
 fn is_relevant_item(tcx: TyCtxt<'_, '_, '_>, item: &Item) -> bool {
     if let ItemKind::Fn(_, _, _, eid) = item.node {
-        is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
+        is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir().body(eid).value)
     } else {
         true
     }
 }
 
 fn is_relevant_impl(tcx: TyCtxt<'_, '_, '_>, item: &ImplItem) -> bool {
     match item.node {
-        ImplItemKind::Method(_, eid) => is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value),
+        ImplItemKind::Method(_, eid) => is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir().body(eid).value),
         _ => false,
     }
 }
@@ -371,7 +371,7 @@ fn is_relevant_trait(tcx: TyCtxt<'_, '_, '_>, item: &TraitItem) -> bool {
     match item.node {
         TraitItemKind::Method(_, TraitMethod::Required(_)) => true,
         TraitItemKind::Method(_, TraitMethod::Provided(eid)) => {
-            is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
+            is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir().body(eid).value)
         },
         _ => false,
     }

clippy_lints/src/block_in_if_condition.rs

@@ -68,7 +68,7 @@ struct ExVisitor<'a, 'tcx: 'a> {
 impl<'a, 'tcx: 'a> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr) {
         if let ExprKind::Closure(_, _, eid, _, _) = expr.node {
-            let body = self.cx.tcx.hir.body(eid);
+            let body = self.cx.tcx.hir().body(eid);
             let ex = &body.value;
             if matches!(ex.node, ExprKind::Block(_, _)) && !in_macro(body.value.span) {
                 self.found_block = Some(ex);

clippy_lints/src/bytecount.rs

@@ -60,7 +60,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
             if filter_args.len() == 2;
             if let ExprKind::Closure(_, _, body_id, _, _) = filter_args[1].node;
             then {
-                let body = cx.tcx.hir.body(body_id);
+                let body = cx.tcx.hir().body(body_id);
                 if_chain! {
                     if body.arguments.len() == 1;
                     if let Some(argname) = get_pat_name(&body.arguments[0].pat);

clippy_lints/src/copy_iterator.rs

@@ -49,7 +49,7 @@ impl LintPass for CopyIterator {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyIterator {
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
         if let ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node {
-            let ty = cx.tcx.type_of(cx.tcx.hir.local_def_id(item.id));
+            let ty = cx.tcx.type_of(cx.tcx.hir().local_def_id(item.id));
 
             if is_copy(cx, ty) && match_path(&trait_ref.path, &paths::ITERATOR) {
                 span_note_and_lint(

clippy_lints/src/cyclomatic_complexity.rs

@@ -130,7 +130,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CyclomaticComplexity {
         span: Span,
         node_id: NodeId,
     ) {
-        let def_id = cx.tcx.hir.local_def_id(node_id);
+        let def_id = cx.tcx.hir().local_def_id(node_id);
         if !cx.tcx.has_attr(def_id, "test") {
             self.check(cx, body, span);
         }

clippy_lints/src/derive.rs

@@ -82,7 +82,7 @@ impl LintPass for Derive {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive {
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
         if let ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node {
-            let ty = cx.tcx.type_of(cx.tcx.hir.local_def_id(item.id));
+            let ty = cx.tcx.type_of(cx.tcx.hir().local_def_id(item.id));
             let is_automatically_derived = is_automatically_derived(&*item.attrs);
 
             check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived);
@@ -129,9 +129,9 @@ fn check_hash_peq<'a, 'tcx>(
                         cx, DERIVE_HASH_XOR_EQ, span,
                         mess,
                         |db| {
-                        if let Some(node_id) = cx.tcx.hir.as_local_node_id(impl_id) {
+                        if let Some(node_id) = cx.tcx.hir().as_local_node_id(impl_id) {
                             db.span_note(
-                                cx.tcx.hir.span(node_id),
+                                cx.tcx.hir().span(node_id),
                                 "`PartialEq` implemented here"
                             );
                         }

clippy_lints/src/empty_enum.rs

@@ -43,7 +43,7 @@ impl LintPass for EmptyEnum {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EmptyEnum {
     fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &Item) {
-        let did = cx.tcx.hir.local_def_id(item.id);
+        let did = cx.tcx.hir().local_def_id(item.id);
         if let ItemKind::Enum(..) = item.node {
             let ty = cx.tcx.type_of(did);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");