run rustfmt on librustc_llvm folder

srinivasreddy · srinivasreddy · commit 593e1567cac9 · 2016-05-29T14:57:34.000+05:30
diff --git a/src/librustc_llvm/archive_ro.rs b/src/librustc_llvm/archive_ro.rs
@@ -18,7 +18,9 @@ use std::path::Path;
 use std::slice;
 use std::str;
 
-pub struct ArchiveRO { ptr: ArchiveRef }
+pub struct ArchiveRO {
+    ptr: ArchiveRef,
+}
 
 pub struct Iter<'a> {
     archive: &'a ArchiveRO,
@@ -61,11 +63,16 @@ impl ArchiveRO {
         }
     }
 
-    pub fn raw(&self) -> ArchiveRef { self.ptr }
+    pub fn raw(&self) -> ArchiveRef {
+        self.ptr
+    }
 
     pub fn iter(&self) -> Iter {
         unsafe {
-            Iter { ptr: ::LLVMRustArchiveIteratorNew(self.ptr), archive: self }
+            Iter {
+                ptr: ::LLVMRustArchiveIteratorNew(self.ptr),
+                archive: self,
+            }
         }
     }
 }
@@ -86,7 +93,10 @@ impl<'a> Iterator for Iter<'a> {
         if ptr.is_null() {
             ::last_error().map(Err)
         } else {
-            Some(Ok(Child { ptr: ptr, _data: marker::PhantomData }))
+            Some(Ok(Child {
+                ptr: ptr,
+                _data: marker::PhantomData,
+            }))
         }
     }
 }
@@ -107,8 +117,7 @@ impl<'a> Child<'a> {
             if name_ptr.is_null() {
                 None
             } else {
-                let name = slice::from_raw_parts(name_ptr as *const u8,
-                                                 name_len as usize);
+                let name = slice::from_raw_parts(name_ptr as *const u8, name_len as usize);
                 str::from_utf8(name).ok().map(|s| s.trim())
             }
         }
@@ -125,11 +134,15 @@ impl<'a> Child<'a> {
         }
     }
 
-    pub fn raw(&self) -> ::ArchiveChildRef { self.ptr }
+    pub fn raw(&self) -> ::ArchiveChildRef {
+        self.ptr
+    }
 }
 
 impl<'a> Drop for Child<'a> {
     fn drop(&mut self) {
-        unsafe { ::LLVMRustArchiveChildFree(self.ptr); }
+        unsafe {
+            ::LLVMRustArchiveChildFree(self.ptr);
+        }
     }
 }
diff --git a/src/librustc_llvm/build.rs b/src/librustc_llvm/build.rs
@@ -21,20 +21,25 @@ fn main() {
     println!("cargo:rustc-cfg=cargobuild");
 
     let target = env::var("TARGET").unwrap();
-    let llvm_config = env::var_os("LLVM_CONFIG").map(PathBuf::from)
-                           .unwrap_or_else(|| {
-        match env::var_os("CARGO_TARGET_DIR").map(PathBuf::from) {
-            Some(dir) => {
-                let to_test = dir.parent().unwrap().parent().unwrap()
-                                 .join(&target).join("llvm/bin/llvm-config");
-                if Command::new(&to_test).output().is_ok() {
-                    return to_test
-                }
-            }
-            None => {}
-        }
-        PathBuf::from("llvm-config")
-    });
+    let llvm_config = env::var_os("LLVM_CONFIG")
+                          .map(PathBuf::from)
+                          .unwrap_or_else(|| {
+                              match env::var_os("CARGO_TARGET_DIR").map(PathBuf::from) {
+                                  Some(dir) => {
+                                      let to_test = dir.parent()
+                                                       .unwrap()
+                                                       .parent()
+                                                       .unwrap()
+                                                       .join(&target)
+                                                       .join("llvm/bin/llvm-config");
+                                      if Command::new(&to_test).output().is_ok() {
+                                          return to_test;
+                                      }
+                                  }
+                                  None => {}
+                              }
+                              PathBuf::from("llvm-config")
+                          });
 
     println!("cargo:rerun-if-changed={}", llvm_config.display());
 
@@ -63,20 +68,22 @@ fn main() {
     let host = env::var("HOST").unwrap();
     let is_crossed = target != host;
 
-    let optional_components = ["x86", "arm", "aarch64", "mips", "powerpc",
-                               "pnacl"];
+    let optional_components = ["x86", "arm", "aarch64", "mips", "powerpc", "pnacl"];
 
     // FIXME: surely we don't need all these components, right? Stuff like mcjit
     //        or interpreter the compiler itself never uses.
-    let required_components = &["ipo", "bitreader", "bitwriter", "linker",
-                                "asmparser", "mcjit", "interpreter",
+    let required_components = &["ipo",
+                                "bitreader",
+                                "bitwriter",
+                                "linker",
+                                "asmparser",
+                                "mcjit",
+                                "interpreter",
                                 "instrumentation"];
 
     let components = output(Command::new(&llvm_config).arg("--components"));
     let mut components = components.split_whitespace().collect::<Vec<_>>();
-    components.retain(|c| {
-        optional_components.contains(c) || required_components.contains(c)
-    });
+    components.retain(|c| optional_components.contains(c) || required_components.contains(c));
 
     for component in required_components {
         if !components.contains(component) {
@@ -96,7 +103,7 @@ fn main() {
     for flag in cxxflags.split_whitespace() {
         // Ignore flags like `-m64` when we're doing a cross build
         if is_crossed && flag.starts_with("-m") {
-            continue
+            continue;
         }
         cfg.flag(flag);
     }
@@ -131,7 +138,7 @@ fn main() {
         } else if lib.starts_with("-") {
             &lib[1..]
         } else {
-            continue
+            continue;
         };
 
         // Don't need or want this library, but LLVM's CMake build system
@@ -140,10 +147,14 @@ fn main() {
         // library and it otherwise may just pull in extra dependencies on
         // libedit which we don't want
         if name == "LLVMLineEditor" {
-            continue
+            continue;
         }
 
-        let kind = if name.starts_with("LLVM") {"static"} else {"dylib"};
+        let kind = if name.starts_with("LLVM") {
+            "static"
+        } else {
+            "dylib"
+        };
         println!("cargo:rustc-link-lib={}={}", kind, name);
     }
 
diff --git a/src/librustc_llvm/diagnostic.rs b/src/librustc_llvm/diagnostic.rs
@@ -16,7 +16,7 @@ pub use self::Diagnostic::*;
 use libc::{c_char, c_uint};
 use std::ptr;
 
-use {ValueRef, TwineRef, DebugLocRef, DiagnosticInfoRef};
+use {DebugLocRef, DiagnosticInfoRef, TwineRef, ValueRef};
 
 #[derive(Copy, Clone)]
 pub enum OptimizationDiagnosticKind {
@@ -46,8 +46,9 @@ pub struct OptimizationDiagnostic {
 }
 
 impl OptimizationDiagnostic {
-    unsafe fn unpack(kind: OptimizationDiagnosticKind, di: DiagnosticInfoRef)
-            -> OptimizationDiagnostic {
+    unsafe fn unpack(kind: OptimizationDiagnosticKind,
+                     di: DiagnosticInfoRef)
+                     -> OptimizationDiagnostic {
 
         let mut opt = OptimizationDiagnostic {
             kind: kind,
@@ -58,10 +59,10 @@ impl OptimizationDiagnostic {
         };
 
         super::LLVMUnpackOptimizationDiagnostic(di,
-            &mut opt.pass_name,
-            &mut opt.function,
-            &mut opt.debug_loc,
-            &mut opt.message);
+                                                &mut opt.pass_name,
+                                                &mut opt.function,
+                                                &mut opt.debug_loc,
+                                                &mut opt.message);
 
         opt
     }
@@ -75,8 +76,7 @@ pub struct InlineAsmDiagnostic {
 }
 
 impl InlineAsmDiagnostic {
-    unsafe fn unpack(di: DiagnosticInfoRef)
-            -> InlineAsmDiagnostic {
+    unsafe fn unpack(di: DiagnosticInfoRef) -> InlineAsmDiagnostic {
 
         let mut opt = InlineAsmDiagnostic {
             cookie: 0,
@@ -85,9 +85,9 @@ impl InlineAsmDiagnostic {
         };
 
         super::LLVMUnpackInlineAsmDiagnostic(di,
-            &mut opt.cookie,
-            &mut opt.message,
-            &mut opt.instruction);
+                                             &mut opt.cookie,
+                                             &mut opt.message,
+                                             &mut opt.instruction);
 
         opt
     }
@@ -106,22 +106,25 @@ impl Diagnostic {
         let kind = super::LLVMGetDiagInfoKind(di);
 
         match kind {
-            super::DK_InlineAsm
-                => InlineAsm(InlineAsmDiagnostic::unpack(di)),
+            super::DK_InlineAsm => InlineAsm(InlineAsmDiagnostic::unpack(di)),
 
-            super::DK_OptimizationRemark
-                => Optimization(OptimizationDiagnostic::unpack(OptimizationRemark, di)),
+            super::DK_OptimizationRemark => {
+                Optimization(OptimizationDiagnostic::unpack(OptimizationRemark, di))
+            }
 
-            super::DK_OptimizationRemarkMissed
-                => Optimization(OptimizationDiagnostic::unpack(OptimizationMissed, di)),
+            super::DK_OptimizationRemarkMissed => {
+                Optimization(OptimizationDiagnostic::unpack(OptimizationMissed, di))
+            }
 
-            super::DK_OptimizationRemarkAnalysis
-                => Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysis, di)),
+            super::DK_OptimizationRemarkAnalysis => {
+                Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysis, di))
+            }
 
-            super::DK_OptimizationFailure
-                => Optimization(OptimizationDiagnostic::unpack(OptimizationFailure, di)),
+            super::DK_OptimizationFailure => {
+                Optimization(OptimizationDiagnostic::unpack(OptimizationFailure, di))
+            }
 
-            _ => UnknownDiagnostic(di)
+            _ => UnknownDiagnostic(di),
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,9 @@ use std::path::Path;`
`18`	`18`	`use std::slice;`
`19`	`19`	`use std::str;`
`20`	`20`
`21`		`-pub struct ArchiveRO { ptr: ArchiveRef }`
	`21`	`+pub struct ArchiveRO {`
	`22`	`+ ptr: ArchiveRef,`
	`23`	`+}`
`22`	`24`
`23`	`25`	`pub struct Iter<'a> {`
`24`	`26`	`archive: &'a ArchiveRO,`
`@@ -61,11 +63,16 @@ impl ArchiveRO {`
`61`	`63`	`}`
`62`	`64`	`}`
`63`	`65`
`64`		`- pub fn raw(&self) -> ArchiveRef { self.ptr }`
	`66`	`+ pub fn raw(&self) -> ArchiveRef {`
	`67`	`+ self.ptr`
	`68`	`+ }`
`65`	`69`
`66`	`70`	`pub fn iter(&self) -> Iter {`
`67`	`71`	`unsafe {`
`68`		`- Iter { ptr: ::LLVMRustArchiveIteratorNew(self.ptr), archive: self }`
	`72`	`+ Iter {`
	`73`	`+ ptr: ::LLVMRustArchiveIteratorNew(self.ptr),`
	`74`	`+ archive: self,`
	`75`	`+ }`
`69`	`76`	`}`
`70`	`77`	`}`
`71`	`78`	`}`
`@@ -86,7 +93,10 @@ impl<'a> Iterator for Iter<'a> {`
`86`	`93`	`if ptr.is_null() {`
`87`	`94`	`::last_error().map(Err)`
`88`	`95`	`} else {`
`89`		`- Some(Ok(Child { ptr: ptr, _data: marker::PhantomData }))`
	`96`	`+ Some(Ok(Child {`
	`97`	`+ ptr: ptr,`
	`98`	`+ _data: marker::PhantomData,`
	`99`	`+ }))`
`90`	`100`	`}`
`91`	`101`	`}`
`92`	`102`	`}`
`@@ -107,8 +117,7 @@ impl<'a> Child<'a> {`
`107`	`117`	`if name_ptr.is_null() {`
`108`	`118`	`None`
`109`	`119`	`} else {`
`110`		`- let name = slice::from_raw_parts(name_ptr as *const u8,`
`111`		`- name_len as usize);`
	`120`	`+ let name = slice::from_raw_parts(name_ptr as *const u8, name_len as usize);`
`112`	`121`	`str::from_utf8(name).ok().map(\|s\| s.trim())`
`113`	`122`	`}`
`114`	`123`	`}`
`@@ -125,11 +134,15 @@ impl<'a> Child<'a> {`
`125`	`134`	`}`
`126`	`135`	`}`
`127`	`136`
`128`		`- pub fn raw(&self) -> ::ArchiveChildRef { self.ptr }`
	`137`	`+ pub fn raw(&self) -> ::ArchiveChildRef {`
	`138`	`+ self.ptr`
	`139`	`+ }`
`129`	`140`	`}`
`130`	`141`
`131`	`142`	`impl<'a> Drop for Child<'a> {`
`132`	`143`	`fn drop(&mut self) {`
`133`		`- unsafe { ::LLVMRustArchiveChildFree(self.ptr); }`
	`144`	`+ unsafe {`
	`145`	`+ ::LLVMRustArchiveChildFree(self.ptr);`
	`146`	`+ }`
`134`	`147`	`}`
`135`	`148`	`}`