[−][src]Trait binjs::specialized::es6::ast::Walker

pub trait Walker<'a> {
    type Output;
    fn walk<V, E, G>(
        &'a mut self, 
        path: &mut Path<ASTNode, ASTField>, 
        visitor: &mut V
    ) -> Result<Option<Self::Output>, E>
    where
        G: WalkGuard<V>,
        V: Visitor<E, G>;
}

Associated Types

`type Output`

Loading content...

Required methods

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Self::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,`

Loading content...

Implementations on Foreign Types

`impl<'a> Walker<'a> for Vec<VariableDeclarator>`[src]

`type Output = Vec<VariableDeclarator>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<VariableDeclarator>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssertedMaybePositionalParameterName>`[src]

`type Output = Vec<AssertedMaybePositionalParameterName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssertedMaybePositionalParameterName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssignmentTargetProperty>`[src]

`type Output = Vec<AssignmentTargetProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssignmentTargetProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for f64`[src]

`type Output = f64`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<f64>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssertedDeclaredName>`[src]

`type Output = Vec<AssertedDeclaredName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssertedDeclaredName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ObjectProperty>`[src]

`type Output = Vec<ObjectProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ObjectProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssertedBoundName>`[src]

`type Output = Vec<AssertedBoundName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssertedBoundName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Parameter>`[src]

`type Output = Vec<Parameter>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Parameter>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ImportSpecifier>`[src]

`type Output = Vec<ImportSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ImportSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExportDeclarationOrImportDeclarationOrStatement>`[src]

`type Output = Vec<ExportDeclarationOrImportDeclarationOrStatement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExportDeclarationOrImportDeclarationOrStatement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Option<ExpressionOrSpreadElement>>`[src]

`type Output = Vec<Option<ExpressionOrSpreadElement>>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Option<ExpressionOrSpreadElement>>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<SwitchCase>`[src]

`type Output = Vec<SwitchCase>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<SwitchCase>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Directive>`[src]

`type Output = Vec<Directive>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Directive>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExportLocalSpecifier>`[src]

`type Output = Vec<ExportLocalSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExportLocalSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Statement>`[src]

`type Output = Vec<Statement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Statement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ClassElement>`[src]

`type Output = Vec<ClassElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ClassElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Option<BindingOrBindingWithInitializer>>`[src]

`type Output = Vec<Option<BindingOrBindingWithInitializer>>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Option<BindingOrBindingWithInitializer>>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExportFromSpecifier>`[src]

`type Output = Vec<ExportFromSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExportFromSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExpressionOrSpreadElement>`[src]

`type Output = Vec<ExpressionOrSpreadElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExpressionOrSpreadElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<BindingProperty>`[src]

`type Output = Vec<BindingProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<BindingProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for u32`[src]

`type Output = u32`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<u32>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for bool`[src]

`type Output = bool`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<bool>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExpressionOrTemplateElement>`[src]

`type Output = Vec<ExpressionOrTemplateElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExpressionOrTemplateElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssignmentTargetOrAssignmentTargetWithInitializer>`[src]

`type Output = Vec<AssignmentTargetOrAssignmentTargetWithInitializer>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssignmentTargetOrAssignmentTargetWithInitializer>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

Loading content...

Implementors

`impl<'a> Walker<'a> for ArrowExpression`[src]

`type Output = ArrowExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrowExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedDeclaredKind where AssertedDeclaredKind: 'a,` [src]

`type Output = AssertedDeclaredKind`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<AssertedDeclaredKind as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedMaybePositionalParameterName`[src]

`type Output = AssertedMaybePositionalParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedMaybePositionalParameterName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTarget`[src]

`type Output = AssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetOrAssignmentTargetWithInitializer`[src]

`type Output = AssignmentTargetOrAssignmentTargetWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetOrAssignmentTargetWithInitializer>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetOrForInOfBinding`[src]

`type Output = AssignmentTargetOrForInOfBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetOrForInOfBinding>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetPattern`[src]

`type Output = AssignmentTargetPattern`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetPattern>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetProperty`[src]

`type Output = AssignmentTargetProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BinaryOperator where BinaryOperator: 'a,` [src]

`type Output = BinaryOperator`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<BinaryOperator as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Binding`[src]

`type Output = Binding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Binding>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BindingOrBindingWithInitializer`[src]

`type Output = BindingOrBindingWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingOrBindingWithInitializer>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BindingPattern`[src]

`type Output = BindingPattern`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingPattern>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BindingProperty`[src]

`type Output = BindingProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ClassDeclarationOrExpressionOrFunctionDeclaration`[src]

`type Output = ClassDeclarationOrExpressionOrFunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ClassDeclarationOrFunctionDeclarationOrVariableDeclaration`[src]

`type Output = ClassDeclarationOrFunctionDeclarationOrVariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for CompoundAssignmentOperator where CompoundAssignmentOperator: 'a,` [src]

`type Output = CompoundAssignmentOperator`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<CompoundAssignmentOperator as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportDeclaration`[src]

`type Output = ExportDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportDeclarationOrImportDeclarationOrStatement`[src]

`type Output = ExportDeclarationOrImportDeclarationOrStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportDeclarationOrImportDeclarationOrStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Expression`[src]

`type Output = Expression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Expression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExpressionOrSpreadElement`[src]

`type Output = ExpressionOrSpreadElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrSpreadElement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExpressionOrSuper`[src]

`type Output = ExpressionOrSuper`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrSuper>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExpressionOrTemplateElement`[src]

`type Output = ExpressionOrTemplateElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrTemplateElement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExpressionOrVariableDeclaration`[src]

`type Output = ExpressionOrVariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrVariableDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for FunctionDeclaration`[src]

`type Output = FunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<FunctionDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for FunctionExpression`[src]

`type Output = FunctionExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<FunctionExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Getter`[src]

`type Output = Getter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Getter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ImportDeclaration`[src]

`type Output = ImportDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ImportDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for IterationStatement`[src]

`type Output = IterationStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<IterationStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Literal`[src]

`type Output = Literal`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Literal>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Method`[src]

`type Output = Method`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Method>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for MethodDefinition`[src]

`type Output = MethodDefinition`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<MethodDefinition>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ObjectProperty`[src]

`type Output = ObjectProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ObjectProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Parameter`[src]

`type Output = Parameter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Parameter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Program`[src]

`type Output = Program`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Program>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for PropertyName`[src]

`type Output = PropertyName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<PropertyName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Setter`[src]

`type Output = Setter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Setter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for SimpleAssignmentTarget`[src]

`type Output = SimpleAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SimpleAssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Statement`[src]

`type Output = Statement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Statement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for UnaryOperator where UnaryOperator: 'a,` [src]

`type Output = UnaryOperator`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<UnaryOperator as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for UpdateOperator where UpdateOperator: 'a,` [src]

`type Output = UpdateOperator`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<UpdateOperator as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for VariableDeclarationKind where VariableDeclarationKind: 'a,` [src]

`type Output = VariableDeclarationKind`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<VariableDeclarationKind as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutArrowExpression<'a> where ViewMutArrowExpression<'a>: 'a,` [src]

`type Output = ArrowExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrowExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedMaybePositionalParameterName<'a> where ViewMutAssertedMaybePositionalParameterName<'a>: 'a,` [src]

`type Output = AssertedMaybePositionalParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedMaybePositionalParameterName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTarget<'a> where ViewMutAssignmentTarget<'a>: 'a,` [src]

`type Output = AssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetOrAssignmentTargetWithInitializer<'a> where ViewMutAssignmentTargetOrAssignmentTargetWithInitializer<'a>: 'a,` [src]

`type Output = AssignmentTargetOrAssignmentTargetWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetOrAssignmentTargetWithInitializer>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetOrForInOfBinding<'a> where ViewMutAssignmentTargetOrForInOfBinding<'a>: 'a,` [src]

`type Output = AssignmentTargetOrForInOfBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetOrForInOfBinding>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetPattern<'a> where ViewMutAssignmentTargetPattern<'a>: 'a,` [src]

`type Output = AssignmentTargetPattern`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetPattern>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetProperty<'a> where ViewMutAssignmentTargetProperty<'a>: 'a,` [src]

`type Output = AssignmentTargetProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBinding<'a> where ViewMutBinding<'a>: 'a,` [src]

`type Output = Binding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Binding>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBindingOrBindingWithInitializer<'a> where ViewMutBindingOrBindingWithInitializer<'a>: 'a,` [src]

`type Output = BindingOrBindingWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingOrBindingWithInitializer>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBindingPattern<'a> where ViewMutBindingPattern<'a>: 'a,` [src]

`type Output = BindingPattern`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingPattern>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBindingProperty<'a> where ViewMutBindingProperty<'a>: 'a,` [src]

`type Output = BindingProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutClassDeclarationOrExpressionOrFunctionDeclaration<'a> where ViewMutClassDeclarationOrExpressionOrFunctionDeclaration<'a>: 'a,` [src]

`type Output = ClassDeclarationOrExpressionOrFunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutClassDeclarationOrFunctionDeclarationOrVariableDeclaration<'a> where ViewMutClassDeclarationOrFunctionDeclarationOrVariableDeclaration<'a>: 'a,` [src]

`type Output = ClassDeclarationOrFunctionDeclarationOrVariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportDeclaration<'a> where ViewMutExportDeclaration<'a>: 'a,` [src]

`type Output = ExportDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportDeclarationOrImportDeclarationOrStatement<'a> where ViewMutExportDeclarationOrImportDeclarationOrStatement<'a>: 'a,` [src]

`type Output = ExportDeclarationOrImportDeclarationOrStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportDeclarationOrImportDeclarationOrStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExpression<'a> where ViewMutExpression<'a>: 'a,` [src]

`type Output = Expression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Expression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExpressionOrSpreadElement<'a> where ViewMutExpressionOrSpreadElement<'a>: 'a,` [src]

`type Output = ExpressionOrSpreadElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrSpreadElement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExpressionOrSuper<'a> where ViewMutExpressionOrSuper<'a>: 'a,` [src]

`type Output = ExpressionOrSuper`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrSuper>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExpressionOrTemplateElement<'a> where ViewMutExpressionOrTemplateElement<'a>: 'a,` [src]

`type Output = ExpressionOrTemplateElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrTemplateElement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExpressionOrVariableDeclaration<'a> where ViewMutExpressionOrVariableDeclaration<'a>: 'a,` [src]

`type Output = ExpressionOrVariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionOrVariableDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutFunctionDeclaration<'a> where ViewMutFunctionDeclaration<'a>: 'a,` [src]

`type Output = FunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<FunctionDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutFunctionExpression<'a> where ViewMutFunctionExpression<'a>: 'a,` [src]

`type Output = FunctionExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<FunctionExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutGetter<'a> where ViewMutGetter<'a>: 'a,` [src]

`type Output = Getter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Getter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutImportDeclaration<'a> where ViewMutImportDeclaration<'a>: 'a,` [src]

`type Output = ImportDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ImportDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutIterationStatement<'a> where ViewMutIterationStatement<'a>: 'a,` [src]

`type Output = IterationStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<IterationStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteral<'a> where ViewMutLiteral<'a>: 'a,` [src]

`type Output = Literal`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Literal>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutMethod<'a> where ViewMutMethod<'a>: 'a,` [src]

`type Output = Method`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Method>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutMethodDefinition<'a> where ViewMutMethodDefinition<'a>: 'a,` [src]

`type Output = MethodDefinition`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<MethodDefinition>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutObjectProperty<'a> where ViewMutObjectProperty<'a>: 'a,` [src]

`type Output = ObjectProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ObjectProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutParameter<'a> where ViewMutParameter<'a>: 'a,` [src]

`type Output = Parameter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Parameter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutProgram<'a> where ViewMutProgram<'a>: 'a,` [src]

`type Output = Program`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Program>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutPropertyName<'a> where ViewMutPropertyName<'a>: 'a,` [src]

`type Output = PropertyName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<PropertyName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSetter<'a> where ViewMutSetter<'a>: 'a,` [src]

`type Output = Setter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Setter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSimpleAssignmentTarget<'a> where ViewMutSimpleAssignmentTarget<'a>: 'a,` [src]

`type Output = SimpleAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SimpleAssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutStatement<'a> where ViewMutStatement<'a>: 'a,` [src]

`type Output = Statement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Statement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ArrayAssignmentTarget`[src]

`type Output = ArrayAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrayAssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ArrayBinding`[src]

`type Output = ArrayBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrayBinding>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ArrayExpression`[src]

`type Output = ArrayExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrayExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ArrowExpressionContentsWithExpression`[src]

`type Output = ArrowExpressionContentsWithExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrowExpressionContentsWithExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ArrowExpressionContentsWithFunctionBody`[src]

`type Output = ArrowExpressionContentsWithFunctionBody`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrowExpressionContentsWithFunctionBody>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedBlockScope`[src]

`type Output = AssertedBlockScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedBlockScope>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedBoundName`[src]

`type Output = AssertedBoundName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedBoundName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedBoundNamesScope`[src]

`type Output = AssertedBoundNamesScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedBoundNamesScope>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedDeclaredName`[src]

`type Output = AssertedDeclaredName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedDeclaredName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedParameterName`[src]

`type Output = AssertedParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedParameterName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedParameterScope`[src]

`type Output = AssertedParameterScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedParameterScope>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedPositionalParameterName`[src]

`type Output = AssertedPositionalParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedPositionalParameterName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedRestParameterName`[src]

`type Output = AssertedRestParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedRestParameterName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedScriptGlobalScope`[src]

`type Output = AssertedScriptGlobalScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedScriptGlobalScope>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedVarScope`[src]

`type Output = AssertedVarScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssertedVarScope>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentExpression`[src]

`type Output = AssignmentExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetIdentifier`[src]

`type Output = AssignmentTargetIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetIdentifier>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetPropertyIdentifier`[src]

`type Output = AssignmentTargetPropertyIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetPropertyIdentifier>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetPropertyProperty`[src]

`type Output = AssignmentTargetPropertyProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetPropertyProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetWithInitializer`[src]

`type Output = AssignmentTargetWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AssignmentTargetWithInitializer>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AwaitExpression`[src]

`type Output = AwaitExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<AwaitExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BinASTExpressionWithProbabilityTable`[src]

`type Output = BinASTExpressionWithProbabilityTable`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BinASTExpressionWithProbabilityTable>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BinaryExpression`[src]

`type Output = BinaryExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BinaryExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BindingIdentifier`[src]

`type Output = BindingIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingIdentifier>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BindingPropertyIdentifier`[src]

`type Output = BindingPropertyIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingPropertyIdentifier>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BindingPropertyProperty`[src]

`type Output = BindingPropertyProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingPropertyProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BindingWithInitializer`[src]

`type Output = BindingWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BindingWithInitializer>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Block`[src]

`type Output = Block`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Block>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for BreakStatement`[src]

`type Output = BreakStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<BreakStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for CallExpression`[src]

`type Output = CallExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<CallExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for CatchClause`[src]

`type Output = CatchClause`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<CatchClause>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ClassDeclaration`[src]

`type Output = ClassDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ClassDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ClassElement`[src]

`type Output = ClassElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ClassElement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ClassExpression`[src]

`type Output = ClassExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ClassExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for CompoundAssignmentExpression`[src]

`type Output = CompoundAssignmentExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<CompoundAssignmentExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ComputedMemberAssignmentTarget`[src]

`type Output = ComputedMemberAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ComputedMemberAssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ComputedMemberExpression`[src]

`type Output = ComputedMemberExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ComputedMemberExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ComputedPropertyName`[src]

`type Output = ComputedPropertyName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ComputedPropertyName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ConditionalExpression`[src]

`type Output = ConditionalExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ConditionalExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ContinueStatement`[src]

`type Output = ContinueStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ContinueStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for DataProperty`[src]

`type Output = DataProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<DataProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for DebuggerStatement`[src]

`type Output = DebuggerStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<DebuggerStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Directive`[src]

`type Output = Directive`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Directive>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for DoWhileStatement`[src]

`type Output = DoWhileStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<DoWhileStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EagerArrowExpressionWithExpression`[src]

`type Output = EagerArrowExpressionWithExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EagerArrowExpressionWithExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EagerArrowExpressionWithFunctionBody`[src]

`type Output = EagerArrowExpressionWithFunctionBody`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EagerArrowExpressionWithFunctionBody>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EagerFunctionDeclaration`[src]

`type Output = EagerFunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EagerFunctionDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EagerFunctionExpression`[src]

`type Output = EagerFunctionExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EagerFunctionExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EagerGetter`[src]

`type Output = EagerGetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EagerGetter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EagerMethod`[src]

`type Output = EagerMethod`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EagerMethod>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EagerSetter`[src]

`type Output = EagerSetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EagerSetter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for EmptyStatement`[src]

`type Output = EmptyStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<EmptyStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Export`[src]

`type Output = Export`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Export>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportAllFrom`[src]

`type Output = ExportAllFrom`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportAllFrom>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportDefault`[src]

`type Output = ExportDefault`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportDefault>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportFrom`[src]

`type Output = ExportFrom`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportFrom>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportFromSpecifier`[src]

`type Output = ExportFromSpecifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportFromSpecifier>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportLocalSpecifier`[src]

`type Output = ExportLocalSpecifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportLocalSpecifier>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExportLocals`[src]

`type Output = ExportLocals`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExportLocals>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ExpressionStatement`[src]

`type Output = ExpressionStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ExpressionStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ForInOfBinding`[src]

`type Output = ForInOfBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ForInOfBinding>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ForInStatement`[src]

`type Output = ForInStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ForInStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ForOfStatement`[src]

`type Output = ForOfStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ForOfStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ForStatement`[src]

`type Output = ForStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ForStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for FormalParameters`[src]

`type Output = FormalParameters`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<FormalParameters>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for FunctionExpressionContents`[src]

`type Output = FunctionExpressionContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<FunctionExpressionContents>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for FunctionOrMethodContents`[src]

`type Output = FunctionOrMethodContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<FunctionOrMethodContents>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for GetterContents`[src]

`type Output = GetterContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<GetterContents>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for IdentifierExpression`[src]

`type Output = IdentifierExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<IdentifierExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for IfStatement`[src]

`type Output = IfStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<IfStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Import`[src]

`type Output = Import`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Import>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ImportNamespace`[src]

`type Output = ImportNamespace`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ImportNamespace>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ImportSpecifier`[src]

`type Output = ImportSpecifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ImportSpecifier>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LabelledStatement`[src]

`type Output = LabelledStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LabelledStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LazyArrowExpressionWithExpression`[src]

`type Output = LazyArrowExpressionWithExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LazyArrowExpressionWithExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LazyArrowExpressionWithFunctionBody`[src]

`type Output = LazyArrowExpressionWithFunctionBody`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LazyArrowExpressionWithFunctionBody>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LazyFunctionDeclaration`[src]

`type Output = LazyFunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LazyFunctionDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LazyFunctionExpression`[src]

`type Output = LazyFunctionExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LazyFunctionExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LazyGetter`[src]

`type Output = LazyGetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LazyGetter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LazyMethod`[src]

`type Output = LazyMethod`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LazyMethod>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LazySetter`[src]

`type Output = LazySetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LazySetter>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LiteralBooleanExpression`[src]

`type Output = LiteralBooleanExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LiteralBooleanExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LiteralInfinityExpression`[src]

`type Output = LiteralInfinityExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LiteralInfinityExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LiteralNullExpression`[src]

`type Output = LiteralNullExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LiteralNullExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LiteralNumericExpression`[src]

`type Output = LiteralNumericExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LiteralNumericExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LiteralPropertyName`[src]

`type Output = LiteralPropertyName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LiteralPropertyName>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LiteralRegExpExpression`[src]

`type Output = LiteralRegExpExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LiteralRegExpExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for LiteralStringExpression`[src]

`type Output = LiteralStringExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<LiteralStringExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Module`[src]

`type Output = Module`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Module>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for NewExpression`[src]

`type Output = NewExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<NewExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for NewTargetExpression`[src]

`type Output = NewTargetExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<NewTargetExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Null`[src]

`type Output = Null`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Null>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ObjectAssignmentTarget`[src]

`type Output = ObjectAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ObjectAssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ObjectBinding`[src]

`type Output = ObjectBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ObjectBinding>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ObjectExpression`[src]

`type Output = ObjectExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ObjectExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ReturnStatement`[src]

`type Output = ReturnStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ReturnStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Script`[src]

`type Output = Script`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Script>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for SetterContents`[src]

`type Output = SetterContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SetterContents>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ShorthandProperty`[src]

`type Output = ShorthandProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ShorthandProperty>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for SpreadElement`[src]

`type Output = SpreadElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SpreadElement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for StaticMemberAssignmentTarget`[src]

`type Output = StaticMemberAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<StaticMemberAssignmentTarget>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for StaticMemberExpression`[src]

`type Output = StaticMemberExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<StaticMemberExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Super`[src]

`type Output = Super`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Super>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for SwitchCase`[src]

`type Output = SwitchCase`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SwitchCase>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for SwitchDefault`[src]

`type Output = SwitchDefault`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SwitchDefault>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for SwitchStatement`[src]

`type Output = SwitchStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SwitchStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for SwitchStatementWithDefault`[src]

`type Output = SwitchStatementWithDefault`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<SwitchStatementWithDefault>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for TemplateElement`[src]

`type Output = TemplateElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<TemplateElement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for TemplateExpression`[src]

`type Output = TemplateExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<TemplateExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ThisExpression`[src]

`type Output = ThisExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ThisExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ThrowStatement`[src]

`type Output = ThrowStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ThrowStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for TryCatchStatement`[src]

`type Output = TryCatchStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<TryCatchStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for TryFinallyStatement`[src]

`type Output = TryFinallyStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<TryFinallyStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for UnaryExpression`[src]

`type Output = UnaryExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<UnaryExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for UpdateExpression`[src]

`type Output = UpdateExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<UpdateExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for VariableDeclaration`[src]

`type Output = VariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<VariableDeclaration>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for VariableDeclarator`[src]

`type Output = VariableDeclarator`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<VariableDeclarator>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutArguments<'a>`[src]

`type Output = Vec<ExpressionOrSpreadElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutArguments<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutArrayAssignmentTarget<'a> where ViewMutArrayAssignmentTarget<'a>: 'a,` [src]

`type Output = ArrayAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutArrayAssignmentTarget<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutArrayBinding<'a> where ViewMutArrayBinding<'a>: 'a,` [src]

`type Output = ArrayBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutArrayBinding<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutArrayExpression<'a> where ViewMutArrayExpression<'a>: 'a,` [src]

`type Output = ArrayExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutArrayExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutArrowExpressionContentsWithExpression<'a> where ViewMutArrowExpressionContentsWithExpression<'a>: 'a,` [src]

`type Output = ArrowExpressionContentsWithExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutArrowExpressionContentsWithExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutArrowExpressionContentsWithFunctionBody<'a> where ViewMutArrowExpressionContentsWithFunctionBody<'a>: 'a,` [src]

`type Output = ArrowExpressionContentsWithFunctionBody`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutArrowExpressionContentsWithFunctionBody<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedBlockScope<'a> where ViewMutAssertedBlockScope<'a>: 'a,` [src]

`type Output = AssertedBlockScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedBlockScope<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedBoundName<'a> where ViewMutAssertedBoundName<'a>: 'a,` [src]

`type Output = AssertedBoundName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedBoundName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedBoundNamesScope<'a> where ViewMutAssertedBoundNamesScope<'a>: 'a,` [src]

`type Output = AssertedBoundNamesScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedBoundNamesScope<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedDeclaredName<'a> where ViewMutAssertedDeclaredName<'a>: 'a,` [src]

`type Output = AssertedDeclaredName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedDeclaredName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedParameterName<'a> where ViewMutAssertedParameterName<'a>: 'a,` [src]

`type Output = AssertedParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedParameterName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedParameterScope<'a> where ViewMutAssertedParameterScope<'a>: 'a,` [src]

`type Output = AssertedParameterScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedParameterScope<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedPositionalParameterName<'a> where ViewMutAssertedPositionalParameterName<'a>: 'a,` [src]

`type Output = AssertedPositionalParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedPositionalParameterName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedRestParameterName<'a> where ViewMutAssertedRestParameterName<'a>: 'a,` [src]

`type Output = AssertedRestParameterName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedRestParameterName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedScriptGlobalScope<'a> where ViewMutAssertedScriptGlobalScope<'a>: 'a,` [src]

`type Output = AssertedScriptGlobalScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedScriptGlobalScope<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssertedVarScope<'a> where ViewMutAssertedVarScope<'a>: 'a,` [src]

`type Output = AssertedVarScope`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssertedVarScope<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentExpression<'a> where ViewMutAssignmentExpression<'a>: 'a,` [src]

`type Output = AssignmentExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssignmentExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetIdentifier<'a> where ViewMutAssignmentTargetIdentifier<'a>: 'a,` [src]

`type Output = AssignmentTargetIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssignmentTargetIdentifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetPropertyIdentifier<'a> where ViewMutAssignmentTargetPropertyIdentifier<'a>: 'a,` [src]

`type Output = AssignmentTargetPropertyIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssignmentTargetPropertyIdentifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetPropertyProperty<'a> where ViewMutAssignmentTargetPropertyProperty<'a>: 'a,` [src]

`type Output = AssignmentTargetPropertyProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssignmentTargetPropertyProperty<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAssignmentTargetWithInitializer<'a> where ViewMutAssignmentTargetWithInitializer<'a>: 'a,` [src]

`type Output = AssignmentTargetWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAssignmentTargetWithInitializer<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutAwaitExpression<'a> where ViewMutAwaitExpression<'a>: 'a,` [src]

`type Output = AwaitExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutAwaitExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBinASTExpressionWithProbabilityTable<'a> where ViewMutBinASTExpressionWithProbabilityTable<'a>: 'a,` [src]

`type Output = BinASTExpressionWithProbabilityTable`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBinASTExpressionWithProbabilityTable<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBinaryExpression<'a> where ViewMutBinaryExpression<'a>: 'a,` [src]

`type Output = BinaryExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBinaryExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBindingIdentifier<'a> where ViewMutBindingIdentifier<'a>: 'a,` [src]

`type Output = BindingIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBindingIdentifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBindingPropertyIdentifier<'a> where ViewMutBindingPropertyIdentifier<'a>: 'a,` [src]

`type Output = BindingPropertyIdentifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBindingPropertyIdentifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBindingPropertyProperty<'a> where ViewMutBindingPropertyProperty<'a>: 'a,` [src]

`type Output = BindingPropertyProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBindingPropertyProperty<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBindingWithInitializer<'a> where ViewMutBindingWithInitializer<'a>: 'a,` [src]

`type Output = BindingWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBindingWithInitializer<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBlock<'a> where ViewMutBlock<'a>: 'a,` [src]

`type Output = Block`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBlock<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutBreakStatement<'a> where ViewMutBreakStatement<'a>: 'a,` [src]

`type Output = BreakStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutBreakStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutCallExpression<'a> where ViewMutCallExpression<'a>: 'a,` [src]

`type Output = CallExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutCallExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutCatchClause<'a> where ViewMutCatchClause<'a>: 'a,` [src]

`type Output = CatchClause`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutCatchClause<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutClassDeclaration<'a> where ViewMutClassDeclaration<'a>: 'a,` [src]

`type Output = ClassDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutClassDeclaration<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutClassElement<'a> where ViewMutClassElement<'a>: 'a,` [src]

`type Output = ClassElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutClassElement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutClassExpression<'a> where ViewMutClassExpression<'a>: 'a,` [src]

`type Output = ClassExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutClassExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutCompoundAssignmentExpression<'a> where ViewMutCompoundAssignmentExpression<'a>: 'a,` [src]

`type Output = CompoundAssignmentExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutCompoundAssignmentExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutComputedMemberAssignmentTarget<'a> where ViewMutComputedMemberAssignmentTarget<'a>: 'a,` [src]

`type Output = ComputedMemberAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutComputedMemberAssignmentTarget<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutComputedMemberExpression<'a> where ViewMutComputedMemberExpression<'a>: 'a,` [src]

`type Output = ComputedMemberExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutComputedMemberExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutComputedPropertyName<'a> where ViewMutComputedPropertyName<'a>: 'a,` [src]

`type Output = ComputedPropertyName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutComputedPropertyName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutConditionalExpression<'a> where ViewMutConditionalExpression<'a>: 'a,` [src]

`type Output = ConditionalExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutConditionalExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutContinueStatement<'a> where ViewMutContinueStatement<'a>: 'a,` [src]

`type Output = ContinueStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutContinueStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutDataProperty<'a> where ViewMutDataProperty<'a>: 'a,` [src]

`type Output = DataProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutDataProperty<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutDebuggerStatement<'a> where ViewMutDebuggerStatement<'a>: 'a,` [src]

`type Output = DebuggerStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutDebuggerStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutDirective<'a> where ViewMutDirective<'a>: 'a,` [src]

`type Output = Directive`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutDirective<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutDoWhileStatement<'a> where ViewMutDoWhileStatement<'a>: 'a,` [src]

`type Output = DoWhileStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutDoWhileStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEagerArrowExpressionWithExpression<'a> where ViewMutEagerArrowExpressionWithExpression<'a>: 'a,` [src]

`type Output = EagerArrowExpressionWithExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEagerArrowExpressionWithExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEagerArrowExpressionWithFunctionBody<'a> where ViewMutEagerArrowExpressionWithFunctionBody<'a>: 'a,` [src]

`type Output = EagerArrowExpressionWithFunctionBody`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEagerArrowExpressionWithFunctionBody<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEagerFunctionDeclaration<'a> where ViewMutEagerFunctionDeclaration<'a>: 'a,` [src]

`type Output = EagerFunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEagerFunctionDeclaration<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEagerFunctionExpression<'a> where ViewMutEagerFunctionExpression<'a>: 'a,` [src]

`type Output = EagerFunctionExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEagerFunctionExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEagerGetter<'a> where ViewMutEagerGetter<'a>: 'a,` [src]

`type Output = EagerGetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEagerGetter<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEagerMethod<'a> where ViewMutEagerMethod<'a>: 'a,` [src]

`type Output = EagerMethod`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEagerMethod<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEagerSetter<'a> where ViewMutEagerSetter<'a>: 'a,` [src]

`type Output = EagerSetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEagerSetter<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutEmptyStatement<'a> where ViewMutEmptyStatement<'a>: 'a,` [src]

`type Output = EmptyStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutEmptyStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExport<'a> where ViewMutExport<'a>: 'a,` [src]

`type Output = Export`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExport<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportAllFrom<'a> where ViewMutExportAllFrom<'a>: 'a,` [src]

`type Output = ExportAllFrom`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExportAllFrom<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportDefault<'a> where ViewMutExportDefault<'a>: 'a,` [src]

`type Output = ExportDefault`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExportDefault<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportFrom<'a> where ViewMutExportFrom<'a>: 'a,` [src]

`type Output = ExportFrom`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExportFrom<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportFromSpecifier<'a> where ViewMutExportFromSpecifier<'a>: 'a,` [src]

`type Output = ExportFromSpecifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExportFromSpecifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportLocalSpecifier<'a> where ViewMutExportLocalSpecifier<'a>: 'a,` [src]

`type Output = ExportLocalSpecifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExportLocalSpecifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExportLocals<'a> where ViewMutExportLocals<'a>: 'a,` [src]

`type Output = ExportLocals`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExportLocals<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutExpressionStatement<'a> where ViewMutExpressionStatement<'a>: 'a,` [src]

`type Output = ExpressionStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutExpressionStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutForInOfBinding<'a> where ViewMutForInOfBinding<'a>: 'a,` [src]

`type Output = ForInOfBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutForInOfBinding<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutForInStatement<'a> where ViewMutForInStatement<'a>: 'a,` [src]

`type Output = ForInStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutForInStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutForOfStatement<'a> where ViewMutForOfStatement<'a>: 'a,` [src]

`type Output = ForOfStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutForOfStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutForStatement<'a> where ViewMutForStatement<'a>: 'a,` [src]

`type Output = ForStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutForStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutFormalParameters<'a> where ViewMutFormalParameters<'a>: 'a,` [src]

`type Output = FormalParameters`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutFormalParameters<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutFunctionExpressionContents<'a> where ViewMutFunctionExpressionContents<'a>: 'a,` [src]

`type Output = FunctionExpressionContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutFunctionExpressionContents<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutFunctionOrMethodContents<'a> where ViewMutFunctionOrMethodContents<'a>: 'a,` [src]

`type Output = FunctionOrMethodContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutFunctionOrMethodContents<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutGetterContents<'a> where ViewMutGetterContents<'a>: 'a,` [src]

`type Output = GetterContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutGetterContents<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutIdentifierExpression<'a> where ViewMutIdentifierExpression<'a>: 'a,` [src]

`type Output = IdentifierExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutIdentifierExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutIfStatement<'a> where ViewMutIfStatement<'a>: 'a,` [src]

`type Output = IfStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutIfStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutImport<'a> where ViewMutImport<'a>: 'a,` [src]

`type Output = Import`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutImport<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutImportNamespace<'a> where ViewMutImportNamespace<'a>: 'a,` [src]

`type Output = ImportNamespace`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutImportNamespace<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutImportSpecifier<'a> where ViewMutImportSpecifier<'a>: 'a,` [src]

`type Output = ImportSpecifier`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutImportSpecifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLabel<'a>`[src]

`type Output = SharedString`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<ViewMutLabel<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLabelledStatement<'a> where ViewMutLabelledStatement<'a>: 'a,` [src]

`type Output = LabelledStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLabelledStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLazyArrowExpressionWithExpression<'a> where ViewMutLazyArrowExpressionWithExpression<'a>: 'a,` [src]

`type Output = LazyArrowExpressionWithExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLazyArrowExpressionWithExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLazyArrowExpressionWithFunctionBody<'a> where ViewMutLazyArrowExpressionWithFunctionBody<'a>: 'a,` [src]

`type Output = LazyArrowExpressionWithFunctionBody`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLazyArrowExpressionWithFunctionBody<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLazyFunctionDeclaration<'a> where ViewMutLazyFunctionDeclaration<'a>: 'a,` [src]

`type Output = LazyFunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLazyFunctionDeclaration<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLazyFunctionExpression<'a> where ViewMutLazyFunctionExpression<'a>: 'a,` [src]

`type Output = LazyFunctionExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLazyFunctionExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLazyGetter<'a> where ViewMutLazyGetter<'a>: 'a,` [src]

`type Output = LazyGetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLazyGetter<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLazyMethod<'a> where ViewMutLazyMethod<'a>: 'a,` [src]

`type Output = LazyMethod`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLazyMethod<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLazySetter<'a> where ViewMutLazySetter<'a>: 'a,` [src]

`type Output = LazySetter`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLazySetter<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfAssertedBoundName<'a>`[src]

`type Output = Vec<AssertedBoundName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfAssertedBoundName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfAssertedDeclaredName<'a>`[src]

`type Output = Vec<AssertedDeclaredName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfAssertedDeclaredName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfAssertedMaybePositionalParameterName<'a>`[src]

`type Output = Vec<AssertedMaybePositionalParameterName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfAssertedMaybePositionalParameterName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfAssignmentTargetOrAssignmentTargetWithInitializer<'a>`[src]

`type Output = Vec<AssignmentTargetOrAssignmentTargetWithInitializer>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfAssignmentTargetOrAssignmentTargetWithInitializer<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfAssignmentTargetProperty<'a>`[src]

`type Output = Vec<AssignmentTargetProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfAssignmentTargetProperty<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfBindingProperty<'a>`[src]

`type Output = Vec<BindingProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfBindingProperty<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfClassElement<'a>`[src]

`type Output = Vec<ClassElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfClassElement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfDirective<'a>`[src]

`type Output = Vec<Directive>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfDirective<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfExportDeclarationOrImportDeclarationOrStatement<'a>`[src]

`type Output = Vec<ExportDeclarationOrImportDeclarationOrStatement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfExportDeclarationOrImportDeclarationOrStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfExportFromSpecifier<'a>`[src]

`type Output = Vec<ExportFromSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfExportFromSpecifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfExportLocalSpecifier<'a>`[src]

`type Output = Vec<ExportLocalSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfExportLocalSpecifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfExpressionOrTemplateElement<'a>`[src]

`type Output = Vec<ExpressionOrTemplateElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfExpressionOrTemplateElement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfImportSpecifier<'a>`[src]

`type Output = Vec<ImportSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfImportSpecifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfObjectProperty<'a>`[src]

`type Output = Vec<ObjectProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfObjectProperty<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfOptionalBindingOrBindingWithInitializer<'a>`[src]

`type Output = Vec<Option<BindingOrBindingWithInitializer>>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfOptionalBindingOrBindingWithInitializer<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfOptionalExpressionOrSpreadElement<'a>`[src]

`type Output = Vec<Option<ExpressionOrSpreadElement>>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfOptionalExpressionOrSpreadElement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfParameter<'a>`[src]

`type Output = Vec<Parameter>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfParameter<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfStatement<'a>`[src]

`type Output = Vec<Statement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfSwitchCase<'a>`[src]

`type Output = Vec<SwitchCase>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfSwitchCase<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutListOfVariableDeclarator<'a>`[src]

`type Output = Vec<VariableDeclarator>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutListOfVariableDeclarator<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteralBooleanExpression<'a> where ViewMutLiteralBooleanExpression<'a>: 'a,` [src]

`type Output = LiteralBooleanExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLiteralBooleanExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteralInfinityExpression<'a> where ViewMutLiteralInfinityExpression<'a>: 'a,` [src]

`type Output = LiteralInfinityExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLiteralInfinityExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteralNullExpression<'a> where ViewMutLiteralNullExpression<'a>: 'a,` [src]

`type Output = LiteralNullExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLiteralNullExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteralNumericExpression<'a> where ViewMutLiteralNumericExpression<'a>: 'a,` [src]

`type Output = LiteralNumericExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLiteralNumericExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteralPropertyName<'a> where ViewMutLiteralPropertyName<'a>: 'a,` [src]

`type Output = LiteralPropertyName`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLiteralPropertyName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteralRegExpExpression<'a> where ViewMutLiteralRegExpExpression<'a>: 'a,` [src]

`type Output = LiteralRegExpExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLiteralRegExpExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutLiteralStringExpression<'a> where ViewMutLiteralStringExpression<'a>: 'a,` [src]

`type Output = LiteralStringExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutLiteralStringExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutModule<'a> where ViewMutModule<'a>: 'a,` [src]

`type Output = Module`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutModule<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutNewExpression<'a> where ViewMutNewExpression<'a>: 'a,` [src]

`type Output = NewExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutNewExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutNewTargetExpression<'a> where ViewMutNewTargetExpression<'a>: 'a,` [src]

`type Output = NewTargetExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutNewTargetExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutNull<'a> where ViewMutNull<'a>: 'a,` [src]

`type Output = Null`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutNull<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutObjectAssignmentTarget<'a> where ViewMutObjectAssignmentTarget<'a>: 'a,` [src]

`type Output = ObjectAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutObjectAssignmentTarget<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutObjectBinding<'a> where ViewMutObjectBinding<'a>: 'a,` [src]

`type Output = ObjectBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutObjectBinding<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutObjectExpression<'a> where ViewMutObjectExpression<'a>: 'a,` [src]

`type Output = ObjectExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutObjectExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOffset<'a>`[src]

`type Output = Offset`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOffset<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalAssignmentTarget<'a>`[src]

`type Output = Option<AssignmentTarget>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalAssignmentTarget<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalBinding<'a>`[src]

`type Output = Option<Binding>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalBinding<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalBindingIdentifier<'a>`[src]

`type Output = Option<BindingIdentifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalBindingIdentifier<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalBindingOrBindingWithInitializer<'a>`[src]

`type Output = Option<BindingOrBindingWithInitializer>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalBindingOrBindingWithInitializer<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalCatchClause<'a>`[src]

`type Output = Option<CatchClause>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalCatchClause<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalExpression<'a>`[src]

`type Output = Option<Expression>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalExpressionOrSpreadElement<'a>`[src]

`type Output = Option<ExpressionOrSpreadElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalExpressionOrSpreadElement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalExpressionOrVariableDeclaration<'a>`[src]

`type Output = Option<ExpressionOrVariableDeclaration>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalExpressionOrVariableDeclaration<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalIdentifierName<'a>`[src]

`type Output = Option<IdentifierName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalIdentifierName<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalLabel<'a>`[src]

`type Output = Option<SharedString>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalLabel<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalPropertyKey<'a>`[src]

`type Output = Option<PropertyKey>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalPropertyKey<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutOptionalStatement<'a>`[src]

`type Output = Option<Statement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutOptionalStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutReturnStatement<'a> where ViewMutReturnStatement<'a>: 'a,` [src]

`type Output = ReturnStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutReturnStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutScript<'a> where ViewMutScript<'a>: 'a,` [src]

`type Output = Script`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutScript<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSetterContents<'a> where ViewMutSetterContents<'a>: 'a,` [src]

`type Output = SetterContents`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutSetterContents<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutShorthandProperty<'a> where ViewMutShorthandProperty<'a>: 'a,` [src]

`type Output = ShorthandProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutShorthandProperty<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSpreadElement<'a> where ViewMutSpreadElement<'a>: 'a,` [src]

`type Output = SpreadElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutSpreadElement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutStaticMemberAssignmentTarget<'a> where ViewMutStaticMemberAssignmentTarget<'a>: 'a,` [src]

`type Output = StaticMemberAssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutStaticMemberAssignmentTarget<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutStaticMemberExpression<'a> where ViewMutStaticMemberExpression<'a>: 'a,` [src]

`type Output = StaticMemberExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutStaticMemberExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutString<'a>`[src]

`type Output = SharedString`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<ViewMutString<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSuper<'a> where ViewMutSuper<'a>: 'a,` [src]

`type Output = Super`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutSuper<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSwitchCase<'a> where ViewMutSwitchCase<'a>: 'a,` [src]

`type Output = SwitchCase`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutSwitchCase<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSwitchDefault<'a> where ViewMutSwitchDefault<'a>: 'a,` [src]

`type Output = SwitchDefault`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutSwitchDefault<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSwitchStatement<'a> where ViewMutSwitchStatement<'a>: 'a,` [src]

`type Output = SwitchStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutSwitchStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutSwitchStatementWithDefault<'a> where ViewMutSwitchStatementWithDefault<'a>: 'a,` [src]

`type Output = SwitchStatementWithDefault`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutSwitchStatementWithDefault<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutTemplateElement<'a> where ViewMutTemplateElement<'a>: 'a,` [src]

`type Output = TemplateElement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutTemplateElement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutTemplateExpression<'a> where ViewMutTemplateExpression<'a>: 'a,` [src]

`type Output = TemplateExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutTemplateExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutThisExpression<'a> where ViewMutThisExpression<'a>: 'a,` [src]

`type Output = ThisExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutThisExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutThrowStatement<'a> where ViewMutThrowStatement<'a>: 'a,` [src]

`type Output = ThrowStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutThrowStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutTryCatchStatement<'a> where ViewMutTryCatchStatement<'a>: 'a,` [src]

`type Output = TryCatchStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutTryCatchStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutTryFinallyStatement<'a> where ViewMutTryFinallyStatement<'a>: 'a,` [src]

`type Output = TryFinallyStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutTryFinallyStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutUnaryExpression<'a> where ViewMutUnaryExpression<'a>: 'a,` [src]

`type Output = UnaryExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutUnaryExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutUpdateExpression<'a> where ViewMutUpdateExpression<'a>: 'a,` [src]

`type Output = UpdateExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutUpdateExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutVariableDeclaration<'a> where ViewMutVariableDeclaration<'a>: 'a,` [src]

`type Output = VariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutVariableDeclaration<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutVariableDeclarator<'a> where ViewMutVariableDeclarator<'a>: 'a,` [src]

`type Output = VariableDeclarator`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutVariableDeclarator<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutWhileStatement<'a> where ViewMutWhileStatement<'a>: 'a,` [src]

`type Output = WhileStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutWhileStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutWithStatement<'a> where ViewMutWithStatement<'a>: 'a,` [src]

`type Output = WithStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutWithStatement<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutYieldExpression<'a> where ViewMutYieldExpression<'a>: 'a,` [src]

`type Output = YieldExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutYieldExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ViewMutYieldStarExpression<'a> where ViewMutYieldStarExpression<'a>: 'a,` [src]

`type Output = YieldStarExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<<ViewMutYieldStarExpression<'a> as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for WhileStatement`[src]

`type Output = WhileStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<WhileStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for WithStatement`[src]

`type Output = WithStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<WithStatement>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for YieldExpression`[src]

`type Output = YieldExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<YieldExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for YieldStarExpression`[src]

`type Output = YieldStarExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<YieldStarExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

Loading content...

[−][src]Trait binjs::specialized::es6::ast::Walker

Associated Types

type Output

Required methods

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Self::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,

Implementations on Foreign Types

impl<'a> Walker<'a> for Vec<VariableDeclarator>[src]

type Output = Vec<VariableDeclarator>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<VariableDeclarator>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<AssertedMaybePositionalParameterName>[src]

type Output = Vec<AssertedMaybePositionalParameterName>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<AssertedMaybePositionalParameterName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<AssignmentTargetProperty>[src]

type Output = Vec<AssignmentTargetProperty>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<AssignmentTargetProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for f64[src]

type Output = f64

fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V) -> Result<Option<f64>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<AssertedDeclaredName>[src]

type Output = Vec<AssertedDeclaredName>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<AssertedDeclaredName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ObjectProperty>[src]

type Output = Vec<ObjectProperty>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ObjectProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<AssertedBoundName>[src]

type Output = Vec<AssertedBoundName>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<AssertedBoundName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<Parameter>[src]

type Output = Vec<Parameter>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<Parameter>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ImportSpecifier>[src]

type Output = Vec<ImportSpecifier>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ImportSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ExportDeclarationOrImportDeclarationOrStatement>[src]

type Output = Vec<ExportDeclarationOrImportDeclarationOrStatement>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ExportDeclarationOrImportDeclarationOrStatement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<Option<ExpressionOrSpreadElement>>[src]

type Output = Vec<Option<ExpressionOrSpreadElement>>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<Option<ExpressionOrSpreadElement>>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<SwitchCase>[src]

type Output = Vec<SwitchCase>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<SwitchCase>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<Directive>[src]

type Output = Vec<Directive>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<Directive>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ExportLocalSpecifier>[src]

type Output = Vec<ExportLocalSpecifier>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ExportLocalSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<Statement>[src]

type Output = Vec<Statement>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<Statement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ClassElement>[src]

type Output = Vec<ClassElement>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ClassElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<Option<BindingOrBindingWithInitializer>>[src]

type Output = Vec<Option<BindingOrBindingWithInitializer>>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<Option<BindingOrBindingWithInitializer>>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ExportFromSpecifier>[src]

type Output = Vec<ExportFromSpecifier>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ExportFromSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ExpressionOrSpreadElement>[src]

type Output = Vec<ExpressionOrSpreadElement>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ExpressionOrSpreadElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<BindingProperty>[src]

type Output = Vec<BindingProperty>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<BindingProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for u32[src]

type Output = u32

fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V) -> Result<Option<u32>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for bool[src]

type Output = bool

fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V) -> Result<Option<bool>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<ExpressionOrTemplateElement>[src]

type Output = Vec<ExpressionOrTemplateElement>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<ExpressionOrTemplateElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

impl<'a> Walker<'a> for Vec<AssignmentTargetOrAssignmentTargetWithInitializer>[src]

type Output = Vec<AssignmentTargetOrAssignmentTargetWithInitializer>

fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V) -> Result<Option<Vec<AssignmentTargetOrAssignmentTargetWithInitializer>>, E> where G: WalkGuard<V>, V: Visitor<E, G>, [src]

Implementors

impl<'a> Walker<'a> for ArrowExpression[src]

`type Output`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Self::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,`

`impl<'a> Walker<'a> for Vec<VariableDeclarator>`[src]

`type Output = Vec<VariableDeclarator>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<VariableDeclarator>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssertedMaybePositionalParameterName>`[src]

`type Output = Vec<AssertedMaybePositionalParameterName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssertedMaybePositionalParameterName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssignmentTargetProperty>`[src]

`type Output = Vec<AssignmentTargetProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssignmentTargetProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for f64`[src]

`type Output = f64`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<f64>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssertedDeclaredName>`[src]

`type Output = Vec<AssertedDeclaredName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssertedDeclaredName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ObjectProperty>`[src]

`type Output = Vec<ObjectProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ObjectProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssertedBoundName>`[src]

`type Output = Vec<AssertedBoundName>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssertedBoundName>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Parameter>`[src]

`type Output = Vec<Parameter>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Parameter>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ImportSpecifier>`[src]

`type Output = Vec<ImportSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ImportSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExportDeclarationOrImportDeclarationOrStatement>`[src]

`type Output = Vec<ExportDeclarationOrImportDeclarationOrStatement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExportDeclarationOrImportDeclarationOrStatement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Option<ExpressionOrSpreadElement>>`[src]

`type Output = Vec<Option<ExpressionOrSpreadElement>>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Option<ExpressionOrSpreadElement>>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<SwitchCase>`[src]

`type Output = Vec<SwitchCase>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<SwitchCase>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Directive>`[src]

`type Output = Vec<Directive>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Directive>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExportLocalSpecifier>`[src]

`type Output = Vec<ExportLocalSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExportLocalSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Statement>`[src]

`type Output = Vec<Statement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Statement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ClassElement>`[src]

`type Output = Vec<ClassElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ClassElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<Option<BindingOrBindingWithInitializer>>`[src]

`type Output = Vec<Option<BindingOrBindingWithInitializer>>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<Option<BindingOrBindingWithInitializer>>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExportFromSpecifier>`[src]

`type Output = Vec<ExportFromSpecifier>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExportFromSpecifier>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExpressionOrSpreadElement>`[src]

`type Output = Vec<ExpressionOrSpreadElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExpressionOrSpreadElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<BindingProperty>`[src]

`type Output = Vec<BindingProperty>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<BindingProperty>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for u32`[src]

`type Output = u32`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<u32>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for bool`[src]

`type Output = bool`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<bool>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<ExpressionOrTemplateElement>`[src]

`type Output = Vec<ExpressionOrTemplateElement>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<ExpressionOrTemplateElement>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for Vec<AssignmentTargetOrAssignmentTargetWithInitializer>`[src]

`type Output = Vec<AssignmentTargetOrAssignmentTargetWithInitializer>`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<Vec<AssignmentTargetOrAssignmentTargetWithInitializer>>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for ArrowExpression`[src]

`type Output = ArrowExpression`

`fn walk<V, E, G>( &'a mut self, path: &mut Path<ASTNode, ASTField>, visitor: &mut V ) -> Result<Option<ArrowExpression>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]

`impl<'a> Walker<'a> for AssertedDeclaredKind where AssertedDeclaredKind: 'a,` [src]

`type Output = AssertedDeclaredKind`

`fn walk<V, E, G>( &'a mut self, &mut Path<ASTNode, ASTField>, &mut V ) -> Result<Option<<AssertedDeclaredKind as Walker<'a>>::Output>, E> where G: WalkGuard<V>, V: Visitor<E, G>,` [src]