Enum ImportForm 

pub enum ImportForm {
    Es {
        default_import: Option<String>,
        namespace_import: Option<String>,
        named: Vec<String>,
        type_only: bool,
        side_effect: bool,
    },
    Python {
        from_import: bool,
        named: Vec<String>,
    },
    RustUse {
        visibility: Option<String>,
        named: Vec<String>,
    },
    Go {
        alias: Option<String>,
    },
    Solidity {
        named: Vec<String>,
        namespace: Option<String>,
        alias: Option<String>,
    },
    Structured {
        named: Vec<String>,
        namespace: Option<String>,
        alias: Option<String>,
        modifiers: Vec<String>,
        import_kind: Option<String>,
    },
}

Structured, language-honest representation of a single import’s shape.

This is the migration target that replaces the TS-shaped flat fields (names/default_import/namespace_import) and their per-language overloads (Rust packs "pub" into default_import; Go packs the alias there). It is introduced additively alongside the flat fields (Stream M of the imports-refactor plan): parsers populate BOTH, readers migrate onto form one at a time behind the golden-parity gate, and the flat fields are removed once no reader depends on them. New-language variants (Static, Include, RuntimeRequire, …) are added when their engines land — only the variants the existing engines produce exist today.

Variants

Es

ES modules: TypeScript, TSX, JavaScript. named holds verbatim specifiers ("useState", "stdin as input", "type Foo", "type Foo as Bar") — see specifier_imported_name.

Fields

default_import: Option<String>

namespace_import: Option<String>

named: Vec<String>

type_only: bool

Statement-level import type { ... }.

side_effect: bool

Side-effect-only import "mod" (no bindings).

Python

Python import module (from_import = false) or from module import a, b (from_import = true).

Fields

from_import: bool

named: Vec<String>

RustUse

Rust use path; / pub use path;. visibility replaces the default_import == "pub" overload (Some("pub"), Some("pub(crate)"), …). The brace/use-tree text remains carried by module_path per the lossless-round-trip decision; named holds extracted use-list names.

Fields

visibility: Option<String>

named: Vec<String>

Go

Go import. alias replaces the default_import overload, including the blank (_) and dot (.) import bindings.

Fields

alias: Option<String>

Solidity

Solidity import, in one of four forms:

• side-effect: import "x"; (all empty)
• named: import { A, B as C } from "x"; (named)
• namespace: import * as A from "x"; (namespace)
• whole-file alias: import "x" as A; (alias)

named holds verbatim specifiers ("A", "B as C") like the ES form, so specifier_imported_name / specifier_local_name apply.

Fields

named: Vec<String>

namespace: Option<String>

alias: Option<String>

Structured

Generic structured form shared by the Phase-1 engines (Java, C#, PHP, Kotlin, Scala, Swift, …). Carries the full schema field set so a new engine does not need its own enum variant; module_path (on the parent ImportStatement) holds the path/FQN. named uses the verbatim specifier convention.

Fields

named: Vec<String>

namespace: Option<String>

alias: Option<String>

modifiers: Vec<String>

import_kind: Option<String>

Trait Implementations

impl Clone for ImportForm

fn clone(&self) -> ImportForm

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ImportForm

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

Formats the value using the given formatter.

impl Eq for ImportForm

impl PartialEq for ImportForm

fn eq(&self, other: &ImportForm) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ImportForm