Downcase std modules again, move to :: for module dereferencing

This should be a snapshot transition.

1 files changed, 187 insertions, 184 deletions

diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index bc7338ff..ba607d3e 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -1,29 +1,29 @@
-import std.Vec;
-import std.Str;
-import std.Str.rustrt.sbuf;
-import std.Vec.rustrt.vbuf;
-
-import llvm.ModuleRef;
-import llvm.ContextRef;
-import llvm.TypeRef;
-import llvm.TypeHandleRef;
-import llvm.ValueRef;
-import llvm.BasicBlockRef;
-import llvm.BuilderRef;
-import llvm.ModuleProviderRef;
-import llvm.MemoryBufferRef;
-import llvm.PassManagerRef;
-import llvm.UseRef;
-import llvm.TargetDataRef;
-import llvm.Linkage;
-import llvm.Attribute;
-import llvm.Visibility;
-import llvm.CallConv;
-import llvm.IntPredicate;
-import llvm.RealPredicate;
-import llvm.Opcode;
-import llvm.ObjectFileRef;
-import llvm.SectionIteratorRef;
+import std::_vec;
+import std::_str;
+import std::_str::rustrt::sbuf;
+import std::_vec::rustrt::vbuf;
+
+import llvm::ModuleRef;
+import llvm::ContextRef;
+import llvm::TypeRef;
+import llvm::TypeHandleRef;
+import llvm::ValueRef;
+import llvm::BasicBlockRef;
+import llvm::BuilderRef;
+import llvm::ModuleProviderRef;
+import llvm::MemoryBufferRef;
+import llvm::PassManagerRef;
+import llvm::UseRef;
+import llvm::TargetDataRef;
+import llvm::Linkage;
+import llvm::Attribute;
+import llvm::Visibility;
+import llvm::CallConv;
+import llvm::IntPredicate;
+import llvm::RealPredicate;
+import llvm::Opcode;
+import llvm::ObjectFileRef;
+import llvm::SectionIteratorRef;
 
 type ULongLong = u64;
 type LongLong = i64;
@@ -717,7 +717,7 @@ native mod llvm = llvm_lib {
     fn LLVMBuildSelect(BuilderRef B, ValueRef If,
                        ValueRef Then, ValueRef Else,
                        sbuf Name) -> ValueRef;
-    fn LLVMBuildVAArg(BuilderRef B, ValueRef List, TypeRef Ty,
+    fn LLVMBuildVAArg(BuilderRef B, ValueRef list, TypeRef Ty,
                       sbuf Name) -> ValueRef;
     fn LLVMBuildExtractElement(BuilderRef B, ValueRef VecVal,
                                ValueRef Index, sbuf Name) -> ValueRef;
@@ -835,7 +835,7 @@ native mod llvm = llvm_lib {
     /** Destroys a section iterator. */
     fn LLVMDisposeSectionIterator(SectionIteratorRef SI);
     /** Returns true if the section iterator is at the end of the section
-        List. */
+        list: */
     fn LLVMIsSectionIteratorAtEnd(ObjectFileRef ObjectFile,
                                   SectionIteratorRef SI) -> Bool;
     /** Moves the section iterator to point to the next section. */
@@ -868,7 +868,7 @@ native mod llvm = llvm_lib {
     /** Parses the bitcode in the given memory buffer. */
     fn LLVMRustParseBitcode(MemoryBufferRef MemBuf) -> ModuleRef;
 
-    /** FiXME: Hacky adaptor for lack of ULongLong in FFI. */
+    /** FiXME: Hacky adaptor for lack of ULongLong in FFI: */
     fn LLVMRustConstSmallInt(TypeRef IntTy, uint N,
                              Bool SignExtend) -> ValueRef;
 
@@ -895,46 +895,46 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     fn RetVoid()  -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildRetVoid(B);
+        ret llvm::LLVMBuildRetVoid(B);
     }
 
     fn Ret(ValueRef V) -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildRet(B, V);
+        ret llvm::LLVMBuildRet(B, V);
     }
 
     fn AggregateRet(vec[ValueRef] RetVals) -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildAggregateRet(B,
-                                       Vec.buf[ValueRef](RetVals),
-                                       Vec.len[ValueRef](RetVals));
+        ret llvm::LLVMBuildAggregateRet(B,
+                                       _vec::buf[ValueRef](RetVals),
+                                       _vec::len[ValueRef](RetVals));
     }
 
     fn Br(BasicBlockRef Dest) -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildBr(B, Dest);
+        ret llvm::LLVMBuildBr(B, Dest);
     }
 
     fn CondBr(ValueRef If, BasicBlockRef Then,
               BasicBlockRef Else) -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildCondBr(B, If, Then, Else);
+        ret llvm::LLVMBuildCondBr(B, If, Then, Else);
     }
 
     fn Switch(ValueRef V, BasicBlockRef Else, uint NumCases) -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildSwitch(B, V, Else, NumCases);
+        ret llvm::LLVMBuildSwitch(B, V, Else, NumCases);
     }
 
     fn IndirectBr(ValueRef Addr, uint NumDests) -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildIndirectBr(B, Addr, NumDests);
+        ret llvm::LLVMBuildIndirectBr(B, Addr, NumDests);
     }
 
     fn Invoke(ValueRef Fn,
@@ -943,352 +943,352 @@ obj builder(BuilderRef B, @mutable bool terminated) {
               BasicBlockRef Catch) -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildInvoke(B, Fn,
-                                 Vec.buf[ValueRef](Args),
-                                 Vec.len[ValueRef](Args),
+        ret llvm::LLVMBuildInvoke(B, Fn,
+                                 _vec::buf[ValueRef](Args),
+                                 _vec::len[ValueRef](Args),
                                  Then, Catch,
-                                 Str.buf(""));
+                                 _str::buf(""));
     }
 
     fn Unwind() -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildUnwind(B);
+        ret llvm::LLVMBuildUnwind(B);
     }
 
     fn Unreachable() -> ValueRef {
         assert (!*terminated);
         *terminated = true;
-        ret llvm.LLVMBuildUnreachable(B);
+        ret llvm::LLVMBuildUnreachable(B);
     }
 
     /* Arithmetic */
     fn Add(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildAdd(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildAdd(B, LHS, RHS, _str::buf(""));
     }
 
     fn NSWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNSWAdd(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildNSWAdd(B, LHS, RHS, _str::buf(""));
     }
 
     fn NUWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNUWAdd(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildNUWAdd(B, LHS, RHS, _str::buf(""));
     }
 
     fn FAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFAdd(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildFAdd(B, LHS, RHS, _str::buf(""));
     }
 
     fn Sub(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildSub(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildSub(B, LHS, RHS, _str::buf(""));
     }
 
     fn NSWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNSWSub(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildNSWSub(B, LHS, RHS, _str::buf(""));
     }
 
     fn NUWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNUWSub(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildNUWSub(B, LHS, RHS, _str::buf(""));
     }
 
     fn FSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFSub(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildFSub(B, LHS, RHS, _str::buf(""));
     }
 
     fn Mul(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildMul(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildMul(B, LHS, RHS, _str::buf(""));
     }
 
     fn NSWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNSWMul(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildNSWMul(B, LHS, RHS, _str::buf(""));
     }
 
     fn NUWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNUWMul(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildNUWMul(B, LHS, RHS, _str::buf(""));
     }
 
     fn FMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFMul(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildFMul(B, LHS, RHS, _str::buf(""));
     }
 
     fn UDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildUDiv(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildUDiv(B, LHS, RHS, _str::buf(""));
     }
 
     fn SDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildSDiv(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildSDiv(B, LHS, RHS, _str::buf(""));
     }
 
     fn ExactSDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildExactSDiv(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildExactSDiv(B, LHS, RHS, _str::buf(""));
     }
 
     fn FDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFDiv(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildFDiv(B, LHS, RHS, _str::buf(""));
     }
 
     fn URem(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildURem(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildURem(B, LHS, RHS, _str::buf(""));
     }
 
     fn SRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildSRem(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildSRem(B, LHS, RHS, _str::buf(""));
     }
 
     fn FRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFRem(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildFRem(B, LHS, RHS, _str::buf(""));
     }
 
     fn Shl(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildShl(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildShl(B, LHS, RHS, _str::buf(""));
     }
 
     fn LShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildLShr(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildLShr(B, LHS, RHS, _str::buf(""));
     }
 
     fn AShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildAShr(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildAShr(B, LHS, RHS, _str::buf(""));
     }
 
     fn And(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildAnd(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildAnd(B, LHS, RHS, _str::buf(""));
     }
 
     fn Or(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildOr(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildOr(B, LHS, RHS, _str::buf(""));
     }
 
     fn Xor(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildXor(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildXor(B, LHS, RHS, _str::buf(""));
     }
 
     fn BinOp(Opcode Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildBinOp(B, Op, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildBinOp(B, Op, LHS, RHS, _str::buf(""));
     }
 
     fn Neg(ValueRef V) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNeg(B, V, Str.buf(""));
+        ret llvm::LLVMBuildNeg(B, V, _str::buf(""));
     }
 
     fn NSWNeg(ValueRef V) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNSWNeg(B, V, Str.buf(""));
+        ret llvm::LLVMBuildNSWNeg(B, V, _str::buf(""));
     }
 
     fn NUWNeg(ValueRef V) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNUWNeg(B, V, Str.buf(""));
+        ret llvm::LLVMBuildNUWNeg(B, V, _str::buf(""));
     }
     fn FNeg(ValueRef V) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFNeg(B, V, Str.buf(""));
+        ret llvm::LLVMBuildFNeg(B, V, _str::buf(""));
     }
     fn Not(ValueRef V) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildNot(B, V, Str.buf(""));
+        ret llvm::LLVMBuildNot(B, V, _str::buf(""));
     }
 
     /* Memory */
     fn Malloc(TypeRef Ty) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildMalloc(B, Ty, Str.buf(""));
+        ret llvm::LLVMBuildMalloc(B, Ty, _str::buf(""));
     }
 
     fn ArrayMalloc(TypeRef Ty, ValueRef Val) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildArrayMalloc(B, Ty, Val, Str.buf(""));
+        ret llvm::LLVMBuildArrayMalloc(B, Ty, Val, _str::buf(""));
     }
 
     fn Alloca(TypeRef Ty) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildAlloca(B, Ty, Str.buf(""));
+        ret llvm::LLVMBuildAlloca(B, Ty, _str::buf(""));
     }
 
     fn ArrayAlloca(TypeRef Ty, ValueRef Val) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildArrayAlloca(B, Ty, Val, Str.buf(""));
+        ret llvm::LLVMBuildArrayAlloca(B, Ty, Val, _str::buf(""));
     }
 
     fn Free(ValueRef PointerVal) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFree(B, PointerVal);
+        ret llvm::LLVMBuildFree(B, PointerVal);
     }
 
     fn Load(ValueRef PointerVal) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildLoad(B, PointerVal, Str.buf(""));
+        ret llvm::LLVMBuildLoad(B, PointerVal, _str::buf(""));
     }
 
     fn Store(ValueRef Val, ValueRef Ptr) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildStore(B, Val, Ptr);
+        ret llvm::LLVMBuildStore(B, Val, Ptr);
     }
 
     fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildGEP(B, Pointer,
-                              Vec.buf[ValueRef](Indices),
-                              Vec.len[ValueRef](Indices),
-                              Str.buf(""));
+        ret llvm::LLVMBuildGEP(B, Pointer,
+                              _vec::buf[ValueRef](Indices),
+                              _vec::len[ValueRef](Indices),
+                              _str::buf(""));
     }
 
     fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildInBoundsGEP(B, Pointer,
-                                      Vec.buf[ValueRef](Indices),
-                                      Vec.len[ValueRef](Indices),
-                                      Str.buf(""));
+        ret llvm::LLVMBuildInBoundsGEP(B, Pointer,
+                                      _vec::buf[ValueRef](Indices),
+                                      _vec::len[ValueRef](Indices),
+                                      _str::buf(""));
     }
 
     fn StructGEP(ValueRef Pointer, uint Idx) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildStructGEP(B, Pointer, Idx, Str.buf(""));
+        ret llvm::LLVMBuildStructGEP(B, Pointer, Idx, _str::buf(""));
     }
 
     fn GlobalString(sbuf _Str) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildGlobalString(B, _Str, Str.buf(""));
+        ret llvm::LLVMBuildGlobalString(B, _Str, _str::buf(""));
     }
 
     fn GlobalStringPtr(sbuf _Str) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildGlobalStringPtr(B, _Str, Str.buf(""));
+        ret llvm::LLVMBuildGlobalStringPtr(B, _Str, _str::buf(""));
     }
 
     /* Casts */
     fn Trunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildTrunc(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildTrunc(B, Val, DestTy, _str::buf(""));
     }
 
     fn ZExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildZExt(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildZExt(B, Val, DestTy, _str::buf(""));
     }
 
     fn SExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildSExt(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildSExt(B, Val, DestTy, _str::buf(""));
     }
 
     fn FPToUI(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFPToUI(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildFPToUI(B, Val, DestTy, _str::buf(""));
     }
 
     fn FPToSI(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFPToSI(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildFPToSI(B, Val, DestTy, _str::buf(""));
     }
 
     fn UIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildUIToFP(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildUIToFP(B, Val, DestTy, _str::buf(""));
     }
 
     fn SIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildSIToFP(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildSIToFP(B, Val, DestTy, _str::buf(""));
     }
 
     fn FPTrunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFPTrunc(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildFPTrunc(B, Val, DestTy, _str::buf(""));
     }
 
     fn FPExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFPExt(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildFPExt(B, Val, DestTy, _str::buf(""));
     }
 
     fn PtrToInt(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildPtrToInt(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildPtrToInt(B, Val, DestTy, _str::buf(""));
     }
 
     fn IntToPtr(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildIntToPtr(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildIntToPtr(B, Val, DestTy, _str::buf(""));
     }
 
     fn BitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildBitCast(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildBitCast(B, Val, DestTy, _str::buf(""));
     }
 
     fn ZExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildZExtOrBitCast(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildZExtOrBitCast(B, Val, DestTy, _str::buf(""));
     }
 
     fn SExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildSExtOrBitCast(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildSExtOrBitCast(B, Val, DestTy, _str::buf(""));
     }
 
     fn TruncOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildTruncOrBitCast(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildTruncOrBitCast(B, Val, DestTy, _str::buf(""));
     }
 
     fn Cast(Opcode Op, ValueRef Val, TypeRef DestTy, sbuf Name) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildCast(B, Op, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildCast(B, Op, Val, DestTy, _str::buf(""));
     }
 
     fn PointerCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildPointerCast(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildPointerCast(B, Val, DestTy, _str::buf(""));
     }
 
     fn IntCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildIntCast(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildIntCast(B, Val, DestTy, _str::buf(""));
     }
 
     fn FPCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFPCast(B, Val, DestTy, Str.buf(""));
+        ret llvm::LLVMBuildFPCast(B, Val, DestTy, _str::buf(""));
     }
 
 
     /* Comparisons */
     fn ICmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildICmp(B, Op, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildICmp(B, Op, LHS, RHS, _str::buf(""));
     }
 
     fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildFCmp(B, Op, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildFCmp(B, Op, LHS, RHS, _str::buf(""));
     }
 
 
@@ -1296,131 +1296,133 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     fn Phi(TypeRef Ty, vec[ValueRef] vals,
            vec[BasicBlockRef] bbs) -> ValueRef {
         assert (!*terminated);
-        auto phi = llvm.LLVMBuildPhi(B, Ty, Str.buf(""));
-        assert (Vec.len[ValueRef](vals) == Vec.len[BasicBlockRef](bbs));
-        llvm.LLVMAddIncoming(phi,
-                             Vec.buf[ValueRef](vals),
-                             Vec.buf[BasicBlockRef](bbs),
-                             Vec.len[ValueRef](vals));
+        auto phi = llvm::LLVMBuildPhi(B, Ty, _str::buf(""));
+        assert (_vec::len[ValueRef](vals) == _vec::len[BasicBlockRef](bbs));
+        llvm::LLVMAddIncoming(phi,
+                             _vec::buf[ValueRef](vals),
+                             _vec::buf[BasicBlockRef](bbs),
+                             _vec::len[ValueRef](vals));
         ret phi;
     }
 
     fn AddIncomingToPhi(ValueRef phi,
                         vec[ValueRef] vals,
                         vec[BasicBlockRef] bbs) {
-        assert (Vec.len[ValueRef](vals) == Vec.len[BasicBlockRef](bbs));
-        llvm.LLVMAddIncoming(phi,
-                             Vec.buf[ValueRef](vals),
-                             Vec.buf[BasicBlockRef](bbs),
-                             Vec.len[ValueRef](vals));
+        assert (_vec::len[ValueRef](vals) == _vec::len[BasicBlockRef](bbs));
+        llvm::LLVMAddIncoming(phi,
+                             _vec::buf[ValueRef](vals),
+                             _vec::buf[BasicBlockRef](bbs),
+                             _vec::len[ValueRef](vals));
     }
 
     fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildCall(B, Fn,
-                               Vec.buf[ValueRef](Args),
-                               Vec.len[ValueRef](Args),
-                               Str.buf(""));
+        ret llvm::LLVMBuildCall(B, Fn,
+                               _vec::buf[ValueRef](Args),
+                               _vec::len[ValueRef](Args),
+                               _str::buf(""));
     }
 
     fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
         assert (!*terminated);
-        auto v = llvm.LLVMBuildCall(B, Fn,
-                                    Vec.buf[ValueRef](Args),
-                                    Vec.len[ValueRef](Args),
-                                    Str.buf(""));
-        llvm.LLVMSetInstructionCallConv(v, LLVMFastCallConv);
+        auto v = llvm::LLVMBuildCall(B, Fn,
+                                    _vec::buf[ValueRef](Args),
+                                    _vec::len[ValueRef](Args),
+                                    _str::buf(""));
+        llvm::LLVMSetInstructionCallConv(v, LLVMFastCallConv);
         ret v;
     }
 
     fn Select(ValueRef If, ValueRef Then, ValueRef Else) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildSelect(B, If, Then, Else, Str.buf(""));
+        ret llvm::LLVMBuildSelect(B, If, Then, Else, _str::buf(""));
     }
 
-    fn VAArg(ValueRef List, TypeRef Ty) -> ValueRef {
+    fn VAArg(ValueRef list, TypeRef Ty) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildVAArg(B, List, Ty, Str.buf(""));
+        ret llvm::LLVMBuildVAArg(B, list, Ty, _str::buf(""));
     }
 
     fn ExtractElement(ValueRef VecVal, ValueRef Index) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildExtractElement(B, VecVal, Index, Str.buf(""));
+        ret llvm::LLVMBuildExtractElement(B, VecVal, Index, _str::buf(""));
     }
 
     fn InsertElement(ValueRef VecVal, ValueRef EltVal,
                      ValueRef Index) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildInsertElement(B, VecVal, EltVal, Index,
-                                        Str.buf(""));
+        ret llvm::LLVMBuildInsertElement(B, VecVal, EltVal, Index,
+                                        _str::buf(""));
     }
 
     fn ShuffleVector(ValueRef V1, ValueRef V2, ValueRef Mask) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildShuffleVector(B, V1, V2, Mask, Str.buf(""));
+        ret llvm::LLVMBuildShuffleVector(B, V1, V2, Mask, _str::buf(""));
     }
 
     fn ExtractValue(ValueRef AggVal, uint Index) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildExtractValue(B, AggVal, Index, Str.buf(""));
+        ret llvm::LLVMBuildExtractValue(B, AggVal, Index, _str::buf(""));
     }
 
     fn InsertValue(ValueRef AggVal, ValueRef EltVal,
                    uint Index) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildInsertValue(B, AggVal, EltVal, Index, Str.buf(""));
+        ret llvm::LLVMBuildInsertValue(B, AggVal, EltVal, Index,
+                                       _str::buf(""));
     }
 
     fn IsNull(ValueRef Val) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildIsNull(B, Val, Str.buf(""));
+        ret llvm::LLVMBuildIsNull(B, Val, _str::buf(""));
     }
 
     fn IsNotNull(ValueRef Val) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildIsNotNull(B, Val, Str.buf(""));
+        ret llvm::LLVMBuildIsNotNull(B, Val, _str::buf(""));
     }
 
     fn PtrDiff(ValueRef LHS, ValueRef RHS) -> ValueRef {
         assert (!*terminated);
-        ret llvm.LLVMBuildPtrDiff(B, LHS, RHS, Str.buf(""));
+        ret llvm::LLVMBuildPtrDiff(B, LHS, RHS, _str::buf(""));
     }
 
     fn Trap() -> ValueRef {
         assert (!*terminated);
-        let BasicBlockRef BB = llvm.LLVMGetInsertBlock(B);
-        let ValueRef FN = llvm.LLVMGetBasicBlockParent(BB);
-        let ModuleRef M = llvm.LLVMGetGlobalParent(FN);
-        let ValueRef T = llvm.LLVMGetNamedFunction(M, Str.buf("llvm.trap"));
+        let BasicBlockRef BB = llvm::LLVMGetInsertBlock(B);
+        let ValueRef FN = llvm::LLVMGetBasicBlockParent(BB);
+        let ModuleRef M = llvm::LLVMGetGlobalParent(FN);
+        let ValueRef T = llvm::LLVMGetNamedFunction(M,
+                                                    _str::buf("llvm.trap"));
         assert (T as int != 0);
         let vec[ValueRef] Args = vec();
-        ret llvm.LLVMBuildCall(B, T,
-                               Vec.buf[ValueRef](Args),
-                               Vec.len[ValueRef](Args),
-                               Str.buf(""));
+        ret llvm::LLVMBuildCall(B, T,
+                               _vec::buf[ValueRef](Args),
+                               _vec::len[ValueRef](Args),
+                               _str::buf(""));
     }
 
     drop {
-        llvm.LLVMDisposeBuilder(B);
+        llvm::LLVMDisposeBuilder(B);
     }
 }
 
 /* Memory-managed object interface to type handles. */
 
 obj type_handle_dtor(TypeHandleRef TH) {
-    drop { llvm.LLVMDisposeTypeHandle(TH); }
+    drop { llvm::LLVMDisposeTypeHandle(TH); }
 }
 
 type type_handle = rec(TypeHandleRef llth, type_handle_dtor dtor);
 
 fn mk_type_handle() -> type_handle {
-    auto th = llvm.LLVMCreateTypeHandle(llvm.LLVMOpaqueType());
+    auto th = llvm::LLVMCreateTypeHandle(llvm::LLVMOpaqueType());
     ret rec(llth=th, dtor=type_handle_dtor(th));
 }
 
 
-state obj type_names(std.Map.hashmap[TypeRef, str] type_names,
-                    std.Map.hashmap[str, TypeRef] named_types) {
+state obj type_names(std::map::hashmap[TypeRef, str] type_names,
+                    std::map::hashmap[str, TypeRef] named_types) {
 
     fn associate(str s, TypeRef t) {
         assert (!named_types.contains_key(s));
@@ -1447,7 +1449,7 @@ state obj type_names(std.Map.hashmap[TypeRef, str] type_names,
 }
 
 fn mk_type_names() -> type_names {
-    auto nt = util.common.new_str_hash[TypeRef]();
+    auto nt = util::common::new_str_hash[TypeRef]();
 
     fn hash(&TypeRef t) -> uint {
         ret t as uint;
@@ -1457,9 +1459,9 @@ fn mk_type_names() -> type_names {
         ret (a as uint) == (b as uint);
     }
 
-    let std.Map.hashfn[TypeRef] hasher = hash;
-    let std.Map.eqfn[TypeRef] eqer = eq;
-    auto tn = std.Map.mk_hashmap[TypeRef,str](hasher, eqer);
+    let std::map::hashfn[TypeRef] hasher = hash;
+    let std::map::eqfn[TypeRef] eqer = eq;
+    auto tn = std::map::mk_hashmap[TypeRef,str](hasher, eqer);
 
     ret type_names(tn, nt);
 }
@@ -1478,7 +1480,7 @@ fn type_to_str_inner(type_names names,
 
     auto outer = outer0 + vec(ty);
 
-    let int kind = llvm.LLVMGetTypeKind(ty);
+    let int kind = llvm::LLVMGetTypeKind(ty);
 
     fn tys_str(type_names names,
                vec[TypeRef] outer, vec[TypeRef] tys) -> str {
@@ -1497,7 +1499,7 @@ fn type_to_str_inner(type_names names,
 
     alt (kind) {
 
-        // FIXME: more enum-as-int constants determined from Core.h;
+        // FIXME: more enum-as-int constants determined from Core::h;
         // horrible, horrible. Complete as needed.
 
         case (0) { ret "Void"; }
@@ -1509,16 +1511,17 @@ fn type_to_str_inner(type_names names,
         case (6) { ret "Label"; }
 
         case (7) {
-            ret "i" + util.common.istr(llvm.LLVMGetIntTypeWidth(ty) as int);
+            ret "i" + util::common::istr(llvm::LLVMGetIntTypeWidth(ty)
+                                         as int);
         }
 
         case (8) {
             auto s = "fn(";
-            let TypeRef out_ty = llvm.LLVMGetReturnType(ty);
-            let uint n_args = llvm.LLVMCountParamTypes(ty);
+            let TypeRef out_ty = llvm::LLVMGetReturnType(ty);
+            let uint n_args = llvm::LLVMCountParamTypes(ty);
             let vec[TypeRef] args =
-                Vec.init_elt[TypeRef](0 as TypeRef, n_args);
-            llvm.LLVMGetParamTypes(ty, Vec.buf[TypeRef](args));
+                _vec::init_elt[TypeRef](0 as TypeRef, n_args);
+            llvm::LLVMGetParamTypes(ty, _vec::buf[TypeRef](args));
             s += tys_str(names, outer, args);
             s += ") -> ";
             s += type_to_str_inner(names, outer, out_ty);
@@ -1527,10 +1530,10 @@ fn type_to_str_inner(type_names names,
 
         case (9) {
             let str s = "{";
-            let uint n_elts = llvm.LLVMCountStructElementTypes(ty);
+            let uint n_elts = llvm::LLVMCountStructElementTypes(ty);
             let vec[TypeRef] elts =
-                Vec.init_elt[TypeRef](0 as TypeRef, n_elts);
-            llvm.LLVMGetStructElementTypes(ty, Vec.buf[TypeRef](elts));
+                _vec::init_elt[TypeRef](0 as TypeRef, n_elts);
+            llvm::LLVMGetStructElementTypes(ty, _vec::buf[TypeRef](elts));
             s += tys_str(names, outer, elts);
             s += "}";
             ret s;
@@ -1543,12 +1546,12 @@ fn type_to_str_inner(type_names names,
             for (TypeRef tout in outer0) {
                 i += 1u;
                 if (tout as int == ty as int) {
-                    let uint n = Vec.len[TypeRef](outer0) - i;
-                    ret "*\\" + util.common.istr(n as int);
+                    let uint n = _vec::len[TypeRef](outer0) - i;
+                    ret "*\\" + util::common::istr(n as int);
                 }
             }
             ret "*" + type_to_str_inner(names, outer,
-                                        llvm.LLVMGetElementType(ty));
+                                        llvm::LLVMGetElementType(ty));
         }
 
         case (12) { ret "Opaque"; }
@@ -1564,52 +1567,52 @@ fn type_to_str_inner(type_names names,
 /* Memory-managed interface to target data. */
 
 obj target_data_dtor(TargetDataRef TD) {
-    drop { llvm.LLVMDisposeTargetData(TD); }
+    drop { llvm::LLVMDisposeTargetData(TD); }
 }
 
 type target_data = rec(TargetDataRef lltd, target_data_dtor dtor);
 
 fn mk_target_data(str string_rep) -> target_data {
-    auto lltd = llvm.LLVMCreateTargetData(Str.buf(string_rep));
+    auto lltd = llvm::LLVMCreateTargetData(_str::buf(string_rep));
     ret rec(lltd=lltd, dtor=target_data_dtor(lltd));
 }
 
 /* Memory-managed interface to pass managers. */
 
 obj pass_manager_dtor(PassManagerRef PM) {
-    drop { llvm.LLVMDisposePassManager(PM); }
+    drop { llvm::LLVMDisposePassManager(PM); }
 }
 
 type pass_manager = rec(PassManagerRef llpm, pass_manager_dtor dtor);
 
 fn mk_pass_manager() -> pass_manager {
-    auto llpm = llvm.LLVMCreatePassManager();
+    auto llpm = llvm::LLVMCreatePassManager();
     ret rec(llpm=llpm, dtor=pass_manager_dtor(llpm));
 }
 
 /* Memory-managed interface to object files. */
 
 obj object_file_dtor(ObjectFileRef ObjectFile) {
-    drop { llvm.LLVMDisposeObjectFile(ObjectFile); }
+    drop { llvm::LLVMDisposeObjectFile(ObjectFile); }
 }
 
 type object_file = rec(ObjectFileRef llof, object_file_dtor dtor);
 
 fn mk_object_file(MemoryBufferRef llmb) -> object_file {
-    auto llof = llvm.LLVMCreateObjectFile(llmb);
+    auto llof = llvm::LLVMCreateObjectFile(llmb);
     ret rec(llof=llof, dtor=object_file_dtor(llof));
 }
 
 /* Memory-managed interface to section iterators. */
 
 obj section_iter_dtor(SectionIteratorRef SI) {
-    drop { llvm.LLVMDisposeSectionIterator(SI); }
+    drop { llvm::LLVMDisposeSectionIterator(SI); }
 }
 
 type section_iter = rec(SectionIteratorRef llsi, section_iter_dtor dtor);
 
 fn mk_section_iter(ObjectFileRef llof) -> section_iter {
-    auto llsi = llvm.LLVMGetSections(llof);
+    auto llsi = llvm::LLVMGetSections(llof);
     ret rec(llsi=llsi, dtor=section_iter_dtor(llsi));
 }