Trait binjs_es6::io::Serialization

pub trait Serialization<T> where
    T: ?Sized, {
    fn serialize(
        &mut self, 
        data: &T, 
        path: &mut Path<InterfaceName, (usize, FieldName)>
    ) -> Result<(), TokenWriterError>;
}

Required methods

fn serialize(
    &mut self,
    data: &T,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<(), TokenWriterError>

Serialize a piece of data.

path indicates the path from the root of the AST.

Loading content...

Implementors

impl<W> Serialization<ArrowExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ArrowExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedDeclaredKind> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedDeclaredKind,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedMaybePositionalParameterName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedMaybePositionalParameterName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTarget> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTarget,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetOrAssignmentTargetWithInitializer> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetOrAssignmentTargetWithInitializer,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetOrForInOfBinding> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetOrForInOfBinding,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetPattern> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetPattern,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetProperty> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BinaryOperator> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BinaryOperator,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Binding> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Binding,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BindingOrBindingWithInitializer> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BindingOrBindingWithInitializer,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BindingPattern> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BindingPattern,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BindingProperty> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BindingProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ClassDeclarationOrExpressionOrFunctionDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ClassDeclarationOrExpressionOrFunctionDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ClassDeclarationOrFunctionDeclarationOrVariableDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<CompoundAssignmentOperator> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &CompoundAssignmentOperator,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportDeclarationOrImportDeclarationOrStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportDeclarationOrImportDeclarationOrStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Expression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Expression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExpressionOrSpreadElement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExpressionOrSpreadElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExpressionOrSuper> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExpressionOrSuper,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExpressionOrTemplateElement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExpressionOrTemplateElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExpressionOrVariableDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExpressionOrVariableDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<FunctionDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &FunctionDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<FunctionExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &FunctionExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Getter> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Getter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ImportDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ImportDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<IterationStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &IterationStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Literal> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Literal,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Method> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Method,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<MethodDefinition> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &MethodDefinition,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ObjectProperty> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ObjectProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Parameter> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Parameter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Program> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Program,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<PropertyName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &PropertyName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Setter> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Setter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SimpleAssignmentTarget> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SimpleAssignmentTarget,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Statement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Statement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<UnaryOperator> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &UnaryOperator,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<UpdateOperator> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &UpdateOperator,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<VariableDeclarationKind> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &VariableDeclarationKind,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SharedString> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SharedString,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ArrowExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ArrowExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedMaybePositionalParameterName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedMaybePositionalParameterName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTarget>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTarget>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetOrAssignmentTargetWithInitializer>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetOrAssignmentTargetWithInitializer>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetOrForInOfBinding>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetOrForInOfBinding>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetPattern>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetPattern>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetProperty>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Binding>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Binding>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BindingOrBindingWithInitializer>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BindingOrBindingWithInitializer>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BindingPattern>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BindingPattern>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BindingProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BindingProperty>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ClassDeclarationOrExpressionOrFunctionDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportDeclarationOrImportDeclarationOrStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportDeclarationOrImportDeclarationOrStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Expression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Expression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExpressionOrSpreadElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExpressionOrSpreadElement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExpressionOrSuper>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExpressionOrSuper>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExpressionOrTemplateElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExpressionOrTemplateElement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExpressionOrVariableDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExpressionOrVariableDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<FunctionDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<FunctionDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<FunctionExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<FunctionExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Getter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Getter>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ImportDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ImportDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<IterationStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<IterationStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Literal>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Literal>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Method>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Method>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<MethodDefinition>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<MethodDefinition>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ObjectProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ObjectProperty>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Parameter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Parameter>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Program>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Program>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<PropertyName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<PropertyName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Setter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Setter>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SimpleAssignmentTarget>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SimpleAssignmentTarget>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Statement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Statement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SharedString>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SharedString>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<bool>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<bool>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<f64>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<f64>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ArrayAssignmentTarget>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ArrayAssignmentTarget>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ArrayBinding>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ArrayBinding>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ArrayExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ArrayExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ArrowExpressionContentsWithExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ArrowExpressionContentsWithExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ArrowExpressionContentsWithFunctionBody>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ArrowExpressionContentsWithFunctionBody>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedBlockScope>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedBlockScope>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedBoundName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedBoundName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedBoundNamesScope>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedBoundNamesScope>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedDeclaredName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedDeclaredName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedParameterName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedParameterName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedParameterScope>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedParameterScope>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedPositionalParameterName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedPositionalParameterName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedRestParameterName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedRestParameterName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedScriptGlobalScope>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedScriptGlobalScope>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssertedVarScope>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssertedVarScope>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetIdentifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetIdentifier>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetPropertyIdentifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetPropertyIdentifier>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetPropertyProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetPropertyProperty>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AssignmentTargetWithInitializer>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AssignmentTargetWithInitializer>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<AwaitExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<AwaitExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BinASTExpressionWithProbabilityTable>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BinASTExpressionWithProbabilityTable>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BinaryExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BinaryExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BindingIdentifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BindingIdentifier>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BindingPropertyIdentifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BindingPropertyIdentifier>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BindingPropertyProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BindingPropertyProperty>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BindingWithInitializer>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BindingWithInitializer>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Block>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Block>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<BreakStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<BreakStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<CallExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<CallExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<CatchClause>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<CatchClause>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ClassDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ClassDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ClassElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ClassElement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ClassExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ClassExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<CompoundAssignmentExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<CompoundAssignmentExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ComputedMemberAssignmentTarget>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ComputedMemberAssignmentTarget>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ComputedMemberExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ComputedMemberExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ComputedPropertyName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ComputedPropertyName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ConditionalExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ConditionalExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ContinueStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ContinueStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<DataProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<DataProperty>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<DebuggerStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<DebuggerStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Directive>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Directive>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<DoWhileStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<DoWhileStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EagerArrowExpressionWithExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EagerArrowExpressionWithExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EagerArrowExpressionWithFunctionBody>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EagerArrowExpressionWithFunctionBody>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EagerFunctionDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EagerFunctionDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EagerFunctionExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EagerFunctionExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EagerGetter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EagerGetter>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EagerMethod>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EagerMethod>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EagerSetter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EagerSetter>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<EmptyStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<EmptyStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Export>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Export>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportAllFrom>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportAllFrom>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportDefault>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportDefault>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportFrom>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportFrom>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportFromSpecifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportFromSpecifier>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportLocalSpecifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportLocalSpecifier>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExportLocals>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExportLocals>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ExpressionStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ExpressionStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ForInOfBinding>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ForInOfBinding>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ForInStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ForInStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ForOfStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ForOfStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ForStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ForStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<FormalParameters>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<FormalParameters>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<FunctionExpressionContents>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<FunctionExpressionContents>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<FunctionOrMethodContents>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<FunctionOrMethodContents>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<GetterContents>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<GetterContents>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<IdentifierExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<IdentifierExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<IfStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<IfStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Import>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Import>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ImportNamespace>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ImportNamespace>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ImportSpecifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ImportSpecifier>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LabelledStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LabelledStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LazyArrowExpressionWithExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LazyArrowExpressionWithExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LazyArrowExpressionWithFunctionBody>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LazyArrowExpressionWithFunctionBody>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LazyFunctionDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LazyFunctionDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LazyFunctionExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LazyFunctionExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LazyGetter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LazyGetter>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LazyMethod>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LazyMethod>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LazySetter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LazySetter>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LiteralBooleanExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LiteralBooleanExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LiteralInfinityExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LiteralInfinityExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LiteralNullExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LiteralNullExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LiteralNumericExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LiteralNumericExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LiteralPropertyName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LiteralPropertyName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LiteralRegExpExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LiteralRegExpExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<LiteralStringExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<LiteralStringExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Module>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Module>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<NewExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<NewExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<NewTargetExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<NewTargetExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Null>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Null>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ObjectAssignmentTarget>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ObjectAssignmentTarget>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ObjectBinding>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ObjectBinding>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ObjectExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ObjectExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ReturnStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ReturnStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Script>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Script>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SetterContents>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SetterContents>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ShorthandProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ShorthandProperty>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SpreadElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SpreadElement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<StaticMemberAssignmentTarget>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<StaticMemberAssignmentTarget>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<StaticMemberExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<StaticMemberExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<Super>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<Super>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SwitchCase>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SwitchCase>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SwitchDefault>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SwitchDefault>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SwitchStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SwitchStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<SwitchStatementWithDefault>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<SwitchStatementWithDefault>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<TemplateElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<TemplateElement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<TemplateExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<TemplateExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ThisExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ThisExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<ThrowStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<ThrowStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<TryCatchStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<TryCatchStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<TryFinallyStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<TryFinallyStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<UnaryExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<UnaryExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<UpdateExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<UpdateExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<VariableDeclaration>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<VariableDeclaration>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<VariableDeclarator>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<VariableDeclarator>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<WhileStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<WhileStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<WithStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<WithStatement>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<YieldExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<YieldExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<YieldStarExpression>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<YieldStarExpression>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<IdentifierName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<IdentifierName>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Option<PropertyKey>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Option<PropertyKey>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<bool> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &bool,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<f64> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &f64,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<u32> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &u32,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ArrayAssignmentTarget> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ArrayAssignmentTarget,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ArrayBinding> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ArrayBinding,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ArrayExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ArrayExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ArrowExpressionContentsWithExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ArrowExpressionContentsWithExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ArrowExpressionContentsWithFunctionBody> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ArrowExpressionContentsWithFunctionBody,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedBlockScope> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedBlockScope,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedBoundName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedBoundName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedBoundNamesScope> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedBoundNamesScope,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedDeclaredName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedDeclaredName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedParameterName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedParameterName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedParameterScope> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedParameterScope,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedPositionalParameterName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedPositionalParameterName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedRestParameterName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedRestParameterName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedScriptGlobalScope> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedScriptGlobalScope,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssertedVarScope> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssertedVarScope,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetIdentifier> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetIdentifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetPropertyIdentifier> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetPropertyIdentifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetPropertyProperty> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetPropertyProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AssignmentTargetWithInitializer> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AssignmentTargetWithInitializer,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<AwaitExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &AwaitExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BinASTExpressionWithProbabilityTable> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BinASTExpressionWithProbabilityTable,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BinaryExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BinaryExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BindingIdentifier> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BindingIdentifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BindingPropertyIdentifier> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BindingPropertyIdentifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BindingPropertyProperty> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BindingPropertyProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BindingWithInitializer> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BindingWithInitializer,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Block> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Block,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<BreakStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BreakStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<CallExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &CallExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<CatchClause> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &CatchClause,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ClassDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ClassDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ClassElement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ClassElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ClassExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ClassExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<CompoundAssignmentExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &CompoundAssignmentExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ComputedMemberAssignmentTarget> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ComputedMemberAssignmentTarget,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ComputedMemberExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ComputedMemberExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ComputedPropertyName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ComputedPropertyName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ConditionalExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ConditionalExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ContinueStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ContinueStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<DataProperty> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &DataProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<DebuggerStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &DebuggerStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Directive> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Directive,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<DoWhileStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &DoWhileStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EagerArrowExpressionWithExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EagerArrowExpressionWithExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EagerArrowExpressionWithFunctionBody> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EagerArrowExpressionWithFunctionBody,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EagerFunctionDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EagerFunctionDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EagerFunctionExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EagerFunctionExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EagerGetter> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EagerGetter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EagerMethod> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EagerMethod,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EagerSetter> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EagerSetter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<EmptyStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &EmptyStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Export> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Export,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportAllFrom> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportAllFrom,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportDefault> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportDefault,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportFrom> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportFrom,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportFromSpecifier> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportFromSpecifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportLocalSpecifier> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportLocalSpecifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExportLocals> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExportLocals,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ExpressionStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ExpressionStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ForInOfBinding> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ForInOfBinding,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ForInStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ForInStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ForOfStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ForOfStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ForStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ForStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<FormalParameters> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &FormalParameters,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<FunctionExpressionContents> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &FunctionExpressionContents,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<FunctionOrMethodContents> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &FunctionOrMethodContents,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<GetterContents> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &GetterContents,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<IdentifierExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &IdentifierExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<IfStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &IfStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Import> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Import,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ImportNamespace> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ImportNamespace,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ImportSpecifier> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ImportSpecifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LabelledStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LabelledStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LazyArrowExpressionWithExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LazyArrowExpressionWithExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LazyArrowExpressionWithFunctionBody> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LazyArrowExpressionWithFunctionBody,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LazyFunctionDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LazyFunctionDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LazyFunctionExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LazyFunctionExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LazyGetter> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LazyGetter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LazyMethod> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LazyMethod,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LazySetter> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LazySetter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LiteralBooleanExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LiteralBooleanExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LiteralInfinityExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LiteralInfinityExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LiteralNullExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LiteralNullExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LiteralNumericExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LiteralNumericExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LiteralPropertyName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LiteralPropertyName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LiteralRegExpExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LiteralRegExpExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<LiteralStringExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &LiteralStringExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Module> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Module,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<NewExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &NewExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<NewTargetExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &NewTargetExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Null> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Null,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ObjectAssignmentTarget> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ObjectAssignmentTarget,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ObjectBinding> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ObjectBinding,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ObjectExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ObjectExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ReturnStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ReturnStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Script> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Script,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SetterContents> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SetterContents,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ShorthandProperty> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ShorthandProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SpreadElement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SpreadElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<StaticMemberAssignmentTarget> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &StaticMemberAssignmentTarget,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<StaticMemberExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &StaticMemberExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Super> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Super,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SwitchCase> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SwitchCase,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SwitchDefault> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SwitchDefault,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SwitchStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SwitchStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<SwitchStatementWithDefault> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &SwitchStatementWithDefault,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<TemplateElement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &TemplateElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<TemplateExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &TemplateExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ThisExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ThisExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<ThrowStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ThrowStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<TryCatchStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &TryCatchStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<TryFinallyStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &TryFinallyStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<UnaryExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &UnaryExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<UpdateExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &UpdateExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<VariableDeclaration> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &VariableDeclaration,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<VariableDeclarator> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &VariableDeclarator,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<WhileStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &WhileStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<WithStatement> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &WithStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<YieldExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &YieldExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<YieldStarExpression> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &YieldStarExpression,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<IdentifierName> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &IdentifierName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Offset> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    _: &Offset,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<PropertyKey> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &PropertyKey,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<AssertedMaybePositionalParameterName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfAssertedMaybePositionalParameterName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<AssignmentTargetOrAssignmentTargetWithInitializer>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfAssignmentTargetOrAssignmentTargetWithInitializer,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<AssignmentTargetProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfAssignmentTargetProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<BindingProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfBindingProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ExportDeclarationOrImportDeclarationOrStatement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfExportDeclarationOrImportDeclarationOrStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ExpressionOrSpreadElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &Arguments,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ExpressionOrTemplateElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfExpressionOrTemplateElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ObjectProperty>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfObjectProperty,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<Parameter>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfParameter,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<Statement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfStatement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<Option<BindingOrBindingWithInitializer>>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfOptionalBindingOrBindingWithInitializer,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<Option<ExpressionOrSpreadElement>>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfOptionalExpressionOrSpreadElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<AssertedBoundName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfAssertedBoundName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<AssertedDeclaredName>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfAssertedDeclaredName,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ClassElement>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfClassElement,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<Directive>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfDirective,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ExportFromSpecifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfExportFromSpecifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ExportLocalSpecifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfExportLocalSpecifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<ImportSpecifier>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfImportSpecifier,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<SwitchCase>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfSwitchCase,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W> Serialization<Vec<VariableDeclarator>> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &ListOfVariableDeclarator,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

impl<W, T> Serialization<Box<T>> for Serializer<W> where
    W: TokenWriter,
    T: ?Sized,
    Self: Serialization<T>, 

fn serialize(
    &mut self,
    value: &Box<T>,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

Loading content...