ret {crate: crate, src: src};
}
-fn time<T>(do_it: bool, what: str, thunk: fn() -> T) -> T {
+fn time<@T>(do_it: bool, what: str, thunk: fn() -> T) -> T {
if !do_it { ret thunk(); }
let start = std::time::precise_time_s();
let rv = thunk();
}
}
-fn span<T>(item: &T) -> ast::spanned<T> {
+fn span<@T>(item: &T) -> ast::spanned<T> {
ret {node: item, span: ast_util::dummy_sp()};
}
ret @item;
}
-fn nospan<T>(t: &T) -> ast::spanned<T> {
+fn nospan<@T>(t: &T) -> ast::spanned<T> {
ret {node: t, span: dummy_sp()};
}
import syntax::visit;
import std::vec;
+import std::option;
import ast::kind;
import ast::kind_unique;
alt e.node {
ast::expr_move(a, b) { need_shared_lhs_rhs(tcx, a, b, "<-"); }
ast::expr_assign(a, b) { need_shared_lhs_rhs(tcx, a, b, "="); }
+ ast::expr_assign_op(_, a, b) { need_shared_lhs_rhs(tcx, a, b, "op="); }
ast::expr_swap(a, b) { need_shared_lhs_rhs(tcx, a, b, "<->"); }
+ ast::expr_copy(a) {
+ need_expr_kind(tcx, a, ast::kind_shared, "'copy' operand");
+ }
+ ast::expr_ret(option::some(a)) {
+ need_expr_kind(tcx, a, ast::kind_shared, "'ret' operand");
+ }
+ ast::expr_be(a) {
+ need_expr_kind(tcx, a, ast::kind_shared, "'be' operand");
+ }
+ ast::expr_fail(option::some(a)) {
+ need_expr_kind(tcx, a, ast::kind_shared, "'fail' operand");
+ }
ast::expr_call(callee, _) {
let tpt = ty::expr_ty_params_and_ty(tcx, callee);
import codemap::span;
import ast::*;
-fn respan<T>(sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
+fn respan<@T>(sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
/* assuming that we're not in macro expansion */
fn mk_sp(lo: uint, hi: uint) -> span {
}
}
-fn spanned<T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
+fn spanned<@T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
ret {node: node, span: ast_util::mk_sp(lo, hi)};
}
}
}
-fn get<T>(itr: &interner<T>, idx: uint) -> T { ret itr.vect[idx]; }
+fn get<@T>(itr: &interner<T>, idx: uint) -> T { ret itr.vect[idx]; }
fn len<T>(itr: &interner<T>) -> uint { ret vec::len(itr.vect); }
resource rust_task_ptr(task: *rust_task) { rustrt::drop_task(task); }
-fn get_task_ptr(id: task) -> rust_task_ptr {
- ret rust_task_ptr(rustrt::get_task_pointer(id));
-}
-
type task = int;
type task_id = task;
// stack.
// set up the task pointer
- let task_ptr = get_task_ptr(id);
+ let task_ptr = rust_task_ptr(rustrt::get_task_pointer(id));
let regs = ptr::addr_of((**task_ptr).ctx.regs);
(*regs).edx = cast(*task_ptr);;
(*regs).esp = cast((**task_ptr).stack_ptr);
}
// Casts the value at `src` to U. The two types must have the same length.
-fn reinterpret_cast<T, U>(src: &T) -> U { ret rusti::cast(src); }
+fn reinterpret_cast<T, @U>(src: &T) -> U { ret rusti::cast(src); }
fn leak<@T>(thing: -T) {
rustrt::leak(thing);
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
/* FIXME (issue #141): See test/run-pass/constrained-type.rs. Uncomment
-// error-pattern: non-copyable
+// error-pattern: mismatched kinds
fn lol(f: &block()) -> block() { ret f; }
fn main() { let i = 8; let f = lol(block () { log_err i; }); f(); }
}
}
-fn with_lib_path<T>(path: &str, f: fn() -> T) -> T {
+fn with_lib_path<@T>(path: &str, f: fn() -> T) -> T {
let maybe_oldpath = getenv(util::lib_path_env_var());
append_lib_path(path);
let res = f();
// -*- rust -*-
-fn f<T, U>(x: &T, y: &U) -> {a: T, b: U} { ret {a: x, b: y}; }
+fn f<@T, @U>(x: &T, y: &U) -> {a: T, b: U} { ret {a: x, b: y}; }
fn main() { log f({x: 3, y: 4, z: 5}, 4).a.x; log f(5, 6).a; }
-fn f<T>(x: &[T]) -> T { ret x[0]; }
+fn f<@T>(x: &[T]) -> T { ret x[0]; }
fn g(act: fn(&[int]) -> int) -> int { ret act([1, 2, 3]); }
type box<T> = {c: @T};
-fn unbox<T>(b: &box<T>) -> T { ret *b.c; }
+fn unbox<@T>(b: &box<T>) -> T { ret *b.c; }
fn main() {
let foo: int = 17;
-fn fix_help<A, B>(f: @fn(@fn(&A) -> B, &A) -> B, x: &A) -> B {
+fn fix_help<A, @B>(f: @fn(@fn(&A) -> B, &A) -> B, x: &A) -> B {
ret f(@bind fix_help(f, _), x);
}
-fn fix<A, B>(f: @fn(@fn(&A) -> B, &A) -> B) -> @fn(&A) -> B {
+fn fix<A, @B>(f: @fn(@fn(&A) -> B, &A) -> B) -> @fn(&A) -> B {
ret @bind fix_help(f, _);
}
-fn id<T>(t: &T) -> T { ret t; }
+fn id<@T>(t: &T) -> T { ret t; }
fn main() {
let expected = @100;
-fn id<T>(t: &T) -> T { ret t; }
+fn id<@T>(t: &T) -> T { ret t; }
fn main() {
let t = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7};
-fn id<T>(t: &T) -> T { ret t; }
+fn id<@T>(t: &T) -> T { ret t; }
fn main() {
let t = {_0: 1, _1: 2, _2: 3, _3: 4, _4: 5, _5: 6, _6: 7};
-fn g<X>(x: &X) -> X { ret x; }
+fn g<@X>(x: &X) -> X { ret x; }
-fn f<T>(t: &T) -> {a: T, b: T} {
+fn f<@T>(t: &T) -> {a: T, b: T} {
type pair = {a: T, b: T};
let x: pair = {a: t, b: t};
// -*- rust -*-
// Issue #45: infer type parameters in function applications
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
fn main() { let x: int = 42; let y: int = id(x); assert (x == y); }
// -*- rust -*-
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
type triple = {x: int, y: int, z: int};
-obj handle<T>(data: T) {
+obj handle<@T>(data: T) {
fn get() -> T { ret data; }
}
-obj buf<T>(data: {_0: T, _1: T, _2: T}) {
+obj buf<@T>(data: {_0: T, _1: T, _2: T}) {
fn get(i: int) -> T {
if i == 0 {
ret data._0;
-fn get_third<T>(t: &(T, T, T)) -> T { let (_, _, x) = t; ret x; }
+fn get_third<@T>(t: &(T, T, T)) -> T { let (_, _, x) = t; ret x; }
fn main() {
log get_third((1, 2, 3));
-fn quux<T>(x: &T) -> T { let f = id::<T>; ret f(x); }
+fn quux<@T>(x: &T) -> T { let f = id::<T>; ret f(x); }
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
fn main() { assert (quux(10) == 10); }
tag myvec<X> = [X];
-fn myvec_deref<X>(mv: &myvec<X>) -> [X] { ret *mv; }
+fn myvec_deref<@X>(mv: &myvec<X>) -> [X] { ret *mv; }
-fn myvec_elt<X>(mv: &myvec<X>) -> X { ret mv[0]; }
+fn myvec_elt<@X>(mv: &myvec<X>) -> X { ret mv[0]; }
fn main() {
let mv = myvec([1, 2, 3]);
tag option<T> { none; some(T); }
-fn f<T>() -> option<T> { ret none; }
+fn f<@T>() -> option<T> { ret none; }
fn main() { f::<int>(); }
projects / rust.git / commitdiff