Merge branch 'master' of https://github.com/ratel-rust/ratel-core into parenfix

Author: maciejhirsz

core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ratel"
-version = "0.5.0"
+version = "0.5.2"
 authors = ["Maciej Hirsz <[email protected]>"]
 license = "MIT/Apache-2.0"
 description = "JavaScript transpiler in Rust"

core/src/codegen.rs

@@ -255,7 +255,7 @@ impl Code for Value {
             Value::Null                => gen.write_bytes(b"null"),
             Value::True                => gen.write_min(b"true", b"!0",),
             Value::False               => gen.write_min(b"false", b"!1"),
-            Value::Integer(ref num)    => gen.write(num),
+            Value::Binary(ref num)     => gen.write(num),
             Value::Number(ref num)     => gen.write(num),
             Value::String(ref string)  => gen.write(string),
             Value::RawQuasi(ref quasi) => write_quasi(gen, *quasi),
@@ -271,7 +271,7 @@ impl Code for ObjectMember {
                 ref key
             } => gen.write(key),
 
-            ObjectMember::Literal {
+            ObjectMember::Value {
                 ref key,
                 ref value,
             } => {
@@ -280,42 +280,39 @@ impl Code for ObjectMember {
                 gen.write(value);
             },
 
-            ObjectMember::Computed {
-                ref key,
-                ref value,
-            } => {
-                gen.write_byte(b'[');
-                gen.write(key);
-                gen.write_min(b"]: ", b"]:");
-                gen.write(value);
-            },
-
             ObjectMember::Method {
-                ref name,
+                ref key,
                 ref params,
                 ref body,
             } => {
-                gen.write(name);
+                gen.write(key);
                 gen.write_byte(b'(');
                 gen.write_list(params);
                 gen.write_min(b") {", b"){");
                 gen.write_block(body);
                 gen.write_byte(b'}');
             },
+        }
+    }
+}
 
-            ObjectMember::ComputedMethod {
-                ref name,
-                ref params,
-                ref body,
-            } => {
+impl Code for ObjectKey {
+    #[inline]
+    fn to_code(&self, gen: &mut Generator) {
+        match *self {
+            ObjectKey::Computed (ref expression) => {
                 gen.write_byte(b'[');
-                gen.write(name);
-                gen.write_bytes(b"](");
-                gen.write_list(params);
-                gen.write_min(b") {", b"){");
-                gen.write_block(body);
-                gen.write_byte(b'}');
+                gen.write(expression);
+                gen.write_byte(b']');
             },
+
+            ObjectKey::Literal (ref slice) => {
+                gen.write(slice);
+            },
+
+            ObjectKey::Binary (ref num) => {
+                gen.write(num)
+            }
         }
     }
 }

core/src/grammar.rs

@@ -6,12 +6,13 @@ pub enum Value {
     Null,
     True,
     False,
-    Integer(u64),
     Number(OwnedSlice),
+    Binary(u64),
     String(OwnedSlice),
     RawQuasi(OwnedSlice),
 }
 
+
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub struct Parameter {
     pub name: OwnedSlice,
@@ -370,24 +371,22 @@ pub enum ObjectMember {
     Shorthand {
         key: OwnedSlice,
     },
-    Literal {
-        key: OwnedSlice,
-        value: Expression,
-    },
-    Computed {
-        key: Expression,
+    Value {
+        key: ObjectKey,
         value: Expression,
     },
     Method {
-        name: OwnedSlice,
+        key: ObjectKey,
         params: Vec<Parameter>,
         body: Vec<Statement>,
     },
-    ComputedMethod {
-        name: Expression,
-        params: Vec<Parameter>,
-        body: Vec<Statement>,
-    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum ObjectKey {
+    Computed(Expression),
+    Literal(OwnedSlice),
+    Binary(u64),
 }
 
 #[derive(Debug, PartialEq, Clone)]

core/src/parser.rs

@@ -172,22 +172,28 @@ impl<'a> Parser<'a> {
     #[inline]
     fn object_member(&mut self, token: Token) -> Result<ObjectMember> {
         Ok(match token {
-            Identifier(key) | Literal(Value::String(key)) => {
+
+            Identifier(key)             |
+            Literal(Value::String(key)) |
+            Literal(Value::Number(key)) => {
+
                 match peek!(self) {
                     Colon => {
                         self.consume();
+                        let key = ObjectKey::Literal(key);
 
-                        ObjectMember::Literal {
+                        ObjectMember::Value {
                             key: key,
                             value: try!(self.expression(0)),
                         }
                     },
 
                     ParenOpen => {
                         self.consume();
+                        let key = ObjectKey::Literal(key);
 
                         ObjectMember::Method {
-                            name: key,
+                            key: key,
                             params: try!(self.parameter_list()),
                             body: try!(self.block_body())
                         }
@@ -198,18 +204,43 @@ impl<'a> Parser<'a> {
                     }
                 }
             },
+            Literal(Value::Binary(num)) => {
+                let key = ObjectKey::Binary(num);
+                match peek!(self) {
+                    Colon => {
+                        self.consume();
+
+                        ObjectMember::Value {
+                            key: key,
+                            value: try!(self.expression(0)),
+                        }
+                    },
+
+                    ParenOpen => {
+                        self.consume();
+
+                        ObjectMember::Method {
+                            key: key,
+                            params: try!(self.parameter_list()),
+                            body: try!(self.block_body())
+                        }
+                    },
+
+                    _ => unexpected_token!(self)
+                }
+            },
             BracketOpen => {
-                let key = try!(self.expression(0));
+                let key = ObjectKey::Computed(try!(self.expression(0)));
 
                 expect!(self, BracketClose);
 
                 match next!(self) {
-                    Colon => ObjectMember::Computed {
+                    Colon => ObjectMember::Value {
                         key: key,
                         value: try!(self.expression(0)),
                     },
-                    ParenOpen => ObjectMember::ComputedMethod {
-                        name: key,
+                    ParenOpen => ObjectMember::Method {
+                        key: key,
                         params: try!(self.parameter_list()),
                         body: try!(self.block_body()),
                     },

core/src/tokenizer.rs

@@ -668,13 +668,13 @@ define_handlers! {
             b'o' | b'O' => {
                 tok.bump();
 
-                return Ok(Literal(tok.read_octal()));
+                return Ok(Literal(tok.read_octal(start)));
             },
 
             b'x' | b'X' => {
                 tok.bump();
 
-                return Ok(Literal(tok.read_hexadec()));
+                return Ok(Literal(tok.read_hexadec(start)));
             },
 
             _ => {}
@@ -1034,60 +1034,49 @@ impl<'a> Tokenizer<'a> {
             }
         }
 
-        Value::Integer(value)
+        Value::Binary(value)
     }
 
     #[inline]
-    fn read_octal(&mut self) -> Value {
-        let mut value = 0;
+    fn consume_label_characters(&mut self) -> &str {
+        let start = self.index;
 
-        while !self.is_eof() {
-            let peek = self.read_byte();
-            let digit = match peek {
-                b'0'...b'7' => peek - b'0',
-                _           => break
-            };
+        self.bump();
 
-            value = (value << 3) + digit as u64;
+        while !self.is_eof() && ident_lookup::TABLE[self.read_byte() as usize] {
             self.bump();
         }
 
-        Value::Integer(value)
+        unsafe {
+            self.source.slice_unchecked(start, self.index)
+        }
     }
 
     #[inline]
-    fn read_hexadec(&mut self) -> Value {
-        let mut value = 0;
+    fn read_octal(&mut self, start: usize) -> Value {
 
         while !self.is_eof() {
-            let peek = self.read_byte();
-            let digit = match peek {
-                b'0'...b'9' => peek - b'0',
-                b'a'...b'f' => peek - b'a' + 10,
-                b'A'...b'F' => peek - b'A' + 10,
+            match self.read_byte() {
+                b'0'...b'7' => self.bump(),
                 _           => break
             };
-
-            value = (value << 4) + digit as u64;
-            self.bump();
         }
 
-        Value::Integer(value)
+        Value::Number(self.slice_source(start, self.index))
     }
 
     #[inline]
-    fn consume_label_characters(&mut self) -> &str {
-        let start = self.index;
-
-        self.bump();
-
-        while !self.is_eof() && ident_lookup::TABLE[self.read_byte() as usize] {
-            self.bump();
+    fn read_hexadec(&mut self, start: usize) -> Value {
+        while !self.is_eof() {
+            match self.read_byte() {
+                b'0'...b'9' => self.bump(),
+                b'a'...b'f' => self.bump(),
+                b'A'...b'F' => self.bump(),
+                _           => break
+            };
         }
 
-        unsafe {
-            self.source.slice_unchecked(start, self.index)
-        }
+        Value::Number(self.slice_source(start, self.index))
     }
 
     #[inline]
@@ -1104,5 +1093,4 @@ impl<'a> Tokenizer<'a> {
 
         Value::Number(value)
     }
-
 }