[Merged by Bors] - Implement AST Visitor pattern (attempt #3)

boa_engine/src/syntax/ast/declaration/mod.rs

@@ -20,10 +20,12 @@ use super::{
     ContainsSymbol,
 };
 use boa_interner::{Interner, ToIndentedString, ToInternedString};
+use core::ops::ControlFlow;
 use tap::Tap;
 
 mod variable;
 
+use crate::syntax::ast::visitor::{VisitWith, Visitor, VisitorMut};
 pub use variable::*;
 
 /// The `Declaration` Parse Node.
@@ -165,3 +167,33 @@ impl ToIndentedString for Declaration {
         }
     }
 }
+
+impl VisitWith for Declaration {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        match self {
+            Declaration::Function(f) => visitor.visit_function(f),
+            Declaration::Generator(g) => visitor.visit_generator(g),
+            Declaration::AsyncFunction(af) => visitor.visit_async_function(af),
+            Declaration::AsyncGenerator(ag) => visitor.visit_async_generator(ag),
+            Declaration::Class(c) => visitor.visit_class(c),
+            Declaration::Lexical(ld) => visitor.visit_lexical_declaration(ld),
+        }
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        match self {
+            Declaration::Function(f) => visitor.visit_function_mut(f),
+            Declaration::Generator(g) => visitor.visit_generator_mut(g),
+            Declaration::AsyncFunction(af) => visitor.visit_async_function_mut(af),
+            Declaration::AsyncGenerator(ag) => visitor.visit_async_generator_mut(ag),
+            Declaration::Class(c) => visitor.visit_class_mut(c),
+            Declaration::Lexical(ld) => visitor.visit_lexical_declaration_mut(ld),
+        }
+    }
+}

boa_engine/src/syntax/ast/declaration/variable.rs

@@ -1,13 +1,16 @@
 //! Variable related declarations.
 
 use std::convert::TryFrom;
+use std::ops::ControlFlow;
 
+use crate::syntax::ast::visitor::{VisitWith, Visitor, VisitorMut};
 use crate::syntax::ast::{
     expression::{Expression, Identifier},
     join_nodes,
     pattern::Pattern,
     ContainsSymbol, Statement,
 };
+use crate::try_break;
 use boa_interner::{Interner, ToInternedString};
 
 use super::Declaration;
@@ -68,6 +71,22 @@ impl ToInternedString for VarDeclaration {
     }
 }
 
+impl VisitWith for VarDeclaration {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        visitor.visit_variable_list(&self.0)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        visitor.visit_variable_list_mut(&mut self.0)
+    }
+}
+
 /// A **[lexical declaration]** defines variables that are scoped to the lexical environment of
 /// the variable declaration.
 ///
@@ -141,6 +160,30 @@ impl ToInternedString for LexicalDeclaration {
     }
 }
 
+impl VisitWith for LexicalDeclaration {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        match self {
+            LexicalDeclaration::Const(vars) | LexicalDeclaration::Let(vars) => {
+                visitor.visit_variable_list(vars)
+            }
+        }
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        match self {
+            LexicalDeclaration::Const(vars) | LexicalDeclaration::Let(vars) => {
+                visitor.visit_variable_list_mut(vars)
+            }
+        }
+    }
+}
+
 /// List of variables in a variable declaration.
 #[cfg_attr(feature = "deser", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, Debug, PartialEq)]
@@ -171,6 +214,28 @@ impl ToInternedString for VariableList {
     }
 }
 
+impl VisitWith for VariableList {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        for variable in self.list.iter() {
+            try_break!(visitor.visit_variable(variable));
+        }
+        ControlFlow::Continue(())
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        for variable in self.list.iter_mut() {
+            try_break!(visitor.visit_variable_mut(variable));
+        }
+        ControlFlow::Continue(())
+    }
+}
+
 /// The error returned by the [`VariableList::try_from`] function.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct TryFromVariableListError(());
@@ -288,6 +353,30 @@ impl Variable {
     }
 }
 
+impl VisitWith for Variable {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        try_break!(visitor.visit_binding(&self.binding));
+        if let Some(init) = &self.init {
+            try_break!(visitor.visit_expression(init));
+        }
+        ControlFlow::Continue(())
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        try_break!(visitor.visit_binding_mut(&mut self.binding));
+        if let Some(init) = &mut self.init {
+            try_break!(visitor.visit_expression_mut(init));
+        }
+        ControlFlow::Continue(())
+    }
+}
+
 /// Binding represents either an individual binding or a binding pattern.
 ///
 /// More information:
@@ -348,6 +437,28 @@ impl ToInternedString for Binding {
     }
 }
 
+impl VisitWith for Binding {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        match self {
+            Binding::Identifier(id) => visitor.visit_identifier(id),
+            Binding::Pattern(pattern) => visitor.visit_pattern(pattern),
+        }
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        match self {
+            Binding::Identifier(id) => visitor.visit_identifier_mut(id),
+            Binding::Pattern(pattern) => visitor.visit_pattern_mut(pattern),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[test]

boa_engine/src/syntax/ast/expression/access.rs

@@ -14,8 +14,11 @@
 //! [spec]: https://tc39.es/ecma262/multipage/ecmascript-language-expressions.html#sec-property-accessors
 //! [access]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors
 
+use crate::syntax::ast::visitor::{VisitWith, Visitor, VisitorMut};
 use crate::syntax::ast::{expression::Expression, ContainsSymbol};
+use crate::try_break;
 use boa_interner::{Interner, Sym, ToInternedString};
+use std::ops::ControlFlow;
 
 /// A property access field.
 ///
@@ -59,6 +62,28 @@ impl From<Expression> for PropertyAccessField {
     }
 }
 
+impl VisitWith for PropertyAccessField {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        match self {
+            PropertyAccessField::Const(sym) => visitor.visit_sym(sym),
+            PropertyAccessField::Expr(expr) => visitor.visit_expression(&*expr),
+        }
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        match self {
+            PropertyAccessField::Const(sym) => visitor.visit_sym_mut(sym),
+            PropertyAccessField::Expr(expr) => visitor.visit_expression_mut(&mut *expr),
+        }
+    }
+}
+
 /// A property access expression.
 ///
 /// See the [module level documentation][self] for more information.
@@ -111,6 +136,30 @@ impl From<PropertyAccess> for Expression {
     }
 }
 
+impl VisitWith for PropertyAccess {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        match self {
+            PropertyAccess::Simple(spa) => visitor.visit_simple_property_access(spa),
+            PropertyAccess::Private(ppa) => visitor.visit_private_property_access(ppa),
+            PropertyAccess::Super(supa) => visitor.visit_super_property_access(supa),
+        }
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        match self {
+            PropertyAccess::Simple(spa) => visitor.visit_simple_property_access_mut(spa),
+            PropertyAccess::Private(ppa) => visitor.visit_private_property_access_mut(ppa),
+            PropertyAccess::Super(supa) => visitor.visit_super_property_access_mut(supa),
+        }
+    }
+}
+
 /// A simple property access, where the target object is an [`Expression`].
 #[cfg_attr(feature = "deser", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, Debug, PartialEq)]
@@ -175,6 +224,24 @@ impl From<SimplePropertyAccess> for PropertyAccess {
     }
 }
 
+impl VisitWith for SimplePropertyAccess {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        try_break!(visitor.visit_expression(&*self.target));
+        visitor.visit_property_access_field(&self.field)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        try_break!(visitor.visit_expression_mut(&mut *self.target));
+        visitor.visit_property_access_field_mut(&mut self.field)
+    }
+}
+
 /// An access expression to a class object's [private fields][mdn].
 ///
 /// Private property accesses differ slightly from plain property accesses, since the accessed
@@ -243,6 +310,24 @@ impl From<PrivatePropertyAccess> for PropertyAccess {
     }
 }
 
+impl VisitWith for PrivatePropertyAccess {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        try_break!(visitor.visit_expression(&*self.target));
+        visitor.visit_sym(&self.field)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        try_break!(visitor.visit_expression_mut(&mut *self.target));
+        visitor.visit_sym_mut(&mut self.field)
+    }
+}
+
 /// A property access of an object's parent, as defined by the [spec].
 ///
 /// A `SuperPropertyAccess` is much like a regular [`PropertyAccess`], but where its `target` object
@@ -298,3 +383,19 @@ impl From<SuperPropertyAccess> for PropertyAccess {
         Self::Super(access)
     }
 }
+
+impl VisitWith for SuperPropertyAccess {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        visitor.visit_property_access_field(&self.field)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        visitor.visit_property_access_field_mut(&mut self.field)
+    }
+}

boa_engine/src/syntax/ast/expression/await.rs

@@ -1,8 +1,10 @@
 //! Await expression Expression.
 
 use crate::syntax::ast::ContainsSymbol;
+use std::ops::ControlFlow;
 
 use super::Expression;
+use crate::syntax::ast::visitor::{VisitWith, Visitor, VisitorMut};
 use boa_interner::{Interner, ToIndentedString, ToInternedString};
 
 /// An await expression is used within an async function to pause execution and wait for a
@@ -62,6 +64,22 @@ impl From<Await> for Expression {
     }
 }
 
+impl VisitWith for Await {
+    fn visit_with<'a, V>(&'a self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: Visitor<'a>,
+    {
+        visitor.visit_expression(&*self.target)
+    }
+
+    fn visit_with_mut<'a, V>(&'a mut self, visitor: &mut V) -> ControlFlow<V::BreakTy>
+    where
+        V: VisitorMut<'a>,
+    {
+        visitor.visit_expression_mut(&mut *self.target)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[test]