Struct hir::SemanticsImpl

pub struct SemanticsImpl<'db> {
    pub db: &'db dyn HirDatabase,
    /* private fields */
}

Fields

db: &'db dyn HirDatabase

Implementations

impl<'db> SemanticsImpl<'db>

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

pub fn attach_first_edition(&self, file: FileId) -> Option<EditionedFileId>

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

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

pub fn module_definition_node(&self, module: Module) -> InFile<SyntaxNode>

Returns the SyntaxNode of the module. If this is a file module, returns the SyntaxNode of the definition file, not of the declaration.

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

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

pub fn check_cfg_attr(&self, attr: &TokenTree) -> Option<bool>

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

Expands the macro if it isn’t one of the built-in ones that expand to custom syntax or dummy expansions.

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, attr: &Attr) -> Option<Vec<Option<Macro>>>

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

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

pub fn derive_helper(&self, attr: &Attr) -> Option<Vec<(Macro, MacroFileId)>>

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

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

Expand the macro call with a different token tree, mapping the token_to_map down into the expansion. token_to_map should be a token from the speculative args node.

pub fn speculative_expand_raw( &self, macro_file: MacroFileId, speculative_args: &SyntaxNode, 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)>

Expand the macro call with a different item as the input, mapping the token_to_map down into the expansion. token_to_map should be a token from the speculative args node.

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 as_format_args_parts( &self, string: &String, ) -> Option<Vec<(TextRange, Option<Either<PathResolution, InlineAsmOperand>>)>>

Retrieves all the formatting parts of the format_args! (or asm!) template string.

pub fn check_for_format_args_template( &self, original_token: SyntaxToken, offset: TextSize, ) -> Option<(TextRange, Option<Either<PathResolution, InlineAsmOperand>>)>

Retrieves the formatting part of the format_args! template string at the given offset.

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 might_be_inside_macro_call(&self, token: &SyntaxToken) -> bool

Does a syntactic traversal to check whether this token might be inside a macro call

pub fn descend_into_macros_cb( &self, token: SyntaxToken, cb: impl FnMut(InFile<SyntaxToken>, SyntaxContextId), )

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

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

pub fn descend_into_macros_breakable<T>( &self, token: InRealFile<SyntaxToken>, cb: impl FnMut(InFile<SyntaxToken>, SyntaxContextId) -> ControlFlow<T>, ) -> Option<T>

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

Descends the token into expansions, returning the tokens that matches the input token’s [SyntaxKind] and text.

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

Descends the token into expansions, returning the first token that matches the input token’s [SyntaxKind] and text.

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_rooted( &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, src: InFile<SyntaxNodePtr>) -> FileRange

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

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 resolve_lifetime_param( &self, lifetime: &Lifetime, ) -> Option<LifetimeParam>

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

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

pub fn resolve_trait(&self, path: &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_binding_in_pat(&self, pat: &IdentPat) -> Option<Type>

It also includes the changes that binding mode makes in the type. For example in let ref x @ Some(_) = None the result of type_of_pat is Option<T> but the result of this function is &mut Option<T>

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_expr_as_callable(&self, call: &Expr) -> Option<Callable>

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

pub fn resolve_method_call_fallback( &self, call: &MethodCallExpr, ) -> Option<Either<Function, Field>>

Attempts to resolve this call expression as a method call falling back to resolving it as a field.

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

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

pub fn resolve_field_fallback( &self, field: &FieldExpr, ) -> Option<Either<Either<Field, TupleField>, Function>>

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

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

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

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

pub fn resolve_macro_call_arm(&self, macro_call: &MacroCall) -> Option<u32>

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_mod_path( &self, scope: &SyntaxNode, path: &ModPath, ) -> Option<impl Iterator<Item = ItemInNs>>

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 scope(&self, node: &SyntaxNode) -> Option<SemanticsScope<'db>>

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

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 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.