Enum ModuleDeclaration 

#[repr(C, u8)]
pub enum ModuleDeclaration<'a> {
    ImportDeclaration(Box<'a, ImportDeclaration<'a>>),
    ExportAllDeclaration(Box<'a, ExportAllDeclaration<'a>>),
    ExportDefaultDeclaration(Box<'a, ExportDefaultDeclaration<'a>>),
    ExportNamedDeclaration(Box<'a, ExportNamedDeclaration<'a>>),
    TSExportAssignment(Box<'a, TSExportAssignment<'a>>),
    TSNamespaceExportDeclaration(Box<'a, TSNamespaceExportDeclaration<'a>>),
}

ES6 Module Declaration

An ESM import or export statement.

Example

// ImportDeclaration
import { foo } from 'foo';
import bar from 'bar';
import * as baz from 'baz';

// Not a ModuleDeclaration
export const a = 5;

const b = 6;

export { b };             // ExportNamedDeclaration
export default b;         // ExportDefaultDeclaration
export * as c from './c'; // ExportAllDeclaration
export = b;               // TSExportAssignment
export as namespace d;    // TSNamespaceExportDeclaration

Variants

ImportDeclaration(Box<'a, ImportDeclaration<'a>>)

import hello from './world.js'; import * as t from './world.js';

ExportAllDeclaration(Box<'a, ExportAllDeclaration<'a>>)

export * as numbers from '../numbers.js'

ExportDefaultDeclaration(Box<'a, ExportDefaultDeclaration<'a>>)

export default 5;

ExportNamedDeclaration(Box<'a, ExportNamedDeclaration<'a>>)

export {five} from './numbers.js'; export {six, seven};

TSExportAssignment(Box<'a, TSExportAssignment<'a>>)

export = 5;

TSNamespaceExportDeclaration(Box<'a, TSNamespaceExportDeclaration<'a>>)

export as namespace React;

Implementations

impl<'a> ModuleDeclaration<'a>

pub fn is_typescript_syntax(&self) -> bool

Returns true if this module declaration uses any TypeScript syntax such as the type or declare keywords.

pub fn is_import(&self) -> bool

Returns true if this is an import declaration.

pub fn is_export(&self) -> bool

Returns true if this is an export declaration.

pub fn is_default_export(&self) -> bool

Returns `true`` if this is a default export declaration.

pub fn source(&self) -> Option<&StringLiteral<'a>>

Returns the import/export source of this module declaration, if it has one.

Example

• import foo from "foo/thing" => "foo/thing"
• export * from "foo" => "foo"
• export default foo => None

pub fn with_clause(&self) -> Option<&WithClause<'a>>

Returns the with clause of an import/export declaration, if it has one.

Example

• import thing from "lib" with { key: "data" } => Some(WithClause)
• export * from "lib" with { key: "data" } => Some(WithClause)
• export default thing => None

Trait Implementations

impl<'a> BoundNames<'a> for ModuleDeclaration<'a>

fn bound_names<F>(&self, f: &mut F)

where F: FnMut(&BindingIdentifier<'a>),

impl<'new_alloc> CloneIn<'new_alloc> for ModuleDeclaration<'_>

type Cloned = ModuleDeclaration<'new_alloc>

The type of the cloned object.

fn clone_in( &self, allocator: &'new_alloc Allocator, ) -> <ModuleDeclaration<'_> as CloneIn<'new_alloc>>::Cloned

Clone self into the given allocator. allocator may be the same one that self is already in.

fn clone_in_with_semantic_ids( &self, allocator: &'new_alloc Allocator, ) -> <ModuleDeclaration<'_> as CloneIn<'new_alloc>>::Cloned

Almost identical as clone_in, but for some special type, it will also clone the semantic ids. Please use this method only if you make sure semantic info is synced with the ast node.

impl ContentEq for ModuleDeclaration<'_>

fn content_eq(&self, other: &ModuleDeclaration<'_>) -> bool

This method tests for contents of self and other to be equal.

fn content_ne(&self, other: &Self) -> bool

This method tests for contents of self and other not to be equal. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Debug for ModuleDeclaration<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Dummy<'a> for ModuleDeclaration<'a>

fn dummy(allocator: &'a Allocator) -> ModuleDeclaration<'a>

Create a dummy ModuleDeclaration.

Has cost of making 1 allocation (32 bytes).

impl ESTree for ModuleDeclaration<'_>

fn serialize<S>(&self, serializer: S)

where S: Serializer,

impl<'a> From<ModuleDeclaration<'a>> for Statement<'a>

fn from(value: ModuleDeclaration<'a>) -> Statement<'a>

Convert ModuleDeclaration to Statement.

impl GetAddress for ModuleDeclaration<'_>

fn address(&self) -> Address

Get the memory address of a value allocated in the arena.

impl GetSpan for ModuleDeclaration<'_>

fn span(&self) -> Span

Get the Span for an AST node.

impl GetSpanMut for ModuleDeclaration<'_>

fn span_mut(&mut self) -> &mut Span

Get a mutable reference to an AST node’s Span.

impl<'a> TakeIn<'a> for ModuleDeclaration<'a>

fn take_in<A>(&mut self, allocator_accessor: A) -> Self

where A: AllocatorAccessor<'a>,

Replace node with a dummy.

fn take_in_box<A>(&mut self, allocator_accessor: A) -> Box<'a, Self>

where A: AllocatorAccessor<'a>,

Replace node with a boxed dummy.

impl<'a> TryFrom<Statement<'a>> for ModuleDeclaration<'a>

fn try_from( value: Statement<'a>, ) -> Result<ModuleDeclaration<'a>, <ModuleDeclaration<'a> as TryFrom<Statement<'a>>>::Error>

Convert Statement to ModuleDeclaration.

type Error = ()

The type returned in the event of a conversion error.