bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

passes: migrate half of check_attr

Browse source 
Migrate half of the `rustc_passes::check_attr` diagnostics to using
diagnostic derives and being translatable.
This commit is contained in:
David Wood 2022-07-11 18:59:04 +01:00
parent 81cf2294b4
commit 78b19a90b7
27 changed files with 844 additions and 524 deletions
Download patch file Download diff file Expand all files Collapse all files

151
compiler/rustc_error_messages/locales/en-US/passes.ftl Normal file
View file

@ -0,0 +1,151 @@
-passes-previously-accepted =
this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-passes-see-issue =
see issue #{$issue} <https://github.com/rust-lang/rust/issues/{$issue}> for more information
passes-outer-crate-level-attr =
crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
passes-inner-crate-level-attr =
crate-level attribute should be in the root module
passes-ignored-attr-with-macro = `#[{$sym}]` is ignored on struct fields, match arms and macro defs
.warn = {-passes-previously-accepted}
.note = {-passes-see-issue(issue: "80564")}
passes-ignored-attr = `#[{$sym}]` is ignored on struct fields and match arms
.warn = {-passes-previously-accepted}
.note = {-passes-see-issue(issue: "80564")}
passes-inline-ignored-function-prototype = `#[inline]` is ignored on function prototypes
passes-inline-ignored-constants = `#[inline]` is ignored on constants
.warn = {-passes-previously-accepted}
.note = {-passes-see-issue(issue: "65833")}
passes-inline-not-fn-or-closure = attribute should be applied to function or closure
.label = not a function or closure
passes-no-coverage-ignored-function-prototype = `#[no_coverage]` is ignored on function prototypes
passes-no-coverage-propagate =
`#[no_coverage]` does not propagate into items and must be applied to the contained functions directly
passes-no-coverage-fn-defn = `#[no_coverage]` may only be applied to function definitions
passes-no-coverage-not-coverable = `#[no_coverage]` must be applied to coverable code
.label = not coverable code
passes-should-be-applied-to-fn = attribute should be applied to a function definition
.label = not a function definition
passes-naked-tracked-caller = cannot use `#[track_caller]` with `#[naked]`
passes-should-be-applied-to-struct-enum = attribute should be applied to a struct or enum
.label = not a struct or enum
passes-should-be-applied-to-trait = attribute should be applied to a trait
.label = not a trait
passes-target-feature-on-statement = {passes-should-be-applied-to-fn}
.warn = {-passes-previously-accepted}
.label = {passes-should-be-applied-to-fn.label}
passes-should-be-applied-to-static = attribute should be applied to a static
.label = not a static
passes-doc-expect-str = doc {$attr_name} attribute expects a string: #[doc({$attr_name} = "a")]
passes-doc-alias-empty = {$attr_str} attribute cannot have empty value
passes-doc-alias-bad-char = {$char_} character isn't allowed in {$attr_str}
passes-doc-alias-start-end = {$attr_str} cannot start or end with ' '
passes-doc-alias-bad-location = {$attr_str} isn't allowed on {$location}
passes-doc-alias-not-an-alias = {$attr_str} is the same as the item's name
passes-doc-alias-duplicated = doc alias is duplicated
.label = first defined here
passes-doc-alias-not-string-literal = `#[doc(alias("a"))]` expects string literals
passes-doc-alias-malformed =
doc alias attribute expects a string `#[doc(alias = "a")]` or a list of strings `#[doc(alias("a", "b"))]`
passes-doc-keyword-empty-mod = `#[doc(keyword = "...")]` should be used on empty modules
passes-doc-keyword-not-mod = `#[doc(keyword = "...")]` should be used on modules
passes-doc-keyword-invalid-ident = `{$doc_keyword}` is not a valid identifier
passes-doc-tuple-variadic-not-first =
`#[doc(tuple_variadic)]` must be used on the first of a set of tuple trait impls with varying arity
passes-doc-keyword-only-impl = `#[doc(keyword = "...")]` should be used on impl blocks
passes-doc-inline-conflict-first = this attribute...
passes-doc-inline-conflict-second = ...conflicts with this attribute
passes-doc-inline-conflict = conflicting doc inlining attributes
.help = remove one of the conflicting attributes
passes-doc-inline-only-use = this attribute can only be applied to a `use` item
.label = only applicable on `use` items
.not-a-use-item-label = not a `use` item
.note = read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#inline-and-no_inline> for more information
passes-doc-attr-not-crate-level =
`#![doc({$attr_name} = "...")]` isn't allowed as a crate-level attribute
passes-attr-crate-level = this attribute can only be applied at the crate level
.suggestion = to apply to the crate, use an inner attribute
.help = to apply to the crate, use an inner attribute
.note = read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#at-the-crate-level> for more information
passes-doc-test-unknown = unknown `doc(test)` attribute `{$path}`
passes-doc-test-takes-list = `#[doc(test(...)]` takes a list of attributes
passes-doc-primitive = `doc(primitive)` should never have been stable
passes-doc-test-unknown-any = unknown `doc` attribute `{$path}`
passes-doc-test-unknown-spotlight = unknown `doc` attribute `{$path}`
.note = `doc(spotlight)` was renamed to `doc(notable_trait)`
.suggestion = use `notable_trait` instead
.no-op-note = `doc(spotlight)` is now a no-op
passes-doc-test-unknown-include = unknown `doc` attribute `{$path}`
.suggestion = use `doc = include_str!` instead
passes-doc-invalid = invalid `doc` attribute
passes-pass-by-value = `pass_by_value` attribute should be applied to a struct, enum or type alias
.label = is not a struct, enum or type alias
passes-allow-incoherent-impl =
`rustc_allow_incoherent_impl` attribute should be applied to impl items.
.label = the only currently supported targets are inherent methods
passes-has-incoherent-inherent-impl =
`rustc_has_incoherent_inherent_impls` attribute should be applied to types or traits.
.label = only adts, extern types and traits are supported
passes-must-use-async =
`must_use` attribute on `async` functions applies to the anonymous `Future` returned by the function, not the value within
.label = this attribute does nothing, the `Future`s returned by async functions are already `must_use`
passes-must-use-no-effect = `#[must_use]` has no effect when applied to {$article} {$target}
passes-must-not-suspend = `must_not_suspend` attribute should be applied to a struct, enum, or trait
.label = is not a struct, enum, or trait
passes-cold = {passes-should-be-applied-to-fn}
.warn = {-passes-previously-accepted}
.label = {passes-should-be-applied-to-fn.label}
passes-link = attribute should be applied to an `extern` block with non-Rust ABI
.warn = {-passes-previously-accepted}
.label = not an `extern` block

1
compiler/rustc_error_messages/src/lib.rs
View file

@ -37,6 +37,7 @@ fluent_messages! {
expand => "../locales/en-US/expand.ftl",
lint => "../locales/en-US/lint.ftl",
parser => "../locales/en-US/parser.ftl",
passes => "../locales/en-US/passes.ftl",
privacy => "../locales/en-US/privacy.ftl",
typeck => "../locales/en-US/typeck.ftl",
}

1
compiler/rustc_errors/src/diagnostic.rs
View file

@ -64,6 +64,7 @@ into_diagnostic_arg_using_display!(
i128,
u128,
std::num::NonZeroU32,
hir::Target,
Edition,
Ident,
);

1
compiler/rustc_passes/Cargo.toml
View file

@ -15,6 +15,7 @@ rustc_hir = { path = "../rustc_hir" }
rustc_index = { path = "../rustc_index" }
rustc_session = { path = "../rustc_session" }
rustc_target = { path = "../rustc_target" }
rustc_macros = { path = "../rustc_macros" }
rustc_ast = { path = "../rustc_ast" }
rustc_serialize = { path = "../rustc_serialize" }
rustc_span = { path = "../rustc_span" }

690
compiler/rustc_passes/src/check_attr.rs
View file

@ -4,9 +4,10 @@
//! conflicts between multiple such attributes attached to the same
//! item.
use crate::errors;
use rustc_ast::{ast, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
use rustc_data_structures::fx::FxHashMap;
use rustc_errors::{pluralize, struct_span_err, Applicability, MultiSpan};
use rustc_errors::{fluent, pluralize, struct_span_err, Applicability, MultiSpan};
use rustc_expand::base::resolve_path;
use rustc_feature::{AttributeDuplicates, AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
use rustc_hir as hir;
@ -175,16 +176,20 @@ impl CheckAttrVisitor<'_> {
if let Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) =
attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name))
{
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
let msg = match attr.style {
ast::AttrStyle::Outer => {
"crate-level attribute should be an inner attribute: add an exclamation \
mark: `#![foo]`"
}
ast::AttrStyle::Inner => "crate-level attribute should be in the root module",
};
lint.build(msg).emit();
});
match attr.style {
ast::AttrStyle::Outer => self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::OuterCrateLevelAttr,
),
ast::AttrStyle::Inner => self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::InnerCrateLevelAttr,
),
}
}
}
@ -209,37 +214,21 @@ impl CheckAttrVisitor<'_> {
}
fn inline_attr_str_error_with_macro_def(&self, hir_id: HirId, attr: &Attribute, sym: &str) {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build(&format!(
"`#[{sym}]` is ignored on struct fields, match arms and macro defs",
))
.warn(
"this was previously accepted by the compiler but is \
being phased out; it will become a hard error in \
a future release!",
)
.note(
"see issue #80564 <https://github.com/rust-lang/rust/issues/80564> \
for more information",
)
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::IgnoredAttrWithMacro { sym },
);
}
fn inline_attr_str_error_without_macro_def(&self, hir_id: HirId, attr: &Attribute, sym: &str) {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build(&format!("`#[{sym}]` is ignored on struct fields and match arms"))
.warn(
"this was previously accepted by the compiler but is \
being phased out; it will become a hard error in \
a future release!",
)
.note(
"see issue #80564 <https://github.com/rust-lang/rust/issues/80564> \
for more information",
)
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::IgnoredAttr { sym },
);
}
/// Checks if an `#[inline]` is applied to a function or a closure. Returns `true` if valid.
@ -249,9 +238,12 @@ impl CheckAttrVisitor<'_> {
| Target::Closure
| Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
Target::Method(MethodKind::Trait { body: false }) | Target::ForeignFn => {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build("`#[inline]` is ignored on function prototypes").emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::IgnoredInlineAttrFnProto,
);
true
}
// FIXME(#65833): We permit associated consts to have an `#[inline]` attribute with
@ -259,19 +251,12 @@ impl CheckAttrVisitor<'_> {
// accidentally, to to be compatible with crates depending on them, we can't throw an
// error here.
Target::AssocConst => {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build("`#[inline]` is ignored on constants")
.warn(
"this was previously accepted by the compiler but is \
being phased out; it will become a hard error in \
a future release!",
)
.note(
"see issue #65833 <https://github.com/rust-lang/rust/issues/65833> \
for more information",
)
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::IgnoredInlineAttrConstants,
);
true
}
// FIXME(#80564): Same for fields, arms, and macro defs
@ -280,14 +265,10 @@ impl CheckAttrVisitor<'_> {
true
}
_ => {
struct_span_err!(
self.tcx.sess,
attr.span,
E0518,
"attribute should be applied to function or closure",
)
.span_label(span, "not a function or closure")
.emit();
self.tcx.sess.emit_err(errors::InlineNotFnOrClosure {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -309,36 +290,40 @@ impl CheckAttrVisitor<'_> {
// function prototypes can't be covered
Target::Method(MethodKind::Trait { body: false }) | Target::ForeignFn => {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build("`#[no_coverage]` is ignored on function prototypes").emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::IgnoredNoCoverageFnProto,
);
true
}
Target::Mod | Target::ForeignMod | Target::Impl | Target::Trait => {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build("`#[no_coverage]` does not propagate into items and must be applied to the contained functions directly").emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::IgnoredNoCoveragePropagate,
);
true
}
Target::Expression | Target::Statement | Target::Arm => {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build("`#[no_coverage]` may only be applied to function definitions")
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::IgnoredNoCoverageFnDefn,
);
true
}
_ => {
struct_span_err!(
self.tcx.sess,
attr.span,
E0788,
"`#[no_coverage]` must be applied to coverable code",
)
.span_label(span, "not coverable code")
.emit();
self.tcx.sess.emit_err(errors::IgnoredNoCoverageNotCoverable {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -389,14 +374,10 @@ impl CheckAttrVisitor<'_> {
true
}
_ => {
self.tcx
.sess
.struct_span_err(
attr.span,
"attribute should be applied to a function definition",
)
.span_label(span, "not a function definition")
.emit();
self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -408,14 +389,10 @@ impl CheckAttrVisitor<'_> {
Target::Fn
| Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
_ => {
self.tcx
.sess
.struct_span_err(
attr.span,
"attribute should be applied to a function definition",
)
.span_label(span, "not a function definition")
.emit();
self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -432,13 +409,7 @@ impl CheckAttrVisitor<'_> {
) -> bool {
match target {
_ if attrs.iter().any(|attr| attr.has_name(sym::naked)) => {
struct_span_err!(
self.tcx.sess,
attr_span,
E0736,
"cannot use `#[track_caller]` with `#[naked]`",
)
.emit();
self.tcx.sess.emit_err(errors::NakedTrackedCaller { attr_span });
false
}
Target::Fn | Target::Method(..) | Target::ForeignFn | Target::Closure => true,
@ -453,14 +424,9 @@ impl CheckAttrVisitor<'_> {
true
}
_ => {
struct_span_err!(
self.tcx.sess,
attr_span,
E0739,
"attribute should be applied to function"
)
.span_label(span, "not a function")
.emit();
self.tcx
.sess
.emit_err(errors::TrackedCallerWrongLocation { attr_span, defn_span: span });
false
}
}
@ -485,14 +451,10 @@ impl CheckAttrVisitor<'_> {
true
}
_ => {
struct_span_err!(
self.tcx.sess,
attr.span,
E0701,
"attribute can only be applied to a struct or enum"
)
.span_label(span, "not a struct or enum")
.emit();
self.tcx.sess.emit_err(errors::NonExhaustiveWrongLocation {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -511,11 +473,10 @@ impl CheckAttrVisitor<'_> {
true
}
_ => {
self.tcx
.sess
.struct_span_err(attr.span, "attribute can only be applied to a trait")
.span_label(span, "not a trait")
.emit();
self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToTrait {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -531,11 +492,10 @@ impl CheckAttrVisitor<'_> {
match target {
Target::Trait => true,
_ => {
self.tcx
.sess
.struct_span_err(attr.span, "attribute can only be applied to a trait")
.span_label(span, "not a trait")
.emit();
self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToTrait {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -555,16 +515,12 @@ impl CheckAttrVisitor<'_> {
// FIXME: #[target_feature] was previously erroneously allowed on statements and some
// crates used this, so only emit a warning.
Target::Statement => {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build("attribute should be applied to a function")
.warn(
"this was previously accepted by the compiler but is \
being phased out; it will become a hard error in \
a future release!",
)
.span_label(span, "not a function")
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::TargetFeatureOnStatement,
);
true
}
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@ -576,11 +532,10 @@ impl CheckAttrVisitor<'_> {
true
}
_ => {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to a function")
.span_label(span, "not a function")
.emit();
self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
attr_span: attr.span,
defn_span: span,
});
false
}
}
@ -591,24 +546,17 @@ impl CheckAttrVisitor<'_> {
match target {
Target::ForeignStatic | Target::Static => true,
_ => {
self.tcx
.sess
.struct_span_err(attr.span, "attribute should be applied to a static")
.span_label(span, "not a static")
.emit();
self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToStatic {
attr_span: attr.span,
defn_span: span,
});
false
}
}
}
fn doc_attr_str_error(&self, meta: &NestedMetaItem, attr_name: &str) {
self.tcx
.sess
.struct_span_err(
meta.span(),
&format!("doc {0} attribute expects a string: #[doc({0} = \"a\")]", attr_name),
)
.emit();
self.tcx.sess.emit_err(errors::DocExpectStr { attr_span: meta.span(), attr_name });
}
fn check_doc_alias_value(
@ -621,22 +569,12 @@ impl CheckAttrVisitor<'_> {
aliases: &mut FxHashMap<String, Span>,
) -> bool {
let tcx = self.tcx;
let err_fn = move |span: Span, msg: &str| {
tcx.sess.span_err(
span,
&format!(
"`#[doc(alias{})]` {}",
if is_list { "(\"...\")" } else { " = \"...\"" },
msg,
),
);
false
};
let span = meta.name_value_literal_span().unwrap_or_else(|| meta.span());
let attr_str =
&format!("`#[doc(alias{})]`", if is_list { "(\"...\")" } else { " = \"...\"" });
if doc_alias == kw::Empty {
return err_fn(
meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
"attribute cannot have empty value",
);
tcx.sess.emit_err(errors::DocAliasEmpty { span, attr_str });
return false;
}
let doc_alias_str = doc_alias.as_str();
@ -644,23 +582,16 @@ impl CheckAttrVisitor<'_> {
.chars()
.find(|&c| c == '"' || c == '\'' || (c.is_whitespace() && c != ' '))
{
self.tcx.sess.span_err(
meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
&format!(
"{:?} character isn't allowed in `#[doc(alias{})]`",
c,
if is_list { "(\"...\")" } else { " = \"...\"" },
),
);
tcx.sess.emit_err(errors::DocAliasBadChar { span, attr_str, char_: c });
return false;
}
if doc_alias_str.starts_with(' ') || doc_alias_str.ends_with(' ') {
return err_fn(
meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
"cannot start or end with ' '",
);
tcx.sess.emit_err(errors::DocAliasStartEnd { span, attr_str });
return false;
}
if let Some(err) = match target {
let span = meta.span();
if let Some(location) = match target {
Target::Impl => Some("implementation block"),
Target::ForeignMod => Some("extern block"),
Target::AssocTy => {
@ -686,19 +617,21 @@ impl CheckAttrVisitor<'_> {
Target::Param => return false,
_ => None,
} {
return err_fn(meta.span(), &format!("isn't allowed on {}", err));
tcx.sess.emit_err(errors::DocAliasBadLocation { span, attr_str, location });
return false;
}
let item_name = self.tcx.hir().name(hir_id);
if item_name == doc_alias {
return err_fn(meta.span(), "is the same as the item's name");
tcx.sess.emit_err(errors::DocAliasNotAnAlias { span, attr_str });
return false;
}
let span = meta.span();
if let Err(entry) = aliases.try_insert(doc_alias_str.to_owned(), span) {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, span, |lint| {
lint.build("doc alias is duplicated")
.span_label(*entry.entry.get(), "first defined here")
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
span,
errors::DocAliasDuplicated { first_defn: *entry.entry.get() },
);
}
true
}
@ -723,22 +656,12 @@ impl CheckAttrVisitor<'_> {
_ => {
self.tcx
.sess
.struct_span_err(
v.span(),
"`#[doc(alias(\"a\"))]` expects string literals",
)
.emit();
.emit_err(errors::DocAliasNotStringLiteral { span: v.span() });
errors += 1;
}
},
None => {
self.tcx
.sess
.struct_span_err(
v.span(),
"`#[doc(alias(\"a\"))]` expects string literals",
)
.emit();
self.tcx.sess.emit_err(errors::DocAliasNotStringLiteral { span: v.span() });
errors += 1;
}
}
@ -747,14 +670,7 @@ impl CheckAttrVisitor<'_> {
} else if let Some(doc_alias) = meta.value_str() {
self.check_doc_alias_value(meta, doc_alias, hir_id, target, false, aliases)
} else {
self.tcx
.sess
.struct_span_err(
meta.span(),
"doc alias attribute expects a string `#[doc(alias = \"a\")]` or a list of \
strings `#[doc(alias(\"a\", \"b\"))]`",
)
.emit();
self.tcx.sess.emit_err(errors::DocAliasMalformed { span: meta.span() });
false
}
}
@ -771,35 +687,20 @@ impl CheckAttrVisitor<'_> {
}) {
Some(ItemKind::Mod(ref module)) => {
if !module.item_ids.is_empty() {
self.tcx
.sess
.struct_span_err(
meta.span(),
"`#[doc(keyword = \"...\")]` can only be used on empty modules",
)
.emit();
self.tcx.sess.emit_err(errors::DocKeywordEmptyMod { span: meta.span() });
return false;
}
}
_ => {
self.tcx
.sess
.struct_span_err(
meta.span(),
"`#[doc(keyword = \"...\")]` can only be used on modules",
)
.emit();
self.tcx.sess.emit_err(errors::DocKeywordNotMod { span: meta.span() });
return false;
}
}
if !rustc_lexer::is_ident(doc_keyword.as_str()) {
self.tcx
.sess
.struct_span_err(
meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
&format!("`{doc_keyword}` is not a valid identifier"),
)
.emit();
self.tcx.sess.emit_err(errors::DocKeywordInvalidIdent {
span: meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
doc_keyword,
});
return false;
}
true
@ -812,24 +713,12 @@ impl CheckAttrVisitor<'_> {
}) {
Some(ItemKind::Impl(ref i)) => {
if !matches!(&i.self_ty.kind, hir::TyKind::Tup([_])) {
self.tcx
.sess
.struct_span_err(
meta.span(),
"`#[doc(tuple_variadic)]` must be used on the first of a set of tuple trait impls with varying arity",
)
.emit();
self.tcx.sess.emit_err(errors::DocTupleVariadicNotFirst { span: meta.span() });
return false;
}
}
_ => {
self.tcx
.sess
.struct_span_err(
meta.span(),
"`#[doc(keyword = \"...\")]` can only be used on impl blocks",
)
.emit();
self.tcx.sess.emit_err(errors::DocKeywordOnlyImpl { span: meta.span() });
return false;
}
}
@ -858,13 +747,9 @@ impl CheckAttrVisitor<'_> {
if let Some((prev_inline, prev_span)) = *specified_inline {
if do_inline != prev_inline {
let mut spans = MultiSpan::from_spans(vec![prev_span, meta.span()]);
spans.push_span_label(prev_span, "this attribute...");
spans.push_span_label(meta.span(), "...conflicts with this attribute");
self.tcx
.sess
.struct_span_err(spans, "conflicting doc inlining attributes")
.help("remove one of the conflicting attributes")
.emit();
spans.push_span_label(prev_span, fluent::passes::doc_inline_conflict_first);
spans.push_span_label(meta.span(), fluent::passes::doc_inline_conflict_second);
self.tcx.sess.emit_err(errors::DocKeywordConflict { spans });
return false;
}
true
@ -873,23 +758,14 @@ impl CheckAttrVisitor<'_> {
true
}
} else {
self.tcx.struct_span_lint_hir(
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
meta.span(),
|lint| {
let mut err = lint.build(
"this attribute can only be applied to a `use` item",
);
err.span_label(meta.span(), "only applicable on `use` items");
if attr.style == AttrStyle::Outer {
err.span_label(
self.tcx.hir().span(hir_id),
"not a `use` item",
);
}
err.note("read https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#inline-and-no_inline for more information")
.emit();
errors::DocInlineOnlyUse {
attr_span: meta.span(),
item_span: (attr.style == AttrStyle::Outer)
.then(|| self.tcx.hir().span(hir_id)),
},
);
false
@ -904,15 +780,7 @@ impl CheckAttrVisitor<'_> {
attr_name: &str,
) -> bool {
if CRATE_HIR_ID == hir_id {
self.tcx
.sess
.struct_span_err(
meta.span(),
&format!(
"`#![doc({attr_name} = \"...\")]` isn't allowed as a crate-level attribute",
),
)
.emit();
self.tcx.sess.emit_err(errors::DocAttrNotCrateLevel { span: meta.span(), attr_name });
return false;
}
true
@ -926,36 +794,25 @@ impl CheckAttrVisitor<'_> {
hir_id: HirId,
) -> bool {
if hir_id != CRATE_HIR_ID {
self.tcx.struct_span_lint_hir(
INVALID_DOC_ATTRIBUTES,
hir_id,
meta.span(),
|lint| {
let mut err = lint.build(
"this attribute can only be applied at the crate level",
);
if attr.style == AttrStyle::Outer && self.tcx.hir().get_parent_item(hir_id) == CRATE_DEF_ID {
if let Ok(mut src) =
self.tcx.sess.source_map().span_to_snippet(attr.span)
{
src.insert(1, '!');
err.span_suggestion_verbose(
attr.span,
"to apply to the crate, use an inner attribute",
src,
Applicability::MaybeIncorrect,
);
} else {
err.span_help(
attr.span,
"to apply to the crate, use an inner attribute",
);
}
self.tcx.struct_span_lint_hir(INVALID_DOC_ATTRIBUTES, hir_id, meta.span(), |lint| {
let mut err = lint.build(fluent::passes::attr_crate_level);
if attr.style == AttrStyle::Outer
&& self.tcx.hir().get_parent_item(hir_id) == CRATE_DEF_ID
{
if let Ok(mut src) = self.tcx.sess.source_map().span_to_snippet(attr.span) {
src.insert(1, '!');
err.span_suggestion_verbose(
attr.span,
fluent::passes::suggestion,
src,
Applicability::MaybeIncorrect,
);
} else {
err.span_help(attr.span, fluent::passes::help);
}
err.note("read https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#at-the-crate-level for more information")
.emit();
},
);
}
err.note(fluent::passes::note).emit();
});
return false;
}
true
@ -970,18 +827,14 @@ impl CheckAttrVisitor<'_> {
match i_meta.name_or_empty() {
sym::attr | sym::no_crate_inject => {}
_ => {
self.tcx.struct_span_lint_hir(
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
i_meta.span(),
|lint| {
lint.build(&format!(
"unknown `doc(test)` attribute `{}`",
rustc_ast_pretty::pprust::path_to_string(
&i_meta.meta_item().unwrap().path
),
))
.emit();
errors::DocTestUnknown {
path: rustc_ast_pretty::pprust::path_to_string(
&i_meta.meta_item().unwrap().path,
),
},
);
is_valid = false;
@ -989,9 +842,12 @@ impl CheckAttrVisitor<'_> {
}
}
} else {
self.tcx.struct_span_lint_hir(INVALID_DOC_ATTRIBUTES, hir_id, meta.span(), |lint| {
lint.build("`#[doc(test(...)]` takes a list of attributes").emit();
});
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
meta.span(),
errors::DocTestTakesList,
);
is_valid = false;
}
is_valid
@ -1093,79 +949,66 @@ impl CheckAttrVisitor<'_> {
sym::primitive => {
if !self.tcx.features().rustdoc_internals {
self.tcx.struct_span_lint_hir(
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
i_meta.span,
|lint| {
let mut diag = lint.build(
"`doc(primitive)` should never have been stable",
);
diag.emit();
},
errors::DocPrimitive,
);
}
}
_ => {
self.tcx.struct_span_lint_hir(
INVALID_DOC_ATTRIBUTES,
hir_id,
i_meta.span,
|lint| {
let mut diag = lint.build(&format!(
"unknown `doc` attribute `{}`",
rustc_ast_pretty::pprust::path_to_string(&i_meta.path),
));
if i_meta.has_name(sym::spotlight) {
diag.note(
"`doc(spotlight)` was renamed to `doc(notable_trait)`",
);
diag.span_suggestion_short(
i_meta.span,
"use `notable_trait` instead",
"notable_trait",
Applicability::MachineApplicable,
);
diag.note("`doc(spotlight)` is now a no-op");
let path = rustc_ast_pretty::pprust::path_to_string(&i_meta.path);
if i_meta.has_name(sym::spotlight) {
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
i_meta.span,
errors::DocTestUnknownSpotlight {
path,
span: i_meta.span
}
if i_meta.has_name(sym::include) {
if let Some(value) = i_meta.value_str() {
// if there are multiple attributes, the suggestion would suggest deleting all of them, which is incorrect
let applicability = if list.len() == 1 {
Applicability::MachineApplicable
} else {
Applicability::MaybeIncorrect
};
let inner = if attr.style == AttrStyle::Inner {
"!"
} else {
""
};
diag.span_suggestion(
attr.meta().unwrap().span,
"use `doc = include_str!` instead",
format!(
"#{inner}[doc = include_str!(\"{value}\")]",
),
applicability,
);
}
);
} else if i_meta.has_name(sym::include) &&
let Some(value) = i_meta.value_str() {
let applicability = if list.len() == 1 {
Applicability::MachineApplicable
} else {
Applicability::MaybeIncorrect
};
// If there are multiple attributes, the suggestion would suggest
// deleting all of them, which is incorrect.
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
i_meta.span,
errors::DocTestUnknownInclude {
path,
value: value.to_string(),
inner: (attr.style == AttrStyle::Inner)
.then_some("!")
.unwrap_or(""),
sugg: (attr.meta().unwrap().span, applicability),
}
diag.emit();
},
);
);
} else {
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
i_meta.span,
errors::DocTestUnknownAny { path }
);
}
is_valid = false;
}
}
} else {
self.tcx.struct_span_lint_hir(
self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES,
hir_id,
meta.span(),
|lint| {
lint.build("invalid `doc` attribute").emit();
},
errors::DocInvalid,
);
is_valid = false;
}
@ -1180,14 +1023,7 @@ impl CheckAttrVisitor<'_> {
match target {
Target::Struct | Target::Enum | Target::TyAlias => true,
_ => {
self.tcx
.sess
.struct_span_err(
attr.span,
"`pass_by_value` attribute should be applied to a struct, enum or type alias.",
)
.span_label(span, "is not a struct, enum or type alias")
.emit();
self.tcx.sess.emit_err(errors::PassByValue { attr_span: attr.span, span });
false
}
}
@ -1197,14 +1033,7 @@ impl CheckAttrVisitor<'_> {
match target {
Target::Method(MethodKind::Inherent) => true,
_ => {
self.tcx
.sess
.struct_span_err(
attr.span,
"`rustc_allow_incoherent_impl` attribute should be applied to impl items.",
)
.span_label(span, "the only currently supported targets are inherent methods")
.emit();
self.tcx.sess.emit_err(errors::AllowIncoherentImpl { attr_span: attr.span, span });
false
}
}
@ -1223,12 +1052,7 @@ impl CheckAttrVisitor<'_> {
_ => {
self.tcx
.sess
.struct_span_err(
attr.span,
"`rustc_has_incoherent_inherent_impls` attribute should be applied to types or traits.",
)
.span_label(span, "only adts, extern types and traits are supported")
.emit();
.emit_err(errors::HasIncoherentInherentImpl { attr_span: attr.span, span });
false
}
}
@ -1238,19 +1062,12 @@ impl CheckAttrVisitor<'_> {
fn check_must_use(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
let node = self.tcx.hir().get(hir_id);
if let Some(kind) = node.fn_kind() && let rustc_hir::IsAsync::Async = kind.asyncness() {
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build(
"`must_use` attribute on `async` functions \
applies to the anonymous `Future` returned by the \
function, not the value within",
)
.span_label(
span,
"this attribute does nothing, the `Future`s \
returned by async functions are already `must_use`",
)
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::MustUseAsync { span }
);
}
if !matches!(
@ -1278,12 +1095,12 @@ impl CheckAttrVisitor<'_> {
_ => "a",
};
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build(&format!(
"`#[must_use]` has no effect when applied to {article} {target}"
))
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::MustUseNoEffect { article, target },
);
}
// For now, its always valid
@ -1295,11 +1112,7 @@ impl CheckAttrVisitor<'_> {
match target {
Target::Struct | Target::Enum | Target::Union | Target::Trait => true,
_ => {
self.tcx
.sess
.struct_span_err(attr.span, "`must_not_suspend` attribute should be applied to a struct, enum, or trait")
.span_label(span, "is not a struct, enum, or trait")
.emit();
self.tcx.sess.emit_err(errors::MustNotSuspend { attr_span: attr.span, span });
false
}
}
@ -1319,16 +1132,12 @@ impl CheckAttrVisitor<'_> {
_ => {
// FIXME: #[cold] was previously allowed on non-functions and some crates used
// this, so only emit a warning.
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
lint.build("attribute should be applied to a function")
.warn(
"this was previously accepted by the compiler but is \
being phased out; it will become a hard error in \
a future release!",
)
.span_label(span, "not a function")
.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::Cold { span },
);
}
}
}
@ -1343,19 +1152,12 @@ impl CheckAttrVisitor<'_> {
return;
}
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, attr.span, |lint| {
let mut diag =
lint.build("attribute should be applied to an `extern` block with non-Rust ABI");
diag.warn(
"this was previously accepted by the compiler but is \
being phased out; it will become a hard error in \
a future release!",
);
if target != Target::ForeignMod {
diag.span_label(span, "not an `extern` block");
}
diag.emit();
});
self.tcx.emit_spanned_lint(
UNUSED_ATTRIBUTES,
hir_id,
attr.span,
errors::Link { span: (target != Target::ForeignMod).then_some(span) },
);
}
/// Checks if `#[link_name]` is applied to an item other than a foreign function or static.

362
compiler/rustc_passes/src/errors.rs Normal file
View file

@ -0,0 +1,362 @@
use rustc_errors::{Applicability, MultiSpan};
use rustc_macros::{LintDiagnostic, SessionDiagnostic};
use rustc_span::{Span, Symbol};
#[derive(LintDiagnostic)]
#[lint(passes::outer_crate_level_attr)]
pub struct OuterCrateLevelAttr;
#[derive(LintDiagnostic)]
#[lint(passes::inner_crate_level_attr)]
pub struct InnerCrateLevelAttr;
#[derive(LintDiagnostic)]
#[lint(passes::ignored_attr_with_macro)]
pub struct IgnoredAttrWithMacro<'a> {
pub sym: &'a str,
}
#[derive(LintDiagnostic)]
#[lint(passes::ignored_attr)]
pub struct IgnoredAttr<'a> {
pub sym: &'a str,
}
#[derive(LintDiagnostic)]
#[lint(passes::inline_ignored_function_prototype)]
pub struct IgnoredInlineAttrFnProto;
#[derive(LintDiagnostic)]
#[lint(passes::inline_ignored_constants)]
#[warn_]
#[note]
pub struct IgnoredInlineAttrConstants;
#[derive(SessionDiagnostic)]
#[error(passes::inline_not_fn_or_closure, code = "E0518")]
pub struct InlineNotFnOrClosure {
#[primary_span]
pub attr_span: Span,
#[label]
pub defn_span: Span,
}
#[derive(LintDiagnostic)]
#[lint(passes::no_coverage_ignored_function_prototype)]
pub struct IgnoredNoCoverageFnProto;
#[derive(LintDiagnostic)]
#[lint(passes::no_coverage_propagate)]
pub struct IgnoredNoCoveragePropagate;
#[derive(LintDiagnostic)]
#[lint(passes::no_coverage_fn_defn)]
pub struct IgnoredNoCoverageFnDefn;
#[derive(SessionDiagnostic)]
#[error(passes::no_coverage_not_coverable, code = "E0788")]
pub struct IgnoredNoCoverageNotCoverable {
#[primary_span]
pub attr_span: Span,
#[label]
pub defn_span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::should_be_applied_to_fn)]
pub struct AttrShouldBeAppliedToFn {
#[primary_span]
pub attr_span: Span,
#[label]
pub defn_span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::naked_tracked_caller, code = "E0736")]
pub struct NakedTrackedCaller {
#[primary_span]
pub attr_span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::should_be_applied_to_fn, code = "E0739")]
pub struct TrackedCallerWrongLocation {
#[primary_span]
pub attr_span: Span,
#[label]
pub defn_span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::should_be_applied_to_struct_enum, code = "E0701")]
pub struct NonExhaustiveWrongLocation {
#[primary_span]
pub attr_span: Span,
#[label]
pub defn_span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::should_be_applied_to_trait)]
pub struct AttrShouldBeAppliedToTrait {
#[primary_span]
pub attr_span: Span,
#[label]
pub defn_span: Span,
}
#[derive(LintDiagnostic)]
#[lint(passes::target_feature_on_statement)]
pub struct TargetFeatureOnStatement;
#[derive(SessionDiagnostic)]
#[error(passes::should_be_applied_to_static)]
pub struct AttrShouldBeAppliedToStatic {
#[primary_span]
pub attr_span: Span,
#[label]
pub defn_span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_expect_str)]
pub struct DocExpectStr<'a> {
#[primary_span]
pub attr_span: Span,
pub attr_name: &'a str,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_alias_empty)]
pub struct DocAliasEmpty<'a> {
#[primary_span]
pub span: Span,
pub attr_str: &'a str,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_alias_bad_char)]
pub struct DocAliasBadChar<'a> {
#[primary_span]
pub span: Span,
pub attr_str: &'a str,
pub char_: char,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_alias_start_end)]
pub struct DocAliasStartEnd<'a> {
#[primary_span]
pub span: Span,
pub attr_str: &'a str,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_alias_bad_location)]
pub struct DocAliasBadLocation<'a> {
#[primary_span]
pub span: Span,
pub attr_str: &'a str,
pub location: &'a str,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_alias_not_an_alias)]
pub struct DocAliasNotAnAlias<'a> {
#[primary_span]
pub span: Span,
pub attr_str: &'a str,
}
#[derive(LintDiagnostic)]
#[lint(passes::doc_alias_duplicated)]
pub struct DocAliasDuplicated {
#[label]
pub first_defn: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_alias_not_string_literal)]
pub struct DocAliasNotStringLiteral {
#[primary_span]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_alias_malformed)]
pub struct DocAliasMalformed {
#[primary_span]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_keyword_empty_mod)]
pub struct DocKeywordEmptyMod {
#[primary_span]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_keyword_not_mod)]
pub struct DocKeywordNotMod {
#[primary_span]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_keyword_invalid_ident)]
pub struct DocKeywordInvalidIdent {
#[primary_span]
pub span: Span,
pub doc_keyword: Symbol,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_tuple_variadic_not_first)]
pub struct DocTupleVariadicNotFirst {
#[primary_span]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_keyword_only_impl)]
pub struct DocKeywordOnlyImpl {
#[primary_span]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_inline_conflict)]
#[help]
pub struct DocKeywordConflict {
#[primary_span]
pub spans: MultiSpan,
}
#[derive(LintDiagnostic)]
#[lint(passes::doc_inline_only_use)]
#[note]
pub struct DocInlineOnlyUse {
#[label]
pub attr_span: Span,
#[label(passes::not_a_use_item_label)]
pub item_span: Option<Span>,
}
#[derive(SessionDiagnostic)]
#[error(passes::doc_attr_not_crate_level)]
pub struct DocAttrNotCrateLevel<'a> {
#[primary_span]
pub span: Span,
pub attr_name: &'a str,
}
#[derive(LintDiagnostic)]
#[lint(passes::doc_test_unknown)]
pub struct DocTestUnknown {
pub path: String,
}
#[derive(LintDiagnostic)]
#[lint(passes::doc_test_takes_list)]
pub struct DocTestTakesList;
#[derive(LintDiagnostic)]
#[lint(passes::doc_primitive)]
pub struct DocPrimitive;
#[derive(LintDiagnostic)]
#[lint(passes::doc_test_unknown_any)]
pub struct DocTestUnknownAny {
pub path: String,
}
#[derive(LintDiagnostic)]
#[lint(passes::doc_test_unknown_spotlight)]
#[note]
#[note(passes::no_op_note)]
pub struct DocTestUnknownSpotlight {
pub path: String,
#[suggestion_short(applicability = "machine-applicable", code = "notable_trait")]
pub span: Span,
}
#[derive(LintDiagnostic)]
#[lint(passes::doc_test_unknown_include)]
pub struct DocTestUnknownInclude {
pub path: String,
pub value: String,
pub inner: &'static str,
#[suggestion(code = "#{inner}[doc = include_str!(\"{value}\")]")]
pub sugg: (Span, Applicability),
}
#[derive(LintDiagnostic)]
#[lint(passes::doc_invalid)]
pub struct DocInvalid;
#[derive(SessionDiagnostic)]
#[error(passes::pass_by_value)]
pub struct PassByValue {
#[primary_span]
pub attr_span: Span,
#[label]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::allow_incoherent_impl)]
pub struct AllowIncoherentImpl {
#[primary_span]
pub attr_span: Span,
#[label]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error(passes::has_incoherent_inherent_impl)]
pub struct HasIncoherentInherentImpl {
#[primary_span]
pub attr_span: Span,
#[label]
pub span: Span,
}
#[derive(LintDiagnostic)]
#[lint(passes::must_use_async)]
pub struct MustUseAsync {
#[label]
pub span: Span,
}
#[derive(LintDiagnostic)]
#[lint(passes::must_use_no_effect)]
pub struct MustUseNoEffect {
pub article: &'static str,
pub target: rustc_hir::Target,
}
#[derive(SessionDiagnostic)]
#[error(passes::must_not_suspend)]
pub struct MustNotSuspend {
#[primary_span]
pub attr_span: Span,
#[label]
pub span: Span,
}
#[derive(LintDiagnostic)]
#[lint(passes::cold)]
#[warn_]
pub struct Cold {
#[label]
pub span: Span,
}
#[derive(LintDiagnostic)]
#[lint(passes::link)]
#[warn_]
pub struct Link {
#[label]
pub span: Option<Span>,
}

3
compiler/rustc_passes/src/lib.rs
View file

@ -7,8 +7,8 @@
#![allow(rustc::potential_query_instability)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![feature(iter_intersperse)]
#![feature(let_else)]
#![feature(let_chains)]
#![feature(let_else)]
#![feature(map_try_insert)]
#![feature(min_specialization)]
#![feature(try_blocks)]
@ -27,6 +27,7 @@ pub mod dead;
mod debugger_visualizer;
mod diagnostic_items;
pub mod entry;
mod errors;
pub mod hir_id_validator;
pub mod hir_stats;
mod lang_items;