Use different syntax for checks that matter to typestate

This giant commit changes the syntax of Rust to use "assert" for
"check" expressions that didn't mean anything to the typestate
system, and continue using "check" for checks that are used as
part of typestate checking.

Most of the changes are just replacing "check" with "assert" in test
cases and rustc.

1 files changed, 93 insertions, 93 deletions

diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index 41ec1836..070174ba 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -861,19 +861,19 @@ obj builder(BuilderRef B, @mutable bool terminated) {
 
     /* Terminators */
     fn RetVoid()  -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildRetVoid(B);
     }
 
     fn Ret(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildRet(B, V);
     }
 
     fn AggregateRet(vec[ValueRef] RetVals) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildAggregateRet(B,
                                        _vec.buf[ValueRef](RetVals),
@@ -881,26 +881,26 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Br(BasicBlockRef Dest) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildBr(B, Dest);
     }
 
     fn CondBr(ValueRef If, BasicBlockRef Then,
               BasicBlockRef Else) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildCondBr(B, If, Then, Else);
     }
 
     fn Switch(ValueRef V, BasicBlockRef Else, uint NumCases) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildSwitch(B, V, Else, NumCases);
     }
 
     fn IndirectBr(ValueRef Addr, uint NumDests) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildIndirectBr(B, Addr, NumDests);
     }
@@ -909,7 +909,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
               vec[ValueRef] Args,
               BasicBlockRef Then,
               BasicBlockRef Catch) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildInvoke(B, Fn,
                                  _vec.buf[ValueRef](Args),
@@ -919,209 +919,209 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Unwind() -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildUnwind(B);
     }
 
     fn Unreachable() -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildUnreachable(B);
     }
 
     /* Arithmetic */
     fn Add(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn NSWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn NUWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn FAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn Sub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn NSWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn NUWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn FSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn Mul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn NSWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn NUWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn FMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn UDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildUDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn SDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn ExactSDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildExactSDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn FDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn URem(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildURem(B, LHS, RHS, _str.buf(""));
     }
 
     fn SRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSRem(B, LHS, RHS, _str.buf(""));
     }
 
     fn FRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFRem(B, LHS, RHS, _str.buf(""));
     }
 
     fn Shl(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildShl(B, LHS, RHS, _str.buf(""));
     }
 
     fn LShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildLShr(B, LHS, RHS, _str.buf(""));
     }
 
     fn AShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAShr(B, LHS, RHS, _str.buf(""));
     }
 
     fn And(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAnd(B, LHS, RHS, _str.buf(""));
     }
 
     fn Or(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildOr(B, LHS, RHS, _str.buf(""));
     }
 
     fn Xor(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildXor(B, LHS, RHS, _str.buf(""));
     }
 
     fn BinOp(Opcode Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildBinOp(B, Op, LHS, RHS, _str.buf(""));
     }
 
     fn Neg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNeg(B, V, _str.buf(""));
     }
 
     fn NSWNeg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWNeg(B, V, _str.buf(""));
     }
 
     fn NUWNeg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWNeg(B, V, _str.buf(""));
     }
     fn FNeg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFNeg(B, V, _str.buf(""));
     }
     fn Not(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNot(B, V, _str.buf(""));
     }
 
     /* Memory */
     fn Malloc(TypeRef Ty) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildMalloc(B, Ty, _str.buf(""));
     }
 
     fn ArrayMalloc(TypeRef Ty, ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildArrayMalloc(B, Ty, Val, _str.buf(""));
     }
 
     fn Alloca(TypeRef Ty) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAlloca(B, Ty, _str.buf(""));
     }
 
     fn ArrayAlloca(TypeRef Ty, ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildArrayAlloca(B, Ty, Val, _str.buf(""));
     }
 
     fn Free(ValueRef PointerVal) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFree(B, PointerVal);
     }
 
     fn Load(ValueRef PointerVal) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildLoad(B, PointerVal, _str.buf(""));
     }
 
     fn Store(ValueRef Val, ValueRef Ptr) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildStore(B, Val, Ptr);
     }
 
     fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildGEP(B, Pointer,
                               _vec.buf[ValueRef](Indices),
                               _vec.len[ValueRef](Indices),
@@ -1129,7 +1129,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildInBoundsGEP(B, Pointer,
                                       _vec.buf[ValueRef](Indices),
                                       _vec.len[ValueRef](Indices),
@@ -1137,125 +1137,125 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn StructGEP(ValueRef Pointer, uint Idx) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildStructGEP(B, Pointer, Idx, _str.buf(""));
     }
 
     fn GlobalString(sbuf Str) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildGlobalString(B, Str, _str.buf(""));
     }
 
     fn GlobalStringPtr(sbuf Str) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildGlobalStringPtr(B, Str, _str.buf(""));
     }
 
     /* Casts */
     fn Trunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildTrunc(B, Val, DestTy, _str.buf(""));
     }
 
     fn ZExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildZExt(B, Val, DestTy, _str.buf(""));
     }
 
     fn SExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSExt(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPToUI(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPToUI(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPToSI(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPToSI(B, Val, DestTy, _str.buf(""));
     }
 
     fn UIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildUIToFP(B, Val, DestTy, _str.buf(""));
     }
 
     fn SIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSIToFP(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPTrunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPTrunc(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPExt(B, Val, DestTy, _str.buf(""));
     }
 
     fn PtrToInt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildPtrToInt(B, Val, DestTy, _str.buf(""));
     }
 
     fn IntToPtr(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIntToPtr(B, Val, DestTy, _str.buf(""));
     }
 
     fn BitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn ZExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildZExtOrBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn SExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSExtOrBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn TruncOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildTruncOrBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn Cast(Opcode Op, ValueRef Val, TypeRef DestTy, sbuf Name) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildCast(B, Op, Val, DestTy, _str.buf(""));
     }
 
     fn PointerCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildPointerCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn IntCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIntCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPCast(B, Val, DestTy, _str.buf(""));
     }
 
 
     /* Comparisons */
     fn ICmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildICmp(B, Op, LHS, RHS, _str.buf(""));
     }
 
     fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFCmp(B, Op, LHS, RHS, _str.buf(""));
     }
 
@@ -1263,9 +1263,9 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     /* Miscellaneous instructions */
     fn Phi(TypeRef Ty, vec[ValueRef] vals,
            vec[BasicBlockRef] bbs) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         auto phi = llvm.LLVMBuildPhi(B, Ty, _str.buf(""));
-        check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
+        assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
         llvm.LLVMAddIncoming(phi,
                              _vec.buf[ValueRef](vals),
                              _vec.buf[BasicBlockRef](bbs),
@@ -1276,7 +1276,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     fn AddIncomingToPhi(ValueRef phi,
                         vec[ValueRef] vals,
                         vec[BasicBlockRef] bbs) {
-        check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
+        assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
         llvm.LLVMAddIncoming(phi,
                              _vec.buf[ValueRef](vals),
                              _vec.buf[BasicBlockRef](bbs),
@@ -1284,7 +1284,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildCall(B, Fn,
                                _vec.buf[ValueRef](Args),
                                _vec.len[ValueRef](Args),
@@ -1292,7 +1292,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         auto v = llvm.LLVMBuildCall(B, Fn,
                                     _vec.buf[ValueRef](Args),
                                     _vec.len[ValueRef](Args),
@@ -1302,65 +1302,65 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Select(ValueRef If, ValueRef Then, ValueRef Else) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSelect(B, If, Then, Else, _str.buf(""));
     }
 
     fn VAArg(ValueRef List, TypeRef Ty) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildVAArg(B, List, Ty, _str.buf(""));
     }
 
     fn ExtractElement(ValueRef VecVal, ValueRef Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildExtractElement(B, VecVal, Index, _str.buf(""));
     }
 
     fn InsertElement(ValueRef VecVal, ValueRef EltVal,
                      ValueRef Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildInsertElement(B, VecVal, EltVal, Index,
                                         _str.buf(""));
     }
 
     fn ShuffleVector(ValueRef V1, ValueRef V2, ValueRef Mask) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildShuffleVector(B, V1, V2, Mask, _str.buf(""));
     }
 
     fn ExtractValue(ValueRef AggVal, uint Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildExtractValue(B, AggVal, Index, _str.buf(""));
     }
 
     fn InsertValue(ValueRef AggVal, ValueRef EltVal,
                    uint Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildInsertValue(B, AggVal, EltVal, Index, _str.buf(""));
     }
 
     fn IsNull(ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIsNull(B, Val, _str.buf(""));
     }
 
     fn IsNotNull(ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIsNotNull(B, Val, _str.buf(""));
     }
 
     fn PtrDiff(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildPtrDiff(B, LHS, RHS, _str.buf(""));
     }
 
     fn Trap() -> ValueRef {
-        check (!*terminated);
+        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"));
-        check (T as int != 0);
+        assert (T as int != 0);
         let vec[ValueRef] Args = vec();
         ret llvm.LLVMBuildCall(B, T,
                                _vec.buf[ValueRef](Args),
@@ -1391,8 +1391,8 @@ state obj type_names(std.map.hashmap[TypeRef, str] type_names,
                     std.map.hashmap[str, TypeRef] named_types) {
 
     fn associate(str s, TypeRef t) {
-        check (!named_types.contains_key(s));
-        check (!type_names.contains_key(t));
+        assert (!named_types.contains_key(s));
+        assert (!type_names.contains_key(t));
         type_names.insert(t, s);
         named_types.insert(s, t);
     }