ret alt metas.name {
some(v) { v }
none. {
- let
- // FIXME: Remove this vec->ivec conversion.
-
- name =
+ // FIXME: Remove this vec->ivec conversion.
+ let name =
{
let os_vec =
str::split(fs::basename(output), '.' as u8);
// some default and generated configuration items
let default_cfg = default_configuration(sess, argv0, input);
let user_cfg = sess.get_opts().cfg;
- let
- // If the user wants a test runner, then add the test cfg
- gen_cfg =
+ // If the user wants a test runner, then add the test cfg
+ let gen_cfg =
{
if sess.get_opts().test && !attr::contains_name(user_cfg, "test")
{
// Pull the inner meta_items from the #[cfg(meta_item, ...)] attributes,
// so we can match against them. This is the list of configurations for
// which the item is valid
- let
-
- item_cfg_metas =
+ let item_cfg_metas =
{
fn extract_metas(inner_items: &(@ast::meta_item)[],
cfg_item: &@ast::meta_item) ->
fn is_terminated() -> bool {
ret *terminated;
- }drop
-
- {
+ }
+ drop {
llvm::LLVMDisposeBuilder(B);
- }
+ }
}
/* Memory-managed object interface to type handles. */
attr::require_unique_names(sess, metas);
- let
- // FIXME: Probably want a warning here since the user
- // is using the wrong type of meta item
- crate_name =
- {
- let name_items = attr::find_meta_items_by_name(metas, "name");
- alt ivec::last(name_items) {
- some(i) {
- alt attr::get_meta_item_value_str(i) {
- some(n) { n }
- _ { ident }
- }
- }
- none. { ident }
+ // FIXME: Probably want a warning here since the user
+ // is using the wrong type of meta item
+ let crate_name = {
+ let name_items = attr::find_meta_items_by_name(metas, "name");
+ alt ivec::last(name_items) {
+ some(i) {
+ alt attr::get_meta_item_value_str(i) {
+ some(n) { n }
+ _ { ident }
}
- };
+ }
+ none. { ident }
+ }
+ };
let nn = default_native_lib_naming(sess, sess.get_opts().static);
let x =
let item = lookup_item(did_.node, data);
let kind_ch = item_kind(item);
let did = {crate: cnum, node: did_.node};
- let
- // We treat references to tags as references to types.
- def =
+ // We treat references to tags as references to types.
+ let def =
alt kind_ch as char {
'c' { ast::def_const(did) }
'f' { ast::def_fn(did, ast::impure_fn) }
type ctx = {tcx: ty::ctxt, local_map: std::map::hashmap[node_id, local_info]};
fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
- let
- // Stores information about object fields and function
- // arguments that's otherwise not easily available.
- cx =
+ // Stores information about object fields and function
+ // arguments that's otherwise not easily available.
+ let cx =
@{tcx: tcx, local_map: std::map::new_int_hash()};
let v =
@{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _),
let e: env =
@{mutable refs: ~[], decls: decls, def_map: def_map, sess: sess};
- walker(visit::mk_simple_visitor(@{visit_local: bind walk_local(e, _),
- visit_pat: bind walk_pat(e, _),
- visit_expr: bind walk_expr(e, _),
- visit_fn: bind walk_fn(e, _, _, _, _, _)
- with
- *visit::default_simple_visitor()}));
+ walker(visit::mk_simple_visitor
+ (@{visit_local: bind walk_local(e, _),
+ visit_pat: bind walk_pat(e, _),
+ visit_expr: bind walk_expr(e, _),
+ visit_fn: bind walk_fn(e, _, _, _, _, _)
+ with *visit::default_simple_visitor()}));
// Calculate (refs - decls). This is the set of captured upvars.
// We build a vec of the node ids of the uses and a set of the
// size of; box_ptr is the type that's converted to a TypeRef and used as
// the pointer cast target in trans_raw_malloc.
- let
- // The mk_int here is the space being
- // reserved for the refcount.
- boxed_body =
+ // The mk_int here is the space being
+ // reserved for the refcount.
+ let boxed_body =
ty::mk_imm_tup(bcx_tcx(cx), ~[ty::mk_int(bcx_tcx(cx)), t]);
let box_ptr = ty::mk_imm_box(bcx_tcx(cx), t);
let sz = size_of(cx, boxed_body);
fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
// NB: v is an *alias* of type t here, not a direct value.
- let
- // FIXME: switch gc/non-gc on layer of the type.
- // FIXME: switch gc/non-gc on layer of the type.
- // TODO: call upcall_kill
+ // FIXME: switch gc/non-gc on layer of the type.
+ // FIXME: switch gc/non-gc on layer of the type.
+ // TODO: call upcall_kill
- // Call through the obj's own fields-drop glue first.
+ // Call through the obj's own fields-drop glue first.
- // Then free the body.
- // FIXME: switch gc/non-gc on layer of the type.
- // Call through the closure's own fields-drop glue first.
+ // Then free the body.
+ // FIXME: switch gc/non-gc on layer of the type.
+ // Call through the closure's own fields-drop glue first.
- // Then free the body.
- // FIXME: switch gc/non-gc on layer of the type.
- rs =
+ // Then free the body.
+ // FIXME: switch gc/non-gc on layer of the type.
+ let rs =
alt ty::struct(bcx_tcx(cx), t) {
ty::ty_str. { let v = cx.build.Load(v0); trans_non_gc_free(cx, v) }
ty::ty_vec(_) {
fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
// NB: v0 is an *alias* of type t here, not a direct value.
let ccx = bcx_ccx(cx);
- let
-
- rs =
+ let rs =
alt ty::struct(ccx.tcx, t) {
ty::ty_str. { decr_refcnt_maybe_free(cx, v0, v0, t) }
ty::ty_vec(_) { decr_refcnt_maybe_free(cx, v0, v0, t) }
// value here, but the dtor expects a type that still has opaque pointers
// for type variables.
let val_llty =
- lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType(llvm::LLVMTypeOf(dtor_addr))).(std::ivec::len(args));
+ lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType
+ (llvm::LLVMTypeOf(dtor_addr)))
+ .(std::ivec::len(args));
let val_cast = cx.build.BitCast(val.val, val_llty);
cx.build.FastCall(dtor_addr, args + ~[val_cast]);
maybe_on_heap_cx.build.PointerCast(vptr,
T_ptr(T_ivec_heap(llunitty)));
let heap_ptr_ptr =
- maybe_on_heap_cx.build.InBoundsGEP(stub_ptr,
- ~[C_int(0),
- C_uint(abi::ivec_heap_stub_elt_ptr)]);
+ maybe_on_heap_cx.build.InBoundsGEP
+ (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]);
let heap_ptr = maybe_on_heap_cx.build.Load(heap_ptr_ptr);
let heap_ptr_is_nonnull =
maybe_on_heap_cx.build.ICmp(lib::llvm::LLVMIntNE, heap_ptr,
// Ok, the vector is on the heap. Copy the heap part.
let alen_ptr =
- on_heap_cx.build.InBoundsGEP(stub_ptr,
- ~[C_int(0),
- C_uint(abi::ivec_heap_stub_elt_alen)]);
+ on_heap_cx.build.InBoundsGEP
+ (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_alen)]);
let alen = on_heap_cx.build.Load(alen_ptr);
let heap_part_sz =
let then_cx = new_scope_block_ctxt(cx, "then");
let then_res = trans_block(then_cx, thn, output);
let else_cx = new_scope_block_ctxt(cx, "else");
- let
- // Synthesize a block here to act as the else block
- // containing an if expression. Needed in order for the
- // else scope to behave like a normal block scope. A tad
- // ugly.
- // Calling trans_block directly instead of trans_expr
- // because trans_expr will create another scope block
- // context for the block, but we've already got the
- // 'else' context
-
- else_res =
+ // Synthesize a block here to act as the else block
+ // containing an if expression. Needed in order for the
+ // else scope to behave like a normal block scope. A tad
+ // ugly.
+ // Calling trans_block directly instead of trans_expr
+ // because trans_expr will create another scope block
+ // context for the block, but we've already got the
+ // 'else' context
+ let else_res =
alt els {
some(elexpr) {
alt elexpr.node {
let llretslot = args_res.retslot;
/*
log "calling: " + val_str(bcx_ccx(cx).tn, faddr);
-
+
for (ValueRef arg in llargs) {
log "arg: " + val_str(bcx_ccx(cx).tn, arg);
}
}
_ {
// The expression is an lvalue. Fall through.
- assert (ty::is_lval(e)); // make sure it really is and that we
- // didn't forget to add a case for a new expr!
-
+ assert (ty::is_lval(e));
+ // make sure it really is and that we
+ // didn't forget to add a case for a new expr!
}
}
// lval cases fall through to trans_lval and then
alt bcx.fcx.llargs.find(aarg.id) {
some(x) { argval = x; }
_ {
- bcx_ccx(bcx).sess.span_fatal(aarg.ty.span,
- "unbound arg ID in copy_args_to_allocas");
+ bcx_ccx(bcx).sess.span_fatal
+ (aarg.ty.span, "unbound arg ID in copy_args_to_allocas");
}
}
bcx.build.Store(argval, a);
alt bcx.fcx.llargs.find(aarg.id) {
some(x) { argval = x; }
_ {
- bcx_ccx(bcx).sess.span_fatal(aarg.ty.span,
- "unbound arg ID in copy_args_to_allocas");
+ bcx_ccx(bcx).sess.span_fatal
+ (aarg.ty.span, "unbound arg ID in copy_args_to_allocas");
}
}
add_clean(bcx, argval, arg_tys.(arg_n).ty);
let bcx = new_top_block_ctxt(fcx);
let lltop = bcx.llbb;
- let
- // Cast the tag to a type we can GEP into.
- llblobptr =
+ // Cast the tag to a type we can GEP into.
+ let llblobptr =
if is_degen {
fcx.llretptr
} else {
if ivec::len(ty::tag_variants(ccx.tcx, vdef.tg)) == 1u {
kind = single;
} else {
- let tagptr =
- bcx.build.PointerCast(val,
- trans_common::T_opaque_tag_ptr(ccx.tn));
+ let tagptr = bcx.build.PointerCast
+ (val, trans_common::T_opaque_tag_ptr(ccx.tn));
let discrimptr = bcx.build.GEP(tagptr, ~[C_int(0), C_int(0)]);
test_val = bcx.build.Load(discrimptr);
kind = switch;
fn quit(keepgoing: @mutable bool, i: &@item) { *keepgoing = false; }
fn kg(keepgoing: @mutable bool) -> bool { ret *keepgoing; }
- let
-
- v =
+ let v =
{visit_block_pre: bind relax_precond_block_non_recursive(fcx, i, _),
visit_expr_pre: bind relax_precond_expr(fcx, i, _),
visit_stmt_pre: bind relax_precond_stmt(fcx, i, _),
This will mean that:
x = 0;
break;
-
+
won't have a postcondition that says x is initialized, but that's ok.
*/
let result_mode;
if expected_input.mode != actual_input.mode {
- ret fn_common_res_err(ures_err(terr_mode_mismatch(expected_input.mode,
- actual_input.mode)));
+ ret fn_common_res_err
+ (ures_err(terr_mode_mismatch(expected_input.mode,
+ actual_input.mode)));
} else { result_mode = expected_input.mode; }
let result = unify_step(cx, expected_input.ty, actual_input.ty);
alt result {
{path: c.node.path, args: c.node.args, id: pred_id});
}
_ {
- tcx.sess.span_fatal(c.span,
- "Predicate " + path_to_str(c.node.path) +
- " is unbound or bound to a non-function or an \
- impure function");
+ tcx.sess.span_fatal
+ (c.span, "Predicate " + path_to_str(c.node.path) +
+ " is unbound or bound to a non-function or an \
+ impure function");
}
}
}
if ty_substs_len > 0u {
let param_var_len = ivec::len(ty_param_vars);
if param_var_len == 0u {
- fcx.ccx.tcx.sess.span_fatal(sp,
- "this item does not take type parameters");
+ fcx.ccx.tcx.sess.span_fatal
+ (sp, "this item does not take type parameters");
} else if (ty_substs_len > param_var_len) {
- fcx.ccx.tcx.sess.span_fatal(sp,
- "too many type parameter provided for this item");
+ fcx.ccx.tcx.sess.span_fatal
+ (sp, "too many type parameter provided for this item");
} else if (ty_substs_len < param_var_len) {
- fcx.ccx.tcx.sess.span_fatal(sp,
- "not enough type parameters provided for this item");
+ fcx.ccx.tcx.sess.span_fatal
+ (sp, "not enough type parameters provided for this item");
}
let ty_substs: ty::t[] = ~[];
let i = 0u;
let abi = @mutable none[ast::native_abi];
let cx = @{tcx: tcx};
let visit =
- visit::mk_simple_visitor(@{visit_item: bind convert(cx, abi, _),
- visit_native_item:
- bind convert_native(cx, abi, _)
- with
- *visit::default_simple_visitor()});
+ visit::mk_simple_visitor
+ (@{visit_item: bind convert(cx, abi, _),
+ visit_native_item: bind convert_native(cx, abi, _)
+ with *visit::default_simple_visitor()});
visit::visit_crate(*crate, (), visit);
}
}
// TODO (issue #448): Wrap a #fmt string over multiple
// lines...
- fcx.ccx.tcx.sess.span_fatal(pat.span,
- #fmt("this pattern has %u field%s, \
- but the corresponding \
- variant has no fields",
- subpats_len,
- if subpats_len == 1u {
- ""
- } else { "s" }));
+ fcx.ccx.tcx.sess.span_fatal
+ (pat.span, #fmt("this pattern has %u field%s, \
+ but the corresponding \
+ variant has no fields",
+ subpats_len,
+ if subpats_len == 1u { "" }
+ else { "s" }));
}
write::ty_fixup(fcx, pat.id, path_tpot);
}
let f_count = ivec::len(fields);
let ex_f_count = ivec::len(ex_fields);
if ex_f_count < f_count || !etc && ex_f_count > f_count {
- fcx.ccx.tcx.sess.span_fatal(pat.span,
- #fmt("mismatched types: expected a record \
- with %u fields, found one with %u \
- fields",
- ex_f_count, f_count));
+ fcx.ccx.tcx.sess.span_fatal
+ (pat.span, #fmt("mismatched types: expected a record \
+ with %u fields, found one with %u \
+ fields", ex_f_count, f_count));
}
fn matches(name: &str, f: &ty::field) -> bool {
ret str::eq(name, f.ident);
alt ccx.tcx.def_map.find(callee.id) {
some(ast::def_fn(_, ast::pure_fn.)) { ret; }
_ {
- ccx.tcx.sess.span_fatal(sp,
- "Pure function calls function not known to be pure");
+ ccx.tcx.sess.span_fatal
+ (sp, "Pure function calls function not known to be pure");
}
}
}
arg_tys.(i).mode == mo_val {
// For why the check is necessary, see the
// none case in trans_bind_thunk
- fcx.ccx.tcx.sess.span_fatal(sp,
- call_kind_str(call_kind) +
- " arguments with types containing parameters \
- must be passed by alias");
+ fcx.ccx.tcx.sess.span_fatal
+ (sp, call_kind_str(call_kind) +
+ " arguments with types containing parameters \
+ must be passed by alias");
}
}
}
let variants = ty::tag_variants(fcx.ccx.tcx, id);
if ivec::len(variants) != 1u ||
ivec::len(variants.(0).args) != 1u {
- fcx.ccx.tcx.sess.span_fatal(expr.span,
- "can only dereference tags " +
- "with a single variant which has a "
- + "single argument");
+ fcx.ccx.tcx.sess.span_fatal
+ (expr.span, "can only dereference tags " +
+ "with a single variant which has a "
+ + "single argument");
}
oper_t =
ty::substitute_type_params(fcx.ccx.tcx, tps,
ty::ty_ivec(vec_elt_ty) { elt_ty = vec_elt_ty.ty; }
ty::ty_istr. { elt_ty = ty::mk_mach(fcx.ccx.tcx, ast::ty_u8); }
_ {
- fcx.ccx.tcx.sess.span_fatal(expr.span,
- "mismatched types: expected vector or string but "
- + "found " +
- ty_to_str(fcx.ccx.tcx, ety));
+ fcx.ccx.tcx.sess.span_fatal
+ (expr.span, "mismatched types: expected vector or string but "
+ + "found " + ty_to_str(fcx.ccx.tcx, ety));
}
}
check_for_or_for_each(fcx, decl, elt_ty, body, id);
_ {
// The user is trying to extend a
// non-object.
- fcx.ccx.tcx.sess.span_fatal(e.span,
- syntax::print::pprust::expr_to_str(e)
- +
- " does not have object type");
+ fcx.ccx.tcx.sess.span_fatal
+ (e.span, syntax::print::pprust::expr_to_str(e) +
+ " does not have object type");
}
}
}
let expected_nargs = n + 1u; // n conversions + the fmt string
if expected_nargs < nargs {
- cx.span_fatal(sp,
- #fmt("too many arguments to #fmt. found %u, expected %u",
- nargs, expected_nargs));
+ cx.span_fatal
+ (sp, #fmt("too many arguments to #fmt. found %u, expected %u",
+ nargs, expected_nargs));
}
ret tmp_expr;
}
ret {fields:
alt ao.fields {
- option::none[anon_obj_field[]]. { ao.fields }
- option::some[anon_obj_field[]](v) {
- option::some[anon_obj_field[]](ivec::map(fold_anon_obj_field,
- v))
+ option::none. { ao.fields }
+ option::some(v) {
+ option::some(ivec::map(fold_anon_obj_field, v))
}
},
methods: ivec::map(fld.fold_method, ao.methods),
let b: ast::blk = parse_block(p);
let inputs: ast::arg[] = ~[];
let output: @ast::ty = @spanned(lo, lo, ast::ty_nil);
- let
-
- // I guess dtors can't have constraints?
- d: ast::fn_decl =
- {inputs: inputs,
- output: output,
- purity: ast::impure_fn,
- cf: ast::return,
- constraints: ~[]};
+ // I guess dtors can't have constraints?
+ let d: ast::fn_decl = {
+ inputs: inputs,
+ output: output,
+ purity: ast::impure_fn,
+ cf: ast::return,
+ constraints: ~[]
+ };
let f: ast::_fn = {decl: d, proto: ast::proto_fn, body: b};
let m: ast::method_ = {ident: "drop", meth: f, id: p.get_id()};
ret @spanned(lo, f.body.span.hi, m);
fn parse_mod_items(p: &parser, term: token::token,
first_item_attrs: &ast::attribute[]) -> ast::_mod {
- let
- // Shouldn't be any view items since we've already parsed an item attr
- view_items =
+ // Shouldn't be any view items since we've already parsed an item attr
+ let view_items =
if ivec::len(first_item_attrs) == 0u { parse_view(p) } else { ~[] };
let items: (@ast::item)[] = ~[];
let initial_attrs = first_item_attrs;
}
fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
- first_item_attrs: &ast::attribute[]) ->
- ast::native_mod {
- let
- // Shouldn't be any view items since we've already parsed an item attr
- view_items =
+ first_item_attrs: &ast::attribute[])
+ -> ast::native_mod {
+ // Shouldn't be any view items since we've already parsed an item attr
+ let view_items =
if ivec::len(first_item_attrs) == 0u {
parse_native_view(p)
} else { ~[] };
{ty: ty, next: uint} {
if i >= lim { error("missing type in conversion"); }
let tstr = str::substr(s, i, 1u);
- let
-
- // TODO: Do we really want two signed types here?
- // How important is it to be printf compatible?
- t =
+ // TODO: Do we really want two signed types here?
+ // How important is it to be printf compatible?
+ let t =
if str::eq(tstr, "b") {
ty_bool
} else if (str::eq(tstr, "s")) {
ret pad(cv, str::from_char(c), pad_nozero);
}
fn conv_str(cv: &conv, s: str) -> str {
- let
-
- // For strings, precision is the maximum characters
- // displayed
+ // For strings, precision is the maximum characters
+ // displayed
- // FIXME: substr works on bytes, not chars!
- unpadded =
+ // FIXME: substr works on bytes, not chars!
+ let unpadded =
alt cv.precision {
count_implied. { s }
count_is(max) {
// Accessors
/// Returns the first element of a vector
-fn head[T](v: &T[mutable? ]) -> T { ret v.(0); }
+fn head[T](v: &T[mutable?]) : is_not_empty(v) -> T { ret v.(0); }
/// Returns all but the first element of a vector
-fn tail[T](v: &T[mutable? ]) -> T[mutable? ] { ret slice(v, 1u, len(v)); }
+fn tail[T](v: &T[mutable? ]) : is_not_empty(v) -> T[mutable?] {
+ ret slice(v, 1u, len(v));
+}
/// Returns the last element of `v`.
fn last[T](v: &T[mutable? ]) -> option::t[T] {
ret rustrt::str_slice(s, begin, end);
}
-fn safe_slice(s: str, begin: uint, end: uint) -> str {
+fn safe_slice(s: str, begin: uint, end: uint): le(begin, end) -> str {
assert (end <=
str::byte_len(s)); // would need some magic to
// make this a precondition
}
// FIXME: This is super-inefficient
-fn replace(s: str, from: str, to: str) -> str {
+fn replace(s: str, from: str, to: str) : is_not_empty(from) -> str {
// FIXME (694): Shouldn't have to check this
check (is_not_empty(from));
if byte_len(s) == 0u {
type opt_res = either::t[test_opts, str];
// Parses command line arguments into test options
-fn parse_opts(args: &str[]) -> opt_res {
+fn parse_opts(args: &str[]) : ivec::is_not_empty(args) -> opt_res {
// FIXME (#649): Shouldn't have to check here
check (ivec::is_not_empty(args));
}
fn main() {
-
- let
- //
- // Leave these commented out to
- // finish in a reasonable time
- // during 'make check' under valgrind
- // 5000000
- // 50000000
- inputs: vec[int] =
- [50000, 500000];
+ //
+ // Leave these commented out to
+ // finish in a reasonable time
+ // during 'make check' under valgrind
+ // 5000000
+ // 50000000
+ let inputs: vec[int] = [50000, 500000];
let bodies: vec[Body::props] = NBodySystem::MakeNBodySystem();
mod NBodySystem {
fn MakeNBodySystem() -> vec[Body::props] {
- let
- // these each return a Body::props
- bodies: vec[Body::props] =
+ // these each return a Body::props
+ let bodies: vec[Body::props] =
[Body::sun(), Body::jupiter(), Body::saturn(), Body::uranus(),
Body::neptune()];
-./src/test/compile-fail/attr-bad-meta.rs:5:6:5:7: \e[1;31merror:\e[0m expecting ], found *
-./src/test/compile-fail/attr-bad-meta.rs:5 #[attr*]
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0xa6bf04c root task failed
+// xfail-stage0
+// error-pattern:expecting ]
+
+// asterisk is bogus
+#[attr*]
+mod m { }
\ No newline at end of file
-./src/test/compile-fail/attr-before-stmt.rs:6:2:6:6: \e[1;31merror:\e[0m expected item
-./src/test/compile-fail/attr-before-stmt.rs:6 auto x = 10;
- ^~~~
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0x8ef904c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+fn f() {
+ #[foo = "bar"]
+ let x = 10;
+}
+
+fn main() {
+}
-./src/test/compile-fail/attr-before-view-item.rs:5:0:5:3: \e[1;31merror:\e[0m expected item but found use
-./src/test/compile-fail/attr-before-view-item.rs:5 use std;
- ^~~
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0xa78604c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+#[foo = "bar"]
+use std;
+
+fn main() {
+}
-./src/test/compile-fail/attr-before-view-item2.rs:6:2:6:5: \e[1;31merror:\e[0m expected item but found use
-./src/test/compile-fail/attr-before-view-item2.rs:6 use std;
- ^~~
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0xa1fd04c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+mod m {
+ #[foo = "bar"]
+ use std;
+}
+
+fn main() {
+}
-./src/test/compile-fail/attr-dangling-in-fn.rs:6:0:6:1: \e[1;31merror:\e[0m expected item
-./src/test/compile-fail/attr-dangling-in-fn.rs:6 }
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x9fb104c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+fn f() {
+ #[foo = "bar"]
+}
+
+fn main() {
+}
-./src/test/compile-fail/attr-dangling-in-mod.rs:7:14:7:14: \e[1;31merror:\e[0m expected item but found <eof>
-./src/test/compile-fail/attr-dangling-in-mod.rs:7 #[foo = "bar"]
- ^
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0xa2d504c root task failed
+// xfail-stage0
+// error-pattern:expected item
+
+fn main() {
+}
+
+#[foo = "bar"]
-./src/test/compile-fail/bad-alt.rs:5:7:5:8: \e[1;31merror:\e[0m expecting {, found ;
-./src/test/compile-fail/bad-alt.rs:5 alt x;
- ^
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0x9e0f04c root task failed
+// error-pattern: expecting
+
+fn main() {
+ let int x = 5;
+ alt x;
+}
-./src/test/compile-fail/bad-name.rs:4:7:4:8: \e[1;31merror:\e[0m expecting ident
-./src/test/compile-fail/bad-name.rs:4 let x.y[int].z foo;
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x8d6004c root task failed
+// error-pattern: expecting
+
+fn main() {
+ let x.y[int].z foo;
+}
pred less_than(x: int, y: int) -> bool { ret x < y; }
-type ordered_range = {low: int, high: int} : : less_than(low, high);
+type ordered_range = {low: int, high: int} : less_than(low, high);
fn main() {
// Should fail to compile, b/c we're not doing the check
// xfail-stage0
// error-pattern: Unsatisfied precondition constraint (for example, even(y
-fn print_even(y: int) { log y; }
+fn print_even(y: int) : even(y) {
+ log y;
+}
-pred even(y: int) -> bool { true }
+pred even(y: int) -> bool {
+ true
+}
fn main() {
-
- let y: int = 42;
- check (even(y));
- do {
- print_even(y);
- do { do { do { y += 1; } while true } while true } while true
- } while true
-}
\ No newline at end of file
+ let y: int = 42;
+ check even(y);
+ do {
+ print_even(y);
+ do {
+ do {
+ do {
+ y += 1;
+ } while (true);
+ } while (true);
+ } while (true);
+ } while (true);
+}
-./src/test/compile-fail/ext-after-attrib.rs:7:1:7:4: \e[1;31merror:\e[0m expecting [, found fmt
-./src/test/compile-fail/ext-after-attrib.rs:7 #fmt("baz")
- ^~~
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0xa47a04c root task failed
+// xfail-stage0
+// error-pattern:expecting [, found fmt
+
+// Don't know how to deal with a syntax extension appearing after an
+// item attribute. Probably could use a better error message.
+#[foo = "bar"]
+#fmt("baz")
+fn main() { }
\ No newline at end of file
-./src/test/compile-fail/ext-noname.rs:4:3:4:4: \e[1;31merror:\e[0m expected a syntax expander name
-./src/test/compile-fail/ext-noname.rs:4 #();
- ^
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0x91a204c root task failed
+// error-pattern:expected a syntax expander name
+
+fn main() {
+ #();
+}
\ No newline at end of file
// error-pattern:malformed #env call
-fn main() { #env; }
\ No newline at end of file
+fn main() {
+ #env();
+}
// error-pattern:format string
-fn main() { #fmt; }
\ No newline at end of file
+fn main() {
+ #fmt();
+}
\ No newline at end of file
-./src/test/compile-fail/fail-simple.rs:5:9:5:10: \e[1;31merror:\e[0m unexpected token: ;
-./src/test/compile-fail/fail-simple.rs:5 fail @ ;
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x994f04c root task failed
+// -*- rust -*-
+
+// error-pattern:unexpected token
+fn main() {
+ fail @ ;
+}
} else if (x == 2u) { ret true; } else { ret even(x - 2u); }
}
-fn print_even(x: uint) { log x; }
+fn print_even(x: uint) : even(x) { log x; }
fn foo(x: uint) { if check even(x) { fail; } else { print_even(x); } }
// xfail-stage0
//error-pattern:is an expr, expected an identifier
fn main() {
- #macro([#mylambda(x, body),
- {
- fn f(x: int) -> int { ret body }
- f
- }]);
+ #macro([#mylambda(x, body), {fn f(x: int) -> int {ret body}; f}]);
- assert (#mylambda(y * 1, y * 2)(8) == 16);
+ assert(#mylambda(y*1, y*2)(8) == 16);
}
\ No newline at end of file
//error-pattern:no clauses match
fn main() {
- #macro([#trivial, 1 * 2 * 4 * 2 * 1]);
+ #macro([#trivial(), 1*2*4*2*1]);
- assert (#trivial(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16) ==
- 16);
-}
\ No newline at end of file
+ assert(#trivial(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) == 16);
+}
-./src/test/compile-fail/multiline-comment-line-tracking.rs:9:2:9:3: \e[1;31merror:\e[0m unexpected token: %
-./src/test/compile-fail/multiline-comment-line-tracking.rs:9 %; // parse error on line 9, but is reported on line 6 instead.
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x969e04c root task failed
+// -*- rust -*-
+// error-pattern:9:2
+
+/* 1
+ * 2
+ * 3
+ */
+fn main() {
+ %; // parse error on line 9, but is reported on line 6 instead.
+}
fn main() {
let z = f();
- check (z.g(42)); // should fail to typecheck, as z.g isn't an explicit name
+ // should fail to typecheck, as z.g isn't an explicit name
+ check (z.g(42));
}
\ No newline at end of file
// xfail-stage0
// error-pattern: Non-predicate in constraint: lt
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
obj lt(a: int, b: int) { }
pred f(q: int) -> bool { ret true; }
fn main() {
- // should fail to typecheck, as pred args must be slot variables or literals
+ // should fail to typecheck, as pred args must be slot variables
+ // or literals
check (f(42 * 17));
}
\ No newline at end of file
// error-pattern: Unsatisfied precondition constraint (for example, lt(a, b)
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
pred lt(a: int, b: int) -> bool { ret a < b; }
// error-pattern: lt(a, c)
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
pred lt(a: int, b: int) -> bool { ret a < b; }
// error-pattern: Unsatisfied precondition constraint (for example, lt(a, b)
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
pred lt(a: int, b: int) -> bool { ret a < b; }
-./src/test/compile-fail/self-missing-method.rs:6:14:6:15: \e[1;31merror:\e[0m expecting ., found (
-./src/test/compile-fail/self-missing-method.rs:6 self();
- ^
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0x8f5904c root task failed
+// error-pattern:expecting ., found (
+fn main() {
+
+ obj foo() {
+ fn m() {
+ self();
+ }
+ }
+
+ let a = foo;
+ a.m();
+}
// xfail-stage0
// error-pattern: unresolved name: lt
-fn f(a: int, b: int) { }
+fn f(a: int, b: int) : lt(a,b) { }
fn main() {
let lt: int;
-./src/test/compile-fail/tail-non-call.rs:5:6:5:7: \e[1;31merror:\e[0m Non-call expression in tail call
-./src/test/compile-fail/tail-non-call.rs:5 be x;
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x9d9404c root task failed
+// error-pattern: Non-call expression in tail call
+
+fn f() -> int {
+ let x = 1;
+ be x;
+}
+
+fn main() {
+ let y = f();
+}
-./src/test/compile-fail/unbalanced-comment.rs:11:1:11:1: \e[1;31merror:\e[0m unterminated block comment
-./src/test/compile-fail/unbalanced-comment.rs:11 }
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/lexer.rs:153
-rt: f00e:main: domain main @0x96ef04c root task failed
+// -*- rust -*-
+
+// error-pattern: unterminated block comment
+
+/*
+ * This is an un-balanced /* multi-line comment.
+ */
+
+fn main() {
+ log "hello, world.";
+}
// xfail-stage0
// error-pattern: Unsatisfied precondition constraint (for example, even(y
-fn print_even(y: int) { log y; }
+fn print_even(y: int) : even(y) { log y; }
pred even(y: int) -> bool { true }
import std::str::*;
import std::uint::*;
-fn nop(a: uint, b: uint) { fail "quux"; }
+fn nop(a: uint, b: uint) : le(a, b) { fail "quux"; }
-fn main() { let a: uint = 5u; let b: uint = 4u; claim (le(a, b)); nop(a, b); }
\ No newline at end of file
+fn main() {
+ let a: uint = 5u;
+ let b: uint = 4u;
+ claim (le(a, b));
+ nop(a, b);
+}
-./src/test/run-fail/task-comm-14.rs:5:0:5:2: \e[1;31merror:\e[0m expected item but found io
-./src/test/run-fail/task-comm-14.rs:5 io fn main() {
- ^~
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0x919b04c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+io fn main() {
+ let port[int] po = port();
+
+ // Spawn 10 tasks each sending us back one int.
+ let int i = 10;
+ while (i > 0) {
+ log i;
+ spawn "child" child(i, chan(po));
+ i = i - 1;
+ }
+
+ // Spawned tasks are likely killed before they get a chance to send
+ // anything back, so we deadlock here.
+
+ i = 10;
+ let int value = 0;
+ while (i > 0) {
+ log i;
+ po |> value;
+ i = i - 1;
+ }
+
+ log "main thread exiting";
+}
+
+io fn child(int x, chan[int] ch) {
+ log x;
+ ch <| x;
+}
-./src/test/run-pass/alt-type-simple.rs:6:6:6:10: \e[1;31merror:\e[0m found type in expression position
-./src/test/run-pass/alt-type-simple.rs:6 alt type (f) {
- ^~~~
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x9b0204c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn altsimple(any x) {
+ alt type (f) {
+ case (int i) { print("int"); }
+ case (str s) { print("str"); }
+ }
+}
+
+fn main() {
+ altsimple(5);
+ altsimple("asdfasdfsDF");
+}
let my_a = a();
// An anonymous object that overloads the 'foo' method.
- let
-
- my_b =
+ let my_b =
obj () {
fn foo() -> int { ret 3; }
with
fn main() {
- auto num = 12;
+ let num = 12;
assert if (true) { 12 } else { 12 } - num == 0;
assert 12 - if (true) { 12 } else { 12 } == 0;
-./src/test/run-pass/clone-with-exterior.rs:12:28:12:29: \e[1;31merror:\e[0m expecting (, found f
-./src/test/run-pass/clone-with-exterior.rs:12 let task p = spawn thread f(z);
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x8f2504c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn f(@rec(int a, int b) x) {
+ assert (x.a == 10);
+ assert (x.b == 12);
+}
+
+fn main() {
+ let @rec(int a, int b) z = rec(a=10, b=12);
+ let task p = spawn thread f(z);
+ join p;
+}
\ No newline at end of file
pred less_than(x: int, y: int) -> bool { ret x < y; }
-type ordered_range = {low: int, high: int} : : less_than(low, high);
+type ordered_range = {low: int, high: int} : less_than(*.low, *.high);
fn main() { }
\ No newline at end of file
-./src/test/run-pass/destructor-ordering.rs:25:0:25:2: \e[1;31merror:\e[0m expected item but found io
-./src/test/run-pass/destructor-ordering.rs:25 io fn check_order(port[order_info] expected_p) {
- ^~
-rt: ---
-rt: 17b9:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 17b9:main: domain main @0x96d304c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+// This test checks that destructors run in the right order. Because
+// stateful objects can't have destructors, we have the destructors
+// record their expected order into a channel when they execute (so
+// the object becomes 'io' rather than 'state'). Then each test case
+// asserts that the channel produces values in ascending order.
+//
+// FIXME: Write an int->str function and concatenate the whole failure
+// message into a single log statement (or, even better, a print).
+//
+// FIXME: check_order should take only 1 line in a test, not 2+a block
+// block. Since destructor-having objects can't refer to mutable state
+// (like the port), we'd need a with-like construct to do the same for
+// stateful objects within a scope.
+//
+// FIXME #21: Each test should execute in its own task, so it can fail
+// independently, writing its error message to a channel that the
+// parent task aggregates.
+
+type order_info = rec(int order, str msg);
+
+io fn check_order(port[order_info] expected_p) {
+ chan(expected_p) <| rec(order=-1, msg="");
+ let mutable int actual = 0;
+ // FIXME #121: Workaround for while(true) bug.
+ auto expected; expected_p |> expected;
+ auto done = -1; // FIXME: Workaround for typechecking bug.
+ while(expected.order != done) {
+ if (expected.order != actual) {
+ log expected.order;
+ log " != ";
+ log actual;
+ log expected.msg;
+ fail;
+ }
+ actual += 1;
+ expected_p |> expected;
+ }
+}
+
+
+obj dorder(chan[order_info] expected, int order, str message) {
+ drop {
+ expected <| rec(order=order, msg=message);
+ }
+}
+
+io fn test_simple() {
+ let port[order_info] tracker_p = port();
+ auto tracker = chan(tracker_p);
+ dorder(tracker, 1, "Reverse decl order");
+ dorder(tracker, 0, "Reverse decl order");
+ check_order(tracker_p);
+}
+
+io fn test_block() {
+ let port[order_info] tracker_p = port();
+ auto tracker = chan(tracker_p);
+ {
+ dorder(tracker, 2, "Before block");
+ {
+ dorder(tracker, 0, "Inside block");
+ }
+ dorder(tracker, 1, "After block");
+ }
+ check_order(tracker_p);
+}
+
+io fn test_decl_v_init() {
+ let port[order_info] tracker_p = port();
+ auto tracker = chan(tracker_p);
+ {
+ auto var1;
+ auto var2;
+ var2 = dorder(tracker, 0, "decl, not init");
+ var1 = dorder(tracker, 1, "decl, not init");
+ }
+ check_order(tracker_p);
+}
+
+io fn test_overwritten_obj() {
+ let port[order_info] tracker_p = port();
+ auto tracker = chan(tracker_p);
+ {
+ auto var1 = dorder(tracker, 0, "overwritten object destroyed first");
+ auto var2 = dorder(tracker, 2, "destroyed at end of scope");
+ var1 = dorder(tracker, 3, "overwriter deleted in rev decl order");
+ {
+ dorder(tracker, 1, "overwritten object destroyed before end of scope");
+ }
+ }
+ check_order(tracker_p);
+}
+
+// Used to embed dorder objects into an expression. Note that the
+// parameters don't get destroyed.
+fn combine_dorders(dorder d1, dorder d2) -> int {
+ ret 1;
+}
+io fn test_expression_destroyed_right_to_left() {
+ let port[order_info] tracker_p = port();
+ auto tracker = chan(tracker_p);
+ {
+ combine_dorders(dorder(tracker, 4, ""), dorder(tracker, 3, ""))
+ / combine_dorders(dorder(tracker, 2, ""), dorder(tracker, 1, ""));
+ {
+ dorder(tracker, 0,
+ "expression objects live to end of block, not statement");
+ }
+ }
+ check_order(tracker_p);
+}
+
+io fn main() {
+ test_simple();
+ test_block();
+ test_decl_v_init();
+ test_overwritten_obj();
+ test_expression_destroyed_right_to_left();
+}
} else if (x == 2u) { ret true; } else { ret even(x - 2u); }
}
-fn print_even(x: uint) { log x; }
+fn print_even(x: uint) : even(x) { log x; }
fn foo(x: uint) { if check even(x) { print_even(x); } else { fail; } }
// xfail-stage0
-fn foo() { if ret { } }
+fn foo() { if (ret) { } }
fn main() { foo(); }
\ No newline at end of file
#[attr = "val"]
mod mod1 {
}
-
+
#[attr = "val"]
native "rust" mod rustrt {
}
#[attr2 = "val"]
mod mod1 {
}
-
+
#[attr1 = "val"]
#[attr2 = "val"]
native "rust" mod rustrt {
// xfail-stage0
fn main() {
- #macro([#mylambda(x, body),
- {
- fn f(x: int) -> int { ret body }
- f
- }]);
+ #macro([#mylambda(x,body), {fn f(x: int) -> int { ret body }; f}]);
- assert (#mylambda(y, y * 2)(8) == 16);
+ assert(#mylambda(y,y*2)(8) == 16);
}
\ No newline at end of file
// xfail-stage0
fn main() {
- #macro([#trivial, 1 * 2 * 4 * 2 * 1]);
+ #macro([#trivial(), 1*2*4*2*1]);
- assert (#trivial == 16);
-}
\ No newline at end of file
+ assert(#trivial() == 16);
+}
// xfail-stage0
-fn main() { #macro([#m1(a), a * 4]); assert (#m1(2) == 8); }
\ No newline at end of file
+fn main() {
+ #macro([#m1(a), a*4]);
+ assert (#m1(2) == 8);
+}
-./src/test/run-pass/many.rs:21:12:21:14: \e[1;31merror:\e[0m expecting ;, found |>
-./src/test/run-pass/many.rs:21 let int p |> y;
- ^~
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x8da604c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+// -*- rust -*-
+
+fn sub(chan[int] parent, int id) {
+ if (id == 0) {
+ parent <| 0;
+ } else {
+ let port[int] p = port();
+ auto child = spawn sub(chan(p), id-1);
+ let int y; p |> y;
+ parent <| y + 1;
+ }
+}
+
+fn main() {
+ let port[int] p = port();
+ auto child = spawn sub(chan(p), 500);
+ let int p |> y;
+ log "transmission complete";
+ log y;
+ assert (y == 500);
+}
// xfail-stage0
-fn main() { let x = (); alt x { () { } } }
\ No newline at end of file
+fn main() { let x = (); alt x { (()) { } } }
\ No newline at end of file
-./src/test/run-pass/spawn-module-qualified.rs:7:7:7:8: \e[1;31merror:\e[0m expected ';' or '}' after expression but found x
-./src/test/run-pass/spawn-module-qualified.rs:7 join x;
- ^
-rt: ---
-rt: 0bb1:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: 0bb1:main: domain main @0xa98404c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn main() {
+ auto x = spawn m::child(10);
+ join x;
+}
+mod m {
+ fn child(int i) {
+ log i;
+ }
+}
-./src/test/run-pass/syntax-extension-shell.rs:6:18:6:19: \e[1;31merror:\e[0m expecting (, found {
-./src/test/run-pass/syntax-extension-shell.rs:6 auto s = #shell { uname -a };
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x910c04c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn main() {
+ auto s = #shell { uname -a };
+ log s;
+}
-./src/test/run-pass/task-killjoin.rs:22:36:22:46: \e[1;31merror:\e[0m expecting (, found supervised
-./src/test/run-pass/task-killjoin.rs:22 let task t = spawn "supervised" supervised();
- ^~~~~~~~~~
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0xa7b604c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+
+// Create a task that is supervised by another task,
+// join the supervised task from the supervising task,
+// then fail the supervised task. The supervised task
+// will kill the supervising task, waking it up. The
+// supervising task no longer needs to be wakened when
+// the supervised task exits.
+
+fn supervised() {
+ // Yield to make sure the supervisor joins before we
+ // fail. This is currently not needed because the supervisor
+ // runs first, but I can imagine that changing.
+ yield;
+ fail;
+}
+
+fn supervisor() {
+ let task t = spawn "supervised" supervised();
+ join t;
+}
+
+fn main() {
+ // Start the test in another domain so that
+ // the process doesn't return a failure status as a result
+ // of the main task being killed.
+ let task dom2 = spawn thread "supervisor" supervisor();
+ join dom2;
+}
+
+// Local Variables:
+// mode: rust;
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
-./src/test/run-pass/threads.rs:11:17:11:24: \e[1;31merror:\e[0m expecting (, found "child"
-./src/test/run-pass/threads.rs:11 spawn thread "child" child(i);
- ^~~~~~~
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x999804c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+
+// -*- rust -*-
+
+fn main() {
+ let int i = 10;
+ while (i > 0) {
+ spawn thread "child" child(i);
+ i = i - 1;
+ }
+ log "main thread exiting";
+}
+
+fn child(int x) {
+ log x;
+}
+
pred p(i: int) -> bool { true }
-fn f(i: int) -> int { i }
+fn f(i: int) : p(i) -> int { i }
-fn g(i: int) -> int { f(i) }
+fn g(i: int) : p(i) -> int { f(i) }
fn main() { }
\ No newline at end of file
-./src/test/run-pass/user.rs:9:16:9:17: \e[1;31merror:\e[0m unexpected token: _
-./src/test/run-pass/user.rs:9 uuid = _, ver = _);
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0x907604c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+// -*- rust -*-
+
+use std (name = "std",
+ url = "http://rust-lang.org/src/std",
+ uuid = _, ver = _);
+
+fn main() {
+ auto s = std::str.alloc(10 as uint);
+ s += "hello ";
+ log s;
+ s += "there";
+ log s;
+ auto z = std::vec.alloc[int](10 as uint);
+}
-./src/test/run-pass/vec-slice.rs:7:16:7:17: \e[1;31merror:\e[0m expecting ), found ,
-./src/test/run-pass/vec-slice.rs:7 auto v2 = v.(1,2);
- ^
-rt: ---
-rt: f00e:main:main: upcall fail 'explicit failure', src/comp/syntax/parse/parser.rs:112
-rt: f00e:main: domain main @0xa73404c root task failed
+// xfail-stage0
+// xfail-stage1
+// xfail-stage2
+// xfail-stage3
+fn main() {
+ let vec[int] v = [1,2,3,4,5];
+ auto v2 = v.(1,2);
+ assert (v2.(0) == 2);
+ assert (v2.(1) == 3);
+}
\ No newline at end of file
two(17, 42));
/*
* FIXME: Segfault. Also appears to be caused only after upcall_grow_task
-
+
log "*** test parameterized: taggypar[int]";
let eqfn[taggypar[int]] eq4 = taggypareq[int];
test_parameterized[taggypar[int]](eq4,
threepar[int](1, 2, 3),
twopar[int](17, 42));
log "*** end test parameterized: taggypar[int]";
-
+
*/
log "*** test parameterized: reccy";
/**
* FIXME (issue #150): we want to check the removed value as in the
* following:
-
+
let util.option[uint] v = hm.remove(i);
alt (v) {
case (util.some[uint](u)) {
}
case (util.none[uint]()) { fail; }
}
-
+
* but we util.option is a tag type so util.some and util.none are
* off limits until we parse the dwarf for tag types.
*/
projects / rust.git / commitdiff