Rename all variables that have uppercase characters in their names to use only lowercase characters

9 files changed, 344 insertions, 344 deletions

diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
index 4d86848482e..3a1c646144b 100644
--- a/src/librustc/back/link.rs
+++ b/src/librustc/back/link.rs
@@ -68,15 +68,15 @@ pub fn llvm_err(sess: Session, msg: ~str) -> ! {
 
 pub fn WriteOutputFile(
         sess: Session,
-        Target: lib::llvm::TargetMachineRef,
-        PM: lib::llvm::PassManagerRef,
-        M: ModuleRef,
-        Output: &Path,
-        FileType: lib::llvm::FileType) {
+        target: lib::llvm::TargetMachineRef,
+        pm: lib::llvm::PassManagerRef,
+        m: ModuleRef,
+        output: &Path,
+        file_type: lib::llvm::FileType) {
     unsafe {
-        Output.with_c_str(|Output| {
+        output.with_c_str(|output| {
             let result = llvm::LLVMRustWriteOutputFile(
-                    Target, PM, M, Output, FileType);
+                    target, pm, m, output, file_type);
             if !result {
                 llvm_err(sess, ~"could not write output");
             }
@@ -138,7 +138,7 @@ pub mod write {
                 })
             }
 
-            let OptLevel = match sess.opts.optimize {
+            let opt_level = match sess.opts.optimize {
               session::No => lib::llvm::CodeGenLevelNone,
               session::Less => lib::llvm::CodeGenLevelLess,
               session::Default => lib::llvm::CodeGenLevelDefault,
@@ -152,14 +152,14 @@ pub mod write {
                              (sess.targ_cfg.os == abi::OsMacos &&
                               sess.targ_cfg.arch == abi::X86_64);
 
-            let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|T| {
-                sess.opts.cg.target_cpu.with_c_str(|CPU| {
-                    target_feature(&sess).with_c_str(|Features| {
+            let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|t| {
+                sess.opts.cg.target_cpu.with_c_str(|cpu| {
+                    target_feature(&sess).with_c_str(|features| {
                         llvm::LLVMRustCreateTargetMachine(
-                            T, CPU, Features,
+                            t, cpu, features,
                             lib::llvm::CodeModelDefault,
                             lib::llvm::RelocPIC,
-                            OptLevel,
+                            opt_level,
                             true,
                             use_softfp,
                             no_fp_elim
@@ -185,7 +185,7 @@ pub mod write {
             if !sess.opts.cg.no_prepopulate_passes {
                 llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
                 llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
-                populate_llvm_passes(fpm, mpm, llmod, OptLevel);
+                populate_llvm_passes(fpm, mpm, llmod, opt_level);
             }
 
             for pass in sess.opts.cg.passes.iter() {
diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs
index 3bee339e3cc..9e091f13be0 100644
--- a/src/librustc/lib/llvm.rs
+++ b/src/librustc/lib/llvm.rs
@@ -1774,25 +1774,25 @@ pub mod llvm {
     }
 }
 
-pub fn SetInstructionCallConv(Instr: ValueRef, CC: CallConv) {
+pub fn SetInstructionCallConv(instr: ValueRef, cc: CallConv) {
     unsafe {
-        llvm::LLVMSetInstructionCallConv(Instr, CC as c_uint);
+        llvm::LLVMSetInstructionCallConv(instr, cc as c_uint);
     }
 }
-pub fn SetFunctionCallConv(Fn: ValueRef, CC: CallConv) {
+pub fn SetFunctionCallConv(fn_: ValueRef, cc: CallConv) {
     unsafe {
-        llvm::LLVMSetFunctionCallConv(Fn, CC as c_uint);
+        llvm::LLVMSetFunctionCallConv(fn_, cc as c_uint);
     }
 }
-pub fn SetLinkage(Global: ValueRef, Link: Linkage) {
+pub fn SetLinkage(global: ValueRef, link: Linkage) {
     unsafe {
-        llvm::LLVMSetLinkage(Global, Link as c_uint);
+        llvm::LLVMSetLinkage(global, link as c_uint);
     }
 }
 
-pub fn SetUnnamedAddr(Global: ValueRef, Unnamed: bool) {
+pub fn SetUnnamedAddr(global: ValueRef, unnamed: bool) {
     unsafe {
-        llvm::LLVMSetUnnamedAddr(Global, Unnamed as Bool);
+        llvm::LLVMSetUnnamedAddr(global, unnamed as Bool);
     }
 }
 
@@ -1802,20 +1802,20 @@ pub fn set_thread_local(global: ValueRef, is_thread_local: bool) {
     }
 }
 
-pub fn ConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
+pub fn ConstICmp(pred: IntPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
     unsafe {
-        llvm::LLVMConstICmp(Pred as c_ushort, V1, V2)
+        llvm::LLVMConstICmp(pred as c_ushort, v1, v2)
     }
 }
-pub fn ConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
+pub fn ConstFCmp(pred: RealPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
     unsafe {
-        llvm::LLVMConstFCmp(Pred as c_ushort, V1, V2)
+        llvm::LLVMConstFCmp(pred as c_ushort, v1, v2)
     }
 }
 
-pub fn SetFunctionAttribute(Fn: ValueRef, attr: Attribute) {
+pub fn SetFunctionAttribute(fn_: ValueRef, attr: Attribute) {
     unsafe {
-        llvm::LLVMAddFunctionAttr(Fn, attr as c_uint)
+        llvm::LLVMAddFunctionAttr(fn_, attr as c_uint)
     }
 }
 /* Memory-managed object interface to type handles. */
@@ -1879,9 +1879,9 @@ impl Drop for target_data_res {
     }
 }
 
-pub fn target_data_res(TD: TargetDataRef) -> target_data_res {
+pub fn target_data_res(td: TargetDataRef) -> target_data_res {
     target_data_res {
-        TD: TD
+        TD: td
     }
 }
 
@@ -1915,9 +1915,9 @@ impl Drop for pass_manager_res {
     }
 }
 
-pub fn pass_manager_res(PM: PassManagerRef) -> pass_manager_res {
+pub fn pass_manager_res(pm: PassManagerRef) -> pass_manager_res {
     pass_manager_res {
-        PM: PM
+        PM: pm
     }
 }
 
@@ -1982,9 +1982,9 @@ impl Drop for section_iter_res {
     }
 }
 
-pub fn section_iter_res(SI: SectionIteratorRef) -> section_iter_res {
+pub fn section_iter_res(si: SectionIteratorRef) -> section_iter_res {
     section_iter_res {
-        SI: SI
+        SI: si
     }
 }
 
diff --git a/src/librustc/middle/trans/asm.rs b/src/librustc/middle/trans/asm.rs
index 130bcb41902..59ef31751eb 100644
--- a/src/librustc/middle/trans/asm.rs
+++ b/src/librustc/middle/trans/asm.rs
@@ -82,12 +82,12 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm)
 
     debug!("Asm Constraints: {:?}", constraints);
 
-    let numOutputs = outputs.len();
+    let num_outputs = outputs.len();
 
     // Depending on how many outputs we have, the return type is different
-    let output_type = if numOutputs == 0 {
+    let output_type = if num_outputs == 0 {
         Type::void()
-    } else if numOutputs == 1 {
+    } else if num_outputs == 1 {
         output_types[0]
     } else {
         Type::struct_(output_types, false)
@@ -112,7 +112,7 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm)
     });
 
     // Again, based on how many outputs we have
-    if numOutputs == 1 {
+    if num_outputs == 1 {
         Store(bcx, r, *outputs.get(0));
     } else {
         for (i, o) in outputs.iter().enumerate() {
diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs
index e8424bcde60..d208394402c 100644
--- a/src/librustc/middle/trans/build.rs
+++ b/src/librustc/middle/trans/build.rs
@@ -54,64 +54,64 @@ pub fn RetVoid(cx: &Block) {
     B(cx).ret_void();
 }
 
-pub fn Ret(cx: &Block, V: ValueRef) {
+pub fn Ret(cx: &Block, v: ValueRef) {
     if cx.unreachable.get() { return; }
     check_not_terminated(cx);
     terminate(cx, "Ret");
-    B(cx).ret(V);
+    B(cx).ret(v);
 }
 
-pub fn AggregateRet(cx: &Block, RetVals: &[ValueRef]) {
+pub fn AggregateRet(cx: &Block, ret_vals: &[ValueRef]) {
     if cx.unreachable.get() { return; }
     check_not_terminated(cx);
     terminate(cx, "AggregateRet");
-    B(cx).aggregate_ret(RetVals);
+    B(cx).aggregate_ret(ret_vals);
 }
 
-pub fn Br(cx: &Block, Dest: BasicBlockRef) {
+pub fn Br(cx: &Block, dest: BasicBlockRef) {
     if cx.unreachable.get() { return; }
     check_not_terminated(cx);
     terminate(cx, "Br");
-    B(cx).br(Dest);
+    B(cx).br(dest);
 }
 
 pub fn CondBr(cx: &Block,
-              If: ValueRef,
-              Then: BasicBlockRef,
-              Else: BasicBlockRef) {
+              if_: ValueRef,
+              then: BasicBlockRef,
+              else_: BasicBlockRef) {
     if cx.unreachable.get() { return; }
     check_not_terminated(cx);
     terminate(cx, "CondBr");
-    B(cx).cond_br(If, Then, Else);
+    B(cx).cond_br(if_, then, else_);
 }
 
-pub fn Switch(cx: &Block, V: ValueRef, Else: BasicBlockRef, NumCases: uint)
+pub fn Switch(cx: &Block, v: ValueRef, else_: BasicBlockRef, num_cases: uint)
     -> ValueRef {
-    if cx.unreachable.get() { return _Undef(V); }
+    if cx.unreachable.get() { return _Undef(v); }
     check_not_terminated(cx);
     terminate(cx, "Switch");
-    B(cx).switch(V, Else, NumCases)
+    B(cx).switch(v, else_, num_cases)
 }
 
-pub fn AddCase(S: ValueRef, OnVal: ValueRef, Dest: BasicBlockRef) {
+pub fn AddCase(s: ValueRef, on_val: ValueRef, dest: BasicBlockRef) {
     unsafe {
-        if llvm::LLVMIsUndef(S) == lib::llvm::True { return; }
-        llvm::LLVMAddCase(S, OnVal, Dest);
+        if llvm::LLVMIsUndef(s) == lib::llvm::True { return; }
+        llvm::LLVMAddCase(s, on_val, dest);
     }
 }
 
-pub fn IndirectBr(cx: &Block, Addr: ValueRef, NumDests: uint) {
+pub fn IndirectBr(cx: &Block, addr: ValueRef, num_dests: uint) {
     if cx.unreachable.get() { return; }
     check_not_terminated(cx);
     terminate(cx, "IndirectBr");
-    B(cx).indirect_br(Addr, NumDests);
+    B(cx).indirect_br(addr, num_dests);
 }
 
 pub fn Invoke(cx: &Block,
-              Fn: ValueRef,
-              Args: &[ValueRef],
-              Then: BasicBlockRef,
-              Catch: BasicBlockRef,
+              fn_: ValueRef,
+              args: &[ValueRef],
+              then: BasicBlockRef,
+              catch: BasicBlockRef,
               attributes: &[(uint, lib::llvm::Attribute)])
               -> ValueRef {
     if cx.unreachable.get() {
@@ -120,9 +120,9 @@ pub fn Invoke(cx: &Block,
     check_not_terminated(cx);
     terminate(cx, "Invoke");
     debug!("Invoke({} with arguments ({}))",
-           cx.val_to_str(Fn),
-           Args.map(|a| cx.val_to_str(*a)).connect(", "));
-    B(cx).invoke(Fn, Args, Then, Catch, attributes)
+           cx.val_to_str(fn_),
+           args.map(|a| cx.val_to_str(*a)).connect(", "));
+    B(cx).invoke(fn_, args, then, catch, attributes)
 }
 
 pub fn Unreachable(cx: &Block) {
@@ -142,208 +142,208 @@ pub fn _Undef(val: ValueRef) -> ValueRef {
 }
 
 /* Arithmetic */
-pub fn Add(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).add(LHS, RHS)
+pub fn Add(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).add(lhs, rhs)
 }
 
-pub fn NSWAdd(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).nswadd(LHS, RHS)
+pub fn NSWAdd(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).nswadd(lhs, rhs)
 }
 
-pub fn NUWAdd(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).nuwadd(LHS, RHS)
+pub fn NUWAdd(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).nuwadd(lhs, rhs)
 }
 
-pub fn FAdd(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).fadd(LHS, RHS)
+pub fn FAdd(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).fadd(lhs, rhs)
 }
 
-pub fn Sub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).sub(LHS, RHS)
+pub fn Sub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).sub(lhs, rhs)
 }
 
-pub fn NSWSub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).nswsub(LHS, RHS)
+pub fn NSWSub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).nswsub(lhs, rhs)
 }
 
-pub fn NUWSub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).nuwsub(LHS, RHS)
+pub fn NUWSub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).nuwsub(lhs, rhs)
 }
 
-pub fn FSub(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).fsub(LHS, RHS)
+pub fn FSub(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).fsub(lhs, rhs)
 }
 
-pub fn Mul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).mul(LHS, RHS)
+pub fn Mul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).mul(lhs, rhs)
 }
 
-pub fn NSWMul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).nswmul(LHS, RHS)
+pub fn NSWMul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).nswmul(lhs, rhs)
 }
 
-pub fn NUWMul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).nuwmul(LHS, RHS)
+pub fn NUWMul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).nuwmul(lhs, rhs)
 }
 
-pub fn FMul(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).fmul(LHS, RHS)
+pub fn FMul(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).fmul(lhs, rhs)
 }
 
-pub fn UDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).udiv(LHS, RHS)
+pub fn UDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).udiv(lhs, rhs)
 }
 
-pub fn SDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).sdiv(LHS, RHS)
+pub fn SDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).sdiv(lhs, rhs)
 }
 
-pub fn ExactSDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).exactsdiv(LHS, RHS)
+pub fn ExactSDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).exactsdiv(lhs, rhs)
 }
 
-pub fn FDiv(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).fdiv(LHS, RHS)
+pub fn FDiv(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).fdiv(lhs, rhs)
 }
 
-pub fn URem(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).urem(LHS, RHS)
+pub fn URem(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).urem(lhs, rhs)
 }
 
-pub fn SRem(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).srem(LHS, RHS)
+pub fn SRem(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).srem(lhs, rhs)
 }
 
-pub fn FRem(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).frem(LHS, RHS)
+pub fn FRem(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).frem(lhs, rhs)
 }
 
-pub fn Shl(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).shl(LHS, RHS)
+pub fn Shl(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).shl(lhs, rhs)
 }
 
-pub fn LShr(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).lshr(LHS, RHS)
+pub fn LShr(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).lshr(lhs, rhs)
 }
 
-pub fn AShr(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).ashr(LHS, RHS)
+pub fn AShr(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).ashr(lhs, rhs)
 }
 
-pub fn And(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).and(LHS, RHS)
+pub fn And(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).and(lhs, rhs)
 }
 
-pub fn Or(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).or(LHS, RHS)
+pub fn Or(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).or(lhs, rhs)
 }
 
-pub fn Xor(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).xor(LHS, RHS)
+pub fn Xor(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).xor(lhs, rhs)
 }
 
-pub fn BinOp(cx: &Block, Op: Opcode, LHS: ValueRef, RHS: ValueRef)
+pub fn BinOp(cx: &Block, op: Opcode, lhs: ValueRef, rhs: ValueRef)
           -> ValueRef {
-    if cx.unreachable.get() { return _Undef(LHS); }
-    B(cx).binop(Op, LHS, RHS)
+    if cx.unreachable.get() { return _Undef(lhs); }
+    B(cx).binop(op, lhs, rhs)
 }
 
-pub fn Neg(cx: &Block, V: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(V); }
-    B(cx).neg(V)
+pub fn Neg(cx: &Block, v: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(v); }
+    B(cx).neg(v)
 }
 
-pub fn NSWNeg(cx: &Block, V: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(V); }
-    B(cx).nswneg(V)
+pub fn NSWNeg(cx: &Block, v: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(v); }
+    B(cx).nswneg(v)
 }
 
-pub fn NUWNeg(cx: &Block, V: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(V); }
-    B(cx).nuwneg(V)
+pub fn NUWNeg(cx: &Block, v: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(v); }
+    B(cx).nuwneg(v)
 }
-pub fn FNeg(cx: &Block, V: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(V); }
-    B(cx).fneg(V)
+pub fn FNeg(cx: &Block, v: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(v); }
+    B(cx).fneg(v)
 }
 
-pub fn Not(cx: &Block, V: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(V); }
-    B(cx).not(V)
+pub fn Not(cx: &Block, v: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(v); }
+    B(cx).not(v)
 }
 
 /* Memory */
-pub fn Malloc(cx: &Block, Ty: Type) -> ValueRef {
+pub fn Malloc(cx: &Block, ty: Type) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
-        B(cx).malloc(Ty)
+        B(cx).malloc(ty)
     }
 }
 
-pub fn ArrayMalloc(cx: &Block, Ty: Type, Val: ValueRef) -> ValueRef {
+pub fn ArrayMalloc(cx: &Block, ty: Type, val: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
-        B(cx).array_malloc(Ty, Val)
+        B(cx).array_malloc(ty, val)
     }
 }
 
-pub fn Alloca(cx: &Block, Ty: Type, name: &str) -> ValueRef {
+pub fn Alloca(cx: &Block, ty: Type, name: &str) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
-        AllocaFcx(cx.fcx, Ty, name)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.ptr_to().to_ref()); }
+        AllocaFcx(cx.fcx, ty, name)
     }
 }
 
-pub fn AllocaFcx(fcx: &FunctionContext, Ty: Type, name: &str) -> ValueRef {
+pub fn AllocaFcx(fcx: &FunctionContext, ty: Type, name: &str) -> ValueRef {
     let b = fcx.ccx.builder();
     b.position_before(fcx.alloca_insert_pt.get().unwrap());
-    b.alloca(Ty, name)
+    b.alloca(ty, name)
 }
 
-pub fn ArrayAlloca(cx: &Block, Ty: Type, Val: ValueRef) -> ValueRef {
+pub fn ArrayAlloca(cx: &Block, ty: Type, val: ValueRef) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.ptr_to().to_ref()); }
         let b = cx.fcx.ccx.builder();
         b.position_before(cx.fcx.alloca_insert_pt.get().unwrap());
-        b.array_alloca(Ty, Val)
+        b.array_alloca(ty, val)
     }
 }
 
-pub fn Free(cx: &Block, PointerVal: ValueRef) {
+pub fn Free(cx: &Block, pointer_val: ValueRef) {
     if cx.unreachable.get() { return; }
-    B(cx).free(PointerVal)
+    B(cx).free(pointer_val)
 }
 
-pub fn Load(cx: &Block, PointerVal: ValueRef) -> ValueRef {
+pub fn Load(cx: &Block, pointer_val: ValueRef) -> ValueRef {
     unsafe {
         let ccx = cx.fcx.ccx;
         if cx.unreachable.get() {
-            let ty = val_ty(PointerVal);
+            let ty = val_ty(pointer_val);
             let eltty = if ty.kind() == lib::llvm::Array {
                 ty.element_type()
             } else {
@@ -351,33 +351,33 @@ pub fn Load(cx: &Block, PointerVal: ValueRef) -> ValueRef {
             };
             return llvm::LLVMGetUndef(eltty.to_ref());
         }
-        B(cx).load(PointerVal)
+        B(cx).load(pointer_val)
     }
 }
 
-pub fn VolatileLoad(cx: &Block, PointerVal: ValueRef) -> ValueRef {
+pub fn VolatileLoad(cx: &Block, pointer_val: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
-        B(cx).volatile_load(PointerVal)
+        B(cx).volatile_load(pointer_val)
     }
 }
 
-pub fn AtomicLoad(cx: &Block, PointerVal: ValueRef, order: AtomicOrdering) -> ValueRef {
+pub fn AtomicLoad(cx: &Block, pointer_val: ValueRef, order: AtomicOrdering) -> ValueRef {
     unsafe {
         let ccx = cx.fcx.ccx;
         if cx.unreachable.get() {
             return llvm::LLVMGetUndef(ccx.int_type.to_ref());
         }
-        B(cx).atomic_load(PointerVal, order)
+        B(cx).atomic_load(pointer_val, order)
     }
 }
 
 
-pub fn LoadRangeAssert(cx: &Block, PointerVal: ValueRef, lo: c_ulonglong,
+pub fn LoadRangeAssert(cx: &Block, pointer_val: ValueRef, lo: c_ulonglong,
                        hi: c_ulonglong, signed: lib::llvm::Bool) -> ValueRef {
     if cx.unreachable.get() {
         let ccx = cx.fcx.ccx;
-        let ty = val_ty(PointerVal);
+        let ty = val_ty(pointer_val);
         let eltty = if ty.kind() == lib::llvm::Array {
             ty.element_type()
         } else {
@@ -387,29 +387,29 @@ pub fn LoadRangeAssert(cx: &Block, PointerVal: ValueRef, lo: c_ulonglong,
             llvm::LLVMGetUndef(eltty.to_ref())
         }
     } else {
-        B(cx).load_range_assert(PointerVal, lo, hi, signed)
+        B(cx).load_range_assert(pointer_val, lo, hi, signed)
     }
 }
 
-pub fn Store(cx: &Block, Val: ValueRef, Ptr: ValueRef) {
+pub fn Store(cx: &Block, val: ValueRef, ptr: ValueRef) {
     if cx.unreachable.get() { return; }
-    B(cx).store(Val, Ptr)
+    B(cx).store(val, ptr)
 }
 
-pub fn VolatileStore(cx: &Block, Val: ValueRef, Ptr: ValueRef) {
+pub fn VolatileStore(cx: &Block, val: ValueRef, ptr: ValueRef) {
     if cx.unreachable.get() { return; }
-    B(cx).volatile_store(Val, Ptr)
+    B(cx).volatile_store(val, ptr)
 }
 
-pub fn AtomicStore(cx: &Block, Val: ValueRef, Ptr: ValueRef, order: AtomicOrdering) {
+pub fn AtomicStore(cx: &Block, val: ValueRef, ptr: ValueRef, order: AtomicOrdering) {
     if cx.unreachable.get() { return; }
-    B(cx).atomic_store(Val, Ptr, order)
+    B(cx).atomic_store(val, ptr, order)
 }
 
-pub fn GEP(cx: &Block, Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef {
+pub fn GEP(cx: &Block, pointer: ValueRef, indices: &[ValueRef]) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()); }
-        B(cx).gep(Pointer, Indices)
+        B(cx).gep(pointer, indices)
     }
 }
 
@@ -423,199 +423,199 @@ pub fn GEPi(cx: &Block, base: ValueRef, ixs: &[uint]) -> ValueRef {
     }
 }
 
-pub fn InBoundsGEP(cx: &Block, Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef {
+pub fn InBoundsGEP(cx: &Block, pointer: ValueRef, indices: &[ValueRef]) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()); }
-        B(cx).inbounds_gep(Pointer, Indices)
+        B(cx).inbounds_gep(pointer, indices)
     }
 }
 
-pub fn StructGEP(cx: &Block, Pointer: ValueRef, Idx: uint) -> ValueRef {
+pub fn StructGEP(cx: &Block, pointer: ValueRef, idx: uint) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()); }
-        B(cx).struct_gep(Pointer, Idx)
+        B(cx).struct_gep(pointer, idx)
     }
 }
 
-pub fn GlobalString(cx: &Block, _Str: *c_char) -> ValueRef {
+pub fn GlobalString(cx: &Block, _str: *c_char) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
-        B(cx).global_string(_Str)
+        B(cx).global_string(_str)
     }
 }
 
-pub fn GlobalStringPtr(cx: &Block, _Str: *c_char) -> ValueRef {
+pub fn GlobalStringPtr(cx: &Block, _str: *c_char) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i8p().to_ref()); }
-        B(cx).global_string_ptr(_Str)
+        B(cx).global_string_ptr(_str)
     }
 }
 
 /* Casts */
-pub fn Trunc(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn Trunc(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).trunc(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).trunc(val, dest_ty)
     }
 }
 
-pub fn ZExt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn ZExt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).zext(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).zext(val, dest_ty)
     }
 }
 
-pub fn SExt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn SExt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).sext(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).sext(val, dest_ty)
     }
 }
 
-pub fn FPToUI(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPToUI(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).fptoui(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).fptoui(val, dest_ty)
     }
 }
 
-pub fn FPToSI(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPToSI(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).fptosi(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).fptosi(val, dest_ty)
     }
 }
 
-pub fn UIToFP(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn UIToFP(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).uitofp(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).uitofp(val, dest_ty)
     }
 }
 
-pub fn SIToFP(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn SIToFP(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).sitofp(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).sitofp(val, dest_ty)
     }
 }
 
-pub fn FPTrunc(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPTrunc(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).fptrunc(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).fptrunc(val, dest_ty)
     }
 }
 
-pub fn FPExt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPExt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).fpext(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).fpext(val, dest_ty)
     }
 }
 
-pub fn PtrToInt(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn PtrToInt(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).ptrtoint(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).ptrtoint(val, dest_ty)
     }
 }
 
-pub fn IntToPtr(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn IntToPtr(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).inttoptr(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).inttoptr(val, dest_ty)
     }
 }
 
-pub fn BitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn BitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).bitcast(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).bitcast(val, dest_ty)
     }
 }
 
-pub fn ZExtOrBitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn ZExtOrBitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).zext_or_bitcast(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).zext_or_bitcast(val, dest_ty)
     }
 }
 
-pub fn SExtOrBitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn SExtOrBitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).sext_or_bitcast(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).sext_or_bitcast(val, dest_ty)
     }
 }
 
-pub fn TruncOrBitCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn TruncOrBitCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).trunc_or_bitcast(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).trunc_or_bitcast(val, dest_ty)
     }
 }
 
-pub fn Cast(cx: &Block, Op: Opcode, Val: ValueRef, DestTy: Type, _: *u8)
+pub fn Cast(cx: &Block, op: Opcode, val: ValueRef, dest_ty: Type, _: *u8)
      -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).cast(Op, Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).cast(op, val, dest_ty)
     }
 }
 
-pub fn PointerCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn PointerCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).pointercast(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).pointercast(val, dest_ty)
     }
 }
 
-pub fn IntCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn IntCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).intcast(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).intcast(val, dest_ty)
     }
 }
 
-pub fn FPCast(cx: &Block, Val: ValueRef, DestTy: Type) -> ValueRef {
+pub fn FPCast(cx: &Block, val: ValueRef, dest_ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(DestTy.to_ref()); }
-        B(cx).fpcast(Val, DestTy)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(dest_ty.to_ref()); }
+        B(cx).fpcast(val, dest_ty)
     }
 }
 
 
 /* Comparisons */
-pub fn ICmp(cx: &Block, Op: IntPredicate, LHS: ValueRef, RHS: ValueRef)
+pub fn ICmp(cx: &Block, op: IntPredicate, lhs: ValueRef, rhs: ValueRef)
      -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
-        B(cx).icmp(Op, LHS, RHS)
+        B(cx).icmp(op, lhs, rhs)
     }
 }
 
-pub fn FCmp(cx: &Block, Op: RealPredicate, LHS: ValueRef, RHS: ValueRef)
+pub fn FCmp(cx: &Block, op: RealPredicate, lhs: ValueRef, rhs: ValueRef)
      -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
-        B(cx).fcmp(Op, LHS, RHS)
+        B(cx).fcmp(op, lhs, rhs)
     }
 }
 
 /* Miscellaneous instructions */
-pub fn EmptyPhi(cx: &Block, Ty: Type) -> ValueRef {
+pub fn EmptyPhi(cx: &Block, ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.to_ref()); }
-        B(cx).empty_phi(Ty)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.to_ref()); }
+        B(cx).empty_phi(ty)
     }
 }
 
-pub fn Phi(cx: &Block, Ty: Type, vals: &[ValueRef], bbs: &[BasicBlockRef]) -> ValueRef {
+pub fn Phi(cx: &Block, ty: Type, vals: &[ValueRef], bbs: &[BasicBlockRef]) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.to_ref()); }
-        B(cx).phi(Ty, vals, bbs)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.to_ref()); }
+        B(cx).phi(ty, vals, bbs)
     }
 }
 
@@ -626,10 +626,10 @@ pub fn AddIncomingToPhi(phi: ValueRef, val: ValueRef, bb: BasicBlockRef) {
     }
 }
 
-pub fn _UndefReturn(cx: &Block, Fn: ValueRef) -> ValueRef {
+pub fn _UndefReturn(cx: &Block, fn_: ValueRef) -> ValueRef {
     unsafe {
         let ccx = cx.fcx.ccx;
-        let ty = val_ty(Fn);
+        let ty = val_ty(fn_);
         let retty = if ty.kind() == lib::llvm::Integer {
             ty.return_type()
         } else {
@@ -655,16 +655,16 @@ pub fn InlineAsmCall(cx: &Block, asm: *c_char, cons: *c_char,
     B(cx).inline_asm_call(asm, cons, inputs, output, volatile, alignstack, dia)
 }
 
-pub fn Call(cx: &Block, Fn: ValueRef, Args: &[ValueRef],
+pub fn Call(cx: &Block, fn_: ValueRef, args: &[ValueRef],
             attributes: &[(uint, lib::llvm::Attribute)]) -> ValueRef {
-    if cx.unreachable.get() { return _UndefReturn(cx, Fn); }
-    B(cx).call(Fn, Args, attributes)
+    if cx.unreachable.get() { return _UndefReturn(cx, fn_); }
+    B(cx).call(fn_, args, attributes)
 }
 
-pub fn CallWithConv(cx: &Block, Fn: ValueRef, Args: &[ValueRef], Conv: CallConv,
+pub fn CallWithConv(cx: &Block, fn_: ValueRef, args: &[ValueRef], conv: CallConv,
                     attributes: &[(uint, lib::llvm::Attribute)]) -> ValueRef {
-    if cx.unreachable.get() { return _UndefReturn(cx, Fn); }
-    B(cx).call_with_conv(Fn, Args, Conv, attributes)
+    if cx.unreachable.get() { return _UndefReturn(cx, fn_); }
+    B(cx).call_with_conv(fn_, args, conv, attributes)
 }
 
 pub fn AtomicFence(cx: &Block, order: AtomicOrdering) {
@@ -672,81 +672,81 @@ pub fn AtomicFence(cx: &Block, order: AtomicOrdering) {
     B(cx).atomic_fence(order)
 }
 
-pub fn Select(cx: &Block, If: ValueRef, Then: ValueRef, Else: ValueRef) -> ValueRef {
-    if cx.unreachable.get() { return _Undef(Then); }
-    B(cx).select(If, Then, Else)
+pub fn Select(cx: &Block, if_: ValueRef, then: ValueRef, else_: ValueRef) -> ValueRef {
+    if cx.unreachable.get() { return _Undef(then); }
+    B(cx).select(if_, then, else_)
 }
 
-pub fn VAArg(cx: &Block, list: ValueRef, Ty: Type) -> ValueRef {
+pub fn VAArg(cx: &Block, list: ValueRef, ty: Type) -> ValueRef {
     unsafe {
-        if cx.unreachable.get() { return llvm::LLVMGetUndef(Ty.to_ref()); }
-        B(cx).va_arg(list, Ty)
+        if cx.unreachable.get() { return llvm::LLVMGetUndef(ty.to_ref()); }
+        B(cx).va_arg(list, ty)
     }
 }
 
-pub fn ExtractElement(cx: &Block, VecVal: ValueRef, Index: ValueRef) -> ValueRef {
+pub fn ExtractElement(cx: &Block, vec_val: ValueRef, index: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
-        B(cx).extract_element(VecVal, Index)
+        B(cx).extract_element(vec_val, index)
     }
 }
 
-pub fn InsertElement(cx: &Block, VecVal: ValueRef, EltVal: ValueRef,
-                     Index: ValueRef) -> ValueRef {
+pub fn InsertElement(cx: &Block, vec_val: ValueRef, elt_val: ValueRef,
+                     index: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
-        B(cx).insert_element(VecVal, EltVal, Index)
+        B(cx).insert_element(vec_val, elt_val, index)
     }
 }
 
-pub fn ShuffleVector(cx: &Block, V1: ValueRef, V2: ValueRef,
-                     Mask: ValueRef) -> ValueRef {
+pub fn ShuffleVector(cx: &Block, v1: ValueRef, v2: ValueRef,
+                     mask: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
-        B(cx).shuffle_vector(V1, V2, Mask)
+        B(cx).shuffle_vector(v1, v2, mask)
     }
 }
 
-pub fn VectorSplat(cx: &Block, NumElts: uint, EltVal: ValueRef) -> ValueRef {
+pub fn VectorSplat(cx: &Block, num_elts: uint, elt_val: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
-        B(cx).vector_splat(NumElts, EltVal)
+        B(cx).vector_splat(num_elts, elt_val)
     }
 }
 
-pub fn ExtractValue(cx: &Block, AggVal: ValueRef, Index: uint) -> ValueRef {
+pub fn ExtractValue(cx: &Block, agg_val: ValueRef, index: uint) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
-        B(cx).extract_value(AggVal, Index)
+        B(cx).extract_value(agg_val, index)
     }
 }
 
-pub fn InsertValue(cx: &Block, AggVal: ValueRef, EltVal: ValueRef, Index: uint) -> ValueRef {
+pub fn InsertValue(cx: &Block, agg_val: ValueRef, elt_val: ValueRef, index: uint) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::nil().to_ref()); }
-        B(cx).insert_value(AggVal, EltVal, Index)
+        B(cx).insert_value(agg_val, elt_val, index)
     }
 }
 
-pub fn IsNull(cx: &Block, Val: ValueRef) -> ValueRef {
+pub fn IsNull(cx: &Block, val: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
-        B(cx).is_null(Val)
+        B(cx).is_null(val)
     }
 }
 
-pub fn IsNotNull(cx: &Block, Val: ValueRef) -> ValueRef {
+pub fn IsNotNull(cx: &Block, val: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable.get() { return llvm::LLVMGetUndef(Type::i1().to_ref()); }
-        B(cx).is_not_null(Val)
+        B(cx).is_not_null(val)
     }
 }
 
-pub fn PtrDiff(cx: &Block, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
+pub fn PtrDiff(cx: &Block, lhs: ValueRef, rhs: ValueRef) -> ValueRef {
     unsafe {
         let ccx = cx.fcx.ccx;
         if cx.unreachable.get() { return llvm::LLVMGetUndef(ccx.int_type.to_ref()); }
-        B(cx).ptrdiff(LHS, RHS)
+        B(cx).ptrdiff(lhs, rhs)
     }
 }
 
@@ -755,21 +755,21 @@ pub fn Trap(cx: &Block) {
     B(cx).trap();
 }
 
-pub fn LandingPad(cx: &Block, Ty: Type, PersFn: ValueRef,
-                  NumClauses: uint) -> ValueRef {
+pub fn LandingPad(cx: &Block, ty: Type, pers_fn: ValueRef,
+                  num_clauses: uint) -> ValueRef {
     check_not_terminated(cx);
     assert!(!cx.unreachable.get());
-    B(cx).landing_pad(Ty, PersFn, NumClauses)
+    B(cx).landing_pad(ty, pers_fn, num_clauses)
 }
 
-pub fn SetCleanup(cx: &Block, LandingPad: ValueRef) {
-    B(cx).set_cleanup(LandingPad)
+pub fn SetCleanup(cx: &Block, landing_pad: ValueRef) {
+    B(cx).set_cleanup(landing_pad)
 }
 
-pub fn Resume(cx: &Block, Exn: ValueRef) -> ValueRef {
+pub fn Resume(cx: &Block, exn: ValueRef) -> ValueRef {
     check_not_terminated(cx);
     terminate(cx, "Resume");
-    B(cx).resume(Exn)
+    B(cx).resume(exn)
 }
 
 // Atomic Operations
diff --git a/src/librustc/middle/trans/builder.rs b/src/librustc/middle/trans/builder.rs
index 4fa807ca608..9535edbf132 100644
--- a/src/librustc/middle/trans/builder.rs
+++ b/src/librustc/middle/trans/builder.rs
@@ -362,37 +362,37 @@ impl<'a> Builder<'a> {
         }
     }
 
-    pub fn neg(&self, V: ValueRef) -> ValueRef {
+    pub fn neg(&self, v: ValueRef) -> ValueRef {
         self.count_insn("neg");
         unsafe {
-            llvm::LLVMBuildNeg(self.llbuilder, V, noname())
+            llvm::LLVMBuildNeg(self.llbuilder, v, noname())
         }
     }
 
-    pub fn nswneg(&self, V: ValueRef) -> ValueRef {
+    pub fn nswneg(&self, v: ValueRef) -> ValueRef {
         self.count_insn("nswneg");
         unsafe {
-            llvm::LLVMBuildNSWNeg(self.llbuilder, V, noname())
+            llvm::LLVMBuildNSWNeg(self.llbuilder, v, noname())
         }
     }
 
-    pub fn nuwneg(&self, V: ValueRef) -> ValueRef {
+    pub fn nuwneg(&self, v: ValueRef) -> ValueRef {
         self.count_insn("nuwneg");
         unsafe {
-            llvm::LLVMBuildNUWNeg(self.llbuilder, V, noname())
+            llvm::LLVMBuildNUWNeg(self.llbuilder, v, noname())
         }
     }
-    pub fn fneg(&self, V: ValueRef) -> ValueRef {
+    pub fn fneg(&self, v: ValueRef) -> ValueRef {
         self.count_insn("fneg");
         unsafe {
-            llvm::LLVMBuildFNeg(self.llbuilder, V, noname())
+            llvm::LLVMBuildFNeg(self.llbuilder, v, noname())
         }
     }
 
-    pub fn not(&self, V: ValueRef) -> ValueRef {
+    pub fn not(&self, v: ValueRef) -> ValueRef {
         self.count_insn("not");
         unsafe {
-            llvm::LLVMBuildNot(self.llbuilder, V, noname())
+            llvm::LLVMBuildNot(self.llbuilder, v, noname())
         }
     }
 
@@ -561,17 +561,17 @@ impl<'a> Builder<'a> {
         }
     }
 
-    pub fn global_string(&self, _Str: *c_char) -> ValueRef {
+    pub fn global_string(&self, _str: *c_char) -> ValueRef {
         self.count_insn("globalstring");
         unsafe {
-            llvm::LLVMBuildGlobalString(self.llbuilder, _Str, noname())
+            llvm::LLVMBuildGlobalString(self.llbuilder, _str, noname())
         }
     }
 
-    pub fn global_string_ptr(&self, _Str: *c_char) -> ValueRef {
+    pub fn global_string_ptr(&self, _str: *c_char) -> ValueRef {
         self.count_insn("globalstringptr");
         unsafe {
-            llvm::LLVMBuildGlobalStringPtr(self.llbuilder, _Str, noname())
+            llvm::LLVMBuildGlobalStringPtr(self.llbuilder, _str, noname())
         }
     }
 
@@ -857,9 +857,9 @@ impl<'a> Builder<'a> {
     pub fn vector_splat(&self, num_elts: uint, elt: ValueRef) -> ValueRef {
         unsafe {
             let elt_ty = val_ty(elt);
-            let Undef = llvm::LLVMGetUndef(Type::vector(&elt_ty, num_elts as u64).to_ref());
-            let vec = self.insert_element(Undef, elt, C_i32(0));
-            self.shuffle_vector(vec, Undef, C_null(Type::vector(&Type::i32(), num_elts as u64)))
+            let undef = llvm::LLVMGetUndef(Type::vector(&elt_ty, num_elts as u64).to_ref());
+            let vec = self.insert_element(undef, elt, C_i32(0));
+            self.shuffle_vector(vec, undef, C_null(Type::vector(&Type::i32(), num_elts as u64)))
         }
     }
 
@@ -902,17 +902,17 @@ impl<'a> Builder<'a> {
 
     pub fn trap(&self) {
         unsafe {
-            let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(self.llbuilder);
-            let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB);
-            let M: ModuleRef = llvm::LLVMGetGlobalParent(FN);
-            let T: ValueRef = "llvm.trap".with_c_str(|buf| {
-                llvm::LLVMGetNamedFunction(M, buf)
+            let bb: BasicBlockRef = llvm::LLVMGetInsertBlock(self.llbuilder);
+            let fn_: ValueRef = llvm::LLVMGetBasicBlockParent(bb);
+            let m: ModuleRef = llvm::LLVMGetGlobalParent(fn_);
+            let t: ValueRef = "llvm.trap".with_c_str(|buf| {
+                llvm::LLVMGetNamedFunction(m, buf)
             });
-            assert!((T as int != 0));
+            assert!((t as int != 0));
             let args: &[ValueRef] = [];
             self.count_insn("trap");
             llvm::LLVMBuildCall(
-                self.llbuilder, T, args.as_ptr(), args.len() as c_uint, noname());
+                self.llbuilder, t, args.as_ptr(), args.len() as c_uint, noname());
         }
     }
 
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index e7e69917ebb..75783f5c47b 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -175,9 +175,9 @@ impl Drop for BuilderRef_res {
     }
 }
 
-pub fn BuilderRef_res(B: BuilderRef) -> BuilderRef_res {
+pub fn BuilderRef_res(b: BuilderRef) -> BuilderRef_res {
     BuilderRef_res {
-        B: B
+        B: b
     }
 }
 
@@ -654,9 +654,9 @@ pub fn C_struct(elts: &[ValueRef], packed: bool) -> ValueRef {
     }
 }
 
-pub fn C_named_struct(T: Type, elts: &[ValueRef]) -> ValueRef {
+pub fn C_named_struct(t: Type, elts: &[ValueRef]) -> ValueRef {
     unsafe {
-        llvm::LLVMConstNamedStruct(T.to_ref(), elts.as_ptr(), elts.len() as c_uint)
+        llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint)
     }
 }
 
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index 793c70770a9..55d44e00bae 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -302,8 +302,8 @@ fn const_expr_unadjusted(cx: @CrateContext, e: &ast::Expr,
                          is_local: bool) -> (ValueRef, bool) {
     let map_list = |exprs: &[@ast::Expr]| {
         exprs.iter().map(|&e| const_expr(cx, e, is_local))
-             .fold((~[], true), |(L, all_inlineable), (val, inlineable)| {
-                (vec::append_one(L, val), all_inlineable && inlineable)
+             .fold((~[], true), |(l, all_inlineable), (val, inlineable)| {
+                (vec::append_one(l, val), all_inlineable && inlineable)
              })
     };
     unsafe {
diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs
index d57f0fc0d33..2aab8926223 100644
--- a/src/librustc/middle/trans/controlflow.rs
+++ b/src/librustc/middle/trans/controlflow.rs
@@ -330,17 +330,17 @@ pub fn trans_fail<'a>(
                   sp: Span,
                   fail_str: InternedString)
                   -> &'a Block<'a> {
-    let V_fail_str = C_cstr(bcx.ccx(), fail_str);
+    let v_fail_str = C_cstr(bcx.ccx(), fail_str);
     let _icx = push_ctxt("trans_fail_value");
     let ccx = bcx.ccx();
     let sess = bcx.sess();
     let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
-    let V_filename = C_cstr(bcx.ccx(),
+    let v_filename = C_cstr(bcx.ccx(),
                             token::intern_and_get_ident(loc.file.name));
-    let V_line = loc.line as int;
-    let V_str = PointerCast(bcx, V_fail_str, Type::i8p());
-    let V_filename = PointerCast(bcx, V_filename, Type::i8p());
-    let args = ~[V_str, V_filename, C_int(ccx, V_line)];
+    let v_line = loc.line as int;
+    let v_str = PointerCast(bcx, v_fail_str, Type::i8p());
+    let v_filename = PointerCast(bcx, v_filename, Type::i8p());
+    let args = ~[v_str, v_filename, C_int(ccx, v_line)];
     let did = langcall(bcx, Some(sp), "", FailFnLangItem);
     let bcx = callee::trans_lang_call(bcx, did, args, Some(expr::Ignore)).bcx;
     Unreachable(bcx);
diff --git a/src/librustc/util/sha2.rs b/src/librustc/util/sha2.rs
index bd17f6b5814..6a6b86b37a3 100644
--- a/src/librustc/util/sha2.rs
+++ b/src/librustc/util/sha2.rs
@@ -338,12 +338,12 @@ impl Engine256State {
         let mut g = self.H6;
         let mut h = self.H7;
 
-        let mut W = [0u32, ..64];
+        let mut w = [0u32, ..64];
 
         // Sha-512 and Sha-256 use basically the same calculations which are implemented
         // by these macros. Inlining the calculations seems to result in better generated code.
         macro_rules! schedule_round( ($t:expr) => (
-                W[$t] = sigma1(W[$t - 2]) + W[$t - 7] + sigma0(W[$t - 15]) + W[$t - 16];
+                w[$t] = sigma1(w[$t - 2]) + w[$t - 7] + sigma0(w[$t - 15]) + w[$t - 16];
                 )
         )
 
@@ -351,14 +351,14 @@ impl Engine256State {
             ($A:ident, $B:ident, $C:ident, $D:ident,
              $E:ident, $F:ident, $G:ident, $H:ident, $K:ident, $t:expr) => (
                 {
-                    $H += sum1($E) + ch($E, $F, $G) + $K[$t] + W[$t];
+                    $H += sum1($E) + ch($E, $F, $G) + $K[$t] + w[$t];
                     $D += $H;
                     $H += sum0($A) + maj($A, $B, $C);
                 }
              )
         )
 
-        read_u32v_be(W.mut_slice(0, 16), data);
+        read_u32v_be(w.mut_slice(0, 16), data);
 
         // Putting the message schedule inside the same loop as the round calculations allows for
         // the compiler to generate better code.