DaGenix

// This code works fine
fn get(f: ~fn() -> int) -> ~fn() -> int {
    || {
        f()
    }
}
fn main() {
    get(|| {8})();
}

DaGenix

trait Printable {
        fn print(&self);
}

fn test(o: &[~Printable]) {
        for o.each |&p| {
                p.print();
        }
}

DaGenix

struct Works {
    val: int
}

impl Works {
    fn fn1(&mut self) {
        // This seems to work perfectly fine
        self.fn2(&const self.val);
    }
    fn fn2(&mut self, x: &const int) {

DaGenix

fn test() -> (u32, u32) {
    return (0, 0,);
}

fn main() {
    let mut X0: u32;
    let mut X1: u32;
    (X0, X1) = test();
}

DaGenix

fn test() -> (u32, u32) {
    return (0, 0,);
}

fn main() {
    let mut X0 = 0u32;
    let mut X1 = 0u32;
    (X0, X1) = test();
}

DaGenix

fn call(f: &fn()) {
        f();
}

fn call_twice(f: &fn()) {
        call(f);
        call(f);
}

fn main() {

DaGenix

use std::unstable::simd::u32x4;

static test: u32x4 = u32x4(0, 0, 0, 0);

fn main() {
}

DaGenix

/*!

this module implements the AES algorithm completely in software without using any table lookups or
other timing dependant mechanisms. This module actually contains two seperate implementations - an
implementation that works on a single block at a time and a second implementation that processes 8
blocks in parallel. Some block encryption modes really only work if you are processing a single
blocks (CFB, OFB, and CBC encryption for example) while other modes are trivially parallelizable
(CTR and CBC decryption). Processing more blocks at once allows for greater efficiency, especially
when using wide registers, such as the XMM registers available in x86 processors.

DaGenix

struct Struct<'self, B> {
    val: B
}

impl <'self, B: MutableVector<'self, u8>> Struct<'self, B> {
}

DaGenix

use std::hash;
use std::hash::Streaming;

// I believe that this pretty much the same thing as hash_crate_independent() in ty.rs
// for a ty_struct on a 64-bit platform
fn hash_struct(local_hash: &str, node: u64) -> u64 {
    let mut state = hash::default_state();
    state.input([18]);
    state.input(local_hash.as_bytes());
    do node.iter_bytes(true) |bytes| { state.input(bytes); true };