Trait binjs::io::InnerDeserialization

pub trait InnerDeserialization<T> {
    fn deserialize_inner(
        &mut self, 
        &mut Path<InterfaceName, (usize, FieldName)>
    ) -> Result<T, TokenReaderError>;
}

Required methods

fn deserialize_inner(
    &mut self,
    &mut Path<InterfaceName, (usize, FieldName)>
) -> Result<T, TokenReaderError>

Loading content...

Implementors

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, 

Loading content...