Enum ReferenceKind 

pub enum ReferenceKind {
    Variable(Arc<str>),
    MethodCall {
        class: Arc<str>,
        method: Arc<str>,
    },
    StaticCall {
        class: Arc<str>,
        method: Arc<str>,
    },
    PropertyAccess {
        class: Arc<str>,
        property: Arc<str>,
    },
    FunctionCall(Arc<str>),
    ClassReference(Arc<str>),
    ConstantAccess {
        class: Arc<str>,
        constant: Arc<str>,
    },
    GlobalConstant(Arc<str>),
    UseImport(Box<ReferenceKind>),
    Receiver,
}

The kind of symbol reference that was resolved.

Variants

Variable(Arc<str>)

A variable reference ($foo).

MethodCall

An instance method call ($obj->method()).

Fields

class: Arc<str>

method: Arc<str>

StaticCall

A static method call (Foo::method()).

Fields

class: Arc<str>

method: Arc<str>

PropertyAccess

A property access ($obj->prop).

Fields

class: Arc<str>

property: Arc<str>

FunctionCall(Arc<str>)

A free function call (foo()).

ClassReference(Arc<str>)

A class reference (new Foo, instanceof Foo, type hints).

ConstantAccess

A class constant access (Config::VERSION, self::CONST, parent::CONST).

Fields

class: Arc<str>

constant: Arc<str>

GlobalConstant(Arc<str>)

A global constant reference (FOO, \FOO).

UseImport(Box<ReferenceKind>)

A symbol occurrence inside a use import statement (use Foo\Bar;, use function foo\bar;, use const FOO\BAR;) — the import’s own name token, not a usage site. Kept distinct from the wrapped kind so a consumer walking reference-index postings (e.g. a future index-based rename) can tell an import line apart from a genuine usage: renaming must update the import too, but a plain find-references / dead-code “is this ever used” check must not count the bare import as one (there is deliberately no UnusedImport check).

Receiver

The type of a member-access receiver ($obj in $obj->prop, Foo in Foo::method()), recorded at the gap between the receiver expression and the member token — the ->/?->/:: operator and any intervening whitespace — rather than at the receiver’s own span. This is what lets a cursor sitting right after the operator (the position a member-completion request fires from) resolve a type, since that offset falls outside both the receiver expression’s span and the member’s span. Not a codebase-level symbol — to_name returns None.

Implementations

impl ReferenceKind

pub fn to_name(&self) -> Option<Name>

Map to a typed crate::Name, or None for kinds that don’t correspond to a codebase-level symbol (currently only Variable).

Trait Implementations

impl Clone for ReferenceKind

fn clone(&self) -> ReferenceKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReferenceKind

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

Formats the value using the given formatter.