[−][src]Trait binjs_es6::ast::Walker

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

Associated Types

`type Output`

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

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

`type Output = Self`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = Self`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = Self`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

Loading content...

Implementors

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

`type Output = ArrowExpression`

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

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

`type Output = AssertedDeclaredKind`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = AssertedMaybePositionalParameterName`

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

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

`type Output = AssignmentTarget`

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

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

`type Output = AssignmentTargetOrAssignmentTargetWithInitializer`

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

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

`type Output = AssignmentTargetOrForInOfBinding`

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

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

`type Output = AssignmentTargetPattern`

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

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

`type Output = AssignmentTargetProperty`

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

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

`type Output = BinaryOperator`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = Binding`

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

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

`type Output = BindingOrBindingWithInitializer`

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

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

`type Output = BindingPattern`

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

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

`type Output = BindingProperty`

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

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

`type Output = ClassDeclarationOrExpressionOrFunctionDeclaration`

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

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

`type Output = ClassDeclarationOrFunctionDeclarationOrVariableDeclaration`

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

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

`type Output = CompoundAssignmentOperator`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = ExportDeclaration`

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

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

`type Output = ExportDeclarationOrImportDeclarationOrStatement`

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

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

`type Output = Expression`

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

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

`type Output = ExpressionOrSpreadElement`

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

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

`type Output = ExpressionOrSuper`

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

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

`type Output = ExpressionOrTemplateElement`

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

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

`type Output = ExpressionOrVariableDeclaration`

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

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

`type Output = FunctionDeclaration`

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

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

`type Output = FunctionExpression`

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

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

`type Output = Getter`

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

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

`type Output = ImportDeclaration`

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

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

`type Output = IterationStatement`

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

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

`type Output = Literal`

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

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

`type Output = Method`

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

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

`type Output = MethodDefinition`

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

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

`type Output = ObjectProperty`

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

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

`type Output = Parameter`

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

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

`type Output = Program`

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

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

`type Output = PropertyName`

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

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

`type Output = Setter`

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

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

`type Output = SimpleAssignmentTarget`

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

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

`type Output = Statement`

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

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

`type Output = UnaryOperator`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = UpdateOperator`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = VariableDeclarationKind`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = ArrowExpression`

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

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

`type Output = AssertedMaybePositionalParameterName`

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

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

`type Output = AssignmentTarget`

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

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

`type Output = AssignmentTargetOrAssignmentTargetWithInitializer`

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

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

`type Output = AssignmentTargetOrForInOfBinding`

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

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

`type Output = AssignmentTargetPattern`

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

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

`type Output = AssignmentTargetProperty`

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

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

`type Output = Binding`

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

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

`type Output = BindingOrBindingWithInitializer`

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

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

`type Output = BindingPattern`

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

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

`type Output = BindingProperty`

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

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

`type Output = ClassDeclarationOrExpressionOrFunctionDeclaration`

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

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

`type Output = ClassDeclarationOrFunctionDeclarationOrVariableDeclaration`

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

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

`type Output = ExportDeclaration`

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

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

`type Output = ExportDeclarationOrImportDeclarationOrStatement`

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

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

`type Output = Expression`

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

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

`type Output = ExpressionOrSpreadElement`

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

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

`type Output = ExpressionOrSuper`

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

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

`type Output = ExpressionOrTemplateElement`

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

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

`type Output = ExpressionOrVariableDeclaration`

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

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

`type Output = FunctionDeclaration`

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

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

`type Output = FunctionExpression`

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

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

`type Output = Getter`

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

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

`type Output = ImportDeclaration`

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

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

`type Output = IterationStatement`

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

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

`type Output = Literal`

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

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

`type Output = Method`

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

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

`type Output = MethodDefinition`

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

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

`type Output = ObjectProperty`

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

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

`type Output = Parameter`

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

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

`type Output = Program`

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

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

`type Output = PropertyName`

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

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

`type Output = Setter`

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

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

`type Output = SimpleAssignmentTarget`

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

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

`type Output = Statement`

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

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

`type Output = ArrayAssignmentTarget`

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

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

`type Output = ArrayBinding`

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

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

`type Output = ArrayExpression`

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

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

`type Output = ArrowExpressionContentsWithExpression`

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

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

`type Output = ArrowExpressionContentsWithFunctionBody`

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

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

`type Output = AssertedBlockScope`

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

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

`type Output = AssertedBoundName`

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

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

`type Output = AssertedBoundNamesScope`

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

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

`type Output = AssertedDeclaredName`

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

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

`type Output = AssertedParameterName`

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

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

`type Output = AssertedParameterScope`

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

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

`type Output = AssertedPositionalParameterName`

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

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

`type Output = AssertedRestParameterName`

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

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

`type Output = AssertedScriptGlobalScope`

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

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

`type Output = AssertedVarScope`

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

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

`type Output = AssignmentExpression`

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

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

`type Output = AssignmentTargetIdentifier`

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

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

`type Output = AssignmentTargetPropertyIdentifier`

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

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

`type Output = AssignmentTargetPropertyProperty`

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

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

`type Output = AssignmentTargetWithInitializer`

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

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

`type Output = AwaitExpression`

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

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

`type Output = BinASTExpressionWithProbabilityTable`

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

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

`type Output = BinaryExpression`

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

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

`type Output = BindingIdentifier`

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

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

`type Output = BindingPropertyIdentifier`

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

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

`type Output = BindingPropertyProperty`

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

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

`type Output = BindingWithInitializer`

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

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

`type Output = Block`

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

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

`type Output = BreakStatement`

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

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

`type Output = CallExpression`

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

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

`type Output = CatchClause`

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

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

`type Output = ClassDeclaration`

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

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

`type Output = ClassElement`

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

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

`type Output = ClassExpression`

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

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

`type Output = CompoundAssignmentExpression`

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

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

`type Output = ComputedMemberAssignmentTarget`

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

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

`type Output = ComputedMemberExpression`

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

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

`type Output = ComputedPropertyName`

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

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

`type Output = ConditionalExpression`

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

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

`type Output = ContinueStatement`

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

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

`type Output = DataProperty`

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

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

`type Output = DebuggerStatement`

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

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

`type Output = Directive`

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

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

`type Output = DoWhileStatement`

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

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

`type Output = EagerArrowExpressionWithExpression`

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

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

`type Output = EagerArrowExpressionWithFunctionBody`

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

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

`type Output = EagerFunctionDeclaration`

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

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

`type Output = EagerFunctionExpression`

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

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

`type Output = EagerGetter`

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

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

`type Output = EagerMethod`

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

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

`type Output = EagerSetter`

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

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

`type Output = EmptyStatement`

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

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

`type Output = Export`

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

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

`type Output = ExportAllFrom`

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

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

`type Output = ExportDefault`

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

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

`type Output = ExportFrom`

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

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

`type Output = ExportFromSpecifier`

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

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

`type Output = ExportLocalSpecifier`

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

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

`type Output = ExportLocals`

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

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

`type Output = ExpressionStatement`

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

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

`type Output = ForInOfBinding`

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

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

`type Output = ForInStatement`

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

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

`type Output = ForOfStatement`

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

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

`type Output = ForStatement`

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

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

`type Output = FormalParameters`

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

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

`type Output = FunctionExpressionContents`

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

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

`type Output = FunctionOrMethodContents`

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

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

`type Output = GetterContents`

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

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

`type Output = IdentifierExpression`

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

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

`type Output = IfStatement`

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

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

`type Output = Import`

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

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

`type Output = ImportNamespace`

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

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

`type Output = ImportSpecifier`

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

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

`type Output = LabelledStatement`

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

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

`type Output = LazyArrowExpressionWithExpression`

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

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

`type Output = LazyArrowExpressionWithFunctionBody`

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

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

`type Output = LazyFunctionDeclaration`

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

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

`type Output = LazyFunctionExpression`

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

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

`type Output = LazyGetter`

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

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

`type Output = LazyMethod`

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

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

`type Output = LazySetter`

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

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

`type Output = LiteralBooleanExpression`

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

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

`type Output = LiteralInfinityExpression`

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

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

`type Output = LiteralNullExpression`

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

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

`type Output = LiteralNumericExpression`

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

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

`type Output = LiteralPropertyName`

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

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

`type Output = LiteralRegExpExpression`

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

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

`type Output = LiteralStringExpression`

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

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

`type Output = Module`

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

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

`type Output = NewExpression`

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

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

`type Output = NewTargetExpression`

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

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

`type Output = Null`

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

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

`type Output = ObjectAssignmentTarget`

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

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

`type Output = ObjectBinding`

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

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

`type Output = ObjectExpression`

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

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

`type Output = ReturnStatement`

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

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

`type Output = Script`

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

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

`type Output = SetterContents`

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

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

`type Output = ShorthandProperty`

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

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

`type Output = SpreadElement`

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

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

`type Output = StaticMemberAssignmentTarget`

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

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

`type Output = StaticMemberExpression`

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

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

`type Output = Super`

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

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

`type Output = SwitchCase`

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

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

`type Output = SwitchDefault`

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

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

`type Output = SwitchStatement`

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

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

`type Output = SwitchStatementWithDefault`

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

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

`type Output = TemplateElement`

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

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

`type Output = TemplateExpression`

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

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

`type Output = ThisExpression`

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

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

`type Output = ThrowStatement`

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

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

`type Output = TryCatchStatement`

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

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

`type Output = TryFinallyStatement`

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

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

`type Output = UnaryExpression`

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

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

`type Output = UpdateExpression`

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

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

`type Output = VariableDeclaration`

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

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

`type Output = VariableDeclarator`

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

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

`type Output = Arguments`

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

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

`type Output = ArrayAssignmentTarget`

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

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

`type Output = ArrayBinding`

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

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

`type Output = ArrayExpression`

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

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

`type Output = ArrowExpressionContentsWithExpression`

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

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

`type Output = ArrowExpressionContentsWithFunctionBody`

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

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

`type Output = AssertedBlockScope`

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

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

`type Output = AssertedBoundName`

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

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

`type Output = AssertedBoundNamesScope`

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

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

`type Output = AssertedDeclaredName`

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

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

`type Output = AssertedParameterName`

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

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

`type Output = AssertedParameterScope`

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

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

`type Output = AssertedPositionalParameterName`

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

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

`type Output = AssertedRestParameterName`

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

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

`type Output = AssertedScriptGlobalScope`

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

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

`type Output = AssertedVarScope`

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

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

`type Output = AssignmentExpression`

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

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

`type Output = AssignmentTargetIdentifier`

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

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

`type Output = AssignmentTargetPropertyIdentifier`

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

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

`type Output = AssignmentTargetPropertyProperty`

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

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

`type Output = AssignmentTargetWithInitializer`

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

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

`type Output = AwaitExpression`

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

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

`type Output = BinASTExpressionWithProbabilityTable`

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

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

`type Output = BinaryExpression`

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

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

`type Output = BindingIdentifier`

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

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

`type Output = BindingPropertyIdentifier`

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

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

`type Output = BindingPropertyProperty`

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

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

`type Output = BindingWithInitializer`

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

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

`type Output = Block`

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

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

`type Output = BreakStatement`

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

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

`type Output = CallExpression`

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

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

`type Output = CatchClause`

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

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

`type Output = ClassDeclaration`

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

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

`type Output = ClassElement`

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

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

`type Output = ClassExpression`

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

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

`type Output = CompoundAssignmentExpression`

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

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

`type Output = ComputedMemberAssignmentTarget`

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

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

`type Output = ComputedMemberExpression`

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

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

`type Output = ComputedPropertyName`

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

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

`type Output = ConditionalExpression`

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

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

`type Output = ContinueStatement`

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

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

`type Output = DataProperty`

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

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

`type Output = DebuggerStatement`

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

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

`type Output = Directive`

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

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

`type Output = DoWhileStatement`

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

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

`type Output = EagerArrowExpressionWithExpression`

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

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

`type Output = EagerArrowExpressionWithFunctionBody`

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

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

`type Output = EagerFunctionDeclaration`

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

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

`type Output = EagerFunctionExpression`

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

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

`type Output = EagerGetter`

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

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

`type Output = EagerMethod`

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

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

`type Output = EagerSetter`

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

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

`type Output = EmptyStatement`

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

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

`type Output = Export`

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

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

`type Output = ExportAllFrom`

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

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

`type Output = ExportDefault`

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

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

`type Output = ExportFrom`

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

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

`type Output = ExportFromSpecifier`

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

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

`type Output = ExportLocalSpecifier`

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

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

`type Output = ExportLocals`

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

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

`type Output = ExpressionStatement`

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

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

`type Output = ForInOfBinding`

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

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

`type Output = ForInStatement`

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

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

`type Output = ForOfStatement`

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

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

`type Output = ForStatement`

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

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

`type Output = FormalParameters`

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

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

`type Output = FunctionExpressionContents`

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

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

`type Output = FunctionOrMethodContents`

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

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

`type Output = GetterContents`

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

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

`type Output = IdentifierExpression`

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

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

`type Output = IfStatement`

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

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

`type Output = Import`

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

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

`type Output = ImportNamespace`

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

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

`type Output = ImportSpecifier`

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

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

`type Output = Label`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = LabelledStatement`

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

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

`type Output = LazyArrowExpressionWithExpression`

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

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

`type Output = LazyArrowExpressionWithFunctionBody`

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

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

`type Output = LazyFunctionDeclaration`

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

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

`type Output = LazyFunctionExpression`

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

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

`type Output = LazyGetter`

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

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

`type Output = LazyMethod`

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

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

`type Output = LazySetter`

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

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

`type Output = ListOfAssertedBoundName`

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

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

`type Output = ListOfAssertedDeclaredName`

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

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

`type Output = ListOfAssertedMaybePositionalParameterName`

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

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

`type Output = ListOfAssignmentTargetOrAssignmentTargetWithInitializer`

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

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

`type Output = ListOfAssignmentTargetProperty`

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

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

`type Output = ListOfBindingProperty`

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

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

`type Output = ListOfClassElement`

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

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

`type Output = ListOfDirective`

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

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

`type Output = ListOfExportDeclarationOrImportDeclarationOrStatement`

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

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

`type Output = ListOfExportFromSpecifier`

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

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

`type Output = ListOfExportLocalSpecifier`

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

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

`type Output = ListOfExpressionOrTemplateElement`

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

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

`type Output = ListOfImportSpecifier`

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

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

`type Output = ListOfObjectProperty`

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

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

`type Output = ListOfOptionalBindingOrBindingWithInitializer`

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

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

`type Output = ListOfOptionalExpressionOrSpreadElement`

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

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

`type Output = ListOfParameter`

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

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

`type Output = ListOfStatement`

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

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

`type Output = ListOfSwitchCase`

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

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

`type Output = ListOfVariableDeclarator`

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

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

`type Output = LiteralBooleanExpression`

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

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

`type Output = LiteralInfinityExpression`

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

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

`type Output = LiteralNullExpression`

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

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

`type Output = LiteralNumericExpression`

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

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

`type Output = LiteralPropertyName`

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

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

`type Output = LiteralRegExpExpression`

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

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

`type Output = LiteralStringExpression`

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

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

`type Output = Module`

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

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

`type Output = NewExpression`

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

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

`type Output = NewTargetExpression`

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

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

`type Output = Null`

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

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

`type Output = ObjectAssignmentTarget`

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

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

`type Output = ObjectBinding`

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

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

`type Output = ObjectExpression`

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

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

`type Output = Offset`

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

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

`type Output = OptionalAssignmentTarget`

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

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

`type Output = OptionalBinding`

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

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

`type Output = OptionalBindingIdentifier`

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

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

`type Output = OptionalBindingOrBindingWithInitializer`

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

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

`type Output = OptionalCatchClause`

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

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

`type Output = OptionalExpression`

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

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

`type Output = OptionalExpressionOrSpreadElement`

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

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

`type Output = OptionalExpressionOrVariableDeclaration`

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

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

`type Output = OptionalIdentifierName`

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

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

`type Output = OptionalLabel`

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

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

`type Output = OptionalPropertyKey`

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

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

`type Output = OptionalStatement`

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

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

`type Output = ReturnStatement`

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

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

`type Output = Script`

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

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

`type Output = SetterContents`

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

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

`type Output = ShorthandProperty`

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

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

`type Output = SpreadElement`

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

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

`type Output = StaticMemberAssignmentTarget`

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

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

`type Output = StaticMemberExpression`

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

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

`type Output = String`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = Super`

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

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

`type Output = SwitchCase`

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

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

`type Output = SwitchDefault`

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

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

`type Output = SwitchStatement`

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

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

`type Output = SwitchStatementWithDefault`

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

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

`type Output = TemplateElement`

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

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

`type Output = TemplateExpression`

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

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

`type Output = ThisExpression`

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

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

`type Output = ThrowStatement`

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

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

`type Output = TryCatchStatement`

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

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

`type Output = TryFinallyStatement`

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

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

`type Output = UnaryExpression`

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

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

`type Output = UpdateExpression`

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

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

`type Output = VariableDeclaration`

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

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

`type Output = VariableDeclarator`

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

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

`type Output = WhileStatement`

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

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

`type Output = WithStatement`

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

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

`type Output = YieldExpression`

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

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

`type Output = YieldStarExpression`

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

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

`type Output = WhileStatement`

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

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

`type Output = WithStatement`

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

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

`type Output = YieldExpression`

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

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

`type Output = YieldStarExpression`

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

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

`type Output = Arguments`

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

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

`type Output = ListOfAssertedBoundName`

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

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

`type Output = ListOfAssertedDeclaredName`

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

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

`type Output = ListOfAssertedMaybePositionalParameterName`

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

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

`type Output = ListOfAssignmentTargetOrAssignmentTargetWithInitializer`

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

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

`type Output = ListOfAssignmentTargetProperty`

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

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

`type Output = ListOfBindingProperty`

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

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

`type Output = ListOfClassElement`

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

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

`type Output = ListOfDirective`

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

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

`type Output = ListOfExportDeclarationOrImportDeclarationOrStatement`

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

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

`type Output = ListOfExportFromSpecifier`

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

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

`type Output = ListOfExportLocalSpecifier`

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

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

`type Output = ListOfExpressionOrTemplateElement`

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

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

`type Output = ListOfImportSpecifier`

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

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

`type Output = ListOfObjectProperty`

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

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

`type Output = ListOfOptionalBindingOrBindingWithInitializer`

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

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

`type Output = ListOfOptionalExpressionOrSpreadElement`

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

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

`type Output = ListOfParameter`

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

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

`type Output = ListOfStatement`

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

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

`type Output = ListOfSwitchCase`

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

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

`type Output = ListOfVariableDeclarator`

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

Loading content...

[−][src]Trait binjs_es6::ast::Walker

Associated Types

type Output

Required methods

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

Implementations on Foreign Types

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

type Output = Self

fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>, [src]

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

type Output = Self

fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>, [src]

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

type Output = Self

fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>, [src]

Implementors

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

type Output = ArrowExpression

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

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

type Output = AssertedDeclaredKind

fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>, [src]

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

type Output = AssertedMaybePositionalParameterName

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

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

type Output = AssignmentTarget

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

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

type Output = AssignmentTargetOrAssignmentTargetWithInitializer

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

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

type Output = AssignmentTargetOrForInOfBinding

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

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

type Output = AssignmentTargetPattern

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

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

type Output = AssignmentTargetProperty

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

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

type Output = BinaryOperator

fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>, [src]

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

type Output = Binding

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

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

type Output = BindingOrBindingWithInitializer

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

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

type Output = BindingPattern

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

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

type Output = BindingProperty

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

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

type Output = ClassDeclarationOrExpressionOrFunctionDeclaration

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

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

type Output = ClassDeclarationOrFunctionDeclarationOrVariableDeclaration

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

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

type Output = CompoundAssignmentOperator

fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>, [src]

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

type Output = ExportDeclaration

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

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

type Output = ExportDeclarationOrImportDeclarationOrStatement

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

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

type Output = Expression

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

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

type Output = ExpressionOrSpreadElement

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

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

type Output = ExpressionOrSuper

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

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

`type Output`

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

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

`type Output = Self`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = Self`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = Self`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = ArrowExpression`

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

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

`type Output = AssertedDeclaredKind`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

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

`type Output = AssertedMaybePositionalParameterName`

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

`impl<'a> Walker<'a> for AssignmentTarget`[src]

`type Output = AssignmentTarget`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<AssignmentTarget>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetOrAssignmentTargetWithInitializer`[src]

`type Output = AssignmentTargetOrAssignmentTargetWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<AssignmentTargetOrAssignmentTargetWithInitializer>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetOrForInOfBinding`[src]

`type Output = AssignmentTargetOrForInOfBinding`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<AssignmentTargetOrForInOfBinding>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetPattern`[src]

`type Output = AssignmentTargetPattern`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<AssignmentTargetPattern>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for AssignmentTargetProperty`[src]

`type Output = AssignmentTargetProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<AssignmentTargetProperty>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for BinaryOperator where Self: 'a,` [src]

`type Output = BinaryOperator`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for Binding`[src]

`type Output = Binding`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<Binding>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for BindingOrBindingWithInitializer`[src]

`type Output = BindingOrBindingWithInitializer`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<BindingOrBindingWithInitializer>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for BindingPattern`[src]

`type Output = BindingPattern`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<BindingPattern>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for BindingProperty`[src]

`type Output = BindingProperty`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<BindingProperty>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ClassDeclarationOrExpressionOrFunctionDeclaration`[src]

`type Output = ClassDeclarationOrExpressionOrFunctionDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ClassDeclarationOrFunctionDeclarationOrVariableDeclaration`[src]

`type Output = ClassDeclarationOrFunctionDeclarationOrVariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for CompoundAssignmentOperator where Self: 'a,` [src]

`type Output = CompoundAssignmentOperator`

`fn walk<V, E, G>( &'a mut self, _: &mut WalkPath, _: &mut V ) -> Result<Option<Self::Output>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ExportDeclaration`[src]

`type Output = ExportDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ExportDeclaration>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ExportDeclarationOrImportDeclarationOrStatement`[src]

`type Output = ExportDeclarationOrImportDeclarationOrStatement`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ExportDeclarationOrImportDeclarationOrStatement>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for Expression`[src]

`type Output = Expression`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<Expression>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ExpressionOrSpreadElement`[src]

`type Output = ExpressionOrSpreadElement`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ExpressionOrSpreadElement>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ExpressionOrSuper`[src]

`type Output = ExpressionOrSuper`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ExpressionOrSuper>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ExpressionOrTemplateElement`[src]

`type Output = ExpressionOrTemplateElement`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ExpressionOrTemplateElement>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]

`impl<'a> Walker<'a> for ExpressionOrVariableDeclaration`[src]

`type Output = ExpressionOrVariableDeclaration`

`fn walk<V, E, G>( &'a mut self, path: &mut WalkPath, visitor: &mut V ) -> Result<Option<ExpressionOrVariableDeclaration>, E> where V: Visitor<E, G>, G: WalkGuard<V>,` [src]