Struct rustc_resolve::late::LateResolutionVisitor

pub(in late) struct LateResolutionVisitor<'a, 'b, 'ast> {
    r: &'b mut Resolver<'a>,
    parent_scope: ParentScope<'a>,
    ribs: PerNS<Vec<Rib<'a>>>,
    label_ribs: Vec<Rib<'a, NodeId>>,
    current_trait_ref: Option<(&'a ModuleData<'a>, TraitRef)>,
    diagnostic_metadata: DiagnosticMetadata<'ast>,
    in_func_body: bool,
}

Fields

r: &'b mut Resolver<'a>

parent_scope: ParentScope<'a>

The module that represents the current item scope.

ribs: PerNS<Vec<Rib<'a>>>

The current set of local scopes for types and values. FIXME #4948: Reuse ribs to avoid allocation.

label_ribs: Vec<Rib<'a, NodeId>>

The current set of local scopes, for labels.

current_trait_ref: Option<(&'a ModuleData<'a>, TraitRef)>

The trait that the current context can refer to.

diagnostic_metadata: DiagnosticMetadata<'ast>

Fields used to add information to diagnostic errors.

in_func_body: bool

State used to know whether to ignore resolution errors for function bodies.

In particular, rustdoc uses this to avoid giving errors for cfg() items. In most cases this will be None, in which case errors will always be reported. If it is true, then it will be updated when entering a nested function or trait body.

Implementations

impl<'a: 'ast, 'ast, '_> LateResolutionVisitor<'a, '_, 'ast>

pub(in late::diagnostics) fn def_span(
    &self,
    def_id: DefId
) -> Option<Span>

pub(crate) fn smart_resolve_report_errors(
    &mut self,
    path: &[Segment],
    span: Span,
    source: PathSource<'_>,
    res: Option<Res<NodeId>>
) -> (DiagnosticBuilder<'a>, Vec<ImportSuggestion>)

Handles error reporting for smart_resolve_path_fragment function. Creates base error and amends it with one short label and possibly some longer helps/notes.

pub(in late::diagnostics) fn restrict_assoc_type_in_where_clause(
    &mut self,
    span: Span,
    err: &mut DiagnosticBuilder<'_>
) -> bool

Given where <T as Bar>::Baz: String, suggest where T: Bar<Baz = String>.

pub(in late::diagnostics) fn call_has_self_arg(
    &self,
    source: PathSource<'_>
) -> Option<(Span, Option<Span>)>

Check if the source is call expression and the first argument is self. If true, return the span of whole call and the span for all arguments expect the first one (self).

pub(in late::diagnostics) fn followed_by_brace(
    &self,
    span: Span
) -> (bool, Option<Span>)

pub(in late::diagnostics) fn smart_resolve_context_dependent_help(
    &mut self,
    err: &mut DiagnosticBuilder<'a>,
    span: Span,
    source: PathSource<'_>,
    res: Res<NodeId>,
    path_str: &str,
    fallback_label: &str
) -> bool

Provides context-dependent help for errors reported by the smart_resolve_path_fragment function. Returns true if able to provide context-dependent help.

pub(in late::diagnostics) fn lookup_assoc_candidate<FilterFn>(
    &mut self,
    ident: Ident,
    ns: Namespace,
    filter_fn: FilterFn
) -> Option<AssocSuggestion> where
    FilterFn: Fn(Res<NodeId>) -> bool, 

pub(in late::diagnostics) fn lookup_typo_candidate(
    &mut self,
    path: &[Segment],
    ns: Namespace,
    filter_fn: &impl Fn(Res<NodeId>) -> bool,
    span: Span
) -> Option<TypoSuggestion>

pub(in late::diagnostics) fn get_colon_suggestion_span(
    &self,
    start: Span
) -> Span

Only used in a specific case of type ascription suggestions

pub(in late::diagnostics) fn type_ascription_suggestion(
    &self,
    err: &mut DiagnosticBuilder<'_>,
    base_span: Span
) -> bool

pub(in late::diagnostics) fn find_module(
    &mut self,
    def_id: DefId
) -> Option<(&'a ModuleData<'a>, ImportSuggestion)>

pub(in late::diagnostics) fn collect_enum_ctors(
    &mut self,
    def_id: DefId
) -> Option<Vec<(Path, DefId, CtorKind)>>

pub(in late::diagnostics) fn suggest_using_enum_variant(
    &mut self,
    err: &mut DiagnosticBuilder<'a>,
    source: PathSource<'_>,
    def_id: DefId,
    span: Span
)

Adds a suggestion for using an enum's variant when an enum is used instead.

pub(crate) fn report_missing_type_error(
    &self,
    path: &[Segment]
) -> Option<(Span, &'static str, String, Applicability)>

pub(crate) fn suggestion_for_label_in_rib(
    &self,
    rib_index: usize,
    label: Ident
) -> Option<(Ident, bool)>

Given the target label, search the rib_indexth label rib for similarly named labels, optionally returning the closest match and whether it is reachable.

impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast>

pub(in late) fn new(
    resolver: &'b mut Resolver<'a>
) -> LateResolutionVisitor<'a, 'b, 'ast>

pub(in late) fn resolve_ident_in_lexical_scope(
    &mut self,
    ident: Ident,
    ns: Namespace,
    record_used_id: Option<NodeId>,
    path_span: Span
) -> Option<LexicalScopeBinding<'a>>

pub(in late) fn resolve_path(
    &mut self,
    path: &[Segment],
    opt_ns: Option<Namespace>,
    record_used: bool,
    path_span: Span,
    crate_lint: CrateLint
) -> PathResult<'a>

pub(in late) fn with_rib<T>(
    &mut self,
    ns: Namespace,
    kind: RibKind<'a>,
    work: impl FnOnce(&mut Self) -> T
) -> T

Do some work within a new innermost rib of the given kind in the given namespace (ns).

pub(in late) fn with_scope<T>(
    &mut self,
    id: NodeId,
    f: impl FnOnce(&mut Self) -> T
) -> T

pub(in late) fn resolve_label(
    &self,
    label: Ident
) -> Option<NodeId>

Searches the current set of local scopes for labels. Returns the NodeId of the resolved label and reports an error if the label is not found or is unreachable.

pub(in late) fn is_label_valid_from_rib(
    &self,
    rib_index: usize
) -> bool

Determine whether or not a label from the rib_indexth label rib is reachable.

pub(in late) fn resolve_adt(
    &mut self,
    item: &'ast Item,
    generics: &'ast Generics
)

pub(in late) fn future_proof_import(
    &mut self,
    use_tree: &UseTree
)

pub(in late) fn resolve_item(
    &mut self,
    item: &'ast Item
)

pub(in late) fn with_generic_param_rib<'c, F>(
    &'c mut self,
    generics: &'c Generics,
    kind: RibKind<'a>,
    f: F
) where
    F: FnOnce(&mut Self), 

pub(in late) fn with_label_rib(
    &mut self,
    kind: RibKind<'a>,
    f: impl FnOnce(&mut Self)
)

pub(in late) fn with_item_rib(
    &mut self,
    has_generic_params: HasGenericParams,
    f: impl FnOnce(&mut Self)
)

pub(in late) fn with_constant_rib(
    &mut self,
    is_repeat: IsRepeatExpr,
    is_trivial: bool,
    f: impl FnOnce(&mut Self)
)

pub(in late) fn with_current_self_type<T>(
    &mut self,
    self_type: &Ty,
    f: impl FnOnce(&mut Self) -> T
) -> T

pub(in late) fn with_current_self_item<T>(
    &mut self,
    self_item: &Item,
    f: impl FnOnce(&mut Self) -> T
) -> T

pub(in late) fn with_trait_items<T>(
    &mut self,
    trait_items: &'ast Vec<P<AssocItem>>,
    f: impl FnOnce(&mut Self) -> T
) -> T

When evaluating a trait use its associated types' idents for suggestions in E0412.

pub(in late) fn with_optional_trait_ref<T>(
    &mut self,
    opt_trait_ref: Option<&TraitRef>,
    f: impl FnOnce(&mut Self, Option<DefId>) -> T
) -> T

This is called to resolve a trait reference from an impl (i.e., impl Trait for Foo).

pub(in late) fn with_self_rib_ns(
    &mut self,
    ns: Namespace,
    self_res: Res<NodeId>,
    f: impl FnOnce(&mut Self)
)

pub(in late) fn with_self_rib(
    &mut self,
    self_res: Res<NodeId>,
    f: impl FnOnce(&mut Self)
)

pub(in late) fn resolve_implementation(
    &mut self,
    generics: &'ast Generics,
    opt_trait_reference: &'ast Option<TraitRef>,
    self_type: &'ast Ty,
    item_id: NodeId,
    impl_items: &'ast [P<AssocItem>]
)

pub(in late) fn check_trait_item<F>(
    &mut self,
    ident: Ident,
    ns: Namespace,
    span: Span,
    err: F
) where
    F: FnOnce(Symbol, &str) -> ResolutionError<'_>, 

pub(in late) fn resolve_params(
    &mut self,
    params: &'ast [Param]
)

pub(in late) fn resolve_local(
    &mut self,
    local: &'ast Local
)

pub(in late) fn binding_mode_map(
    &mut self,
    pat: &Pat
) -> FxHashMap<Ident, BindingInfo>

build a map from pattern identifiers to binding-info's. this is done hygienically. This could arise for a macro that expands into an or-pattern where one 'x' was from the user and one 'x' came from the macro.

pub(in late) fn is_base_res_local(
    &self,
    nid: NodeId
) -> bool

pub(in late) fn check_consistent_bindings(
    &mut self,
    pats: &[P<Pat>]
) -> Vec<FxHashMap<Ident, BindingInfo>>

Checks that all of the arms in an or-pattern have exactly the same set of bindings, with the same binding modes for each.

pub(in late) fn check_consistent_bindings_top(
    &mut self,
    pat: &'ast Pat
)

Check the consistency of the outermost or-patterns.

pub(in late) fn resolve_arm(
    &mut self,
    arm: &'ast Arm
)

pub(in late) fn resolve_pattern_top(
    &mut self,
    pat: &'ast Pat,
    pat_src: PatternSource
)

Arising from source, resolve a top level pattern.

pub(in late) fn resolve_pattern(
    &mut self,
    pat: &'ast Pat,
    pat_src: PatternSource,
    bindings: &mut SmallVec<[(PatBoundCtx, FxHashSet<Ident>); 1]>
)

pub(in late) fn resolve_pattern_inner(
    &mut self,
    pat: &Pat,
    pat_src: PatternSource,
    bindings: &mut SmallVec<[(PatBoundCtx, FxHashSet<Ident>); 1]>
)

Resolve bindings in a pattern. This is a helper to resolve_pattern.

bindings

A stack of sets of bindings accumulated.

In each set, PatBoundCtx::Product denotes that a found binding in it should be interpreted as re-binding an already bound binding. This results in an error. Meanwhile, PatBound::Or denotes that a found binding in the set should result in reusing this binding rather than creating a fresh one.

When called at the top level, the stack must have a single element with PatBound::Product. Otherwise, pushing to the stack happens as or-patterns (p_0 | ... | p_n) are encountered and the context needs to be switched to PatBoundCtx::Or and then PatBoundCtx::Product for each p_i. When each p_i has been dealt with, the top set is merged with its parent. When a whole or-pattern has been dealt with, the thing happens.

See the implementation and fresh_binding for more details.

pub(in late) fn fresh_binding(
    &mut self,
    ident: Ident,
    pat_id: NodeId,
    pat_src: PatternSource,
    bindings: &mut SmallVec<[(PatBoundCtx, FxHashSet<Ident>); 1]>
) -> Res<NodeId>

pub(in late) fn innermost_rib_bindings(
    &mut self,
    ns: Namespace
) -> &mut FxHashMap<Ident, Res<NodeId>>

pub(in late) fn try_resolve_as_non_binding(
    &mut self,
    pat_src: PatternSource,
    pat: &Pat,
    bm: BindingMode,
    ident: Ident,
    has_sub: bool
) -> Option<Res<NodeId>>

pub(in late) fn smart_resolve_path(
    &mut self,
    id: NodeId,
    qself: Option<&QSelf>,
    path: &Path,
    source: PathSource<'ast>
)

pub(in late) fn smart_resolve_path_fragment(
    &mut self,
    id: NodeId,
    qself: Option<&QSelf>,
    path: &[Segment],
    span: Span,
    source: PathSource<'ast>,
    crate_lint: CrateLint
) -> PartialRes

pub(in late) fn self_type_is_available(
    &mut self,
    span: Span
) -> bool

pub(in late) fn self_value_is_available(
    &mut self,
    self_span: Span,
    path_span: Span
) -> bool

pub(in late) fn report_error(
    &self,
    span: Span,
    resolution_error: ResolutionError<'_>
)

A wrapper around Resolver::report_error.

This doesn't emit errors for function bodies if this is rustdoc.

pub(in late) fn should_report_errs(
    &self
) -> bool

If we're actually rustdoc then avoid giving a name resolution error for cfg() items.

pub(in late) fn resolve_qpath_anywhere(
    &mut self,
    id: NodeId,
    qself: Option<&QSelf>,
    path: &[Segment],
    primary_ns: Namespace,
    span: Span,
    defer_to_typeck: bool,
    crate_lint: CrateLint
) -> Result<Option<PartialRes>, Spanned<ResolutionError<'a>>>

pub(in late) fn resolve_qpath(
    &mut self,
    id: NodeId,
    qself: Option<&QSelf>,
    path: &[Segment],
    ns: Namespace,
    span: Span,
    crate_lint: CrateLint
) -> Result<Option<PartialRes>, Spanned<ResolutionError<'a>>>

Handles paths that may refer to associated items.

pub(in late) fn with_resolved_label(
    &mut self,
    label: Option<Label>,
    id: NodeId,
    f: impl FnOnce(&mut Self)
)

pub(in late) fn resolve_labeled_block(
    &mut self,
    label: Option<Label>,
    id: NodeId,
    block: &'ast Block
)

pub(in late) fn resolve_block(
    &mut self,
    block: &'ast Block
)

pub(in late) fn resolve_anon_const(
    &mut self,
    constant: &'ast AnonConst,
    is_repeat: IsRepeatExpr
)

pub(in late) fn resolve_expr(
    &mut self,
    expr: &'ast Expr,
    parent: Option<&'ast Expr>
)

pub(in late) fn record_candidate_traits_for_expr_if_necessary(
    &mut self,
    expr: &'ast Expr
)

pub(in late) fn get_traits_containing_item(
    &mut self,
    ident: Ident,
    ns: Namespace
) -> Vec<TraitCandidate>

Trait Implementations

impl<'a: 'ast, 'ast, '_> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast>

Walks the whole crate in DFS order, visiting each item, resolving names as it goes.

pub fn visit_item(&mut self, item: &'ast Item)

pub fn visit_arm(&mut self, arm: &'ast Arm)

pub fn visit_block(&mut self, block: &'ast Block)

pub fn visit_anon_const(&mut self, constant: &'ast AnonConst)

pub fn visit_expr(&mut self, expr: &'ast Expr)

pub fn visit_local(&mut self, local: &'ast Local)

pub fn visit_ty(&mut self, ty: &'ast Ty)

pub fn visit_poly_trait_ref(
    &mut self,
    tref: &'ast PolyTraitRef,
    m: &'ast TraitBoundModifier
)

pub fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem)

pub fn visit_fn(&mut self, fn_kind: FnKind<'ast>, sp: Span, _: NodeId)

pub fn visit_generics(&mut self, generics: &'ast Generics)

pub fn visit_generic_arg(&mut self, arg: &'ast GenericArg)

pub fn visit_where_predicate(&mut self, p: &'ast WherePredicate)

pub fn visit_name(&mut self, _span: Span, _name: Symbol)

pub fn visit_ident(&mut self, ident: Ident)

pub fn visit_mod(
    &mut self,
    m: &'ast Mod,
    _s: Span,
    _attrs: &[Attribute],
    _n: NodeId
)

pub fn visit_global_asm(&mut self, ga: &'ast GlobalAsm)

pub fn visit_stmt(&mut self, s: &'ast Stmt)

pub fn visit_param(&mut self, param: &'ast Param)

pub fn visit_pat(&mut self, p: &'ast Pat)

pub fn visit_expr_post(&mut self, _ex: &'ast Expr)

pub fn visit_generic_param(&mut self, param: &'ast GenericParam)

pub fn visit_assoc_item(
    &mut self,
    i: &'ast Item<AssocItemKind>,
    ctxt: AssocCtxt
)

pub fn visit_trait_ref(&mut self, t: &'ast TraitRef)

pub fn visit_param_bound(&mut self, bounds: &'ast GenericBound)

pub fn visit_variant_data(&mut self, s: &'ast VariantData)

pub fn visit_struct_field(&mut self, s: &'ast StructField)

pub fn visit_enum_def(
    &mut self,
    enum_definition: &'ast EnumDef,
    generics: &'ast Generics,
    item_id: NodeId,
    Span
)

pub fn visit_variant(&mut self, v: &'ast Variant)

pub fn visit_label(&mut self, label: &'ast Label)

pub fn visit_lifetime(&mut self, lifetime: &'ast Lifetime)

pub fn visit_mac_call(&mut self, mac: &'ast MacCall)

pub fn visit_mac_def(&mut self, _mac: &'ast MacroDef, _id: NodeId)

pub fn visit_path(&mut self, path: &'ast Path, _id: NodeId)

pub fn visit_use_tree(
    &mut self,
    use_tree: &'ast UseTree,
    id: NodeId,
    _nested: bool
)

pub fn visit_path_segment(
    &mut self,
    path_span: Span,
    path_segment: &'ast PathSegment
)

pub fn visit_generic_args(
    &mut self,
    path_span: Span,
    generic_args: &'ast GenericArgs
)

pub fn visit_assoc_ty_constraint(&mut self, constraint: &'ast AssocTyConstraint)

pub fn visit_attribute(&mut self, attr: &'ast Attribute)

pub fn visit_vis(&mut self, vis: &'ast Visibility)

pub fn visit_fn_ret_ty(&mut self, ret_ty: &'ast FnRetTy)

pub fn visit_fn_header(&mut self, _header: &'ast FnHeader)

pub fn visit_field(&mut self, f: &'ast Field)

pub fn visit_field_pattern(&mut self, fp: &'ast FieldPat)