Address review comments: Remove new PathResult variant

Author: estebank

src/librustc_resolve/lib.rs

@@ -1034,8 +1034,6 @@ enum PathResult<'a> {
     NonModule(PathResolution),
     Indeterminate,
     Failed(Span, String, bool /* is the error from the last segment? */),
-    /// Encountered an error that is reported elsewhere
-    Ignore,
 }
 
 enum ModuleKind {
@@ -1768,7 +1766,6 @@ impl<'a> Resolver<'a> {
                 error_callback(self, span, ResolutionError::FailedToResolve(&msg));
                 Def::Err
             }
-            PathResult::Ignore => Def::Err,
         };
 
         let segments: Vec<_> = segments.iter().map(|seg| {
@@ -3696,7 +3693,7 @@ impl<'a> Resolver<'a> {
                 resolve_error(self, span, ResolutionError::FailedToResolve(&msg));
                 err_path_resolution()
             }
-            PathResult::Module(..) | PathResult::Failed(..) | PathResult::Ignore => return None,
+            PathResult::Module(..) | PathResult::Failed(..) => return None,
             PathResult::Indeterminate => bug!("indetermined path result in resolve_qpath"),
         };
 
@@ -3928,11 +3925,11 @@ impl<'a> Resolver<'a> {
                         });
                         if let Some(candidate) = candidates.get(0) {
                             format!("did you mean `{}`?", candidate.path)
-                        } else if !ident.is_used_keyword() {
+                        } else if !ident.is_reserved() {
                             format!("maybe a missing `extern crate {};`?", ident)
                         } else {
                             // the parser will already have complained about the keyword being used
-                            return PathResult::Ignore;
+                            return PathResult::NonModule(err_path_resolution());
                         }
                     } else if i == 0 {
                         format!("use of undeclared type or module `{}`", ident)

src/librustc_resolve/macros.rs

@@ -364,8 +364,7 @@ impl<'a> Resolver<'a> {
                     Ok(path_res.base_def())
                 }
                 PathResult::Indeterminate if !force => return Err(Determinacy::Undetermined),
-                PathResult::NonModule(..) | PathResult::Indeterminate |
-                PathResult::Failed(..) | PathResult::Ignore => {
+                PathResult::NonModule(..) | PathResult::Indeterminate | PathResult::Failed(..) => {
                     Err(Determinacy::Determined)
                 }
                 PathResult::Module(..) => unreachable!(),
@@ -930,8 +929,7 @@ impl<'a> Resolver<'a> {
                     let def = path_res.base_def();
                     check_consistency(self, &path, path_span, kind, initial_def, def);
                 }
-                path_res @ PathResult::NonModule(..) | path_res @ PathResult::Failed(..) |
-                path_res @ PathResult::Ignore => {
+                path_res @ PathResult::NonModule(..) | path_res @ PathResult::Failed(..) => {
                     let (span, msg) = if let PathResult::Failed(span, msg, ..) = path_res {
                         (span, msg)
                     } else {

src/librustc_resolve/resolve_imports.rs

@@ -767,8 +767,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
             match path_res {
                 PathResult::Module(module) => module,
                 PathResult::Indeterminate => return false,
-                PathResult::NonModule(..) | PathResult::Failed(..) |
-                PathResult::Ignore => return true,
+                PathResult::NonModule(..) | PathResult::Failed(..) => return true,
             }
         };
 
@@ -862,9 +861,6 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
 
                 module
             }
-            PathResult::Ignore => {
-                return None;
-            }
             PathResult::Failed(span, msg, false) => {
                 if no_ambiguity {
                     assert!(directive.imported_module.get().is_none());