remove over-generalized helper for expression!

Add a test for props up the prototype chain. It is currently failing,
but should be passing for this to be complete.

boa/src/exec/tests.rs

@@ -365,6 +365,16 @@ mod in_operator {
         assert_eq!(exec(p_in_o), String::from("true"));
     }
 
+    #[test]
+    fn test_p_in_property_chain() {
+        let p_in_o = r#"
+            var o = {};
+            var p = 'toString';
+            p in o
+        "#;
+        assert_eq!(exec(p_in_o), String::from("true"));
+    }
+
     #[test]
     fn test_p_not_in_o() {
         let p_not_in_o = r#"

boa/src/syntax/parser/expression/mod.rs

@@ -18,10 +18,7 @@ mod update;
 use self::assignment::ExponentiationExpression;
 pub(super) use self::{assignment::AssignmentExpression, primary::Initializer};
 use super::{AllowAwait, AllowIn, AllowYield, Cursor, ParseResult, TokenParser};
-use crate::syntax::ast::{
-    keyword::Keyword, node::Node, op::BinOp, punc::Punctuator, token::TokenKind,
-};
-use std::{convert::TryInto, fmt::Debug};
+use crate::syntax::ast::{keyword::Keyword, node::Node, punc::Punctuator, token::TokenKind};
 
 // For use in the expression! macro to allow for both Punctuator and Keyword parameters.
 // Always returns false.
@@ -47,23 +44,6 @@ impl PartialEq<Punctuator> for Keyword {
 ///
 /// Those exressions are divided by the punctuators passed as the third parameter.
 macro_rules! expression { ($name:ident, $lower:ident, [$( $op:path ),*], [$( $low_param:ident ),*] ) => {
-    impl $name {
-        // Helper method to build a BinOp in the parse method
-        fn build_op<O, L>(&self, op: O, lhs: L, cursor: &mut Cursor<'_>) -> ParseResult
-        where
-            O: TryInto<BinOp>,
-            <O as TryInto<BinOp>>::Error: Debug, // for call to `expect`
-            L: Into<Box<Node>>
-        {
-            let _ = cursor.next().expect("token disappeared");
-            Ok(Node::bin_op(
-                op.try_into().expect("Could not get binary operation."),
-                lhs,
-                $lower::new($( self.$low_param ),*).parse(cursor)?
-            ))
-        }
-    }
-
     impl TokenParser for $name {
         type Output = Node;
 
@@ -72,10 +52,20 @@ macro_rules! expression { ($name:ident, $lower:ident, [$( $op:path ),*], [$( $lo
             while let Some(tok) = cursor.peek(0) {
                 match tok.kind {
                     TokenKind::Punctuator(op) if $( op == $op )||* => {
-                        lhs = self.build_op(op, lhs, cursor)?;
+                        let _ = cursor.next().expect("token disappeared");
+                        lhs = Node::bin_op(
+                            op.as_binop().expect("Could not get binary operation."),
+                            lhs,
+                            $lower::new($( self.$low_param ),*).parse(cursor)?
+                        )
                     }
                     TokenKind::Keyword(op) if $( op == $op )||* => {
-                        lhs = self.build_op(op, lhs, cursor)?;
+                        let _ = cursor.next().expect("token disappeared");
+                        lhs = Node::bin_op(
+                            op.as_binop().expect("Could not get binary operation."),
+                            lhs,
+                            $lower::new($( self.$low_param ),*).parse(cursor)?
+                        )
                     }
                     _ => break
                 }