bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Revert "Use different syntax for checks that matter to typestate"

Browse source 
This reverts commit aa25f22f19. It broke stage2, not sure why yet.
This commit is contained in:
Graydon Hoare 2011-05-02 16:24:09 -07:00
parent 764de078e7
commit d08b443fff
182 changed files with 1239 additions and 1256 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/boot/fe/item.ml
View file

@ -199,14 +199,6 @@ and parse_stmts_including_none (ps:pstate) : Ast.stmt array =
bump ps; bump ps;
expect ps SEMI; expect ps SEMI;
[| span ps apos (lexpos ps) Ast.STMT_cont |] [| span ps apos (lexpos ps) Ast.STMT_cont |]
| ASSERT ->
bump ps;
let (stmts, expr) =
ctxt "stmts: check value" parse_expr ps
in
expect ps SEMI;
spans ps stmts apos (Ast.STMT_check_expr expr)
(* leaving check as it is; adding assert as a synonym for the "old" check *)
| CHECK -> | CHECK ->
bump ps; bump ps;
begin begin

1
src/boot/fe/lexer.mll
View file

@ -92,7 +92,6 @@
("type", TYPE); ("type", TYPE);
("check", CHECK); ("check", CHECK);
("assert", ASSERT);
("claim", CLAIM); ("claim", CLAIM);
("prove", PROVE); ("prove", PROVE);

2
src/boot/fe/token.ml
View file

@ -77,7 +77,6 @@ type token =
(* Type and type-state keywords *) (* Type and type-state keywords *)
| TYPE | TYPE
| CHECK | CHECK
| ASSERT
| CLAIM | CLAIM
| PROVE | PROVE
@ -238,7 +237,6 @@ let rec string_of_tok t =
(* Type and type-state keywords *) (* Type and type-state keywords *)
| TYPE -> "type" | TYPE -> "type"
| CHECK -> "check" | CHECK -> "check"
| ASSERT -> "assert"
| CLAIM -> "claim" | CLAIM -> "claim"
| PROVE -> "prove" | PROVE -> "prove"

5
src/comp/front/ast.rs
View file

@ -283,10 +283,7 @@ tag expr_ {
expr_put(option.t[@expr], ann); expr_put(option.t[@expr], ann);
expr_be(@expr, ann); expr_be(@expr, ann);
expr_log(int, @expr, ann); expr_log(int, @expr, ann);
/* just an assert, no significance to typestate */ expr_check_expr(@expr, ann);
expr_assert(@expr, ann);
/* preds that typestate is aware of */
expr_check(@expr, ann);
expr_port(ann); expr_port(ann);
expr_chan(@expr, ann); expr_chan(@expr, ann);
} }

14
src/comp/front/creader.rs
View file

@ -93,7 +93,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
case ('c') { ret ty.mk_char(st.tcx); } case ('c') { ret ty.mk_char(st.tcx); }
case ('s') { ret ty.mk_str(st.tcx); } case ('s') { ret ty.mk_str(st.tcx); }
case ('t') { case ('t') {
assert (next(st) as char == '['); check(next(st) as char == '[');
auto def = parse_def(st, sd); auto def = parse_def(st, sd);
let vec[ty.t] params = vec(); let vec[ty.t] params = vec();
while (peek(st) as char != ']') { while (peek(st) as char != ']') {
@ -108,7 +108,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); } case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); }
case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); } case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); }
case ('T') { case ('T') {
assert (next(st) as char == '['); check(next(st) as char == '[');
let vec[ty.mt] params = vec(); let vec[ty.mt] params = vec();
while (peek(st) as char != ']') { while (peek(st) as char != ']') {
params += vec(parse_mt(st, sd)); params += vec(parse_mt(st, sd));
@ -117,7 +117,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
ret ty.mk_tup(st.tcx, params); ret ty.mk_tup(st.tcx, params);
} }
case ('R') { case ('R') {
assert (next(st) as char == '['); check(next(st) as char == '[');
let vec[ty.field] fields = vec(); let vec[ty.field] fields = vec();
while (peek(st) as char != ']') { while (peek(st) as char != ']') {
auto name = ""; auto name = "";
@ -149,7 +149,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
ret ty.mk_native_fn(st.tcx,abi,func._0,func._1); ret ty.mk_native_fn(st.tcx,abi,func._0,func._1);
} }
case ('O') { case ('O') {
assert (next(st) as char == '['); check(next(st) as char == '[');
let vec[ty.method] methods = vec(); let vec[ty.method] methods = vec();
while (peek(st) as char != ']') { while (peek(st) as char != ']') {
auto proto; auto proto;
@ -175,9 +175,9 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
case ('Y') { ret ty.mk_type(st.tcx); } case ('Y') { ret ty.mk_type(st.tcx); }
case ('#') { case ('#') {
auto pos = parse_hex(st); auto pos = parse_hex(st);
assert (next(st) as char == ':'); check (next(st) as char == ':');
auto len = parse_hex(st); auto len = parse_hex(st);
assert (next(st) as char == '#'); check (next(st) as char == '#');
alt (st.tcx.rcache.find(tup(st.crate,pos,len))) { alt (st.tcx.rcache.find(tup(st.crate,pos,len))) {
case (some[ty.t](?tt)) { ret tt; } case (some[ty.t](?tt)) { ret tt; }
case (none[ty.t]) { case (none[ty.t]) {
@ -245,7 +245,7 @@ fn parse_hex(@pstate st) -> uint {
} }
fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) { fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
assert (next(st) as char == '['); check(next(st) as char == '[');
let vec[ty.arg] inputs = vec(); let vec[ty.arg] inputs = vec();
while (peek(st) as char != ']') { while (peek(st) as char != ']') {
auto mode = ast.val; auto mode = ast.val;

3
src/comp/front/lexer.rs
View file

@ -127,7 +127,6 @@ fn keyword_table() -> std.map.hashmap[str, token.token] {
keywords.insert("type", token.TYPE); keywords.insert("type", token.TYPE);
keywords.insert("check", token.CHECK); keywords.insert("check", token.CHECK);
keywords.insert("assert", token.ASSERT);
keywords.insert("claim", token.CLAIM); keywords.insert("claim", token.CLAIM);
keywords.insert("prove", token.PROVE); keywords.insert("prove", token.PROVE);
@ -529,7 +528,7 @@ fn scan_numeric_escape(reader rdr) -> char {
auto n_hex_digits = 0; auto n_hex_digits = 0;
assert (rdr.curr() == '\\'); check (rdr.curr() == '\\');
alt (rdr.next()) { alt (rdr.next()) {
case ('x') { n_hex_digits = 2; } case ('x') { n_hex_digits = 2; }

36
src/comp/front/parser.rs
View file

@ -621,7 +621,7 @@ fn parse_path(parser p, greed g) -> ast.path {
if (p.peek() == token.DOT) { if (p.peek() == token.DOT) {
if (g == GREEDY) { if (g == GREEDY) {
p.bump(); p.bump();
assert (is_ident(p.peek())); check (is_ident(p.peek()));
} else { } else {
more = false; more = false;
} }
@ -816,21 +816,18 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
ex = ast.expr_log(0, e, ast.ann_none); ex = ast.expr_log(0, e, ast.ann_none);
} }
case (token.ASSERT) {
p.bump();
auto e = parse_expr(p);
auto hi = e.span.hi;
ex = ast.expr_assert(e, ast.ann_none);
}
case (token.CHECK) { case (token.CHECK) {
p.bump(); p.bump();
/* Should be a predicate (pure boolean function) applied to alt (p.peek()) {
arguments that are all either slot variables or literals. case (token.LPAREN) {
but the typechecker enforces that. */
auto e = parse_expr(p); auto e = parse_expr(p);
auto hi = e.span.hi; auto hi = e.span.hi;
ex = ast.expr_check(e, ast.ann_none); ex = ast.expr_check_expr(e, ast.ann_none);
}
case (_) {
p.get_session().unimpl("constraint-check stmt");
}
}
} }
case (token.RET) { case (token.RET) {
@ -940,7 +937,7 @@ fn expand_syntax_ext(parser p, ast.span sp,
&ast.path path, vec[@ast.expr] args, &ast.path path, vec[@ast.expr] args,
option.t[str] body) -> ast.expr_ { option.t[str] body) -> ast.expr_ {
assert (_vec.len[ast.ident](path.node.idents) > 0u); check (_vec.len[ast.ident](path.node.idents) > 0u);
auto extname = path.node.idents.(0); auto extname = path.node.idents.(0);
if (_str.eq(extname, "fmt")) { if (_str.eq(extname, "fmt")) {
auto expanded = extfmt.expand_syntax_ext(args, body); auto expanded = extfmt.expand_syntax_ext(args, body);
@ -1676,8 +1673,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool {
case (ast.expr_put(_,_)) { ret true; } case (ast.expr_put(_,_)) { ret true; }
case (ast.expr_be(_,_)) { ret true; } case (ast.expr_be(_,_)) { ret true; }
case (ast.expr_log(_,_,_)) { ret true; } case (ast.expr_log(_,_,_)) { ret true; }
case (ast.expr_check(_,_)) { ret true; } case (ast.expr_check_expr(_,_)) { ret true; }
case (ast.expr_assert(_,_)) { ret true; }
} }
} }
// We should not be calling this on a cdir. // We should not be calling this on a cdir.
@ -2161,24 +2157,24 @@ fn parse_item(parser p) -> @ast.item {
alt (p.peek()) { alt (p.peek()) {
case (token.CONST) { case (token.CONST) {
assert (lyr == ast.layer_value); check (lyr == ast.layer_value);
ret parse_item_const(p); ret parse_item_const(p);
} }
case (token.FN) { case (token.FN) {
assert (lyr == ast.layer_value); check (lyr == ast.layer_value);
ret parse_item_fn_or_iter(p); ret parse_item_fn_or_iter(p);
} }
case (token.ITER) { case (token.ITER) {
assert (lyr == ast.layer_value); check (lyr == ast.layer_value);
ret parse_item_fn_or_iter(p); ret parse_item_fn_or_iter(p);
} }
case (token.MOD) { case (token.MOD) {
assert (lyr == ast.layer_value); check (lyr == ast.layer_value);
ret parse_item_mod(p); ret parse_item_mod(p);
} }
case (token.NATIVE) { case (token.NATIVE) {
assert (lyr == ast.layer_value); check (lyr == ast.layer_value);
ret parse_item_native_mod(p); ret parse_item_native_mod(p);
} }
case (token.TYPE) { case (token.TYPE) {

2
src/comp/front/token.rs
View file

@ -89,7 +89,6 @@ tag token {
/* Type and type-state keywords */ /* Type and type-state keywords */
TYPE; TYPE;
ASSERT;
CHECK; CHECK;
CLAIM; CLAIM;
PROVE; PROVE;
@ -259,7 +258,6 @@ fn to_str(token t) -> str {
/* Type and type-state keywords */ /* Type and type-state keywords */
case (TYPE) { ret "type"; } case (TYPE) { ret "type"; }
case (ASSERT) { ret "assert"; }
case (CHECK) { ret "check"; } case (CHECK) { ret "check"; }
case (CLAIM) { ret "claim"; } case (CLAIM) { ret "claim"; }
case (PROVE) { ret "prove"; } case (PROVE) { ret "prove"; }

186
src/comp/lib/llvm.rs
View file

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

31
src/comp/middle/fold.rs
View file

@ -196,10 +196,7 @@ type ast_fold[ENV] =
@expr e, ann a) -> @expr) fold_expr_log, @expr e, ann a) -> @expr) fold_expr_log,
(fn(&ENV e, &span sp, (fn(&ENV e, &span sp,
@expr e, ann a) -> @expr) fold_expr_check, @expr e, ann a) -> @expr) fold_expr_check_expr,
(fn(&ENV e, &span sp,
@expr e, ann a) -> @expr) fold_expr_assert,
(fn(&ENV e, &span sp, (fn(&ENV e, &span sp,
ann a) -> @expr) fold_expr_port, ann a) -> @expr) fold_expr_port,
@ -799,16 +796,10 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
ret fld.fold_expr_log(env_, e.span, l, ee, t2); ret fld.fold_expr_log(env_, e.span, l, ee, t2);
} }
case (ast.expr_check(?x, ?t)) { case (ast.expr_check_expr(?x, ?t)) {
auto ee = fold_expr(env_, fld, x); auto ee = fold_expr(env_, fld, x);
auto t2 = fld.fold_ann(env_, t); auto t2 = fld.fold_ann(env_, t);
ret fld.fold_expr_check(env_, e.span, ee, t2); ret fld.fold_expr_check_expr(env_, e.span, ee, t2);
}
case (ast.expr_assert(?x, ?t)) {
auto ee = fold_expr(env_, fld, x);
auto t2 = fld.fold_ann(env_, t);
ret fld.fold_expr_assert(env_, e.span, ee, t2);
} }
case (ast.expr_port(?t)) { case (ast.expr_port(?t)) {
@ -1389,14 +1380,9 @@ fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, @expr x,
ret @respan(sp, ast.expr_log(lvl, x, a)); ret @respan(sp, ast.expr_log(lvl, x, a));
} }
fn identity_fold_expr_check[ENV](&ENV e, &span sp, @expr x, ann a) fn identity_fold_expr_check_expr[ENV](&ENV e, &span sp, @expr x, ann a)
-> @expr { -> @expr {
ret @respan(sp, ast.expr_check(x, a)); ret @respan(sp, ast.expr_check_expr(x, a));
}
fn identity_fold_expr_assert[ENV](&ENV e, &span sp, @expr x, ann a)
-> @expr {
ret @respan(sp, ast.expr_check(x, a));
} }
fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr { fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr {
@ -1690,11 +1676,8 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
fold_expr_put = bind identity_fold_expr_put[ENV](_,_,_,_), fold_expr_put = bind identity_fold_expr_put[ENV](_,_,_,_),
fold_expr_be = bind identity_fold_expr_be[ENV](_,_,_,_), fold_expr_be = bind identity_fold_expr_be[ENV](_,_,_,_),
fold_expr_log = bind identity_fold_expr_log[ENV](_,_,_,_,_), fold_expr_log = bind identity_fold_expr_log[ENV](_,_,_,_,_),
fold_expr_check fold_expr_check_expr
= bind identity_fold_expr_check[ENV](_,_,_,_), = bind identity_fold_expr_check_expr[ENV](_,_,_,_),
fold_expr_assert
= bind identity_fold_expr_assert[ENV](_,_,_,_),
fold_expr_port = bind identity_fold_expr_port[ENV](_,_,_), fold_expr_port = bind identity_fold_expr_port[ENV](_,_,_),
fold_expr_chan = bind identity_fold_expr_chan[ENV](_,_,_,_), fold_expr_chan = bind identity_fold_expr_chan[ENV](_,_,_,_),

2
src/comp/middle/metadata.rs
View file

@ -63,7 +63,7 @@ mod Encode {
); );
fn ty_str(@ctxt cx, ty.t t) -> str { fn ty_str(@ctxt cx, ty.t t) -> str {
assert (! cx.use_abbrevs); check (! cx.use_abbrevs);
auto sw = io.string_writer(); auto sw = io.string_writer();
enc_ty(sw.get_writer(), cx, t); enc_ty(sw.get_writer(), cx, t);
ret sw.get_str(); ret sw.get_str();

2
src/comp/middle/resolve.rs
View file

@ -662,7 +662,7 @@ fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args,
fn fold_expr_path(&env e, &span sp, &ast.path p, &option.t[def] d, fn fold_expr_path(&env e, &span sp, &ast.path p, &option.t[def] d,
ann a) -> @ast.expr { ann a) -> @ast.expr {
auto n_idents = _vec.len[ast.ident](p.node.idents); auto n_idents = _vec.len[ast.ident](p.node.idents);
assert (n_idents != 0u); check (n_idents != 0u);
auto index = new_def_hash[def_wrap](); auto index = new_def_hash[def_wrap]();
auto d = find_final_def(e, index, sp, p.node.idents, ns_value, auto d = find_final_def(e, index, sp, p.node.idents, ns_value,

72
src/comp/middle/trans.rs
View file

@ -586,7 +586,7 @@ fn type_of_explicit_args(@crate_ctxt cx, vec[ty.arg] inputs) -> vec[TypeRef] {
let vec[TypeRef] atys = vec(); let vec[TypeRef] atys = vec();
for (ty.arg arg in inputs) { for (ty.arg arg in inputs) {
if (ty.type_has_dynamic_size(cx.tcx, arg.ty)) { if (ty.type_has_dynamic_size(cx.tcx, arg.ty)) {
assert (arg.mode == ast.alias); check (arg.mode == ast.alias);
atys += vec(T_typaram_ptr(cx.tn)); atys += vec(T_typaram_ptr(cx.tn));
} else { } else {
let TypeRef t; let TypeRef t;
@ -632,7 +632,7 @@ fn type_of_fn_full(@crate_ctxt cx,
// Arg 2: Env (closure-bindings / self-obj) // Arg 2: Env (closure-bindings / self-obj)
alt (obj_self) { alt (obj_self) {
case (some[TypeRef](?t)) { case (some[TypeRef](?t)) {
assert (t as int != 0); check (t as int != 0);
atys += vec(t); atys += vec(t);
} }
case (_) { case (_) {
@ -800,7 +800,7 @@ fn type_of_inner(@crate_ctxt cx, ty.t t) -> TypeRef {
case (ty.ty_type) { llty = T_ptr(T_tydesc(cx.tn)); } case (ty.ty_type) { llty = T_ptr(T_tydesc(cx.tn)); }
} }
assert (llty as int != 0); check (llty as int != 0);
llvm.LLVMAddTypeName(cx.llmod, llvm.LLVMAddTypeName(cx.llmod,
_str.buf(ty.ty_to_short_str(cx.tcx, _str.buf(ty.ty_to_short_str(cx.tcx,
cx.type_abbrevs, t)), cx.type_abbrevs, t)),
@ -1355,7 +1355,7 @@ fn dynamic_align_of(@block_ctxt cx, ty.t t) -> result {
fn GEP_tup_like(@block_ctxt cx, ty.t t, fn GEP_tup_like(@block_ctxt cx, ty.t t,
ValueRef base, vec[int] ixs) -> result { ValueRef base, vec[int] ixs) -> result {
assert (ty.type_is_tup_like(cx.fcx.lcx.ccx.tcx, t)); check (ty.type_is_tup_like(cx.fcx.lcx.ccx.tcx, t));
// It might be a static-known type. Handle this. // It might be a static-known type. Handle this.
@ -1393,17 +1393,17 @@ fn GEP_tup_like(@block_ctxt cx, ty.t t,
// and the latter would only be meaningful if we supported non-0 // and the latter would only be meaningful if we supported non-0
// values for the 0th index (we don't). // values for the 0th index (we don't).
assert (len > 1u); check (len > 1u);
if (n == 0u) { if (n == 0u) {
// Since we're starting from a value that's a pointer to a // Since we're starting from a value that's a pointer to a
// *single* structure, the first index (in GEP-ese) should just be // *single* structure, the first index (in GEP-ese) should just be
// 0, to yield the pointee. // 0, to yield the pointee.
assert (ixs.(n) == 0); check (ixs.(n) == 0);
ret split_type(ccx, t, ixs, n+1u); ret split_type(ccx, t, ixs, n+1u);
} }
assert (n < len); check (n < len);
let int ix = ixs.(n); let int ix = ixs.(n);
let vec[ty.t] prefix = vec(); let vec[ty.t] prefix = vec();
@ -1618,8 +1618,8 @@ fn get_tydesc(&@block_ctxt cx, ty.t t, bool escapes) -> result {
let uint n_params = ty.count_ty_params(cx.fcx.lcx.ccx.tcx, t); let uint n_params = ty.count_ty_params(cx.fcx.lcx.ccx.tcx, t);
auto tys = linearize_ty_params(cx, t); auto tys = linearize_ty_params(cx, t);
assert (n_params == _vec.len[uint](tys._0)); check (n_params == _vec.len[uint](tys._0));
assert (n_params == _vec.len[ValueRef](tys._1)); check (n_params == _vec.len[ValueRef](tys._1));
auto root = get_static_tydesc(cx, t, tys._0).tydesc; auto root = get_static_tydesc(cx, t, tys._0).tydesc;
@ -2348,7 +2348,7 @@ fn tag_variants(@crate_ctxt cx, ast.def_id id) -> vec[variant_info] {
ret creader.get_tag_variants(cx.sess, cx.tcx, id); ret creader.get_tag_variants(cx.sess, cx.tcx, id);
} }
assert (cx.items.contains_key(id)); check (cx.items.contains_key(id));
alt (cx.items.get(id).node) { alt (cx.items.get(id).node) {
case (ast.item_tag(_, ?variants, _, _, _)) { case (ast.item_tag(_, ?variants, _, _, _)) {
let vec[variant_info] result = vec(); let vec[variant_info] result = vec();
@ -3367,7 +3367,7 @@ fn join_results(@block_ctxt parent_cx,
// No incoming edges are live, so we're in dead-code-land. // No incoming edges are live, so we're in dead-code-land.
// Arbitrarily pick the first dead edge, since the caller // Arbitrarily pick the first dead edge, since the caller
// is just going to propagate it outward. // is just going to propagate it outward.
assert (_vec.len[result](ins) >= 1u); check (_vec.len[result](ins) >= 1u);
ret ins.(0); ret ins.(0);
} }
@ -3995,7 +3995,7 @@ fn lval_generic_fn(@block_ctxt cx,
auto lv; auto lv;
if (cx.fcx.lcx.ccx.sess.get_targ_crate_num() == fn_id._0) { if (cx.fcx.lcx.ccx.sess.get_targ_crate_num() == fn_id._0) {
// Internal reference. // Internal reference.
assert (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id)); check (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id));
lv = lval_val(cx, cx.fcx.lcx.ccx.fn_pairs.get(fn_id)); lv = lval_val(cx, cx.fcx.lcx.ccx.fn_pairs.get(fn_id));
} else { } else {
// External reference. // External reference.
@ -4038,7 +4038,7 @@ fn lookup_discriminant(@local_ctxt lcx, ast.def_id tid, ast.def_id vid)
alt (lcx.ccx.discrims.find(vid)) { alt (lcx.ccx.discrims.find(vid)) {
case (none[ValueRef]) { case (none[ValueRef]) {
// It's an external discriminant that we haven't seen yet. // It's an external discriminant that we haven't seen yet.
assert (lcx.ccx.sess.get_targ_crate_num() != vid._0); check (lcx.ccx.sess.get_targ_crate_num() != vid._0);
auto sym = creader.get_symbol(lcx.ccx.sess, vid); auto sym = creader.get_symbol(lcx.ccx.sess, vid);
auto gvar = llvm.LLVMAddGlobal(lcx.ccx.llmod, T_int(), auto gvar = llvm.LLVMAddGlobal(lcx.ccx.llmod, T_int(),
_str.buf(sym)); _str.buf(sym));
@ -4060,7 +4060,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
case (ast.def_arg(?did)) { case (ast.def_arg(?did)) {
alt (cx.fcx.llargs.find(did)) { alt (cx.fcx.llargs.find(did)) {
case (none[ValueRef]) { case (none[ValueRef]) {
assert (cx.fcx.llupvars.contains_key(did)); check (cx.fcx.llupvars.contains_key(did));
ret lval_mem(cx, cx.fcx.llupvars.get(did)); ret lval_mem(cx, cx.fcx.llupvars.get(did));
} }
case (some[ValueRef](?llval)) { case (some[ValueRef](?llval)) {
@ -4071,7 +4071,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
case (ast.def_local(?did)) { case (ast.def_local(?did)) {
alt (cx.fcx.lllocals.find(did)) { alt (cx.fcx.lllocals.find(did)) {
case (none[ValueRef]) { case (none[ValueRef]) {
assert (cx.fcx.llupvars.contains_key(did)); check (cx.fcx.llupvars.contains_key(did));
ret lval_mem(cx, cx.fcx.llupvars.get(did)); ret lval_mem(cx, cx.fcx.llupvars.get(did));
} }
case (some[ValueRef](?llval)) { case (some[ValueRef](?llval)) {
@ -4080,11 +4080,11 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
} }
} }
case (ast.def_binding(?did)) { case (ast.def_binding(?did)) {
assert (cx.fcx.lllocals.contains_key(did)); check (cx.fcx.lllocals.contains_key(did));
ret lval_mem(cx, cx.fcx.lllocals.get(did)); ret lval_mem(cx, cx.fcx.lllocals.get(did));
} }
case (ast.def_obj_field(?did)) { case (ast.def_obj_field(?did)) {
assert (cx.fcx.llobjfields.contains_key(did)); check (cx.fcx.llobjfields.contains_key(did));
ret lval_mem(cx, cx.fcx.llobjfields.get(did)); ret lval_mem(cx, cx.fcx.llobjfields.get(did));
} }
case (ast.def_fn(?did)) { case (ast.def_fn(?did)) {
@ -4136,7 +4136,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
} }
case (ast.def_const(?did)) { case (ast.def_const(?did)) {
// TODO: externals // TODO: externals
assert (cx.fcx.lcx.ccx.consts.contains_key(did)); check (cx.fcx.lcx.ccx.consts.contains_key(did));
ret lval_mem(cx, cx.fcx.lcx.ccx.consts.get(did)); ret lval_mem(cx, cx.fcx.lcx.ccx.consts.get(did));
} }
case (ast.def_native_fn(?did)) { case (ast.def_native_fn(?did)) {
@ -4275,7 +4275,7 @@ fn trans_lval(@block_ctxt cx, @ast.expr e) -> lval_result {
ret trans_index(cx, e.span, base, idx, ann); ret trans_index(cx, e.span, base, idx, ann);
} }
case (ast.expr_unary(?unop, ?base, ?ann)) { case (ast.expr_unary(?unop, ?base, ?ann)) {
assert (unop == ast.deref); check (unop == ast.deref);
auto sub = trans_expr(cx, base); auto sub = trans_expr(cx, base);
auto val = sub.bcx.build.GEP(sub.val, auto val = sub.bcx.build.GEP(sub.val,
@ -4439,7 +4439,7 @@ fn trans_bind_thunk(@local_ctxt cx,
} }
} else if (ty.type_contains_params(cx.ccx.tcx, } else if (ty.type_contains_params(cx.ccx.tcx,
out_arg.ty)) { out_arg.ty)) {
assert (out_arg.mode == ast.alias); check (out_arg.mode == ast.alias);
val = bcx.build.PointerCast(val, llout_arg_ty); val = bcx.build.PointerCast(val, llout_arg_ty);
} }
@ -4452,7 +4452,7 @@ fn trans_bind_thunk(@local_ctxt cx,
let ValueRef passed_arg = llvm.LLVMGetParam(llthunk, a); let ValueRef passed_arg = llvm.LLVMGetParam(llthunk, a);
if (ty.type_contains_params(cx.ccx.tcx, out_arg.ty)) { if (ty.type_contains_params(cx.ccx.tcx, out_arg.ty)) {
assert (out_arg.mode == ast.alias); check (out_arg.mode == ast.alias);
passed_arg = bcx.build.PointerCast(passed_arg, passed_arg = bcx.build.PointerCast(passed_arg,
llout_arg_ty); llout_arg_ty);
} }
@ -5142,7 +5142,7 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result {
case (ast.expr_assign(?dst, ?src, ?ann)) { case (ast.expr_assign(?dst, ?src, ?ann)) {
auto lhs_res = trans_lval(cx, dst); auto lhs_res = trans_lval(cx, dst);
assert (lhs_res.is_mem); check (lhs_res.is_mem);
auto rhs_res = trans_expr(lhs_res.res.bcx, src); auto rhs_res = trans_expr(lhs_res.res.bcx, src);
auto t = node_ann_type(cx.fcx.lcx.ccx, ann); auto t = node_ann_type(cx.fcx.lcx.ccx, ann);
// FIXME: calculate copy init-ness in typestate. // FIXME: calculate copy init-ness in typestate.
@ -5153,7 +5153,7 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result {
case (ast.expr_assign_op(?op, ?dst, ?src, ?ann)) { case (ast.expr_assign_op(?op, ?dst, ?src, ?ann)) {
auto t = node_ann_type(cx.fcx.lcx.ccx, ann); auto t = node_ann_type(cx.fcx.lcx.ccx, ann);
auto lhs_res = trans_lval(cx, dst); auto lhs_res = trans_lval(cx, dst);
assert (lhs_res.is_mem); check (lhs_res.is_mem);
auto rhs_res = trans_expr(lhs_res.res.bcx, src); auto rhs_res = trans_expr(lhs_res.res.bcx, src);
if (ty.type_is_sequence(cx.fcx.lcx.ccx.tcx, t)) { if (ty.type_is_sequence(cx.fcx.lcx.ccx.tcx, t)) {
alt (op) { alt (op) {
@ -5210,11 +5210,7 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result {
ret trans_log(lvl, cx, a); ret trans_log(lvl, cx, a);
} }
case (ast.expr_assert(?a, _)) { case (ast.expr_check_expr(?a, _)) {
ret trans_check_expr(cx, a);
}
case (ast.expr_check(?a, _)) {
ret trans_check_expr(cx, a); ret trans_check_expr(cx, a);
} }
@ -5535,7 +5531,7 @@ fn trans_ret(@block_ctxt cx, &option.t[@ast.expr] e) -> result {
fn trans_be(@block_ctxt cx, @ast.expr e) -> result { fn trans_be(@block_ctxt cx, @ast.expr e) -> result {
// FIXME: This should be a typestate precondition // FIXME: This should be a typestate precondition
assert (ast.is_call_expr(e)); check (ast.is_call_expr(e));
// FIXME: Turn this into a real tail call once // FIXME: Turn this into a real tail call once
// calling convention issues are settled // calling convention issues are settled
ret trans_ret(cx, some(e)); ret trans_ret(cx, some(e));
@ -5631,7 +5627,7 @@ fn trans_recv(@block_ctxt cx, @ast.expr lhs, @ast.expr rhs,
auto bcx = cx; auto bcx = cx;
auto data = trans_lval(bcx, lhs); auto data = trans_lval(bcx, lhs);
assert (data.is_mem); check (data.is_mem);
bcx = data.res.bcx; bcx = data.res.bcx;
auto unit_ty = node_ann_type(bcx.fcx.lcx.ccx, ann); auto unit_ty = node_ann_type(bcx.fcx.lcx.ccx, ann);
@ -5663,7 +5659,7 @@ fn recv_val(@block_ctxt cx, ValueRef lhs, @ast.expr rhs,
fn init_local(@block_ctxt cx, @ast.local local) -> result { fn init_local(@block_ctxt cx, @ast.local local) -> result {
// Make a note to drop this slot on the way out. // Make a note to drop this slot on the way out.
assert (cx.fcx.lllocals.contains_key(local.id)); check (cx.fcx.lllocals.contains_key(local.id));
auto llptr = cx.fcx.lllocals.get(local.id); auto llptr = cx.fcx.lllocals.get(local.id);
auto ty = node_ann_type(cx.fcx.lcx.ccx, local.ann); auto ty = node_ann_type(cx.fcx.lcx.ccx, local.ann);
auto bcx = cx; auto bcx = cx;
@ -5779,7 +5775,7 @@ fn trans_block_cleanups(@block_ctxt cx,
auto bcx = cx; auto bcx = cx;
if (cleanup_cx.kind == NON_SCOPE_BLOCK) { if (cleanup_cx.kind == NON_SCOPE_BLOCK) {
assert (_vec.len[cleanup](cleanup_cx.cleanups) == 0u); check (_vec.len[cleanup](cleanup_cx.cleanups) == 0u);
} }
auto i = _vec.len[cleanup](cleanup_cx.cleanups); auto i = _vec.len[cleanup](cleanup_cx.cleanups);
@ -6000,7 +5996,7 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx,
auto i = 0u; auto i = 0u;
for (ast.ty_param tp in ty_params) { for (ast.ty_param tp in ty_params) {
auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n); auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
assert (llarg as int != 0); check (llarg as int != 0);
cx.lltydescs += vec(llarg); cx.lltydescs += vec(llarg);
arg_n += 1u; arg_n += 1u;
i += 1u; i += 1u;
@ -6010,14 +6006,14 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx,
if (proto == ast.proto_iter) { if (proto == ast.proto_iter) {
auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n); auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
assert (llarg as int != 0); check (llarg as int != 0);
cx.lliterbody = some[ValueRef](llarg); cx.lliterbody = some[ValueRef](llarg);
arg_n += 1u; arg_n += 1u;
} }
for (ast.arg arg in args) { for (ast.arg arg in args) {
auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n); auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
assert (llarg as int != 0); check (llarg as int != 0);
cx.llargs.insert(arg.id, llarg); cx.llargs.insert(arg.id, llarg);
arg_n += 1u; arg_n += 1u;
} }
@ -6455,7 +6451,7 @@ fn trans_tag_variant(@local_ctxt cx, ast.def_id tag_id,
id=varg.id)); id=varg.id));
} }
assert (cx.ccx.item_ids.contains_key(variant.node.id)); check (cx.ccx.item_ids.contains_key(variant.node.id));
let ValueRef llfndecl = cx.ccx.item_ids.get(variant.node.id); let ValueRef llfndecl = cx.ccx.item_ids.get(variant.node.id);
auto fcx = new_fn_ctxt(cx, llfndecl); auto fcx = new_fn_ctxt(cx, llfndecl);
@ -6722,7 +6718,7 @@ fn decl_native_fn_and_pair(@crate_ctxt ccx,
for each (uint i in _uint.range(0u, num_ty_param)) { for each (uint i in _uint.range(0u, num_ty_param)) {
auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n); auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n);
fcx.lltydescs += vec(llarg); fcx.lltydescs += vec(llarg);
assert (llarg as int != 0); check (llarg as int != 0);
call_args += vec(vp2i(bcx, llarg)); call_args += vec(vp2i(bcx, llarg));
arg_n += 1u; arg_n += 1u;
} }
@ -6788,7 +6784,7 @@ fn decl_native_fn_and_pair(@crate_ctxt ccx,
for (ty.arg arg in args) { for (ty.arg arg in args) {
auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n); auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n);
assert (llarg as int != 0); check (llarg as int != 0);
push_arg(bcx, call_args, llarg, arg.ty, arg.mode); push_arg(bcx, call_args, llarg, arg.ty, arg.mode);
if (arg.mode == ast.val) { if (arg.mode == ast.val) {
drop_args += vec(tup(llarg, arg.ty)); drop_args += vec(tup(llarg, arg.ty));

179
src/comp/middle/ty.rs
View file

@ -895,7 +895,7 @@ fn type_is_tup_like(ctxt cx, t ty) -> bool {
} }
fn get_element_type(ctxt cx, t ty, uint i) -> t { fn get_element_type(ctxt cx, t ty, uint i) -> t {
assert (type_is_tup_like(cx, ty)); check (type_is_tup_like(cx, ty));
alt (struct(cx, ty)) { alt (struct(cx, ty)) {
case (ty_tup(?mts)) { case (ty_tup(?mts)) {
ret mts.(i).ty; ret mts.(i).ty;
@ -1785,117 +1785,50 @@ fn pat_ty(ctxt cx, @ast.pat pat) -> t {
fail; // not reached fail; // not reached
} }
fn expr_ann(&@ast.expr e) -> ast.ann { fn expr_ann(@ast.expr expr) -> option.t[ast.ann] {
alt(e.node) { alt (expr.node) {
case (ast.expr_vec(_,_,?a)) { case (ast.expr_vec(_, _, ?ann)) { ret some[ast.ann](ann); }
ret a; case (ast.expr_tup(_, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_rec(_, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_tup(_,?a)) { case (ast.expr_bind(_, _, ?ann)) { ret some[ast.ann](ann); }
ret a; case (ast.expr_call(_, _, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_self_method(_, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_rec(_,_,?a)) { case (ast.expr_spawn(_, _, _, _, ?ann))
ret a; { ret some[ast.ann](ann); }
} case (ast.expr_binary(_, _, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_call(_,_,?a)) { case (ast.expr_unary(_, _, ?ann)) { ret some[ast.ann](ann); }
ret a; case (ast.expr_lit(_, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_cast(_, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_bind(_,_,?a)) { case (ast.expr_if(_, _, _, ?ann)) { ret some[ast.ann](ann); }
ret a; case (ast.expr_for(_, _, _, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_for_each(_, _, _, ?ann))
case (ast.expr_binary(_,_,_,?a)) { { ret some[ast.ann](ann); }
ret a; case (ast.expr_while(_, _, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_do_while(_, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_unary(_,_,?a)) { case (ast.expr_alt(_, _, ?ann)) { ret some[ast.ann](ann); }
ret a; case (ast.expr_block(_, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_assign(_, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_lit(_,?a)) { case (ast.expr_assign_op(_, _, _, ?ann))
ret a; { ret some[ast.ann](ann); }
} case (ast.expr_field(_, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_cast(_,_,?a)) { case (ast.expr_index(_, _, ?ann)) { ret some[ast.ann](ann); }
ret a; case (ast.expr_path(_, _, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_ext(_, _, _, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_if(_,_,_,?a)) { case (ast.expr_port(?ann)) { ret some[ast.ann](ann); }
ret a; case (ast.expr_chan(_, ?ann)) { ret some[ast.ann](ann); }
} case (ast.expr_send(_, _, ?ann)) { ret some[ast.ann](ann); }
case (ast.expr_while(_,_,?a)) { case (ast.expr_recv(_, _, ?ann)) { ret some[ast.ann](ann); }
ret a;
} case (ast.expr_fail(_)) { ret none[ast.ann]; }
case (ast.expr_for(_,_,_,?a)) { case (ast.expr_break(_)) { ret none[ast.ann]; }
ret a; case (ast.expr_cont(_)) { ret none[ast.ann]; }
} case (ast.expr_log(_,_,_)) { ret none[ast.ann]; }
case (ast.expr_for_each(_,_,_,?a)) { case (ast.expr_check_expr(_,_)) { ret none[ast.ann]; }
ret a; case (ast.expr_ret(_,_)) { ret none[ast.ann]; }
} case (ast.expr_put(_,_)) { ret none[ast.ann]; }
case (ast.expr_do_while(_,_,?a)) { case (ast.expr_be(_,_)) { ret none[ast.ann]; }
ret a;
}
case (ast.expr_alt(_,_,?a)) {
ret a;
}
case (ast.expr_block(_,?a)) {
ret a;
}
case (ast.expr_assign(_,_,?a)) {
ret a;
}
case (ast.expr_assign_op(_,_,_,?a)) {
ret a;
}
case (ast.expr_send(_,_,?a)) {
ret a;
}
case (ast.expr_recv(_,_,?a)) {
ret a;
}
case (ast.expr_field(_,_,?a)) {
ret a;
}
case (ast.expr_index(_,_,?a)) {
ret a;
}
case (ast.expr_path(_,_,?a)) {
ret a;
}
case (ast.expr_ext(_,_,_,_,?a)) {
ret a;
}
case (ast.expr_fail(?a)) {
ret a;
}
case (ast.expr_ret(_,?a)) {
ret a;
}
case (ast.expr_put(_,?a)) {
ret a;
}
case (ast.expr_be(_,?a)) {
ret a;
}
case (ast.expr_log(_,_,?a)) {
ret a;
}
case (ast.expr_assert(_,?a)) {
ret a;
}
case (ast.expr_check(_,?a)) {
ret a;
}
case (ast.expr_port(?a)) {
ret a;
}
case (ast.expr_chan(_,?a)) {
ret a;
}
case (ast.expr_break(?a)) {
ret a;
}
case (ast.expr_cont(?a)) {
ret a;
}
case (ast.expr_self_method(_, ?a)) {
ret a;
}
} }
fail;
} }
// Returns the type of an expression as a monotype. // Returns the type of an expression as a monotype.
@ -1905,23 +1838,37 @@ fn expr_ann(&@ast.expr e) -> ast.ann {
// instead of "fn(&T) -> T with T = int". If this isn't what you want, see // instead of "fn(&T) -> T with T = int". If this isn't what you want, see
// expr_ty_params_and_ty() below. // expr_ty_params_and_ty() below.
fn expr_ty(ctxt cx, @ast.expr expr) -> t { fn expr_ty(ctxt cx, @ast.expr expr) -> t {
{ ret ann_to_monotype(cx, expr_ann(expr)); } alt (expr_ann(expr)) {
case (none[ast.ann]) { ret mk_nil(cx); }
case (some[ast.ann](?a)) { ret ann_to_monotype(cx, a); }
}
} }
fn expr_ty_params_and_ty(ctxt cx, @ast.expr expr) -> tup(vec[t], t) { fn expr_ty_params_and_ty(ctxt cx, @ast.expr expr) -> tup(vec[t], t) {
auto a = expr_ann(expr); alt (expr_ann(expr)) {
case (none[ast.ann]) {
let vec[t] tps = vec();
ret tup(tps, mk_nil(cx));
}
case (some[ast.ann](?a)) {
ret tup(ann_to_type_params(a), ann_to_type(a)); ret tup(ann_to_type_params(a), ann_to_type(a));
}
}
} }
fn expr_has_ty_params(@ast.expr expr) -> bool { fn expr_has_ty_params(@ast.expr expr) -> bool {
// FIXME: Rewrite using complex patterns when they're trustworthy. // FIXME: Rewrite using complex patterns when they're trustworthy.
alt (expr_ann(expr)) { alt (expr_ann(expr)) {
case (none[ast.ann]) { fail; }
case (some[ast.ann](?a)) {
alt (a) {
case (ast.ann_none) { fail; } case (ast.ann_none) { fail; }
case (ast.ann_type(_, ?tps_opt, _)) { case (ast.ann_type(_, ?tps_opt, _)) {
ret !option.is_none[vec[t]](tps_opt); ret !option.is_none[vec[t]](tps_opt);
} }
} }
}
}
} }
// FIXME: At the moment this works only for call, bind, and path expressions. // FIXME: At the moment this works only for call, bind, and path expressions.
@ -2286,7 +2233,7 @@ mod Unify {
if (actual_n < vlen) { if (actual_n < vlen) {
cx.types.(actual_n) += vec(expected); cx.types.(actual_n) += vec(expected);
} else { } else {
assert (actual_n == vlen); check (actual_n == vlen);
cx.types += vec(mutable vec(expected)); cx.types += vec(mutable vec(expected));
} }
} }
@ -2654,7 +2601,7 @@ mod Unify {
if (expected_n < vlen) { if (expected_n < vlen) {
cx.types.(expected_n) += vec(actual); cx.types.(expected_n) += vec(actual);
} else { } else {
assert (expected_n == vlen); check (expected_n == vlen);
cx.types += vec(mutable vec(actual)); cx.types += vec(mutable vec(actual));
} }
ret ures_ok(expected); ret ures_ok(expected);

46
src/comp/middle/typeck.rs
View file

@ -110,7 +110,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
-> ty_param_count_and_ty { -> ty_param_count_and_ty {
alt (defn) { alt (defn) {
case (ast.def_arg(?id)) { case (ast.def_arg(?id)) {
// assert (fcx.locals.contains_key(id)); // check (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id)); ret tup(0u, fcx.locals.get(id));
} }
case (ast.def_local(?id)) { case (ast.def_local(?id)) {
@ -122,7 +122,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
ret tup(0u, t); ret tup(0u, t);
} }
case (ast.def_obj_field(?id)) { case (ast.def_obj_field(?id)) {
// assert (fcx.locals.contains_key(id)); // check (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id)); ret tup(0u, fcx.locals.get(id));
} }
case (ast.def_fn(?id)) { case (ast.def_fn(?id)) {
@ -142,7 +142,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
fcx.ccx.type_cache, vid); fcx.ccx.type_cache, vid);
} }
case (ast.def_binding(?id)) { case (ast.def_binding(?id)) {
// assert (fcx.locals.contains_key(id)); // check (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id)); ret tup(0u, fcx.locals.get(id));
} }
case (ast.def_obj(?id)) { case (ast.def_obj(?id)) {
@ -298,7 +298,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t {
} }
case (ast.ty_path(?path, ?def)) { case (ast.ty_path(?path, ?def)) {
assert (def != none[ast.def]); check (def != none[ast.def]);
alt (option.get[ast.def](def)) { alt (option.get[ast.def](def)) {
case (ast.def_ty(?id)) { case (ast.def_ty(?id)) {
typ = instantiate(tcx, getter, id, path.node.types); typ = instantiate(tcx, getter, id, path.node.types);
@ -411,7 +411,7 @@ mod Collect {
ret creader.get_type(cx.sess, cx.tcx, id); ret creader.get_type(cx.sess, cx.tcx, id);
} }
// assert (cx.id_to_ty_item.contains_key(id)); // check (cx.id_to_ty_item.contains_key(id));
auto it = cx.id_to_ty_item.get(id); auto it = cx.id_to_ty_item.get(id);
auto tpt; auto tpt;
@ -672,7 +672,7 @@ mod Collect {
fn fold_item_const(&@env e, &span sp, ast.ident i, fn fold_item_const(&@env e, &span sp, ast.ident i,
@ast.ty t, @ast.expr ex, @ast.ty t, @ast.expr ex,
ast.def_id id, ast.ann a) -> @ast.item { ast.def_id id, ast.ann a) -> @ast.item {
// assert (e.cx.type_cache.contains_key(id)); // check (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1; auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.item_const(i, t, ex, id, triv_ann(typ)); auto item = ast.item_const(i, t, ex, id, triv_ann(typ));
ret @fold.respan[ast.item_](sp, item); ret @fold.respan[ast.item_](sp, item);
@ -681,7 +681,7 @@ mod Collect {
fn fold_item_fn(&@env e, &span sp, ast.ident i, fn fold_item_fn(&@env e, &span sp, ast.ident i,
&ast._fn f, vec[ast.ty_param] ty_params, &ast._fn f, vec[ast.ty_param] ty_params,
ast.def_id id, ast.ann a) -> @ast.item { ast.def_id id, ast.ann a) -> @ast.item {
// assert (e.cx.type_cache.contains_key(id)); // check (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1; auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.item_fn(i, f, ty_params, id, triv_ann(typ)); auto item = ast.item_fn(i, f, ty_params, id, triv_ann(typ));
ret @fold.respan[ast.item_](sp, item); ret @fold.respan[ast.item_](sp, item);
@ -690,7 +690,7 @@ mod Collect {
fn fold_native_item_fn(&@env e, &span sp, ast.ident i, option.t[str] ln, fn fold_native_item_fn(&@env e, &span sp, ast.ident i, option.t[str] ln,
&ast.fn_decl d, vec[ast.ty_param] ty_params, &ast.fn_decl d, vec[ast.ty_param] ty_params,
ast.def_id id, ast.ann a) -> @ast.native_item { ast.def_id id, ast.ann a) -> @ast.native_item {
// assert (e.cx.type_cache.contains_key(id)); // check (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1; auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.native_item_fn(i, ln, d, ty_params, id, auto item = ast.native_item_fn(i, ln, d, ty_params, id,
triv_ann(typ)); triv_ann(typ));
@ -721,7 +721,7 @@ mod Collect {
fn fold_item_obj(&@env e, &span sp, ast.ident i, fn fold_item_obj(&@env e, &span sp, ast.ident i,
&ast._obj ob, vec[ast.ty_param] ty_params, &ast._obj ob, vec[ast.ty_param] ty_params,
ast.obj_def_ids odid, ast.ann a) -> @ast.item { ast.obj_def_ids odid, ast.ann a) -> @ast.item {
// assert (e.cx.type_cache.contains_key(odid.ctor)); // check (e.cx.type_cache.contains_key(odid.ctor));
auto t = e.cx.type_cache.get(odid.ctor)._1; auto t = e.cx.type_cache.get(odid.ctor)._1;
let vec[method] meth_tys = get_ctor_obj_methods(e, t); let vec[method] meth_tys = get_ctor_obj_methods(e, t);
let vec[@ast.method] methods = vec(); let vec[@ast.method] methods = vec();
@ -777,7 +777,7 @@ mod Collect {
fn fold_item_ty(&@env e, &span sp, ast.ident i, fn fold_item_ty(&@env e, &span sp, ast.ident i,
@ast.ty t, vec[ast.ty_param] ty_params, @ast.ty t, vec[ast.ty_param] ty_params,
ast.def_id id, ast.ann a) -> @ast.item { ast.def_id id, ast.ann a) -> @ast.item {
// assert (e.cx.type_cache.contains_key(id)); // check (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1; auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.item_ty(i, t, ty_params, id, triv_ann(typ)); auto item = ast.item_ty(i, t, ty_params, id, triv_ann(typ));
ret @fold.respan[ast.item_](sp, item); ret @fold.respan[ast.item_](sp, item);
@ -1214,7 +1214,7 @@ mod Pushdown {
case (none[@ast.expr]) { case (none[@ast.expr]) {
auto i = 0u; auto i = 0u;
for (ast.field field_0 in fields_0) { for (ast.field field_0 in fields_0) {
assert (_str.eq(field_0.ident, check (_str.eq(field_0.ident,
field_mts.(i).ident)); field_mts.(i).ident));
auto e_1 = auto e_1 =
pushdown_expr(fcx, pushdown_expr(fcx,
@ -1409,8 +1409,7 @@ mod Pushdown {
case (ast.expr_ret(_,_)) { e_1 = e.node; } case (ast.expr_ret(_,_)) { e_1 = e.node; }
case (ast.expr_put(_,_)) { e_1 = e.node; } case (ast.expr_put(_,_)) { e_1 = e.node; }
case (ast.expr_be(_,_)) { e_1 = e.node; } case (ast.expr_be(_,_)) { e_1 = e.node; }
case (ast.expr_check(_,_)) { e_1 = e.node; } case (ast.expr_check_expr(_,_)) { e_1 = e.node; }
case (ast.expr_assert(_,_)) { e_1 = e.node; }
case (ast.expr_port(?ann)) { case (ast.expr_port(?ann)) {
auto t = Demand.simple(fcx, e.span, expected, auto t = Demand.simple(fcx, e.span, expected,
@ -1840,7 +1839,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
case (ast.expr_path(?pth, ?defopt, _)) { case (ast.expr_path(?pth, ?defopt, _)) {
auto t = ty.mk_nil(fcx.ccx.tcx); auto t = ty.mk_nil(fcx.ccx.tcx);
assert (defopt != none[ast.def]); check (defopt != none[ast.def]);
auto defn = option.get[ast.def](defopt); auto defn = option.get[ast.def](defopt);
auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn); auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn);
@ -1940,7 +1939,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
case (ast.expr_be(?e, _)) { case (ast.expr_be(?e, _)) {
/* FIXME: prove instead of check */ /* FIXME: prove instead of check */
assert (ast.is_call_expr(e)); check (ast.is_call_expr(e));
auto expr_0 = check_expr(fcx, e); auto expr_0 = check_expr(fcx, e);
auto expr_1 = Pushdown.pushdown_expr(fcx, fcx.ret_ty, expr_0); auto expr_1 = Pushdown.pushdown_expr(fcx, fcx.ret_ty, expr_0);
ret @fold.respan[ast.expr_](expr.span, ret @fold.respan[ast.expr_](expr.span,
@ -1954,25 +1953,12 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
plain_ann(fcx.ccx.tcx))); plain_ann(fcx.ccx.tcx)));
} }
case (ast.expr_check(?e, _)) { case (ast.expr_check_expr(?e, _)) {
/* FIXME */
/* presumably, here is where we should check that e is
actually a call to a predicate, where all the arguments
are literals or slot variables? */
auto expr_t = check_expr(fcx, e); auto expr_t = check_expr(fcx, e);
Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx), Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
expr_ty(fcx.ccx.tcx, expr_t)); expr_ty(fcx.ccx.tcx, expr_t));
ret @fold.respan[ast.expr_] ret @fold.respan[ast.expr_]
(expr.span, ast.expr_check(expr_t, (expr.span, ast.expr_check_expr(expr_t,
plain_ann(fcx.ccx.tcx)));
}
case (ast.expr_assert(?e, _)) {
auto expr_t = check_expr(fcx, e);
Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
expr_ty(fcx.ccx.tcx, expr_t));
ret @fold.respan[ast.expr_]
(expr.span, ast.expr_assert(expr_t,
plain_ann(fcx.ccx.tcx))); plain_ann(fcx.ccx.tcx)));
} }

404
src/comp/middle/typestate_check.rs
View file

@ -55,8 +55,7 @@ import front.ast.expr_put;
import front.ast.expr_port; import front.ast.expr_port;
import front.ast.expr_chan; import front.ast.expr_chan;
import front.ast.expr_be; import front.ast.expr_be;
import front.ast.expr_check; import front.ast.expr_check_expr;
import front.ast.expr_assert;
import front.ast.expr_cast; import front.ast.expr_cast;
import front.ast.expr_for; import front.ast.expr_for;
import front.ast.expr_for_each; import front.ast.expr_for_each;
@ -148,7 +147,8 @@ import util.typestate_ann.clone;
import middle.ty; import middle.ty;
import middle.ty.ann_to_type; import middle.ty.ann_to_type;
import middle.ty.arg; import middle.ty.arg;
import middle.ty.expr_ann; import middle.ty.block_ty;
import middle.ty.expr_ty;
import middle.ty.ty_to_str; import middle.ty.ty_to_str;
import pretty.pprust.print_block; import pretty.pprust.print_block;
@ -293,11 +293,11 @@ type fn_info = std.map.hashmap[def_id, var_info];
type fn_info_map = std.map.hashmap[def_id, fn_info]; type fn_info_map = std.map.hashmap[def_id, fn_info];
fn bit_num(def_id v, fn_info m) -> uint { fn bit_num(def_id v, fn_info m) -> uint {
assert (m.contains_key(v)); check (m.contains_key(v));
ret m.get(v)._0; ret m.get(v)._0;
} }
fn get_fn_info(fn_info_map fm, def_id did) -> fn_info { fn get_fn_info(fn_info_map fm, def_id did) -> fn_info {
assert (fm.contains_key(did)); check (fm.contains_key(did));
ret fm.get(did); ret fm.get(did);
} }
@ -389,6 +389,116 @@ fn mk_f_to_fn_info(@ast.crate c) -> fn_info_map {
ret res; ret res;
} }
/**** Helpers ****/ /**** Helpers ****/
fn expr_ann(&expr e) -> ann {
alt(e.node) {
case (ast.expr_vec(_,_,?a)) {
ret a;
}
case (ast.expr_tup(_,?a)) {
ret a;
}
case (ast.expr_rec(_,_,?a)) {
ret a;
}
case (ast.expr_call(_,_,?a)) {
ret a;
}
case (ast.expr_bind(_,_,?a)) {
ret a;
}
case (ast.expr_binary(_,_,_,?a)) {
ret a;
}
case (ast.expr_unary(_,_,?a)) {
ret a;
}
case (ast.expr_lit(_,?a)) {
ret a;
}
case (ast.expr_cast(_,_,?a)) {
ret a;
}
case (ast.expr_if(_,_,_,?a)) {
ret a;
}
case (ast.expr_while(_,_,?a)) {
ret a;
}
case (ast.expr_for(_,_,_,?a)) {
ret a;
}
case (ast.expr_for_each(_,_,_,?a)) {
ret a;
}
case (ast.expr_do_while(_,_,?a)) {
ret a;
}
case (ast.expr_alt(_,_,?a)) {
ret a;
}
case (ast.expr_block(_,?a)) {
ret a;
}
case (ast.expr_assign(_,_,?a)) {
ret a;
}
case (ast.expr_assign_op(_,_,_,?a)) {
ret a;
}
case (ast.expr_send(_,_,?a)) {
ret a;
}
case (ast.expr_recv(_,_,?a)) {
ret a;
}
case (ast.expr_field(_,_,?a)) {
ret a;
}
case (ast.expr_index(_,_,?a)) {
ret a;
}
case (ast.expr_path(_,_,?a)) {
ret a;
}
case (ast.expr_ext(_,_,_,_,?a)) {
ret a;
}
case (ast.expr_fail(?a)) {
ret a;
}
case (ast.expr_ret(_,?a)) {
ret a;
}
case (ast.expr_put(_,?a)) {
ret a;
}
case (ast.expr_be(_,?a)) {
ret a;
}
case (ast.expr_log(_,_,?a)) {
ret a;
}
case (ast.expr_check_expr(_,?a)) {
ret a;
}
case (ast.expr_port(?a)) {
ret a;
}
case (ast.expr_chan(_,?a)) {
ret a;
}
case (expr_break(?a)) {
ret a;
}
case (expr_cont(?a)) {
ret a;
}
case (expr_self_method(_, ?a)) {
ret a;
}
}
}
fn ann_to_ts_ann(ann a, uint nv) -> ts_ann { fn ann_to_ts_ann(ann a, uint nv) -> ts_ann {
alt (a) { alt (a) {
case (ann_none) { ret empty_ann(nv); } case (ann_none) { ret empty_ann(nv); }
@ -422,7 +532,7 @@ fn ann_to_ts_ann_fail_more(ann a) -> @ts_ann {
fail; fail;
} }
case (ann_type(_,_,?t)) { case (ann_type(_,_,?t)) {
assert (! is_none[@ts_ann](t)); check (! is_none[@ts_ann](t));
ret get[@ts_ann](t); ret get[@ts_ann](t);
} }
} }
@ -447,7 +557,7 @@ fn stmt_to_ann(&stmt s) -> option.t[@ts_ann] {
} }
/* fails if e has no annotation */ /* fails if e has no annotation */
fn expr_states(@expr e) -> pre_and_post_state { fn expr_states(&expr e) -> pre_and_post_state {
alt (expr_ann(e)) { alt (expr_ann(e)) {
case (ann_none) { case (ann_none) {
log_err "expr_pp: the impossible happened (no annotation)"; log_err "expr_pp: the impossible happened (no annotation)";
@ -468,7 +578,7 @@ fn expr_states(@expr e) -> pre_and_post_state {
} }
/* fails if e has no annotation */ /* fails if e has no annotation */
fn expr_pp(@expr e) -> pre_and_post { fn expr_pp(&expr e) -> pre_and_post {
alt (expr_ann(e)) { alt (expr_ann(e)) {
case (ann_none) { case (ann_none) {
log_err "expr_pp: the impossible happened (no annotation)"; log_err "expr_pp: the impossible happened (no annotation)";
@ -554,19 +664,19 @@ fn stmt_states(&stmt s, uint nv) -> pre_and_post_state {
} }
fn expr_precond(@expr e) -> precond { fn expr_precond(&expr e) -> precond {
ret (expr_pp(e)).precondition; ret (expr_pp(e)).precondition;
} }
fn expr_postcond(@expr e) -> postcond { fn expr_postcond(&expr e) -> postcond {
ret (expr_pp(e)).postcondition; ret (expr_pp(e)).postcondition;
} }
fn expr_prestate(@expr e) -> prestate { fn expr_prestate(&expr e) -> prestate {
ret (expr_states(e)).prestate; ret (expr_states(e)).prestate;
} }
fn expr_poststate(@expr e) -> poststate { fn expr_poststate(&expr e) -> poststate {
ret (expr_states(e)).poststate; ret (expr_states(e)).poststate;
} }
@ -627,7 +737,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond {
if (sz >= 1u) { if (sz >= 1u) {
auto first = pps.(0); auto first = pps.(0);
assert (pps_len(first) == num_vars); check (pps_len(first) == num_vars);
let precond rest = seq_preconds(enclosing, let precond rest = seq_preconds(enclosing,
slice[pre_and_post](pps, 1u, sz)); slice[pre_and_post](pps, 1u, sz));
difference(rest, first.postcondition); difference(rest, first.postcondition);
@ -687,7 +797,7 @@ fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
} }
fn intersect_postconds(&vec[postcond] pcs) -> postcond { fn intersect_postconds(&vec[postcond] pcs) -> postcond {
assert (len[postcond](pcs) > 0u); check (len[postcond](pcs) > 0u);
ret intersect_postconds_go(bitv.clone(pcs.(0)), pcs); ret intersect_postconds_go(bitv.clone(pcs.(0)), pcs);
} }
@ -716,7 +826,7 @@ fn find_pre_post_state_native_mod(&native_mod m) -> bool {
fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () { fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () {
fn do_a_method(fn_info_map fm, &@method m) -> () { fn do_a_method(fn_info_map fm, &@method m) -> () {
assert (fm.contains_key(m.node.id)); check(fm.contains_key(m.node.id));
find_pre_post_fn(fm, fm.get(m.node.id), m.node.meth); find_pre_post_fn(fm, fm.get(m.node.id), m.node.meth);
} }
auto f = bind do_a_method(fm,_); auto f = bind do_a_method(fm,_);
@ -726,7 +836,7 @@ fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () {
fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool { fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
fn do_a_method(fn_info_map fm, &@method m) -> bool { fn do_a_method(fn_info_map fm, &@method m) -> bool {
assert (fm.contains_key(m.node.id)); check(fm.contains_key(m.node.id));
ret find_pre_post_state_fn(fm, fm.get(m.node.id), m.node.meth); ret find_pre_post_state_fn(fm, fm.get(m.node.id), m.node.meth);
} }
auto f = bind do_a_method(fm,_); auto f = bind do_a_method(fm,_);
@ -739,10 +849,10 @@ fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
fn find_pre_post_item(fn_info_map fm, fn_info enclosing, &item i) -> () { fn find_pre_post_item(fn_info_map fm, fn_info enclosing, &item i) -> () {
alt (i.node) { alt (i.node) {
case (ast.item_const(?id, ?t, ?e, ?di, ?a)) { case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
find_pre_post_expr(fm, enclosing, e); find_pre_post_expr(fm, enclosing, *e);
} }
case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) { case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
assert (fm.contains_key(di)); check (fm.contains_key(di));
find_pre_post_fn(fm, fm.get(di), f); find_pre_post_fn(fm, fm.get(di), f);
} }
case (ast.item_mod(?id, ?m, ?di)) { case (ast.item_mod(?id, ?m, ?di)) {
@ -773,14 +883,14 @@ fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing,
fn do_one(fn_info_map fm, fn_info enclosing, fn do_one(fn_info_map fm, fn_info enclosing,
&@expr e) -> () { &@expr e) -> () {
find_pre_post_expr(fm, enclosing, e); find_pre_post_expr(fm, enclosing, *e);
} }
auto f = bind do_one(fm, enclosing, _); auto f = bind do_one(fm, enclosing, _);
_vec.map[@expr, ()](f, args); _vec.map[@expr, ()](f, args);
fn get_pp(&@expr e) -> pre_and_post { fn get_pp(&@expr e) -> pre_and_post {
ret expr_pp(e); ret expr_pp(*e);
} }
auto g = get_pp; auto g = get_pp;
auto pps = _vec.map[@expr, pre_and_post](g, args); auto pps = _vec.map[@expr, pre_and_post](g, args);
@ -794,31 +904,31 @@ fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing,
fn find_pre_post_loop(&fn_info_map fm, &fn_info enclosing, &@decl d, fn find_pre_post_loop(&fn_info_map fm, &fn_info enclosing, &@decl d,
&@expr index, &block body, &ann a) -> () { &@expr index, &block body, &ann a) -> () {
find_pre_post_expr(fm, enclosing, index); find_pre_post_expr(fm, enclosing, *index);
find_pre_post_block(fm, enclosing, body); find_pre_post_block(fm, enclosing, body);
auto loop_precond = declare_var(enclosing, decl_lhs(d), auto loop_precond = declare_var(enclosing, decl_lhs(d),
seq_preconds(enclosing, vec(expr_pp(index), seq_preconds(enclosing, vec(expr_pp(*index),
block_pp(body)))); block_pp(body))));
auto loop_postcond = intersect_postconds auto loop_postcond = intersect_postconds
(vec(expr_postcond(index), block_postcond(body))); (vec(expr_postcond(*index), block_postcond(body)));
set_pre_and_post(a, rec(precondition=loop_precond, set_pre_and_post(a, rec(precondition=loop_precond,
postcondition=loop_postcond)); postcondition=loop_postcond));
} }
/* Fills in annotations as a side effect. Does not rebuild the expr */ /* Fills in annotations as a side effect. Does not rebuild the expr */
fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () { fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
auto num_local_vars = num_locals(enclosing); auto num_local_vars = num_locals(enclosing);
fn do_rand_(fn_info_map fm, fn_info enclosing, &@expr e) -> () { fn do_rand_(fn_info_map fm, fn_info enclosing, &@expr e) -> () {
find_pre_post_expr(fm, enclosing, e); find_pre_post_expr(fm, enclosing, *e);
} }
fn pp_one(&@expr e) -> pre_and_post { fn pp_one(&@expr e) -> pre_and_post {
ret expr_pp(e); ret expr_pp(*e);
} }
log("find_pre_post_expr (num_locals =" + log("find_pre_post_expr (num_locals =" +
uistr(num_local_vars) + "):"); uistr(num_local_vars) + "):");
log_expr(*e); log_expr(e);
alt (e.node) { alt (e.node) {
case (expr_call(?operator, ?operands, ?a)) { case (expr_call(?operator, ?operands, ?a)) {
@ -864,18 +974,18 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
set_pre_and_post(a, empty_pre_post(num_local_vars)); set_pre_and_post(a, empty_pre_post(num_local_vars));
} }
case(expr_log(_, ?arg, ?a)) { case(expr_log(_, ?arg, ?a)) {
find_pre_post_expr(fm, enclosing, arg); find_pre_post_expr(fm, enclosing, *arg);
set_pre_and_post(a, expr_pp(arg)); set_pre_and_post(a, expr_pp(*arg));
} }
case (expr_chan(?arg, ?a)) { case (expr_chan(?arg, ?a)) {
find_pre_post_expr(fm, enclosing, arg); find_pre_post_expr(fm, enclosing, *arg);
set_pre_and_post(a, expr_pp(arg)); set_pre_and_post(a, expr_pp(*arg));
} }
case(expr_put(?opt, ?a)) { case(expr_put(?opt, ?a)) {
alt (opt) { alt (opt) {
case (some[@expr](?arg)) { case (some[@expr](?arg)) {
find_pre_post_expr(fm, enclosing, arg); find_pre_post_expr(fm, enclosing, *arg);
set_pre_and_post(a, expr_pp(arg)); set_pre_and_post(a, expr_pp(*arg));
} }
case (none[@expr]) { case (none[@expr]) {
set_pre_and_post(a, empty_pre_post(num_local_vars)); set_pre_and_post(a, empty_pre_post(num_local_vars));
@ -894,10 +1004,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
case (expr_assign(?lhs, ?rhs, ?a)) { case (expr_assign(?lhs, ?rhs, ?a)) {
alt (lhs.node) { alt (lhs.node) {
case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) { case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
find_pre_post_expr(fm, enclosing, rhs); find_pre_post_expr(fm, enclosing, *rhs);
set_pre_and_post(a, expr_pp(rhs)); set_pre_and_post(a, expr_pp(*rhs));
log("gen:"); log("gen:");
log_expr(*e); log_expr(e);
gen(enclosing, a, d_id); gen(enclosing, a, d_id);
} }
case (_) { case (_) {
@ -910,10 +1020,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
case (expr_recv(?lhs, ?rhs, ?a)) { case (expr_recv(?lhs, ?rhs, ?a)) {
alt (lhs.node) { alt (lhs.node) {
case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) { case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
find_pre_post_expr(fm, enclosing, rhs); find_pre_post_expr(fm, enclosing, *rhs);
set_pre_and_post(a, expr_pp(rhs)); set_pre_and_post(a, expr_pp(*rhs));
log("gen:"); log("gen:");
log_expr(*e); log_expr(e);
gen(enclosing, a, d_id); gen(enclosing, a, d_id);
} }
case (_) { case (_) {
@ -939,45 +1049,45 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
postcondition=false_postcond(num_local_vars))); postcondition=false_postcond(num_local_vars)));
} }
case (some[@expr](?ret_val)) { case (some[@expr](?ret_val)) {
find_pre_post_expr(fm, enclosing, ret_val); find_pre_post_expr(fm, enclosing, *ret_val);
let pre_and_post pp = let pre_and_post pp =
rec(precondition=expr_precond(ret_val), rec(precondition=expr_precond(*ret_val),
postcondition=false_postcond(num_local_vars)); postcondition=false_postcond(num_local_vars));
set_pre_and_post(a, pp); set_pre_and_post(a, pp);
} }
} }
} }
case (expr_be(?e, ?a)) { case (expr_be(?e, ?a)) {
find_pre_post_expr(fm, enclosing, e); find_pre_post_expr(fm, enclosing, *e);
set_pre_and_post(a, rec(precondition=expr_prestate(e), set_pre_and_post(a, rec(precondition=expr_prestate(*e),
postcondition=false_postcond(num_local_vars))); postcondition=false_postcond(num_local_vars)));
} }
case (expr_if(?antec, ?conseq, ?maybe_alt, ?a)) { case (expr_if(?antec, ?conseq, ?maybe_alt, ?a)) {
find_pre_post_expr(fm, enclosing, antec); find_pre_post_expr(fm, enclosing, *antec);
find_pre_post_block(fm, enclosing, conseq); find_pre_post_block(fm, enclosing, conseq);
alt (maybe_alt) { alt (maybe_alt) {
case (none[@expr]) { case (none[@expr]) {
auto precond_res = seq_preconds(enclosing, auto precond_res = seq_preconds(enclosing,
vec(expr_pp(antec), vec(expr_pp(*antec),
block_pp(conseq))); block_pp(conseq)));
set_pre_and_post(a, rec(precondition=precond_res, set_pre_and_post(a, rec(precondition=precond_res,
postcondition= postcondition=
expr_poststate(antec))); expr_poststate(*antec)));
} }
case (some[@expr](?altern)) { case (some[@expr](?altern)) {
find_pre_post_expr(fm, enclosing, altern); find_pre_post_expr(fm, enclosing, *altern);
auto precond_true_case = auto precond_true_case =
seq_preconds(enclosing, seq_preconds(enclosing,
vec(expr_pp(antec), block_pp(conseq))); vec(expr_pp(*antec), block_pp(conseq)));
auto postcond_true_case = union_postconds auto postcond_true_case = union_postconds
(num_local_vars, (num_local_vars,
vec(expr_postcond(antec), block_postcond(conseq))); vec(expr_postcond(*antec), block_postcond(conseq)));
auto precond_false_case = seq_preconds auto precond_false_case = seq_preconds
(enclosing, (enclosing,
vec(expr_pp(antec), expr_pp(altern))); vec(expr_pp(*antec), expr_pp(*altern)));
auto postcond_false_case = union_postconds auto postcond_false_case = union_postconds
(num_local_vars, (num_local_vars,
vec(expr_postcond(antec), expr_postcond(altern))); vec(expr_postcond(*antec), expr_postcond(*altern)));
auto precond_res = union_postconds auto precond_res = union_postconds
(num_local_vars, (num_local_vars,
vec(precond_true_case, precond_false_case)); vec(precond_true_case, precond_false_case));
@ -997,31 +1107,31 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
find_pre_post_exprs(fm, enclosing, vec(l, r), a); find_pre_post_exprs(fm, enclosing, vec(l, r), a);
} }
case (expr_unary(_,?operand,?a)) { case (expr_unary(_,?operand,?a)) {
find_pre_post_expr(fm, enclosing, operand); find_pre_post_expr(fm, enclosing, *operand);
set_pre_and_post(a, expr_pp(operand)); set_pre_and_post(a, expr_pp(*operand));
} }
case (expr_cast(?operand, _, ?a)) { case (expr_cast(?operand, _, ?a)) {
find_pre_post_expr(fm, enclosing, operand); find_pre_post_expr(fm, enclosing, *operand);
set_pre_and_post(a, expr_pp(operand)); set_pre_and_post(a, expr_pp(*operand));
} }
case (expr_while(?test, ?body, ?a)) { case (expr_while(?test, ?body, ?a)) {
find_pre_post_expr(fm, enclosing, test); find_pre_post_expr(fm, enclosing, *test);
find_pre_post_block(fm, enclosing, body); find_pre_post_block(fm, enclosing, body);
set_pre_and_post(a, set_pre_and_post(a,
rec(precondition= rec(precondition=
seq_preconds(enclosing, seq_preconds(enclosing,
vec(expr_pp(test), vec(expr_pp(*test),
block_pp(body))), block_pp(body))),
postcondition= postcondition=
intersect_postconds(vec(expr_postcond(test), intersect_postconds(vec(expr_postcond(*test),
block_postcond(body))))); block_postcond(body)))));
} }
case (expr_do_while(?body, ?test, ?a)) { case (expr_do_while(?body, ?test, ?a)) {
find_pre_post_block(fm, enclosing, body); find_pre_post_block(fm, enclosing, body);
find_pre_post_expr(fm, enclosing, test); find_pre_post_expr(fm, enclosing, *test);
auto loop_postcond = union_postconds(num_local_vars, auto loop_postcond = union_postconds(num_local_vars,
vec(block_postcond(body), expr_postcond(test))); vec(block_postcond(body), expr_postcond(*test)));
/* conservative approximination: if the body /* conservative approximination: if the body
could break or cont, the test may never be executed */ could break or cont, the test may never be executed */
if (has_nonlocal_exits(body)) { if (has_nonlocal_exits(body)) {
@ -1031,7 +1141,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
set_pre_and_post(a, set_pre_and_post(a,
rec(precondition=seq_preconds(enclosing, rec(precondition=seq_preconds(enclosing,
vec(block_pp(body), vec(block_pp(body),
expr_pp(test))), expr_pp(*test))),
postcondition=loop_postcond)); postcondition=loop_postcond));
} }
case (expr_for(?d, ?index, ?body, ?a)) { case (expr_for(?d, ?index, ?body, ?a)) {
@ -1044,7 +1154,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
find_pre_post_exprs(fm, enclosing, vec(e, sub), a); find_pre_post_exprs(fm, enclosing, vec(e, sub), a);
} }
case (expr_alt(?e, ?alts, ?a)) { case (expr_alt(?e, ?alts, ?a)) {
find_pre_post_expr(fm, enclosing, e); find_pre_post_expr(fm, enclosing, *e);
fn do_an_alt(fn_info_map fm, fn_info enc, &arm an_alt) fn do_an_alt(fn_info_map fm, fn_info enc, &arm an_alt)
-> pre_and_post { -> pre_and_post {
find_pre_post_block(fm, enc, an_alt.block); find_pre_post_block(fm, enc, an_alt.block);
@ -1060,7 +1170,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
intersect(pp.postcondition, next.postcondition); intersect(pp.postcondition, next.postcondition);
ret pp; ret pp;
} }
auto antec_pp = pp_clone(expr_pp(e)); auto antec_pp = pp_clone(expr_pp(*e));
auto e_pp = rec(precondition=empty_prestate(num_local_vars), auto e_pp = rec(precondition=empty_prestate(num_local_vars),
postcondition=false_postcond(num_local_vars)); postcondition=false_postcond(num_local_vars));
auto g = bind combine_pp(antec_pp, enclosing, _, _); auto g = bind combine_pp(antec_pp, enclosing, _, _);
@ -1071,8 +1181,8 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
set_pre_and_post(a, alts_overall_pp); set_pre_and_post(a, alts_overall_pp);
} }
case (expr_field(?operator, _, ?a)) { case (expr_field(?operator, _, ?a)) {
find_pre_post_expr(fm, enclosing, operator); find_pre_post_expr(fm, enclosing, *operator);
set_pre_and_post(a, expr_pp(operator)); set_pre_and_post(a, expr_pp(*operator));
} }
case (expr_fail(?a)) { case (expr_fail(?a)) {
set_pre_and_post(a, set_pre_and_post(a,
@ -1081,14 +1191,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
rec(precondition=empty_prestate(num_local_vars), rec(precondition=empty_prestate(num_local_vars),
postcondition=false_postcond(num_local_vars))); postcondition=false_postcond(num_local_vars)));
} }
case (expr_assert(?p, ?a)) { case (expr_check_expr(?p, ?a)) {
find_pre_post_expr(fm, enclosing, p);
set_pre_and_post(a, expr_pp(p));
}
case (expr_check(?p, ?a)) {
/* will need to change when we support arbitrary predicates... */ /* will need to change when we support arbitrary predicates... */
find_pre_post_expr(fm, enclosing, p); find_pre_post_expr(fm, enclosing, *p);
set_pre_and_post(a, expr_pp(p)); set_pre_and_post(a, expr_pp(*p));
} }
case(expr_bind(?operator, ?maybe_args, ?a)) { case(expr_bind(?operator, ?maybe_args, ?a)) {
auto args = _vec.cat_options[@expr](maybe_args); auto args = _vec.cat_options[@expr](maybe_args);
@ -1105,21 +1211,21 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
set_pre_and_post(a, empty_pre_post(num_local_vars)); set_pre_and_post(a, empty_pre_post(num_local_vars));
} }
case (expr_ext(_, _, _, ?expanded, ?a)) { case (expr_ext(_, _, _, ?expanded, ?a)) {
find_pre_post_expr(fm, enclosing, expanded); find_pre_post_expr(fm, enclosing, *expanded);
set_pre_and_post(a, expr_pp(expanded)); set_pre_and_post(a, expr_pp(*expanded));
} }
} }
} }
fn gen(&fn_info enclosing, &ann a, def_id id) -> bool { fn gen(&fn_info enclosing, &ann a, def_id id) -> bool {
assert (enclosing.contains_key(id)); check(enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0; let uint i = (enclosing.get(id))._0;
ret set_in_postcond(i, (ann_to_ts_ann_fail_more(a)).conditions); ret set_in_postcond(i, (ann_to_ts_ann_fail_more(a)).conditions);
} }
fn declare_var(&fn_info enclosing, def_id id, prestate pre) fn declare_var(&fn_info enclosing, def_id id, prestate pre)
-> prestate { -> prestate {
assert (enclosing.contains_key(id)); check(enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0; let uint i = (enclosing.get(id))._0;
auto res = clone(pre); auto res = clone(pre);
relax_prestate(i, res); relax_prestate(i, res);
@ -1127,7 +1233,7 @@ fn declare_var(&fn_info enclosing, def_id id, prestate pre)
} }
fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool { fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool {
assert (enclosing.contains_key(id)); check(enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0; let uint i = (enclosing.get(id))._0;
ret set_in_poststate(i, (ann_to_ts_ann_fail_more(a)).states); ret set_in_poststate(i, (ann_to_ts_ann_fail_more(a)).states);
@ -1145,8 +1251,8 @@ fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s)
case(ast.decl_local(?alocal)) { case(ast.decl_local(?alocal)) {
alt(alocal.init) { alt(alocal.init) {
case(some[ast.initializer](?an_init)) { case(some[ast.initializer](?an_init)) {
find_pre_post_expr(fm, enclosing, an_init.expr); find_pre_post_expr(fm, enclosing, *an_init.expr);
auto rhs_pp = expr_pp(an_init.expr); auto rhs_pp = expr_pp(*an_init.expr);
set_pre_and_post(alocal.ann, rhs_pp); set_pre_and_post(alocal.ann, rhs_pp);
/* Inherit ann from initializer, and add var being /* Inherit ann from initializer, and add var being
@ -1175,8 +1281,8 @@ fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s)
} }
} }
case(stmt_expr(?e,?a)) { case(stmt_expr(?e,?a)) {
find_pre_post_expr(fm, enclosing, e); find_pre_post_expr(fm, enclosing, *e);
set_pre_and_post(a, expr_pp(e)); set_pre_and_post(a, expr_pp(*e));
} }
} }
} }
@ -1212,7 +1318,7 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b)
_vec.map[@stmt, ()](do_one, b.node.stmts); _vec.map[@stmt, ()](do_one, b.node.stmts);
fn do_inner_(fn_info_map fm, fn_info i, &@expr e) -> () { fn do_inner_(fn_info_map fm, fn_info i, &@expr e) -> () {
find_pre_post_expr(fm, i, e); find_pre_post_expr(fm, i, *e);
} }
auto do_inner = bind do_inner_(fm, enclosing, _); auto do_inner = bind do_inner_(fm, enclosing, _);
option.map[@expr, ()](do_inner, b.node.expr); option.map[@expr, ()](do_inner, b.node.expr);
@ -1225,7 +1331,7 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b)
auto f = get_pp_stmt; auto f = get_pp_stmt;
pps += _vec.map[@stmt, pre_and_post](f, b.node.stmts); pps += _vec.map[@stmt, pre_and_post](f, b.node.stmts);
fn get_pp_expr(&@expr e) -> pre_and_post { fn get_pp_expr(&@expr e) -> pre_and_post {
ret expr_pp(e); ret expr_pp(*e);
} }
auto g = get_pp_expr; auto g = get_pp_expr;
plus_option[pre_and_post](pps, plus_option[pre_and_post](pps,
@ -1257,7 +1363,7 @@ fn check_item_fn(&fn_info_map fm, &span sp, ident i, &ast._fn f,
log("check_item_fn:"); log("check_item_fn:");
log_fn(f, i, ty_params); log_fn(f, i, ty_params);
assert (fm.contains_key(id)); check (fm.contains_key(id));
find_pre_post_fn(fm, fm.get(id), f); find_pre_post_fn(fm, fm.get(id), f);
ret @respan(sp, ast.item_fn(i, f, ty_params, id, a)); ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
@ -1271,7 +1377,7 @@ fn find_pre_post_state_item(fn_info_map fm, fn_info enclosing, @item i)
empty_prestate(num_locals(enclosing)), e); empty_prestate(num_locals(enclosing)), e);
} }
case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) { case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
assert (fm.contains_key(di)); check (fm.contains_key(di));
ret find_pre_post_state_fn(fm, fm.get(di), f); ret find_pre_post_state_fn(fm, fm.get(di), f);
} }
case (ast.item_mod(?id, ?m, ?di)) { case (ast.item_mod(?id, ?m, ?di)) {
@ -1295,7 +1401,7 @@ fn find_pre_post_state_item(fn_info_map fm, fn_info enclosing, @item i)
fn set_prestate_ann(@ann a, prestate pre) -> bool { fn set_prestate_ann(@ann a, prestate pre) -> bool {
alt (*a) { alt (*a) {
case (ann_type(_,_,?ts_a)) { case (ann_type(_,_,?ts_a)) {
assert (! is_none[@ts_ann](ts_a)); check (! is_none[@ts_ann](ts_a));
ret set_prestate(get[@ts_ann](ts_a), pre); ret set_prestate(get[@ts_ann](ts_a), pre);
} }
case (ann_none) { case (ann_none) {
@ -1309,8 +1415,8 @@ fn set_prestate_ann(@ann a, prestate pre) -> bool {
fn extend_prestate_ann(ann a, prestate pre) -> bool { fn extend_prestate_ann(ann a, prestate pre) -> bool {
alt (a) { alt (a) {
case (ann_type(_,_,?ts_a)) { case (ann_type(_,_,?ts_a)) {
assert (! is_none[@ts_ann](ts_a)); check (! is_none[@ts_ann](ts_a));
ret extend_prestate((get[@ts_ann](ts_a)).states.prestate, pre); ret extend_prestate((*get[@ts_ann](ts_a)).states.prestate, pre);
} }
case (ann_none) { case (ann_none) {
log("set_prestate_ann: expected an ann_type here"); log("set_prestate_ann: expected an ann_type here");
@ -1322,8 +1428,8 @@ fn extend_prestate_ann(ann a, prestate pre) -> bool {
fn set_poststate_ann(ann a, poststate post) -> bool { fn set_poststate_ann(ann a, poststate post) -> bool {
alt (a) { alt (a) {
case (ann_type(_,_,?ts_a)) { case (ann_type(_,_,?ts_a)) {
assert (! is_none[@ts_ann](ts_a)); check (! is_none[@ts_ann](ts_a));
ret set_poststate(get[@ts_ann](ts_a), post); ret set_poststate(*get[@ts_ann](ts_a), post);
} }
case (ann_none) { case (ann_none) {
log("set_poststate_ann: expected an ann_type here"); log("set_poststate_ann: expected an ann_type here");
@ -1335,7 +1441,7 @@ fn set_poststate_ann(ann a, poststate post) -> bool {
fn extend_poststate_ann(ann a, poststate post) -> bool { fn extend_poststate_ann(ann a, poststate post) -> bool {
alt (a) { alt (a) {
case (ann_type(_,_,?ts_a)) { case (ann_type(_,_,?ts_a)) {
assert (! is_none[@ts_ann](ts_a)); check (! is_none[@ts_ann](ts_a));
ret extend_poststate((*get[@ts_ann](ts_a)).states.poststate, post); ret extend_poststate((*get[@ts_ann](ts_a)).states.poststate, post);
} }
case (ann_none) { case (ann_none) {
@ -1348,7 +1454,7 @@ fn extend_poststate_ann(ann a, poststate post) -> bool {
fn set_pre_and_post(&ann a, pre_and_post pp) -> () { fn set_pre_and_post(&ann a, pre_and_post pp) -> () {
alt (a) { alt (a) {
case (ann_type(_,_,?ts_a)) { case (ann_type(_,_,?ts_a)) {
assert (! is_none[@ts_ann](ts_a)); check (! is_none[@ts_ann](ts_a));
auto t = *get[@ts_ann](ts_a); auto t = *get[@ts_ann](ts_a);
/* log("set_pre_and_post, old ="); /* log("set_pre_and_post, old =");
log_pp(t.conditions); log_pp(t.conditions);
@ -1372,7 +1478,7 @@ fn seq_states(&fn_info_map fm, &fn_info enclosing,
for (@expr e in exprs) { for (@expr e in exprs) {
changed = find_pre_post_state_expr(fm, enclosing, post, e) || changed; changed = find_pre_post_state_expr(fm, enclosing, post, e) || changed;
post = expr_poststate(e); post = expr_poststate(*e);
} }
ret tup(changed, post); ret tup(changed, post);
@ -1407,8 +1513,8 @@ fn find_pre_post_state_loop(fn_info_map fm, fn_info enclosing,
/* in general, would need the intersection of /* in general, would need the intersection of
(poststate of index, poststate of body) */ (poststate of index, poststate of body) */
changed = find_pre_post_state_block(fm, enclosing, changed = find_pre_post_state_block(fm, enclosing,
expr_poststate(index), body) || changed; expr_poststate(*index), body) || changed;
auto res_p = intersect_postconds(vec(expr_poststate(index), auto res_p = intersect_postconds(vec(expr_poststate(*index),
block_poststate(body))); block_poststate(body)));
changed = extend_poststate_ann(a, res_p) || changed; changed = extend_poststate_ann(a, res_p) || changed;
@ -1416,7 +1522,7 @@ fn find_pre_post_state_loop(fn_info_map fm, fn_info enclosing,
} }
fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
&prestate pres, @expr e) -> bool { &prestate pres, &@expr e) -> bool {
auto changed = false; auto changed = false;
auto num_local_vars = num_locals(enclosing); auto num_local_vars = num_locals(enclosing);
@ -1434,20 +1540,20 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
|| changed; || changed;
/* rands go left-to-right */ /* rands go left-to-right */
ret(find_pre_post_state_exprs(fm, enclosing, ret(find_pre_post_state_exprs(fm, enclosing,
expr_poststate(operator), a, operands) expr_poststate(*operator), a, operands)
|| changed); || changed);
} }
case (expr_spawn(_, _, ?operator, ?operands, ?a)) { case (expr_spawn(_, _, ?operator, ?operands, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, operator); changed = find_pre_post_state_expr(fm, enclosing, pres, operator);
ret(find_pre_post_state_exprs(fm, enclosing, ret(find_pre_post_state_exprs(fm, enclosing,
expr_poststate(operator), a, operands) expr_poststate(*operator), a, operands)
|| changed); || changed);
} }
case (expr_bind(?operator, ?maybe_args, ?a)) { case (expr_bind(?operator, ?maybe_args, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, operator) changed = find_pre_post_state_expr(fm, enclosing, pres, operator)
|| changed; || changed;
ret (find_pre_post_state_exprs(fm, enclosing, ret (find_pre_post_state_exprs(fm, enclosing,
expr_poststate(operator), a, cat_options[@expr](maybe_args)) expr_poststate(*operator), a, cat_options[@expr](maybe_args))
|| changed); || changed);
} }
case (expr_path(_,_,?a)) { case (expr_path(_,_,?a)) {
@ -1457,19 +1563,19 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
/* factor out the "one exp" pattern */ /* factor out the "one exp" pattern */
changed = find_pre_post_state_expr(fm, enclosing, pres, e); changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(e)) || changed; changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
ret changed; ret changed;
} }
case (expr_chan(?e, ?a)) { case (expr_chan(?e, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e); changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(e)) || changed; changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
ret changed; ret changed;
} }
case (expr_ext(_, _, _, ?expanded, ?a)) { case (expr_ext(_, _, _, ?expanded, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, expanded); changed = find_pre_post_state_expr(fm, enclosing, pres, expanded);
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(expanded)) changed = extend_poststate_ann(a, expr_poststate(*expanded))
|| changed; || changed;
ret changed; ret changed;
} }
@ -1478,7 +1584,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
case (some[@expr](?arg)) { case (some[@expr](?arg)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, arg); changed = find_pre_post_state_expr(fm, enclosing, pres, arg);
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(arg)) changed = extend_poststate_ann(a, expr_poststate(*arg))
|| changed; || changed;
ret changed; ret changed;
} }
@ -1505,7 +1611,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
case (some[@expr](?base)) { case (some[@expr](?base)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, base) changed = find_pre_post_state_expr(fm, enclosing, pres, base)
|| changed; || changed;
changed = extend_poststate_ann(a, expr_poststate(base)) changed = extend_poststate_ann(a, expr_poststate(*base))
|| changed; || changed;
} }
} }
@ -1520,7 +1626,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = pure_exp(a_lhs, pres) || changed; changed = pure_exp(a_lhs, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, rhs) changed = find_pre_post_state_expr(fm, enclosing, pres, rhs)
|| changed; || changed;
changed = extend_poststate_ann(a, expr_poststate(rhs)) changed = extend_poststate_ann(a, expr_poststate(*rhs))
|| changed; || changed;
changed = gen_poststate(enclosing, a, d_id) || changed; changed = gen_poststate(enclosing, a, d_id) || changed;
} }
@ -1529,8 +1635,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, lhs) changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
|| changed; || changed;
changed = find_pre_post_state_expr(fm, enclosing, changed = find_pre_post_state_expr(fm, enclosing,
expr_poststate(lhs), rhs) || changed; expr_poststate(*lhs), rhs) || changed;
changed = extend_poststate_ann(a, expr_poststate(rhs)) changed = extend_poststate_ann(a, expr_poststate(*rhs))
|| changed; || changed;
} }
} }
@ -1545,7 +1651,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = pure_exp(a_lhs, pres) || changed; changed = pure_exp(a_lhs, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, rhs) changed = find_pre_post_state_expr(fm, enclosing, pres, rhs)
|| changed; || changed;
changed = extend_poststate_ann(a, expr_poststate(rhs)) changed = extend_poststate_ann(a, expr_poststate(*rhs))
|| changed; || changed;
changed = gen_poststate(enclosing, a, d_id) || changed; changed = gen_poststate(enclosing, a, d_id) || changed;
} }
@ -1554,8 +1660,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, lhs) changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
|| changed; || changed;
changed = find_pre_post_state_expr(fm, enclosing, changed = find_pre_post_state_expr(fm, enclosing,
expr_poststate(lhs), rhs) || changed; expr_poststate(*lhs), rhs) || changed;
changed = extend_poststate_ann(a, expr_poststate(rhs)) changed = extend_poststate_ann(a, expr_poststate(*rhs))
|| changed; || changed;
} }
} }
@ -1585,17 +1691,17 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, antec) changed = find_pre_post_state_expr(fm, enclosing, pres, antec)
|| changed; || changed;
changed = find_pre_post_state_block(fm, enclosing, changed = find_pre_post_state_block(fm, enclosing,
expr_poststate(antec), conseq) || changed; expr_poststate(*antec), conseq) || changed;
alt (maybe_alt) { alt (maybe_alt) {
case (none[@expr]) { case (none[@expr]) {
changed = extend_poststate_ann(a, expr_poststate(antec)) changed = extend_poststate_ann(a, expr_poststate(*antec))
|| changed; || changed;
} }
case (some[@expr](?altern)) { case (some[@expr](?altern)) {
changed = find_pre_post_state_expr(fm, enclosing, changed = find_pre_post_state_expr(fm, enclosing,
expr_poststate(antec), altern) || changed; expr_poststate(*antec), altern) || changed;
auto poststate_res = intersect_postconds auto poststate_res = intersect_postconds
(vec(block_poststate(conseq), expr_poststate(altern))); (vec(block_poststate(conseq), expr_poststate(*altern)));
changed = extend_poststate_ann(a, poststate_res) || changed; changed = extend_poststate_ann(a, poststate_res) || changed;
} }
} }
@ -1604,7 +1710,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
log("new prestate:"); log("new prestate:");
log_bitv(enclosing, pres); log_bitv(enclosing, pres);
log("new poststate:"); log("new poststate:");
log_bitv(enclosing, expr_poststate(e)); log_bitv(enclosing, expr_poststate(*e));
ret changed; ret changed;
} }
@ -1614,8 +1720,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, l) changed = find_pre_post_state_expr(fm, enclosing, pres, l)
|| changed; || changed;
changed = find_pre_post_state_expr(fm, changed = find_pre_post_state_expr(fm,
enclosing, expr_poststate(l), r) || changed; enclosing, expr_poststate(*l), r) || changed;
changed = extend_poststate_ann(a, expr_poststate(r)) || changed; changed = extend_poststate_ann(a, expr_poststate(*r)) || changed;
ret changed; ret changed;
} }
case (expr_send(?l, ?r, ?a)) { case (expr_send(?l, ?r, ?a)) {
@ -1623,8 +1729,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, l) changed = find_pre_post_state_expr(fm, enclosing, pres, l)
|| changed; || changed;
changed = find_pre_post_state_expr(fm, changed = find_pre_post_state_expr(fm,
enclosing, expr_poststate(l), r) || changed; enclosing, expr_poststate(*l), r) || changed;
changed = extend_poststate_ann(a, expr_poststate(r)) || changed; changed = extend_poststate_ann(a, expr_poststate(*r)) || changed;
ret changed; ret changed;
} }
case (expr_assign_op(?op, ?lhs, ?rhs, ?a)) { case (expr_assign_op(?op, ?lhs, ?rhs, ?a)) {
@ -1633,8 +1739,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, lhs) changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
|| changed; || changed;
changed = find_pre_post_state_expr(fm, changed = find_pre_post_state_expr(fm,
enclosing, expr_poststate(lhs), rhs) || changed; enclosing, expr_poststate(*lhs), rhs) || changed;
changed = extend_poststate_ann(a, expr_poststate(rhs)) || changed; changed = extend_poststate_ann(a, expr_poststate(*rhs)) || changed;
ret changed; ret changed;
} }
case (expr_while(?test, ?body, ?a)) { case (expr_while(?test, ?body, ?a)) {
@ -1650,9 +1756,9 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, test) changed = find_pre_post_state_expr(fm, enclosing, pres, test)
|| changed; || changed;
changed = find_pre_post_state_block(fm, changed = find_pre_post_state_block(fm,
enclosing, expr_poststate(test), body) || changed; enclosing, expr_poststate(*test), body) || changed;
changed = extend_poststate_ann(a, changed = extend_poststate_ann(a,
intersect_postconds(vec(expr_poststate(test), intersect_postconds(vec(expr_poststate(*test),
block_poststate(body)))) || changed; block_poststate(body)))) || changed;
ret changed; ret changed;
} }
@ -1671,7 +1777,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = set_poststate_ann(a, pres) || changed; changed = set_poststate_ann(a, pres) || changed;
} }
else { else {
changed = extend_poststate_ann(a, expr_poststate(test)) changed = extend_poststate_ann(a, expr_poststate(*test))
|| changed; || changed;
} }
@ -1687,14 +1793,14 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed; changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
changed = find_pre_post_state_expr(fm, enclosing, changed = find_pre_post_state_expr(fm, enclosing,
expr_poststate(e), sub) || changed; expr_poststate(*e), sub) || changed;
changed = extend_poststate_ann(a, expr_poststate(sub)); changed = extend_poststate_ann(a, expr_poststate(*sub));
ret changed; ret changed;
} }
case (expr_alt(?e, ?alts, ?a)) { case (expr_alt(?e, ?alts, ?a)) {
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed; changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
auto e_post = expr_poststate(e); auto e_post = expr_poststate(*e);
auto a_post; auto a_post;
if (_vec.len[arm](alts) > 0u) { if (_vec.len[arm](alts) > 0u) {
a_post = false_postcond(num_local_vars); a_post = false_postcond(num_local_vars);
@ -1715,14 +1821,14 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
case (expr_field(?e,_,?a)) { case (expr_field(?e,_,?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e); changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(e)) || changed; changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
ret changed; ret changed;
} }
case (expr_unary(_,?operand,?a)) { case (expr_unary(_,?operand,?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, operand) changed = find_pre_post_state_expr(fm, enclosing, pres, operand)
|| changed; || changed;
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(operand)) changed = extend_poststate_ann(a, expr_poststate(*operand))
|| changed; || changed;
ret changed; ret changed;
} }
@ -1730,7 +1836,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr(fm, enclosing, pres, operand) changed = find_pre_post_state_expr(fm, enclosing, pres, operand)
|| changed; || changed;
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = extend_poststate_ann(a, expr_poststate(operand)) changed = extend_poststate_ann(a, expr_poststate(*operand))
|| changed; || changed;
ret changed; ret changed;
} }
@ -1739,15 +1845,14 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
/* if execution continues after fail, then everything is true! woo! */ /* if execution continues after fail, then everything is true! woo! */
changed = set_poststate_ann(a, false_postcond(num_local_vars)) changed = set_poststate_ann(a, false_postcond(num_local_vars))
|| changed; || changed;
/* log_err("fail: poststate = ");
log_bitv(enclosing, expr_poststate(*e)); */
ret changed; ret changed;
} }
case (expr_assert(?p, ?a)) { case (expr_check_expr(?p, ?a)) {
ret pure_exp(a, pres);
}
case (expr_check(?p, ?a)) {
changed = extend_prestate_ann(a, pres) || changed; changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, p) || changed; changed = find_pre_post_state_expr(fm, enclosing, pres, p) || changed;
/* FIXME: update the postcondition to reflect that p holds */ /* p is pure, so the poststate must be the same as the prestate */
changed = extend_poststate_ann(a, pres) || changed; changed = extend_poststate_ann(a, pres) || changed;
ret changed; ret changed;
} }
@ -1770,7 +1875,7 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing,
&prestate pres, @stmt s) -> bool { &prestate pres, @stmt s) -> bool {
auto changed = false; auto changed = false;
auto stmt_ann_ = stmt_to_ann(*s); auto stmt_ann_ = stmt_to_ann(*s);
assert (!is_none[@ts_ann](stmt_ann_)); check (!is_none[@ts_ann](stmt_ann_));
auto stmt_ann = *(get[@ts_ann](stmt_ann_)); auto stmt_ann = *(get[@ts_ann](stmt_ann_));
log("*At beginning: stmt = "); log("*At beginning: stmt = ");
log_stmt(*s); log_stmt(*s);
@ -1792,7 +1897,7 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing,
changed = find_pre_post_state_expr changed = find_pre_post_state_expr
(fm, enclosing, pres, an_init.expr) || changed; (fm, enclosing, pres, an_init.expr) || changed;
changed = extend_poststate(stmt_ann.states.poststate, changed = extend_poststate(stmt_ann.states.poststate,
expr_poststate(an_init.expr)) expr_poststate(*an_init.expr))
|| changed; || changed;
changed = gen_poststate(enclosing, a, alocal.id) || changed; changed = gen_poststate(enclosing, a, alocal.id) || changed;
log("Summary: stmt = "); log("Summary: stmt = ");
@ -1827,10 +1932,10 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing,
} }
case (stmt_expr(?e, _)) { case (stmt_expr(?e, _)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed; changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
changed = extend_prestate(stmt_ann.states.prestate, expr_prestate(e)) changed = extend_prestate(stmt_ann.states.prestate, expr_prestate(*e))
|| changed; || changed;
changed = extend_poststate(stmt_ann.states.poststate, changed = extend_poststate(stmt_ann.states.poststate,
expr_poststate(e)) || changed; expr_poststate(*e)) || changed;
/* /*
log("Summary: stmt = "); log("Summary: stmt = ");
log_stmt(*s); log_stmt(*s);
@ -1875,7 +1980,7 @@ fn find_pre_post_state_block(&fn_info_map fm, &fn_info enclosing,
case (none[@expr]) {} case (none[@expr]) {}
case (some[@expr](?e)) { case (some[@expr](?e)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed; changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
post = expr_poststate(e); post = expr_poststate(*e);
} }
} }
@ -1933,13 +2038,13 @@ fn fixed_point_states(fn_info_map fm, fn_info f_info,
} }
} }
fn check_states_expr(fn_info enclosing, @expr e) -> () { fn check_states_expr(fn_info enclosing, &expr e) -> () {
let precond prec = expr_precond(e); let precond prec = expr_precond(e);
let prestate pres = expr_prestate(e); let prestate pres = expr_prestate(e);
if (!implies(pres, prec)) { if (!implies(pres, prec)) {
log_err("check_states_expr: Unsatisfied precondition constraint for "); log_err("check_states_expr: Unsatisfied precondition constraint for ");
log_expr_err(*e); log_expr_err(e);
log_err("Precondition: "); log_err("Precondition: ");
log_bitv_err(enclosing, prec); log_bitv_err(enclosing, prec);
log_err("Prestate: "); log_err("Prestate: ");
@ -1988,7 +2093,7 @@ fn check_states_against_conditions(fn_info enclosing, &ast._fn f) -> () {
_vec.map[@stmt, ()](do_one, f.body.node.stmts); _vec.map[@stmt, ()](do_one, f.body.node.stmts);
fn do_inner_(fn_info i, &@expr e) -> () { fn do_inner_(fn_info i, &@expr e) -> () {
check_states_expr(i, e); check_states_expr(i, *e);
} }
auto do_inner = bind do_inner_(enclosing, _); auto do_inner = bind do_inner_(enclosing, _);
option.map[@expr, ()](do_inner, f.body.node.expr); option.map[@expr, ()](do_inner, f.body.node.expr);
@ -2011,7 +2116,7 @@ fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i,
ann a) -> @item { ann a) -> @item {
/* Look up the var-to-bit-num map for this function */ /* Look up the var-to-bit-num map for this function */
assert (f_info_map.contains_key(id)); check(f_info_map.contains_key(id));
auto f_info = f_info_map.get(id); auto f_info = f_info_map.get(id);
check_fn_states(f_info_map, f_info, f); check_fn_states(f_info_map, f_info, f);
@ -2021,7 +2126,7 @@ fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i,
} }
fn check_method_states(&fn_info_map f_info_map, @method m) -> () { fn check_method_states(&fn_info_map f_info_map, @method m) -> () {
assert (f_info_map.contains_key(m.node.id)); check (f_info_map.contains_key(m.node.id));
auto f_info = f_info_map.get(m.node.id); auto f_info = f_info_map.get(m.node.id);
check_fn_states(f_info_map, f_info, m.node.meth); check_fn_states(f_info_map, f_info, m.node.meth);
} }
@ -2088,7 +2193,7 @@ fn init_block(&fn_info fi, &span sp, &block_ b) -> block {
fn item_fn_anns(&fn_info_map fm, &span sp, ident i, &ast._fn f, fn item_fn_anns(&fn_info_map fm, &span sp, ident i, &ast._fn f,
vec[ast.ty_param] ty_params, def_id id, ann a) -> @item { vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
assert (fm.contains_key(id)); check(fm.contains_key(id));
auto f_info = fm.get(id); auto f_info = fm.get(id);
log(i + " has " + uistr(num_locals(f_info)) + " local vars"); log(i + " has " + uistr(num_locals(f_info)) + " local vars");
@ -2308,11 +2413,8 @@ fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr {
case (expr_log(?n, ?e, ?a)) { case (expr_log(?n, ?e, ?a)) {
e1 = expr_log(n, annotate_expr(fm, e), a); e1 = expr_log(n, annotate_expr(fm, e), a);
} }
case (expr_assert(?e, ?a)) { case (expr_check_expr(?e, ?a)) {
e1 = expr_assert(annotate_expr(fm, e), a); e1 = expr_check_expr(annotate_expr(fm, e), a);
}
case (expr_check(?e, ?a)) {
e1 = expr_check(annotate_expr(fm, e), a);
} }
case (expr_port(_)) { /* no change */ } case (expr_port(_)) { /* no change */ }
case (expr_chan(?e, ?a)) { case (expr_chan(?e, ?a)) {

5
src/comp/middle/walk.rs
View file

@ -392,10 +392,7 @@ fn walk_expr(&ast_visitor v, @ast.expr e) {
case (ast.expr_log(_,?x, _)) { case (ast.expr_log(_,?x, _)) {
walk_expr(v, x); walk_expr(v, x);
} }
case (ast.expr_check(?x, _)) { case (ast.expr_check_expr(?x, _)) {
walk_expr(v, x);
}
case (ast.expr_assert(?x, _)) {
walk_expr(v, x); walk_expr(v, x);
} }
case (ast.expr_port(_)) { } case (ast.expr_port(_)) { }

8
src/comp/pretty/pprust.rs
View file

@ -661,18 +661,12 @@ fn print_expr(ps s, &@ast.expr expr) {
} }
print_expr(s, expr); print_expr(s, expr);
} }
case (ast.expr_check(?expr,_)) { case (ast.expr_check_expr(?expr,_)) {
wrd1(s, "check"); wrd1(s, "check");
popen_h(s); popen_h(s);
print_expr(s, expr); print_expr(s, expr);
pclose(s); pclose(s);
} }
case (ast.expr_assert(?expr,_)) {
wrd1(s, "assert");
popen_h(s);
print_expr(s, expr);
pclose(s);
}
case (ast.expr_ext(?path, ?args, ?body, _, _)) { case (ast.expr_ext(?path, ?args, ?body, _, _)) {
wrd(s.s, "#"); wrd(s.s, "#");
print_path(s, path); print_path(s, path);

4
src/comp/util/typestate_ann.rs
View file

@ -85,7 +85,7 @@ fn intersect(&precond p1, &precond p2) -> bool {
fn pps_len(&pre_and_post p) -> uint { fn pps_len(&pre_and_post p) -> uint {
// gratuitous check // gratuitous check
assert (p.precondition.nbits == p.postcondition.nbits); check (p.precondition.nbits == p.postcondition.nbits);
ret p.precondition.nbits; ret p.precondition.nbits;
} }
@ -129,7 +129,7 @@ fn set_prestate(@ts_ann a, &prestate p) -> bool {
// Sets all the bits in a's postcondition to equal the // Sets all the bits in a's postcondition to equal the
// corresponding bit in p's postcondition. // corresponding bit in p's postcondition.
fn set_poststate(@ts_ann a, &poststate p) -> bool { fn set_poststate(&ts_ann a, &poststate p) -> bool {
ret bitv.copy(a.states.poststate, p); ret bitv.copy(a.states.poststate, p);
} }

2
src/lib/Term.rs
View file

@ -35,7 +35,7 @@ fn color_supported() -> bool {
} }
fn set_color(io.buf_writer writer, u8 first_char, u8 color) { fn set_color(io.buf_writer writer, u8 first_char, u8 color) {
assert (color < 16u8); check (color < 16u8);
esc(writer); esc(writer);
if (color >= 8u8) { if (color >= 8u8) {

2
src/lib/_int.rs
View file

@ -27,7 +27,7 @@ iter range(int lo, int hi) -> int {
fn to_str(int n, uint radix) -> str fn to_str(int n, uint radix) -> str
{ {
assert (0u < radix && radix <= 16u); check (0u < radix && radix <= 16u);
if (n < 0) { if (n < 0) {
ret "-" + _uint.to_str((-n) as uint, radix); ret "-" + _uint.to_str((-n) as uint, radix);
} else { } else {

14
src/lib/_str.rs
View file

@ -218,14 +218,14 @@ fn utf8_char_width(u8 b) -> uint {
fn char_range_at(str s, uint i) -> tup(char, uint) { fn char_range_at(str s, uint i) -> tup(char, uint) {
auto b0 = s.(i); auto b0 = s.(i);
auto w = utf8_char_width(b0); auto w = utf8_char_width(b0);
assert (w != 0u); check(w != 0u);
if (w == 1u) {ret tup(b0 as char, i + 1u);} if (w == 1u) {ret tup(b0 as char, i + 1u);}
auto val = 0u; auto val = 0u;
auto end = i + w; auto end = i + w;
i += 1u; i += 1u;
while (i < end) { while (i < end) {
auto byte = s.(i); auto byte = s.(i);
assert (byte & 0xc0_u8 == tag_cont_u8); check(byte & 0xc0_u8 == tag_cont_u8);
val <<= 6u; val <<= 6u;
val += (byte & 0x3f_u8) as uint; val += (byte & 0x3f_u8) as uint;
i += 1u; i += 1u;
@ -247,11 +247,11 @@ fn char_len(str s) -> uint {
auto total = byte_len(s); auto total = byte_len(s);
while (i < total) { while (i < total) {
auto chsize = utf8_char_width(s.(i)); auto chsize = utf8_char_width(s.(i));
assert (chsize > 0u); check(chsize > 0u);
len += 1u; len += 1u;
i += chsize; i += chsize;
} }
assert (i == total); check(i == total);
ret len; ret len;
} }
@ -274,7 +274,7 @@ fn push_char(&mutable str s, char ch) {
fn pop_char(&mutable str s) -> char { fn pop_char(&mutable str s) -> char {
auto end = byte_len(s); auto end = byte_len(s);
while (end > 0u && s.(end - 1u) & 0xc0_u8 == tag_cont_u8) {end -= 1u;} while (end > 0u && s.(end - 1u) & 0xc0_u8 == tag_cont_u8) {end -= 1u;}
assert (end > 0u); check(end > 0u);
auto ch = char_at(s, end - 1u); auto ch = char_at(s, end - 1u);
s = substr(s, 0u, end - 1u); s = substr(s, 0u, end - 1u);
ret ch; ret ch;
@ -404,7 +404,7 @@ fn slice(str s, uint begin, uint end) -> str {
fn shift_byte(&mutable str s) -> u8 { fn shift_byte(&mutable str s) -> u8 {
auto len = byte_len(s); auto len = byte_len(s);
assert (len > 0u); check(len > 0u);
auto b = s.(0); auto b = s.(0);
s = substr(s, 1u, len - 1u); s = substr(s, 1u, len - 1u);
ret b; ret b;
@ -412,7 +412,7 @@ fn shift_byte(&mutable str s) -> u8 {
fn pop_byte(&mutable str s) -> u8 { fn pop_byte(&mutable str s) -> u8 {
auto len = byte_len(s); auto len = byte_len(s);
assert (len > 0u); check(len > 0u);
auto b = s.(len - 1u); auto b = s.(len - 1u);
s = substr(s, 0u, len - 1u); s = substr(s, 0u, len - 1u);
ret b; ret b;

2
src/lib/_uint.rs
View file

@ -56,7 +56,7 @@ fn to_str(uint num, uint radix) -> str
{ {
auto n = num; auto n = num;
assert (0u < radix && radix <= 16u); check (0u < radix && radix <= 16u);
fn digit(uint n) -> char { fn digit(uint n) -> char {
alt (n) { alt (n) {
case (0u) { ret '0'; } case (0u) { ret '0'; }

11
src/lib/_vec.rs
View file

@ -131,7 +131,7 @@ fn len_set[T](array[T] v, uint n) {
} }
fn buf_off[T](array[T] v, uint offset) -> vbuf { fn buf_off[T](array[T] v, uint offset) -> vbuf {
assert (offset < len[T](v)); check (offset < len[T](v));
ret rustrt.vec_buf[T](v, offset); ret rustrt.vec_buf[T](v, offset);
} }
@ -149,10 +149,9 @@ fn last[T](array[T] v) -> option.t[T] {
} }
// Returns elements from [start..end) from v. // Returns elements from [start..end) from v.
fn slice[T](array[T] v, uint start, uint end) -> vec[T] { fn slice[T](array[T] v, uint start, uint end) -> vec[T] {
assert (start <= end); check (start <= end);
assert (end <= len[T](v)); check (end <= len[T](v));
auto result = alloc[T](end - start); auto result = alloc[T](end - start);
let uint i = start; let uint i = start;
while (i < end) { while (i < end) {
@ -164,7 +163,7 @@ fn slice[T](array[T] v, uint start, uint end) -> vec[T] {
fn shift[T](&mutable array[T] v) -> T { fn shift[T](&mutable array[T] v) -> T {
auto ln = len[T](v); auto ln = len[T](v);
assert (ln > 0u); check(ln > 0u);
auto e = v.(0); auto e = v.(0);
v = slice[T](v, 1u, ln); v = slice[T](v, 1u, ln);
ret e; ret e;
@ -172,7 +171,7 @@ fn shift[T](&mutable array[T] v) -> T {
fn pop[T](&mutable array[T] v) -> T { fn pop[T](&mutable array[T] v) -> T {
auto ln = len[T](v); auto ln = len[T](v);
assert (ln > 0u); check(ln > 0u);
ln -= 1u; ln -= 1u;
auto e = v.(ln); auto e = v.(ln);
v = slice[T](v, 0u, ln); v = slice[T](v, 0u, ln);

10
src/lib/bitv.rs
View file

@ -28,8 +28,8 @@ fn create(uint nbits, bool init) -> t {
fn process(&fn(uint, uint) -> uint op, &t v0, &t v1) -> bool { fn process(&fn(uint, uint) -> uint op, &t v0, &t v1) -> bool {
auto len = _vec.len[mutable uint](v1.storage); auto len = _vec.len[mutable uint](v1.storage);
assert (_vec.len[mutable uint](v0.storage) == len); check (_vec.len[mutable uint](v0.storage) == len);
assert (v0.nbits == v1.nbits); check (v0.nbits == v1.nbits);
auto changed = false; auto changed = false;
@ -84,7 +84,7 @@ fn clone(t v) -> t {
} }
fn get(&t v, uint i) -> bool { fn get(&t v, uint i) -> bool {
assert (i < v.nbits); check (i < v.nbits);
auto bits = uint_bits(); auto bits = uint_bits();
@ -129,7 +129,7 @@ fn difference(&t v0, &t v1) -> bool {
} }
fn set(&t v, uint i, bool x) { fn set(&t v, uint i, bool x) {
assert (i < v.nbits); check (i < v.nbits);
auto bits = uint_bits(); auto bits = uint_bits();
@ -196,7 +196,7 @@ fn to_str(&t v) -> str {
// FIXME: can we just use structural equality on to_vec? // FIXME: can we just use structural equality on to_vec?
fn eq_vec(&t v0, &vec[uint] v1) -> bool { fn eq_vec(&t v0, &vec[uint] v1) -> bool {
assert (v0.nbits == _vec.len[uint](v1)); check (v0.nbits == _vec.len[uint](v1));
auto len = v0.nbits; auto len = v0.nbits;
auto i = 0u; auto i = 0u;
while (i < len) { while (i < len) {

2
src/lib/deque.rs
View file

@ -28,7 +28,7 @@ fn create[T]() -> t[T] {
* elsewhere. * elsewhere.
*/ */
fn grow[T](uint nelts, uint lo, vec[cell[T]] elts) -> vec[cell[T]] { fn grow[T](uint nelts, uint lo, vec[cell[T]] elts) -> vec[cell[T]] {
assert (nelts == _vec.len[cell[T]](elts)); check (nelts == _vec.len[cell[T]](elts));
fn fill[T](uint i, uint nelts, uint lo, fn fill[T](uint i, uint nelts, uint lo,
vec[cell[T]] old) -> cell[T] { vec[cell[T]] old) -> cell[T] {

2
src/lib/ebml.rs
View file

@ -99,7 +99,7 @@ fn doc_data(doc d) -> vec[u8] {
fn be_uint_from_bytes(vec[u8] data, uint start, uint size) -> uint { fn be_uint_from_bytes(vec[u8] data, uint start, uint size) -> uint {
auto sz = size; auto sz = size;
assert (sz <= 4u); check (sz <= 4u);
auto val = 0u; auto val = 0u;
auto pos = start; auto pos = start;
while (sz > 0u) { while (sz > 0u) {

2
src/lib/fs.rs
View file

@ -10,7 +10,7 @@ type path = str;
fn dirname(path p) -> path { fn dirname(path p) -> path {
auto sep = path_sep(); auto sep = path_sep();
assert (_str.byte_len(sep) == 1u); check (_str.byte_len(sep) == 1u);
let int i = _str.rindex(p, sep.(0)); let int i = _str.rindex(p, sep.(0));
if (i == -1) { if (i == -1) {
ret p; ret p;

10
src/lib/io.rs
View file

@ -72,7 +72,7 @@ state obj FILE_buf_reader(os.libc.FILE f, bool must_close) {
ret os.libc.feof(f) != 0; ret os.libc.feof(f) != 0;
} }
fn seek(int offset, seek_style whence) { fn seek(int offset, seek_style whence) {
assert (os.libc.fseek(f, offset, convert_whence(whence)) == 0); check (os.libc.fseek(f, offset, convert_whence(whence)) == 0);
} }
fn tell() -> uint { fn tell() -> uint {
ret os.libc.ftell(f) as uint; ret os.libc.ftell(f) as uint;
@ -101,14 +101,14 @@ state obj new_reader(buf_reader rdr) {
if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid? if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid?
auto b0 = c0 as u8; auto b0 = c0 as u8;
auto w = _str.utf8_char_width(b0); auto w = _str.utf8_char_width(b0);
assert (w > 0u); check(w > 0u);
if (w == 1u) {ret b0 as char;} if (w == 1u) {ret b0 as char;}
auto val = 0u; auto val = 0u;
while (w > 1u) { while (w > 1u) {
w -= 1u; w -= 1u;
auto next = rdr.read_byte(); auto next = rdr.read_byte();
assert (next > -1); check(next > -1);
assert (next & 0xc0 == 0x80); check(next & 0xc0 == 0x80);
val <<= 6u; val <<= 6u;
val += (next & 0x3f) as uint; val += (next & 0x3f) as uint;
} }
@ -279,7 +279,7 @@ state obj FILE_writer(os.libc.FILE f, bool must_close) {
} }
fn seek(int offset, seek_style whence) { fn seek(int offset, seek_style whence) {
assert (os.libc.fseek(f, offset, convert_whence(whence)) == 0); check(os.libc.fseek(f, offset, convert_whence(whence)) == 0);
} }
fn tell() -> uint { fn tell() -> uint {

4
src/lib/linux_os.rs
View file

@ -66,7 +66,7 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) { fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0); let vec[mutable int] fds = vec(mutable 0, 0);
assert (os.libc.pipe(_vec.buf[mutable int](fds)) == 0); check(os.libc.pipe(_vec.buf[mutable int](fds)) == 0);
ret tup(fds.(0), fds.(1)); ret tup(fds.(0), fds.(1));
} }
@ -76,7 +76,7 @@ fn fd_FILE(int fd) -> libc.FILE {
fn waitpid(int pid) -> int { fn waitpid(int pid) -> int {
let vec[mutable int] status = vec(mutable 0); let vec[mutable int] status = vec(mutable 0);
assert (os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1); check(os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1);
ret status.(0); ret status.(0);
} }

4
src/lib/macos_os.rs
View file

@ -63,7 +63,7 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) { fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0); let vec[mutable int] fds = vec(mutable 0, 0);
assert (os.libc.pipe(_vec.buf[mutable int](fds)) == 0); check(os.libc.pipe(_vec.buf[mutable int](fds)) == 0);
ret tup(fds.(0), fds.(1)); ret tup(fds.(0), fds.(1));
} }
@ -73,7 +73,7 @@ fn fd_FILE(int fd) -> libc.FILE {
fn waitpid(int pid) -> int { fn waitpid(int pid) -> int {
let vec[mutable int] status = vec(mutable 0); let vec[mutable int] status = vec(mutable 0);
assert (os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1); check(os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1);
ret status.(0); ret status.(0);
} }

2
src/lib/posix_fs.rs
View file

@ -5,7 +5,7 @@ native "rust" mod rustrt {
fn list_dir(str path) -> vec[str] { fn list_dir(str path) -> vec[str] {
// TODO ensure this is always closed // TODO ensure this is always closed
auto dir = os.libc.opendir(_str.buf(path)); auto dir = os.libc.opendir(_str.buf(path));
assert (dir as uint != 0u); check (dir as uint != 0u);
let vec[str] result = vec(); let vec[str] result = vec();
while (true) { while (true) {
auto ent = os.libc.readdir(dir); auto ent = os.libc.readdir(dir);

8
src/lib/sha1.rs
View file

@ -43,7 +43,7 @@ fn mk_sha1() -> sha1 {
fn add_input(&sha1state st, &vec[u8] msg) { fn add_input(&sha1state st, &vec[u8] msg) {
// FIXME: Should be typestate precondition // FIXME: Should be typestate precondition
assert (!st.computed); check (!st.computed);
for (u8 element in msg) { for (u8 element in msg) {
st.msg_block.(st.msg_block_idx) = element; st.msg_block.(st.msg_block_idx) = element;
@ -67,7 +67,7 @@ fn mk_sha1() -> sha1 {
fn process_msg_block(&sha1state st) { fn process_msg_block(&sha1state st) {
// FIXME: Make precondition // FIXME: Make precondition
assert (_vec.len[mutable u32](st.h) == digest_buf_len); check (_vec.len[mutable u32](st.h) == digest_buf_len);
// Constants // Constants
auto k = vec(0x5A827999u32, auto k = vec(0x5A827999u32,
@ -192,7 +192,7 @@ fn mk_sha1() -> sha1 {
*/ */
fn pad_msg(&sha1state st) { fn pad_msg(&sha1state st) {
// FIXME: Should be a precondition // FIXME: Should be a precondition
assert (_vec.len[mutable u8](st.msg_block) == msg_block_len); check (_vec.len[mutable u8](st.msg_block) == msg_block_len);
/* /*
* Check to see if the current message block is too small to hold * Check to see if the current message block is too small to hold
@ -236,7 +236,7 @@ fn mk_sha1() -> sha1 {
fn reset() { fn reset() {
// FIXME: Should be typestate precondition // FIXME: Should be typestate precondition
assert (_vec.len[mutable u32](st.h) == digest_buf_len); check (_vec.len[mutable u32](st.h) == digest_buf_len);
st.len_low = 0u32; st.len_low = 0u32;
st.len_high = 0u32; st.len_high = 0u32;

2
src/lib/win32_os.rs
View file

@ -53,7 +53,7 @@ fn dylib_filename(str base) -> str {
fn pipe() -> tup(int, int) { fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0); let vec[mutable int] fds = vec(mutable 0, 0);
assert (os.libc._pipe(_vec.buf[mutable int](fds), 1024u, check(os.libc._pipe(_vec.buf[mutable int](fds), 1024u,
libc_constants.O_BINARY()) == 0); libc_constants.O_BINARY()) == 0);
ret tup(fds.(0), fds.(1)); ret tup(fds.(0), fds.(1));
} }

2
src/test/run-fail/fail.rs
View file

@ -2,5 +2,5 @@
// error-pattern:1 == 2 // error-pattern:1 == 2
fn main() { fn main() {
assert (1 == 2); check (1 == 2);
} }

2
src/test/run-fail/linked-failure.rs
View file

@ -4,7 +4,7 @@
// error-pattern:1 == 2 // error-pattern:1 == 2
fn child() { fn child() {
assert (1 == 2); check (1 == 2);
} }
fn main() { fn main() {

4
src/test/run-fail/str-overrun.rs
View file

@ -6,12 +6,12 @@
fn main() { fn main() {
let str s = "hello"; let str s = "hello";
let int x = 0; let int x = 0;
assert (s.(x) == (0x68 as u8)); check (s.(x) == (0x68 as u8));
// NB: at the moment a string always has a trailing NULL, // NB: at the moment a string always has a trailing NULL,
// so the largest index value on the string above is 5, not // so the largest index value on the string above is 5, not
// 4. Possibly change this. // 4. Possibly change this.
// Bounds-check failure. // Bounds-check failure.
assert (s.(x + 6) == (0x0 as u8)); check (s.(x + 6) == (0x0 as u8));
} }

4
src/test/run-fail/vec-overrun.rs
View file

@ -6,7 +6,7 @@
fn main() { fn main() {
let vec[int] v = vec(10); let vec[int] v = vec(10);
let int x = 0; let int x = 0;
assert (v.(x) == 10); check (v.(x) == 10);
// Bounds-check failure. // Bounds-check failure.
assert (v.(x + 2) == 20); check (v.(x + 2) == 20);
} }

4
src/test/run-fail/vec-underrun.rs
View file

@ -6,7 +6,7 @@
fn main() { fn main() {
let vec[int] v = vec(10, 20); let vec[int] v = vec(10, 20);
let int x = 0; let int x = 0;
assert (v.(x) == 10); check (v.(x) == 10);
// Bounds-check failure. // Bounds-check failure.
assert (v.(x-1) == 20); check (v.(x-1) == 20);
} }

4
src/test/run-pass/alt-pattern-drop.rs
View file

@ -21,12 +21,12 @@ fn foo(str s) {
} }
log _str.refcount(s); log _str.refcount(s);
assert (_str.refcount(s) == const_refcount); check (_str.refcount(s) == const_refcount);
} }
fn main() { fn main() {
let str s = "hi"; // ref up let str s = "hi"; // ref up
foo(s); // ref up then down foo(s); // ref up then down
log _str.refcount(s); log _str.refcount(s);
assert (_str.refcount(s) == const_refcount); check (_str.refcount(s) == const_refcount);
} }

4
src/test/run-pass/alt-pattern-lit.rs
View file

@ -12,6 +12,6 @@ fn altlit(int f) -> int {
} }
fn main() { fn main() {
assert (altlit(10) == 20); check (altlit(10) == 20);
assert (altlit(11) == 22); check (altlit(11) == 22);
} }

6
src/test/run-pass/alt-tag.rs
View file

@ -32,8 +32,8 @@ fn main() {
let color gray = rgb(127, 127, 127); let color gray = rgb(127, 127, 127);
let color clear = rgba(50, 150, 250, 0); let color clear = rgba(50, 150, 250, 0);
let color red = hsl(0, 255, 255); let color red = hsl(0, 255, 255);
assert (process(gray) == 127); check (process(gray) == 127);
assert (process(clear) == 0); check (process(clear) == 0);
assert (process(red) == 255); check (process(red) == 255);
} }

2
src/test/run-pass/arith-0.rs
View file

@ -1,5 +1,5 @@
fn main() -> () { fn main() -> () {
let int a = 10; let int a = 10;
log a; log a;
assert (a * (a - 1) == 90); check (a * (a - 1) == 90);
} }

32
src/test/run-pass/arith-1.rs
View file

@ -1,22 +1,22 @@
fn main() -> () { fn main() -> () {
let int i32_a = 10; let int i32_a = 10;
assert (i32_a == 10); check(i32_a == 10);
assert (i32_a - 10 == 0); check(i32_a - 10 == 0);
assert (i32_a / 10 == 1); check(i32_a / 10 == 1);
assert (i32_a - 20 == -10); check(i32_a - 20 == -10);
assert (i32_a << 10 == 10240); check(i32_a << 10 == 10240);
assert (i32_a << 16 == 655360); check(i32_a << 16 == 655360);
assert (i32_a * 16 == 160); check(i32_a * 16 == 160);
assert (i32_a * i32_a * i32_a == 1000); check(i32_a * i32_a * i32_a == 1000);
assert (i32_a * i32_a * i32_a * i32_a == 10000); check(i32_a * i32_a * i32_a * i32_a == 10000);
assert (((i32_a * i32_a) / i32_a) * i32_a == 100); check(((i32_a * i32_a) / i32_a) * i32_a == 100);
assert (i32_a * (i32_a - 1) << 2 + i32_a == 368640); check(i32_a * (i32_a - 1) << 2 + i32_a == 368640);
let int i32_b = 0x10101010; let int i32_b = 0x10101010;
assert (i32_b + 1 - 1 == i32_b); check(i32_b + 1 - 1 == i32_b);
assert (i32_b << 1 == i32_b << 1); check(i32_b << 1 == i32_b << 1);
assert (i32_b >> 1 == i32_b >> 1); check(i32_b >> 1 == i32_b >> 1);
assert ((i32_b & (i32_b << 1)) == 0); check((i32_b & (i32_b << 1)) == 0);
log ((i32_b | (i32_b << 1))); log ((i32_b | (i32_b << 1)));
assert ((i32_b | (i32_b << 1)) == 0x30303030); check((i32_b | (i32_b << 1)) == 0x30303030);
} }

2
src/test/run-pass/arith-2.rs
View file

@ -1,5 +1,5 @@
fn main() -> () { fn main() -> () {
let int i32_c = 0x10101010; let int i32_c = 0x10101010;
assert (i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) == check (i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
i32_c + (((i32_c * 2) / 3) * 2) + (i32_c - (7 % 3))); i32_c + (((i32_c * 2) / 3) * 2) + (i32_c - (7 % 3)));
} }

36
src/test/run-pass/arith-unsigned.rs
View file

@ -2,24 +2,24 @@
// Unsigned integer operations // Unsigned integer operations
fn main() { fn main() {
assert (0u8 < 255u8); check (0u8 < 255u8);
assert (0u8 <= 255u8); check (0u8 <= 255u8);
assert (255u8 > 0u8); check (255u8 > 0u8);
assert (255u8 >= 0u8); check (255u8 >= 0u8);
assert (250u8 / 10u8 == 25u8); check (250u8 / 10u8 == 25u8);
assert (255u8 % 10u8 == 5u8); check (255u8 % 10u8 == 5u8);
assert (0u16 < 60000u16); check (0u16 < 60000u16);
assert (0u16 <= 60000u16); check (0u16 <= 60000u16);
assert (60000u16 > 0u16); check (60000u16 > 0u16);
assert (60000u16 >= 0u16); check (60000u16 >= 0u16);
assert (60000u16 / 10u16 == 6000u16); check (60000u16 / 10u16 == 6000u16);
assert (60005u16 % 10u16 == 5u16); check (60005u16 % 10u16 == 5u16);
assert (0u32 < 4000000000u32); check (0u32 < 4000000000u32);
assert (0u32 <= 4000000000u32); check (0u32 <= 4000000000u32);
assert (4000000000u32 > 0u32); check (4000000000u32 > 0u32);
assert (4000000000u32 >= 0u32); check (4000000000u32 >= 0u32);
assert (4000000000u32 / 10u32 == 400000000u32); check (4000000000u32 / 10u32 == 400000000u32);
assert (4000000005u32 % 10u32 == 5u32); check (4000000005u32 % 10u32 == 5u32);
// 64-bit numbers have some flakiness yet. Not tested // 64-bit numbers have some flakiness yet. Not tested
} }

4
src/test/run-pass/autoderef-full-lval.rs
View file

@ -8,11 +8,11 @@ fn main() {
let clam b = rec(x=@10, y=@20); let clam b = rec(x=@10, y=@20);
let int z = a.x + b.y; let int z = a.x + b.y;
log z; log z;
assert (z == 21); check (z == 21);
let fish forty = tup(@40); let fish forty = tup(@40);
let fish two = tup(@2); let fish two = tup(@2);
let int answer = forty._0 + two._0; let int answer = forty._0 + two._0;
log answer; log answer;
assert (answer == 42); check (answer == 42);
} }

2
src/test/run-pass/bind-exterior.rs
View file

@ -4,5 +4,5 @@ fn foo(@int a, @int b) -> int {
fn main() { fn main() {
auto f1 = bind foo(@10, @12); auto f1 = bind foo(@10, @12);
assert (f1() == 22); check(f1() == 22);
} }

2
src/test/run-pass/bind-interior.rs
View file

@ -7,5 +7,5 @@ fn f(int n) -> int {
fn main() { fn main() {
let fn() -> int g = bind f(10); let fn() -> int g = bind f(10);
let int i = g(); let int i = g();
assert (i == 10); check(i == 10);
} }

6
src/test/run-pass/bind-obj-ctor.rs
View file

@ -11,7 +11,7 @@ fn main() {
auto ctor1 = bind simple(_, 2); auto ctor1 = bind simple(_, 2);
auto obj1 = ctor0(2); auto obj1 = ctor0(2);
auto obj2 = ctor1(1); auto obj2 = ctor1(1);
assert (obj0.sum() == 3); check (obj0.sum() == 3);
assert (obj1.sum() == 3); check (obj1.sum() == 3);
assert (obj2.sum() == 3); check (obj2.sum() == 3);
} }

2
src/test/run-pass/bind-thunk.rs
View file

@ -7,5 +7,5 @@ fn f() -> int {
fn main() { fn main() {
let fn() -> int g = bind f(); let fn() -> int g = bind f();
let int i = g(); let int i = g();
assert (i == 42); check(i == 42);
} }

2
src/test/run-pass/bind-trivial.rs
View file

@ -7,5 +7,5 @@ fn f(int n) -> int {
fn main() { fn main() {
let fn(int) -> int g = bind f(_); let fn(int) -> int g = bind f(_);
let int i = g(42); let int i = g(42);
assert (i == 42); check(i == 42);
} }

16
src/test/run-pass/bitwise.rs
View file

@ -8,14 +8,14 @@ fn main() {
a = a ^ b; a = a ^ b;
log a; log a;
log b; log b;
assert (b == 1); check (b == 1);
assert (a == 2); check (a == 2);
assert (~(0xf0) & 0xff == 0xf); check (~(0xf0) & 0xff == 0xf);
assert (0xf0 | 0xf == 0xff); check (0xf0 | 0xf == 0xff);
assert (0xf << 4 == 0xf0); check (0xf << 4 == 0xf0);
assert (0xf0 >> 4 == 0xf); check (0xf0 >> 4 == 0xf);
assert (-16 >>> 2 == -4); check (-16 >>> 2 == -4);
assert (0b1010_1010 | 0b0101_0101 == 0xff); check (0b1010_1010 | 0b0101_0101 == 0xff);
} }

8
src/test/run-pass/bool-not.rs
View file

@ -2,14 +2,14 @@
fn main() { fn main() {
if (!false) { if (!false) {
assert (true); check (true);
} else { } else {
assert (false); check (false);
} }
if (!true) { if (!true) {
assert (false); check (false);
} else { } else {
assert (true); check (true);
} }
} }

6
src/test/run-pass/box-compare.rs
View file

@ -1,6 +1,6 @@
// xfail-boot // xfail-boot
fn main() { fn main() {
assert (@1 < @3); check (@1 < @3);
assert (@@"hello " > @@"hello"); check (@@"hello " > @@"hello");
assert (@@@"hello" != @@@"there"); check (@@@"hello" != @@@"there");
} }

2
src/test/run-pass/box-unbox.rs
View file

@ -6,5 +6,5 @@ fn main() {
let int foo = 17; let int foo = 17;
let box[int] bfoo = tup(@foo); let box[int] bfoo = tup(@foo);
log "see what's in our box"; log "see what's in our box";
assert (unbox[int](bfoo) == foo); check (unbox[int](bfoo) == foo);
} }

2
src/test/run-pass/box.rs
View file

@ -1,4 +1,4 @@
fn main() { fn main() {
let @int x = @10; let @int x = @10;
assert ((*x) == 10); check ((*x) == 10);
} }

12
src/test/run-pass/break.rs
View file

@ -6,35 +6,35 @@ fn main() {
i += 1; i += 1;
if (i == 10) { break; } if (i == 10) { break; }
} }
assert (i == 10); check(i == 10);
do { do {
i += 1; i += 1;
if (i == 20) { break; } if (i == 20) { break; }
} while (i < 30); } while (i < 30);
assert (i == 20); check(i == 20);
for (int x in vec(1, 2, 3, 4, 5, 6)) { for (int x in vec(1, 2, 3, 4, 5, 6)) {
if (x == 3) { break; } if (x == 3) { break; }
assert (x <= 3); check(x <= 3);
} }
i = 0; i = 0;
while (i < 10) { while (i < 10) {
i += 1; i += 1;
if (i % 2 == 0) { cont; } if (i % 2 == 0) { cont; }
assert (i % 2 != 0); check(i % 2 != 0);
} }
i = 0; i = 0;
do { do {
i += 1; i += 1;
if (i % 2 == 0) { cont; } if (i % 2 == 0) { cont; }
assert (i % 2 != 0); check(i % 2 != 0);
} while (i < 10); } while (i < 10);
for (int x in vec(1, 2, 3, 4, 5, 6)) { for (int x in vec(1, 2, 3, 4, 5, 6)) {
if (x % 2 == 0) { cont; } if (x % 2 == 0) { cont; }
assert (x % 2 != 0); check(x % 2 != 0);
} }
} }

16
src/test/run-pass/cast.rs
View file

@ -3,14 +3,14 @@
fn main() { fn main() {
let int i = 'Q' as int; let int i = 'Q' as int;
assert (i == 0x51); check (i == 0x51);
let u32 u = i as u32; let u32 u = i as u32;
assert (u == (0x51 as u32)); check (u == (0x51 as u32));
assert (u == ('Q' as u32)); check (u == ('Q' as u32));
assert ((i as u8) == ('Q' as u8)); check ((i as u8) == ('Q' as u8));
assert (((i as u8) as i8) == (('Q' as u8) as i8)); check (((i as u8) as i8) == (('Q' as u8) as i8));
assert ((0x51 as char) == 'Q'); check ((0x51 as char) == 'Q');
assert (true == (1 as bool)); check (true == (1 as bool));
assert ((0 as u32) == (false as u32)); check ((0 as u32) == (false as u32));
} }

14
src/test/run-pass/char.rs
View file

@ -1,12 +1,12 @@
fn main() { fn main() {
let char c = 'x'; let char c = 'x';
let char d = 'x'; let char d = 'x';
assert (c == 'x'); check(c == 'x');
assert ('x' == c); check('x' == c);
assert (c == c); check(c == c);
assert (c == d); check(c == d);
assert (d == c); check(d == c);
assert (d == 'x'); check (d == 'x');
assert ('x' == d); check('x' == d);
} }

4
src/test/run-pass/clone-with-exterior.rs
View file

@ -1,8 +1,8 @@
// xfail-boot // xfail-boot
// xfail-stage0 // xfail-stage0
fn f(@rec(int a, int b) x) { fn f(@rec(int a, int b) x) {
assert (x.a == 10); check (x.a == 10);
assert (x.b == 12); check (x.b == 12);
} }
fn main() { fn main() {

2
src/test/run-pass/comm.rs
View file

@ -8,7 +8,7 @@ fn main() {
y <- p; y <- p;
log "received"; log "received";
log y; log y;
assert (y == 10); check (y == 10);
} }
fn child(chan[int] c) { fn child(chan[int] c) {

4
src/test/run-pass/decl-with-recv.rs
View file

@ -6,9 +6,9 @@ fn main() {
ch <| 10; ch <| 10;
let int i <- po; let int i <- po;
assert (i == 10); check (i == 10);
ch <| 11; ch <| 11;
auto j <- po; auto j <- po;
assert (j == 11); check (j == 11);
} }

2
src/test/run-pass/deep.rs
View file

@ -10,5 +10,5 @@ fn f(int x) -> int {
} }
fn main() { fn main() {
assert (f(5000) == 5000); check (f(5000) == 5000);
} }

20
src/test/run-pass/div-mod.rs
View file

@ -3,15 +3,15 @@
fn main() { fn main() {
let int x = 15; let int x = 15;
let int y = 5; let int y = 5;
assert (x / 5 == 3); check(x / 5 == 3);
assert (x / 4 == 3); check(x / 4 == 3);
assert (x / 3 == 5); check(x / 3 == 5);
assert (x / y == 3); check(x / y == 3);
assert (15 / y == 3); check(15 / y == 3);
assert (x % 5 == 0); check(x % 5 == 0);
assert (x % 4 == 3); check(x % 4 == 3);
assert (x % 3 == 0); check(x % 3 == 0);
assert (x % y == 0); check(x % y == 0);
assert (15 % y == 0); check(15 % y == 0);
} }

26
src/test/run-pass/else-if.rs
View file

@ -1,42 +1,42 @@
fn main() { fn main() {
if (1 == 2) { if (1 == 2) {
assert (false); check(false);
} else if (2 == 3) { } else if (2 == 3) {
assert (false); check(false);
} else if (3 == 4) { } else if (3 == 4) {
assert (false); check(false);
} else { } else {
assert (true); check(true);
} }
if (1 == 2) { if (1 == 2) {
assert (false); check(false);
} else if (2 == 2) { } else if (2 == 2) {
assert (true); check(true);
} }
if (1 == 2) { if (1 == 2) {
assert (false); check(false);
} else if (2 == 2) { } else if (2 == 2) {
if (1 == 1) { if (1 == 1) {
assert (true); check(true);
} else { } else {
if (2 == 1) { if (2 == 1) {
assert (false); check(false);
} else { } else {
assert (false); check(false);
} }
} }
} }
if (1 == 2) { if (1 == 2) {
assert (false); check(false);
} else { } else {
if (1 == 2) { if (1 == 2) {
assert (false); check(false);
} else { } else {
assert (true); check(true);
} }
} }
} }

4
src/test/run-pass/expr-alt-box.rs
View file

@ -9,7 +9,7 @@ fn test_box() {
@100 @100
} }
}; };
assert (*res == 100); check (*res == 100);
} }
fn test_str() { fn test_str() {
@ -18,7 +18,7 @@ fn test_str() {
"happy" "happy"
} }
}; };
assert (res == "happy"); check (res == "happy");
} }
fn main() { fn main() {

2
src/test/run-pass/expr-alt-generic-box1.rs
View file

@ -9,7 +9,7 @@ fn test_generic[T](@T expected, &compare[T] eq) {
expected expected
} }
}; };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_box() { fn test_box() {

2
src/test/run-pass/expr-alt-generic-box2.rs
View file

@ -9,7 +9,7 @@ fn test_generic[T](&T expected, &compare[T] eq) {
expected expected
} }
}; };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_vec() { fn test_vec() {

2
src/test/run-pass/expr-alt-generic.rs
View file

@ -9,7 +9,7 @@ fn test_generic[T](&T expected, &compare[T] eq) {
expected expected
} }
}; };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_bool() { fn test_bool() {

4
src/test/run-pass/expr-alt-struct.rs
View file

@ -9,7 +9,7 @@ fn test_rec() {
rec(i = 100) rec(i = 100)
} }
}; };
assert (res == rec(i = 100)); check (res == rec(i = 100));
} }
fn test_tag() { fn test_tag() {
@ -26,7 +26,7 @@ fn test_tag() {
sad sad
} }
}; };
assert (res == happy); check (res == happy);
} }
fn main() { fn main() {

10
src/test/run-pass/expr-alt.rs
View file

@ -12,7 +12,7 @@ fn test_basic() {
false false
} }
}; };
assert (res); check (res);
res = alt(false) { res = alt(false) {
case (true) { case (true) {
@ -22,7 +22,7 @@ fn test_basic() {
true true
} }
}; };
assert (res); check (res);
} }
fn test_inferrence() { fn test_inferrence() {
@ -34,7 +34,7 @@ fn test_inferrence() {
false false
} }
}; };
assert (res); check (res);
} }
fn test_alt_as_alt_head() { fn test_alt_as_alt_head() {
@ -47,7 +47,7 @@ fn test_alt_as_alt_head() {
true true
} }
}; };
assert (res); check (res);
} }
fn test_alt_as_block_result() { fn test_alt_as_block_result() {
@ -66,7 +66,7 @@ fn test_alt_as_block_result() {
} }
} }
}; };
assert (res); check (res);
} }
fn main() { fn main() {

2
src/test/run-pass/expr-block-box.rs
View file

@ -6,5 +6,5 @@ fn main() {
@100 @100
}; };
assert (*x == 100); check (*x == 100);
} }

2
src/test/run-pass/expr-block-fn.rs
View file

@ -6,7 +6,7 @@ fn test_fn() {
ret 10; ret 10;
} }
let t res = { ten }; let t res = { ten };
assert (res() == 10); check (res() == 10);
} }
fn main() { fn main() {

2
src/test/run-pass/expr-block-generic-box1.rs
View file

@ -5,7 +5,7 @@ type compare[T] = fn(@T t1, @T t2) -> bool;
fn test_generic[T](@T expected, &compare[T] eq) { fn test_generic[T](@T expected, &compare[T] eq) {
let @T actual = { expected }; let @T actual = { expected };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_box() { fn test_box() {

2
src/test/run-pass/expr-block-generic-box2.rs
View file

@ -5,7 +5,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
fn test_generic[T](&T expected, &compare[T] eq) { fn test_generic[T](&T expected, &compare[T] eq) {
let T actual = { expected }; let T actual = { expected };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_vec() { fn test_vec() {

2
src/test/run-pass/expr-block-generic.rs
View file

@ -7,7 +7,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
fn test_generic[T](&T expected, &compare[T] eq) { fn test_generic[T](&T expected, &compare[T] eq) {
let T actual = { expected }; let T actual = { expected };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_bool() { fn test_bool() {

6
src/test/run-pass/expr-block.rs
View file

@ -5,12 +5,12 @@
fn test_basic() { fn test_basic() {
let bool res = { true }; let bool res = { true };
assert (res); check (res);
} }
fn test_rec() { fn test_rec() {
auto res = { rec(v1 = 10, v2 = 20) }; auto res = { rec(v1 = 10, v2 = 20) };
assert (res.v2 == 20); check (res.v2 == 20);
} }
fn test_filled_with_stuff() { fn test_filled_with_stuff() {
@ -21,7 +21,7 @@ fn test_filled_with_stuff() {
} }
a a
}; };
assert (res == 10); check (res == 10);
} }
fn main() { fn main() {

4
src/test/run-pass/expr-if-box.rs
View file

@ -5,12 +5,12 @@
fn test_box() { fn test_box() {
auto res = if (true) { @100 } else { @101 }; auto res = if (true) { @100 } else { @101 };
assert (*res == 100); check (*res == 100);
} }
fn test_str() { fn test_str() {
auto res = if (true) { "happy" } else { "sad" }; auto res = if (true) { "happy" } else { "sad" };
assert (res == "happy"); check (res == "happy");
} }
fn main() { fn main() {

2
src/test/run-pass/expr-if-generic-box1.rs
View file

@ -5,7 +5,7 @@ type compare[T] = fn(@T t1, @T t2) -> bool;
fn test_generic[T](@T expected, @T not_expected, &compare[T] eq) { fn test_generic[T](@T expected, @T not_expected, &compare[T] eq) {
let @T actual = if (true) { expected } else { not_expected }; let @T actual = if (true) { expected } else { not_expected };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_box() { fn test_box() {

2
src/test/run-pass/expr-if-generic-box2.rs
View file

@ -5,7 +5,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) { fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) {
let T actual = if (true) { expected } else { not_expected }; let T actual = if (true) { expected } else { not_expected };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_vec() { fn test_vec() {

2
src/test/run-pass/expr-if-generic.rs
View file

@ -7,7 +7,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) { fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) {
let T actual = if (true) { expected } else { not_expected }; let T actual = if (true) { expected } else { not_expected };
assert (eq(expected, actual)); check (eq(expected, actual));
} }
fn test_bool() { fn test_bool() {

4
src/test/run-pass/expr-if-struct.rs
View file

@ -5,7 +5,7 @@
fn test_rec() { fn test_rec() {
auto res = if (true) { rec(i = 100) } else { rec(i = 101) }; auto res = if (true) { rec(i = 100) } else { rec(i = 101) };
assert (res == rec(i = 100)); check (res == rec(i = 100));
} }
fn test_tag() { fn test_tag() {
@ -15,7 +15,7 @@ fn test_tag() {
} }
auto res = if (true) { happy } else { sad }; auto res = if (true) { happy } else { sad };
assert (res == happy); check (res == happy);
} }
fn main() { fn main() {

18
src/test/run-pass/expr-if.rs
View file

@ -5,12 +5,12 @@
fn test_if() { fn test_if() {
let bool res = if (true) { true } else { false }; let bool res = if (true) { true } else { false };
assert (res); check (res);
} }
fn test_else() { fn test_else() {
let bool res = if (false) { false } else { true }; let bool res = if (false) { false } else { true };
assert (res); check (res);
} }
fn test_elseif1() { fn test_elseif1() {
@ -21,7 +21,7 @@ fn test_elseif1() {
} else { } else {
false false
}; };
assert (res); check (res);
} }
fn test_elseif2() { fn test_elseif2() {
@ -32,7 +32,7 @@ fn test_elseif2() {
} else { } else {
false false
}; };
assert (res); check (res);
} }
fn test_elseif3() { fn test_elseif3() {
@ -43,12 +43,12 @@ fn test_elseif3() {
} else { } else {
true true
}; };
assert (res); check (res);
} }
fn test_inferrence() { fn test_inferrence() {
auto res = if (true) { true } else { false }; auto res = if (true) { true } else { false };
assert (res); check (res);
} }
fn test_if_as_if_condition() { fn test_if_as_if_condition() {
@ -57,14 +57,14 @@ fn test_if_as_if_condition() {
} else { } else {
false false
}; };
assert (res1); check (res1);
auto res2 = if (if (true) { false } else { true }) { auto res2 = if (if (true) { false } else { true }) {
false false
} else { } else {
true true
}; };
assert (res2); check (res2);
} }
fn test_if_as_block_result() { fn test_if_as_block_result() {
@ -77,7 +77,7 @@ fn test_if_as_block_result() {
} else { } else {
false false
}; };
assert (res); check (res);
} }
fn main() { fn main() {

10
src/test/run-pass/exterior.rs
View file

@ -3,16 +3,16 @@
type point = rec(int x, int y, mutable int z); type point = rec(int x, int y, mutable int z);
fn f(@point p) { fn f(@point p) {
assert (p.z == 12); check (p.z == 12);
p.z = 13; p.z = 13;
assert (p.z == 13); check (p.z == 13);
} }
fn main() { fn main() {
let point a = rec(x=10, y=11, mutable z=12); let point a = rec(x=10, y=11, mutable z=12);
let @point b = @a; let @point b = @a;
assert (b.z == 12); check (b.z == 12);
f(b); f(b);
assert (a.z == 12); check (a.z == 12);
assert (b.z == 13); check (b.z == 13);
} }

2
src/test/run-pass/fact.rs
View file

@ -15,7 +15,7 @@ fn f(int x) -> int {
} }
} }
fn main () { fn main () {
assert (f(5) == 120); check (f(5) == 120);
// log "all done"; // log "all done";
} }

18
src/test/run-pass/float2.rs
View file

@ -12,13 +12,13 @@ fn main() {
auto j = 3.1e+9; auto j = 3.1e+9;
auto k = 3.2e-10; auto k = 3.2e-10;
assert (a == b); check(a == b);
assert (c < b); check(c < b);
assert (c == d); check(c == d);
assert (e < g); check(e < g);
assert (f < h); check(f < h);
assert (g == 1000000.0f32); check(g == 1000000.0f32);
assert (h == i); check(h == i);
assert (j > k); check(j > k);
assert (k < a); check(k < a);
} }

8
src/test/run-pass/floatlits.rs
View file

@ -1,9 +1,9 @@
// xfail-boot // xfail-boot
fn main() { fn main() {
auto f = 4.999999999999; auto f = 4.999999999999;
assert (f > 4.90); check (f > 4.90);
assert (f < 5.0); check (f < 5.0);
auto g = 4.90000000001e-10; auto g = 4.90000000001e-10;
assert (g > 5e-11); check(g > 5e-11);
assert (g < 5e-9); check(g < 5e-9);
} }

16
src/test/run-pass/foreach-nested-2.rs
View file

@ -28,12 +28,12 @@ fn main() {
} }
} }
assert (a.(0) == 0); check (a.(0) == 0);
assert (a.(1) == 1); check (a.(1) == 1);
assert (a.(2) == 10); check (a.(2) == 10);
assert (a.(3) == 11); check (a.(3) == 11);
assert (a.(4) == 100); check (a.(4) == 100);
assert (a.(5) == 101); check (a.(5) == 101);
assert (a.(6) == 110); check (a.(6) == 110);
assert (a.(7) == 111); check (a.(7) == 111);
} }

8
src/test/run-pass/foreach-nested.rs
View file

@ -16,8 +16,8 @@ fn main() {
} }
} }
assert (a.(0) == 0); check (a.(0) == 0);
assert (a.(1) == 1); check (a.(1) == 1);
assert (a.(2) == 10); check (a.(2) == 10);
assert (a.(3) == 11); check (a.(3) == 11);
} }

4
src/test/run-pass/foreach-put-structured.rs
View file

@ -14,9 +14,9 @@ fn main() {
for each (tup(int,int) p in pairs()) { for each (tup(int,int) p in pairs()) {
log p._0; log p._0;
log p._1; log p._1;
assert (p._0 + 10 == i); check (p._0 + 10 == i);
i += 1; i += 1;
j = p._1; j = p._1;
} }
assert (j == 45); check(j == 45);
} }

2
src/test/run-pass/foreach-simple-outer-slot.rs
View file

@ -9,7 +9,7 @@ fn main() {
} }
log "sum"; log "sum";
log sum; log sum;
assert (sum == 45); check (sum == 45);
} }
iter first_ten() -> int { iter first_ten() -> int {

4
src/test/run-pass/fun-call-variants.rs
View file

@ -13,7 +13,7 @@ fn main() {
let int a = direct(3); // direct let int a = direct(3); // direct
//let int b = ho(direct); // indirect unbound //let int b = ho(direct); // indirect unbound
let int c = ho(bind direct(_)); // indirect bound let int c = ho(bind direct(_)); // indirect bound
//assert (a == b); //check(a == b);
//assert (b == c); //check(b == c);
} }

2
src/test/run-pass/fun-indirect-call.rs
View file

@ -7,5 +7,5 @@ fn f() -> int {
fn main() { fn main() {
let fn() -> int g = f; let fn() -> int g = f;
let int i = g(); let int i = g();
assert (i == 42); check(i == 42);
} }

2
src/test/run-pass/generic-alias-box.rs
View file

@ -8,5 +8,5 @@ fn main() {
auto expected = @100; auto expected = @100;
auto actual = id[@int](expected); auto actual = id[@int](expected);
log *actual; log *actual;
assert (*expected == *actual); check (*expected == *actual);
} }

4
src/test/run-pass/generic-bind-2.rs
View file

@ -5,7 +5,7 @@ fn id[T](&T t) -> T {
fn main() { fn main() {
auto t = tup(1,2,3,4,5,6,7); auto t = tup(1,2,3,4,5,6,7);
assert (t._5 == 6); check (t._5 == 6);
auto f0 = bind id[tup(int,int,int,int,int,int,int)](t); auto f0 = bind id[tup(int,int,int,int,int,int,int)](t);
assert (f0()._5 == 6); check (f0()._5 == 6);
} }

4
src/test/run-pass/generic-bind.rs
View file

@ -4,7 +4,7 @@ fn id[T](&T t) -> T {
fn main() { fn main() {
auto t = tup(1,2,3,4,5,6,7); auto t = tup(1,2,3,4,5,6,7);
assert (t._5 == 6); check (t._5 == 6);
auto f1 = bind id[tup(int,int,int,int,int,int,int)](_); auto f1 = bind id[tup(int,int,int,int,int,int,int)](_);
assert (f1(t)._5 == 6); check (f1(t)._5 == 6);
} }

2
src/test/run-pass/generic-box.rs
View file

@ -4,5 +4,5 @@ fn box[T](&tup(T,T,T) x) -> @tup(T,T,T) {
fn main() { fn main() {
let @tup(int,int,int) x = box[int](tup(1,2,3)); let @tup(int,int,int) x = box[int](tup(1,2,3));
assert (x._1 == 2); check (x._1 == 2);
} }

4
src/test/run-pass/generic-derived-type.rs
View file

@ -12,6 +12,6 @@ fn main() {
auto b = f[int](10); auto b = f[int](10);
log b._0; log b._0;
log b._1; log b._1;
assert (b._0 == 10); check (b._0 == 10);
assert (b._1 == 10); check (b._1 == 10);
} }

4
src/test/run-pass/generic-exterior-box.rs
View file

@ -8,6 +8,6 @@ fn main() {
let int foo = 17; let int foo = 17;
let tupbox[int] tbfoo = tuplift[int](foo); let tupbox[int] tbfoo = tuplift[int](foo);
let recbox[int] rbfoo = reclift[int](foo); let recbox[int] rbfoo = reclift[int](foo);
assert (tbfoo._0 == foo); check (tbfoo._0 == foo);
assert (rbfoo.x == foo); check (rbfoo.x == foo);
} }

Some files were not shown because too many files have changed in this diff Show more