Struct ImportStatement 

pub struct ImportStatement {
    pub path: String,
    pub kind: ImportKind,
    pub line: u32,
}

A single import statement extracted from source code by tree-sitter.

Carries enough information for the resolver to decide whether to attempt resolution, and for debugging/IDE integration via the line number.

Fields

path: String

The raw path/module string as extracted from source.

• Rust: the use argument without the as alias (e.g. crate::store::db)
• Python: the dotted module name (e.g. django.conf or .helpers)
• TypeScript/JavaScript: the module specifier without quotes (e.g. ./utils or react)
• Go: the import path without quotes (e.g. fmt or github.com/user/pkg)
• Java: the fully-qualified class/package name (e.g. java.util.List)
• C/C++: the filename inside the include directive (e.g. stdio.h or myheader.h)
• Ruby: the argument to require/require_relative
• Scala: the import path without import prefix
• Elixir: the module name from import/alias/use/require
• Haskell: the module name (e.g. Data.List)

kind: ImportKind

Structural classification that determines resolver behavior.

line: u32

Line number in the source file where the import appears (1-indexed). Used for debugging and future IDE integration. 0 if unknown.

Implementations

impl ImportStatement

pub fn new(path: impl Into<String>, kind: ImportKind, line: u32) -> Self

Create a new import statement with all fields specified.

Trait Implementations

impl Clone for ImportStatement

fn clone(&self) -> ImportStatement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ImportStatement

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ImportStatement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ImportStatement

impl Hash for ImportStatement

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ImportStatement

fn eq(&self, other: &ImportStatement) -> 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 Serialize for ImportStatement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ImportStatement