Update for latest Rust

Author: TomBebbington

Diff for: Cargo.toml

@@ -1,6 +1,6 @@
 [project]
 
-name = "js.rs"
+name = "js"
 version = "0.0.1"
 readme = "README.md"
 authors = ["Tom Bebbington <[email protected]>"]
@@ -14,9 +14,11 @@ path = "src/lib/lib.rs"
 
 [[bin]]
 
-name = "js.rs"
+name = "js"
 path = "src/bin/bin.rs"
 
 [dependencies.jit]
+git = "https://github.com/TomBebbington/jit.rs.git"
 
-git = "https://github.com/TomBebbington/jit.rs.git"
+[dependencies.url]
+git = "https://github.com/servo/rust-url"

Diff for: src/bin/bin.rs

@@ -1,4 +1,3 @@
-#![crate_id = "github.com/TomBebbington/js.rs"]
 #![comment = "Javascript parsing and execution command line tool"]
 #![license = "MIT"]
 #![crate_type = "bin"]
@@ -41,14 +40,14 @@ pub fn main() {
         None if m.opt_present("h") => {
             println!("{}", getopts::usage("Usage: js.rs [OPTIONS] [INPUT]", opts));
         },
-        None if m.opt_present("t") || (m.free.len() >= 2 && m.free.get(1).as_slice() == "test") => {
+        None if m.opt_present("t") || (m.free.len() >= 2 && m.free[1].as_slice() == "test") => {
             Tests::new().run();
         },
-        None if m.opt_present("i") || (m.free.len() >= 2 && m.free.get(1).as_slice() == "interactive") => {
+        None if m.opt_present("i") || (m.free.len() >= 2 && m.free[1].as_slice() == "interactive") => {
             Interactive::new().run();
         },
         None if m.free.len() >= 2 => {
-            Runner::new(m.free.get(1).clone()).run();
+            Runner::new(m.free[1].clone()).run();
         },
         None => {
             println!("{}", getopts::short_usage("Usage: js.rs [OPTIONS] [INPUT]", opts));

Diff for: src/bin/interactive.rs

@@ -18,7 +18,7 @@ pub struct Interactive<'a> {
 }
 impl<'a> Interactive<'a> {
     /// Create a new interactive mode info
-    pub fn new() -> Interactive {
+    pub fn new() -> Interactive<'a> {
         Interactive {
             context: Context::new(),
             executor: Executor::new(&Default::default()),

Diff for: src/bin/tests.rs

@@ -36,7 +36,7 @@ pub struct Tests<'a> {
 }
 impl<'a> Tests<'a> {
     /// Create a new unit tester
-    pub fn new() -> Tests {
+    pub fn new() -> Tests<'a> {
         Tests {
             context: Context::new()
         }
@@ -47,8 +47,8 @@ impl<'a> Tests<'a> {
             if args.len() < 2 {
                 return Err(to_value("'assert' function expects assertion and description arguments"));
             }
-            let val : bool = from_value(*args.get(0)).unwrap();
-            let desc : Value = *args.get(1);
+            let val : bool = from_value(args[0]).unwrap();
+            let desc : Value = args[1];
             if val {
                 Ok(desc)
             } else {

Diff for: src/lib/back/compiler.rs

@@ -24,7 +24,7 @@ pub struct JitCompiler<'a> {
 impl<'a> JitCompiler<'a> {
     /// Construct a new JIT Compiler on the given context
     pub fn new(context: &'a Context) -> JitCompiler<'a> {
-        let main_t = get_type::<fn(*const int, *const int, *const int) -> *const int>();
+        let main_t = get_type::<fn(*mut int, *mut int, *mut int) -> *mut int>();
         JitCompiler {
             curr: Function::new(context, main_t)
         }
@@ -33,21 +33,23 @@ impl<'a> JitCompiler<'a> {
         let bool_t = get_type::<bool>();
         let val_kind = val.get_type().get_kind();
         let convert = |v| self.curr.insn_convert(&v, bool_t.clone(), false);
-        if val_kind.contains(SysBool) {
-            val
-        } else if val_kind.contains(Float64) {
-            let zero = 0.0f64.compile(&self.curr);
-            let not_zero = self.curr.insn_neq(&val, &zero);
-            let not_nan = !self.curr.insn_is_nan(&val);
-            convert(not_zero & not_nan)
-        } else if val_kind.contains(Int) || val_kind.contains(UInt) || val_kind.contains(NInt) || val_kind.contains(NUInt) {
-            let zero = 0i.compile(&self.curr); 
-            convert(self.curr.insn_neq(&val, &zero))
-        } else if val_kind.contains(Pointer) {
-            let one = 1i.compile(&self.curr);
-            convert(self.curr.insn_gt(&val, &one))
-        } else {
-            convert(val)
+        match val_kind {
+            SysBool => val,
+            Float64 => {
+                let zero = 0.0f64.compile(&self.curr);
+                let not_zero = self.curr.insn_neq(&val, &zero);
+                let not_nan = !self.curr.insn_is_nan(&val);
+                convert(not_zero & not_nan)
+            },
+            Int | UInt | NInt | NUInt => {
+                let zero = 0i.compile(&self.curr); 
+                convert(self.curr.insn_neq(&val, &zero))
+            },
+            Pointer => {
+                let one = 1i.compile(&self.curr);
+                convert(self.curr.insn_gt(&val, &one))
+            },
+            _ => convert(val)
         }
     }
     fn undefined(&'a self) -> Value<'a> {
@@ -159,7 +161,7 @@ impl<'a> Compiler<'a, (Value<'a>, &'a Function<'a>)> for JitCompiler<'a> {
     }
     fn compile_return(&'a self, val:Option<Box<Expr>>) -> CompiledValue<'a> {
         match val {
-            Some(val) => {
+            Some(box ref val) => {
                 let (c_val, _) = self.compile(val);
                 self.curr.insn_return(&c_val)
             },

Diff for: src/lib/back/executor.rs

@@ -49,49 +49,54 @@ impl<'a> Executor<(JITVal<'a>, &'a Function<'a>)> for JitExecutor {
 fn convert_to_value<'a>(func:&Function<'a>, val:&'a JITVal<'a>) -> JITVal<'a> {
     let val_type = val.get_type();
     let val_kind = val_type.get_kind();
-    if val_kind.contains(SysBool) || val_kind.contains(UByte) {
-        let bool_value = to_value::<bool>;
-        let sig = get_type::<fn(bool) -> *const int>();
-        func.insn_call_native1(Some("bool_value"), bool_value, sig, &mut [val])
-    } else if val_kind.contains(Pointer) {
-        let ref_t = val_type.get_ref();
-        if ref_t.get_kind().contains(SysChar) {
-            fn string_value(val: &i8) -> JSVal {
-                unsafe {
-                    let text = CString::new(val, false);
-                    to_value(text.as_str().unwrap().into_string())
+    match val_kind {
+        SysBool | UByte => {
+            let bool_value = to_value::<bool>;
+            let sig = get_type::<fn(bool) -> &'static int>();
+            func.insn_call_native1(Some("bool_value"), bool_value, sig, [val])
+        },
+        Pointer => {
+            let ref_t = val_type.get_ref();
+            if ref_t.get_kind() == SysChar {
+                fn string_value(val: &i8) -> JSVal {
+                    unsafe {
+                        let text = CString::new(val, false);
+                        to_value(text.as_str().unwrap().into_string())
+                    }
                 }
-            }
-            let sig = get_type::<fn(String) -> *const int>();
-            func.insn_call_native1(Some("string_value"), string_value, sig, &mut [val])
-        } else {
-            fn ptr_value(ptr: &i8) -> JSVal {
-                match ptr.to_uint() {
-                    Some(0u) => JSVal::undefined(),
-                    Some(1u) => JSVal {
-                        ptr: box(GC) VNull
-                    },
-                    ptr => fail!("Invalid pointer: {}", ptr)
+                let sig = get_type::<fn(String) -> &'static int>();
+                func.insn_call_native1(Some("string_value"), string_value, sig, [val])
+            } else {
+                fn ptr_value(ptr: &i8) -> JSVal {
+                    match ptr.to_uint() {
+                        Some(0u) => JSVal::undefined(),
+                        Some(1u) => JSVal {
+                            ptr: box(GC) VNull
+                        },
+                        ptr => fail!("Invalid pointer: {}", ptr)
+                    }
                 }
+                let sig = get_type::<fn(&'static i8) -> &'static int>();
+                func.insn_call_native1(Some("ptr_value"), ptr_value, sig, [val])
             }
-            let sig = get_type::<fn(*const i8) -> *const int>();
-            func.insn_call_native1(Some("ptr_value"), ptr_value, sig, &mut [val])
-        }
-    } else if val_kind.contains(Int) || val_kind.contains(UInt) {
-        let int_value = to_value::<i32>;
-        let sig = get_type::<fn(i32) -> *const int>();
-        func.insn_call_native1(Some("int_value"), int_value, sig, &mut [val])
-    } else if val_kind.contains(NInt) || val_kind.contains(NUInt) {
-        fn sys_int_value(num:int) -> JSVal {
-            to_value::<i32>(num as i32)
-        }
-        let sig = get_type::<fn(int) -> *const int>();
-        func.insn_call_native1(Some("sys_int_value"), sys_int_value, sig, &mut [val])
-    } else if val_kind.contains(Float64) {
-        let float_value = to_value::<f64>;
-        let sig = get_type::<fn(f64) -> *const int>();
-        func.insn_call_native1(Some("float_value"), float_value, sig, &mut [val])
-    } else {
-        fail!("Invalid kind {}", val_kind.bits())
+        },
+        Int | UInt => {
+            let int_value = to_value::<i32>;
+            let sig = get_type::<fn(i32) -> &'static int>();
+            func.insn_call_native1(Some("int_value"), int_value, sig, [val])
+        },
+        NInt | NUInt => {
+            fn sys_int_value(num:int) -> JSVal {
+                to_value::<i32>(num as i32)
+            }
+            let sig = get_type::<fn(int) -> &'static int>();
+            func.insn_call_native1(Some("sys_int_value"), sys_int_value, sig, [val])
+        },
+        Float64 => {
+            let float_value = to_value::<f64>;
+            let sig = get_type::<fn(f64) -> &'static int>();
+            func.insn_call_native1(Some("float_value"), float_value, sig, [val])
+        },
+        _ => fail!("Unexpected type {}", val_kind)
     }
 }

Diff for: src/lib/front/run/compiler.rs

@@ -11,48 +11,48 @@ pub trait Compiler<'a, Compiled> {
     fn compile(&'a self, expr:&Expr) -> Compiled {
         debug!("Compiling {}", expr);
         match expr.def.clone() {
-            UnaryOpExpr(op, box ref ex) =>
-                self.compile_unary_op(op, ex),
-            BinOpExpr(op, box ref left, box ref right) =>
-                self.compile_bin_op(op, left, right),
+            UnaryOpExpr(op, box ex) =>
+                self.compile_unary_op(op, &ex),
+            BinOpExpr(op, box left, box right) =>
+                self.compile_bin_op(op, &left, &right),
             ConstExpr(ref c) =>
                 self.compile_const(c),
             LocalExpr(l) =>
                 self.compile_local(l),
             BlockExpr(vals) =>
                 self.compile_block(vals),
-            GetConstFieldExpr(box ref obj, field) =>
-                self.compile_get_const_field(obj, field),
-            GetFieldExpr(box ref obj, box ref field) =>
-                self.compile_get_field(obj, field),
-            CallExpr(box ref func, args) =>
-                self.compile_call(func, args),
-            WhileLoopExpr(box ref cond, box ref expr) =>
-                self.compile_while_loop(cond, expr),
-            IfExpr(box ref cond, box ref if_expr, else_expr) =>
-                self.compile_if(cond, if_expr, else_expr),
-            SwitchExpr(box ref value, cases, default) =>
-                self.compile_switch(value, cases, default),
-            ObjectDeclExpr(box ref fields) =>
-                self.compile_object_decl(fields),
+            GetConstFieldExpr(box obj, field) =>
+                self.compile_get_const_field(&obj, field),
+            GetFieldExpr(box obj, box field) =>
+                self.compile_get_field(&obj, &field),
+            CallExpr(box func, args) =>
+                self.compile_call(&func, args),
+            WhileLoopExpr(box cond, box expr) =>
+                self.compile_while_loop(&cond, &expr),
+            IfExpr(box cond, box if_expr, else_expr) =>
+                self.compile_if(&cond, &if_expr, else_expr),
+            SwitchExpr(box value, cases, default) =>
+                self.compile_switch(&value, cases, default),
+            ObjectDeclExpr(box fields) =>
+                self.compile_object_decl(&fields),
             ArrayDeclExpr(values) =>
                 self.compile_array_decl(values),
-            FunctionDeclExpr(name, args, box ref ret) =>
-                self.compile_function_decl(name, args, ret),
-            ArrowFunctionDeclExpr(args, box ref ret) =>
-                self.compile_arrow_function_decl(args, ret),
-            ConstructExpr(box ref func, args) =>
-                self.compile_construct(func, args),
+            FunctionDeclExpr(name, args, box ret) =>
+                self.compile_function_decl(name, args, &ret),
+            ArrowFunctionDeclExpr(args, box ret) =>
+                self.compile_arrow_function_decl(args, &ret),
+            ConstructExpr(box func, args) =>
+                self.compile_construct(&func, args),
             ReturnExpr(val) =>
                 self.compile_return(val),
-            ThrowExpr(box ref val) =>
-                self.compile_throw(val),
-            AssignExpr(box ref left, box ref right) =>
-                self.compile_assign(left, right),
+            ThrowExpr(box val) =>
+                self.compile_throw(&val),
+            AssignExpr(box left, box right) =>
+                self.compile_assign(&left, &right),
             VarDeclExpr(vars) =>
                 self.compile_var_decl(vars),
-            TypeOfExpr(box ref expr) =>
-                self.compile_typeof(expr)
+            TypeOfExpr(box expr) =>
+                self.compile_typeof(&expr)
         }
     }
     /// Compile a unary operation

Diff for: src/lib/front/stdlib/console.rs

@@ -13,7 +13,7 @@ pub fn error(args:Vec<Value>, _:Value, _:Value, _:Value) -> ResultValue {
     let args : Vec<String> = args.iter().map(|x|from_value::<String>(*x).unwrap()).collect();
     match writeln!(&mut stderr().unwrap(), "{}: {}", strftime("%X", &now()), args.connect(" ")) {
         Ok(_) => Ok(Value::undefined()),
-        Err(io_error) => Err(to_value(io_error.to_str()))
+        Err(io_error) => Err(to_value(io_error.to_string()))
     }
 }
 /// Create a new `console` object

Diff for: src/lib/front/stdlib/error.rs

@@ -5,7 +5,7 @@ use front::stdlib::function::Function;
 /// Create a new error
 pub fn make_error(args:Vec<Value>, _:Value, _:Value, this:Value) -> ResultValue {
     if args.len() >= 1 {
-        this.set_field("message", to_value(args.get(0).to_str().into_string()));
+        this.set_field("message", args[0]);
     }
     Ok(Value::undefined())
 }

Diff for: src/lib/front/stdlib/json.rs

@@ -3,18 +3,19 @@ use front::stdlib::function::Function;
 use serialize::json::{ToJson, from_str};
 /// Parse a JSON string into a Javascript object
 pub fn parse(args:Vec<Value>, _:Value, _:Value, _:Value) -> ResultValue {
-    match from_str(args.get(0).to_str().as_slice()) {
+    let arg = args[0];
+    match from_str(arg.to_string().as_slice()) {
         Ok(json) => {
             Ok(to_value(json))
         },
         Err(err) => {
-            Err(to_value(err.to_str()))
+            Err(to_value(err.to_string()))
         }
     }
 }
 /// Process a Javascript object into a JSON string
 pub fn stringify(args:Vec<Value>, _:Value, _:Value, _:Value) -> ResultValue {
-    let obj = args.get(0);
+    let obj = args[0];
     let json = obj.to_json();
     Ok(to_value(json.to_pretty_str()))
 }