lib.rs 203.2 KB
Newer Older
1
// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 3 4 5 6 7 8 9 10
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

11
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
12 13
       html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
       html_root_url = "https://doc.rust-lang.org/nightly/")]
14

15
#![feature(crate_visibility_modifier)]
16
#![feature(nll)]
A
Alex Crichton 已提交
17
#![feature(rustc_diagnostic_macros)]
18
#![feature(slice_sort_by_cached_key)]
19

C
corentih 已提交
20 21 22 23
#[macro_use]
extern crate log;
#[macro_use]
extern crate syntax;
24 25
extern crate syntax_pos;
extern crate rustc_errors as errors;
26
extern crate arena;
C
corentih 已提交
27
#[macro_use]
28
extern crate rustc;
29
extern crate rustc_data_structures;
30
extern crate rustc_metadata;
31

32 33
pub use rustc::hir::def::{Namespace, PerNS};

S
Steven Fackler 已提交
34 35 36
use self::TypeParameters::*;
use self::RibKind::*;

37
use rustc::hir::map::{Definitions, DefCollector};
38
use rustc::hir::{self, PrimTy, Bool, Char, Float, Int, Uint, Str};
39
use rustc::middle::cstore::CrateStore;
40 41
use rustc::session::Session;
use rustc::lint;
42
use rustc::hir::def::*;
43
use rustc::hir::def::Namespace::*;
44
use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, DefId};
S
Seo Sanghyeon 已提交
45
use rustc::hir::{Freevar, FreevarMap, TraitCandidate, TraitMap, GlobMap};
46 47
use rustc::session::config::nightly_options;
use rustc::ty;
48
use rustc::util::nodemap::{NodeMap, NodeSet, FxHashMap, FxHashSet, DefIdMap};
49

50 51 52
use rustc_metadata::creader::CrateLoader;
use rustc_metadata::cstore::CStore;

D
Donato Sciarra 已提交
53
use syntax::source_map::SourceMap;
54
use syntax::ext::hygiene::{Mark, Transparency, SyntaxContext};
V
Vadim Petrochenkov 已提交
55
use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
J
Jeffrey Seyfried 已提交
56
use syntax::ext::base::SyntaxExtension;
J
Jeffrey Seyfried 已提交
57
use syntax::ext::base::Determinacy::{self, Determined, Undetermined};
58
use syntax::ext::base::MacroKind;
59
use syntax::symbol::{Symbol, keywords};
60
use syntax::util::lev_distance::find_best_match_for_name;
61

62
use syntax::visit::{self, FnKind, Visitor};
63
use syntax::attr;
64
use syntax::ast::{CRATE_NODE_ID, Arm, IsAsync, BindingMode, Block, Crate, Expr, ExprKind};
V
varkor 已提交
65
use syntax::ast::{FnDecl, ForeignItem, ForeignItemKind, GenericParamKind, Generics};
66
use syntax::ast::{Item, ItemKind, ImplItem, ImplItemKind};
67
use syntax::ast::{Label, Local, Mutability, Pat, PatKind, Path};
J
Jeffrey Seyfried 已提交
68
use syntax::ast::{QSelf, TraitItemKind, TraitRef, Ty, TyKind};
69
use syntax::ptr::P;
70

71
use syntax_pos::{Span, DUMMY_SP, MultiSpan};
72
use errors::{Applicability, DiagnosticBuilder, DiagnosticId};
73

74
use std::cell::{Cell, RefCell};
75
use std::cmp;
76
use std::collections::BTreeSet;
77
use std::fmt;
M
Manish Goregaokar 已提交
78
use std::iter;
79
use std::mem::replace;
80
use rustc_data_structures::sync::Lrc;
81

82
use resolve_imports::{ImportDirective, ImportDirectiveSubclass, NameResolution, ImportResolver};
83
use macros::{InvocationData, LegacyBinding, ParentScope};
84

85 86
// NB: This module needs to be declared first so diagnostics are
// registered before they are used.
J
Jeffrey Seyfried 已提交
87
mod diagnostics;
88

89
mod macros;
A
Alex Crichton 已提交
90
mod check_unused;
91
mod build_reduced_graph;
92
mod resolve_imports;
93

94 95 96 97
fn is_known_tool(name: Name) -> bool {
    ["clippy", "rustfmt"].contains(&&*name.as_str())
}

98 99 100
/// A free importable items suggested in case of resolution failure.
struct ImportSuggestion {
    path: Path,
101 102
}

103 104 105 106 107
/// A field or associated item from self type suggested in case of resolution failure.
enum AssocSuggestion {
    Field,
    MethodWithSelf,
    AssocItem,
108 109
}

110 111 112
#[derive(Eq)]
struct BindingError {
    name: Name,
113 114
    origin: BTreeSet<Span>,
    target: BTreeSet<Span>,
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
}

impl PartialOrd for BindingError {
    fn partial_cmp(&self, other: &BindingError) -> Option<cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl PartialEq for BindingError {
    fn eq(&self, other: &BindingError) -> bool {
        self.name == other.name
    }
}

impl Ord for BindingError {
    fn cmp(&self, other: &BindingError) -> cmp::Ordering {
        self.name.cmp(&other.name)
    }
}

J
Jeffrey Seyfried 已提交
135
enum ResolutionError<'a> {
136
    /// error E0401: can't use type parameters from outer function
137
    TypeParametersFromOuterFunction(Def),
138
    /// error E0403: the name is already used for a type parameter in this type parameter list
C
Chris Stankus 已提交
139
    NameAlreadyUsedInTypeParameterList(Name, &'a Span),
140
    /// error E0407: method is not a member of trait
141
    MethodNotMemberOfTrait(Name, &'a str),
142 143 144 145
    /// error E0437: type is not a member of trait
    TypeNotMemberOfTrait(Name, &'a str),
    /// error E0438: const is not a member of trait
    ConstNotMemberOfTrait(Name, &'a str),
146 147 148 149
    /// error E0408: variable `{}` is not bound in all patterns
    VariableNotBoundInPattern(&'a BindingError),
    /// error E0409: variable `{}` is bound in inconsistent ways within the same match arm
    VariableBoundWithDifferentMode(Name, Span),
150
    /// error E0415: identifier is bound more than once in this parameter list
151
    IdentifierBoundMoreThanOnceInParameterList(&'a str),
152
    /// error E0416: identifier is bound more than once in the same pattern
153
    IdentifierBoundMoreThanOnceInSamePattern(&'a str),
154
    /// error E0426: use of undeclared label
155
    UndeclaredLabel(&'a str, Option<Name>),
156
    /// error E0429: `self` imports are only allowed within a { } list
157
    SelfImportsOnlyAllowedWithin,
158
    /// error E0430: `self` import can only appear once in the list
159
    SelfImportCanOnlyAppearOnceInTheList,
160
    /// error E0431: `self` import can only appear in an import list with a non-empty prefix
161
    SelfImportOnlyInImportListWithNonEmptyPrefix,
162
    /// error E0433: failed to resolve
163
    FailedToResolve(&'a str),
164
    /// error E0434: can't capture dynamic environment in a fn item
165
    CannotCaptureDynamicEnvironmentInFnItem,
166
    /// error E0435: attempt to use a non-constant value in a constant
167
    AttemptToUseNonConstantValueInConstant,
168
    /// error E0530: X bindings cannot shadow Ys
169
    BindingShadowsSomethingUnacceptable(&'a str, Name, &'a NameBinding<'a>),
170 171
    /// error E0128: type parameters with a default cannot use forward declared identifiers
    ForwardDeclaredTyParam,
172 173
}

174 175 176 177
/// Combines an error with provided span and emits it
///
/// This takes the error provided, combines it with the span and any additional spans inside the
/// error and emits it.
178 179 180
fn resolve_error<'sess, 'a>(resolver: &'sess Resolver,
                            span: Span,
                            resolution_error: ResolutionError<'a>) {
N
Nick Cameron 已提交
181
    resolve_struct_error(resolver, span, resolution_error).emit();
N
Nick Cameron 已提交
182 183
}

184 185 186 187
fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver,
                                   span: Span,
                                   resolution_error: ResolutionError<'a>)
                                   -> DiagnosticBuilder<'sess> {
N
Nick Cameron 已提交
188
    match resolution_error {
189
        ResolutionError::TypeParametersFromOuterFunction(outer_def) => {
190 191 192
            let mut err = struct_span_err!(resolver.session,
                                           span,
                                           E0401,
193
                                           "can't use type parameters from outer function");
194
            err.span_label(span, "use of type variable from outer function");
195

D
Donato Sciarra 已提交
196
            let cm = resolver.session.source_map();
197
            match outer_def {
E
Esteban Küber 已提交
198 199 200 201 202 203
                Def::SelfTy(maybe_trait_defid, maybe_impl_defid) => {
                    if let Some(impl_span) = maybe_impl_defid.and_then(|def_id| {
                        resolver.definitions.opt_span(def_id)
                    }) {
                        err.span_label(
                            reduce_impl_span_to_impl_keyword(cm, impl_span),
E
Esteban Küber 已提交
204
                            "`Self` type implicitly declared here, by this `impl`",
E
Esteban Küber 已提交
205
                        );
206
                    }
E
Esteban Küber 已提交
207 208 209 210 211 212 213 214 215 216
                    match (maybe_trait_defid, maybe_impl_defid) {
                        (Some(_), None) => {
                            err.span_label(span, "can't use `Self` here");
                        }
                        (_, Some(_)) => {
                            err.span_label(span, "use a type here instead");
                        }
                        (None, None) => bug!("`impl` without trait nor type?"),
                    }
                    return err;
217
                },
218
                Def::TyParam(typaram_defid) => {
219 220 221 222
                    if let Some(typaram_span) = resolver.definitions.opt_span(typaram_defid) {
                        err.span_label(typaram_span, "type variable from outer function");
                    }
                },
223
                _ => {
224
                    bug!("TypeParametersFromOuterFunction should only be used with Def::SelfTy or \
225
                         Def::TyParam")
226
                }
227 228 229 230 231
            }

            // Try to retrieve the span of the function signature and generate a new message with
            // a local type parameter
            let sugg_msg = "try using a local type parameter instead";
232
            if let Some((sugg_span, new_snippet)) = cm.generate_local_type_param_snippet(span) {
233
                // Suggest the modification to the user
234 235 236 237 238 239
                err.span_suggestion_with_applicability(
                    sugg_span,
                    sugg_msg,
                    new_snippet,
                    Applicability::MachineApplicable,
                );
240
            } else if let Some(sp) = cm.generate_fn_name_span(span) {
241
                err.span_label(sp, "try adding a local type parameter in this method instead");
242 243 244 245
            } else {
                err.help("try using a local type parameter instead");
            }

246
            err
C
corentih 已提交
247
        }
C
Chris Stankus 已提交
248 249 250 251 252 253 254
        ResolutionError::NameAlreadyUsedInTypeParameterList(name, first_use_span) => {
             let mut err = struct_span_err!(resolver.session,
                                            span,
                                            E0403,
                                            "the name `{}` is already used for a type parameter \
                                            in this type parameter list",
                                            name);
255 256
             err.span_label(span, "already used");
             err.span_label(first_use_span.clone(), format!("first use of `{}`", name));
C
Chris Stankus 已提交
257
             err
C
corentih 已提交
258
        }
259
        ResolutionError::MethodNotMemberOfTrait(method, trait_) => {
C
crypto-universe 已提交
260 261 262 263 264 265
            let mut err = struct_span_err!(resolver.session,
                                           span,
                                           E0407,
                                           "method `{}` is not a member of trait `{}`",
                                           method,
                                           trait_);
266
            err.span_label(span, format!("not a member of trait `{}`", trait_));
C
crypto-universe 已提交
267
            err
C
corentih 已提交
268
        }
269
        ResolutionError::TypeNotMemberOfTrait(type_, trait_) => {
S
Shyam Sundar B 已提交
270
            let mut err = struct_span_err!(resolver.session,
N
Nick Cameron 已提交
271 272 273 274
                             span,
                             E0437,
                             "type `{}` is not a member of trait `{}`",
                             type_,
S
Shyam Sundar B 已提交
275
                             trait_);
276
            err.span_label(span, format!("not a member of trait `{}`", trait_));
S
Shyam Sundar B 已提交
277
            err
C
corentih 已提交
278
        }
279
        ResolutionError::ConstNotMemberOfTrait(const_, trait_) => {
S
Shyam Sundar B 已提交
280
            let mut err = struct_span_err!(resolver.session,
N
Nick Cameron 已提交
281 282 283 284
                             span,
                             E0438,
                             "const `{}` is not a member of trait `{}`",
                             const_,
S
Shyam Sundar B 已提交
285
                             trait_);
286
            err.span_label(span, format!("not a member of trait `{}`", trait_));
S
Shyam Sundar B 已提交
287
            err
C
corentih 已提交
288
        }
289
        ResolutionError::VariableNotBoundInPattern(binding_error) => {
S
Shotaro Yamada 已提交
290
            let target_sp = binding_error.target.iter().cloned().collect::<Vec<_>>();
291 292
            let msp = MultiSpan::from_spans(target_sp.clone());
            let msg = format!("variable `{}` is not bound in all patterns", binding_error.name);
293 294 295 296 297
            let mut err = resolver.session.struct_span_err_with_code(
                msp,
                &msg,
                DiagnosticId::Error("E0408".into()),
            );
298
            for sp in target_sp {
299
                err.span_label(sp, format!("pattern doesn't bind `{}`", binding_error.name));
300
            }
S
Shotaro Yamada 已提交
301
            let origin_sp = binding_error.origin.iter().cloned();
302
            for sp in origin_sp {
303
                err.span_label(sp, "variable not in all patterns");
304
            }
305
            err
C
corentih 已提交
306
        }
M
Mikhail Modin 已提交
307 308 309
        ResolutionError::VariableBoundWithDifferentMode(variable_name,
                                                        first_binding_span) => {
            let mut err = struct_span_err!(resolver.session,
N
Nick Cameron 已提交
310 311
                             span,
                             E0409,
312 313 314
                             "variable `{}` is bound in inconsistent \
                             ways within the same match arm",
                             variable_name);
315 316
            err.span_label(span, "bound in different ways");
            err.span_label(first_binding_span, "first binding");
M
Mikhail Modin 已提交
317
            err
C
corentih 已提交
318
        }
319
        ResolutionError::IdentifierBoundMoreThanOnceInParameterList(identifier) => {
320
            let mut err = struct_span_err!(resolver.session,
N
Nick Cameron 已提交
321 322 323
                             span,
                             E0415,
                             "identifier `{}` is bound more than once in this parameter list",
324
                             identifier);
325
            err.span_label(span, "used as parameter more than once");
326
            err
C
corentih 已提交
327
        }
328
        ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(identifier) => {
329
            let mut err = struct_span_err!(resolver.session,
N
Nick Cameron 已提交
330 331 332
                             span,
                             E0416,
                             "identifier `{}` is bound more than once in the same pattern",
333
                             identifier);
334
            err.span_label(span, "used in a pattern more than once");
335
            err
C
corentih 已提交
336
        }
337
        ResolutionError::UndeclaredLabel(name, lev_candidate) => {
C
crypto-universe 已提交
338 339 340 341 342
            let mut err = struct_span_err!(resolver.session,
                                           span,
                                           E0426,
                                           "use of undeclared label `{}`",
                                           name);
343 344 345 346 347
            if let Some(lev_candidate) = lev_candidate {
                err.span_label(span, format!("did you mean `{}`?", lev_candidate));
            } else {
                err.span_label(span, format!("undeclared label `{}`", name));
            }
C
crypto-universe 已提交
348
            err
C
corentih 已提交
349
        }
350
        ResolutionError::SelfImportsOnlyAllowedWithin => {
N
Nick Cameron 已提交
351 352 353 354 355
            struct_span_err!(resolver.session,
                             span,
                             E0429,
                             "{}",
                             "`self` imports are only allowed within a { } list")
C
corentih 已提交
356
        }
357
        ResolutionError::SelfImportCanOnlyAppearOnceInTheList => {
E
Esteban Küber 已提交
358 359 360 361
            let mut err = struct_span_err!(resolver.session, span, E0430,
                                           "`self` import can only appear once in an import list");
            err.span_label(span, "can only appear once in an import list");
            err
C
corentih 已提交
362
        }
363
        ResolutionError::SelfImportOnlyInImportListWithNonEmptyPrefix => {
E
Esteban Küber 已提交
364 365 366 367 368
            let mut err = struct_span_err!(resolver.session, span, E0431,
                                           "`self` import can only appear in an import list with \
                                            a non-empty prefix");
            err.span_label(span, "can only appear in an import list with a non-empty prefix");
            err
369
        }
370
        ResolutionError::FailedToResolve(msg) => {
J
Jonathan Turner 已提交
371 372
            let mut err = struct_span_err!(resolver.session, span, E0433,
                                           "failed to resolve. {}", msg);
373
            err.span_label(span, msg);
374
            err
C
corentih 已提交
375
        }
376
        ResolutionError::CannotCaptureDynamicEnvironmentInFnItem => {
E
Esteban Küber 已提交
377 378 379 380 381 382 383
            let mut err = struct_span_err!(resolver.session,
                                           span,
                                           E0434,
                                           "{}",
                                           "can't capture dynamic environment in a fn item");
            err.help("use the `|| { ... }` closure form instead");
            err
C
corentih 已提交
384 385
        }
        ResolutionError::AttemptToUseNonConstantValueInConstant => {
E
Esteban Küber 已提交
386 387
            let mut err = struct_span_err!(resolver.session, span, E0435,
                                           "attempt to use a non-constant value in a constant");
388
            err.span_label(span, "non-constant value");
S
Shyam Sundar B 已提交
389
            err
C
corentih 已提交
390
        }
391
        ResolutionError::BindingShadowsSomethingUnacceptable(what_binding, name, binding) => {
392
            let shadows_what = PathResolution::new(binding.def()).kind_name();
393 394
            let mut err = struct_span_err!(resolver.session,
                                           span,
395
                                           E0530,
396
                                           "{}s cannot shadow {}s", what_binding, shadows_what);
397
            err.span_label(span, format!("cannot be named the same as a {}", shadows_what));
398
            let participle = if binding.is_import() { "imported" } else { "defined" };
399
            let msg = format!("a {} `{}` is {} here", shadows_what, name, participle);
400
            err.span_label(binding.span, msg);
401 402
            err
        }
403 404 405 406
        ResolutionError::ForwardDeclaredTyParam => {
            let mut err = struct_span_err!(resolver.session, span, E0128,
                                           "type parameters with a default cannot use \
                                            forward declared identifiers");
L
ljedrz 已提交
407 408
            err.span_label(
                span, "defaulted type parameters cannot be forward declared".to_string());
409 410
            err
        }
N
Nick Cameron 已提交
411
    }
412 413
}

414 415 416 417 418 419
/// Adjust the impl span so that just the `impl` keyword is taken by removing
/// everything after `<` (`"impl<T> Iterator for A<T> {}" -> "impl"`) and
/// everything after the first whitespace (`"impl Iterator for A" -> "impl"`)
///
/// Attention: The method used is very fragile since it essentially duplicates the work of the
/// parser. If you need to use this function or something similar, please consider updating the
D
Donato Sciarra 已提交
420
/// source_map functions and this function to something more robust.
D
Donato Sciarra 已提交
421
fn reduce_impl_span_to_impl_keyword(cm: &SourceMap, impl_span: Span) -> Span {
422 423 424 425 426
    let impl_span = cm.span_until_char(impl_span, '<');
    let impl_span = cm.span_until_whitespace(impl_span);
    impl_span
}

427
#[derive(Copy, Clone, Debug)]
428
struct BindingInfo {
429
    span: Span,
430
    binding_mode: BindingMode,
431 432
}

433
/// Map from the name in a pattern to its binding mode.
434
type BindingMap = FxHashMap<Ident, BindingInfo>;
435

436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum PatternSource {
    Match,
    IfLet,
    WhileLet,
    Let,
    For,
    FnParam,
}

impl PatternSource {
    fn descr(self) -> &'static str {
        match self {
            PatternSource::Match => "match binding",
            PatternSource::IfLet => "if let binding",
            PatternSource::WhileLet => "while let binding",
            PatternSource::Let => "let binding",
            PatternSource::For => "for binding",
            PatternSource::FnParam => "function parameter",
        }
    }
457 458
}

A
Alex Burka 已提交
459 460 461 462 463 464
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
enum AliasPossibility {
    No,
    Maybe,
}

465
#[derive(Copy, Clone, Debug)]
466 467 468 469
enum PathSource<'a> {
    // Type paths `Path`.
    Type,
    // Trait paths in bounds or impls.
A
Alex Burka 已提交
470
    Trait(AliasPossibility),
471
    // Expression paths `path`, with optional parent context.
472
    Expr(Option<&'a Expr>),
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
    // Paths in path patterns `Path`.
    Pat,
    // Paths in struct expressions and patterns `Path { .. }`.
    Struct,
    // Paths in tuple struct patterns `Path(..)`.
    TupleStruct,
    // `m::A::B` in `<T as m::A>::B::C`.
    TraitItem(Namespace),
    // Path in `pub(path)`
    Visibility,
    // Path in `use a::b::{...};`
    ImportPrefix,
}

impl<'a> PathSource<'a> {
    fn namespace(self) -> Namespace {
        match self {
A
Alex Burka 已提交
490
            PathSource::Type | PathSource::Trait(_) | PathSource::Struct |
491 492 493 494 495 496 497 498 499 500 501
            PathSource::Visibility | PathSource::ImportPrefix => TypeNS,
            PathSource::Expr(..) | PathSource::Pat | PathSource::TupleStruct => ValueNS,
            PathSource::TraitItem(ns) => ns,
        }
    }

    fn global_by_default(self) -> bool {
        match self {
            PathSource::Visibility | PathSource::ImportPrefix => true,
            PathSource::Type | PathSource::Expr(..) | PathSource::Pat |
            PathSource::Struct | PathSource::TupleStruct |
A
Alex Burka 已提交
502
            PathSource::Trait(_) | PathSource::TraitItem(..) => false,
503 504 505 506 507 508 509
        }
    }

    fn defer_to_typeck(self) -> bool {
        match self {
            PathSource::Type | PathSource::Expr(..) | PathSource::Pat |
            PathSource::Struct | PathSource::TupleStruct => true,
A
Alex Burka 已提交
510
            PathSource::Trait(_) | PathSource::TraitItem(..) |
511 512 513 514 515 516 517
            PathSource::Visibility | PathSource::ImportPrefix => false,
        }
    }

    fn descr_expected(self) -> &'static str {
        match self {
            PathSource::Type => "type",
A
Alex Burka 已提交
518
            PathSource::Trait(_) => "trait",
519 520 521 522 523 524 525 526 527 528
            PathSource::Pat => "unit struct/variant or constant",
            PathSource::Struct => "struct, variant or union type",
            PathSource::TupleStruct => "tuple struct/variant",
            PathSource::Visibility => "module",
            PathSource::ImportPrefix => "module or enum",
            PathSource::TraitItem(ns) => match ns {
                TypeNS => "associated type",
                ValueNS => "method or associated constant",
                MacroNS => bug!("associated macro"),
            },
529
            PathSource::Expr(parent) => match parent.map(|p| &p.node) {
530 531 532 533 534 535 536 537 538 539 540 541 542
                // "function" here means "anything callable" rather than `Def::Fn`,
                // this is not precise but usually more helpful than just "value".
                Some(&ExprKind::Call(..)) => "function",
                _ => "value",
            },
        }
    }

    fn is_expected(self, def: Def) -> bool {
        match self {
            PathSource::Type => match def {
                Def::Struct(..) | Def::Union(..) | Def::Enum(..) |
                Def::Trait(..) | Def::TyAlias(..) | Def::AssociatedTy(..) |
543
                Def::PrimTy(..) | Def::TyParam(..) | Def::SelfTy(..) |
O
Oliver Schneider 已提交
544
                Def::Existential(..) |
V
varkor 已提交
545
                Def::ForeignTy(..) => true,
546 547
                _ => false,
            },
A
Alex Burka 已提交
548 549 550 551 552
            PathSource::Trait(AliasPossibility::No) => match def {
                Def::Trait(..) => true,
                _ => false,
            },
            PathSource::Trait(AliasPossibility::Maybe) => match def {
553
                Def::Trait(..) => true,
A
Alex Burka 已提交
554
                Def::TraitAlias(..) => true,
555 556 557 558 559 560
                _ => false,
            },
            PathSource::Expr(..) => match def {
                Def::StructCtor(_, CtorKind::Const) | Def::StructCtor(_, CtorKind::Fn) |
                Def::VariantCtor(_, CtorKind::Const) | Def::VariantCtor(_, CtorKind::Fn) |
                Def::Const(..) | Def::Static(..) | Def::Local(..) | Def::Upvar(..) |
F
F001 已提交
561 562
                Def::Fn(..) | Def::Method(..) | Def::AssociatedConst(..) |
                Def::SelfCtor(..) => true,
563 564 565 566 567
                _ => false,
            },
            PathSource::Pat => match def {
                Def::StructCtor(_, CtorKind::Const) |
                Def::VariantCtor(_, CtorKind::Const) |
F
F001 已提交
568 569
                Def::Const(..) | Def::AssociatedConst(..) |
                Def::SelfCtor(..) => true,
570 571 572
                _ => false,
            },
            PathSource::TupleStruct => match def {
F
F001 已提交
573 574 575
                Def::StructCtor(_, CtorKind::Fn) |
                Def::VariantCtor(_, CtorKind::Fn) |
                Def::SelfCtor(..) => true,
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
                _ => false,
            },
            PathSource::Struct => match def {
                Def::Struct(..) | Def::Union(..) | Def::Variant(..) |
                Def::TyAlias(..) | Def::AssociatedTy(..) | Def::SelfTy(..) => true,
                _ => false,
            },
            PathSource::TraitItem(ns) => match def {
                Def::AssociatedConst(..) | Def::Method(..) if ns == ValueNS => true,
                Def::AssociatedTy(..) if ns == TypeNS => true,
                _ => false,
            },
            PathSource::ImportPrefix => match def {
                Def::Mod(..) | Def::Enum(..) => true,
                _ => false,
            },
            PathSource::Visibility => match def {
                Def::Mod(..) => true,
                _ => false,
            },
        }
    }

    fn error_code(self, has_unexpected_resolution: bool) -> &'static str {
        __diagnostic_used!(E0404);
        __diagnostic_used!(E0405);
        __diagnostic_used!(E0412);
        __diagnostic_used!(E0422);
        __diagnostic_used!(E0423);
        __diagnostic_used!(E0425);
        __diagnostic_used!(E0531);
        __diagnostic_used!(E0532);
        __diagnostic_used!(E0573);
        __diagnostic_used!(E0574);
        __diagnostic_used!(E0575);
        __diagnostic_used!(E0576);
        __diagnostic_used!(E0577);
        __diagnostic_used!(E0578);
        match (self, has_unexpected_resolution) {
A
Alex Burka 已提交
615 616
            (PathSource::Trait(_), true) => "E0404",
            (PathSource::Trait(_), false) => "E0405",
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
            (PathSource::Type, true) => "E0573",
            (PathSource::Type, false) => "E0412",
            (PathSource::Struct, true) => "E0574",
            (PathSource::Struct, false) => "E0422",
            (PathSource::Expr(..), true) => "E0423",
            (PathSource::Expr(..), false) => "E0425",
            (PathSource::Pat, true) | (PathSource::TupleStruct, true) => "E0532",
            (PathSource::Pat, false) | (PathSource::TupleStruct, false) => "E0531",
            (PathSource::TraitItem(..), true) => "E0575",
            (PathSource::TraitItem(..), false) => "E0576",
            (PathSource::Visibility, true) | (PathSource::ImportPrefix, true) => "E0577",
            (PathSource::Visibility, false) | (PathSource::ImportPrefix, false) => "E0578",
        }
    }
}

633 634 635
struct UsePlacementFinder {
    target_module: NodeId,
    span: Option<Span>,
636
    found_use: bool,
637 638
}

639 640 641 642 643 644 645 646 647 648 649 650
impl UsePlacementFinder {
    fn check(krate: &Crate, target_module: NodeId) -> (Option<Span>, bool) {
        let mut finder = UsePlacementFinder {
            target_module,
            span: None,
            found_use: false,
        };
        visit::walk_crate(&mut finder, krate);
        (finder.span, finder.found_use)
    }
}

651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
impl<'tcx> Visitor<'tcx> for UsePlacementFinder {
    fn visit_mod(
        &mut self,
        module: &'tcx ast::Mod,
        _: Span,
        _: &[ast::Attribute],
        node_id: NodeId,
    ) {
        if self.span.is_some() {
            return;
        }
        if node_id != self.target_module {
            visit::walk_mod(self, module);
            return;
        }
        // find a use statement
        for item in &module.items {
            match item.node {
                ItemKind::Use(..) => {
                    // don't suggest placing a use before the prelude
                    // import or other generated ones
672
                    if item.span.ctxt().outer().expn_info().is_none() {
673
                        self.span = Some(item.span.shrink_to_lo());
674
                        self.found_use = true;
675 676 677 678 679 680 681
                        return;
                    }
                },
                // don't place use before extern crate
                ItemKind::ExternCrate(_) => {}
                // but place them before the first other item
                _ => if self.span.map_or(true, |span| item.span < span ) {
682 683 684
                    if item.span.ctxt().outer().expn_info().is_none() {
                        // don't insert between attributes and an item
                        if item.attrs.is_empty() {
685
                            self.span = Some(item.span.shrink_to_lo());
686 687 688 689
                        } else {
                            // find the first attribute on the item
                            for attr in &item.attrs {
                                if self.span.map_or(true, |span| attr.span < span) {
690
                                    self.span = Some(attr.span.shrink_to_lo());
691 692 693 694
                                }
                            }
                        }
                    }
695 696 697 698 699 700
                },
            }
        }
    }
}

701
/// This thing walks the whole crate in DFS manner, visiting each item, resolving names as it goes.
702
impl<'a, 'tcx, 'cl> Visitor<'tcx> for Resolver<'a, 'cl> {
703
    fn visit_item(&mut self, item: &'tcx Item) {
A
Alex Crichton 已提交
704
        self.resolve_item(item);
705
    }
706
    fn visit_arm(&mut self, arm: &'tcx Arm) {
A
Alex Crichton 已提交
707
        self.resolve_arm(arm);
708
    }
709
    fn visit_block(&mut self, block: &'tcx Block) {
A
Alex Crichton 已提交
710
        self.resolve_block(block);
711
    }
712 713 714 715 716
    fn visit_anon_const(&mut self, constant: &'tcx ast::AnonConst) {
        self.with_constant_rib(|this| {
            visit::walk_anon_const(this, constant);
        });
    }
717
    fn visit_expr(&mut self, expr: &'tcx Expr) {
718
        self.resolve_expr(expr, None);
719
    }
720
    fn visit_local(&mut self, local: &'tcx Local) {
A
Alex Crichton 已提交
721
        self.resolve_local(local);
722
    }
723
    fn visit_ty(&mut self, ty: &'tcx Ty) {
724 725 726 727 728 729
        match ty.node {
            TyKind::Path(ref qself, ref path) => {
                self.smart_resolve_path(ty.id, qself.as_ref(), path, PathSource::Type);
            }
            TyKind::ImplicitSelf => {
                let self_ty = keywords::SelfType.ident();
730
                let def = self.resolve_ident_in_lexical_scope(self_ty, TypeNS, Some(ty.id), ty.span)
731 732 733 734
                              .map_or(Def::Err, |d| d.def());
                self.record_def(ty.id, PathResolution::new(def));
            }
            _ => (),
735 736
        }
        visit::walk_ty(self, ty);
737
    }
738 739 740
    fn visit_poly_trait_ref(&mut self,
                            tref: &'tcx ast::PolyTraitRef,
                            m: &'tcx ast::TraitBoundModifier) {
741
        self.smart_resolve_path(tref.trait_ref.ref_id, None,
A
Alex Burka 已提交
742
                                &tref.trait_ref.path, PathSource::Trait(AliasPossibility::Maybe));
743
        visit::walk_poly_trait_ref(self, tref, m);
744
    }
745
    fn visit_foreign_item(&mut self, foreign_item: &'tcx ForeignItem) {
746
        let type_parameters = match foreign_item.node {
747
            ForeignItemKind::Fn(_, ref generics) => {
748
                HasTypeParameters(generics, ItemRibKind)
749
            }
750
            ForeignItemKind::Static(..) => NoTypeParameters,
P
Paul Lietar 已提交
751
            ForeignItemKind::Ty => NoTypeParameters,
752
            ForeignItemKind::Macro(..) => NoTypeParameters,
753 754
        };
        self.with_type_parameter_rib(type_parameters, |this| {
755
            visit::walk_foreign_item(this, foreign_item);
756 757 758
        });
    }
    fn visit_fn(&mut self,
759 760
                function_kind: FnKind<'tcx>,
                declaration: &'tcx FnDecl,
761
                _: Span,
T
Taylor Cramer 已提交
762 763 764 765 766 767 768 769 770 771 772
                node_id: NodeId)
    {
        let (rib_kind, asyncness) = match function_kind {
            FnKind::ItemFn(_, ref header, ..) =>
                (ItemRibKind, header.asyncness),
            FnKind::Method(_, ref sig, _, _) =>
                (TraitOrImplItemRibKind, sig.header.asyncness),
            FnKind::Closure(_) =>
                // Async closures aren't resolved through `visit_fn`-- they're
                // processed separately
                (ClosureRibKind(node_id), IsAsync::NotAsync),
773
        };
774 775

        // Create a value rib for the function.
J
Jeffrey Seyfried 已提交
776
        self.ribs[ValueNS].push(Rib::new(rib_kind));
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791

        // Create a label rib for the function.
        self.label_ribs.push(Rib::new(rib_kind));

        // Add each argument to the rib.
        let mut bindings_list = FxHashMap();
        for argument in &declaration.inputs {
            self.resolve_pattern(&argument.pat, PatternSource::FnParam, &mut bindings_list);

            self.visit_ty(&argument.ty);

            debug!("(resolving function) recorded argument");
        }
        visit::walk_fn_ret_ty(self, &declaration.output);

T
Taylor Cramer 已提交
792
        // Resolve the function body, potentially inside the body of an async closure
793 794
        if let IsAsync::Async { closure_id, .. } = asyncness {
            let rib_kind = ClosureRibKind(closure_id);
T
Taylor Cramer 已提交
795 796 797 798
            self.ribs[ValueNS].push(Rib::new(rib_kind));
            self.label_ribs.push(Rib::new(rib_kind));
        }

799 800 801 802 803 804 805 806 807 808
        match function_kind {
            FnKind::ItemFn(.., body) |
            FnKind::Method(.., body) => {
                self.visit_block(body);
            }
            FnKind::Closure(body) => {
                self.visit_expr(body);
            }
        };

T
Taylor Cramer 已提交
809 810 811 812 813 814
        // Leave the body of the async closure
        if asyncness.is_async() {
            self.label_ribs.pop();
            self.ribs[ValueNS].pop();
        }

815 816 817
        debug!("(resolving function) leaving function");

        self.label_ribs.pop();
J
Jeffrey Seyfried 已提交
818
        self.ribs[ValueNS].pop();
819
    }
820 821 822
    fn visit_generics(&mut self, generics: &'tcx Generics) {
        // For type parameter defaults, we have to ban access
        // to following type parameters, as the Substs can only
823 824 825
        // provide previous type parameters as they're built. We
        // put all the parameters on the ban list and then remove
        // them one by one as they are processed and become available.
826
        let mut default_ban_rib = Rib::new(ForwardTyParamBanRibKind);
V
varkor 已提交
827
        let mut found_default = false;
828
        default_ban_rib.bindings.extend(generics.params.iter()
V
varkor 已提交
829
            .filter_map(|param| match param.kind {
V
varkor 已提交
830 831
                GenericParamKind::Lifetime { .. } => None,
                GenericParamKind::Type { ref default, .. } => {
V
varkor 已提交
832 833
                    found_default |= default.is_some();
                    if found_default {
V
varkor 已提交
834
                        Some((Ident::with_empty_ctxt(param.ident.name), Def::Err))
V
varkor 已提交
835 836
                    } else {
                        None
V
varkor 已提交
837 838 839
                    }
                }
            }));
840

841
        for param in &generics.params {
V
varkor 已提交
842
            match param.kind {
V
varkor 已提交
843
                GenericParamKind::Lifetime { .. } => self.visit_generic_param(param),
V
varkor 已提交
844 845
                GenericParamKind::Type { ref default, .. } => {
                    for bound in &param.bounds {
V
varkor 已提交
846
                        self.visit_param_bound(bound);
847
                    }
848

V
varkor 已提交
849
                    if let Some(ref ty) = default {
850 851 852 853
                        self.ribs[TypeNS].push(default_ban_rib);
                        self.visit_ty(ty);
                        default_ban_rib = self.ribs[TypeNS].pop().unwrap();
                    }
854

855
                    // Allow all following defaults to refer to this type parameter.
V
varkor 已提交
856
                    default_ban_rib.bindings.remove(&Ident::with_empty_ctxt(param.ident.name));
857 858
                }
            }
859
        }
V
varkor 已提交
860 861 862
        for p in &generics.where_clause.predicates {
            self.visit_where_predicate(p);
        }
863
    }
864
}
865

N
Niko Matsakis 已提交
866
#[derive(Copy, Clone)]
867
enum TypeParameters<'a, 'b> {
868
    NoTypeParameters,
C
corentih 已提交
869
    HasTypeParameters(// Type parameters.
870
                      &'b Generics,
871

C
corentih 已提交
872
                      // The kind of the rib used for type parameters.
873
                      RibKind<'a>),
874 875
}

M
Mark Mansi 已提交
876 877
/// The rib kind controls the translation of local
/// definitions (`Def::Local`) to upvars (`Def::Upvar`).
N
Niko Matsakis 已提交
878
#[derive(Copy, Clone, Debug)]
879
enum RibKind<'a> {
M
Mark Mansi 已提交
880
    /// No translation needs to be applied.
881
    NormalRibKind,
882

M
Mark Mansi 已提交
883 884
    /// We passed through a closure scope at the given node ID.
    /// Translate upvars as appropriate.
885
    ClosureRibKind(NodeId /* func id */),
886

M
Mark Mansi 已提交
887 888 889 890
    /// We passed through an impl or trait and are now in one of its
    /// methods or associated types. Allow references to ty params that impl or trait
    /// binds. Disallow any other upvars (including other ty params that are
    /// upvars).
891
    TraitOrImplItemRibKind,
892

M
Mark Mansi 已提交
893
    /// We passed through an item scope. Disallow upvars.
894
    ItemRibKind,
895

M
Mark Mansi 已提交
896
    /// We're in a constant item. Can't refer to dynamic stuff.
C
corentih 已提交
897
    ConstantItemRibKind,
898

M
Mark Mansi 已提交
899
    /// We passed through a module.
900
    ModuleRibKind(Module<'a>),
901

M
Mark Mansi 已提交
902
    /// We passed through a `macro_rules!` statement
903
    MacroDefinition(DefId),
904

M
Mark Mansi 已提交
905 906 907
    /// All bindings in this rib are type parameters that can't be used
    /// from the default of a type parameter because they're not declared
    /// before said type parameter. Also see the `visit_generics` override.
908
    ForwardTyParamBanRibKind,
909 910
}

911
/// One local scope.
912 913 914
///
/// A rib represents a scope names can live in. Note that these appear in many places, not just
/// around braces. At any place where the list of accessible names (of the given namespace)
915 916 917
/// changes or a new restrictions on the name accessibility are introduced, a new rib is put onto a
/// stack. This may be, for example, a `let` statement (because it introduces variables), a macro,
/// etc.
918 919 920 921 922
///
/// Different [rib kinds](enum.RibKind) are transparent for different names.
///
/// The resolution keeps a separate stack of ribs as it traverses the AST for each namespace. When
/// resolving, the name is looked up from inside out.
J
Jorge Aparicio 已提交
923
#[derive(Debug)]
924
struct Rib<'a> {
925
    bindings: FxHashMap<Ident, Def>,
926
    kind: RibKind<'a>,
B
Brian Anderson 已提交
927
}
928

929 930
impl<'a> Rib<'a> {
    fn new(kind: RibKind<'a>) -> Rib<'a> {
931
        Rib {
932
            bindings: FxHashMap(),
933
            kind,
934
        }
935 936 937
    }
}

938 939 940 941 942
/// An intermediate resolution result.
///
/// This refers to the thing referred by a name. The difference between `Def` and `Item` is that
/// items are visible in their whole block, while defs only from the place they are defined
/// forward.
943 944
enum LexicalScopeBinding<'a> {
    Item(&'a NameBinding<'a>),
J
Jeffrey Seyfried 已提交
945
    Def(Def),
946 947
}

948
impl<'a> LexicalScopeBinding<'a> {
949
    fn item(self) -> Option<&'a NameBinding<'a>> {
950
        match self {
951
            LexicalScopeBinding::Item(binding) => Some(binding),
952 953 954
            _ => None,
        }
    }
955 956 957 958 959 960 961

    fn def(self) -> Def {
        match self {
            LexicalScopeBinding::Item(binding) => binding.def(),
            LexicalScopeBinding::Def(def) => def,
        }
    }
962 963
}

964 965 966 967 968 969 970 971 972 973 974
#[derive(Copy, Clone, Debug)]
pub enum ModuleOrUniformRoot<'a> {
    /// Regular module.
    Module(Module<'a>),

    /// The `{{root}}` (`CrateRoot` aka "global") / `extern` initial segment
    /// in which external crates resolve, and also `crate` (only in `{{root}}`,
    /// but *not* `extern`), in the Rust 2018 edition.
    UniformRoot(Name),
}

975
#[derive(Clone, Debug)]
J
Jeffrey Seyfried 已提交
976
enum PathResult<'a> {
977
    Module(ModuleOrUniformRoot<'a>),
J
Jeffrey Seyfried 已提交
978 979
    NonModule(PathResolution),
    Indeterminate,
980
    Failed(Span, String, bool /* is the error from the last segment? */),
J
Jeffrey Seyfried 已提交
981 982
}

J
Jeffrey Seyfried 已提交
983
enum ModuleKind {
984 985 986 987 988 989 990 991 992 993 994 995
    /// An anonymous module, eg. just a block.
    ///
    /// ```
    /// fn main() {
    ///     fn f() {} // (1)
    ///     { // This is an anonymous module
    ///         f(); // This resolves to (2) as we are inside the block.
    ///         fn f() {} // (2)
    ///     }
    ///     f(); // Resolves to (1)
    /// }
    /// ```
J
Jeffrey Seyfried 已提交
996
    Block(NodeId),
997 998 999
    /// Any module with a name.
    ///
    /// This could be:
1000
    ///
1001 1002 1003
    /// * A normal module ‒ either `mod from_file;` or `mod from_block { }`.
    /// * A trait or an enum (it implicitly contains associated types, methods and variant
    ///   constructors).
J
Jeffrey Seyfried 已提交
1004
    Def(Def, Name),
1005 1006
}

1007
/// One node in the tree of modules.
1008
pub struct ModuleData<'a> {
J
Jeffrey Seyfried 已提交
1009 1010
    parent: Option<Module<'a>>,
    kind: ModuleKind,
1011

1012 1013
    // The def id of the closest normal module (`mod`) ancestor (including this module).
    normal_ancestor_id: DefId,
1014

1015
    resolutions: RefCell<FxHashMap<(Ident, Namespace), &'a RefCell<NameResolution<'a>>>>,
1016
    legacy_macro_resolutions: RefCell<Vec<(Ident, MacroKind, ParentScope<'a>, Option<Def>)>>,
1017
    macro_resolutions: RefCell<Vec<(Box<[Ident]>, Span)>>,
1018
    builtin_attrs: RefCell<Vec<(Ident, ParentScope<'a>)>>,
1019

1020 1021 1022
    // Macro invocations that can expand into items in this module.
    unresolved_invocations: RefCell<FxHashSet<Mark>>,

1023
    no_implicit_prelude: bool,
1024

1025
    glob_importers: RefCell<Vec<&'a ImportDirective<'a>>>,
1026
    globs: RefCell<Vec<&'a ImportDirective<'a>>>,
1027

J
Jeffrey Seyfried 已提交
1028
    // Used to memoize the traits in this module for faster searches through all traits in scope.
1029
    traits: RefCell<Option<Box<[(Ident, &'a NameBinding<'a>)]>>>,
J
Jeffrey Seyfried 已提交
1030

1031 1032 1033
    // Whether this module is populated. If not populated, any attempt to
    // access the children must be preceded with a
    // `populate_module_if_necessary` call.
1034
    populated: Cell<bool>,
1035 1036 1037

    /// Span of the module itself. Used for error reporting.
    span: Span,
J
Jeffrey Seyfried 已提交
1038 1039

    expansion: Mark,
1040 1041
}

1042
type Module<'a> = &'a ModuleData<'a>;
1043

1044
impl<'a> ModuleData<'a> {
O
Oliver Schneider 已提交
1045 1046 1047
    fn new(parent: Option<Module<'a>>,
           kind: ModuleKind,
           normal_ancestor_id: DefId,
J
Jeffrey Seyfried 已提交
1048
           expansion: Mark,
O
Oliver Schneider 已提交
1049
           span: Span) -> Self {
1050
        ModuleData {
1051 1052 1053
            parent,
            kind,
            normal_ancestor_id,
1054
            resolutions: RefCell::new(FxHashMap()),
1055
            legacy_macro_resolutions: RefCell::new(Vec::new()),
1056
            macro_resolutions: RefCell::new(Vec::new()),
1057
            builtin_attrs: RefCell::new(Vec::new()),
1058
            unresolved_invocations: RefCell::new(FxHashSet()),
1059
            no_implicit_prelude: false,
1060
            glob_importers: RefCell::new(Vec::new()),
1061
            globs: RefCell::new(Vec::new()),
J
Jeffrey Seyfried 已提交
1062
            traits: RefCell::new(None),
1063
            populated: Cell::new(normal_ancestor_id.is_local()),
1064 1065
            span,
            expansion,
1066
        }
B
Brian Anderson 已提交
1067 1068
    }

1069 1070 1071
    fn for_each_child<F: FnMut(Ident, Namespace, &'a NameBinding<'a>)>(&self, mut f: F) {
        for (&(ident, ns), name_resolution) in self.resolutions.borrow().iter() {
            name_resolution.borrow().binding.map(|binding| f(ident, ns, binding));
1072 1073 1074
        }
    }

1075 1076
    fn for_each_child_stable<F: FnMut(Ident, Namespace, &'a NameBinding<'a>)>(&self, mut f: F) {
        let resolutions = self.resolutions.borrow();
1077
        let mut resolutions = resolutions.iter().collect::<Vec<_>>();
V
Vadim Petrochenkov 已提交
1078
        resolutions.sort_by_cached_key(|&(&(ident, ns), _)| (ident.as_str(), ns));
1079
        for &(&(ident, ns), &resolution) in resolutions.iter() {
1080 1081 1082 1083
            resolution.borrow().binding.map(|binding| f(ident, ns, binding));
        }
    }

J
Jeffrey Seyfried 已提交
1084 1085 1086 1087 1088 1089 1090
    fn def(&self) -> Option<Def> {
        match self.kind {
            ModuleKind::Def(def, _) => Some(def),
            _ => None,
        }
    }

1091
    fn def_id(&self) -> Option<DefId> {
J
Jeffrey Seyfried 已提交
1092
        self.def().as_ref().map(Def::def_id)
1093 1094
    }

1095
    // `self` resolves to the first module ancestor that `is_normal`.
1096
    fn is_normal(&self) -> bool {
J
Jeffrey Seyfried 已提交
1097 1098
        match self.kind {
            ModuleKind::Def(Def::Mod(_), _) => true,
1099 1100 1101 1102 1103
            _ => false,
        }
    }

    fn is_trait(&self) -> bool {
J
Jeffrey Seyfried 已提交
1104 1105
        match self.kind {
            ModuleKind::Def(Def::Trait(_), _) => true,
1106
            _ => false,
1107
        }
B
Brian Anderson 已提交
1108
    }
1109 1110

    fn is_local(&self) -> bool {
1111
        self.normal_ancestor_id.is_local()
1112
    }
1113 1114 1115 1116

    fn nearest_item_scope(&'a self) -> Module<'a> {
        if self.is_trait() { self.parent.unwrap() } else { self }
    }
V
Victor Berger 已提交
1117 1118
}

1119
impl<'a> fmt::Debug for ModuleData<'a> {
1120
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
J
Jeffrey Seyfried 已提交
1121
        write!(f, "{:?}", self.def())
1122 1123 1124
    }
}

M
Mark Mansi 已提交
1125
/// Records a possibly-private value, type, or module definition.
1126
#[derive(Clone, Debug)]
1127
pub struct NameBinding<'a> {
1128
    kind: NameBindingKind<'a>,
1129
    expansion: Mark,
1130
    span: Span,
1131
    vis: ty::Visibility,
1132 1133
}

1134
pub trait ToNameBinding<'a> {
J
Jeffrey Seyfried 已提交
1135
    fn to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a>;
1136 1137
}

J
Jeffrey Seyfried 已提交
1138 1139
impl<'a> ToNameBinding<'a> for &'a NameBinding<'a> {
    fn to_name_binding(self, _: &'a ResolverArenas<'a>) -> &'a NameBinding<'a> {
1140 1141 1142 1143
        self
    }
}

1144
#[derive(Clone, Debug)]
1145
enum NameBindingKind<'a> {
1146
    Def(Def, /* is_macro_export */ bool),
1147
    Module(Module<'a>),
1148 1149
    Import {
        binding: &'a NameBinding<'a>,
1150
        directive: &'a ImportDirective<'a>,
1151
        used: Cell<bool>,
1152
    },
1153 1154 1155 1156
    Ambiguity {
        b1: &'a NameBinding<'a>,
        b2: &'a NameBinding<'a>,
    }
1157 1158
}

1159 1160
struct PrivacyError<'a>(Span, Name, &'a NameBinding<'a>);

1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
struct UseError<'a> {
    err: DiagnosticBuilder<'a>,
    /// Attach `use` statements for these candidates
    candidates: Vec<ImportSuggestion>,
    /// The node id of the module to place the use statements in
    node_id: NodeId,
    /// Whether the diagnostic should state that it's "better"
    better: bool,
}

J
Jeffrey Seyfried 已提交
1171
struct AmbiguityError<'a> {
1172
    ident: Ident,
J
Jeffrey Seyfried 已提交
1173 1174 1175 1176
    b1: &'a NameBinding<'a>,
    b2: &'a NameBinding<'a>,
}

1177
impl<'a> NameBinding<'a> {
J
Jeffrey Seyfried 已提交
1178
    fn module(&self) -> Option<Module<'a>> {
1179
        match self.kind {
J
Jeffrey Seyfried 已提交
1180
            NameBindingKind::Module(module) => Some(module),
1181
            NameBindingKind::Import { binding, .. } => binding.module(),
J
Jeffrey Seyfried 已提交
1182
            _ => None,
1183 1184 1185
        }
    }

1186
    fn def(&self) -> Def {
1187
        match self.kind {
1188
            NameBindingKind::Def(def, _) => def,
J
Jeffrey Seyfried 已提交
1189
            NameBindingKind::Module(module) => module.def().unwrap(),
1190
            NameBindingKind::Import { binding, .. } => binding.def(),
1191
            NameBindingKind::Ambiguity { .. } => Def::Err,
1192
        }
1193
    }
1194

1195
    fn def_ignoring_ambiguity(&self) -> Def {
J
Jeffrey Seyfried 已提交
1196
        match self.kind {
1197 1198 1199
            NameBindingKind::Import { binding, .. } => binding.def_ignoring_ambiguity(),
            NameBindingKind::Ambiguity { b1, .. } => b1.def_ignoring_ambiguity(),
            _ => self.def(),
J
Jeffrey Seyfried 已提交
1200 1201 1202
        }
    }

1203
    fn get_macro<'b: 'a>(&self, resolver: &mut Resolver<'a, 'b>) -> Lrc<SyntaxExtension> {
1204 1205 1206
        resolver.get_macro(self.def_ignoring_ambiguity())
    }

1207 1208
    // We sometimes need to treat variants as `pub` for backwards compatibility
    fn pseudo_vis(&self) -> ty::Visibility {
1209 1210 1211 1212 1213
        if self.is_variant() && self.def().def_id().is_local() {
            ty::Visibility::Public
        } else {
            self.vis
        }
1214 1215 1216 1217
    }

    fn is_variant(&self) -> bool {
        match self.kind {
1218 1219
            NameBindingKind::Def(Def::Variant(..), _) |
            NameBindingKind::Def(Def::VariantCtor(..), _) => true,
1220 1221
            _ => false,
        }
1222 1223
    }

1224
    fn is_extern_crate(&self) -> bool {
1225 1226 1227
        match self.kind {
            NameBindingKind::Import {
                directive: &ImportDirective {
1228
                    subclass: ImportDirectiveSubclass::ExternCrate(_), ..
1229 1230 1231 1232
                }, ..
            } => true,
            _ => false,
        }
1233
    }
1234 1235 1236 1237 1238 1239 1240

    fn is_import(&self) -> bool {
        match self.kind {
            NameBindingKind::Import { .. } => true,
            _ => false,
        }
    }
1241

1242 1243 1244 1245 1246 1247 1248 1249 1250
    fn is_renamed_extern_crate(&self) -> bool {
        if let NameBindingKind::Import { directive, ..} = self.kind {
            if let ImportDirectiveSubclass::ExternCrate(Some(_)) = directive.subclass {
                return true;
            }
        }
        false
    }

1251 1252 1253
    fn is_glob_import(&self) -> bool {
        match self.kind {
            NameBindingKind::Import { directive, .. } => directive.is_glob(),
1254
            NameBindingKind::Ambiguity { b1, .. } => b1.is_glob_import(),
1255 1256 1257 1258 1259
            _ => false,
        }
    }

    fn is_importable(&self) -> bool {
1260
        match self.def() {
1261 1262 1263 1264
            Def::AssociatedConst(..) | Def::Method(..) | Def::AssociatedTy(..) => false,
            _ => true,
        }
    }
1265 1266 1267

    fn is_macro_def(&self) -> bool {
        match self.kind {
1268
            NameBindingKind::Def(Def::Macro(..), _) => true,
1269 1270 1271
            _ => false,
        }
    }
1272

1273 1274 1275
    fn macro_kind(&self) -> Option<MacroKind> {
        match self.def_ignoring_ambiguity() {
            Def::Macro(_, kind) => Some(kind),
1276
            Def::NonMacroAttr(..) => Some(MacroKind::Attr),
1277 1278 1279 1280
            _ => None,
        }
    }

1281 1282 1283
    fn descr(&self) -> &'static str {
        if self.is_extern_crate() { "extern crate" } else { self.def().kind_name() }
    }
1284

1285 1286
    // Suppose that we resolved macro invocation with `invoc_parent_expansion` to binding `binding`
    // at some expansion round `max(invoc, binding)` when they both emerged from macros.
1287 1288
    // Then this function returns `true` if `self` may emerge from a macro *after* that
    // in some later round and screw up our previously found resolution.
1289 1290
    // See more detailed explanation in
    // https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049
1291 1292
    fn may_appear_after(&self, invoc_parent_expansion: Mark, binding: &NameBinding) -> bool {
        // self > max(invoc, binding) => !(self <= invoc || self <= binding)
1293 1294 1295 1296 1297 1298 1299 1300 1301
        // Expansions are partially ordered, so "may appear after" is an inversion of
        // "certainly appears before or simultaneously" and includes unordered cases.
        let self_parent_expansion = self.expansion;
        let other_parent_expansion = binding.expansion;
        let certainly_before_other_or_simultaneously =
            other_parent_expansion.is_descendant_of(self_parent_expansion);
        let certainly_before_invoc_or_simultaneously =
            invoc_parent_expansion.is_descendant_of(self_parent_expansion);
        !(certainly_before_other_or_simultaneously || certainly_before_invoc_or_simultaneously)
1302
    }
1303 1304
}

1305
/// Interns the names of the primitive types.
1306 1307 1308
///
/// All other types are defined somewhere and possibly imported, but the primitive ones need
/// special handling, since they have no place of origin.
F
Felix S. Klock II 已提交
1309
struct PrimitiveTypeTable {
1310
    primitive_types: FxHashMap<Name, PrimTy>,
1311
}
1312

1313
impl PrimitiveTypeTable {
K
Kevin Butler 已提交
1314
    fn new() -> PrimitiveTypeTable {
1315
        let mut table = PrimitiveTypeTable { primitive_types: FxHashMap() };
C
corentih 已提交
1316

1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
        table.intern("bool", Bool);
        table.intern("char", Char);
        table.intern("f32", Float(FloatTy::F32));
        table.intern("f64", Float(FloatTy::F64));
        table.intern("isize", Int(IntTy::Isize));
        table.intern("i8", Int(IntTy::I8));
        table.intern("i16", Int(IntTy::I16));
        table.intern("i32", Int(IntTy::I32));
        table.intern("i64", Int(IntTy::I64));
        table.intern("i128", Int(IntTy::I128));
        table.intern("str", Str);
        table.intern("usize", Uint(UintTy::Usize));
        table.intern("u8", Uint(UintTy::U8));
        table.intern("u16", Uint(UintTy::U16));
        table.intern("u32", Uint(UintTy::U32));
        table.intern("u64", Uint(UintTy::U64));
        table.intern("u128", Uint(UintTy::U128));
K
Kevin Butler 已提交
1334 1335 1336
        table
    }

1337
    fn intern(&mut self, string: &str, primitive_type: PrimTy) {
1338
        self.primitive_types.insert(Symbol::intern(string), primitive_type);
1339 1340 1341
    }
}

1342
/// The main resolver class.
1343 1344
///
/// This is the visitor that walks the whole crate.
1345
pub struct Resolver<'a, 'b: 'a> {
E
Eduard Burtescu 已提交
1346
    session: &'a Session,
1347
    cstore: &'a CStore,
1348

1349
    pub definitions: Definitions,
1350

1351
    graph_root: Module<'a>,
1352

1353 1354
    prelude: Option<Module<'a>>,

M
Mark Mansi 已提交
1355
    /// n.b. This is used only for better diagnostics, not name resolution itself.
1356
    has_self: FxHashSet<DefId>,
1357

M
Mark Mansi 已提交
1358 1359
    /// Names of fields of an item `DefId` accessible with dot syntax.
    /// Used for hints during error reporting.
1360
    field_names: FxHashMap<DefId, Vec<Name>>,
1361

M
Mark Mansi 已提交
1362
    /// All imports known to succeed or fail.
1363 1364
    determined_imports: Vec<&'a ImportDirective<'a>>,

M
Mark Mansi 已提交
1365
    /// All non-determined imports.
1366
    indeterminate_imports: Vec<&'a ImportDirective<'a>>,
1367

M
Mark Mansi 已提交
1368
    /// The module that represents the current item scope.
1369
    current_module: Module<'a>,
1370

M
Mark Mansi 已提交
1371 1372
    /// The current set of local scopes for types and values.
    /// FIXME #4948: Reuse ribs to avoid allocation.
J
Jeffrey Seyfried 已提交
1373
    ribs: PerNS<Vec<Rib<'a>>>,
1374

M
Mark Mansi 已提交
1375
    /// The current set of local scopes, for labels.
1376
    label_ribs: Vec<Rib<'a>>,
1377

M
Mark Mansi 已提交
1378
    /// The trait that the current context can refer to.
1379
    current_trait_ref: Option<(Module<'a>, TraitRef)>,
1380

M
Mark Mansi 已提交
1381
    /// The current self type if inside an impl (used for better errors).
1382
    current_self_type: Option<Ty>,
1383

1384 1385 1386
    /// The current self item if inside an ADT (used for better errors).
    current_self_item: Option<NodeId>,

M
Mark Mansi 已提交
1387
    /// The idents for the primitive types.
E
Eduard Burtescu 已提交
1388
    primitive_type_table: PrimitiveTypeTable,
1389

1390
    def_map: DefMap,
1391
    import_map: ImportMap,
1392
    pub freevars: FreevarMap,
1393
    freevars_seen: NodeMap<NodeMap<usize>>,
1394 1395
    pub export_map: ExportMap,
    pub trait_map: TraitMap,
1396

M
Mark Mansi 已提交
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
    /// A map from nodes to anonymous modules.
    /// Anonymous modules are pseudo-modules that are implicitly created around items
    /// contained within blocks.
    ///
    /// For example, if we have this:
    ///
    ///  fn f() {
    ///      fn g() {
    ///          ...
    ///      }
    ///  }
    ///
    /// There will be an anonymous module created around `g` with the ID of the
    /// entry block for `f`.
1411 1412
    block_map: NodeMap<Module<'a>>,
    module_map: FxHashMap<DefId, Module<'a>>,
J
Jeffrey Seyfried 已提交
1413
    extern_module_map: FxHashMap<(DefId, bool /* MacrosOnly? */), Module<'a>>,
1414

1415
    pub make_glob_map: bool,
1416 1417
    /// Maps imports to the names of items actually imported (this actually maps
    /// all imports, but only glob imports are actually interesting).
1418
    pub glob_map: GlobMap,
1419

1420
    used_imports: FxHashSet<(NodeId, Namespace)>,
1421
    pub maybe_unused_trait_imports: NodeSet,
1422
    pub maybe_unused_extern_crates: Vec<(NodeId, Span)>,
G
Garming Sam 已提交
1423

1424 1425 1426 1427
    /// A list of labels as of yet unused. Labels will be removed from this map when
    /// they are used (in a `break` or `continue` statement)
    pub unused_labels: FxHashMap<NodeId, Span>,

1428
    /// privacy errors are delayed until the end in order to deduplicate them
1429
    privacy_errors: Vec<PrivacyError<'a>>,
1430
    /// ambiguity errors are delayed for deduplication
J
Jeffrey Seyfried 已提交
1431
    ambiguity_errors: Vec<AmbiguityError<'a>>,
1432 1433
    /// `use` injections are delayed for better placement and deduplication
    use_injections: Vec<UseError<'a>>,
1434 1435
    /// crate-local macro expanded `macro_export` referred to by a module-relative path
    macro_expanded_macro_export_errors: BTreeSet<(Span, Span)>,
1436 1437

    arenas: &'a ResolverArenas<'a>,
1438
    dummy_binding: &'a NameBinding<'a>,
1439

1440
    crate_loader: &'a mut CrateLoader<'b>,
J
Jeffrey Seyfried 已提交
1441
    macro_names: FxHashSet<Ident>,
1442 1443
    builtin_macros: FxHashMap<Name, &'a NameBinding<'a>>,
    macro_use_prelude: FxHashMap<Name, &'a NameBinding<'a>>,
1444
    pub all_macros: FxHashMap<Name, Def>,
1445
    macro_map: FxHashMap<DefId, Lrc<SyntaxExtension>>,
1446 1447
    macro_defs: FxHashMap<Mark, DefId>,
    local_macro_def_scopes: FxHashMap<NodeId, Module<'a>>,
1448
    pub whitelisted_legacy_custom_derives: Vec<Name>,
1449
    pub found_unresolved_macro: bool,
1450

M
Mark Mansi 已提交
1451 1452
    /// List of crate local macros that we need to warn about as being unused.
    /// Right now this only includes macro_rules! macros, and macros 2.0.
E
est31 已提交
1453
    unused_macros: FxHashSet<DefId>,
E
est31 已提交
1454

M
Mark Mansi 已提交
1455
    /// Maps the `Mark` of an expansion to its containing module or block.
1456
    invocations: FxHashMap<Mark, &'a InvocationData<'a>>,
1457

M
Mark Mansi 已提交
1458
    /// Avoid duplicated errors for "name already defined".
1459
    name_already_seen: FxHashMap<Name, Span>,
1460

1461
    potentially_unused_imports: Vec<&'a ImportDirective<'a>>,
1462

M
Mark Mansi 已提交
1463 1464
    /// This table maps struct IDs into struct constructor IDs,
    /// it's not used during normal resolution, only for better error reporting.
1465
    struct_constructors: DefIdMap<(Def, ty::Visibility)>,
1466

M
Mark Mansi 已提交
1467
    /// Only used for better errors on `fn(): fn()`
1468
    current_type_ascription: Vec<Span>,
1469 1470

    injected_crate: Option<Module<'a>>,
1471 1472
}

1473
/// Nothing really interesting here, it just provides memory for the rest of the crate.
1474
pub struct ResolverArenas<'a> {
1475
    modules: arena::TypedArena<ModuleData<'a>>,
1476
    local_modules: RefCell<Vec<Module<'a>>>,
1477
    name_bindings: arena::TypedArena<NameBinding<'a>>,
1478
    import_directives: arena::TypedArena<ImportDirective<'a>>,
1479
    name_resolutions: arena::TypedArena<RefCell<NameResolution<'a>>>,
1480
    invocation_data: arena::TypedArena<InvocationData<'a>>,
J
Jeffrey Seyfried 已提交
1481
    legacy_bindings: arena::TypedArena<LegacyBinding<'a>>,
1482 1483 1484
}

impl<'a> ResolverArenas<'a> {
1485
    fn alloc_module(&'a self, module: ModuleData<'a>) -> Module<'a> {
1486 1487 1488 1489 1490 1491 1492 1493
        let module = self.modules.alloc(module);
        if module.def_id().map(|def_id| def_id.is_local()).unwrap_or(true) {
            self.local_modules.borrow_mut().push(module);
        }
        module
    }
    fn local_modules(&'a self) -> ::std::cell::Ref<'a, Vec<Module<'a>>> {
        self.local_modules.borrow()
1494 1495 1496 1497
    }
    fn alloc_name_binding(&'a self, name_binding: NameBinding<'a>) -> &'a NameBinding<'a> {
        self.name_bindings.alloc(name_binding)
    }
1498 1499
    fn alloc_import_directive(&'a self, import_directive: ImportDirective<'a>)
                              -> &'a ImportDirective {
1500 1501
        self.import_directives.alloc(import_directive)
    }
1502 1503 1504
    fn alloc_name_resolution(&'a self) -> &'a RefCell<NameResolution<'a>> {
        self.name_resolutions.alloc(Default::default())
    }
1505 1506 1507
    fn alloc_invocation_data(&'a self, expansion_data: InvocationData<'a>)
                             -> &'a InvocationData<'a> {
        self.invocation_data.alloc(expansion_data)
J
Jeffrey Seyfried 已提交
1508
    }
J
Jeffrey Seyfried 已提交
1509 1510 1511
    fn alloc_legacy_binding(&'a self, binding: LegacyBinding<'a>) -> &'a LegacyBinding<'a> {
        self.legacy_bindings.alloc(binding)
    }
1512 1513
}

1514
impl<'a, 'b: 'a, 'cl: 'b> ty::DefIdTree for &'a Resolver<'b, 'cl> {
1515 1516 1517
    fn parent(self, id: DefId) -> Option<DefId> {
        match id.krate {
            LOCAL_CRATE => self.definitions.def_key(id.index).parent,
1518
            _ => self.cstore.def_key(id).parent,
1519
        }.map(|index| DefId { index, ..id })
1520 1521 1522
    }
}

1523 1524
/// This interface is used through the AST→HIR step, to embed full paths into the HIR. After that
/// the resolver is no longer needed as all the relevant information is inline.
1525
impl<'a, 'cl> hir::lowering::Resolver for Resolver<'a, 'cl> {
J
Jeffrey Seyfried 已提交
1526
    fn resolve_hir_path(&mut self, path: &mut hir::Path, is_value: bool) {
1527 1528 1529 1530
        self.resolve_hir_path_cb(path, is_value,
                                 |resolver, span, error| resolve_error(resolver, span, error))
    }

T
Taylor Cramer 已提交
1531 1532 1533 1534 1535
    fn resolve_str_path(
        &mut self,
        span: Span,
        crate_root: Option<&str>,
        components: &[&str],
1536
        args: Option<P<hir::GenericArgs>>,
T
Taylor Cramer 已提交
1537 1538
        is_value: bool
    ) -> hir::Path {
V
Vadim Petrochenkov 已提交
1539
        let mut segments = iter::once(keywords::CrateRoot.ident())
T
Taylor Cramer 已提交
1540 1541 1542
            .chain(
                crate_root.into_iter()
                    .chain(components.iter().cloned())
V
Vadim Petrochenkov 已提交
1543 1544
                    .map(Ident::from_str)
            ).map(hir::PathSegment::from_ident).collect::<Vec<_>>();
T
Taylor Cramer 已提交
1545

1546
        if let Some(args) = args {
V
Vadim Petrochenkov 已提交
1547
            let ident = segments.last().unwrap().ident;
T
Taylor Cramer 已提交
1548
            *segments.last_mut().unwrap() = hir::PathSegment {
V
Vadim Petrochenkov 已提交
1549
                ident,
1550
                args: Some(args),
T
Taylor Cramer 已提交
1551 1552 1553 1554
                infer_types: true,
            };
        }

1555 1556 1557
        let mut path = hir::Path {
            span,
            def: Def::Err,
T
Taylor Cramer 已提交
1558
            segments: segments.into(),
1559 1560
        };

M
Manish Goregaokar 已提交
1561
        self.resolve_hir_path(&mut path, is_value);
1562 1563 1564
        path
    }

M
Manish Goregaokar 已提交
1565 1566 1567 1568
    fn get_resolution(&mut self, id: NodeId) -> Option<PathResolution> {
        self.def_map.get(&id).cloned()
    }

1569 1570 1571 1572
    fn get_import(&mut self, id: NodeId) -> PerNS<Option<PathResolution>> {
        self.import_map.get(&id).cloned().unwrap_or_default()
    }

M
Manish Goregaokar 已提交
1573 1574 1575 1576 1577
    fn definitions(&mut self) -> &mut Definitions {
        &mut self.definitions
    }
}

1578
impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
1579 1580 1581
    /// Rustdoc uses this to resolve things in a recoverable way. ResolutionError<'a>
    /// isn't something that can be returned because it can't be made to live that long,
    /// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
1582
    /// just that an error occurred.
M
Manish Goregaokar 已提交
1583 1584
    pub fn resolve_str_path_error(&mut self, span: Span, path_str: &str, is_value: bool)
        -> Result<hir::Path, ()> {
M
Manish Goregaokar 已提交
1585
        use std::iter;
1586
        let mut errored = false;
M
Manish Goregaokar 已提交
1587 1588 1589 1590 1591

        let mut path = if path_str.starts_with("::") {
            hir::Path {
                span,
                def: Def::Err,
1592 1593 1594
                segments: iter::once(keywords::CrateRoot.ident()).chain({
                    path_str.split("::").skip(1).map(Ident::from_str)
                }).map(hir::PathSegment::from_ident).collect(),
M
Manish Goregaokar 已提交
1595 1596 1597 1598 1599
            }
        } else {
            hir::Path {
                span,
                def: Def::Err,
1600 1601
                segments: path_str.split("::").map(Ident::from_str)
                                  .map(hir::PathSegment::from_ident).collect(),
M
Manish Goregaokar 已提交
1602 1603 1604
            }
        };
        self.resolve_hir_path_cb(&mut path, is_value, |_, _, _| errored = true);
1605 1606 1607 1608 1609 1610 1611 1612 1613
        if errored || path.def == Def::Err {
            Err(())
        } else {
            Ok(path)
        }
    }

    /// resolve_hir_path, but takes a callback in case there was an error
    fn resolve_hir_path_cb<F>(&mut self, path: &mut hir::Path, is_value: bool, error_callback: F)
1614 1615
        where F: for<'c, 'b> FnOnce(&'c mut Resolver, Span, ResolutionError<'b>)
    {
1616
        let namespace = if is_value { ValueNS } else { TypeNS };
1617
        let hir::Path { ref segments, span, ref mut def } = *path;
1618
        let path: Vec<_> = segments.iter().map(|seg| seg.ident).collect();
1619
        // FIXME (Manishearth): Intra doc links won't get warned of epoch changes
1620 1621 1622
        match self.resolve_path(None, &path, Some(namespace), true, span, CrateLint::No) {
            PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                *def = module.def().unwrap(),
1623 1624
            PathResult::NonModule(path_res) if path_res.unresolved_segments() == 0 =>
                *def = path_res.base_def(),
N
Niko Matsakis 已提交
1625
            PathResult::NonModule(..) => match self.resolve_path(
1626
                None,
N
Niko Matsakis 已提交
1627 1628 1629 1630 1631 1632
                &path,
                None,
                true,
                span,
                CrateLint::No,
            ) {
1633
                PathResult::Failed(span, msg, _) => {
1634
                    error_callback(self, span, ResolutionError::FailedToResolve(&msg));
J
Jeffrey Seyfried 已提交
1635 1636 1637
                }
                _ => {}
            },
1638
            PathResult::Module(ModuleOrUniformRoot::UniformRoot(_)) |
J
Jeffrey Seyfried 已提交
1639
            PathResult::Indeterminate => unreachable!(),
1640
            PathResult::Failed(span, msg, _) => {
1641
                error_callback(self, span, ResolutionError::FailedToResolve(&msg));
1642 1643 1644 1645 1646
            }
        }
    }
}

1647
impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
1648
    pub fn new(session: &'a Session,
1649
               cstore: &'a CStore,
1650
               krate: &Crate,
1651
               crate_name: &str,
1652
               make_glob_map: MakeGlobMap,
1653
               crate_loader: &'a mut CrateLoader<'crateloader>,
1654
               arenas: &'a ResolverArenas<'a>)
1655
               -> Resolver<'a, 'crateloader> {
1656 1657
        let root_def_id = DefId::local(CRATE_DEF_INDEX);
        let root_module_kind = ModuleKind::Def(Def::Mod(root_def_id), keywords::Invalid.name());
1658
        let graph_root = arenas.alloc_module(ModuleData {
1659
            no_implicit_prelude: attr::contains_name(&krate.attrs, "no_implicit_prelude"),
J
Jeffrey Seyfried 已提交
1660
            ..ModuleData::new(None, root_module_kind, root_def_id, Mark::root(), krate.span)
1661
        });
1662 1663
        let mut module_map = FxHashMap();
        module_map.insert(DefId::local(CRATE_DEF_INDEX), graph_root);
K
Kevin Butler 已提交
1664

1665
        let mut definitions = Definitions::new();
J
Jeffrey Seyfried 已提交
1666
        DefCollector::new(&mut definitions, Mark::root())
1667
            .collect_root(crate_name, session.local_crate_disambiguator());
1668

1669
        let mut invocations = FxHashMap();
1670 1671
        invocations.insert(Mark::root(),
                           arenas.alloc_invocation_data(InvocationData::root(graph_root)));
1672

1673 1674 1675
        let mut macro_defs = FxHashMap();
        macro_defs.insert(Mark::root(), root_def_id);

K
Kevin Butler 已提交
1676
        Resolver {
1677
            session,
K
Kevin Butler 已提交
1678

1679 1680
            cstore,

1681
            definitions,
1682

K
Kevin Butler 已提交
1683 1684
            // The outermost module has def ID 0; this is not reflected in the
            // AST.
1685
            graph_root,
1686
            prelude: None,
K
Kevin Butler 已提交
1687

1688
            has_self: FxHashSet(),
1689
            field_names: FxHashMap(),
K
Kevin Butler 已提交
1690

1691
            determined_imports: Vec::new(),
1692
            indeterminate_imports: Vec::new(),
K
Kevin Butler 已提交
1693

1694
            current_module: graph_root,
J
Jeffrey Seyfried 已提交
1695 1696 1697
            ribs: PerNS {
                value_ns: vec![Rib::new(ModuleRibKind(graph_root))],
                type_ns: vec![Rib::new(ModuleRibKind(graph_root))],
1698
                macro_ns: vec![Rib::new(ModuleRibKind(graph_root))],
J
Jeffrey Seyfried 已提交
1699
            },
1700
            label_ribs: Vec::new(),
K
Kevin Butler 已提交
1701 1702 1703

            current_trait_ref: None,
            current_self_type: None,
1704
            current_self_item: None,
K
Kevin Butler 已提交
1705 1706 1707

            primitive_type_table: PrimitiveTypeTable::new(),

1708
            def_map: NodeMap(),
1709
            import_map: NodeMap(),
1710 1711
            freevars: NodeMap(),
            freevars_seen: NodeMap(),
A
Alex Crichton 已提交
1712
            export_map: FxHashMap(),
1713
            trait_map: NodeMap(),
1714
            module_map,
1715
            block_map: NodeMap(),
J
Jeffrey Seyfried 已提交
1716
            extern_module_map: FxHashMap(),
K
Kevin Butler 已提交
1717

1718
            make_glob_map: make_glob_map == MakeGlobMap::Yes,
1719
            glob_map: NodeMap(),
G
Garming Sam 已提交
1720

1721
            used_imports: FxHashSet(),
S
Seo Sanghyeon 已提交
1722
            maybe_unused_trait_imports: NodeSet(),
1723
            maybe_unused_extern_crates: Vec::new(),
S
Seo Sanghyeon 已提交
1724

1725 1726
            unused_labels: FxHashMap(),

1727
            privacy_errors: Vec::new(),
1728
            ambiguity_errors: Vec::new(),
1729
            use_injections: Vec::new(),
1730
            macro_expanded_macro_export_errors: BTreeSet::new(),
1731

1732
            arenas,
1733
            dummy_binding: arenas.alloc_name_binding(NameBinding {
1734
                kind: NameBindingKind::Def(Def::Err, false),
1735
                expansion: Mark::root(),
1736 1737 1738
                span: DUMMY_SP,
                vis: ty::Visibility::Public,
            }),
1739

1740
            crate_loader,
1741
            macro_names: FxHashSet(),
1742 1743
            builtin_macros: FxHashMap(),
            macro_use_prelude: FxHashMap(),
1744
            all_macros: FxHashMap(),
J
Jeffrey Seyfried 已提交
1745
            macro_map: FxHashMap(),
1746 1747
            invocations,
            macro_defs,
1748
            local_macro_def_scopes: FxHashMap(),
1749
            name_already_seen: FxHashMap(),
1750
            whitelisted_legacy_custom_derives: Vec::new(),
1751
            potentially_unused_imports: Vec::new(),
1752
            struct_constructors: DefIdMap(),
1753
            found_unresolved_macro: false,
E
est31 已提交
1754
            unused_macros: FxHashSet(),
1755
            current_type_ascription: Vec::new(),
1756
            injected_crate: None,
1757 1758 1759
        }
    }

1760
    pub fn arenas() -> ResolverArenas<'a> {
1761 1762
        ResolverArenas {
            modules: arena::TypedArena::new(),
1763
            local_modules: RefCell::new(Vec::new()),
1764
            name_bindings: arena::TypedArena::new(),
1765
            import_directives: arena::TypedArena::new(),
1766
            name_resolutions: arena::TypedArena::new(),
1767
            invocation_data: arena::TypedArena::new(),
J
Jeffrey Seyfried 已提交
1768
            legacy_bindings: arena::TypedArena::new(),
K
Kevin Butler 已提交
1769 1770
        }
    }
1771

1772
    /// Runs the function on each namespace.
1773 1774 1775
    fn per_ns<F: FnMut(&mut Self, Namespace)>(&mut self, mut f: F) {
        f(self, TypeNS);
        f(self, ValueNS);
1776
        f(self, MacroNS);
J
Jeffrey Seyfried 已提交
1777 1778
    }

J
Jeffrey Seyfried 已提交
1779 1780 1781 1782 1783 1784 1785 1786 1787
    fn macro_def(&self, mut ctxt: SyntaxContext) -> DefId {
        loop {
            match self.macro_defs.get(&ctxt.outer()) {
                Some(&def_id) => return def_id,
                None => ctxt.remove_mark(),
            };
        }
    }

1788 1789
    /// Entry point to crate resolution.
    pub fn resolve_crate(&mut self, krate: &Crate) {
1790
        ImportResolver { resolver: self }.finalize_imports();
1791
        self.current_module = self.graph_root;
1792
        self.finalize_current_module_macro_resolutions();
1793

1794 1795 1796
        visit::walk_crate(self, krate);

        check_unused::check_crate(self, krate);
1797
        self.report_errors(krate);
1798
        self.crate_loader.postprocess(krate);
1799 1800
    }

O
Oliver Schneider 已提交
1801 1802 1803 1804 1805
    fn new_module(
        &self,
        parent: Module<'a>,
        kind: ModuleKind,
        normal_ancestor_id: DefId,
J
Jeffrey Seyfried 已提交
1806
        expansion: Mark,
O
Oliver Schneider 已提交
1807 1808
        span: Span,
    ) -> Module<'a> {
J
Jeffrey Seyfried 已提交
1809 1810
        let module = ModuleData::new(Some(parent), kind, normal_ancestor_id, expansion, span);
        self.arenas.alloc_module(module)
1811 1812
    }

1813
    fn record_use(&mut self, ident: Ident, ns: Namespace, binding: &'a NameBinding<'a>)
1814
                  -> bool /* true if an error was reported */ {
1815
        match binding.kind {
1816
            NameBindingKind::Import { directive, binding, ref used }
J
Jeffrey Seyfried 已提交
1817
                    if !used.get() => {
1818
                used.set(true);
1819
                directive.used.set(true);
1820
                self.used_imports.insert((directive.id, ns));
1821
                self.add_to_glob_map(directive.id, ident);
1822
                self.record_use(ident, ns, binding)
1823 1824
            }
            NameBindingKind::Import { .. } => false,
1825
            NameBindingKind::Ambiguity { b1, b2 } => {
1826
                self.ambiguity_errors.push(AmbiguityError { ident, b1, b2 });
1827
                true
1828 1829
            }
            _ => false
1830
        }
1831
    }
1832

1833
    fn add_to_glob_map(&mut self, id: NodeId, ident: Ident) {
1834
        if self.make_glob_map {
1835
            self.glob_map.entry(id).or_default().insert(ident.name);
1836
        }
1837 1838
    }

1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852
    /// This resolves the identifier `ident` in the namespace `ns` in the current lexical scope.
    /// More specifically, we proceed up the hierarchy of scopes and return the binding for
    /// `ident` in the first scope that defines it (or None if no scopes define it).
    ///
    /// A block's items are above its local variables in the scope hierarchy, regardless of where
    /// the items are defined in the block. For example,
    /// ```rust
    /// fn f() {
    ///    g(); // Since there are no local variables in scope yet, this resolves to the item.
    ///    let g = || {};
    ///    fn g() {}
    ///    g(); // This resolves to the local variable `g` since it shadows the item.
    /// }
    /// ```
1853
    ///
1854 1855
    /// Invariant: This must only be called during main resolution, not during
    /// import resolution.
1856
    fn resolve_ident_in_lexical_scope(&mut self,
1857
                                      mut ident: Ident,
1858
                                      ns: Namespace,
1859
                                      record_used_id: Option<NodeId>,
1860
                                      path_span: Span)
1861
                                      -> Option<LexicalScopeBinding<'a>> {
1862
        let record_used = record_used_id.is_some();
1863
        assert!(ns == TypeNS  || ns == ValueNS);
1864
        if ns == TypeNS {
1865 1866 1867
            ident.span = if ident.name == keywords::SelfType.name() {
                // FIXME(jseyfried) improve `Self` hygiene
                ident.span.with_ctxt(SyntaxContext::empty())
J
Jeffrey Seyfried 已提交
1868
            } else {
1869
                ident.span.modern()
J
Jeffrey Seyfried 已提交
1870
            }
1871 1872
        } else {
            ident = ident.modern_and_legacy();
1873
        }
1874

1875
        // Walk backwards up the ribs in scope.
J
Jeffrey Seyfried 已提交
1876
        let mut module = self.graph_root;
J
Jeffrey Seyfried 已提交
1877 1878
        for i in (0 .. self.ribs[ns].len()).rev() {
            if let Some(def) = self.ribs[ns][i].bindings.get(&ident).cloned() {
1879
                // The ident resolves to a type parameter or local variable.
1880
                return Some(LexicalScopeBinding::Def(
1881
                    self.adjust_local_def(ns, i, def, record_used, path_span)
1882
                ));
1883 1884
            }

J
Jeffrey Seyfried 已提交
1885 1886
            module = match self.ribs[ns][i].kind {
                ModuleRibKind(module) => module,
1887
                MacroDefinition(def) if def == self.macro_def(ident.span.ctxt()) => {
J
Jeffrey Seyfried 已提交
1888 1889
                    // If an invocation of this macro created `ident`, give up on `ident`
                    // and switch to `ident`'s source from the macro definition.
1890
                    ident.span.remove_mark();
J
Jeffrey Seyfried 已提交
1891
                    continue
1892
                }
J
Jeffrey Seyfried 已提交
1893 1894
                _ => continue,
            };
1895

J
Jeffrey Seyfried 已提交
1896
            let item = self.resolve_ident_in_module_unadjusted(
1897 1898 1899 1900 1901 1902
                ModuleOrUniformRoot::Module(module),
                ident,
                ns,
                false,
                record_used,
                path_span,
J
Jeffrey Seyfried 已提交
1903 1904 1905 1906
            );
            if let Ok(binding) = item {
                // The ident resolves to an item.
                return Some(LexicalScopeBinding::Item(binding));
1907
            }
1908

J
Jeffrey Seyfried 已提交
1909 1910 1911 1912 1913 1914
            match module.kind {
                ModuleKind::Block(..) => {}, // We can see through blocks
                _ => break,
            }
        }

1915
        ident.span = ident.span.modern();
1916
        let mut poisoned = None;
J
Jeffrey Seyfried 已提交
1917
        loop {
1918
            let opt_module = if let Some(node_id) = record_used_id {
1919
                self.hygienic_lexical_parent_with_compatibility_fallback(module, &mut ident.span,
1920
                                                                         node_id, &mut poisoned)
1921
            } else {
1922
                self.hygienic_lexical_parent(module, &mut ident.span)
1923 1924
            };
            module = unwrap_or!(opt_module, break);
J
Jeffrey Seyfried 已提交
1925 1926 1927
            let orig_current_module = self.current_module;
            self.current_module = module; // Lexical resolutions can never be a privacy error.
            let result = self.resolve_ident_in_module_unadjusted(
1928 1929 1930 1931 1932 1933
                ModuleOrUniformRoot::Module(module),
                ident,
                ns,
                false,
                record_used,
                path_span,
J
Jeffrey Seyfried 已提交
1934 1935 1936 1937
            );
            self.current_module = orig_current_module;

            match result {
1938
                Ok(binding) => {
1939
                    if let Some(node_id) = poisoned {
1940 1941
                        self.session.buffer_lint_with_diagnostic(
                            lint::builtin::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
1942
                            node_id, ident.span,
1943 1944 1945 1946 1947 1948 1949
                            &format!("cannot find {} `{}` in this scope", ns.descr(), ident),
                            lint::builtin::BuiltinLintDiagnostics::
                                ProcMacroDeriveResolutionFallback(ident.span),
                        );
                    }
                    return Some(LexicalScopeBinding::Item(binding))
                }
1950 1951 1952
                Err(Determined) => continue,
                Err(Undetermined) =>
                    span_bug!(ident.span, "undetermined resolution during main resolution pass"),
J
Jeffrey Seyfried 已提交
1953 1954 1955
            }
        }

1956 1957
        if !module.no_implicit_prelude {
            // `record_used` means that we don't try to load crates during speculative resolution
1958
            if record_used && ns == TypeNS && self.session.extern_prelude.contains(&ident.name) {
1959 1960 1961
                let crate_id = self.crate_loader.process_path_extern(ident.name, ident.span);
                let crate_root = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
                self.populate_module_if_necessary(&crate_root);
1962 1963 1964 1965 1966

                let binding = (crate_root, ty::Visibility::Public,
                               ident.span, Mark::root()).to_name_binding(self.arenas);
                return Some(LexicalScopeBinding::Item(binding));
            }
1967 1968 1969 1970 1971
            if ns == TypeNS && is_known_tool(ident.name) {
                let binding = (Def::ToolMod, ty::Visibility::Public,
                               ident.span, Mark::root()).to_name_binding(self.arenas);
                return Some(LexicalScopeBinding::Item(binding));
            }
1972
            if let Some(prelude) = self.prelude {
1973 1974 1975 1976 1977 1978 1979 1980
                if let Ok(binding) = self.resolve_ident_in_module_unadjusted(
                    ModuleOrUniformRoot::Module(prelude),
                    ident,
                    ns,
                    false,
                    false,
                    path_span,
                ) {
1981 1982
                    return Some(LexicalScopeBinding::Item(binding));
                }
J
Jeffrey Seyfried 已提交
1983 1984
            }
        }
1985 1986

        None
J
Jeffrey Seyfried 已提交
1987 1988
    }

1989
    fn hygienic_lexical_parent(&mut self, module: Module<'a>, span: &mut Span)
J
Jeffrey Seyfried 已提交
1990
                               -> Option<Module<'a>> {
1991 1992
        if !module.expansion.is_descendant_of(span.ctxt().outer()) {
            return Some(self.macro_def_scope(span.remove_mark()));
J
Jeffrey Seyfried 已提交
1993 1994 1995 1996 1997 1998
        }

        if let ModuleKind::Block(..) = module.kind {
            return Some(module.parent.unwrap());
        }

1999 2000 2001
        None
    }

2002 2003 2004 2005
    fn hygienic_lexical_parent_with_compatibility_fallback(&mut self, module: Module<'a>,
                                                           span: &mut Span, node_id: NodeId,
                                                           poisoned: &mut Option<NodeId>)
                                                           -> Option<Module<'a>> {
2006
        if let module @ Some(..) = self.hygienic_lexical_parent(module, span) {
2007
            return module;
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027
        }

        // We need to support the next case under a deprecation warning
        // ```
        // struct MyStruct;
        // ---- begin: this comes from a proc macro derive
        // mod implementation_details {
        //     // Note that `MyStruct` is not in scope here.
        //     impl SomeTrait for MyStruct { ... }
        // }
        // ---- end
        // ```
        // So we have to fall back to the module's parent during lexical resolution in this case.
        if let Some(parent) = module.parent {
            // Inner module is inside the macro, parent module is outside of the macro.
            if module.expansion != parent.expansion &&
            module.expansion.is_descendant_of(parent.expansion) {
                // The macro is a proc macro derive
                if module.expansion.looks_like_proc_macro_derive() {
                    if parent.expansion.is_descendant_of(span.ctxt().outer()) {
2028 2029
                        *poisoned = Some(node_id);
                        return module.parent;
2030 2031
                    }
                }
2032
            }
2033
        }
2034

2035
        None
2036 2037
    }

J
Jeffrey Seyfried 已提交
2038
    fn resolve_ident_in_module(&mut self,
2039
                               module: ModuleOrUniformRoot<'a>,
J
Jeffrey Seyfried 已提交
2040 2041 2042 2043 2044
                               mut ident: Ident,
                               ns: Namespace,
                               record_used: bool,
                               span: Span)
                               -> Result<&'a NameBinding<'a>, Determinacy> {
2045
        ident.span = ident.span.modern();
J
Jeffrey Seyfried 已提交
2046
        let orig_current_module = self.current_module;
2047 2048 2049 2050
        if let ModuleOrUniformRoot::Module(module) = module {
            if let Some(def) = ident.span.adjust(module.expansion) {
                self.current_module = self.macro_def_scope(def);
            }
J
Jeffrey Seyfried 已提交
2051 2052
        }
        let result = self.resolve_ident_in_module_unadjusted(
2053
            module, ident, ns, false, record_used, span,
J
Jeffrey Seyfried 已提交
2054 2055 2056 2057 2058
        );
        self.current_module = orig_current_module;
        result
    }

2059 2060 2061
    fn resolve_crate_root(&mut self, ident: Ident) -> Module<'a> {
        let mut ctxt = ident.span.ctxt();
        let mark = if ident.name == keywords::DollarCrate.name() {
2062 2063 2064
            // When resolving `$crate` from a `macro_rules!` invoked in a `macro`,
            // we don't want to pretend that the `macro_rules!` definition is in the `macro`
            // as described in `SyntaxContext::apply_mark`, so we ignore prepended modern marks.
2065 2066 2067 2068 2069 2070 2071
            // FIXME: This is only a guess and it doesn't work correctly for `macro_rules!`
            // definitions actually produced by `macro` and `macro` definitions produced by
            // `macro_rules!`, but at least such configurations are not stable yet.
            ctxt = ctxt.modern_and_legacy();
            let mut iter = ctxt.marks().into_iter().rev().peekable();
            let mut result = None;
            // Find the last modern mark from the end if it exists.
2072 2073
            while let Some(&(mark, transparency)) = iter.peek() {
                if transparency == Transparency::Opaque {
2074 2075 2076 2077 2078 2079 2080
                    result = Some(mark);
                    iter.next();
                } else {
                    break;
                }
            }
            // Then find the last legacy mark from the end if it exists.
2081 2082
            for (mark, transparency) in iter {
                if transparency == Transparency::SemiTransparent {
2083 2084 2085 2086 2087 2088
                    result = Some(mark);
                } else {
                    break;
                }
            }
            result
2089 2090 2091 2092 2093
        } else {
            ctxt = ctxt.modern();
            ctxt.adjust(Mark::root())
        };
        let module = match mark {
J
Jeffrey Seyfried 已提交
2094 2095 2096 2097 2098 2099 2100 2101
            Some(def) => self.macro_def_scope(def),
            None => return self.graph_root,
        };
        self.get_module(DefId { index: CRATE_DEF_INDEX, ..module.normal_ancestor_id })
    }

    fn resolve_self(&mut self, ctxt: &mut SyntaxContext, module: Module<'a>) -> Module<'a> {
        let mut module = self.get_module(module.normal_ancestor_id);
2102
        while module.span.ctxt().modern() != *ctxt {
J
Jeffrey Seyfried 已提交
2103 2104
            let parent = module.parent.unwrap_or_else(|| self.macro_def_scope(ctxt.remove_mark()));
            module = self.get_module(parent.normal_ancestor_id);
2105
        }
J
Jeffrey Seyfried 已提交
2106
        module
2107 2108
    }

2109 2110
    // AST resolution
    //
2111
    // We maintain a list of value ribs and type ribs.
2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
    //
    // Simultaneously, we keep track of the current position in the module
    // graph in the `current_module` pointer. When we go to resolve a name in
    // the value or type namespaces, we first look through all the ribs and
    // then query the module graph. When we resolve a name in the module
    // namespace, we can skip all the ribs (since nested modules are not
    // allowed within blocks in Rust) and jump straight to the current module
    // graph node.
    //
    // Named implementations are handled separately. When we find a method
    // call, we consult the module node to find all of the implementations in
    // scope. This information is lazily cached in the module node. We then
    // generate a fake "implementation scope" containing all the
    // implementations thus found, for compatibility with old resolve pass.

M
Manish Goregaokar 已提交
2127 2128
    pub fn with_scope<F, T>(&mut self, id: NodeId, f: F) -> T
        where F: FnOnce(&mut Resolver) -> T
J
Jorge Aparicio 已提交
2129
    {
2130
        let id = self.definitions.local_def_id(id);
2131 2132
        let module = self.module_map.get(&id).cloned(); // clones a reference
        if let Some(module) = module {
2133
            // Move down in the graph.
2134
            let orig_module = replace(&mut self.current_module, module);
J
Jeffrey Seyfried 已提交
2135 2136
            self.ribs[ValueNS].push(Rib::new(ModuleRibKind(module)));
            self.ribs[TypeNS].push(Rib::new(ModuleRibKind(module)));
2137

2138
            self.finalize_current_module_macro_resolutions();
M
Manish Goregaokar 已提交
2139
            let ret = f(self);
2140

2141
            self.current_module = orig_module;
J
Jeffrey Seyfried 已提交
2142 2143
            self.ribs[ValueNS].pop();
            self.ribs[TypeNS].pop();
M
Manish Goregaokar 已提交
2144
            ret
2145
        } else {
M
Manish Goregaokar 已提交
2146
            f(self)
2147
        }
2148 2149
    }

2150 2151 2152
    /// Searches the current set of local scopes for labels. Returns the first non-None label that
    /// is returned by the given predicate function
    ///
S
Seo Sanghyeon 已提交
2153
    /// Stops after meeting a closure.
2154 2155 2156
    fn search_label<P, R>(&self, mut ident: Ident, pred: P) -> Option<R>
        where P: Fn(&Rib, Ident) -> Option<R>
    {
2157 2158
        for rib in self.label_ribs.iter().rev() {
            match rib.kind {
J
Jeffrey Seyfried 已提交
2159 2160 2161
                NormalRibKind => {}
                // If an invocation of this macro created `ident`, give up on `ident`
                // and switch to `ident`'s source from the macro definition.
2162
                MacroDefinition(def) => {
2163 2164
                    if def == self.macro_def(ident.span.ctxt()) {
                        ident.span.remove_mark();
2165 2166
                    }
                }
2167 2168
                _ => {
                    // Do not resolve labels across function boundary
C
corentih 已提交
2169
                    return None;
2170 2171
                }
            }
2172 2173 2174
            let r = pred(rib, ident);
            if r.is_some() {
                return r;
2175 2176 2177 2178 2179
            }
        }
        None
    }

F
F001 已提交
2180
    fn resolve_adt(&mut self, item: &Item, generics: &Generics) {
2181 2182 2183 2184 2185 2186 2187 2188
        self.with_current_self_item(item, |this| {
            this.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind), |this| {
                let item_def_id = this.definitions.local_def_id(item.id);
                if this.session.features_untracked().self_in_typedefs {
                    this.with_self_rib(Def::SelfTy(None, Some(item_def_id)), |this| {
                        visit::walk_item(this, item);
                    });
                } else {
F
F001 已提交
2189
                    visit::walk_item(this, item);
2190 2191
                }
            });
F
F001 已提交
2192 2193 2194
        });
    }

2195
    fn resolve_item(&mut self, item: &Item) {
2196
        let name = item.ident.name;
C
corentih 已提交
2197
        debug!("(resolving item) resolving {}", name);
2198

2199
        match item.node {
2200
            ItemKind::Ty(_, ref generics) |
2201 2202
            ItemKind::Fn(_, _, ref generics, _) |
            ItemKind::Existential(_, ref generics) => {
2203
                self.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind),
2204 2205 2206 2207 2208 2209
                                             |this| visit::walk_item(this, item));
            }

            ItemKind::Enum(_, ref generics) |
            ItemKind::Struct(_, ref generics) |
            ItemKind::Union(_, ref generics) => {
F
F001 已提交
2210
                self.resolve_adt(item, generics);
2211 2212
            }

V
Vadim Petrochenkov 已提交
2213
            ItemKind::Impl(.., ref generics, ref opt_trait_ref, ref self_type, ref impl_items) =>
2214
                self.resolve_implementation(generics,
2215
                                            opt_trait_ref,
J
Jonas Schievink 已提交
2216
                                            &self_type,
2217
                                            item.id,
2218
                                            impl_items),
2219

2220
            ItemKind::Trait(.., ref generics, ref bounds, ref trait_items) => {
2221
                // Create a new rib for the trait-wide type parameters.
2222
                self.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind), |this| {
2223
                    let local_def_id = this.definitions.local_def_id(item.id);
2224
                    this.with_self_rib(Def::SelfTy(Some(local_def_id), None), |this| {
2225
                        this.visit_generics(generics);
V
varkor 已提交
2226
                        walk_list!(this, visit_param_bound, bounds);
2227 2228

                        for trait_item in trait_items {
2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
                            let type_parameters = HasTypeParameters(&trait_item.generics,
                                                                    TraitOrImplItemRibKind);
                            this.with_type_parameter_rib(type_parameters, |this| {
                                match trait_item.node {
                                    TraitItemKind::Const(ref ty, ref default) => {
                                        this.visit_ty(ty);

                                        // Only impose the restrictions of
                                        // ConstRibKind for an actual constant
                                        // expression in a provided default.
                                        if let Some(ref expr) = *default{
                                            this.with_constant_rib(|this| {
                                                this.visit_expr(expr);
                                            });
                                        }
2244
                                    }
2245
                                    TraitItemKind::Method(_, _) => {
2246
                                        visit::walk_trait_item(this, trait_item)
2247 2248
                                    }
                                    TraitItemKind::Type(..) => {
2249
                                        visit::walk_trait_item(this, trait_item)
2250 2251 2252 2253 2254 2255
                                    }
                                    TraitItemKind::Macro(_) => {
                                        panic!("unexpanded macro in resolve!")
                                    }
                                };
                            });
2256 2257
                        }
                    });
2258
                });
2259 2260
            }

A
Alex Burka 已提交
2261 2262 2263 2264 2265 2266
            ItemKind::TraitAlias(ref generics, ref bounds) => {
                // Create a new rib for the trait-wide type parameters.
                self.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind), |this| {
                    let local_def_id = this.definitions.local_def_id(item.id);
                    this.with_self_rib(Def::SelfTy(Some(local_def_id), None), |this| {
                        this.visit_generics(generics);
V
varkor 已提交
2267
                        walk_list!(this, visit_param_bound, bounds);
A
Alex Burka 已提交
2268 2269 2270 2271
                    });
                });
            }

2272
            ItemKind::Mod(_) | ItemKind::ForeignMod(_) => {
2273
                self.with_scope(item.id, |this| {
2274
                    visit::walk_item(this, item);
2275
                });
2276 2277
            }

2278 2279 2280 2281 2282 2283 2284
            ItemKind::Static(ref ty, _, ref expr) |
            ItemKind::Const(ref ty, ref expr) => {
                self.with_item_rib(|this| {
                    this.visit_ty(ty);
                    this.with_constant_rib(|this| {
                        this.visit_expr(expr);
                    });
2285
                });
2286
            }
2287

2288
            ItemKind::Use(ref use_tree) => {
2289
                // Imports are resolved as global by default, add starting root segment.
2290
                let path = Path {
2291
                    segments: use_tree.prefix.make_root().into_iter().collect(),
2292 2293
                    span: use_tree.span,
                };
2294
                self.resolve_use_tree(item.id, use_tree.span, item.id, use_tree, &path);
W
we 已提交
2295 2296
            }

2297
            ItemKind::ExternCrate(_) | ItemKind::MacroDef(..) | ItemKind::GlobalAsm(_) => {
2298
                // do nothing, these are just around to be encoded
2299
            }
2300 2301

            ItemKind::Mac(_) => panic!("unexpanded macro in resolve!"),
2302 2303 2304
        }
    }

2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
    /// For the most part, use trees are desugared into `ImportDirective` instances
    /// when building the reduced graph (see `build_reduced_graph_for_use_tree`). But
    /// there is one special case we handle here: an empty nested import like
    /// `a::{b::{}}`, which desugares into...no import directives.
    fn resolve_use_tree(
        &mut self,
        root_id: NodeId,
        root_span: Span,
        id: NodeId,
        use_tree: &ast::UseTree,
        prefix: &Path,
    ) {
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329
        match use_tree.kind {
            ast::UseTreeKind::Nested(ref items) => {
                let path = Path {
                    segments: prefix.segments
                        .iter()
                        .chain(use_tree.prefix.segments.iter())
                        .cloned()
                        .collect(),
                    span: prefix.span.to(use_tree.prefix.span),
                };

                if items.len() == 0 {
                    // Resolve prefix of an import with empty braces (issue #28388).
2330 2331 2332 2333 2334
                    self.smart_resolve_path_with_crate_lint(
                        id,
                        None,
                        &path,
                        PathSource::ImportPrefix,
2335
                        CrateLint::UsePath { root_id, root_span },
2336
                    );
2337
                } else {
2338
                    for &(ref tree, nested_id) in items {
2339
                        self.resolve_use_tree(root_id, root_span, nested_id, tree, &path);
2340 2341 2342
                    }
                }
            }
2343
            ast::UseTreeKind::Simple(..) => {},
2344 2345 2346 2347
            ast::UseTreeKind::Glob => {},
        }
    }

2348
    fn with_type_parameter_rib<'b, F>(&'b mut self, type_parameters: TypeParameters<'a, 'b>, f: F)
C
corentih 已提交
2349
        where F: FnOnce(&mut Resolver)
J
Jorge Aparicio 已提交
2350
    {
2351
        match type_parameters {
2352
            HasTypeParameters(generics, rib_kind) => {
2353
                let mut function_type_rib = Rib::new(rib_kind);
2354
                let mut seen_bindings = FxHashMap();
V
varkor 已提交
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370
                for param in &generics.params {
                    match param.kind {
                        GenericParamKind::Lifetime { .. } => {}
                        GenericParamKind::Type { .. } => {
                            let ident = param.ident.modern();
                            debug!("with_type_parameter_rib: {}", param.id);

                            if seen_bindings.contains_key(&ident) {
                                let span = seen_bindings.get(&ident).unwrap();
                                let err = ResolutionError::NameAlreadyUsedInTypeParameterList(
                                    ident.name,
                                    span,
                                );
                                resolve_error(self, param.ident.span, err);
                            }
                            seen_bindings.entry(ident).or_insert(param.ident.span);
V
varkor 已提交
2371

V
varkor 已提交
2372
                        // Plain insert (no renaming).
2373
                        let def = Def::TyParam(self.definitions.local_def_id(param.id));
V
varkor 已提交
2374 2375 2376
                            function_type_rib.bindings.insert(ident, def);
                            self.record_def(param.id, PathResolution::new(def));
                        }
V
varkor 已提交
2377
                    }
V
varkor 已提交
2378
                }
J
Jeffrey Seyfried 已提交
2379
                self.ribs[TypeNS].push(function_type_rib);
2380 2381
            }

B
Brian Anderson 已提交
2382
            NoTypeParameters => {
2383 2384 2385 2386
                // Nothing to do.
            }
        }

A
Alex Crichton 已提交
2387
        f(self);
2388

J
Jeffrey Seyfried 已提交
2389
        if let HasTypeParameters(..) = type_parameters {
J
Jeffrey Seyfried 已提交
2390
            self.ribs[TypeNS].pop();
2391 2392 2393
        }
    }

C
corentih 已提交
2394 2395
    fn with_label_rib<F>(&mut self, f: F)
        where F: FnOnce(&mut Resolver)
J
Jorge Aparicio 已提交
2396
    {
2397
        self.label_ribs.push(Rib::new(NormalRibKind));
A
Alex Crichton 已提交
2398
        f(self);
J
Jeffrey Seyfried 已提交
2399
        self.label_ribs.pop();
2400
    }
2401

2402 2403 2404 2405 2406 2407 2408 2409 2410 2411
    fn with_item_rib<F>(&mut self, f: F)
        where F: FnOnce(&mut Resolver)
    {
        self.ribs[ValueNS].push(Rib::new(ItemRibKind));
        self.ribs[TypeNS].push(Rib::new(ItemRibKind));
        f(self);
        self.ribs[TypeNS].pop();
        self.ribs[ValueNS].pop();
    }

C
corentih 已提交
2412 2413
    fn with_constant_rib<F>(&mut self, f: F)
        where F: FnOnce(&mut Resolver)
J
Jorge Aparicio 已提交
2414
    {
J
Jeffrey Seyfried 已提交
2415
        self.ribs[ValueNS].push(Rib::new(ConstantItemRibKind));
2416
        self.label_ribs.push(Rib::new(ConstantItemRibKind));
A
Alex Crichton 已提交
2417
        f(self);
2418
        self.label_ribs.pop();
J
Jeffrey Seyfried 已提交
2419
        self.ribs[ValueNS].pop();
2420 2421
    }

2422 2423
    fn with_current_self_type<T, F>(&mut self, self_type: &Ty, f: F) -> T
        where F: FnOnce(&mut Resolver) -> T
J
Jorge Aparicio 已提交
2424
    {
2425 2426 2427 2428 2429 2430 2431
        // Handle nested impls (inside fn bodies)
        let previous_value = replace(&mut self.current_self_type, Some(self_type.clone()));
        let result = f(self);
        self.current_self_type = previous_value;
        result
    }

2432 2433 2434 2435 2436 2437 2438 2439 2440
    fn with_current_self_item<T, F>(&mut self, self_item: &Item, f: F) -> T
        where F: FnOnce(&mut Resolver) -> T
    {
        let previous_value = replace(&mut self.current_self_item, Some(self_item.id));
        let result = f(self);
        self.current_self_item = previous_value;
        result
    }

2441
    /// This is called to resolve a trait reference from an `impl` (i.e. `impl Trait for Foo`)
2442
    fn with_optional_trait_ref<T, F>(&mut self, opt_trait_ref: Option<&TraitRef>, f: F) -> T
2443
        where F: FnOnce(&mut Resolver, Option<DefId>) -> T
J
Jorge Aparicio 已提交
2444
    {
2445
        let mut new_val = None;
2446
        let mut new_id = None;
E
Eduard Burtescu 已提交
2447
        if let Some(trait_ref) = opt_trait_ref {
2448
            let path: Vec<_> = trait_ref.path.segments.iter()
V
Vadim Petrochenkov 已提交
2449
                .map(|seg| seg.ident)
2450
                .collect();
2451 2452 2453 2454 2455
            let def = self.smart_resolve_path_fragment(
                trait_ref.ref_id,
                None,
                &path,
                trait_ref.path.span,
2456 2457
                PathSource::Trait(AliasPossibility::No),
                CrateLint::SimplePath(trait_ref.ref_id),
2458
            ).base_def();
2459 2460
            if def != Def::Err {
                new_id = Some(def.def_id());
2461
                let span = trait_ref.path.span;
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
                if let PathResult::Module(ModuleOrUniformRoot::Module(module)) =
                    self.resolve_path(
                        None,
                        &path,
                        None,
                        false,
                        span,
                        CrateLint::SimplePath(trait_ref.ref_id),
                    )
                {
2472 2473
                    new_val = Some((module, trait_ref.clone()));
                }
2474
            }
2475
        }
2476
        let original_trait_ref = replace(&mut self.current_trait_ref, new_val);
2477
        let result = f(self, new_id);
2478 2479 2480 2481
        self.current_trait_ref = original_trait_ref;
        result
    }

2482 2483 2484 2485 2486 2487
    fn with_self_rib<F>(&mut self, self_def: Def, f: F)
        where F: FnOnce(&mut Resolver)
    {
        let mut self_type_rib = Rib::new(NormalRibKind);

        // plain insert (no renaming, types are not currently hygienic....)
2488
        self_type_rib.bindings.insert(keywords::SelfType.ident(), self_def);
J
Jeffrey Seyfried 已提交
2489
        self.ribs[TypeNS].push(self_type_rib);
2490
        f(self);
J
Jeffrey Seyfried 已提交
2491
        self.ribs[TypeNS].pop();
2492 2493
    }

F
F001 已提交
2494
    fn with_self_struct_ctor_rib<F>(&mut self, impl_id: DefId, f: F)
F
F001 已提交
2495 2496
        where F: FnOnce(&mut Resolver)
    {
F
F001 已提交
2497 2498 2499 2500 2501 2502
        let self_def = Def::SelfCtor(impl_id);
        let mut self_type_rib = Rib::new(NormalRibKind);
        self_type_rib.bindings.insert(keywords::SelfType.ident(), self_def);
        self.ribs[ValueNS].push(self_type_rib);
        f(self);
        self.ribs[ValueNS].pop();
F
F001 已提交
2503 2504
    }

F
Felix S. Klock II 已提交
2505
    fn resolve_implementation(&mut self,
2506 2507 2508
                              generics: &Generics,
                              opt_trait_reference: &Option<TraitRef>,
                              self_type: &Ty,
2509
                              item_id: NodeId,
2510
                              impl_items: &[ImplItem]) {
2511
        // If applicable, create a rib for the type parameters.
2512
        self.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind), |this| {
2513 2514 2515 2516 2517 2518 2519
            // Dummy self type for better errors if `Self` is used in the trait path.
            this.with_self_rib(Def::SelfTy(None, None), |this| {
                // Resolve the trait reference, if necessary.
                this.with_optional_trait_ref(opt_trait_reference.as_ref(), |this, trait_id| {
                    let item_def_id = this.definitions.local_def_id(item_id);
                    this.with_self_rib(Def::SelfTy(trait_id, Some(item_def_id)), |this| {
                        if let Some(trait_ref) = opt_trait_reference.as_ref() {
2520
                            // Resolve type arguments in the trait path.
2521 2522 2523 2524 2525 2526
                            visit::walk_trait_ref(this, trait_ref);
                        }
                        // Resolve the self type.
                        this.visit_ty(self_type);
                        // Resolve the type parameters.
                        this.visit_generics(generics);
2527
                        // Resolve the items within the impl.
2528
                        this.with_current_self_type(self_type, |this| {
F
F001 已提交
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548
                            this.with_self_struct_ctor_rib(item_def_id, |this| {
                                for impl_item in impl_items {
                                    this.resolve_visibility(&impl_item.vis);

                                    // We also need a new scope for the impl item type parameters.
                                    let type_parameters = HasTypeParameters(&impl_item.generics,
                                                                            TraitOrImplItemRibKind);
                                    this.with_type_parameter_rib(type_parameters, |this| {
                                        use self::ResolutionError::*;
                                        match impl_item.node {
                                            ImplItemKind::Const(..) => {
                                                // If this is a trait impl, ensure the const
                                                // exists in trait
                                                this.check_trait_item(impl_item.ident,
                                                                      ValueNS,
                                                                      impl_item.span,
                                                    |n, s| ConstNotMemberOfTrait(n, s));
                                                this.with_constant_rib(|this|
                                                    visit::walk_impl_item(this, impl_item)
                                                );
O
Oliver Schneider 已提交
2549
                                            }
F
F001 已提交
2550 2551 2552 2553 2554 2555 2556 2557
                                            ImplItemKind::Method(..) => {
                                                // If this is a trait impl, ensure the method
                                                // exists in trait
                                                this.check_trait_item(impl_item.ident,
                                                                      ValueNS,
                                                                      impl_item.span,
                                                    |n, s| MethodNotMemberOfTrait(n, s));

F
F001 已提交
2558
                                                visit::walk_impl_item(this, impl_item);
O
Oliver Schneider 已提交
2559
                                            }
F
F001 已提交
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583
                                            ImplItemKind::Type(ref ty) => {
                                                // If this is a trait impl, ensure the type
                                                // exists in trait
                                                this.check_trait_item(impl_item.ident,
                                                                      TypeNS,
                                                                      impl_item.span,
                                                    |n, s| TypeNotMemberOfTrait(n, s));

                                                this.visit_ty(ty);
                                            }
                                            ImplItemKind::Existential(ref bounds) => {
                                                // If this is a trait impl, ensure the type
                                                // exists in trait
                                                this.check_trait_item(impl_item.ident,
                                                                      TypeNS,
                                                                      impl_item.span,
                                                    |n, s| TypeNotMemberOfTrait(n, s));

                                                for bound in bounds {
                                                    this.visit_param_bound(bound);
                                                }
                                            }
                                            ImplItemKind::Macro(_) =>
                                                panic!("unexpanded macro in resolve!"),
O
Oliver Schneider 已提交
2584
                                        }
F
F001 已提交
2585 2586 2587
                                    });
                                }
                            });
2588
                        });
2589
                    });
2590
                });
2591
            });
2592
        });
2593 2594
    }

2595
    fn check_trait_item<F>(&mut self, ident: Ident, ns: Namespace, span: Span, err: F)
C
corentih 已提交
2596 2597 2598 2599
        where F: FnOnce(Name, &str) -> ResolutionError
    {
        // If there is a TraitRef in scope for an impl, then the method must be in the
        // trait.
2600
        if let Some((module, _)) = self.current_trait_ref {
2601 2602 2603 2604 2605 2606 2607
            if self.resolve_ident_in_module(
                ModuleOrUniformRoot::Module(module),
                ident,
                ns,
                false,
                span,
            ).is_err() {
2608 2609
                let path = &self.current_trait_ref.as_ref().unwrap().1.path;
                resolve_error(self, span, err(ident.name, &path_names_to_string(path)));
2610 2611 2612 2613
            }
        }
    }

E
Eduard Burtescu 已提交
2614
    fn resolve_local(&mut self, local: &Local) {
2615
        // Resolve the type.
2616
        walk_list!(self, visit_ty, &local.ty);
2617

2618
        // Resolve the initializer.
2619
        walk_list!(self, visit_expr, &local.init);
2620 2621

        // Resolve the pattern.
2622
        self.resolve_pattern(&local.pat, PatternSource::Let, &mut FxHashMap());
2623 2624
    }

J
John Clements 已提交
2625 2626 2627 2628
    // 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.
E
Eduard Burtescu 已提交
2629
    fn binding_mode_map(&mut self, pat: &Pat) -> BindingMap {
2630
        let mut binding_map = FxHashMap();
2631 2632 2633

        pat.walk(&mut |pat| {
            if let PatKind::Ident(binding_mode, ident, ref sub_pat) = pat.node {
2634 2635
                if sub_pat.is_some() || match self.def_map.get(&pat.id).map(|res| res.base_def()) {
                    Some(Def::Local(..)) => true,
2636 2637 2638
                    _ => false,
                } {
                    let binding_info = BindingInfo { span: ident.span, binding_mode: binding_mode };
V
Vadim Petrochenkov 已提交
2639
                    binding_map.insert(ident, binding_info);
2640 2641 2642
                }
            }
            true
2643
        });
2644 2645

        binding_map
2646 2647
    }

J
John Clements 已提交
2648 2649
    // check that all of the arms in an or-pattern have exactly the
    // same set of bindings, with the same binding modes for each.
2650 2651
    fn check_consistent_bindings(&mut self, pats: &[P<Pat>]) {
        if pats.is_empty() {
C
corentih 已提交
2652
            return;
2653
        }
2654 2655 2656

        let mut missing_vars = FxHashMap();
        let mut inconsistent_vars = FxHashMap();
2657
        for (i, p) in pats.iter().enumerate() {
J
Jonas Schievink 已提交
2658
            let map_i = self.binding_mode_map(&p);
2659

2660
            for (j, q) in pats.iter().enumerate() {
2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671
                if i == j {
                    continue;
                }

                let map_j = self.binding_mode_map(&q);
                for (&key, &binding_i) in &map_i {
                    if map_j.len() == 0 {                   // Account for missing bindings when
                        let binding_error = missing_vars    // map_j has none.
                            .entry(key.name)
                            .or_insert(BindingError {
                                name: key.name,
2672 2673
                                origin: BTreeSet::new(),
                                target: BTreeSet::new(),
2674 2675 2676
                            });
                        binding_error.origin.insert(binding_i.span);
                        binding_error.target.insert(q.span);
C
corentih 已提交
2677
                    }
2678 2679 2680 2681 2682 2683 2684
                    for (&key_j, &binding_j) in &map_j {
                        match map_i.get(&key_j) {
                            None => {  // missing binding
                                let binding_error = missing_vars
                                    .entry(key_j.name)
                                    .or_insert(BindingError {
                                        name: key_j.name,
2685 2686
                                        origin: BTreeSet::new(),
                                        target: BTreeSet::new(),
2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697
                                    });
                                binding_error.origin.insert(binding_j.span);
                                binding_error.target.insert(p.span);
                            }
                            Some(binding_i) => {  // check consistent binding
                                if binding_i.binding_mode != binding_j.binding_mode {
                                    inconsistent_vars
                                        .entry(key.name)
                                        .or_insert((binding_j.span, binding_i.span));
                                }
                            }
C
corentih 已提交
2698
                        }
2699
                    }
2700 2701
                }
            }
2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713
        }
        let mut missing_vars = missing_vars.iter().collect::<Vec<_>>();
        missing_vars.sort();
        for (_, v) in missing_vars {
            resolve_error(self,
                          *v.origin.iter().next().unwrap(),
                          ResolutionError::VariableNotBoundInPattern(v));
        }
        let mut inconsistent_vars = inconsistent_vars.iter().collect::<Vec<_>>();
        inconsistent_vars.sort();
        for (name, v) in inconsistent_vars {
            resolve_error(self, v.0, ResolutionError::VariableBoundWithDifferentMode(*name, v.1));
2714
        }
2715 2716
    }

F
Felix S. Klock II 已提交
2717
    fn resolve_arm(&mut self, arm: &Arm) {
J
Jeffrey Seyfried 已提交
2718
        self.ribs[ValueNS].push(Rib::new(NormalRibKind));
2719

2720
        let mut bindings_list = FxHashMap();
2721
        for pattern in &arm.pats {
2722
            self.resolve_pattern(&pattern, PatternSource::Match, &mut bindings_list);
2723 2724
        }

2725 2726
        // This has to happen *after* we determine which pat_idents are variants
        self.check_consistent_bindings(&arm.pats);
2727

F
F001 已提交
2728 2729 2730 2731
        match arm.guard {
            Some(ast::Guard::If(ref expr)) => self.visit_expr(expr),
            _ => {}
        }
J
Jonas Schievink 已提交
2732
        self.visit_expr(&arm.body);
2733

J
Jeffrey Seyfried 已提交
2734
        self.ribs[ValueNS].pop();
2735 2736
    }

E
Eduard Burtescu 已提交
2737
    fn resolve_block(&mut self, block: &Block) {
2738
        debug!("(resolving block) entering block");
2739
        // Move down in the graph, if there's an anonymous module rooted here.
2740
        let orig_module = self.current_module;
2741
        let anonymous_module = self.block_map.get(&block.id).cloned(); // clones a reference
2742

2743
        let mut num_macro_definition_ribs = 0;
2744 2745
        if let Some(anonymous_module) = anonymous_module {
            debug!("(resolving block) found anonymous module, moving down");
J
Jeffrey Seyfried 已提交
2746 2747
            self.ribs[ValueNS].push(Rib::new(ModuleRibKind(anonymous_module)));
            self.ribs[TypeNS].push(Rib::new(ModuleRibKind(anonymous_module)));
2748
            self.current_module = anonymous_module;
2749
            self.finalize_current_module_macro_resolutions();
2750
        } else {
J
Jeffrey Seyfried 已提交
2751
            self.ribs[ValueNS].push(Rib::new(NormalRibKind));
2752 2753 2754
        }

        // Descend into the block.
2755
        for stmt in &block.stmts {
2756
            if let ast::StmtKind::Item(ref item) = stmt.node {
2757
                if let ast::ItemKind::MacroDef(..) = item.node {
2758
                    num_macro_definition_ribs += 1;
2759 2760 2761
                    let def = self.definitions.local_def_id(item.id);
                    self.ribs[ValueNS].push(Rib::new(MacroDefinition(def)));
                    self.label_ribs.push(Rib::new(MacroDefinition(def)));
2762 2763 2764 2765 2766
                }
            }

            self.visit_stmt(stmt);
        }
2767 2768

        // Move back up.
J
Jeffrey Seyfried 已提交
2769
        self.current_module = orig_module;
2770
        for _ in 0 .. num_macro_definition_ribs {
J
Jeffrey Seyfried 已提交
2771
            self.ribs[ValueNS].pop();
2772
            self.label_ribs.pop();
2773
        }
J
Jeffrey Seyfried 已提交
2774
        self.ribs[ValueNS].pop();
2775
        if anonymous_module.is_some() {
J
Jeffrey Seyfried 已提交
2776
            self.ribs[TypeNS].pop();
G
Garming Sam 已提交
2777
        }
2778
        debug!("(resolving block) leaving block");
2779 2780
    }

2781
    fn fresh_binding(&mut self,
V
Vadim Petrochenkov 已提交
2782
                     ident: Ident,
2783 2784 2785
                     pat_id: NodeId,
                     outer_pat_id: NodeId,
                     pat_src: PatternSource,
2786
                     bindings: &mut FxHashMap<Ident, NodeId>)
2787 2788
                     -> PathResolution {
        // Add the binding to the local ribs, if it
2789 2790
        // doesn't already exist in the bindings map. (We
        // must not add it if it's in the bindings map
2791 2792
        // because that breaks the assumptions later
        // passes make about or-patterns.)
2793
        let ident = ident.modern_and_legacy();
2794
        let mut def = Def::Local(pat_id);
V
Vadim Petrochenkov 已提交
2795
        match bindings.get(&ident).cloned() {
2796 2797 2798 2799 2800 2801
            Some(id) if id == outer_pat_id => {
                // `Variant(a, a)`, error
                resolve_error(
                    self,
                    ident.span,
                    ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(
V
Vadim Petrochenkov 已提交
2802
                        &ident.as_str())
2803 2804 2805 2806 2807 2808 2809 2810
                );
            }
            Some(..) if pat_src == PatternSource::FnParam => {
                // `fn f(a: u8, a: u8)`, error
                resolve_error(
                    self,
                    ident.span,
                    ResolutionError::IdentifierBoundMoreThanOnceInParameterList(
V
Vadim Petrochenkov 已提交
2811
                        &ident.as_str())
2812 2813
                );
            }
2814 2815 2816
            Some(..) if pat_src == PatternSource::Match ||
                        pat_src == PatternSource::IfLet ||
                        pat_src == PatternSource::WhileLet => {
2817 2818
                // `Variant1(a) | Variant2(a)`, ok
                // Reuse definition from the first `a`.
V
Vadim Petrochenkov 已提交
2819
                def = self.ribs[ValueNS].last_mut().unwrap().bindings[&ident];
2820 2821 2822 2823 2824 2825
            }
            Some(..) => {
                span_bug!(ident.span, "two bindings with the same name from \
                                       unexpected pattern source {:?}", pat_src);
            }
            None => {
2826
                // A completely fresh binding, add to the lists if it's valid.
V
Vadim Petrochenkov 已提交
2827 2828 2829
                if ident.name != keywords::Invalid.name() {
                    bindings.insert(ident, outer_pat_id);
                    self.ribs[ValueNS].last_mut().unwrap().bindings.insert(ident, def);
2830
                }
2831
            }
2832
        }
2833

2834
        PathResolution::new(def)
2835
    }
2836

2837 2838 2839 2840 2841
    fn resolve_pattern(&mut self,
                       pat: &Pat,
                       pat_src: PatternSource,
                       // Maps idents to the node ID for the
                       // outermost pattern that binds them.
2842
                       bindings: &mut FxHashMap<Ident, NodeId>) {
2843
        // Visit all direct subpatterns of this pattern.
2844 2845 2846
        let outer_pat_id = pat.id;
        pat.walk(&mut |pat| {
            match pat.node {
V
Vadim Petrochenkov 已提交
2847
                PatKind::Ident(bmode, ident, ref opt_pat) => {
2848 2849
                    // First try to resolve the identifier as some existing
                    // entity, then fall back to a fresh binding.
V
Vadim Petrochenkov 已提交
2850
                    let binding = self.resolve_ident_in_lexical_scope(ident, ValueNS,
2851
                                                                      None, pat.span)
2852
                                      .and_then(LexicalScopeBinding::item);
2853
                    let resolution = binding.map(NameBinding::def).and_then(|def| {
2854 2855
                        let is_syntactic_ambiguity = opt_pat.is_none() &&
                            bmode == BindingMode::ByValue(Mutability::Immutable);
2856
                        match def {
2857 2858
                            Def::StructCtor(_, CtorKind::Const) |
                            Def::VariantCtor(_, CtorKind::Const) |
2859 2860 2861
                            Def::Const(..) if is_syntactic_ambiguity => {
                                // Disambiguate in favor of a unit struct/variant
                                // or constant pattern.
2862
                                self.record_use(ident, ValueNS, binding.unwrap());
2863
                                Some(PathResolution::new(def))
2864
                            }
2865
                            Def::StructCtor(..) | Def::VariantCtor(..) |
2866
                            Def::Const(..) | Def::Static(..) => {
2867 2868 2869 2870 2871
                                // This is unambiguously a fresh binding, either syntactically
                                // (e.g. `IDENT @ PAT` or `ref IDENT`) or because `IDENT` resolves
                                // to something unusable as a pattern (e.g. constructor function),
                                // but we still conservatively report an error, see
                                // issues/33118#issuecomment-233962221 for one reason why.
2872
                                resolve_error(
2873
                                    self,
2874 2875
                                    ident.span,
                                    ResolutionError::BindingShadowsSomethingUnacceptable(
V
Vadim Petrochenkov 已提交
2876
                                        pat_src.descr(), ident.name, binding.unwrap())
2877
                                );
2878
                                None
2879
                            }
2880
                            Def::Fn(..) | Def::Err => {
2881 2882
                                // These entities are explicitly allowed
                                // to be shadowed by fresh bindings.
2883
                                None
2884 2885 2886
                            }
                            def => {
                                span_bug!(ident.span, "unexpected definition for an \
2887
                                                       identifier in pattern: {:?}", def);
2888
                            }
2889
                        }
2890
                    }).unwrap_or_else(|| {
2891
                        self.fresh_binding(ident, pat.id, outer_pat_id, pat_src, bindings)
2892
                    });
2893 2894

                    self.record_def(pat.id, resolution);
2895 2896
                }

2897
                PatKind::TupleStruct(ref path, ..) => {
2898
                    self.smart_resolve_path(pat.id, None, path, PathSource::TupleStruct);
2899 2900
                }

2901
                PatKind::Path(ref qself, ref path) => {
2902
                    self.smart_resolve_path(pat.id, qself.as_ref(), path, PathSource::Pat);
2903 2904
                }

V
Vadim Petrochenkov 已提交
2905
                PatKind::Struct(ref path, ..) => {
2906
                    self.smart_resolve_path(pat.id, None, path, PathSource::Struct);
2907
                }
2908 2909

                _ => {}
2910
            }
2911
            true
2912
        });
2913

2914
        visit::walk_pat(self, pat);
2915 2916
    }

2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
    // High-level and context dependent path resolution routine.
    // Resolves the path and records the resolution into definition map.
    // If resolution fails tries several techniques to find likely
    // resolution candidates, suggest imports or other help, and report
    // errors in user friendly way.
    fn smart_resolve_path(&mut self,
                          id: NodeId,
                          qself: Option<&QSelf>,
                          path: &Path,
                          source: PathSource)
                          -> PathResolution {
2928 2929 2930 2931 2932 2933
        self.smart_resolve_path_with_crate_lint(id, qself, path, source, CrateLint::SimplePath(id))
    }

    /// A variant of `smart_resolve_path` where you also specify extra
    /// information about where the path came from; this extra info is
    /// sometimes needed for the lint that recommends rewriting
T
Takanori Ishibashi 已提交
2934
    /// absolute paths to `crate`, so that it knows how to frame the
2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
    /// suggestion. If you are just resolving a path like `foo::bar`
    /// that appears...somewhere, though, then you just want
    /// `CrateLint::SimplePath`, which is what `smart_resolve_path`
    /// already provides.
    fn smart_resolve_path_with_crate_lint(
        &mut self,
        id: NodeId,
        qself: Option<&QSelf>,
        path: &Path,
        source: PathSource,
        crate_lint: CrateLint
    ) -> PathResolution {
2947
        let segments = &path.segments.iter()
V
Vadim Petrochenkov 已提交
2948
            .map(|seg| seg.ident)
2949
            .collect::<Vec<_>>();
2950
        self.smart_resolve_path_fragment(id, qself, segments, path.span, source, crate_lint)
2951 2952 2953
    }

    fn smart_resolve_path_fragment(&mut self,
2954
                                   id: NodeId,
2955
                                   qself: Option<&QSelf>,
V
Vadim Petrochenkov 已提交
2956
                                   path: &[Ident],
2957
                                   span: Span,
2958 2959
                                   source: PathSource,
                                   crate_lint: CrateLint)
2960
                                   -> PathResolution {
2961
        let ident_span = path.last().map_or(span, |ident| ident.span);
2962 2963
        let ns = source.namespace();
        let is_expected = &|def| source.is_expected(def);
2964
        let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false };
2965 2966 2967 2968 2969 2970

        // Base error is amended with one short label and possibly some longer helps/notes.
        let report_errors = |this: &mut Self, def: Option<Def>| {
            // Make the base error.
            let expected = source.descr_expected();
            let path_str = names_to_string(path);
C
csmoe 已提交
2971
            let item_str = path[path.len() - 1];
2972
            let code = source.error_code(def.is_some());
2973
            let (base_msg, fallback_label, base_span) = if let Some(def) = def {
2974
                (format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str),
2975 2976
                 format!("not a {}", expected),
                 span)
2977
            } else {
2978
                let item_span = path[path.len() - 1].span;
2979
                let (mod_prefix, mod_str) = if path.len() == 1 {
L
ljedrz 已提交
2980
                    (String::new(), "this scope".to_string())
V
Vadim Petrochenkov 已提交
2981
                } else if path.len() == 2 && path[0].name == keywords::CrateRoot.name() {
L
ljedrz 已提交
2982
                    (String::new(), "the crate root".to_string())
2983 2984
                } else {
                    let mod_path = &path[..path.len() - 1];
2985
                    let mod_prefix = match this.resolve_path(None, mod_path, Some(TypeNS),
2986
                                                             false, span, CrateLint::No) {
2987 2988
                        PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                            module.def(),
2989
                        _ => None,
L
ljedrz 已提交
2990
                    }.map_or(String::new(), |def| format!("{} ", def.kind_name()));
2991 2992 2993
                    (mod_prefix, format!("`{}`", names_to_string(mod_path)))
                };
                (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str),
2994 2995
                 format!("not found in {}", mod_str),
                 item_span)
2996
            };
2997
            let code = DiagnosticId::Error(code.into());
2998
            let mut err = this.session.struct_span_err_with_code(base_span, &base_msg, code);
2999

C
csmoe 已提交
3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
            // Emit help message for fake-self from other languages like `this`(javascript)
            let fake_self: Vec<Ident> = ["this", "my"].iter().map(
                |s| Ident::from_str(*s)
            ).collect();
            if fake_self.contains(&item_str)
                && this.self_value_is_available(path[0].span, span) {
                err.span_suggestion_with_applicability(
                    span,
                    "did you mean",
                    "self".to_string(),
C
csmoe 已提交
3010
                    Applicability::MaybeIncorrect,
C
csmoe 已提交
3011 3012 3013
                );
            }

3014 3015 3016
            // Emit special messages for unresolved `Self` and `self`.
            if is_self_type(path, ns) {
                __diagnostic_used!(E0411);
3017
                err.code(DiagnosticId::Error("E0411".into()));
A
Alexander Regueiro 已提交
3018 3019 3020 3021 3022 3023
                let available_in = if this.session.features_untracked().self_in_typedefs {
                    "impls, traits, and type definitions"
                } else {
                    "traits and impls"
                };
                err.span_label(span, format!("`Self` is only available in {}", available_in));
3024 3025 3026 3027
                if this.current_self_item.is_some() && nightly_options::is_nightly_build() {
                    err.help("add #![feature(self_in_typedefs)] to the crate attributes \
                              to enable");
                }
3028
                return (err, Vec::new());
3029 3030 3031
            }
            if is_self_value(path, ns) {
                __diagnostic_used!(E0424);
3032
                err.code(DiagnosticId::Error("E0424".into()));
J
Julian Kulesh 已提交
3033 3034
                err.span_label(span, format!("`self` value is a keyword \
                                               only available in \
3035
                                               methods with `self` parameter"));
3036
                return (err, Vec::new());
3037 3038 3039
            }

            // Try to lookup the name in more relaxed fashion for better error reporting.
3040
            let ident = *path.last().unwrap();
V
Vadim Petrochenkov 已提交
3041
            let candidates = this.lookup_import_candidates(ident.name, ns, is_expected);
3042
            if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) {
3043
                let enum_candidates =
V
Vadim Petrochenkov 已提交
3044
                    this.lookup_import_candidates(ident.name, ns, is_enum_variant);
E
Esteban Küber 已提交
3045 3046 3047 3048
                let mut enum_candidates = enum_candidates.iter()
                    .map(|suggestion| import_candidate_to_paths(&suggestion)).collect::<Vec<_>>();
                enum_candidates.sort();
                for (sp, variant_path, enum_path) in enum_candidates {
V
Vadim Petrochenkov 已提交
3049
                    if sp.is_dummy() {
3050 3051 3052 3053
                        let msg = format!("there is an enum variant `{}`, \
                                        try using `{}`?",
                                        variant_path,
                                        enum_path);
3054 3055
                        err.help(&msg);
                    } else {
3056 3057 3058 3059 3060 3061
                        err.span_suggestion_with_applicability(
                            span,
                            "you can try using the variant's enum",
                            enum_path,
                            Applicability::MachineApplicable,
                        );
3062 3063
                    }
                }
3064
            }
3065
            if path.len() == 1 && this.self_type_is_available(span) {
V
Vadim Petrochenkov 已提交
3066 3067
                if let Some(candidate) = this.lookup_assoc_candidate(ident, ns, is_expected) {
                    let self_is_available = this.self_value_is_available(path[0].span, span);
3068 3069
                    match candidate {
                        AssocSuggestion::Field => {
3070 3071 3072 3073 3074 3075
                            err.span_suggestion_with_applicability(
                                span,
                                "try",
                                format!("self.{}", path_str),
                                Applicability::MachineApplicable,
                            );
3076
                            if !self_is_available {
J
Julian Kulesh 已提交
3077 3078
                                err.span_label(span, format!("`self` value is a keyword \
                                                               only available in \
3079 3080 3081 3082
                                                               methods with `self` parameter"));
                            }
                        }
                        AssocSuggestion::MethodWithSelf if self_is_available => {
3083 3084 3085 3086 3087 3088
                            err.span_suggestion_with_applicability(
                                span,
                                "try",
                                format!("self.{}", path_str),
                                Applicability::MachineApplicable,
                            );
3089 3090
                        }
                        AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => {
3091 3092 3093 3094 3095 3096
                            err.span_suggestion_with_applicability(
                                span,
                                "try",
                                format!("Self::{}", path_str),
                                Applicability::MachineApplicable,
                            );
3097 3098
                        }
                    }
3099
                    return (err, candidates);
3100 3101 3102
                }
            }

3103 3104 3105
            let mut levenshtein_worked = false;

            // Try Levenshtein.
3106
            if let Some(candidate) = this.lookup_typo_candidate(path, ns, is_expected, span) {
3107
                err.span_label(ident_span, format!("did you mean `{}`?", candidate));
3108 3109 3110
                levenshtein_worked = true;
            }

3111 3112 3113 3114
            // Try context dependent help if relaxed lookup didn't work.
            if let Some(def) = def {
                match (def, source) {
                    (Def::Macro(..), _) => {
3115
                        err.span_label(span, format!("did you mean `{}!(...)`?", path_str));
3116
                        return (err, candidates);
3117
                    }
A
Alex Burka 已提交
3118
                    (Def::TyAlias(..), PathSource::Trait(_)) => {
3119
                        err.span_label(span, "type aliases cannot be used for traits");
3120
                        return (err, candidates);
3121
                    }
3122
                    (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node {
3123
                        ExprKind::Field(_, ident) => {
3124
                            err.span_label(parent.span, format!("did you mean `{}::{}`?",
V
Vadim Petrochenkov 已提交
3125
                                                                 path_str, ident));
3126
                            return (err, candidates);
3127
                        }
3128
                        ExprKind::MethodCall(ref segment, ..) => {
3129
                            err.span_label(parent.span, format!("did you mean `{}::{}(...)`?",
3130
                                                                 path_str, segment.ident));
3131
                            return (err, candidates);
3132 3133 3134
                        }
                        _ => {}
                    },
3135 3136
                    (Def::Enum(..), PathSource::TupleStruct)
                        | (Def::Enum(..), PathSource::Expr(..))  => {
3137 3138 3139 3140
                        if let Some(variants) = this.collect_enum_variants(def) {
                            err.note(&format!("did you mean to use one \
                                               of the following variants?\n{}",
                                variants.iter()
3141 3142
                                    .map(|suggestion| path_names_to_string(suggestion))
                                    .map(|suggestion| format!("- `{}`", suggestion))
3143 3144 3145 3146 3147 3148 3149 3150
                                    .collect::<Vec<_>>()
                                    .join("\n")));

                        } else {
                            err.note("did you mean to use one of the enum's variants?");
                        }
                        return (err, candidates);
                    },
E
Esteban Küber 已提交
3151
                    (Def::Struct(def_id), _) if ns == ValueNS => {
3152 3153 3154 3155 3156 3157
                        if let Some((ctor_def, ctor_vis))
                                = this.struct_constructors.get(&def_id).cloned() {
                            let accessible_ctor = this.is_accessible(ctor_vis);
                            if is_expected(ctor_def) && !accessible_ctor {
                                err.span_label(span, format!("constructor is not visible \
                                                              here due to private fields"));
3158
                            }
3159
                        } else {
3160 3161 3162 3163
                            // HACK(estebank): find a better way to figure out that this was a
                            // parser issue where a struct literal is being used on an expression
                            // where a brace being opened means a block is being started. Look
                            // ahead for the next text to see if `span` is followed by a `{`.
3164
                            let sm = this.session.source_map();
3165 3166
                            let mut sp = span;
                            loop {
3167 3168
                                sp = sm.next_point(sp);
                                match sm.span_to_snippet(sp) {
3169 3170 3171 3172 3173 3174 3175 3176
                                    Ok(ref snippet) => {
                                        if snippet.chars().any(|c| { !c.is_whitespace() }) {
                                            break;
                                        }
                                    }
                                    _ => break,
                                }
                            }
3177
                            let followed_by_brace = match sm.span_to_snippet(sp) {
3178 3179 3180
                                Ok(ref snippet) if snippet == "{" => true,
                                _ => false,
                            };
3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
                            match source {
                                PathSource::Expr(Some(parent)) => {
                                    match parent.node {
                                        ExprKind::MethodCall(ref path_assignment, _)  => {
                                            err.span_suggestion_with_applicability(
                                                sm.start_point(parent.span)
                                                  .to(path_assignment.ident.span),
                                                "use `::` to access an associated function",
                                                format!("{}::{}",
                                                        path_str,
                                                        path_assignment.ident),
                                                Applicability::MaybeIncorrect
                                            );
                                            return (err, candidates);
                                        },
                                        _ => {
                                            err.span_label(
                                                span,
                                                format!("did you mean `{} {{ /* fields */ }}`?",
                                                        path_str),
                                            );
                                            return (err, candidates);
                                        },
                                    }
                                },
                                PathSource::Expr(None) if followed_by_brace == true => {
                                    err.span_label(
                                        span,
                                        format!("did you mean `({} {{ /* fields */ }})`?",
                                                path_str),
                                    );
                                    return (err, candidates);
                                },
                                _ => {
                                    err.span_label(
                                        span,
                                        format!("did you mean `{} {{ /* fields */ }}`?",
                                                path_str),
                                    );
                                    return (err, candidates);
                                },
3222
                            }
3223
                        }
3224
                        return (err, candidates);
3225
                    }
3226 3227 3228
                    (Def::Union(..), _) |
                    (Def::Variant(..), _) |
                    (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => {
3229
                        err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?",
3230
                                                     path_str));
3231
                        return (err, candidates);
3232
                    }
E
Esteban Küber 已提交
3233
                    (Def::SelfTy(..), _) if ns == ValueNS => {
3234
                        err.span_label(span, fallback_label);
E
Esteban Küber 已提交
3235 3236
                        err.note("can't use `Self` as a constructor, you must use the \
                                  implemented struct");
3237
                        return (err, candidates);
3238
                    }
3239
                    (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => {
E
Esteban Küber 已提交
3240
                        err.note("can't use a type alias as a constructor");
3241
                        return (err, candidates);
E
Esteban Küber 已提交
3242
                    }
3243 3244 3245 3246
                    _ => {}
                }
            }

3247
            // Fallback label.
3248
            if !levenshtein_worked {
3249
                err.span_label(base_span, fallback_label);
3250
                this.type_ascription_suggestion(&mut err, base_span);
3251
            }
3252
            (err, candidates)
3253 3254
        };
        let report_errors = |this: &mut Self, def: Option<Def>| {
3255 3256 3257 3258 3259
            let (err, candidates) = report_errors(this, def);
            let def_id = this.current_module.normal_ancestor_id;
            let node_id = this.definitions.as_local_node_id(def_id).unwrap();
            let better = def.is_some();
            this.use_injections.push(UseError { err, candidates, node_id, better });
3260 3261 3262
            err_path_resolution()
        };

3263 3264 3265 3266 3267 3268 3269 3270 3271 3272
        let resolution = match self.resolve_qpath_anywhere(
            id,
            qself,
            path,
            ns,
            span,
            source.defer_to_typeck(),
            source.global_by_default(),
            crate_lint,
        ) {
3273 3274
            Some(resolution) if resolution.unresolved_segments() == 0 => {
                if is_expected(resolution.base_def()) || resolution.base_def() == Def::Err {
3275 3276
                    resolution
                } else {
3277 3278 3279
                    // Add a temporary hack to smooth the transition to new struct ctor
                    // visibility rules. See #38932 for more details.
                    let mut res = None;
3280
                    if let Def::Struct(def_id) = resolution.base_def() {
3281
                        if let Some((ctor_def, ctor_vis))
3282
                                = self.struct_constructors.get(&def_id).cloned() {
3283 3284
                            if is_expected(ctor_def) && self.is_accessible(ctor_vis) {
                                let lint = lint::builtin::LEGACY_CONSTRUCTOR_VISIBILITY;
3285
                                self.session.buffer_lint(lint, id, span,
3286
                                    "private struct constructors are not usable through \
3287
                                     re-exports in outer modules",
3288
                                );
3289 3290 3291 3292 3293
                                res = Some(PathResolution::new(ctor_def));
                            }
                        }
                    }

3294
                    res.unwrap_or_else(|| report_errors(self, Some(resolution.base_def())))
3295 3296 3297 3298 3299 3300 3301
                }
            }
            Some(resolution) if source.defer_to_typeck() => {
                // Not fully resolved associated item `T::A::B` or `<T as Tr>::A::B`
                // or `<T>::A::B`. If `B` should be resolved in value namespace then
                // it needs to be added to the trait map.
                if ns == ValueNS {
V
Vadim Petrochenkov 已提交
3302
                    let item_name = *path.last().unwrap();
3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317
                    let traits = self.get_traits_containing_item(item_name, ns);
                    self.trait_map.insert(id, traits);
                }
                resolution
            }
            _ => report_errors(self, None)
        };

        if let PathSource::TraitItem(..) = source {} else {
            // Avoid recording definition of `A::B` in `<T as A>::B::C`.
            self.record_def(id, resolution);
        }
        resolution
    }

3318 3319 3320 3321
    fn type_ascription_suggestion(&self,
                                  err: &mut DiagnosticBuilder,
                                  base_span: Span) {
        debug!("type_ascription_suggetion {:?}", base_span);
D
Donato Sciarra 已提交
3322
        let cm = self.session.source_map();
3323 3324 3325 3326
        debug!("self.current_type_ascription {:?}", self.current_type_ascription);
        if let Some(sp) = self.current_type_ascription.last() {
            let mut sp = *sp;
            loop {  // try to find the `:`, bail on first non-':'/non-whitespace
3327 3328
                sp = cm.next_point(sp);
                if let Ok(snippet) = cm.span_to_snippet(sp.to(cm.next_point(sp))) {
3329
                    debug!("snippet {:?}", snippet);
3330 3331
                    let line_sp = cm.lookup_char_pos(sp.hi()).line;
                    let line_base_sp = cm.lookup_char_pos(base_span.lo()).line;
3332 3333 3334 3335 3336
                    debug!("{:?} {:?}", line_sp, line_base_sp);
                    if snippet == ":" {
                        err.span_label(base_span,
                                       "expecting a type here because of type ascription");
                        if line_sp != line_base_sp {
3337
                            err.span_suggestion_short_with_applicability(
V
Vitaly _Vi Shukela 已提交
3338 3339 3340 3341 3342
                                sp,
                                "did you mean to use `;` here instead?",
                                ";".to_string(),
                                Applicability::MaybeIncorrect,
                            );
3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355
                        }
                        break;
                    } else if snippet.trim().len() != 0  {
                        debug!("tried to find type ascription `:` token, couldn't find it");
                        break;
                    }
                } else {
                    break;
                }
            }
        }
    }

3356 3357
    fn self_type_is_available(&mut self, span: Span) -> bool {
        let binding = self.resolve_ident_in_lexical_scope(keywords::SelfType.ident(),
3358
                                                          TypeNS, None, span);
3359 3360 3361
        if let Some(LexicalScopeBinding::Def(def)) = binding { def != Def::Err } else { false }
    }

3362 3363
    fn self_value_is_available(&mut self, self_span: Span, path_span: Span) -> bool {
        let ident = Ident::new(keywords::SelfValue.name(), self_span);
3364
        let binding = self.resolve_ident_in_lexical_scope(ident, ValueNS, None, path_span);
3365 3366 3367 3368 3369 3370 3371
        if let Some(LexicalScopeBinding::Def(def)) = binding { def != Def::Err } else { false }
    }

    // Resolve in alternative namespaces if resolution in the primary namespace fails.
    fn resolve_qpath_anywhere(&mut self,
                              id: NodeId,
                              qself: Option<&QSelf>,
V
Vadim Petrochenkov 已提交
3372
                              path: &[Ident],
3373 3374 3375
                              primary_ns: Namespace,
                              span: Span,
                              defer_to_typeck: bool,
3376 3377
                              global_by_default: bool,
                              crate_lint: CrateLint)
3378 3379 3380 3381 3382 3383
                              -> Option<PathResolution> {
        let mut fin_res = None;
        // FIXME: can't resolve paths in macro namespace yet, macros are
        // processed by the little special hack below.
        for (i, ns) in [primary_ns, TypeNS, ValueNS, /*MacroNS*/].iter().cloned().enumerate() {
            if i == 0 || ns != primary_ns {
3384
                match self.resolve_qpath(id, qself, path, ns, span, global_by_default, crate_lint) {
3385 3386
                    // If defer_to_typeck, then resolution > no resolution,
                    // otherwise full resolution > partial resolution > no resolution.
3387 3388
                    Some(res) if res.unresolved_segments() == 0 || defer_to_typeck =>
                        return Some(res),
3389 3390 3391 3392
                    res => if fin_res.is_none() { fin_res = res },
                };
            }
        }
3393 3394 3395 3396 3397 3398
        if primary_ns != MacroNS &&
           (self.macro_names.contains(&path[0].modern()) ||
            self.builtin_macros.get(&path[0].name).cloned()
                               .and_then(NameBinding::macro_kind) == Some(MacroKind::Bang) ||
            self.macro_use_prelude.get(&path[0].name).cloned()
                                  .and_then(NameBinding::macro_kind) == Some(MacroKind::Bang)) {
3399
            // Return some dummy definition, it's enough for error reporting.
J
Josh Driver 已提交
3400 3401 3402
            return Some(
                PathResolution::new(Def::Macro(DefId::local(CRATE_DEF_INDEX), MacroKind::Bang))
            );
3403 3404 3405 3406 3407 3408 3409 3410
        }
        fin_res
    }

    /// Handles paths that may refer to associated items.
    fn resolve_qpath(&mut self,
                     id: NodeId,
                     qself: Option<&QSelf>,
V
Vadim Petrochenkov 已提交
3411
                     path: &[Ident],
3412 3413
                     ns: Namespace,
                     span: Span,
3414 3415
                     global_by_default: bool,
                     crate_lint: CrateLint)
3416
                     -> Option<PathResolution> {
3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427
        debug!(
            "resolve_qpath(id={:?}, qself={:?}, path={:?}, \
             ns={:?}, span={:?}, global_by_default={:?})",
            id,
            qself,
            path,
            ns,
            span,
            global_by_default,
        );

3428
        if let Some(qself) = qself {
J
Jeffrey Seyfried 已提交
3429
            if qself.position == 0 {
3430 3431 3432
                // This is a case like `<T>::B`, where there is no
                // trait to resolve.  In that case, we leave the `B`
                // segment to be resolved by type-check.
3433 3434 3435
                return Some(PathResolution::with_unresolved_segments(
                    Def::Mod(DefId::local(CRATE_DEF_INDEX)), path.len()
                ));
3436
            }
3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451

            // Make sure `A::B` in `<T as A::B>::C` is a trait item.
            //
            // Currently, `path` names the full item (`A::B::C`, in
            // our example).  so we extract the prefix of that that is
            // the trait (the slice upto and including
            // `qself.position`). And then we recursively resolve that,
            // but with `qself` set to `None`.
            //
            // However, setting `qself` to none (but not changing the
            // span) loses the information about where this path
            // *actually* appears, so for the purposes of the crate
            // lint we pass along information that this is the trait
            // name from a fully qualified path, and this also
            // contains the full span (the `CrateLint::QPathTrait`).
3452
            let ns = if qself.position + 1 == path.len() { ns } else { TypeNS };
3453 3454 3455 3456 3457 3458
            let res = self.smart_resolve_path_fragment(
                id,
                None,
                &path[..qself.position + 1],
                span,
                PathSource::TraitItem(ns),
3459 3460 3461 3462
                CrateLint::QPathTrait {
                    qpath_id: id,
                    qpath_span: qself.path_span,
                },
3463
            );
3464 3465 3466 3467

            // The remaining segments (the `C` in our example) will
            // have to be resolved by type-check, since that requires doing
            // trait resolution.
3468 3469 3470
            return Some(PathResolution::with_unresolved_segments(
                res.base_def(), res.unresolved_segments() + path.len() - qself.position - 1
            ));
3471 3472
        }

N
Niko Matsakis 已提交
3473
        let result = match self.resolve_path(
3474
            None,
N
Niko Matsakis 已提交
3475 3476 3477 3478
            &path,
            Some(ns),
            true,
            span,
3479
            crate_lint,
N
Niko Matsakis 已提交
3480
        ) {
3481
            PathResult::NonModule(path_res) => path_res,
3482
            PathResult::Module(ModuleOrUniformRoot::Module(module)) if !module.is_normal() => {
J
Jeffrey Seyfried 已提交
3483
                PathResolution::new(module.def().unwrap())
V
Cleanup  
Vadim Petrochenkov 已提交
3484
            }
3485 3486 3487 3488 3489 3490
            // In `a(::assoc_item)*` `a` cannot be a module. If `a` does resolve to a module we
            // don't report an error right away, but try to fallback to a primitive type.
            // So, we are still able to successfully resolve something like
            //
            // use std::u8; // bring module u8 in scope
            // fn f() -> u8 { // OK, resolves to primitive u8, not to std::u8
V
Cleanup  
Vadim Petrochenkov 已提交
3491 3492
            //     u8::max_value() // OK, resolves to associated function <u8>::max_value,
            //                     // not to non-existent std::u8::max_value
3493 3494 3495 3496
            // }
            //
            // Such behavior is required for backward compatibility.
            // The same fallback is used when `a` resolves to nothing.
3497 3498
            PathResult::Module(ModuleOrUniformRoot::Module(_)) |
            PathResult::Failed(..)
3499
                    if (ns == TypeNS || path.len() > 1) &&
3500
                       self.primitive_type_table.primitive_types
V
Vadim Petrochenkov 已提交
3501 3502
                           .contains_key(&path[0].name) => {
                let prim = self.primitive_type_table.primitive_types[&path[0].name];
3503
                PathResolution::with_unresolved_segments(Def::PrimTy(prim), path.len() - 1)
J
Jeffrey Seyfried 已提交
3504
            }
3505 3506
            PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                PathResolution::new(module.def().unwrap()),
3507
            PathResult::Failed(span, msg, false) => {
J
Jeffrey Seyfried 已提交
3508 3509 3510
                resolve_error(self, span, ResolutionError::FailedToResolve(&msg));
                err_path_resolution()
            }
3511
            PathResult::Module(ModuleOrUniformRoot::UniformRoot(_)) |
3512 3513
            PathResult::Failed(..) => return None,
            PathResult::Indeterminate => bug!("indetermined path result in resolve_qpath"),
J
Jeffrey Seyfried 已提交
3514 3515
        };

3516
        if path.len() > 1 && !global_by_default && result.base_def() != Def::Err &&
V
Vadim Petrochenkov 已提交
3517 3518
           path[0].name != keywords::CrateRoot.name() &&
           path[0].name != keywords::DollarCrate.name() {
3519
            let unqualified_result = {
N
Niko Matsakis 已提交
3520
                match self.resolve_path(
3521
                    None,
N
Niko Matsakis 已提交
3522 3523 3524 3525 3526 3527
                    &[*path.last().unwrap()],
                    Some(ns),
                    false,
                    span,
                    CrateLint::No,
                ) {
3528
                    PathResult::NonModule(path_res) => path_res.base_def(),
3529 3530
                    PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                        module.def().unwrap(),
3531 3532 3533
                    _ => return Some(result),
                }
            };
3534
            if result.base_def() == unqualified_result {
3535
                let lint = lint::builtin::UNUSED_QUALIFICATIONS;
3536
                self.session.buffer_lint(lint, id, span, "unnecessary qualification")
N
Nick Cameron 已提交
3537
            }
3538
        }
N
Nick Cameron 已提交
3539

J
Jeffrey Seyfried 已提交
3540
        Some(result)
3541 3542
    }

3543 3544
    fn resolve_path(
        &mut self,
3545
        base_module: Option<ModuleOrUniformRoot<'a>>,
3546 3547 3548 3549 3550
        path: &[Ident],
        opt_ns: Option<Namespace>, // `None` indicates a module path
        record_used: bool,
        path_span: Span,
        crate_lint: CrateLint,
3551
    ) -> PathResult<'a> {
3552 3553 3554
        let parent_scope = ParentScope { module: self.current_module, ..self.dummy_parent_scope() };
        self.resolve_path_with_parent_scope(base_module, path, opt_ns, &parent_scope,
                                            record_used, path_span, crate_lint)
3555 3556
    }

3557
    fn resolve_path_with_parent_scope(
3558 3559 3560 3561
        &mut self,
        base_module: Option<ModuleOrUniformRoot<'a>>,
        path: &[Ident],
        opt_ns: Option<Namespace>, // `None` indicates a module path
3562
        parent_scope: &ParentScope<'a>,
3563 3564 3565
        record_used: bool,
        path_span: Span,
        crate_lint: CrateLint,
3566
    ) -> PathResult<'a> {
3567
        let mut module = base_module;
3568
        let mut allow_super = true;
3569
        let mut second_binding = None;
3570
        self.current_module = parent_scope.module;
J
Jeffrey Seyfried 已提交
3571

3572
        debug!(
N
Niko Matsakis 已提交
3573 3574
            "resolve_path(path={:?}, opt_ns={:?}, record_used={:?}, \
             path_span={:?}, crate_lint={:?})",
3575 3576 3577 3578 3579 3580 3581
            path,
            opt_ns,
            record_used,
            path_span,
            crate_lint,
        );

J
Jeffrey Seyfried 已提交
3582
        for (i, &ident) in path.iter().enumerate() {
3583
            debug!("resolve_path ident {} {:?}", i, ident);
J
Jeffrey Seyfried 已提交
3584 3585
            let is_last = i == path.len() - 1;
            let ns = if is_last { opt_ns.unwrap_or(TypeNS) } else { TypeNS };
V
Vadim Petrochenkov 已提交
3586
            let name = ident.name;
J
Jeffrey Seyfried 已提交
3587

3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608
            allow_super &= ns == TypeNS &&
                (name == keywords::SelfValue.name() ||
                 name == keywords::Super.name());

            if ns == TypeNS {
                if allow_super && name == keywords::Super.name() {
                    let mut ctxt = ident.span.ctxt().modern();
                    let self_module = match i {
                        0 => Some(self.resolve_self(&mut ctxt, self.current_module)),
                        _ => match module {
                            Some(ModuleOrUniformRoot::Module(module)) => Some(module),
                            _ => None,
                        },
                    };
                    if let Some(self_module) = self_module {
                        if let Some(parent) = self_module.parent {
                            module = Some(ModuleOrUniformRoot::Module(
                                self.resolve_self(&mut ctxt, parent)));
                            continue;
                        }
                    }
J
Jeffrey Seyfried 已提交
3609
                    let msg = "There are too many initial `super`s.".to_string();
3610
                    return PathResult::Failed(ident.span, msg, false);
J
Jeffrey Seyfried 已提交
3611
                }
3612
                if i == 0 {
3613 3614 3615 3616 3617 3618
                    if name == keywords::SelfValue.name() {
                        let mut ctxt = ident.span.ctxt().modern();
                        module = Some(ModuleOrUniformRoot::Module(
                            self.resolve_self(&mut ctxt, self.current_module)));
                        continue;
                    }
3619 3620 3621 3622 3623 3624
                    if name == keywords::Extern.name() ||
                       name == keywords::CrateRoot.name() &&
                       self.session.rust_2018() {
                        module = Some(ModuleOrUniformRoot::UniformRoot(name));
                        continue;
                    }
3625 3626 3627 3628 3629 3630 3631 3632
                    if name == keywords::CrateRoot.name() ||
                       name == keywords::Crate.name() ||
                       name == keywords::DollarCrate.name() {
                        // `::a::b`, `crate::a::b` or `$crate::a::b`
                        module = Some(ModuleOrUniformRoot::Module(
                            self.resolve_crate_root(ident)));
                        continue;
                    }
V
Vadim Petrochenkov 已提交
3633
                }
3634 3635
            }

3636
            // Report special messages for path segment keywords in wrong positions.
3637
            if ident.is_path_segment_keyword() && i != 0 {
3638
                let name_str = if name == keywords::CrateRoot.name() {
L
ljedrz 已提交
3639
                    "crate root".to_string()
3640 3641 3642
                } else {
                    format!("`{}`", name)
                };
V
Vadim Petrochenkov 已提交
3643
                let msg = if i == 1 && path[0].name == keywords::CrateRoot.name() {
3644 3645 3646 3647 3648 3649 3650
                    format!("global paths cannot start with {}", name_str)
                } else {
                    format!("{} in paths can only be used in start position", name_str)
                };
                return PathResult::Failed(ident.span, msg, false);
            }

J
Jeffrey Seyfried 已提交
3651
            let binding = if let Some(module) = module {
3652
                self.resolve_ident_in_module(module, ident, ns, record_used, path_span)
3653
            } else if opt_ns == Some(MacroNS) {
3654
                assert!(ns == TypeNS);
3655 3656
                self.resolve_lexical_macro_path_segment(ident, ns, None, parent_scope, record_used,
                                                        record_used, path_span).map(|(b, _)| b)
J
Jeffrey Seyfried 已提交
3657
            } else {
3658 3659 3660
                let record_used_id =
                    if record_used { crate_lint.node_id().or(Some(CRATE_NODE_ID)) } else { None };
                match self.resolve_ident_in_lexical_scope(ident, ns, record_used_id, path_span) {
3661
                    // we found a locally-imported or available item/module
J
Jeffrey Seyfried 已提交
3662
                    Some(LexicalScopeBinding::Item(binding)) => Ok(binding),
3663
                    // we found a local variable or type param
3664 3665
                    Some(LexicalScopeBinding::Def(def))
                            if opt_ns == Some(TypeNS) || opt_ns == Some(ValueNS) => {
3666 3667 3668
                        return PathResult::NonModule(PathResolution::with_unresolved_segments(
                            def, path.len() - 1
                        ));
J
Jeffrey Seyfried 已提交
3669
                    }
3670
                    _ => Err(if record_used { Determined } else { Undetermined }),
J
Jeffrey Seyfried 已提交
3671 3672 3673 3674 3675
                }
            };

            match binding {
                Ok(binding) => {
3676 3677 3678
                    if i == 1 {
                        second_binding = Some(binding);
                    }
3679 3680
                    let def = binding.def();
                    let maybe_assoc = opt_ns != Some(MacroNS) && PathSource::Type.is_expected(def);
J
Jeffrey Seyfried 已提交
3681
                    if let Some(next_module) = binding.module() {
3682
                        module = Some(ModuleOrUniformRoot::Module(next_module));
3683
                    } else if def == Def::ToolMod && i + 1 != path.len() {
3684 3685
                        let def = Def::NonMacroAttr(NonMacroAttrKind::Tool);
                        return PathResult::NonModule(PathResolution::new(def));
3686
                    } else if def == Def::Err {
J
Jeffrey Seyfried 已提交
3687
                        return PathResult::NonModule(err_path_resolution());
3688
                    } else if opt_ns.is_some() && (is_last || maybe_assoc) {
3689
                        self.lint_if_path_starts_with_module(
3690
                            crate_lint,
3691 3692 3693 3694
                            path,
                            path_span,
                            second_binding,
                        );
3695 3696 3697
                        return PathResult::NonModule(PathResolution::with_unresolved_segments(
                            def, path.len() - i - 1
                        ));
J
Jeffrey Seyfried 已提交
3698
                    } else {
3699
                        return PathResult::Failed(ident.span,
V
Vadim Petrochenkov 已提交
3700
                                                  format!("Not a module `{}`", ident),
3701
                                                  is_last);
J
Jeffrey Seyfried 已提交
3702 3703 3704 3705
                    }
                }
                Err(Undetermined) => return PathResult::Indeterminate,
                Err(Determined) => {
3706
                    if let Some(ModuleOrUniformRoot::Module(module)) = module {
J
Jeffrey Seyfried 已提交
3707
                        if opt_ns.is_some() && !module.is_normal() {
3708 3709 3710
                            return PathResult::NonModule(PathResolution::with_unresolved_segments(
                                module.def().unwrap(), path.len() - i
                            ));
J
Jeffrey Seyfried 已提交
3711 3712
                        }
                    }
3713 3714 3715 3716 3717
                    let module_def = match module {
                        Some(ModuleOrUniformRoot::Module(module)) => module.def(),
                        _ => None,
                    };
                    let msg = if module_def == self.graph_root.def() {
J
Jeffrey Seyfried 已提交
3718 3719
                        let is_mod = |def| match def { Def::Mod(..) => true, _ => false };
                        let mut candidates =
3720
                            self.lookup_import_candidates(name, TypeNS, is_mod);
3721 3722 3723
                        candidates.sort_by_cached_key(|c| {
                            (c.path.segments.len(), c.path.to_string())
                        });
J
Jeffrey Seyfried 已提交
3724
                        if let Some(candidate) = candidates.get(0) {
3725
                            format!("Did you mean `{}`?", candidate.path)
J
Jeffrey Seyfried 已提交
3726
                        } else {
V
Vadim Petrochenkov 已提交
3727
                            format!("Maybe a missing `extern crate {};`?", ident)
J
Jeffrey Seyfried 已提交
3728 3729
                        }
                    } else if i == 0 {
V
Vadim Petrochenkov 已提交
3730
                        format!("Use of undeclared type or module `{}`", ident)
J
Jeffrey Seyfried 已提交
3731
                    } else {
V
Vadim Petrochenkov 已提交
3732
                        format!("Could not find `{}` in `{}`", ident, path[i - 1])
J
Jeffrey Seyfried 已提交
3733
                    };
3734
                    return PathResult::Failed(ident.span, msg, is_last);
J
Jeffrey Seyfried 已提交
3735 3736
                }
            }
3737 3738
        }

3739
        self.lint_if_path_starts_with_module(crate_lint, path, path_span, second_binding);
3740

3741 3742 3743 3744
        PathResult::Module(module.unwrap_or_else(|| {
            span_bug!(path_span, "resolve_path: empty(?) path {:?} has no module", path);
        }))

3745 3746
    }

3747 3748 3749 3750 3751 3752 3753
    fn lint_if_path_starts_with_module(
        &self,
        crate_lint: CrateLint,
        path: &[Ident],
        path_span: Span,
        second_binding: Option<&NameBinding>,
    ) {
3754 3755 3756 3757 3758
        // In the 2018 edition this lint is a hard error, so nothing to do
        if self.session.rust_2018() {
            return
        }

3759 3760 3761 3762
        let (diag_id, diag_span) = match crate_lint {
            CrateLint::No => return,
            CrateLint::SimplePath(id) => (id, path_span),
            CrateLint::UsePath { root_id, root_span } => (root_id, root_span),
3763
            CrateLint::QPathTrait { qpath_id, qpath_span } => (qpath_id, qpath_span),
3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778
        };

        let first_name = match path.get(0) {
            Some(ident) => ident.name,
            None => return,
        };

        // We're only interested in `use` paths which should start with
        // `{{root}}` or `extern` currently.
        if first_name != keywords::Extern.name() && first_name != keywords::CrateRoot.name() {
            return
        }

        match path.get(1) {
            // If this import looks like `crate::...` it's already good
3779
            Some(ident) if ident.name == keywords::Crate.name() => return,
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792
            // Otherwise go below to see if it's an extern crate
            Some(_) => {}
            // If the path has length one (and it's `CrateRoot` most likely)
            // then we don't know whether we're gonna be importing a crate or an
            // item in our crate. Defer this lint to elsewhere
            None => return,
        }

        // If the first element of our path was actually resolved to an
        // `ExternCrate` (also used for `crate::...`) then no need to issue a
        // warning, this looks all good!
        if let Some(binding) = second_binding {
            if let NameBindingKind::Import { directive: d, .. } = binding.kind {
3793 3794 3795
                // Careful: we still want to rewrite paths from
                // renamed extern crates.
                if let ImportDirectiveSubclass::ExternCrate(None) = d.subclass {
3796 3797 3798 3799 3800 3801
                    return
                }
            }
        }

        let diag = lint::builtin::BuiltinLintDiagnostics
3802
            ::AbsPathWithModule(diag_span);
3803
        self.session.buffer_lint_with_diagnostic(
3804
            lint::builtin::ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
3805
            diag_id, diag_span,
3806 3807 3808 3809 3810
            "absolute paths must start with `self`, `super`, \
            `crate`, or an external crate name in the 2018 edition",
            diag);
    }

3811
    // Resolve a local definition, potentially adjusting for closures.
3812 3813 3814 3815
    fn adjust_local_def(&mut self,
                        ns: Namespace,
                        rib_index: usize,
                        mut def: Def,
3816 3817
                        record_used: bool,
                        span: Span) -> Def {
3818 3819 3820 3821
        let ribs = &self.ribs[ns][rib_index + 1..];

        // An invalid forward use of a type parameter from a previous default.
        if let ForwardTyParamBanRibKind = self.ribs[ns][rib_index].kind {
3822
            if record_used {
3823
                resolve_error(self, span, ResolutionError::ForwardDeclaredTyParam);
3824 3825 3826 3827 3828
            }
            assert_eq!(def, Def::Err);
            return Def::Err;
        }

3829
        match def {
3830
            Def::Upvar(..) => {
3831
                span_bug!(span, "unexpected {:?} in bindings", def)
3832
            }
3833
            Def::Local(node_id) => {
3834 3835
                for rib in ribs {
                    match rib.kind {
3836 3837
                        NormalRibKind | ModuleRibKind(..) | MacroDefinition(..) |
                        ForwardTyParamBanRibKind => {
3838 3839 3840 3841 3842
                            // Nothing to do. Continue.
                        }
                        ClosureRibKind(function_id) => {
                            let prev_def = def;

C
corentih 已提交
3843 3844
                            let seen = self.freevars_seen
                                           .entry(function_id)
3845
                                           .or_default();
3846
                            if let Some(&index) = seen.get(&node_id) {
3847
                                def = Def::Upvar(node_id, index, function_id);
3848 3849
                                continue;
                            }
C
corentih 已提交
3850 3851
                            let vec = self.freevars
                                          .entry(function_id)
3852
                                          .or_default();
3853
                            let depth = vec.len();
3854
                            def = Def::Upvar(node_id, depth, function_id);
3855

3856
                            if record_used {
3857 3858
                                vec.push(Freevar {
                                    def: prev_def,
3859
                                    span,
3860 3861 3862
                                });
                                seen.insert(node_id, depth);
                            }
3863
                        }
3864
                        ItemRibKind | TraitOrImplItemRibKind => {
3865 3866 3867
                            // This was an attempt to access an upvar inside a
                            // named function item. This is not allowed, so we
                            // report an error.
3868
                            if record_used {
3869 3870 3871
                                resolve_error(self, span,
                                        ResolutionError::CannotCaptureDynamicEnvironmentInFnItem);
                            }
3872
                            return Def::Err;
3873 3874 3875
                        }
                        ConstantItemRibKind => {
                            // Still doesn't deal with upvars
3876
                            if record_used {
3877 3878 3879
                                resolve_error(self, span,
                                        ResolutionError::AttemptToUseNonConstantValueInConstant);
                            }
3880
                            return Def::Err;
3881 3882 3883 3884
                        }
                    }
                }
            }
3885
            Def::TyParam(..) | Def::SelfTy(..) => {
3886 3887
                for rib in ribs {
                    match rib.kind {
3888
                        NormalRibKind | TraitOrImplItemRibKind | ClosureRibKind(..) |
3889 3890
                        ModuleRibKind(..) | MacroDefinition(..) | ForwardTyParamBanRibKind |
                        ConstantItemRibKind => {
3891 3892 3893 3894 3895
                            // Nothing to do. Continue.
                        }
                        ItemRibKind => {
                            // This was an attempt to use a type parameter outside
                            // its scope.
3896
                            if record_used {
3897
                                resolve_error(self, span,
3898
                                    ResolutionError::TypeParametersFromOuterFunction(def));
3899
                            }
3900
                            return Def::Err;
3901 3902 3903 3904 3905 3906
                        }
                    }
                }
            }
            _ => {}
        }
3907
        return def;
3908 3909
    }

3910
    fn lookup_assoc_candidate<FilterFn>(&mut self,
3911
                                        ident: Ident,
3912 3913 3914 3915 3916
                                        ns: Namespace,
                                        filter_fn: FilterFn)
                                        -> Option<AssocSuggestion>
        where FilterFn: Fn(Def) -> bool
    {
3917
        fn extract_node_id(t: &Ty) -> Option<NodeId> {
3918
            match t.node {
3919 3920
                TyKind::Path(None, _) => Some(t.id),
                TyKind::Rptr(_, ref mut_ty) => extract_node_id(&mut_ty.ty),
3921 3922 3923 3924 3925 3926 3927
                // This doesn't handle the remaining `Ty` variants as they are not
                // that commonly the self_type, it might be interesting to provide
                // support for those in future.
                _ => None,
            }
        }

3928
        // Fields are generally expected in the same contexts as locals.
3929
        if filter_fn(Def::Local(ast::DUMMY_NODE_ID)) {
3930 3931 3932
            if let Some(node_id) = self.current_self_type.as_ref().and_then(extract_node_id) {
                // Look for a field with the same name in the current self_type.
                if let Some(resolution) = self.def_map.get(&node_id) {
3933 3934 3935
                    match resolution.base_def() {
                        Def::Struct(did) | Def::Union(did)
                                if resolution.unresolved_segments() == 0 => {
3936
                            if let Some(field_names) = self.field_names.get(&did) {
3937
                                if field_names.iter().any(|&field_name| ident.name == field_name) {
3938 3939
                                    return Some(AssocSuggestion::Field);
                                }
3940
                            }
3941
                        }
3942
                        _ => {}
3943
                    }
3944
                }
3945
            }
3946 3947
        }

3948
        // Look for associated items in the current trait.
3949
        if let Some((module, _)) = self.current_trait_ref {
3950 3951 3952 3953 3954 3955 3956
            if let Ok(binding) = self.resolve_ident_in_module(
                    ModuleOrUniformRoot::Module(module),
                    ident,
                    ns,
                    false,
                    module.span,
                ) {
3957
                let def = binding.def();
3958
                if filter_fn(def) {
3959
                    return Some(if self.has_self.contains(&def.def_id()) {
3960 3961 3962 3963
                        AssocSuggestion::MethodWithSelf
                    } else {
                        AssocSuggestion::AssocItem
                    });
3964 3965 3966 3967
                }
            }
        }

3968
        None
3969 3970
    }

3971
    fn lookup_typo_candidate<FilterFn>(&mut self,
V
Vadim Petrochenkov 已提交
3972
                                       path: &[Ident],
3973
                                       ns: Namespace,
3974 3975
                                       filter_fn: FilterFn,
                                       span: Span)
3976
                                       -> Option<Symbol>
3977 3978
        where FilterFn: Fn(Def) -> bool
    {
3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989
        let add_module_candidates = |module: Module, names: &mut Vec<Name>| {
            for (&(ident, _), resolution) in module.resolutions.borrow().iter() {
                if let Some(binding) = resolution.borrow().binding {
                    if filter_fn(binding.def()) {
                        names.push(ident.name);
                    }
                }
            }
        };

        let mut names = Vec::new();
3990
        if path.len() == 1 {
3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008
            // Search in lexical scope.
            // Walk backwards up the ribs in scope and collect candidates.
            for rib in self.ribs[ns].iter().rev() {
                // Locals and type parameters
                for (ident, def) in &rib.bindings {
                    if filter_fn(*def) {
                        names.push(ident.name);
                    }
                }
                // Items in scope
                if let ModuleRibKind(module) = rib.kind {
                    // Items from this module
                    add_module_candidates(module, &mut names);

                    if let ModuleKind::Block(..) = module.kind {
                        // We can see through blocks
                    } else {
                        // Items from the prelude
4009
                        if !module.no_implicit_prelude {
4010
                            names.extend(self.session.extern_prelude.iter().cloned());
4011
                            if let Some(prelude) = self.prelude {
4012 4013 4014 4015 4016 4017 4018 4019
                                add_module_candidates(prelude, &mut names);
                            }
                        }
                        break;
                    }
                }
            }
            // Add primitive types to the mix
4020
            if filter_fn(Def::PrimTy(Bool)) {
4021 4022 4023
                names.extend(
                    self.primitive_type_table.primitive_types.iter().map(|(name, _)| name)
                )
4024 4025 4026 4027
            }
        } else {
            // Search in module.
            let mod_path = &path[..path.len() - 1];
4028
            if let PathResult::Module(module) = self.resolve_path(None, mod_path, Some(TypeNS),
4029
                                                                  false, span, CrateLint::No) {
4030 4031 4032
                if let ModuleOrUniformRoot::Module(module) = module {
                    add_module_candidates(module, &mut names);
                }
4033
            }
4034
        }
4035

V
Vadim Petrochenkov 已提交
4036
        let name = path[path.len() - 1].name;
4037
        // Make sure error reporting is deterministic.
4038
        names.sort_by_cached_key(|name| name.as_str());
4039
        match find_best_match_for_name(names.iter(), &name.as_str(), None) {
4040
            Some(found) if found != name => Some(found),
4041
            _ => None,
4042
        }
4043 4044
    }

4045
    fn with_resolved_label<F>(&mut self, label: Option<Label>, id: NodeId, f: F)
4046 4047
        where F: FnOnce(&mut Resolver)
    {
4048
        if let Some(label) = label {
4049
            self.unused_labels.insert(id, label.ident.span);
4050
            let def = Def::Label(id);
4051
            self.with_label_rib(|this| {
4052 4053
                let ident = label.ident.modern_and_legacy();
                this.label_ribs.last_mut().unwrap().bindings.insert(ident, def);
4054
                f(this);
4055 4056
            });
        } else {
4057
            f(self);
4058 4059 4060
        }
    }

4061
    fn resolve_labeled_block(&mut self, label: Option<Label>, id: NodeId, block: &Block) {
4062 4063 4064
        self.with_resolved_label(label, id, |this| this.visit_block(block));
    }

4065
    fn resolve_expr(&mut self, expr: &Expr, parent: Option<&Expr>) {
P
Patrick Walton 已提交
4066 4067
        // First, record candidate traits for this expression if it could
        // result in the invocation of a method call.
4068 4069 4070

        self.record_candidate_traits_for_expr_if_necessary(expr);

4071
        // Next, resolve the node.
4072
        match expr.node {
4073 4074
            ExprKind::Path(ref qself, ref path) => {
                self.smart_resolve_path(expr.id, qself.as_ref(), path, PathSource::Expr(parent));
4075
                visit::walk_expr(self, expr);
4076 4077
            }

V
Vadim Petrochenkov 已提交
4078
            ExprKind::Struct(ref path, ..) => {
4079
                self.smart_resolve_path(expr.id, None, path, PathSource::Struct);
4080
                visit::walk_expr(self, expr);
4081 4082
            }

4083
            ExprKind::Break(Some(label), _) | ExprKind::Continue(Some(label)) => {
4084 4085 4086 4087
                let def = self.search_label(label.ident, |rib, ident| {
                    rib.bindings.get(&ident.modern_and_legacy()).cloned()
                });
                match def {
4088
                    None => {
4089 4090 4091
                        // Search again for close matches...
                        // Picks the first label that is "close enough", which is not necessarily
                        // the closest match
4092
                        let close_match = self.search_label(label.ident, |rib, ident| {
4093
                            let names = rib.bindings.iter().map(|(id, _)| &id.name);
V
Vadim Petrochenkov 已提交
4094
                            find_best_match_for_name(names, &*ident.as_str(), None)
4095
                        });
4096
                        self.record_def(expr.id, err_path_resolution());
4097
                        resolve_error(self,
4098
                                      label.ident.span,
V
Vadim Petrochenkov 已提交
4099
                                      ResolutionError::UndeclaredLabel(&label.ident.as_str(),
4100
                                                                       close_match));
4101
                    }
4102
                    Some(Def::Label(id)) => {
4103
                        // Since this def is a label, it is never read.
4104 4105
                        self.record_def(expr.id, PathResolution::new(Def::Label(id)));
                        self.unused_labels.remove(&id);
4106 4107
                    }
                    Some(_) => {
4108
                        span_bug!(expr.span, "label wasn't mapped to a label def!");
4109 4110
                    }
                }
4111 4112 4113

                // visit `break` argument if any
                visit::walk_expr(self, expr);
4114
            }
4115

4116
            ExprKind::IfLet(ref pats, ref subexpression, ref if_block, ref optional_else) => {
4117 4118
                self.visit_expr(subexpression);

J
Jeffrey Seyfried 已提交
4119
                self.ribs[ValueNS].push(Rib::new(NormalRibKind));
4120 4121 4122 4123 4124 4125
                let mut bindings_list = FxHashMap();
                for pat in pats {
                    self.resolve_pattern(pat, PatternSource::IfLet, &mut bindings_list);
                }
                // This has to happen *after* we determine which pat_idents are variants
                self.check_consistent_bindings(pats);
4126
                self.visit_block(if_block);
J
Jeffrey Seyfried 已提交
4127
                self.ribs[ValueNS].pop();
4128 4129 4130 4131

                optional_else.as_ref().map(|expr| self.visit_expr(expr));
            }

J
Jeffrey Seyfried 已提交
4132 4133 4134
            ExprKind::Loop(ref block, label) => self.resolve_labeled_block(label, expr.id, &block),

            ExprKind::While(ref subexpression, ref block, label) => {
4135 4136 4137 4138
                self.with_resolved_label(label, expr.id, |this| {
                    this.visit_expr(subexpression);
                    this.visit_block(block);
                });
J
Jeffrey Seyfried 已提交
4139 4140
            }

4141
            ExprKind::WhileLet(ref pats, ref subexpression, ref block, label) => {
4142 4143
                self.with_resolved_label(label, expr.id, |this| {
                    this.visit_expr(subexpression);
4144
                    this.ribs[ValueNS].push(Rib::new(NormalRibKind));
4145 4146 4147 4148 4149 4150
                    let mut bindings_list = FxHashMap();
                    for pat in pats {
                        this.resolve_pattern(pat, PatternSource::WhileLet, &mut bindings_list);
                    }
                    // This has to happen *after* we determine which pat_idents are variants
                    this.check_consistent_bindings(pats);
4151
                    this.visit_block(block);
4152
                    this.ribs[ValueNS].pop();
4153
                });
4154 4155 4156 4157
            }

            ExprKind::ForLoop(ref pattern, ref subexpression, ref block, label) => {
                self.visit_expr(subexpression);
J
Jeffrey Seyfried 已提交
4158
                self.ribs[ValueNS].push(Rib::new(NormalRibKind));
4159
                self.resolve_pattern(pattern, PatternSource::For, &mut FxHashMap());
4160

J
Jeffrey Seyfried 已提交
4161
                self.resolve_labeled_block(label, expr.id, block);
4162

J
Jeffrey Seyfried 已提交
4163
                self.ribs[ValueNS].pop();
4164 4165
            }

4166 4167
            ExprKind::Block(ref block, label) => self.resolve_labeled_block(label, block.id, block),

4168
            // Equivalent to `visit::walk_expr` + passing some context to children.
4169
            ExprKind::Field(ref subexpression, _) => {
4170
                self.resolve_expr(subexpression, Some(expr));
4171
            }
4172
            ExprKind::MethodCall(ref segment, ref arguments) => {
4173
                let mut arguments = arguments.iter();
4174
                self.resolve_expr(arguments.next().unwrap(), Some(expr));
4175 4176 4177
                for argument in arguments {
                    self.resolve_expr(argument, None);
                }
4178
                self.visit_path_segment(expr.span, segment);
4179
            }
4180

4181
            ExprKind::Call(ref callee, ref arguments) => {
4182
                self.resolve_expr(callee, Some(expr));
4183 4184 4185 4186
                for argument in arguments {
                    self.resolve_expr(argument, None);
                }
            }
4187 4188 4189 4190 4191
            ExprKind::Type(ref type_expr, _) => {
                self.current_type_ascription.push(type_expr.span);
                visit::walk_expr(self, expr);
                self.current_type_ascription.pop();
            }
T
Taylor Cramer 已提交
4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204
            // Resolve the body of async exprs inside the async closure to which they desugar
            ExprKind::Async(_, async_closure_id, ref block) => {
                let rib_kind = ClosureRibKind(async_closure_id);
                self.ribs[ValueNS].push(Rib::new(rib_kind));
                self.label_ribs.push(Rib::new(rib_kind));
                self.visit_block(&block);
                self.label_ribs.pop();
                self.ribs[ValueNS].pop();
            }
            // `async |x| ...` gets desugared to `|x| future_from_generator(|| ...)`, so we need to
            // resolve the arguments within the proper scopes so that usages of them inside the
            // closure are detected as upvars rather than normal closure arg usages.
            ExprKind::Closure(
4205 4206 4207
                _, IsAsync::Async { closure_id: inner_closure_id, .. }, _,
                ref fn_decl, ref body, _span,
            ) => {
T
Taylor Cramer 已提交
4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235
                let rib_kind = ClosureRibKind(expr.id);
                self.ribs[ValueNS].push(Rib::new(rib_kind));
                self.label_ribs.push(Rib::new(rib_kind));
                // Resolve arguments:
                let mut bindings_list = FxHashMap();
                for argument in &fn_decl.inputs {
                    self.resolve_pattern(&argument.pat, PatternSource::FnParam, &mut bindings_list);
                    self.visit_ty(&argument.ty);
                }
                // No need to resolve return type-- the outer closure return type is
                // FunctionRetTy::Default

                // Now resolve the inner closure
                {
                    let rib_kind = ClosureRibKind(inner_closure_id);
                    self.ribs[ValueNS].push(Rib::new(rib_kind));
                    self.label_ribs.push(Rib::new(rib_kind));
                    // No need to resolve arguments: the inner closure has none.
                    // Resolve the return type:
                    visit::walk_fn_ret_ty(self, &fn_decl.output);
                    // Resolve the body
                    self.visit_expr(body);
                    self.label_ribs.pop();
                    self.ribs[ValueNS].pop();
                }
                self.label_ribs.pop();
                self.ribs[ValueNS].pop();
            }
B
Brian Anderson 已提交
4236
            _ => {
4237
                visit::walk_expr(self, expr);
4238 4239 4240 4241
            }
        }
    }

E
Eduard Burtescu 已提交
4242
    fn record_candidate_traits_for_expr_if_necessary(&mut self, expr: &Expr) {
4243
        match expr.node {
V
Vadim Petrochenkov 已提交
4244
            ExprKind::Field(_, ident) => {
4245 4246 4247 4248
                // FIXME(#6890): Even though you can't treat a method like a
                // field, we need to add any trait methods we find that match
                // the field name so that we can do some nice error reporting
                // later on in typeck.
V
Vadim Petrochenkov 已提交
4249
                let traits = self.get_traits_containing_item(ident, ValueNS);
4250
                self.trait_map.insert(expr.id, traits);
4251
            }
4252
            ExprKind::MethodCall(ref segment, ..) => {
C
corentih 已提交
4253
                debug!("(recording candidate traits for expr) recording traits for {}",
4254
                       expr.id);
4255
                let traits = self.get_traits_containing_item(segment.ident, ValueNS);
4256
                self.trait_map.insert(expr.id, traits);
4257
            }
4258
            _ => {
4259 4260 4261 4262 4263
                // Nothing to do.
            }
        }
    }

J
Jeffrey Seyfried 已提交
4264 4265
    fn get_traits_containing_item(&mut self, mut ident: Ident, ns: Namespace)
                                  -> Vec<TraitCandidate> {
4266
        debug!("(getting traits containing item) looking for '{}'", ident.name);
E
Eduard Burtescu 已提交
4267

4268
        let mut found_traits = Vec::new();
J
Jeffrey Seyfried 已提交
4269
        // Look for the current trait.
4270
        if let Some((module, _)) = self.current_trait_ref {
4271 4272 4273 4274 4275 4276 4277
            if self.resolve_ident_in_module(
                ModuleOrUniformRoot::Module(module),
                ident,
                ns,
                false,
                module.span,
            ).is_ok() {
4278 4279
                let def_id = module.def_id().unwrap();
                found_traits.push(TraitCandidate { def_id: def_id, import_id: None });
E
Eduard Burtescu 已提交
4280
            }
J
Jeffrey Seyfried 已提交
4281
        }
4282

4283
        ident.span = ident.span.modern();
J
Jeffrey Seyfried 已提交
4284 4285
        let mut search_module = self.current_module;
        loop {
4286
            self.get_traits_in_module_containing_item(ident, ns, search_module, &mut found_traits);
4287 4288 4289
            search_module = unwrap_or!(
                self.hygienic_lexical_parent(search_module, &mut ident.span), break
            );
4290
        }
4291

4292 4293
        if let Some(prelude) = self.prelude {
            if !search_module.no_implicit_prelude {
4294
                self.get_traits_in_module_containing_item(ident, ns, prelude, &mut found_traits);
E
Eduard Burtescu 已提交
4295
            }
4296 4297
        }

E
Eduard Burtescu 已提交
4298
        found_traits
4299 4300
    }

4301
    fn get_traits_in_module_containing_item(&mut self,
4302
                                            ident: Ident,
4303
                                            ns: Namespace,
4304
                                            module: Module<'a>,
4305
                                            found_traits: &mut Vec<TraitCandidate>) {
4306
        assert!(ns == TypeNS || ns == ValueNS);
4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319
        let mut traits = module.traits.borrow_mut();
        if traits.is_none() {
            let mut collected_traits = Vec::new();
            module.for_each_child(|name, ns, binding| {
                if ns != TypeNS { return }
                if let Def::Trait(_) = binding.def() {
                    collected_traits.push((name, binding));
                }
            });
            *traits = Some(collected_traits.into_boxed_slice());
        }

        for &(trait_name, binding) in traits.as_ref().unwrap().iter() {
4320
            let module = binding.module().unwrap();
J
Jeffrey Seyfried 已提交
4321
            let mut ident = ident;
4322
            if ident.span.glob_adjust(module.expansion, binding.span.ctxt().modern()).is_none() {
J
Jeffrey Seyfried 已提交
4323 4324
                continue
            }
4325 4326 4327 4328 4329 4330 4331 4332
            if self.resolve_ident_in_module_unadjusted(
                ModuleOrUniformRoot::Module(module),
                ident,
                ns,
                false,
                false,
                module.span,
            ).is_ok() {
4333 4334 4335 4336 4337 4338 4339 4340
                let import_id = match binding.kind {
                    NameBindingKind::Import { directive, .. } => {
                        self.maybe_unused_trait_imports.insert(directive.id);
                        self.add_to_glob_map(directive.id, trait_name);
                        Some(directive.id)
                    }
                    _ => None,
                };
4341
                let trait_def_id = module.def_id().unwrap();
4342 4343 4344 4345 4346
                found_traits.push(TraitCandidate { def_id: trait_def_id, import_id: import_id });
            }
        }
    }

D
Douglas Campos 已提交
4347
    fn lookup_import_candidates_from_module<FilterFn>(&mut self,
4348 4349
                                          lookup_name: Name,
                                          namespace: Namespace,
D
Douglas Campos 已提交
4350
                                          start_module: &'a ModuleData<'a>,
D
Douglas Campos 已提交
4351
                                          crate_name: Ident,
4352 4353 4354 4355 4356
                                          filter_fn: FilterFn)
                                          -> Vec<ImportSuggestion>
        where FilterFn: Fn(Def) -> bool
    {
        let mut candidates = Vec::new();
4357
        let mut worklist = Vec::new();
4358
        let mut seen_modules = FxHashSet();
4359
        let not_local_module = crate_name != keywords::Crate.ident();
D
Douglas Campos 已提交
4360
        worklist.push((start_module, Vec::<ast::PathSegment>::new(), not_local_module));
4361 4362 4363 4364

        while let Some((in_module,
                        path_segments,
                        in_module_is_extern)) = worklist.pop() {
4365
            self.populate_module_if_necessary(in_module);
4366

4367 4368 4369
            // We have to visit module children in deterministic order to avoid
            // instabilities in reported imports (#43552).
            in_module.for_each_child_stable(|ident, ns, name_binding| {
4370
                // avoid imports entirely
4371
                if name_binding.is_import() && !name_binding.is_extern_crate() { return; }
4372 4373
                // avoid non-importable candidates as well
                if !name_binding.is_importable() { return; }
4374 4375

                // collect results based on the filter function
4376
                if ident.name == lookup_name && ns == namespace {
4377
                    if filter_fn(name_binding.def()) {
4378
                        // create the path
4379
                        let mut segms = path_segments.clone();
4380
                        if self.session.rust_2018() {
4381 4382
                            // crate-local absolute paths start with `crate::` in edition 2018
                            // FIXME: may also be stabilized for Rust 2015 (Issues #45477, #44660)
D
Douglas Campos 已提交
4383 4384 4385
                            segms.insert(
                                0, ast::PathSegment::from_ident(crate_name)
                            );
4386
                        }
4387

4388
                        segms.push(ast::PathSegment::from_ident(ident));
4389
                        let path = Path {
4390
                            span: name_binding.span,
4391 4392 4393 4394 4395 4396 4397 4398 4399
                            segments: segms,
                        };
                        // the entity is accessible in the following cases:
                        // 1. if it's defined in the same crate, it's always
                        // accessible (since private entities can be made public)
                        // 2. if it's defined in another crate, it's accessible
                        // only if both the module is public and the entity is
                        // declared as public (due to pruning, we don't explore
                        // outside crate private modules => no need to check this)
4400
                        if !in_module_is_extern || name_binding.vis == ty::Visibility::Public {
4401
                            candidates.push(ImportSuggestion { path: path });
4402 4403 4404 4405 4406
                        }
                    }
                }

                // collect submodules to explore
J
Jeffrey Seyfried 已提交
4407
                if let Some(module) = name_binding.module() {
4408
                    // form the path
4409
                    let mut path_segments = path_segments.clone();
4410
                    path_segments.push(ast::PathSegment::from_ident(ident));
4411

4412 4413
                    let is_extern_crate_that_also_appears_in_prelude =
                        name_binding.is_extern_crate() &&
D
Douglas Campos 已提交
4414
                        self.session.rust_2018();
4415 4416 4417 4418

                    let is_visible_to_user =
                        !in_module_is_extern || name_binding.vis == ty::Visibility::Public;

4419
                    if !is_extern_crate_that_also_appears_in_prelude && is_visible_to_user {
4420
                        // add the module to the lookup
4421
                        let is_extern = in_module_is_extern || name_binding.is_extern_crate();
4422
                        if seen_modules.insert(module.def_id().unwrap()) {
4423 4424
                            worklist.push((module, path_segments, is_extern));
                        }
4425 4426 4427 4428 4429
                    }
                }
            })
        }

4430
        candidates
4431 4432
    }

D
Douglas Campos 已提交
4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446
    /// When name resolution fails, this method can be used to look up candidate
    /// entities with the expected name. It allows filtering them using the
    /// supplied predicate (which should be used to only accept the types of
    /// definitions expected e.g. traits). The lookup spans across all crates.
    ///
    /// NOTE: The method does not look into imports, but this is not a problem,
    /// since we report the definitions (thus, the de-aliased imports).
    fn lookup_import_candidates<FilterFn>(&mut self,
                                          lookup_name: Name,
                                          namespace: Namespace,
                                          filter_fn: FilterFn)
                                          -> Vec<ImportSuggestion>
        where FilterFn: Fn(Def) -> bool
    {
4447 4448 4449 4450
        let mut suggestions = vec![];

        suggestions.extend(
            self.lookup_import_candidates_from_module(
D
Douglas Campos 已提交
4451
                lookup_name, namespace, self.graph_root, keywords::Crate.ident(), &filter_fn
4452 4453 4454
            )
        );

4455
        if self.session.rust_2018() {
4456
            for &name in &self.session.extern_prelude {
4457 4458 4459 4460 4461 4462 4463 4464
                let ident = Ident::with_empty_ctxt(name);
                match self.crate_loader.maybe_process_path_extern(name, ident.span) {
                    Some(crate_id) => {
                        let crate_root = self.get_module(DefId {
                            krate: crate_id,
                            index: CRATE_DEF_INDEX,
                        });
                        self.populate_module_if_necessary(&crate_root);
4465

4466 4467 4468 4469 4470 4471 4472 4473
                        suggestions.extend(
                            self.lookup_import_candidates_from_module(
                                lookup_name, namespace, crate_root, ident, &filter_fn
                            )
                        );
                    }
                    None => {}
                }
4474 4475 4476 4477
            }
        }

        suggestions
D
Douglas Campos 已提交
4478 4479
    }

4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490
    fn find_module(&mut self,
                   module_def: Def)
                   -> Option<(Module<'a>, ImportSuggestion)>
    {
        let mut result = None;
        let mut worklist = Vec::new();
        let mut seen_modules = FxHashSet();
        worklist.push((self.graph_root, Vec::new()));

        while let Some((in_module, path_segments)) = worklist.pop() {
            // abort if the module is already found
4491
            if result.is_some() { break; }
4492 4493 4494

            self.populate_module_if_necessary(in_module);

4495
            in_module.for_each_child_stable(|ident, _, name_binding| {
4496 4497 4498
                // abort if the module is already found or if name_binding is private external
                if result.is_some() || !name_binding.vis.is_visible_locally() {
                    return
4499 4500 4501 4502
                }
                if let Some(module) = name_binding.module() {
                    // form the path
                    let mut path_segments = path_segments.clone();
4503
                    path_segments.push(ast::PathSegment::from_ident(ident));
4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528
                    if module.def() == Some(module_def) {
                        let path = Path {
                            span: name_binding.span,
                            segments: path_segments,
                        };
                        result = Some((module, ImportSuggestion { path: path }));
                    } else {
                        // add the module to the lookup
                        if seen_modules.insert(module.def_id().unwrap()) {
                            worklist.push((module, path_segments));
                        }
                    }
                }
            });
        }

        result
    }

    fn collect_enum_variants(&mut self, enum_def: Def) -> Option<Vec<Path>> {
        if let Def::Enum(..) = enum_def {} else {
            panic!("Non-enum def passed to collect_enum_variants: {:?}", enum_def)
        }

        self.find_module(enum_def).map(|(enum_module, enum_import_suggestion)| {
4529 4530
            self.populate_module_if_necessary(enum_module);

4531 4532 4533 4534
            let mut variants = Vec::new();
            enum_module.for_each_child_stable(|ident, _, name_binding| {
                if let Def::Variant(..) = name_binding.def() {
                    let mut segms = enum_import_suggestion.path.segments.clone();
4535
                    segms.push(ast::PathSegment::from_ident(ident));
4536 4537 4538 4539 4540 4541 4542 4543 4544 4545
                    variants.push(Path {
                        span: name_binding.span,
                        segments: segms,
                    });
                }
            });
            variants
        })
    }

4546 4547
    fn record_def(&mut self, node_id: NodeId, resolution: PathResolution) {
        debug!("(recording def) recording {:?} for {}", resolution, node_id);
4548
        if let Some(prev_res) = self.def_map.insert(node_id, resolution) {
4549
            panic!("path resolved multiple times ({:?} before, {:?} now)", prev_res, resolution);
4550
        }
4551 4552
    }

4553
    fn resolve_visibility(&mut self, vis: &ast::Visibility) -> ty::Visibility {
4554 4555 4556 4557 4558 4559
        match vis.node {
            ast::VisibilityKind::Public => ty::Visibility::Public,
            ast::VisibilityKind::Crate(..) => {
                ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX))
            }
            ast::VisibilityKind::Inherited => {
4560
                ty::Visibility::Restricted(self.current_module.normal_ancestor_id)
4561
            }
4562
            ast::VisibilityKind::Restricted { ref path, id, .. } => {
4563 4564
                // Visibilities are resolved as global by default, add starting root segment.
                let segments = path.make_root().iter().chain(path.segments.iter())
4565
                    .map(|seg| seg.ident)
4566
                    .collect::<Vec<_>>();
4567 4568 4569 4570 4571 4572 4573 4574
                let def = self.smart_resolve_path_fragment(
                    id,
                    None,
                    &segments,
                    path.span,
                    PathSource::Visibility,
                    CrateLint::SimplePath(id),
                ).base_def();
4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586
                if def == Def::Err {
                    ty::Visibility::Public
                } else {
                    let vis = ty::Visibility::Restricted(def.def_id());
                    if self.is_accessible(vis) {
                        vis
                    } else {
                        self.session.span_err(path.span, "visibilities can only be restricted \
                                                          to ancestor modules");
                        ty::Visibility::Public
                    }
                }
4587 4588 4589 4590
            }
        }
    }

4591
    fn is_accessible(&self, vis: ty::Visibility) -> bool {
4592
        vis.is_accessible_from(self.current_module.normal_ancestor_id, self)
4593 4594
    }

4595
    fn is_accessible_from(&self, vis: ty::Visibility, module: Module<'a>) -> bool {
4596
        vis.is_accessible_from(module.normal_ancestor_id, self)
4597 4598
    }

4599
    fn report_ambiguity_error(&self, ident: Ident, b1: &NameBinding, b2: &NameBinding) {
4600
        let participle = |is_import: bool| if is_import { "imported" } else { "defined" };
4601
        let msg1 =
4602
            format!("`{}` could refer to the name {} here", ident, participle(b1.is_import()));
4603
        let msg2 =
4604
            format!("`{}` could also refer to the name {} here", ident, participle(b2.is_import()));
4605 4606
        let note = if b1.expansion != Mark::root() {
            Some(if let Def::Macro(..) = b1.def() {
4607
                format!("macro-expanded {} do not shadow",
4608
                        if b1.is_import() { "macro imports" } else { "macros" })
4609 4610
            } else {
                format!("macro-expanded {} do not shadow when used in a macro invocation path",
4611
                        if b1.is_import() { "imports" } else { "items" })
4612
            })
4613
        } else if b1.is_glob_import() {
4614
            Some(format!("consider adding an explicit import of `{}` to disambiguate", ident))
4615 4616 4617 4618
        } else {
            None
        };

4619 4620
        let mut err = struct_span_err!(self.session, ident.span, E0659, "`{}` is ambiguous", ident);
        err.span_label(ident.span, "ambiguous name");
4621 4622 4623
        err.span_note(b1.span, &msg1);
        match b2.def() {
            Def::Macro(..) if b2.span.is_dummy() =>
4624
                err.note(&format!("`{}` is also a builtin macro", ident)),
4625
            _ => err.span_note(b2.span, &msg2),
4626 4627 4628 4629 4630 4631 4632
        };
        if let Some(note) = note {
            err.note(&note);
        }
        err.emit();
    }

4633 4634
    fn report_errors(&mut self, krate: &Crate) {
        self.report_with_use_injections(krate);
4635
        let mut reported_spans = FxHashSet();
4636

4637 4638 4639
        for &(span_use, span_def) in &self.macro_expanded_macro_export_errors {
            let msg = "macro-expanded `macro_export` macros from the current crate \
                       cannot be referred to by absolute paths";
4640 4641 4642 4643 4644 4645
            self.session.buffer_lint_with_diagnostic(
                lint::builtin::MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
                CRATE_NODE_ID, span_use, msg,
                lint::builtin::BuiltinLintDiagnostics::
                    MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def),
            );
4646 4647
        }

4648 4649 4650
        for &AmbiguityError { ident, b1, b2 } in &self.ambiguity_errors {
            if reported_spans.insert(ident.span) {
                self.report_ambiguity_error(ident, b1, b2);
4651
            }
4652 4653
        }

4654 4655
        for &PrivacyError(span, name, binding) in &self.privacy_errors {
            if !reported_spans.insert(span) { continue }
G
Guillaume Gomez 已提交
4656
            span_err!(self.session, span, E0603, "{} `{}` is private", binding.descr(), name);
4657 4658
        }
    }
4659

4660 4661
    fn report_with_use_injections(&mut self, krate: &Crate) {
        for UseError { mut err, candidates, node_id, better } in self.use_injections.drain(..) {
4662
            let (span, found_use) = UsePlacementFinder::check(krate, node_id);
4663
            if !candidates.is_empty() {
4664
                show_candidates(&mut err, span, &candidates, better, found_use);
4665 4666 4667 4668 4669
            }
            err.emit();
        }
    }

C
Cldfire 已提交
4670
    fn report_conflict<'b>(&mut self,
4671
                       parent: Module,
4672
                       ident: Ident,
4673
                       ns: Namespace,
C
Cldfire 已提交
4674 4675
                       new_binding: &NameBinding<'b>,
                       old_binding: &NameBinding<'b>) {
4676
        // Error on the second of two conflicting names
4677
        if old_binding.span.lo() > new_binding.span.lo() {
4678
            return self.report_conflict(parent, ident, ns, old_binding, new_binding);
4679 4680
        }

J
Jeffrey Seyfried 已提交
4681 4682 4683 4684
        let container = match parent.kind {
            ModuleKind::Def(Def::Mod(_), _) => "module",
            ModuleKind::Def(Def::Trait(_), _) => "trait",
            ModuleKind::Block(..) => "block",
4685 4686 4687
            _ => "enum",
        };

4688 4689 4690
        let old_noun = match old_binding.is_import() {
            true => "import",
            false => "definition",
4691 4692
        };

4693 4694 4695 4696 4697
        let new_participle = match new_binding.is_import() {
            true => "imported",
            false => "defined",
        };

D
Donato Sciarra 已提交
4698
        let (name, span) = (ident.name, self.session.source_map().def_span(new_binding.span));
4699 4700 4701 4702 4703 4704 4705

        if let Some(s) = self.name_already_seen.get(&name) {
            if s == &span {
                return;
            }
        }

4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717
        let old_kind = match (ns, old_binding.module()) {
            (ValueNS, _) => "value",
            (MacroNS, _) => "macro",
            (TypeNS, _) if old_binding.is_extern_crate() => "extern crate",
            (TypeNS, Some(module)) if module.is_normal() => "module",
            (TypeNS, Some(module)) if module.is_trait() => "trait",
            (TypeNS, _) => "type",
        };

        let msg = format!("the name `{}` is defined multiple times", name);

        let mut err = match (old_binding.is_extern_crate(), new_binding.is_extern_crate()) {
4718
            (true, true) => struct_span_err!(self.session, span, E0259, "{}", msg),
4719
            (true, _) | (_, true) => match new_binding.is_import() && old_binding.is_import() {
4720 4721
                true => struct_span_err!(self.session, span, E0254, "{}", msg),
                false => struct_span_err!(self.session, span, E0260, "{}", msg),
M
Mohit Agarwal 已提交
4722
            },
4723
            _ => match (old_binding.is_import(), new_binding.is_import()) {
4724 4725 4726
                (false, false) => struct_span_err!(self.session, span, E0428, "{}", msg),
                (true, true) => struct_span_err!(self.session, span, E0252, "{}", msg),
                _ => struct_span_err!(self.session, span, E0255, "{}", msg),
4727 4728 4729
            },
        };

4730 4731
        err.note(&format!("`{}` must be defined only once in the {} namespace of this {}",
                          name,
4732
                          ns.descr(),
4733 4734 4735
                          container));

        err.span_label(span, format!("`{}` re{} here", name, new_participle));
V
Vadim Petrochenkov 已提交
4736
        if !old_binding.span.is_dummy() {
D
Donato Sciarra 已提交
4737
            err.span_label(self.session.source_map().def_span(old_binding.span),
4738
                           format!("previous {} of the {} `{}` here", old_noun, old_kind, name));
4739
        }
4740

C
Cldfire 已提交
4741 4742
        // See https://github.com/rust-lang/rust/issues/32354
        if old_binding.is_import() || new_binding.is_import() {
V
Vadim Petrochenkov 已提交
4743
            let binding = if new_binding.is_import() && !new_binding.span.is_dummy() {
C
Cldfire 已提交
4744 4745 4746 4747 4748
                new_binding
            } else {
                old_binding
            };

D
Donato Sciarra 已提交
4749
            let cm = self.session.source_map();
C
Cldfire 已提交
4750 4751
            let rename_msg = "You can use `as` to change the binding name of the import";

4752 4753
            if let (Ok(snippet), false) = (cm.span_to_snippet(binding.span),
                                           binding.is_renamed_extern_crate()) {
4754 4755 4756 4757 4758 4759
                let suggested_name = if name.as_str().chars().next().unwrap().is_uppercase() {
                    format!("Other{}", name)
                } else {
                    format!("other_{}", name)
                };

4760 4761 4762 4763 4764 4765 4766 4767 4768 4769
                err.span_suggestion_with_applicability(
                    binding.span,
                    rename_msg,
                    if snippet.ends_with(';') {
                        format!("{} as {};", &snippet[..snippet.len() - 1], suggested_name)
                    } else {
                        format!("{} as {}", snippet, suggested_name)
                    },
                    Applicability::MachineApplicable,
                );
C
Cldfire 已提交
4770 4771 4772 4773 4774
            } else {
                err.span_label(binding.span, rename_msg);
            }
        }

4775
        err.emit();
4776
        self.name_already_seen.insert(name, span);
4777 4778
    }
}
4779

V
Vadim Petrochenkov 已提交
4780 4781
fn is_self_type(path: &[Ident], namespace: Namespace) -> bool {
    namespace == TypeNS && path.len() == 1 && path[0].name == keywords::SelfType.name()
4782 4783
}

V
Vadim Petrochenkov 已提交
4784 4785
fn is_self_value(path: &[Ident], namespace: Namespace) -> bool {
    namespace == ValueNS && path.len() == 1 && path[0].name == keywords::SelfValue.name()
4786 4787
}

V
Vadim Petrochenkov 已提交
4788
fn names_to_string(idents: &[Ident]) -> String {
4789
    let mut result = String::new();
4790
    for (i, ident) in idents.iter()
V
Vadim Petrochenkov 已提交
4791
                            .filter(|ident| ident.name != keywords::CrateRoot.name())
4792
                            .enumerate() {
4793 4794 4795
        if i > 0 {
            result.push_str("::");
        }
V
Vadim Petrochenkov 已提交
4796
        result.push_str(&ident.as_str());
C
corentih 已提交
4797
    }
4798 4799 4800
    result
}

4801
fn path_names_to_string(path: &Path) -> String {
4802
    names_to_string(&path.segments.iter()
V
Vadim Petrochenkov 已提交
4803
                        .map(|seg| seg.ident)
4804
                        .collect::<Vec<_>>())
4805 4806
}

4807
/// Get the path for an enum and the variant from an `ImportSuggestion` for an enum variant.
E
Esteban Küber 已提交
4808
fn import_candidate_to_paths(suggestion: &ImportSuggestion) -> (Span, String, String) {
4809 4810 4811 4812 4813 4814 4815 4816 4817 4818
    let variant_path = &suggestion.path;
    let variant_path_string = path_names_to_string(variant_path);

    let path_len = suggestion.path.segments.len();
    let enum_path = ast::Path {
        span: suggestion.path.span,
        segments: suggestion.path.segments[0..path_len - 1].to_vec(),
    };
    let enum_path_string = path_names_to_string(&enum_path);

E
Esteban Küber 已提交
4819
    (suggestion.path.span, variant_path_string, enum_path_string)
4820 4821 4822
}


4823 4824 4825
/// When an entity with a given name is not available in scope, we search for
/// entities with that name in all crates. This method allows outputting the
/// results of this search in a programmer-friendly way
4826
fn show_candidates(err: &mut DiagnosticBuilder,
4827 4828
                   // This is `None` if all placement locations are inside expansions
                   span: Option<Span>,
4829
                   candidates: &[ImportSuggestion],
4830 4831
                   better: bool,
                   found_use: bool) {
4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842

    // we want consistent results across executions, but candidates are produced
    // by iterating through a hash map, so make sure they are ordered:
    let mut path_strings: Vec<_> =
        candidates.into_iter().map(|c| path_names_to_string(&c.path)).collect();
    path_strings.sort();

    let better = if better { "better " } else { "" };
    let msg_diff = match path_strings.len() {
        1 => " is found in another module, you can import it",
        _ => "s are found in other modules, you can import them",
4843
    };
4844 4845
    let msg = format!("possible {}candidate{} into scope", better, msg_diff);

4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856
    if let Some(span) = span {
        for candidate in &mut path_strings {
            // produce an additional newline to separate the new use statement
            // from the directly following item.
            let additional_newline = if found_use {
                ""
            } else {
                "\n"
            };
            *candidate = format!("use {};\n{}", candidate, additional_newline);
        }
4857

V
Vitaly _Vi Shukela 已提交
4858 4859 4860 4861 4862 4863
        err.span_suggestions_with_applicability(
            span,
            &msg,
            path_strings,
            Applicability::Unspecified,
        );
4864 4865 4866 4867 4868 4869 4870 4871
    } else {
        let mut msg = msg;
        msg.push(':');
        for candidate in path_strings {
            msg.push('\n');
            msg.push_str(&candidate);
        }
    }
4872 4873
}

4874
/// A somewhat inefficient routine to obtain the name of a module.
4875
fn module_to_string(module: Module) -> Option<String> {
4876 4877
    let mut names = Vec::new();

4878
    fn collect_mod(names: &mut Vec<Ident>, module: Module) {
J
Jeffrey Seyfried 已提交
4879 4880
        if let ModuleKind::Def(_, name) = module.kind {
            if let Some(parent) = module.parent {
4881
                names.push(Ident::with_empty_ctxt(name));
J
Jeffrey Seyfried 已提交
4882
                collect_mod(names, parent);
4883
            }
J
Jeffrey Seyfried 已提交
4884 4885
        } else {
            // danger, shouldn't be ident?
4886
            names.push(Ident::from_str("<opaque>"));
J
Jeffrey Seyfried 已提交
4887
            collect_mod(names, module.parent.unwrap());
4888 4889 4890 4891
        }
    }
    collect_mod(&mut names, module);

4892
    if names.is_empty() {
4893
        return None;
4894
    }
4895
    Some(names_to_string(&names.into_iter()
4896
                        .rev()
4897
                        .collect::<Vec<_>>()))
4898 4899
}

4900
fn err_path_resolution() -> PathResolution {
4901
    PathResolution::new(Def::Err)
4902 4903
}

N
Niko Matsakis 已提交
4904
#[derive(PartialEq,Copy, Clone)]
4905 4906
pub enum MakeGlobMap {
    Yes,
C
corentih 已提交
4907
    No,
4908 4909
}

4910
#[derive(Copy, Clone, Debug)]
4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923
enum CrateLint {
    /// Do not issue the lint
    No,

    /// This lint applies to some random path like `impl ::foo::Bar`
    /// or whatever. In this case, we can take the span of that path.
    SimplePath(NodeId),

    /// This lint comes from a `use` statement. In this case, what we
    /// care about really is the *root* `use` statement; e.g., if we
    /// have nested things like `use a::{b, c}`, we care about the
    /// `use a` part.
    UsePath { root_id: NodeId, root_span: Span },
4924 4925 4926 4927 4928

    /// This is the "trait item" from a fully qualified path. For example,
    /// we might be resolving  `X::Y::Z` from a path like `<T as X::Y>::Z`.
    /// The `path_span` is the span of the to the trait itself (`X::Y`).
    QPathTrait { qpath_id: NodeId, qpath_span: Span },
4929 4930
}

4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941
impl CrateLint {
    fn node_id(&self) -> Option<NodeId> {
        match *self {
            CrateLint::No => None,
            CrateLint::SimplePath(id) |
            CrateLint::UsePath { root_id: id, .. } |
            CrateLint::QPathTrait { qpath_id: id, .. } => Some(id),
        }
    }
}

4942
__build_diagnostic_array! { librustc_resolve, DIAGNOSTICS }