Struct binjs::specialized::es6::io::Deserializer

pub struct Deserializer<R> where
    R: TokenReader,  {
    pub reader: R,
}

A structure used for deserialization purposes.

Fields

reader: R

Methods

impl<R> Deserializer<R> where
    R: TokenReader, 

pub fn new(reader: R) -> Deserializer<R>

Trait Implementations

impl<R> Deserialization<ArrayAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrayAssignmentTarget, TokenReaderError>

impl<R> Deserialization<ArrayBinding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrayBinding, TokenReaderError>

impl<R> Deserialization<ArrayExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrayExpression, TokenReaderError>

impl<R> Deserialization<ArrowExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrowExpression, TokenReaderError>

impl<R> Deserialization<ArrowExpressionContentsWithExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrowExpressionContentsWithExpression, TokenReaderError>

impl<R> Deserialization<ArrowExpressionContentsWithFunctionBody> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrowExpressionContentsWithFunctionBody, TokenReaderError>

impl<R> Deserialization<AssertedBlockScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedBlockScope, TokenReaderError>

impl<R> Deserialization<AssertedBoundName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedBoundName, TokenReaderError>

impl<R> Deserialization<AssertedBoundNamesScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedBoundNamesScope, TokenReaderError>

impl<R> Deserialization<AssertedDeclaredKind> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedDeclaredKind, TokenReaderError>

impl<R> Deserialization<AssertedDeclaredName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedDeclaredName, TokenReaderError>

impl<R> Deserialization<AssertedMaybePositionalParameterName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedMaybePositionalParameterName, TokenReaderError>

impl<R> Deserialization<AssertedParameterName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedParameterName, TokenReaderError>

impl<R> Deserialization<AssertedParameterScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedParameterScope, TokenReaderError>

impl<R> Deserialization<AssertedPositionalParameterName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedPositionalParameterName, TokenReaderError>

impl<R> Deserialization<AssertedRestParameterName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedRestParameterName, TokenReaderError>

impl<R> Deserialization<AssertedScriptGlobalScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedScriptGlobalScope, TokenReaderError>

impl<R> Deserialization<AssertedVarScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedVarScope, TokenReaderError>

impl<R> Deserialization<AssignmentExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentExpression, TokenReaderError>

impl<R> Deserialization<AssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTarget, TokenReaderError>

impl<R> Deserialization<AssignmentTargetIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetIdentifier, TokenReaderError>

impl<R> Deserialization<AssignmentTargetOrAssignmentTargetWithInitializer> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetOrAssignmentTargetWithInitializer, TokenReaderError>

impl<R> Deserialization<AssignmentTargetOrForInOfBinding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetOrForInOfBinding, TokenReaderError>

impl<R> Deserialization<AssignmentTargetPattern> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetPattern, TokenReaderError>

impl<R> Deserialization<AssignmentTargetProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetProperty, TokenReaderError>

impl<R> Deserialization<AssignmentTargetPropertyIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetPropertyIdentifier, TokenReaderError>

impl<R> Deserialization<AssignmentTargetPropertyProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetPropertyProperty, TokenReaderError>

impl<R> Deserialization<AssignmentTargetWithInitializer> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetWithInitializer, TokenReaderError>

impl<R> Deserialization<AwaitExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AwaitExpression, TokenReaderError>

impl<R> Deserialization<BinASTExpressionWithProbabilityTable> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BinASTExpressionWithProbabilityTable, TokenReaderError>

impl<R> Deserialization<BinaryExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BinaryExpression, TokenReaderError>

impl<R> Deserialization<BinaryOperator> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BinaryOperator, TokenReaderError>

impl<R> Deserialization<Binding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Binding, TokenReaderError>

impl<R> Deserialization<BindingIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingIdentifier, TokenReaderError>

impl<R> Deserialization<BindingOrBindingWithInitializer> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingOrBindingWithInitializer, TokenReaderError>

impl<R> Deserialization<BindingPattern> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingPattern, TokenReaderError>

impl<R> Deserialization<BindingProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingProperty, TokenReaderError>

impl<R> Deserialization<BindingPropertyIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingPropertyIdentifier, TokenReaderError>

impl<R> Deserialization<BindingPropertyProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingPropertyProperty, TokenReaderError>

impl<R> Deserialization<BindingWithInitializer> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingWithInitializer, TokenReaderError>

impl<R> Deserialization<Block> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Block, TokenReaderError>

impl<R> Deserialization<BreakStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BreakStatement, TokenReaderError>

impl<R> Deserialization<CallExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<CallExpression, TokenReaderError>

impl<R> Deserialization<CatchClause> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<CatchClause, TokenReaderError>

impl<R> Deserialization<ClassDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassDeclaration, TokenReaderError>

impl<R> Deserialization<ClassDeclarationOrExpressionOrFunctionDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassDeclarationOrExpressionOrFunctionDeclaration, TokenReaderError>

impl<R> Deserialization<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration, TokenReaderError>

impl<R> Deserialization<ClassElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassElement, TokenReaderError>

impl<R> Deserialization<ClassExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassExpression, TokenReaderError>

impl<R> Deserialization<CompoundAssignmentExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<CompoundAssignmentExpression, TokenReaderError>

impl<R> Deserialization<CompoundAssignmentOperator> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<CompoundAssignmentOperator, TokenReaderError>

impl<R> Deserialization<ComputedMemberAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ComputedMemberAssignmentTarget, TokenReaderError>

impl<R> Deserialization<ComputedMemberExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ComputedMemberExpression, TokenReaderError>

impl<R> Deserialization<ComputedPropertyName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ComputedPropertyName, TokenReaderError>

impl<R> Deserialization<ConditionalExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ConditionalExpression, TokenReaderError>

impl<R> Deserialization<ContinueStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ContinueStatement, TokenReaderError>

impl<R> Deserialization<DataProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<DataProperty, TokenReaderError>

impl<R> Deserialization<DebuggerStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<DebuggerStatement, TokenReaderError>

impl<R> Deserialization<Directive> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Directive, TokenReaderError>

impl<R> Deserialization<DoWhileStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<DoWhileStatement, TokenReaderError>

impl<R> Deserialization<EagerArrowExpressionWithExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerArrowExpressionWithExpression, TokenReaderError>

impl<R> Deserialization<EagerArrowExpressionWithFunctionBody> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerArrowExpressionWithFunctionBody, TokenReaderError>

impl<R> Deserialization<EagerFunctionDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerFunctionDeclaration, TokenReaderError>

impl<R> Deserialization<EagerFunctionExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerFunctionExpression, TokenReaderError>

impl<R> Deserialization<EagerGetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerGetter, TokenReaderError>

impl<R> Deserialization<EagerMethod> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerMethod, TokenReaderError>

impl<R> Deserialization<EagerSetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerSetter, TokenReaderError>

impl<R> Deserialization<EmptyStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EmptyStatement, TokenReaderError>

impl<R> Deserialization<Export> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Export, TokenReaderError>

impl<R> Deserialization<ExportAllFrom> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportAllFrom, TokenReaderError>

impl<R> Deserialization<ExportDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportDeclaration, TokenReaderError>

impl<R> Deserialization<ExportDeclarationOrImportDeclarationOrStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportDeclarationOrImportDeclarationOrStatement, TokenReaderError>

impl<R> Deserialization<ExportDefault> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportDefault, TokenReaderError>

impl<R> Deserialization<ExportFrom> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportFrom, TokenReaderError>

impl<R> Deserialization<ExportFromSpecifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportFromSpecifier, TokenReaderError>

impl<R> Deserialization<ExportLocalSpecifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportLocalSpecifier, TokenReaderError>

impl<R> Deserialization<ExportLocals> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportLocals, TokenReaderError>

impl<R> Deserialization<Expression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Expression, TokenReaderError>

impl<R> Deserialization<ExpressionOrSpreadElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExpressionOrSpreadElement, TokenReaderError>

impl<R> Deserialization<ExpressionOrSuper> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExpressionOrSuper, TokenReaderError>

impl<R> Deserialization<ExpressionOrTemplateElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExpressionOrTemplateElement, TokenReaderError>

impl<R> Deserialization<ExpressionOrVariableDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExpressionOrVariableDeclaration, TokenReaderError>

impl<R> Deserialization<ExpressionStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExpressionStatement, TokenReaderError>

impl<R> Deserialization<ForInOfBinding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForInOfBinding, TokenReaderError>

impl<R> Deserialization<ForInStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForInStatement, TokenReaderError>

impl<R> Deserialization<ForOfStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForOfStatement, TokenReaderError>

impl<R> Deserialization<ForStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForStatement, TokenReaderError>

impl<R> Deserialization<FormalParameters> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FormalParameters, TokenReaderError>

impl<R> Deserialization<FunctionDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FunctionDeclaration, TokenReaderError>

impl<R> Deserialization<FunctionExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FunctionExpression, TokenReaderError>

impl<R> Deserialization<FunctionExpressionContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FunctionExpressionContents, TokenReaderError>

impl<R> Deserialization<FunctionOrMethodContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FunctionOrMethodContents, TokenReaderError>

impl<R> Deserialization<Getter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Getter, TokenReaderError>

impl<R> Deserialization<GetterContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<GetterContents, TokenReaderError>

impl<R> Deserialization<IdentifierExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<IdentifierExpression, TokenReaderError>

impl<R> Deserialization<IdentifierName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<IdentifierName, TokenReaderError>

impl<R> Deserialization<IfStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<IfStatement, TokenReaderError>

impl<R> Deserialization<Import> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Import, TokenReaderError>

impl<R> Deserialization<ImportDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ImportDeclaration, TokenReaderError>

impl<R> Deserialization<ImportNamespace> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ImportNamespace, TokenReaderError>

impl<R> Deserialization<ImportSpecifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ImportSpecifier, TokenReaderError>

impl<R> Deserialization<IterationStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<IterationStatement, TokenReaderError>

impl<R> Deserialization<LabelledStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LabelledStatement, TokenReaderError>

impl<R> Deserialization<LazyArrowExpressionWithExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyArrowExpressionWithExpression, TokenReaderError>

impl<R> Deserialization<LazyArrowExpressionWithFunctionBody> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyArrowExpressionWithFunctionBody, TokenReaderError>

impl<R> Deserialization<LazyFunctionDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyFunctionDeclaration, TokenReaderError>

impl<R> Deserialization<LazyFunctionExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyFunctionExpression, TokenReaderError>

impl<R> Deserialization<LazyGetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyGetter, TokenReaderError>

impl<R> Deserialization<LazyMethod> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyMethod, TokenReaderError>

impl<R> Deserialization<LazySetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazySetter, TokenReaderError>

impl<R> Deserialization<Literal> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Literal, TokenReaderError>

impl<R> Deserialization<LiteralBooleanExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralBooleanExpression, TokenReaderError>

impl<R> Deserialization<LiteralInfinityExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralInfinityExpression, TokenReaderError>

impl<R> Deserialization<LiteralNullExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralNullExpression, TokenReaderError>

impl<R> Deserialization<LiteralNumericExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralNumericExpression, TokenReaderError>

impl<R> Deserialization<LiteralPropertyName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralPropertyName, TokenReaderError>

impl<R> Deserialization<LiteralRegExpExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralRegExpExpression, TokenReaderError>

impl<R> Deserialization<LiteralStringExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralStringExpression, TokenReaderError>

impl<R> Deserialization<Method> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Method, TokenReaderError>

impl<R> Deserialization<MethodDefinition> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<MethodDefinition, TokenReaderError>

impl<R> Deserialization<Module> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Module, TokenReaderError>

impl<R> Deserialization<NewExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<NewExpression, TokenReaderError>

impl<R> Deserialization<NewTargetExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<NewTargetExpression, TokenReaderError>

impl<R> Deserialization<Null> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Null, TokenReaderError>

impl<R> Deserialization<ObjectAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ObjectAssignmentTarget, TokenReaderError>

impl<R> Deserialization<ObjectBinding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ObjectBinding, TokenReaderError>

impl<R> Deserialization<ObjectExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ObjectExpression, TokenReaderError>

impl<R> Deserialization<ObjectProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ObjectProperty, TokenReaderError>

impl<R> Deserialization<Offset> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Offset, TokenReaderError>

impl<R> Deserialization<Option<ArrayAssignmentTarget>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ArrayAssignmentTarget>, TokenReaderError>

impl<R> Deserialization<Option<ArrayBinding>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ArrayBinding>, TokenReaderError>

impl<R> Deserialization<Option<ArrayExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ArrayExpression>, TokenReaderError>

impl<R> Deserialization<Option<ArrowExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ArrowExpression>, TokenReaderError>

impl<R> Deserialization<Option<ArrowExpressionContentsWithExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ArrowExpressionContentsWithExpression>, TokenReaderError>

impl<R> Deserialization<Option<ArrowExpressionContentsWithFunctionBody>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ArrowExpressionContentsWithFunctionBody>, TokenReaderError>

impl<R> Deserialization<Option<AssertedBlockScope>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedBlockScope>, TokenReaderError>

impl<R> Deserialization<Option<AssertedBoundName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedBoundName>, TokenReaderError>

impl<R> Deserialization<Option<AssertedBoundNamesScope>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedBoundNamesScope>, TokenReaderError>

impl<R> Deserialization<Option<AssertedDeclaredName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedDeclaredName>, TokenReaderError>

impl<R> Deserialization<Option<AssertedMaybePositionalParameterName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedMaybePositionalParameterName>, TokenReaderError>

impl<R> Deserialization<Option<AssertedParameterName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedParameterName>, TokenReaderError>

impl<R> Deserialization<Option<AssertedParameterScope>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedParameterScope>, TokenReaderError>

impl<R> Deserialization<Option<AssertedPositionalParameterName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedPositionalParameterName>, TokenReaderError>

impl<R> Deserialization<Option<AssertedRestParameterName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedRestParameterName>, TokenReaderError>

impl<R> Deserialization<Option<AssertedScriptGlobalScope>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedScriptGlobalScope>, TokenReaderError>

impl<R> Deserialization<Option<AssertedVarScope>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssertedVarScope>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentExpression>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTarget>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTarget>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetIdentifier>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetIdentifier>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetOrAssignmentTargetWithInitializer>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetOrAssignmentTargetWithInitializer>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetOrForInOfBinding>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetOrForInOfBinding>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetPattern>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetPattern>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetProperty>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetProperty>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetPropertyIdentifier>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetPropertyIdentifier>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetPropertyProperty>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetPropertyProperty>, TokenReaderError>

impl<R> Deserialization<Option<AssignmentTargetWithInitializer>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AssignmentTargetWithInitializer>, TokenReaderError>

impl<R> Deserialization<Option<AwaitExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<AwaitExpression>, TokenReaderError>

impl<R> Deserialization<Option<BinASTExpressionWithProbabilityTable>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BinASTExpressionWithProbabilityTable>, TokenReaderError>

impl<R> Deserialization<Option<BinaryExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BinaryExpression>, TokenReaderError>

impl<R> Deserialization<Option<Binding>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Binding>, TokenReaderError>

impl<R> Deserialization<Option<BindingIdentifier>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BindingIdentifier>, TokenReaderError>

impl<R> Deserialization<Option<BindingOrBindingWithInitializer>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BindingOrBindingWithInitializer>, TokenReaderError>

impl<R> Deserialization<Option<BindingPattern>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BindingPattern>, TokenReaderError>

impl<R> Deserialization<Option<BindingProperty>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BindingProperty>, TokenReaderError>

impl<R> Deserialization<Option<BindingPropertyIdentifier>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BindingPropertyIdentifier>, TokenReaderError>

impl<R> Deserialization<Option<BindingPropertyProperty>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BindingPropertyProperty>, TokenReaderError>

impl<R> Deserialization<Option<BindingWithInitializer>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BindingWithInitializer>, TokenReaderError>

impl<R> Deserialization<Option<Block>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Block>, TokenReaderError>

impl<R> Deserialization<Option<BreakStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<BreakStatement>, TokenReaderError>

impl<R> Deserialization<Option<CallExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<CallExpression>, TokenReaderError>

impl<R> Deserialization<Option<CatchClause>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<CatchClause>, TokenReaderError>

impl<R> Deserialization<Option<ClassDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ClassDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ClassDeclarationOrExpressionOrFunctionDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ClassDeclarationOrFunctionDeclarationOrVariableDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<ClassElement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ClassElement>, TokenReaderError>

impl<R> Deserialization<Option<ClassExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ClassExpression>, TokenReaderError>

impl<R> Deserialization<Option<CompoundAssignmentExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<CompoundAssignmentExpression>, TokenReaderError>

impl<R> Deserialization<Option<ComputedMemberAssignmentTarget>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ComputedMemberAssignmentTarget>, TokenReaderError>

impl<R> Deserialization<Option<ComputedMemberExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ComputedMemberExpression>, TokenReaderError>

impl<R> Deserialization<Option<ComputedPropertyName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ComputedPropertyName>, TokenReaderError>

impl<R> Deserialization<Option<ConditionalExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ConditionalExpression>, TokenReaderError>

impl<R> Deserialization<Option<ContinueStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ContinueStatement>, TokenReaderError>

impl<R> Deserialization<Option<DataProperty>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<DataProperty>, TokenReaderError>

impl<R> Deserialization<Option<DebuggerStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<DebuggerStatement>, TokenReaderError>

impl<R> Deserialization<Option<Directive>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Directive>, TokenReaderError>

impl<R> Deserialization<Option<DoWhileStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<DoWhileStatement>, TokenReaderError>

impl<R> Deserialization<Option<EagerArrowExpressionWithExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EagerArrowExpressionWithExpression>, TokenReaderError>

impl<R> Deserialization<Option<EagerArrowExpressionWithFunctionBody>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EagerArrowExpressionWithFunctionBody>, TokenReaderError>

impl<R> Deserialization<Option<EagerFunctionDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EagerFunctionDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<EagerFunctionExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EagerFunctionExpression>, TokenReaderError>

impl<R> Deserialization<Option<EagerGetter>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EagerGetter>, TokenReaderError>

impl<R> Deserialization<Option<EagerMethod>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EagerMethod>, TokenReaderError>

impl<R> Deserialization<Option<EagerSetter>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EagerSetter>, TokenReaderError>

impl<R> Deserialization<Option<EmptyStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<EmptyStatement>, TokenReaderError>

impl<R> Deserialization<Option<Export>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Export>, TokenReaderError>

impl<R> Deserialization<Option<ExportAllFrom>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportAllFrom>, TokenReaderError>

impl<R> Deserialization<Option<ExportDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<ExportDeclarationOrImportDeclarationOrStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportDeclarationOrImportDeclarationOrStatement>, TokenReaderError>

impl<R> Deserialization<Option<ExportDefault>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportDefault>, TokenReaderError>

impl<R> Deserialization<Option<ExportFrom>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportFrom>, TokenReaderError>

impl<R> Deserialization<Option<ExportFromSpecifier>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportFromSpecifier>, TokenReaderError>

impl<R> Deserialization<Option<ExportLocalSpecifier>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportLocalSpecifier>, TokenReaderError>

impl<R> Deserialization<Option<ExportLocals>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExportLocals>, TokenReaderError>

impl<R> Deserialization<Option<Expression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Expression>, TokenReaderError>

impl<R> Deserialization<Option<ExpressionOrSpreadElement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExpressionOrSpreadElement>, TokenReaderError>

impl<R> Deserialization<Option<ExpressionOrSuper>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExpressionOrSuper>, TokenReaderError>

impl<R> Deserialization<Option<ExpressionOrTemplateElement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExpressionOrTemplateElement>, TokenReaderError>

impl<R> Deserialization<Option<ExpressionOrVariableDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExpressionOrVariableDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<ExpressionStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ExpressionStatement>, TokenReaderError>

impl<R> Deserialization<Option<ForInOfBinding>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ForInOfBinding>, TokenReaderError>

impl<R> Deserialization<Option<ForInStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ForInStatement>, TokenReaderError>

impl<R> Deserialization<Option<ForOfStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ForOfStatement>, TokenReaderError>

impl<R> Deserialization<Option<ForStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ForStatement>, TokenReaderError>

impl<R> Deserialization<Option<FormalParameters>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<FormalParameters>, TokenReaderError>

impl<R> Deserialization<Option<FunctionDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<FunctionDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<FunctionExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<FunctionExpression>, TokenReaderError>

impl<R> Deserialization<Option<FunctionExpressionContents>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<FunctionExpressionContents>, TokenReaderError>

impl<R> Deserialization<Option<FunctionOrMethodContents>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<FunctionOrMethodContents>, TokenReaderError>

impl<R> Deserialization<Option<Getter>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Getter>, TokenReaderError>

impl<R> Deserialization<Option<GetterContents>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<GetterContents>, TokenReaderError>

impl<R> Deserialization<Option<IdentifierExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<IdentifierExpression>, TokenReaderError>

impl<R> Deserialization<Option<IdentifierName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<IdentifierName>, TokenReaderError>

impl<R> Deserialization<Option<IfStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<IfStatement>, TokenReaderError>

impl<R> Deserialization<Option<Import>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Import>, TokenReaderError>

impl<R> Deserialization<Option<ImportDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ImportDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<ImportNamespace>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ImportNamespace>, TokenReaderError>

impl<R> Deserialization<Option<ImportSpecifier>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ImportSpecifier>, TokenReaderError>

impl<R> Deserialization<Option<IterationStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<IterationStatement>, TokenReaderError>

impl<R> Deserialization<Option<LabelledStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LabelledStatement>, TokenReaderError>

impl<R> Deserialization<Option<LazyArrowExpressionWithExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LazyArrowExpressionWithExpression>, TokenReaderError>

impl<R> Deserialization<Option<LazyArrowExpressionWithFunctionBody>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LazyArrowExpressionWithFunctionBody>, TokenReaderError>

impl<R> Deserialization<Option<LazyFunctionDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LazyFunctionDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<LazyFunctionExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LazyFunctionExpression>, TokenReaderError>

impl<R> Deserialization<Option<LazyGetter>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LazyGetter>, TokenReaderError>

impl<R> Deserialization<Option<LazyMethod>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LazyMethod>, TokenReaderError>

impl<R> Deserialization<Option<LazySetter>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LazySetter>, TokenReaderError>

impl<R> Deserialization<Option<Literal>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Literal>, TokenReaderError>

impl<R> Deserialization<Option<LiteralBooleanExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LiteralBooleanExpression>, TokenReaderError>

impl<R> Deserialization<Option<LiteralInfinityExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LiteralInfinityExpression>, TokenReaderError>

impl<R> Deserialization<Option<LiteralNullExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LiteralNullExpression>, TokenReaderError>

impl<R> Deserialization<Option<LiteralNumericExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LiteralNumericExpression>, TokenReaderError>

impl<R> Deserialization<Option<LiteralPropertyName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LiteralPropertyName>, TokenReaderError>

impl<R> Deserialization<Option<LiteralRegExpExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LiteralRegExpExpression>, TokenReaderError>

impl<R> Deserialization<Option<LiteralStringExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<LiteralStringExpression>, TokenReaderError>

impl<R> Deserialization<Option<Method>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Method>, TokenReaderError>

impl<R> Deserialization<Option<MethodDefinition>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<MethodDefinition>, TokenReaderError>

impl<R> Deserialization<Option<Module>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Module>, TokenReaderError>

impl<R> Deserialization<Option<NewExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<NewExpression>, TokenReaderError>

impl<R> Deserialization<Option<NewTargetExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<NewTargetExpression>, TokenReaderError>

impl<R> Deserialization<Option<Null>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Null>, TokenReaderError>

impl<R> Deserialization<Option<ObjectAssignmentTarget>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ObjectAssignmentTarget>, TokenReaderError>

impl<R> Deserialization<Option<ObjectBinding>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ObjectBinding>, TokenReaderError>

impl<R> Deserialization<Option<ObjectExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ObjectExpression>, TokenReaderError>

impl<R> Deserialization<Option<ObjectProperty>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ObjectProperty>, TokenReaderError>

impl<R> Deserialization<Option<Parameter>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Parameter>, TokenReaderError>

impl<R> Deserialization<Option<Program>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Program>, TokenReaderError>

impl<R> Deserialization<Option<PropertyKey>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<PropertyKey>, TokenReaderError>

impl<R> Deserialization<Option<PropertyName>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<PropertyName>, TokenReaderError>

impl<R> Deserialization<Option<ReturnStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ReturnStatement>, TokenReaderError>

impl<R> Deserialization<Option<Script>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Script>, TokenReaderError>

impl<R> Deserialization<Option<Setter>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Setter>, TokenReaderError>

impl<R> Deserialization<Option<SetterContents>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SetterContents>, TokenReaderError>

impl<R> Deserialization<Option<SharedString>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SharedString>, TokenReaderError>

impl<R> Deserialization<Option<ShorthandProperty>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ShorthandProperty>, TokenReaderError>

impl<R> Deserialization<Option<SimpleAssignmentTarget>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SimpleAssignmentTarget>, TokenReaderError>

impl<R> Deserialization<Option<SpreadElement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SpreadElement>, TokenReaderError>

impl<R> Deserialization<Option<Statement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Statement>, TokenReaderError>

impl<R> Deserialization<Option<StaticMemberAssignmentTarget>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<StaticMemberAssignmentTarget>, TokenReaderError>

impl<R> Deserialization<Option<StaticMemberExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<StaticMemberExpression>, TokenReaderError>

impl<R> Deserialization<Option<Super>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<Super>, TokenReaderError>

impl<R> Deserialization<Option<SwitchCase>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SwitchCase>, TokenReaderError>

impl<R> Deserialization<Option<SwitchDefault>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SwitchDefault>, TokenReaderError>

impl<R> Deserialization<Option<SwitchStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SwitchStatement>, TokenReaderError>

impl<R> Deserialization<Option<SwitchStatementWithDefault>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<SwitchStatementWithDefault>, TokenReaderError>

impl<R> Deserialization<Option<TemplateElement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<TemplateElement>, TokenReaderError>

impl<R> Deserialization<Option<TemplateExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<TemplateExpression>, TokenReaderError>

impl<R> Deserialization<Option<ThisExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ThisExpression>, TokenReaderError>

impl<R> Deserialization<Option<ThrowStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<ThrowStatement>, TokenReaderError>

impl<R> Deserialization<Option<TryCatchStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<TryCatchStatement>, TokenReaderError>

impl<R> Deserialization<Option<TryFinallyStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<TryFinallyStatement>, TokenReaderError>

impl<R> Deserialization<Option<UnaryExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<UnaryExpression>, TokenReaderError>

impl<R> Deserialization<Option<UpdateExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<UpdateExpression>, TokenReaderError>

impl<R> Deserialization<Option<VariableDeclaration>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<VariableDeclaration>, TokenReaderError>

impl<R> Deserialization<Option<VariableDeclarator>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<VariableDeclarator>, TokenReaderError>

impl<R> Deserialization<Option<WhileStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<WhileStatement>, TokenReaderError>

impl<R> Deserialization<Option<WithStatement>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<WithStatement>, TokenReaderError>

impl<R> Deserialization<Option<YieldExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<YieldExpression>, TokenReaderError>

impl<R> Deserialization<Option<YieldStarExpression>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<YieldStarExpression>, TokenReaderError>

impl<R> Deserialization<Option<bool>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<bool>, TokenReaderError>

impl<R> Deserialization<Option<f64>> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Option<f64>, TokenReaderError>

impl<R> Deserialization<Parameter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Parameter, TokenReaderError>

impl<R> Deserialization<Program> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Program, TokenReaderError>

impl<R> Deserialization<PropertyKey> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<PropertyKey, TokenReaderError>

impl<R> Deserialization<PropertyName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<PropertyName, TokenReaderError>

impl<R> Deserialization<ReturnStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ReturnStatement, TokenReaderError>

impl<R> Deserialization<Script> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Script, TokenReaderError>

impl<R> Deserialization<Setter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Setter, TokenReaderError>

impl<R> Deserialization<SetterContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SetterContents, TokenReaderError>

impl<R> Deserialization<SharedString> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SharedString, TokenReaderError>

impl<R> Deserialization<ShorthandProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ShorthandProperty, TokenReaderError>

impl<R> Deserialization<SimpleAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SimpleAssignmentTarget, TokenReaderError>

impl<R> Deserialization<SpreadElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SpreadElement, TokenReaderError>

impl<R> Deserialization<Statement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Statement, TokenReaderError>

impl<R> Deserialization<StaticMemberAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<StaticMemberAssignmentTarget, TokenReaderError>

impl<R> Deserialization<StaticMemberExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<StaticMemberExpression, TokenReaderError>

impl<R> Deserialization<Super> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Super, TokenReaderError>

impl<R> Deserialization<SwitchCase> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchCase, TokenReaderError>

impl<R> Deserialization<SwitchDefault> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchDefault, TokenReaderError>

impl<R> Deserialization<SwitchStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchStatement, TokenReaderError>

impl<R> Deserialization<SwitchStatementWithDefault> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchStatementWithDefault, TokenReaderError>

impl<R> Deserialization<TemplateElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TemplateElement, TokenReaderError>

impl<R> Deserialization<TemplateExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TemplateExpression, TokenReaderError>

impl<R> Deserialization<ThisExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ThisExpression, TokenReaderError>

impl<R> Deserialization<ThrowStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ThrowStatement, TokenReaderError>

impl<R> Deserialization<TryCatchStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TryCatchStatement, TokenReaderError>

impl<R> Deserialization<TryFinallyStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TryFinallyStatement, TokenReaderError>

impl<R> Deserialization<UnaryExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<UnaryExpression, TokenReaderError>

impl<R> Deserialization<UnaryOperator> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<UnaryOperator, TokenReaderError>

impl<R> Deserialization<UpdateExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<UpdateExpression, TokenReaderError>

impl<R> Deserialization<UpdateOperator> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<UpdateOperator, TokenReaderError>

impl<R> Deserialization<VariableDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<VariableDeclaration, TokenReaderError>

impl<R> Deserialization<VariableDeclarationKind> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<VariableDeclarationKind, TokenReaderError>

impl<R> Deserialization<VariableDeclarator> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<VariableDeclarator, TokenReaderError>

impl<R, T> Deserialization<Vec<T>> for Deserializer<R> where
    R: TokenReader,
    Deserializer<R>: Deserialization<T>, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Vec<T>, TokenReaderError>

impl<R> Deserialization<WhileStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<WhileStatement, TokenReaderError>

impl<R> Deserialization<WithStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<WithStatement, TokenReaderError>

impl<R> Deserialization<YieldExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<YieldExpression, TokenReaderError>

impl<R> Deserialization<YieldStarExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<YieldStarExpression, TokenReaderError>

impl<R> Deserialization<bool> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<bool, TokenReaderError>

impl<R> Deserialization<f64> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<f64, TokenReaderError>

impl<R> Deserialization<u32> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<u32, TokenReaderError>

impl<R> InnerDeserialization<ArrayAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrayAssignmentTarget, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ArrayBinding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrayBinding, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ArrayExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrayExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ArrowExpressionContentsWithExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrowExpressionContentsWithExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ArrowExpressionContentsWithFunctionBody> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ArrowExpressionContentsWithFunctionBody, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedBlockScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedBlockScope, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedBoundName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedBoundName, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedBoundNamesScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedBoundNamesScope, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedDeclaredName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedDeclaredName, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedParameterName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedParameterName, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedParameterScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedParameterScope, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedPositionalParameterName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedPositionalParameterName, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedRestParameterName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedRestParameterName, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedScriptGlobalScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedScriptGlobalScope, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssertedVarScope> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssertedVarScope, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssignmentExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssignmentTargetIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetIdentifier, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssignmentTargetPropertyIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetPropertyIdentifier, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssignmentTargetPropertyProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetPropertyProperty, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AssignmentTargetWithInitializer> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AssignmentTargetWithInitializer, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<AwaitExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<AwaitExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<BinASTExpressionWithProbabilityTable> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BinASTExpressionWithProbabilityTable, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<BinaryExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BinaryExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<BindingIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingIdentifier, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<BindingPropertyIdentifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingPropertyIdentifier, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<BindingPropertyProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingPropertyProperty, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<BindingWithInitializer> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BindingWithInitializer, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Block> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Block, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<BreakStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<BreakStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<CallExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<CallExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<CatchClause> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<CatchClause, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ClassDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassDeclaration, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ClassElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassElement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ClassExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ClassExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<CompoundAssignmentExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<CompoundAssignmentExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ComputedMemberAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ComputedMemberAssignmentTarget, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ComputedMemberExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ComputedMemberExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ComputedPropertyName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ComputedPropertyName, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ConditionalExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ConditionalExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ContinueStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ContinueStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<DataProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<DataProperty, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<DebuggerStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<DebuggerStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Directive> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Directive, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<DoWhileStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<DoWhileStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EagerArrowExpressionWithExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerArrowExpressionWithExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EagerArrowExpressionWithFunctionBody> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerArrowExpressionWithFunctionBody, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EagerFunctionDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerFunctionDeclaration, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EagerFunctionExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerFunctionExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EagerGetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerGetter, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EagerMethod> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerMethod, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EagerSetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EagerSetter, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<EmptyStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<EmptyStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Export> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Export, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ExportAllFrom> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportAllFrom, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ExportDefault> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportDefault, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ExportFrom> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportFrom, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ExportFromSpecifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportFromSpecifier, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ExportLocalSpecifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportLocalSpecifier, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ExportLocals> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExportLocals, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ExpressionStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ExpressionStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ForInOfBinding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForInOfBinding, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ForInStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForInStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ForOfStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForOfStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ForStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ForStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<FormalParameters> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FormalParameters, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<FunctionExpressionContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FunctionExpressionContents, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<FunctionOrMethodContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<FunctionOrMethodContents, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<GetterContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<GetterContents, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<IdentifierExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<IdentifierExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<IfStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<IfStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Import> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Import, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ImportNamespace> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ImportNamespace, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ImportSpecifier> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ImportSpecifier, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LabelledStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LabelledStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LazyArrowExpressionWithExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyArrowExpressionWithExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LazyArrowExpressionWithFunctionBody> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyArrowExpressionWithFunctionBody, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LazyFunctionDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyFunctionDeclaration, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LazyFunctionExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyFunctionExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LazyGetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyGetter, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LazyMethod> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazyMethod, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LazySetter> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LazySetter, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LiteralBooleanExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralBooleanExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LiteralInfinityExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralInfinityExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LiteralNullExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralNullExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LiteralNumericExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralNumericExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LiteralPropertyName> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralPropertyName, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LiteralRegExpExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralRegExpExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<LiteralStringExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<LiteralStringExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Module> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Module, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<NewExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<NewExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<NewTargetExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<NewTargetExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Null> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Null, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ObjectAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ObjectAssignmentTarget, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ObjectBinding> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ObjectBinding, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ObjectExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ObjectExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ReturnStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ReturnStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Script> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Script, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<SetterContents> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SetterContents, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ShorthandProperty> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ShorthandProperty, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<SpreadElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SpreadElement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<StaticMemberAssignmentTarget> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<StaticMemberAssignmentTarget, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<StaticMemberExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<StaticMemberExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<Super> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<Super, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<SwitchCase> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchCase, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<SwitchDefault> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchDefault, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<SwitchStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<SwitchStatementWithDefault> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<SwitchStatementWithDefault, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<TemplateElement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TemplateElement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<TemplateExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TemplateExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ThisExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ThisExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<ThrowStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<ThrowStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<TryCatchStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TryCatchStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<TryFinallyStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<TryFinallyStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<UnaryExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<UnaryExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<UpdateExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<UpdateExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<VariableDeclaration> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<VariableDeclaration, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<VariableDeclarator> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<VariableDeclarator, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<WhileStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<WhileStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<WithStatement> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<WithStatement, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<YieldExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<YieldExpression, TokenReaderError> where
    R: TokenReader, 

impl<R> InnerDeserialization<YieldStarExpression> for Deserializer<R> where
    R: TokenReader, 

fn deserialize_inner(
    &mut self,
    path: &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<YieldStarExpression, TokenReaderError> where
    R: TokenReader,