Resolved boa-dev#359

Removed Node::TypeOf, implemented UnaryOp::TypeOf, and added tests

boa/src/builtins/value/mod.rs

@@ -700,27 +700,6 @@ impl ValueData {
             Self::Integer(val) => JSONValue::Number(JSONNumber::from(val)),
         }
     }
-
-    /// Get the type of the value
-    ///
-    /// https://tc39.es/ecma262/#sec-typeof-operator
-    pub fn get_type(&self) -> &'static str {
-        match *self {
-            Self::Rational(_) | Self::Integer(_) => "number",
-            Self::String(_) => "string",
-            Self::Boolean(_) => "boolean",
-            Self::Symbol(_) => "symbol",
-            Self::Null => "null",
-            Self::Undefined => "undefined",
-            Self::Object(ref o) => {
-                if o.deref().borrow().is_callable() {
-                    "function"
-                } else {
-                    "object"
-                }
-            }
-        }
-    }
 }
 
 impl Default for ValueData {

boa/src/exec/mod.rs

@@ -420,11 +420,24 @@ impl Executor for Interpreter {
                         | Node::FunctionExpr(_, _, _)
                         | Node::New(_)
                         | Node::Object(_)
-                        | Node::TypeOf(_)
                         | Node::UnaryOp(_, _) => Value::boolean(true),
                         _ => panic!("SyntaxError: wrong delete argument {}", node),
                     },
-                    _ => unimplemented!(),
+                    UnaryOp::TypeOf => Value::from(match v_a.data() {
+                        ValueData::Undefined => "undefined",
+                        ValueData::Symbol(_) => "symbol",
+                        ValueData::Null => "object",
+                        ValueData::Boolean(_) => "boolean",
+                        ValueData::Rational(_) | ValueData::Integer(_) => "number",
+                        ValueData::String(_) => "string",
+                        ValueData::Object(ref o) => {
+                            if o.deref().borrow().is_callable() {
+                                "function"
+                            } else {
+                                "object"
+                            }
+                        }
+                    }),
                 })
             }
             Node::BinOp(BinOp::Bit(ref op), ref a, ref b) => {
@@ -607,24 +620,6 @@ impl Executor for Interpreter {
                 }
                 Ok(Value::undefined())
             }
-            Node::TypeOf(ref val_e) => {
-                let val = self.run(val_e)?;
-                Ok(Value::from(match *val {
-                    ValueData::Undefined => "undefined",
-                    ValueData::Symbol(_) => "symbol",
-                    ValueData::Null => "object",
-                    ValueData::Boolean(_) => "boolean",
-                    ValueData::Rational(_) | ValueData::Integer(_) => "number",
-                    ValueData::String(_) => "string",
-                    ValueData::Object(ref o) => {
-                        if o.deref().borrow().is_callable() {
-                            "function"
-                        } else {
-                            "object"
-                        }
-                    }
-                }))
-            }
             Node::StatementList(ref list) => {
                 {
                     let env = &mut self.realm.environment;

boa/src/exec/tests.rs

@@ -385,6 +385,63 @@ fn unary_pre() {
     assert_eq!(&exec(execs_before_dec), "true");
 }
 
+#[test]
+fn unary_typeof() {
+    let typeof_string = r#"
+        const a = String();
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_string), "string");
+
+    let typeof_int = r#"
+        let a = 5;
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_int), "number");
+
+    let typeof_rational = r#"
+        let a = 0.5;
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_rational), "number");
+
+    let typeof_undefined = r#"
+        let a = undefined;
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_undefined), "undefined");
+
+    let typeof_boolean = r#"
+        let a = true;
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_boolean), "boolean");
+
+    let typeof_null = r#"
+        let a = null;
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_null), "object");
+
+    let typeof_object = r#"
+        let a = {};
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_object), "object");
+
+    let typeof_symbol = r#"
+        let a = Symbol();
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_symbol), "symbol");
+
+    let typeof_function = r#"
+        let a = function(){};
+        typeof a;
+    "#;
+    assert_eq!(&exec(typeof_function), "function");
+}
+
 #[test]
 fn unary_post() {
     let unary_inc = r#"

boa/src/syntax/ast/node.rs

@@ -469,20 +469,6 @@ pub enum Node {
     /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw
     Throw(Box<Node>),
 
-    /// The `typeof` operator returns a string indicating the type of the unevaluated operand.
-    ///
-    /// Syntax: `typeof operand`
-    ///
-    /// Returns a string indicating the type of the unevaluated operand.
-    ///
-    /// More information:
-    ///  - [ECMAScript reference][spec]
-    ///  - [MDN documentation][mdn]
-    ///
-    /// [spec]: https://tc39.es/ecma262/#sec-typeof-operator
-    /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
-    TypeOf(Box<Node>),
-
     /// The `try...catch` statement marks a block of statements to try and specifies a response
     /// should an exception be thrown.
     ///
@@ -564,7 +550,7 @@ pub enum Node {
 impl Operator for Node {
     fn get_assoc(&self) -> bool {
         match *self {
-            Self::UnaryOp(_, _) | Self::TypeOf(_) | Self::If(_, _, _) | Self::Assign(_, _) => false,
+            Self::UnaryOp(_, _) | Self::If(_, _, _) | Self::Assign(_, _) => false,
             _ => true,
         }
     }
@@ -580,7 +566,7 @@ impl Operator for Node {
             Self::UnaryOp(UnaryOp::Not, _)
             | Self::UnaryOp(UnaryOp::Tilde, _)
             | Self::UnaryOp(UnaryOp::Minus, _)
-            | Self::TypeOf(_) => 4,
+            | Self::UnaryOp(UnaryOp::TypeOf, _) => 4,
             Self::BinOp(op, _, _) => op.get_precedence(),
             Self::If(_, _, _) => 15,
             // 16 should be yield
@@ -848,14 +834,6 @@ impl Node {
         Self::Throw(val.into())
     }
 
-    /// Creates a `TypeOf` AST node.
-    pub fn type_of<E>(expr: E) -> Self
-    where
-        E: Into<Box<Self>>,
-    {
-        Self::TypeOf(expr.into())
-    }
-
     /// Creates a `Try` AST node.
     pub fn try_node<T, OC, OP, OF, C, P, F>(try_node: T, catch: OC, param: OP, finally: OF) -> Self
     where
@@ -1116,7 +1094,6 @@ impl Node {
                 }
                 Ok(())
             }
-            Self::TypeOf(ref e) => write!(f, "typeof {}", e),
         }
     }
 }