Improved formatting.

src/commands/tests.rs

@@ -26,8 +26,8 @@ pub fn test_main() {
             emit_llvm: None,
         },
     }
-        .run()
-        .unwrap();
+    .run()
+    .unwrap();
 
     let program_output = Command::new(output).output().expect("program not found");
     assert_eq!(program_output.status.code(), Some(27), "program failed");

src/ir_gen/build.rs

@@ -78,7 +78,7 @@ impl<'ctx> CompilerWithBuilder<'ctx, '_> {
                         ptr
                     }
                 }
-                    .as_ptr_to(tag::Pi);
+                .as_ptr_to(tag::Pi);
                 let dest_captures_ptr = self.build_store_pi_static_part(
                     dest_pi_ptr,
                     raw_function,

src/ir_gen/initialize.rs

@@ -26,12 +26,12 @@ impl<'ctx> Compiler<'ctx> {
     /// [`tag::CapturesCloneFn`].
     /// * Destroy function delegates to a field [`tag::CapturesDestroyFn`].
     fn add_delegating_builtin<B: BuiltinType>(&mut self, b: B)
-        where
-            B: Structure,
-            tag::TotalSize: FieldOf<B, Ty=tag::Usize>,
-            tag::CapturesCloneFn: FieldOf<B, Ty=tag::CapturesCloneFn>,
-            tag::CapturesDestroyFn: FieldOf<B, Ty=tag::CapturesDestroyFn>,
-            tag::Captures: FieldOf<B, Ty=tag::Captures>,
+    where
+        B: Structure,
+        tag::TotalSize: FieldOf<B, Ty = tag::Usize>,
+        tag::CapturesCloneFn: FieldOf<B, Ty = tag::CapturesCloneFn>,
+        tag::CapturesDestroyFn: FieldOf<B, Ty = tag::CapturesDestroyFn>,
+        tag::Captures: FieldOf<B, Ty = tag::Captures>,
     {
         self.add_delegating_size_fn(b);
         self.add_delegating_clone_fn(b);
@@ -45,9 +45,9 @@ impl<'ctx> Compiler<'ctx> {
     /// Requires `b` is the tag of a built-in type whose size function delegates to a field
     /// [`tag::TotalSize`].
     fn add_delegating_size_fn<B: BuiltinType>(&mut self, b: B)
-        where
-            B: Structure,
-            tag::TotalSize: FieldOf<B, Ty=tag::Usize>,
+    where
+        B: Structure,
+        tag::TotalSize: FieldOf<B, Ty = tag::Usize>,
     {
         let mut function = self.add_function(tag::SizeFn, B::get_name_of(tag::SizeFn));
         let arg_ptr = function.args.arg_ptr.as_ptr_to(b);
@@ -62,10 +62,10 @@ impl<'ctx> Compiler<'ctx> {
     /// Requires `b` is the tag of a built-in type whose clone function copies the static part and
     /// then delegates to a field [`tag::CapturesCloneFn`].
     fn add_delegating_clone_fn<B: BuiltinType>(&mut self, b: B)
-        where
-            B: Structure,
-            tag::CapturesCloneFn: FieldOf<B, Ty=tag::CapturesCloneFn>,
-            tag::Captures: FieldOf<B, Ty=tag::Captures>,
+    where
+        B: Structure,
+        tag::CapturesCloneFn: FieldOf<B, Ty = tag::CapturesCloneFn>,
+        tag::Captures: FieldOf<B, Ty = tag::Captures>,
     {
         let mut function = self.add_function(tag::CloneFn, B::get_name_of(tag::CloneFn));
         let src_ptr = function.args.src_ptr.as_ptr_to(b);
@@ -97,10 +97,10 @@ impl<'ctx> Compiler<'ctx> {
     /// Requires `b` is the tag of a built-in type whose destroy function delegates to a field
     /// [`tag::CapturesDestroyFn`].
     fn add_delegating_destroy_fn<B: BuiltinType>(&mut self, b: B)
-        where
-            B: Structure,
-            tag::CapturesDestroyFn: FieldOf<B, Ty=tag::CapturesDestroyFn>,
-            tag::Captures: FieldOf<B, Ty=tag::Captures>,
+    where
+        B: Structure,
+        tag::CapturesDestroyFn: FieldOf<B, Ty = tag::CapturesDestroyFn>,
+        tag::Captures: FieldOf<B, Ty = tag::Captures>,
     {
         let mut function = self.add_function(tag::DestroyFn, B::get_name_of(tag::DestroyFn));
         let arg_ptr = function.args.arg_ptr.as_ptr_to(b);

src/ir_gen/values/captures/mod.rs

@@ -131,7 +131,7 @@ impl CaptureOffsetIndexable for Partial {
     type Offset = Read;
 }
 
-pub trait CaptureIndexable: CaptureOffsetIndexable<Offset=Read> {
+pub trait CaptureIndexable: CaptureOffsetIndexable<Offset = Read> {
     type Elem: Flow;
 }
 

src/ir_gen/values/constants.rs

@@ -38,8 +38,8 @@ impl<'ctx> Compiler<'ctx> {
         _b: B,
         f: F,
     ) -> FnValue<'ctx, F>
-        where
-            B: HasAssociatedFn<F>,
+    where
+        B: HasAssociatedFn<F>,
     {
         self.get_function_ptr(B::get_name_of(f))
             .unwrap()

src/ir_gen/values/members.rs

@@ -44,14 +44,14 @@ impl<'ctx> CompilerWithBuilder<'ctx, '_> {
         &mut self,
         ptr: PtrValue<'ctx, F, S>,
     ) -> PtrValue<'ctx, F, tag::Captures>
-        where
-            tag::Captures: FieldOf<S, Ty=tag::Captures>,
+    where
+        tag::Captures: FieldOf<S, Ty = tag::Captures>,
     {
         self.build_get_field_ptr(ptr, tag::Captures)
     }
 
     /// Builds a load of a given field of a given pointer to a structure.
-    pub fn build_load_field<S: Structure, FieldTy: LoadStore, Field: FieldOf<S, Ty=FieldTy>>(
+    pub fn build_load_field<S: Structure, FieldTy: LoadStore, Field: FieldOf<S, Ty = FieldTy>>(
         &mut self,
         ptr: PtrValue<'ctx, Read, S>,
         field: Field,
@@ -63,7 +63,7 @@ impl<'ctx> CompilerWithBuilder<'ctx, '_> {
     /// Builds a store of a given field of a given pointer to a structure.
     ///
     /// Requires the specified field is only stored to by this one call.
-    pub fn build_store_field<S: Structure, FieldTy: LoadStore, Field: FieldOf<S, Ty=FieldTy>>(
+    pub fn build_store_field<S: Structure, FieldTy: LoadStore, Field: FieldOf<S, Ty = FieldTy>>(
         &mut self,
         ptr: PtrValue<'ctx, Write, S>,
         field: Field,

src/ir_gen/values/tags/builtin_type.rs

@@ -20,8 +20,9 @@ pub trait HasAssociatedFn<F: Function>: Object {
 ///
 /// Built-in types must have associated special members: size, clone, and destroy functions.
 pub trait BuiltinType:
-HasAssociatedFn<tag::SizeFn> + HasAssociatedFn<tag::CloneFn> + HasAssociatedFn<tag::DestroyFn>
-{}
+    HasAssociatedFn<tag::SizeFn> + HasAssociatedFn<tag::CloneFn> + HasAssociatedFn<tag::DestroyFn>
+{
+}
 
 impl HasAssociatedFn<tag::SizeFn> for tag::Universe {
     const NAMED: &'static str = "universe_size";

src/typing/unification.rs

@@ -181,8 +181,8 @@ mod detail {
                     neu = func;
                     match arg.force(defs) {
                         Value::Neutral(Neutral::Principal(Principal::Variable(
-                                                              VVariable::Local(level),
-                                                          ))) => args.push(level),
+                            VVariable::Local(level),
+                        ))) => args.push(level),
                         arg => return Err(TypeError::NonLevelInSpine(arg)),
                     }
                 }