Resolve lang items in ast

Author: camsteffen

Cargo.lock

@@ -4064,6 +4064,7 @@ dependencies = [
  "rustc_feature",
  "rustc_hir",
  "rustc_index",
+ "rustc_macros",
  "rustc_metadata",
  "rustc_middle",
  "rustc_query_system",

compiler/rustc_ast/src/ast.rs

@@ -2882,7 +2882,7 @@ impl ItemKind {
         }
     }
 
-    pub fn descr(&self) -> &str {
+    pub fn descr(&self) -> &'static str {
         match self {
             ItemKind::ExternCrate(..) => "extern crate",
             ItemKind::Use(..) => "`use` import",
@@ -2952,6 +2952,15 @@ impl AssocItemKind {
             Self::MacCall(..) => Defaultness::Final,
         }
     }
+
+    pub fn generics(&self) -> Option<&Generics> {
+        match self {
+            Self::Const(..) => None,
+            Self::Fn(f) => Some(&f.generics),
+            Self::Type(t) => Some(&t.generics),
+            Self::MacCall(_) => None,
+        }
+    }
 }
 
 impl From<AssocItemKind> for ItemKind {

compiler/rustc_error_messages/locales/en-US/passes.ftl

@@ -361,9 +361,6 @@ passes_deprecated_annotation_has_no_effect =
     this `#[deprecated]` annotation has no effect
     .suggestion = remove the unnecessary deprecation attribute
 
-passes_unknown_external_lang_item =
-    unknown external lang item: `{$lang_item}`
-
 passes_missing_panic_handler =
     `#[panic_handler]` function required, but not found
 
@@ -372,14 +369,6 @@ passes_missing_lang_item =
     .note = this can occur when a binary crate with `#![no_std]` is compiled for a target where `{$name}` is defined in the standard library
     .help = you may be able to compile for a target that doesn't need `{$name}`, specify a target with `--target` or in `.cargo/config`
 
-passes_lang_item_on_incorrect_target =
-    `{$name}` language item must be applied to a {$expected_target}
-    .label = attribute should be applied to a {$expected_target}, not a {$actual_target}
-
-passes_unknown_lang_item =
-    definition of an unknown language item: `{$name}`
-    .label = definition of unknown language item `{$name}`
-
 passes_invalid_attr_at_crate_level =
     `{$name}` attribute cannot be used at crate level
     .suggestion = perhaps you meant to use an outer attribute
@@ -559,19 +548,6 @@ passes_duplicate_lang_item_crate_depends =
     .first_definition_path = first definition in `{$orig_crate_name}` loaded from {$orig_path}
     .second_definition_path = second definition in `{$crate_name}` loaded from {$path}
 
-passes_incorrect_target =
-    `{$name}` language item must be applied to a {$kind} with {$at_least ->
-        [true] at least {$num}
-        *[false] {$num}
-    } generic {$num ->
-        [one] argument
-        *[other] arguments
-    }
-    .label = this {$kind} has {$actual_num} generic {$actual_num ->
-        [one] argument
-        *[other] arguments
-    }
-
 passes_useless_assignment =
     useless assignment of {$is_field_assign ->
         [true] field

compiler/rustc_error_messages/locales/en-US/resolve.ftl

@@ -0,0 +1,23 @@
+resolve_lang_item_on_incorrect_target =
+    `{$name}` language item must be applied to a {$expected_target}
+    .label = attribute should be applied to a {$expected_target}, not a {$actual_target}
+
+resolve_unknown_external_lang_item =
+    unknown external lang item: `{$lang_item}`
+
+resolve_unknown_lang_item =
+    definition of an unknown language item: `{$name}`
+    .label = definition of unknown language item `{$name}`
+
+resolve_incorrect_target =
+    `{$name}` language item must be applied to a {$kind} with {$at_least ->
+        [true] at least {$num}
+        *[false] {$num}
+    } generic {$num ->
+        [one] argument
+        *[other] arguments
+    }
+    .label = this {$kind} has {$actual_num} generic {$actual_num ->
+        [one] argument
+        *[other] arguments
+    }

compiler/rustc_error_messages/src/lib.rs

@@ -61,6 +61,7 @@ fluent_messages! {
     plugin_impl => "../locales/en-US/plugin_impl.ftl",
     privacy => "../locales/en-US/privacy.ftl",
     query_system => "../locales/en-US/query_system.ftl",
+    resolve => "../locales/en-US/resolve.ftl",
     save_analysis => "../locales/en-US/save_analysis.ftl",
     session => "../locales/en-US/session.ftl",
     symbol_mangling => "../locales/en-US/symbol_mangling.ftl",

compiler/rustc_hir/src/target.rs

@@ -4,6 +4,9 @@
 //! conflicts between multiple such attributes attached to the same
 //! item.
 
+use rustc_ast as ast;
+use rustc_ast::visit as ast_visit;
+
 use crate::hir;
 use crate::{Item, ItemKind, TraitItem, TraitItemKind};
 
@@ -198,4 +201,41 @@ impl Target {
             Target::ExprField => "struct field",
         }
     }
+
+    pub fn from_ast_item(item: &ast::Item) -> Target {
+        match item.kind {
+            ast::ItemKind::ExternCrate(_) => Target::ExternCrate,
+            ast::ItemKind::Use(_) => Target::Use,
+            ast::ItemKind::Static(..) => Target::Static,
+            ast::ItemKind::Const(..) => Target::Const,
+            ast::ItemKind::Fn(_) => Target::Fn,
+            ast::ItemKind::Mod(..) => Target::Mod,
+            ast::ItemKind::ForeignMod(_) => Target::ForeignMod,
+            ast::ItemKind::GlobalAsm(_) => Target::GlobalAsm,
+            ast::ItemKind::TyAlias(_) => Target::TyAlias,
+            ast::ItemKind::Enum(..) => Target::Enum,
+            ast::ItemKind::Struct(..) => Target::Struct,
+            ast::ItemKind::Union(..) => Target::Union,
+            ast::ItemKind::Trait(_) => Target::Trait,
+            ast::ItemKind::TraitAlias(..) => Target::TraitAlias,
+            ast::ItemKind::Impl(_) => Target::Impl,
+            ast::ItemKind::MacroDef(_) => Target::MacroDef,
+            ast::ItemKind::MacCall(_) => panic!("unexpected MacCall"),
+        }
+    }
+
+    pub fn from_ast_assoc_item(kind: &ast::AssocItemKind, ctxt: ast_visit::AssocCtxt) -> Target {
+        match kind {
+            ast::AssocItemKind::Const(..) => Target::AssocConst,
+            ast::AssocItemKind::Fn(f) => {
+                let kind = match ctxt {
+                    ast_visit::AssocCtxt::Impl => MethodKind::Inherent,
+                    ast_visit::AssocCtxt::Trait => MethodKind::Trait { body: f.body.is_some() },
+                };
+                Target::Method(kind)
+            }
+            ast::AssocItemKind::Type(_) => Target::AssocTy,
+            ast::AssocItemKind::MacCall(_) => panic!("unexpected MacCall"),
+        }
+    }
 }

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -15,6 +15,7 @@ use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
 use rustc_hir::definitions::{DefKey, DefPath, DefPathData, DefPathHash};
 use rustc_hir::diagnostic_items::DiagnosticItems;
+use rustc_hir::LangItem;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_middle::metadata::ModChild;
 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1908,10 +1908,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
     fn encode_lang_items(&mut self) -> LazyArray<(DefIndex, LangItem)> {
         empty_proc_macro!(self);
-        let lang_items = self.tcx.lang_items().iter();
-        self.lazy_array(lang_items.filter_map(|(lang_item, def_id)| {
-            def_id.as_local().map(|id| (id.local_def_index, lang_item))
-        }))
+        let lang_items = self.tcx.resolutions(()).lang_items.iter();
+        self.lazy_array(lang_items.map(|&(def_id, lang_item)| (def_id.local_def_index, lang_item)))
     }
 
     fn encode_lang_items_missing(&mut self) -> LazyArray<LangItem> {

compiler/rustc_middle/src/ty/mod.rs

@@ -39,7 +39,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, LifetimeRes, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LocalDefIdMap};
 use rustc_hir::definitions::Definitions;
-use rustc_hir::Node;
+use rustc_hir::{LangItem, Node};
 use rustc_index::vec::IndexVec;
 use rustc_macros::HashStable;
 use rustc_query_system::ich::StableHashingContext;
@@ -178,6 +178,8 @@ pub struct ResolverGlobalCtxt {
     /// exist under `std`. For example, wrote `str::from_utf8` instead of `std::str::from_utf8`.
     pub confused_type_with_std_module: FxHashMap<Span, Span>,
     pub registered_tools: RegisteredTools,
+    pub lang_items: Vec<(LocalDefId, LangItem)>,
+    pub missing_lang_items: Vec<LangItem>,
 }
 
 /// Resolutions that should only be used for lowering.

compiler/rustc_passes/src/errors.rs

@@ -5,7 +5,7 @@ use std::{
 
 use rustc_ast::Label;
 use rustc_errors::{error_code, Applicability, ErrorGuaranteed, IntoDiagnostic, MultiSpan};
-use rustc_hir::{self as hir, ExprKind, Target};
+use rustc_hir::{self as hir, ExprKind};
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::ty::{MainDefinition, Ty};
 use rustc_span::{Span, Symbol, DUMMY_SP};
@@ -689,14 +689,6 @@ pub struct DeprecatedAnnotationHasNoEffect {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_unknown_external_lang_item, code = "E0264")]
-pub struct UnknownExternLangItem {
-    #[primary_span]
-    pub span: Span,
-    pub lang_item: Symbol,
-}
-
 #[derive(Diagnostic)]
 #[diag(passes_missing_panic_handler)]
 pub struct MissingPanicHandler;
@@ -709,26 +701,6 @@ pub struct MissingLangItem {
     pub name: Symbol,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_lang_item_on_incorrect_target, code = "E0718")]
-pub struct LangItemOnIncorrectTarget {
-    #[primary_span]
-    #[label]
-    pub span: Span,
-    pub name: Symbol,
-    pub expected_target: Target,
-    pub actual_target: Target,
-}
-
-#[derive(Diagnostic)]
-#[diag(passes_unknown_lang_item, code = "E0522")]
-pub struct UnknownLangItem {
-    #[primary_span]
-    #[label]
-    pub span: Span,
-    pub name: Symbol,
-}
-
 pub struct InvalidAttrAtCrateLevel {
     pub span: Span,
     pub snippet: Option<String>,
@@ -1238,20 +1210,6 @@ impl IntoDiagnostic<'_> for DuplicateLangItem {
     }
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_incorrect_target, code = "E0718")]
-pub struct IncorrectTarget<'a> {
-    #[primary_span]
-    pub span: Span,
-    #[label]
-    pub generics_span: Span,
-    pub name: &'a str, // cannot be symbol because it renders e.g. `r#fn` instead of `fn`
-    pub kind: &'static str,
-    pub num: usize,
-    pub actual_num: usize,
-    pub at_least: bool,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(passes_useless_assignment)]
 pub struct UselessAssignment<'a> {