Struct ra_ap_hir::Semantics

pub struct Semantics<'db, DB> {
    pub db: &'db DB,
    /* private fields */
}

Primary API to get semantic information, like types, from syntax trees.

Fields

db: &'db DB

Implementations

impl<'db, DB: HirDatabase> Semantics<'db, DB>

pub fn new(db: &DB) -> Semantics<'_, DB>

pub fn parse(&self, file_id: FileId) -> SourceFile

pub fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>

pub fn expand(&self, macro_call: &MacroCall) -> Option<SyntaxNode>

pub fn expand_attr_macro(&self, item: &Item) -> Option<SyntaxNode>

If item has an attribute macro attached to it, expands it.

pub fn expand_derive_as_pseudo_attr_macro(
    &self,
    attr: &Attr
) -> Option<SyntaxNode>

pub fn resolve_derive_macro(&self, derive: &Attr) -> Option<Vec<Option<Macro>>>

pub fn expand_derive_macro(&self, derive: &Attr) -> Option<Vec<SyntaxNode>>

pub fn is_attr_macro_call(&self, item: &Item) -> bool

pub fn is_derive_annotated(&self, item: &Adt) -> bool

pub fn speculative_expand(
    &self,
    actual_macro_call: &MacroCall,
    speculative_args: &TokenTree,
    token_to_map: SyntaxToken
) -> Option<(SyntaxNode, SyntaxToken)>

pub fn speculative_expand_attr_macro(
    &self,
    actual_macro_call: &Item,
    speculative_args: &Item,
    token_to_map: SyntaxToken
) -> Option<(SyntaxNode, SyntaxToken)>

pub fn speculative_expand_derive_as_pseudo_attr_macro(
    &self,
    actual_macro_call: &Attr,
    speculative_args: &Attr,
    token_to_map: SyntaxToken
) -> Option<(SyntaxNode, SyntaxToken)>

pub fn descend_into_macros_single(&self, token: SyntaxToken) -> SyntaxToken

Descend the token into macrocalls to its first mapped counterpart.

pub fn descend_into_macros(
    &self,
    token: SyntaxToken
) -> SmallVec<[SyntaxToken; 1]>

Descend the token into macrocalls to all its mapped counterparts.

pub fn descend_into_macros_with_same_text(
    &self,
    token: SyntaxToken
) -> SmallVec<[SyntaxToken; 1]>

Descend the token into macrocalls to all its mapped counterparts that have the same text as the input token.

Returns the original non descended token if none of the mapped counterparts have the same text.

pub fn descend_into_macros_with_kind_preference(
    &self,
    token: SyntaxToken
) -> SyntaxToken

pub fn descend_node_into_attributes<N: AstNode>(
    &self,
    node: N
) -> SmallVec<[N; 1]>

Maps a node down by mapping its first and last token down.

pub fn source<Def: HasSource>(&self, def: Def) -> Option<InFile<Def::Ast>>where
    Def::Ast: AstNode,

Search for a definition’s source and cache its syntax tree

pub fn hir_file_for(&self, syntax_node: &SyntaxNode) -> HirFileId

pub fn original_range(&self, node: &SyntaxNode) -> FileRange

Attempts to map the node out of macro expanded files returning the original file range. If upmapping is not possible, this will fall back to the range of the macro call of the macro file the node resides in.

pub fn original_range_opt(&self, node: &SyntaxNode) -> Option<FileRange>

Attempts to map the node out of macro expanded files returning the original file range.

pub fn original_ast_node<N: AstNode>(&self, node: N) -> Option<N>

Attempts to map the node out of macro expanded files. This only work for attribute expansions, as other ones do not have nodes as input.

pub fn original_syntax_node(&self, node: &SyntaxNode) -> Option<SyntaxNode>

Attempts to map the node out of macro expanded files. This only work for attribute expansions, as other ones do not have nodes as input.

pub fn diagnostics_display_range(
    &self,
    diagnostics: InFile<SyntaxNodePtr>
) -> FileRange

pub fn token_ancestors_with_macros(
    &self,
    token: SyntaxToken
) -> impl Iterator<Item = SyntaxNode> + '_

pub fn ancestors_with_macros(
    &self,
    node: SyntaxNode
) -> impl Iterator<Item = SyntaxNode> + '_

Iterates the ancestors of the given node, climbing up macro expansions while doing so.

pub fn ancestors_at_offset_with_macros(
    &self,
    node: &SyntaxNode,
    offset: TextSize
) -> impl Iterator<Item = SyntaxNode> + '_

pub fn find_node_at_offset_with_macros<N: AstNode>(
    &self,
    node: &SyntaxNode,
    offset: TextSize
) -> Option<N>

Find an AstNode by offset inside SyntaxNode, if it is inside Macrofile, search up until it is of the target AstNode type

pub fn find_node_at_offset_with_descend<N: AstNode>(
    &self,
    node: &SyntaxNode,
    offset: TextSize
) -> Option<N>

Find an AstNode by offset inside SyntaxNode, if it is inside MacroCall, descend it and find again

pub fn find_nodes_at_offset_with_descend<'slf, N: AstNode + 'slf>(
    &'slf self,
    node: &SyntaxNode,
    offset: TextSize
) -> impl Iterator<Item = N> + 'slf

Find an AstNode by offset inside SyntaxNode, if it is inside MacroCall, descend it and find again

pub fn resolve_lifetime_param(
    &self,
    lifetime: &Lifetime
) -> Option<LifetimeParam>

pub fn resolve_label(&self, lifetime: &Lifetime) -> Option<Label>

pub fn resolve_type(&self, ty: &Type) -> Option<Type>

pub fn resolve_trait(&self, trait_: &Path) -> Option<Trait>

pub fn expr_adjustments(&self, expr: &Expr) -> Option<Vec<Adjustment>>

pub fn type_of_expr(&self, expr: &Expr) -> Option<TypeInfo>

pub fn type_of_pat(&self, pat: &Pat) -> Option<TypeInfo>

pub fn type_of_self(&self, param: &SelfParam) -> Option<Type>

pub fn pattern_adjustments(&self, pat: &Pat) -> SmallVec<[Type; 1]>

pub fn binding_mode_of_pat(&self, pat: &IdentPat) -> Option<BindingMode>

pub fn resolve_method_call(&self, call: &MethodCallExpr) -> Option<Function>

pub fn resolve_await_to_poll(&self, await_expr: &AwaitExpr) -> Option<Function>

pub fn resolve_prefix_expr(&self, prefix_expr: &PrefixExpr) -> Option<Function>

pub fn resolve_index_expr(&self, index_expr: &IndexExpr) -> Option<Function>

pub fn resolve_bin_expr(&self, bin_expr: &BinExpr) -> Option<Function>

pub fn resolve_try_expr(&self, try_expr: &TryExpr) -> Option<Function>

pub fn resolve_method_call_as_callable(
    &self,
    call: &MethodCallExpr
) -> Option<Callable>

pub fn resolve_field(&self, field: &FieldExpr) -> Option<Field>

pub fn resolve_record_field(
    &self,
    field: &RecordExprField
) -> Option<(Field, Option<Local>, Type)>

pub fn resolve_record_pat_field(&self, field: &RecordPatField) -> Option<Field>

pub fn resolve_macro_call(&self, macro_call: &MacroCall) -> Option<Macro>

pub fn is_unsafe_macro_call(&self, macro_call: &MacroCall) -> bool

pub fn resolve_attr_macro_call(&self, item: &Item) -> Option<Macro>

pub fn resolve_path(&self, path: &Path) -> Option<PathResolution>

pub fn resolve_extern_crate(&self, extern_crate: &ExternCrate) -> Option<Crate>

pub fn resolve_variant(&self, record_lit: RecordExpr) -> Option<VariantDef>

pub fn resolve_bind_pat_to_const(&self, pat: &IdentPat) -> Option<ModuleDef>

pub fn record_literal_missing_fields(
    &self,
    literal: &RecordExpr
) -> Vec<(Field, Type)>

pub fn record_pattern_missing_fields(
    &self,
    pattern: &RecordPat
) -> Vec<(Field, Type)>

pub fn to_def<T: ToDef>(&self, src: &T) -> Option<T::Def>

pub fn to_module_def(&self, file: FileId) -> Option<Module>

pub fn to_module_defs(&self, file: FileId) -> impl Iterator<Item = Module>

pub fn scope(&self, node: &SyntaxNode) -> Option<SemanticsScope<'db>>

pub fn scope_at_offset(
    &self,
    node: &SyntaxNode,
    offset: TextSize
) -> Option<SemanticsScope<'db>>

pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db>

pub fn assert_contains_node(&self, node: &SyntaxNode)

pub fn is_unsafe_method_call(&self, method_call_expr: &MethodCallExpr) -> bool

pub fn is_unsafe_ref_expr(&self, ref_expr: &RefExpr) -> bool

pub fn is_unsafe_ident_pat(&self, ident_pat: &IdentPat) -> bool

pub fn is_inside_unsafe(&self, expr: &Expr) -> bool

Returns true if the node is inside an unsafe context.

Trait Implementations

impl<DB> Debug for Semantics<'_, DB>

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

Formats the value using the given formatter.