Struct MethodCall 

pub struct MethodCall {
    pub caller: String,
    pub method_name: String,
    pub receiver: Option<String>,
    pub is_static: bool,
    pub range: Range,
    pub caller_range: Option<Range>,
}

Represents a method call with rich receiver information

This struct captures the full context of a method call, including:

• The calling context (which function contains this call)
• The method being called
• The receiver (if any) and whether it’s a static call
• The source location

Examples

use codanna::parsing::MethodCall;
use codanna::Range;

let range = Range::new(1, 0, 1, 10);

// Instance method: vec.push(item)
let call = MethodCall::new("process_items", "push", range)
    .with_receiver("vec");

// Static method: String::new()
let call = MethodCall::new("create_string", "new", range)
    .with_receiver("String")
    .static_method();

// Self method: self.validate()
let call = MethodCall::new("save", "validate", range)
    .with_receiver("self");

Fields

caller: String

The function/method making the call

This is the name of the function where this method call appears. For example, in a function fn process() that calls vec.push(), this would be "process".

method_name: String

The method being called

Just the method name without any qualification. For String::new(), this would be "new".

receiver: Option<String>

The receiver expression (e.g., “self”, “vec”, “String”)

• None for plain function calls
• Some("self") for self method calls
• Some("vec") for instance method calls
• Some("String") for static method calls (when is_static is true)

is_static: bool

Whether this is a static method call (e.g., String::new)

Used to distinguish between:

• string.len() (instance method, is_static = false)
• String::new() (static method, is_static = true)

range: Range

Location of the call in the source file (call site)

caller_range: Option<Range>

Definition range of the calling function/method

Used for precise symbol lookup during relationship resolution. When provided, enables exact matching instead of name-only fallback.

Implementations

impl MethodCall

pub fn new(caller: &str, method_name: &str, range: Range) -> Self

Creates a new method call with minimal information

Use the builder methods to add receiver and type information.

Arguments

• caller - The function containing this method call
• method_name - The name of the method being called
• range - The source location of the call

pub fn with_receiver(self, receiver: &str) -> Self

Sets the receiver for this method call

Arguments

• receiver - The receiver expression (e.g., “self”, “vec”, “String”)

pub fn static_method(self) -> Self

Marks this as a static method call

Should be used when the receiver is a type name rather than an instance.

pub fn with_caller_range(self, range: Range) -> Self

Sets the definition range of the calling function

Used for precise symbol lookup during relationship resolution.

pub fn is_self_call(&self) -> bool

Checks if this is a self method call

pub fn is_function_call(&self) -> bool

Checks if this is a plain function call (no receiver)

pub fn qualified_name(&self) -> String

Gets the fully qualified method name for display

Returns

• "Type::method" for static calls
• "receiver.method" for instance calls
• "method" for plain function calls

Trait Implementations

impl Clone for MethodCall

fn clone(&self) -> MethodCall

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MethodCall

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

Formats the value using the given formatter.

impl PartialEq for MethodCall

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