Auto merge of #67540 - Mark-Simulacrum:fmt-the-world, r=Centril

Format the world

This PR modifies the formatting infrastructure a bit in the first commit (to enable the forgotten 2018 edition), as well as removes most directories from the ignore list in rustfmt.toml. It then follows that up with the second commit which runs `x.py fmt` and formats the entire repository.

We continue to not format the test directory (`src/test`) because of interactions with pretty printing and, in part, because re-blessing all of those files is somewhat harder to review, so is best suited for a follow up PR in my opinion.

6 files changed, 123 insertions, 153 deletions

diff --git a/src/librustc_codegen_utils/codegen_backend.rs b/src/librustc_codegen_utils/codegen_backend.rs
index 0e2c3731eae..0737fd6b5ca 100644
--- a/src/librustc_codegen_utils/codegen_backend.rs
+++ b/src/librustc_codegen_utils/codegen_backend.rs
@@ -8,21 +8,23 @@
 
 use std::any::Any;
 
-use syntax::symbol::Symbol;
-use rustc::session::Session;
-use rustc::util::common::ErrorReported;
+use rustc::dep_graph::DepGraph;
+use rustc::middle::cstore::{EncodedMetadata, MetadataLoaderDyn};
 use rustc::session::config::{OutputFilenames, PrintRequest};
-use rustc::ty::TyCtxt;
+use rustc::session::Session;
 use rustc::ty::query::Providers;
-use rustc::middle::cstore::{EncodedMetadata, MetadataLoaderDyn};
-use rustc::dep_graph::DepGraph;
+use rustc::ty::TyCtxt;
+use rustc::util::common::ErrorReported;
+use syntax::symbol::Symbol;
 
 pub use rustc_data_structures::sync::MetadataRef;
 
 pub trait CodegenBackend {
     fn init(&self, _sess: &Session) {}
     fn print(&self, _req: PrintRequest, _sess: &Session) {}
-    fn target_features(&self, _sess: &Session) -> Vec<Symbol> { vec![] }
+    fn target_features(&self, _sess: &Session) -> Vec<Symbol> {
+        vec![]
+    }
     fn print_passes(&self) {}
     fn print_version(&self) {}
 
diff --git a/src/librustc_codegen_utils/lib.rs b/src/librustc_codegen_utils/lib.rs
index fb2099e71a3..578aa591b5c 100644
--- a/src/librustc_codegen_utils/lib.rs
+++ b/src/librustc_codegen_utils/lib.rs
@@ -3,7 +3,6 @@
 //! This API is completely unstable and subject to change.
 
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
-
 #![feature(arbitrary_self_types)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
@@ -11,27 +10,25 @@
 #![feature(never_type)]
 #![feature(nll)]
 #![feature(in_band_lifetimes)]
-
-#![recursion_limit="256"]
+#![recursion_limit = "256"]
 
 #[macro_use]
 extern crate rustc;
 
-use rustc::ty::TyCtxt;
+use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 use rustc::ty::query::Providers;
-use rustc::hir::def_id::{LOCAL_CRATE, DefId};
+use rustc::ty::TyCtxt;
 use syntax::symbol::sym;
 
-pub mod link;
 pub mod codegen_backend;
+pub mod link;
 pub mod symbol_names;
 pub mod symbol_names_test;
 
-
 pub fn trigger_delay_span_bug(tcx: TyCtxt<'_>, key: DefId) {
     tcx.sess.delay_span_bug(
         tcx.def_span(key),
-        "delayed span bug triggered by #[rustc_error(delay_span_bug_from_inside_query)]"
+        "delayed span bug triggered by #[rustc_error(delay_span_bug_from_inside_query)]",
     );
 }
 
@@ -48,8 +45,8 @@ pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_>) {
                     // check if there is a #[rustc_error(delayed)]
                     Some(list) => {
                         if list.iter().any(|list_item| {
-                            list_item.ident().map(|i| i.name) ==
-                                Some(sym::delay_span_bug_from_inside_query)
+                            list_item.ident().map(|i| i.name)
+                                == Some(sym::delay_span_bug_from_inside_query)
                         }) {
                             tcx.ensure().trigger_delay_span_bug(def_id);
                         }
@@ -58,7 +55,7 @@ pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_>) {
                     None => {
                         tcx.sess.span_fatal(
                             tcx.def_span(def_id),
-                            "fatal error triggered by #[rustc_error]"
+                            "fatal error triggered by #[rustc_error]",
                         );
                     }
                 }
@@ -69,8 +66,5 @@ pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_>) {
 
 pub fn provide(providers: &mut Providers<'_>) {
     crate::symbol_names::provide(providers);
-    *providers = Providers {
-        trigger_delay_span_bug,
-        ..*providers
-    };
+    *providers = Providers { trigger_delay_span_bug, ..*providers };
 }
diff --git a/src/librustc_codegen_utils/link.rs b/src/librustc_codegen_utils/link.rs
index 6b9258c32e7..89a68d775f2 100644
--- a/src/librustc_codegen_utils/link.rs
+++ b/src/librustc_codegen_utils/link.rs
@@ -1,20 +1,23 @@
-use rustc::session::config::{self, OutputFilenames, Input, OutputType};
+use rustc::session::config::{self, Input, OutputFilenames, OutputType};
 use rustc::session::Session;
 use std::path::{Path, PathBuf};
-use syntax::{ast, attr};
 use syntax::symbol::sym;
+use syntax::{ast, attr};
 use syntax_pos::Span;
 
-pub fn out_filename(sess: &Session,
-                crate_type: config::CrateType,
-                outputs: &OutputFilenames,
-                crate_name: &str)
-                -> PathBuf {
+pub fn out_filename(
+    sess: &Session,
+    crate_type: config::CrateType,
+    outputs: &OutputFilenames,
+    crate_name: &str,
+) -> PathBuf {
     let default_filename = filename_for_input(sess, crate_type, crate_name, outputs);
-    let out_filename = outputs.outputs.get(&OutputType::Exe)
-                              .and_then(|s| s.to_owned())
-                              .or_else(|| outputs.single_output_file.clone())
-                              .unwrap_or(default_filename);
+    let out_filename = outputs
+        .outputs
+        .get(&OutputType::Exe)
+        .and_then(|s| s.to_owned())
+        .or_else(|| outputs.single_output_file.clone())
+        .unwrap_or(default_filename);
 
     check_file_is_writeable(&out_filename, sess);
 
@@ -26,21 +29,22 @@ pub fn out_filename(sess: &Session,
 // read-only file.  We should be consistent.
 pub fn check_file_is_writeable(file: &Path, sess: &Session) {
     if !is_writeable(file) {
-        sess.fatal(&format!("output file {} is not writeable -- check its \
-                            permissions", file.display()));
+        sess.fatal(&format!(
+            "output file {} is not writeable -- check its \
+                            permissions",
+            file.display()
+        ));
     }
 }
 
 fn is_writeable(p: &Path) -> bool {
     match p.metadata() {
         Err(..) => true,
-        Ok(m) => !m.permissions().readonly()
+        Ok(m) => !m.permissions().readonly(),
     }
 }
 
-pub fn find_crate_name(sess: Option<&Session>,
-                       attrs: &[ast::Attribute],
-                       input: &Input) -> String {
+pub fn find_crate_name(sess: Option<&Session>, attrs: &[ast::Attribute], input: &Input) -> String {
     let validate = |s: String, span: Option<Span>| {
         rustc_metadata::validate_crate_name(sess, &s, span);
         s
@@ -50,16 +54,18 @@ pub fn find_crate_name(sess: Option<&Session>,
     // as used. After doing this, however, we still prioritize a crate name from
     // the command line over one found in the #[crate_name] attribute. If we
     // find both we ensure that they're the same later on as well.
-    let attr_crate_name = attr::find_by_name(attrs, sym::crate_name)
-        .and_then(|at| at.value_str().map(|s| (at, s)));
+    let attr_crate_name =
+        attr::find_by_name(attrs, sym::crate_name).and_then(|at| at.value_str().map(|s| (at, s)));
 
     if let Some(sess) = sess {
         if let Some(ref s) = sess.opts.crate_name {
             if let Some((attr, name)) = attr_crate_name {
                 if name.as_str() != *s {
-                    let msg = format!("`--crate-name` and `#[crate_name]` are \
+                    let msg = format!(
+                        "`--crate-name` and `#[crate_name]` are \
                                        required to match, but `{}` != `{}`",
-                                      s, name);
+                        s, name
+                    );
                     sess.span_err(attr.span, &msg);
                 }
             }
@@ -73,8 +79,11 @@ pub fn find_crate_name(sess: Option<&Session>,
     if let Input::File(ref path) = *input {
         if let Some(s) = path.file_stem().and_then(|s| s.to_str()) {
             if s.starts_with("-") {
-                let msg = format!("crate names cannot start with a `-`, but \
-                                   `{}` has a leading hyphen", s);
+                let msg = format!(
+                    "crate names cannot start with a `-`, but \
+                                   `{}` has a leading hyphen",
+                    s
+                );
                 if let Some(sess) = sess {
                     sess.err(&msg);
                 }
@@ -87,12 +96,16 @@ pub fn find_crate_name(sess: Option<&Session>,
     "rust_out".to_string()
 }
 
-pub fn filename_for_metadata(sess: &Session,
-                             crate_name: &str,
-                             outputs: &OutputFilenames) -> PathBuf {
+pub fn filename_for_metadata(
+    sess: &Session,
+    crate_name: &str,
+    outputs: &OutputFilenames,
+) -> PathBuf {
     let libname = format!("{}{}", crate_name, sess.opts.cg.extra_filename);
 
-    let out_filename = outputs.single_output_file.clone()
+    let out_filename = outputs
+        .single_output_file
+        .clone()
         .unwrap_or_else(|| outputs.out_directory.join(&format!("lib{}.rmeta", libname)));
 
     check_file_is_writeable(&out_filename, sess);
@@ -100,38 +113,32 @@ pub fn filename_for_metadata(sess: &Session,
     out_filename
 }
 
-pub fn filename_for_input(sess: &Session,
-                          crate_type: config::CrateType,
-                          crate_name: &str,
-                          outputs: &OutputFilenames) -> PathBuf {
+pub fn filename_for_input(
+    sess: &Session,
+    crate_type: config::CrateType,
+    crate_name: &str,
+    outputs: &OutputFilenames,
+) -> PathBuf {
     let libname = format!("{}{}", crate_name, sess.opts.cg.extra_filename);
 
     match crate_type {
-        config::CrateType::Rlib => {
-            outputs.out_directory.join(&format!("lib{}.rlib", libname))
-        }
-        config::CrateType::Cdylib |
-        config::CrateType::ProcMacro |
-        config::CrateType::Dylib => {
-            let (prefix, suffix) = (&sess.target.target.options.dll_prefix,
-                                    &sess.target.target.options.dll_suffix);
-            outputs.out_directory.join(&format!("{}{}{}", prefix, libname,
-                                                suffix))
+        config::CrateType::Rlib => outputs.out_directory.join(&format!("lib{}.rlib", libname)),
+        config::CrateType::Cdylib | config::CrateType::ProcMacro | config::CrateType::Dylib => {
+            let (prefix, suffix) =
+                (&sess.target.target.options.dll_prefix, &sess.target.target.options.dll_suffix);
+            outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix))
         }
         config::CrateType::Staticlib => {
-            let (prefix, suffix) = (&sess.target.target.options.staticlib_prefix,
-                                    &sess.target.target.options.staticlib_suffix);
-            outputs.out_directory.join(&format!("{}{}{}", prefix, libname,
-                                                suffix))
+            let (prefix, suffix) = (
+                &sess.target.target.options.staticlib_prefix,
+                &sess.target.target.options.staticlib_suffix,
+            );
+            outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix))
         }
         config::CrateType::Executable => {
             let suffix = &sess.target.target.options.exe_suffix;
             let out_filename = outputs.path(OutputType::Exe);
-            if suffix.is_empty() {
-                out_filename
-            } else {
-                out_filename.with_extension(&suffix[1..])
-            }
+            if suffix.is_empty() { out_filename } else { out_filename.with_extension(&suffix[1..]) }
         }
     }
 }
@@ -154,17 +161,14 @@ pub fn default_output_for_target(sess: &Session) -> config::CrateType {
 }
 
 /// Checks if target supports crate_type as output
-pub fn invalid_output_for_target(sess: &Session,
-                                 crate_type: config::CrateType) -> bool {
+pub fn invalid_output_for_target(sess: &Session, crate_type: config::CrateType) -> bool {
     match crate_type {
-        config::CrateType::Cdylib |
-        config::CrateType::Dylib |
-        config::CrateType::ProcMacro => {
+        config::CrateType::Cdylib | config::CrateType::Dylib | config::CrateType::ProcMacro => {
             if !sess.target.target.options.dynamic_linking {
-                return true
+                return true;
             }
             if sess.crt_static() && !sess.target.target.options.crt_static_allows_dylibs {
-                return true
+                return true;
             }
         }
         _ => {}
@@ -177,7 +181,7 @@ pub fn invalid_output_for_target(sess: &Session,
     }
     if !sess.target.target.options.executables {
         if crate_type == config::CrateType::Executable {
-            return true
+            return true;
         }
     }
 
diff --git a/src/librustc_codegen_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs
index 922964ee45f..bd714f5c6b7 100644
--- a/src/librustc_codegen_utils/symbol_names.rs
+++ b/src/librustc_codegen_utils/symbol_names.rs
@@ -88,12 +88,12 @@
 //! DefPaths which are much more robust in the face of changes to the code base.
 
 use rustc::hir::def_id::LOCAL_CRATE;
-use rustc::hir::Node;
 use rustc::hir::CodegenFnAttrFlags;
+use rustc::hir::Node;
+use rustc::mir::mono::{InstantiationMode, MonoItem};
 use rustc::session::config::SymbolManglingVersion;
 use rustc::ty::query::Providers;
-use rustc::ty::{self, TyCtxt, Instance};
-use rustc::mir::mono::{MonoItem, InstantiationMode};
+use rustc::ty::{self, Instance, TyCtxt};
 
 use syntax_pos::symbol::Symbol;
 
@@ -104,9 +104,7 @@ mod v0;
 
 pub fn provide(providers: &mut Providers<'_>) {
     *providers = Providers {
-        symbol_name: |tcx, instance| ty::SymbolName {
-            name: symbol_name(tcx, instance),
-        },
+        symbol_name: |tcx, instance| ty::SymbolName { name: symbol_name(tcx, instance) },
 
         ..*providers
     };
@@ -160,8 +158,8 @@ fn symbol_name(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Symbol {
     //
     // [1]: https://bugs.llvm.org/show_bug.cgi?id=44316
     if is_foreign {
-        if tcx.sess.target.target.arch != "wasm32" ||
-            !tcx.wasm_import_module_map(def_id.krate).contains_key(&def_id)
+        if tcx.sess.target.target.arch != "wasm32"
+            || !tcx.wasm_import_module_map(def_id.krate).contains_key(&def_id)
         {
             if let Some(name) = attrs.link_name {
                 return name;
diff --git a/src/librustc_codegen_utils/symbol_names/legacy.rs b/src/librustc_codegen_utils/symbol_names/legacy.rs
index 1597f98771c..29869a1dae4 100644
--- a/src/librustc_codegen_utils/symbol_names/legacy.rs
+++ b/src/librustc_codegen_utils/symbol_names/legacy.rs
@@ -2,9 +2,9 @@ use rustc::hir::def_id::CrateNum;
 use rustc::hir::map::{DefPathData, DisambiguatedDefPathData};
 use rustc::ich::NodeIdHashingMode;
 use rustc::mir::interpret::{ConstValue, Scalar};
-use rustc::ty::print::{PrettyPrinter, Printer, Print};
+use rustc::ty::print::{PrettyPrinter, Print, Printer};
 use rustc::ty::subst::{GenericArg, GenericArgKind};
-use rustc::ty::{self, Ty, TyCtxt, TypeFoldable, Instance};
+use rustc::ty::{self, Instance, Ty, TyCtxt, TypeFoldable};
 use rustc::util::common::record_time;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 
@@ -55,11 +55,9 @@ pub(super) fn mangle(
 
     let hash = get_symbol_hash(tcx, instance, instance_ty, instantiating_crate);
 
-    let mut printer = SymbolPrinter {
-        tcx,
-        path: SymbolPath::new(),
-        keep_within_component: false,
-    }.print_def_path(def_id, &[]).unwrap();
+    let mut printer = SymbolPrinter { tcx, path: SymbolPath::new(), keep_within_component: false }
+        .print_def_path(def_id, &[])
+        .unwrap();
 
     if instance.is_vtable_shim() {
         let _ = printer.write_str("{{vtable-shim}}");
@@ -84,10 +82,7 @@ fn get_symbol_hash<'tcx>(
 ) -> u64 {
     let def_id = instance.def_id();
     let substs = instance.substs;
-    debug!(
-        "get_symbol_hash(def_id={:?}, parameters={:?})",
-        def_id, substs
-    );
+    debug!("get_symbol_hash(def_id={:?}, parameters={:?})", def_id, substs);
 
     let mut hasher = StableHasher::new();
     let mut hcx = tcx.create_stable_hashing_context();
@@ -121,10 +116,10 @@ fn get_symbol_hash<'tcx>(
         substs.hash_stable(&mut hcx, &mut hasher);
 
         if let Some(instantiating_crate) = instantiating_crate {
-            tcx.original_crate_name(instantiating_crate).as_str()
-                .hash_stable(&mut hcx, &mut hasher);
-            tcx.crate_disambiguator(instantiating_crate)
+            tcx.original_crate_name(instantiating_crate)
+                .as_str()
                 .hash_stable(&mut hcx, &mut hasher);
+            tcx.crate_disambiguator(instantiating_crate).hash_stable(&mut hcx, &mut hasher);
         }
 
         // We want to avoid accidental collision between different types of instances.
@@ -157,10 +152,8 @@ struct SymbolPath {
 
 impl SymbolPath {
     fn new() -> Self {
-        let mut result = SymbolPath {
-            result: String::with_capacity(64),
-            temp_buf: String::with_capacity(16),
-        };
+        let mut result =
+            SymbolPath { result: String::with_capacity(64), temp_buf: String::with_capacity(16) };
         result.result.push_str("_ZN"); // _Z == Begin name-sequence, N == nested
         result
     }
@@ -208,27 +201,19 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
         self.tcx
     }
 
-    fn print_region(
-        self,
-        _region: ty::Region<'_>,
-    ) -> Result<Self::Region, Self::Error> {
+    fn print_region(self, _region: ty::Region<'_>) -> Result<Self::Region, Self::Error> {
         Ok(self)
     }
 
-    fn print_type(
-        self,
-        ty: Ty<'tcx>,
-    ) -> Result<Self::Type, Self::Error> {
+    fn print_type(self, ty: Ty<'tcx>) -> Result<Self::Type, Self::Error> {
         match ty.kind {
             // Print all nominal types as paths (unlike `pretty_print_type`).
-            ty::FnDef(def_id, substs) |
-            ty::Opaque(def_id, substs) |
-            ty::Projection(ty::ProjectionTy { item_def_id: def_id, substs }) |
-            ty::UnnormalizedProjection(ty::ProjectionTy { item_def_id: def_id, substs }) |
-            ty::Closure(def_id, substs) |
-            ty::Generator(def_id, substs, _) => {
-                self.print_def_path(def_id, substs)
-            }
+            ty::FnDef(def_id, substs)
+            | ty::Opaque(def_id, substs)
+            | ty::Projection(ty::ProjectionTy { item_def_id: def_id, substs })
+            | ty::UnnormalizedProjection(ty::ProjectionTy { item_def_id: def_id, substs })
+            | ty::Closure(def_id, substs)
+            | ty::Generator(def_id, substs, _) => self.print_def_path(def_id, substs),
             _ => self.pretty_print_type(ty),
         }
     }
@@ -248,10 +233,7 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
         Ok(self)
     }
 
-    fn print_const(
-        mut self,
-        ct: &'tcx ty::Const<'tcx>,
-    ) -> Result<Self::Const, Self::Error> {
+    fn print_const(mut self, ct: &'tcx ty::Const<'tcx>) -> Result<Self::Const, Self::Error> {
         // only print integers
         if let ty::ConstKind::Value(ConstValue::Scalar(Scalar::Raw { .. })) = ct.val {
             if ct.ty.is_integral() {
@@ -262,10 +244,7 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
         Ok(self)
     }
 
-    fn path_crate(
-        mut self,
-        cnum: CrateNum,
-    ) -> Result<Self::Path, Self::Error> {
+    fn path_crate(mut self, cnum: CrateNum) -> Result<Self::Path, Self::Error> {
         self.write_str(&self.tcx.original_crate_name(cnum).as_str())?;
         Ok(self)
     }
@@ -277,18 +256,18 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
         // Similar to `pretty_path_qualified`, but for the other
         // types that are printed as paths (see `print_type` above).
         match self_ty.kind {
-            ty::FnDef(..) |
-            ty::Opaque(..) |
-            ty::Projection(_) |
-            ty::UnnormalizedProjection(_) |
-            ty::Closure(..) |
-            ty::Generator(..)
+            ty::FnDef(..)
+            | ty::Opaque(..)
+            | ty::Projection(_)
+            | ty::UnnormalizedProjection(_)
+            | ty::Closure(..)
+            | ty::Generator(..)
                 if trait_ref.is_none() =>
             {
                 self.print_type(self_ty)
             }
 
-            _ => self.pretty_path_qualified(self_ty, trait_ref)
+            _ => self.pretty_path_qualified(self_ty, trait_ref),
         }
     }
 
@@ -343,14 +322,12 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
         mut self,
         print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
         args: &[GenericArg<'tcx>],
-    )  -> Result<Self::Path, Self::Error> {
+    ) -> Result<Self::Path, Self::Error> {
         self = print_prefix(self)?;
 
-        let args = args.iter().cloned().filter(|arg| {
-            match arg.unpack() {
-                GenericArgKind::Lifetime(_) => false,
-                _ => true,
-            }
+        let args = args.iter().cloned().filter(|arg| match arg.unpack() {
+            GenericArgKind::Lifetime(_) => false,
+            _ => true,
         });
 
         if args.clone().next().is_some() {
@@ -362,10 +339,7 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
 }
 
 impl PrettyPrinter<'tcx> for SymbolPrinter<'tcx> {
-    fn region_should_not_be_omitted(
-        &self,
-        _region: ty::Region<'_>,
-    ) -> bool {
+    fn region_should_not_be_omitted(&self, _region: ty::Region<'_>) -> bool {
         false
     }
     fn comma_sep<T>(mut self, mut elems: impl Iterator<Item = T>) -> Result<Self, Self::Error>
@@ -388,8 +362,7 @@ impl PrettyPrinter<'tcx> for SymbolPrinter<'tcx> {
     ) -> Result<Self, Self::Error> {
         write!(self, "<")?;
 
-        let kept_within_component =
-            mem::replace(&mut self.keep_within_component, true);
+        let kept_within_component = mem::replace(&mut self.keep_within_component, true);
         self = f(self)?;
         self.keep_within_component = kept_within_component;
 
diff --git a/src/librustc_codegen_utils/symbol_names_test.rs b/src/librustc_codegen_utils/symbol_names_test.rs
index 893aea16fd2..7cb3050576c 100644
--- a/src/librustc_codegen_utils/symbol_names_test.rs
+++ b/src/librustc_codegen_utils/symbol_names_test.rs
@@ -5,8 +5,8 @@
 //! paths etc in all kinds of annoying scenarios.
 
 use rustc::hir;
-use rustc::ty::{TyCtxt, Instance};
-use syntax::symbol::{Symbol, sym};
+use rustc::ty::{Instance, TyCtxt};
+use syntax::symbol::{sym, Symbol};
 
 const SYMBOL_NAME: Symbol = sym::rustc_symbol_name;
 const DEF_PATH: Symbol = sym::rustc_def_path;
@@ -30,8 +30,7 @@ struct SymbolNamesTest<'tcx> {
 }
 
 impl SymbolNamesTest<'tcx> {
-    fn process_attrs(&mut self,
-                     hir_id: hir::HirId) {
+    fn process_attrs(&mut self, hir_id: hir::HirId) {
         let tcx = self.tcx;
         let def_id = tcx.hir().local_def_id(hir_id);
         for attr in tcx.get_attrs(def_id).iter() {