Struct DiscoveryQuery 

pub struct DiscoveryQuery {
    pub pattern: Pattern,
    pub case_options: CaseOptions,
    pub kinds: Option<Vec<SymbolKind>>,
    pub in_crate: Option<String>,
    pub in_module: Option<String>,
    pub include_relations: bool,
    pub relation_depth: usize,
    pub limit: Option<usize>,
    pub sort: SortOrder,
    pub type_filter: Option<TypeFilter>,
}

Query specification for symbol discovery.

Fields

pattern: Pattern

Name pattern to match.

case_options: CaseOptions

Case matching options.

kinds: Option<Vec<SymbolKind>>

Filter by kinds.

in_crate: Option<String>

Filter by crate.

in_module: Option<String>

Filter by module path (partial match).

include_relations: bool

Include related symbols (callers, implementors, etc.).

relation_depth: usize

Maximum depth for relation traversal.

limit: Option<usize>

Maximum results to return.

sort: SortOrder

Sort order for results.

type_filter: Option<TypeFilter>

Type-based filter using TypeFlowGraph.

Implementations

impl DiscoveryQuery

pub fn symbol(pattern: impl Into<String>) -> Self

Create a query matching symbol names.

pub fn symbol_with_options( pattern: impl Into<String>, case_options: CaseOptions, ) -> Self

Create a query matching symbol names with case options.

pub fn exact(name: impl Into<String>) -> Self

Create a query with exact name match.

pub fn regex(pattern: impl Into<String>) -> Result<Self, PatternError>

Create a query with regex pattern.

pub fn ignore_case(self) -> Self

Enable case-insensitive matching.

Examples

let query = DiscoveryQuery::symbol("*config").ignore_case();
// Matches: AppConfig, APPCONFIG, appconfig

pub fn ignore_word_separate(self) -> Self

Enable word-separate-insensitive matching.

Ignores differences in casing style (snake_case vs camelCase vs PascalCase).

Examples

let query = DiscoveryQuery::symbol("get_user*").ignore_word_separate();
// Matches: get_user_name, getUserName, GetUserName

pub fn kinds(self, kinds: Vec<SymbolKind>) -> Self

Filter by specific kinds.

pub fn kind(self, kind: SymbolKind) -> Self

Filter by a single kind.

pub fn in_crate(self, crate_name: impl Into<String>) -> Self

Filter by crate name.

pub fn in_module(self, module: impl Into<String>) -> Self

Filter by module path.

pub fn with_relations(self) -> Self

Include related symbols in results.

pub fn relation_depth(self, depth: usize) -> Self

Set relation traversal depth.

pub fn limit(self, limit: usize) -> Self

Limit the number of results.

pub fn sort(self, sort: SortOrder) -> Self

Set sort order.

pub fn with_type_filter(self, filter: TypeFilter) -> Self

Add type-based filter.

pub fn returns(self, pattern: impl Into<String>) -> Self

Filter by return type pattern.

pub fn has_param_type(self, pattern: impl Into<String>) -> Self

Filter by parameter type pattern.

pub fn has_field_type(self, pattern: impl Into<String>) -> Self

Filter by field type pattern.

Trait Implementations

impl Clone for DiscoveryQuery

fn clone(&self) -> DiscoveryQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DiscoveryQuery

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

Formats the value using the given formatter.

impl Default for DiscoveryQuery

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DiscoveryQuery

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DiscoveryQuery

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

where __S: Serializer,

Serialize this value into the given Serde serializer.