Rollup of 11 pull requests

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -2,7 +2,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::temp_dir::MaybeTempDir;
 use rustc_fs_util::fix_windows_verbatim_for_gcc;
 use rustc_hir::def_id::CrateNum;
-use rustc_middle::middle::cstore::{EncodedMetadata, LibSource, NativeLib};
+use rustc_middle::middle::cstore::{EncodedMetadata, LibSource};
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_session::config::{self, CFGuard, CrateType, DebugInfo};
 use rustc_session::config::{OutputFilenames, OutputType, PrintRequest, SanitizerSet};
@@ -22,7 +22,8 @@ use super::command::Command;
 use super::linker::{self, Linker};
 use super::rpath::{self, RPathConfig};
 use crate::{
- looks_like_rust_object_file, CodegenResults, CompiledModule, CrateInfo, METADATA_FILENAME,
+ looks_like_rust_object_file, CodegenResults, CompiledModule, CrateInfo, NativeLib,
+ METADATA_FILENAME,
 };
 
 use cc::windows_registry;

compiler/rustc_codegen_ssa/src/base.rs

@@ -766,7 +766,7 @@ impl CrateInfo {
  profiler_runtime: None,
  is_no_builtins: Default::default(),
  native_libraries: Default::default(),
- used_libraries: tcx.native_libraries(LOCAL_CRATE),
+ used_libraries: tcx.native_libraries(LOCAL_CRATE).iter().map(Into::into).collect(),
  link_args: tcx.link_args(LOCAL_CRATE),
  crate_name: Default::default(),
  used_crates_dynamic: cstore::used_crates(tcx, LinkagePreference::RequireDynamic),
@@ -787,7 +787,8 @@ impl CrateInfo {
  info.missing_lang_items.reserve(n_crates);
 
  for &cnum in crates.iter() {
- info.native_libraries.insert(cnum, tcx.native_libraries(cnum));
+ info.native_libraries
+ .insert(cnum, tcx.native_libraries(cnum).iter().map(Into::into).collect());
  info.crate_name.insert(cnum, tcx.crate_name(cnum).to_string());
  info.used_crate_source.insert(cnum, tcx.used_crate_source(cnum));
  if tcx.is_panic_runtime(cnum) {

compiler/rustc_codegen_ssa/src/lib.rs

@@ -21,15 +21,17 @@ extern crate tracing;
 #[macro_use]
 extern crate rustc_middle;
 
+use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir::def_id::CrateNum;
 use rustc_hir::LangItem;
 use rustc_middle::dep_graph::WorkProduct;
-use rustc_middle::middle::cstore::{CrateSource, LibSource, NativeLib};
+use rustc_middle::middle::cstore::{self, CrateSource, LibSource};
 use rustc_middle::middle::dependency_format::Dependencies;
 use rustc_middle::ty::query::Providers;
 use rustc_session::config::{OutputFilenames, OutputType, RUST_CGU_EXT};
+use rustc_session::utils::NativeLibKind;
 use rustc_span::symbol::Symbol;
 use std::path::{Path, PathBuf};
 
@@ -105,6 +107,19 @@ bitflags::bitflags! {
  }
 }
 
+#[derive(Clone, Debug, Encodable, Decodable, HashStable)]
+pub struct NativeLib {
+ pub kind: NativeLibKind,
+ pub name: Option<Symbol>,
+ pub cfg: Option<ast::MetaItem>,
+}
+
+impl From<&cstore::NativeLib> for NativeLib {
+ fn from(lib: &cstore::NativeLib) -> Self {
+ NativeLib { kind: lib.kind.clone(), name: lib.name.clone(), cfg: lib.cfg.clone() }
+ }
+}
+
 /// Misc info we load from metadata to persist beyond the tcx.
 ///
 /// Note: though `CrateNum` is only meaningful within the same tcx, information within `CrateInfo`
@@ -119,9 +134,9 @@ pub struct CrateInfo {
  pub compiler_builtins: Option<CrateNum>,
  pub profiler_runtime: Option<CrateNum>,
  pub is_no_builtins: FxHashSet<CrateNum>,
- pub native_libraries: FxHashMap<CrateNum, Lrc<Vec<NativeLib>>>,
+ pub native_libraries: FxHashMap<CrateNum, Vec<NativeLib>>,
  pub crate_name: FxHashMap<CrateNum, String>,
- pub used_libraries: Lrc<Vec<NativeLib>>,
+ pub used_libraries: Vec<NativeLib>,
  pub link_args: Lrc<Vec<String>>,
  pub used_crate_source: FxHashMap<CrateNum, Lrc<CrateSource>>,
  pub used_crates_static: Vec<(CrateNum, LibSource)>,

compiler/rustc_expand/src/mbe.rs

@@ -84,7 +84,7 @@ enum TokenTree {
  /// e.g., `$var`
  MetaVar(Span, Ident),
  /// e.g., `$var:expr`. This is only used in the left hand side of MBE macros.
- MetaVarDecl(Span, Ident /* name to bind */, NonterminalKind),
+ MetaVarDecl(Span, Ident /* name to bind */, Option<NonterminalKind>),
 }
 
 impl TokenTree {

compiler/rustc_expand/src/mbe/macro_parser.rs

@@ -378,6 +378,11 @@ fn nameize<I: Iterator<Item = NamedMatch>>(
  n_rec(sess, next_m, res.by_ref(), ret_val)?;
  }
  }
+ TokenTree::MetaVarDecl(span, _, None) => {
+ if sess.missing_fragment_specifiers.borrow_mut().remove(&span).is_some() {
+ return Err((span, "missing fragment specifier".to_string()));
+ }
+ }
  TokenTree::MetaVarDecl(sp, bind_name, _) => match ret_val
  .entry(MacroRulesNormalizedIdent::new(bind_name))
  {
@@ -446,6 +451,7 @@ fn or_pat_mode(edition: Edition) -> OrPatNonterminalMode {
 ///
 /// A `ParseResult`. Note that matches are kept track of through the items generated.
 fn inner_parse_loop<'root, 'tt>(
+ sess: &ParseSess,
  cur_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
  next_items: &mut Vec<MatcherPosHandle<'root, 'tt>>,
  eof_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
@@ -563,9 +569,16 @@ fn inner_parse_loop<'root, 'tt>(
  })));
  }
 
+ // We need to match a metavar (but the identifier is invalid)... this is an error
+ TokenTree::MetaVarDecl(span, _, None) => {
+ if sess.missing_fragment_specifiers.borrow_mut().remove(&span).is_some() {
+ return Error(span, "missing fragment specifier".to_string());
+ }
+ }
+
  // We need to match a metavar with a valid ident... call out to the black-box
  // parser by adding an item to `bb_items`.
- TokenTree::MetaVarDecl(span, _, kind) => {
+ TokenTree::MetaVarDecl(span, _, Some(kind)) => {
  // Built-in nonterminals never start with these tokens, so we can eliminate
  // them from consideration.
  //
@@ -640,6 +653,7 @@ pub(super) fn parse_tt(parser: &mut Cow<'_, Parser<'_>>, ms: &[TokenTree]) -> Na
  // parsing from the black-box parser done. The result is that `next_items` will contain a
  // bunch of possible next matcher positions in `next_items`.
  match inner_parse_loop(
+ parser.sess,
  &mut cur_items,
  &mut next_items,
  &mut eof_items,
@@ -701,7 +715,7 @@ pub(super) fn parse_tt(parser: &mut Cow<'_, Parser<'_>>, ms: &[TokenTree]) -> Na
  let nts = bb_items
  .iter()
  .map(|item| match item.top_elts.get_tt(item.idx) {
- TokenTree::MetaVarDecl(_, bind, kind) => format!("{} ('{}')", kind, bind),
+ TokenTree::MetaVarDecl(_, bind, Some(kind)) => format!("{} ('{}')", kind, bind),
  _ => panic!(),
  })
  .collect::<Vec<String>>()
@@ -731,7 +745,7 @@ pub(super) fn parse_tt(parser: &mut Cow<'_, Parser<'_>>, ms: &[TokenTree]) -> Na
  assert_eq!(bb_items.len(), 1);
 
  let mut item = bb_items.pop().unwrap();
- if let TokenTree::MetaVarDecl(span, _, kind) = item.top_elts.get_tt(item.idx) {
+ if let TokenTree::MetaVarDecl(span, _, Some(kind)) = item.top_elts.get_tt(item.idx) {
  let match_cur = item.match_cur;
  // We use the span of the metavariable declaration to determine any
  // edition-specific matching behavior for non-terminals.

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -401,7 +401,7 @@ pub fn compile_declarative_macro(
  let diag = &sess.parse_sess.span_diagnostic;
  let lhs_nm = Ident::new(sym::lhs, def.span);
  let rhs_nm = Ident::new(sym::rhs, def.span);
- let tt_spec = NonterminalKind::TT;
+ let tt_spec = Some(NonterminalKind::TT);
 
  // Parse the macro_rules! invocation
  let (macro_rules, body) = match &def.kind {
@@ -578,7 +578,7 @@ fn check_lhs_no_empty_seq(sess: &ParseSess, tts: &[mbe::TokenTree]) -> bool {
  TokenTree::Sequence(span, ref seq) => {
  if seq.separator.is_none()
  && seq.tts.iter().all(|seq_tt| match *seq_tt {
- TokenTree::MetaVarDecl(_, _, NonterminalKind::Vis) => true,
+ TokenTree::MetaVarDecl(_, _, Some(NonterminalKind::Vis)) => true,
  TokenTree::Sequence(_, ref sub_seq) => {
  sub_seq.kleene.op == mbe::KleeneOp::ZeroOrMore
  || sub_seq.kleene.op == mbe::KleeneOp::ZeroOrOne
@@ -961,7 +961,7 @@ fn check_matcher_core(
  // Now `last` holds the complete set of NT tokens that could
  // end the sequence before SUFFIX. Check that every one works with `suffix`.
  for token in &last.tokens {
- if let TokenTree::MetaVarDecl(_, name, kind) = *token {
+ if let TokenTree::MetaVarDecl(_, name, Some(kind)) = *token {
  for next_token in &suffix_first.tokens {
  match is_in_follow(next_token, kind) {
  IsInFollow::Yes => {}
@@ -1019,7 +1019,7 @@ fn check_matcher_core(
 }
 
 fn token_can_be_followed_by_any(tok: &mbe::TokenTree) -> bool {
- if let mbe::TokenTree::MetaVarDecl(_, _, kind) = *tok {
+ if let mbe::TokenTree::MetaVarDecl(_, _, Some(kind)) = *tok {
  frag_can_be_followed_by_any(kind)
  } else {
  // (Non NT's can always be followed by anything in matchers.)
@@ -1123,7 +1123,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
  }
  _ => IsInFollow::No(TOKENS),
  },
- TokenTree::MetaVarDecl(_, _, NonterminalKind::Block) => IsInFollow::Yes,
+ TokenTree::MetaVarDecl(_, _, Some(NonterminalKind::Block)) => IsInFollow::Yes,
  _ => IsInFollow::No(TOKENS),
  }
  }
@@ -1158,7 +1158,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
  TokenTree::MetaVarDecl(
  _,
  _,
- NonterminalKind::Ident | NonterminalKind::Ty | NonterminalKind::Path,
+ Some(NonterminalKind::Ident | NonterminalKind::Ty | NonterminalKind::Path),
  ) => IsInFollow::Yes,
  _ => IsInFollow::No(TOKENS),
  }
@@ -1171,7 +1171,8 @@ fn quoted_tt_to_string(tt: &mbe::TokenTree) -> String {
  match *tt {
  mbe::TokenTree::Token(ref token) => pprust::token_to_string(&token),
  mbe::TokenTree::MetaVar(_, name) => format!("${}", name),
- mbe::TokenTree::MetaVarDecl(_, name, kind) => format!("${}:{}", name, kind),
+ mbe::TokenTree::MetaVarDecl(_, name, Some(kind)) => format!("${}:{}", name, kind),
+ mbe::TokenTree::MetaVarDecl(_, name, None) => format!("${}:", name),
  _ => panic!(
  "{}",
  "unexpected mbe::TokenTree::{Sequence or Delimited} \

compiler/rustc_expand/src/mbe/quoted.rs

@@ -3,7 +3,7 @@ use crate::mbe::{Delimited, KleeneOp, KleeneToken, SequenceRepetition, TokenTree
 
 use rustc_ast::token::{self, Token};
 use rustc_ast::tokenstream;
-use rustc_ast::NodeId;
+use rustc_ast::{NodeId, DUMMY_NODE_ID};
 use rustc_ast_pretty::pprust;
 use rustc_session::parse::ParseSess;
 use rustc_span::symbol::{kw, Ident};
@@ -73,7 +73,7 @@ pub(super) fn parse(
  .emit();
  token::NonterminalKind::Ident
  });
- result.push(TokenTree::MetaVarDecl(span, ident, kind));
+ result.push(TokenTree::MetaVarDecl(span, ident, Some(kind)));
  continue;
  }
  _ => token.span,
@@ -83,8 +83,11 @@ pub(super) fn parse(
  }
  tree => tree.as_ref().map(tokenstream::TokenTree::span).unwrap_or(start_sp),
  };
- sess.span_diagnostic.struct_span_err(span, "missing fragment specifier").emit();
- continue;
+ if node_id != DUMMY_NODE_ID {
+ // Macros loaded from other crates have dummy node ids.
+ sess.missing_fragment_specifiers.borrow_mut().insert(span, node_id);
+ }
+ result.push(TokenTree::MetaVarDecl(span, ident, None));
  }
 
  // Not a metavar or no matchers allowed, so just return the tree

compiler/rustc_interface/src/passes.rs

@@ -29,6 +29,7 @@ use rustc_passes::{self, hir_stats, layout_test};
 use rustc_plugin_impl as plugin;
 use rustc_resolve::{Resolver, ResolverArenas};
 use rustc_session::config::{CrateType, Input, OutputFilenames, OutputType, PpMode, PpSourceMode};
+use rustc_session::lint;
 use rustc_session::output::{filename_for_input, filename_for_metadata};
 use rustc_session::search_paths::PathKind;
 use rustc_session::Session;
@@ -306,11 +307,27 @@ fn configure_and_expand_inner<'a>(
  ecx.check_unused_macros();
  });
 
+ let mut missing_fragment_specifiers: Vec<_> = ecx
+ .sess
+ .parse_sess
+ .missing_fragment_specifiers
+ .borrow()
+ .iter()
+ .map(|(span, node_id)| (*span, *node_id))
+ .collect();
+ missing_fragment_specifiers.sort_unstable_by_key(|(span, _)| *span);
+
+ let recursion_limit_hit = ecx.reduced_recursion_limit.is_some();
+
+ for (span, node_id) in missing_fragment_specifiers {
+ let lint = lint::builtin::MISSING_FRAGMENT_SPECIFIER;
+ let msg = "missing fragment specifier";
+ resolver.lint_buffer().buffer_lint(lint, node_id, span, msg);
+ }
  if cfg!(windows) {
  env::set_var("PATH", &old_path);
  }
 
- let recursion_limit_hit = ecx.reduced_recursion_limit.is_some();
  if recursion_limit_hit {
  // If we hit a recursion limit, exit early to avoid later passes getting overwhelmed
  // with a large AST

compiler/rustc_lint/src/levels.rs

@@ -12,7 +12,9 @@ use rustc_hir::{intravisit, HirId};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::LevelSource;
 use rustc_middle::lint::LintDiagnosticBuilder;
-use rustc_middle::lint::{struct_lint_level, LintLevelMap, LintLevelSets, LintSet, LintSource};
+use rustc_middle::lint::{
+ struct_lint_level, LintLevelMap, LintLevelSets, LintLevelSource, LintSet,
+};
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::lint::{builtin, Level, Lint, LintId};
@@ -91,7 +93,7 @@ impl<'s> LintLevelsBuilder<'s> {
  };
  for id in ids {
  self.check_gated_lint(id, DUMMY_SP);
- let src = LintSource::CommandLine(lint_flag_val, orig_level);
+ let src = LintLevelSource::CommandLine(lint_flag_val, orig_level);
  specs.insert(id, (level, src));
  }
  }
@@ -128,19 +130,19 @@ impl<'s> LintLevelsBuilder<'s> {
  );
  diag_builder.span_label(src.span(), "overruled by previous forbid");
  match old_src {
- LintSource::Default => {
+ LintLevelSource::Default => {
  diag_builder.note(&format!(
  "`forbid` lint level is the default for {}",
  id.to_string()
  ));
  }
- LintSource::Node(_, forbid_source_span, reason) => {
+ LintLevelSource::Node(_, forbid_source_span, reason) => {
  diag_builder.span_label(forbid_source_span, "`forbid` level set here");
  if let Some(rationale) = reason {
  diag_builder.note(&rationale.as_str());
  }
  }
- LintSource::CommandLine(_, _) => {
+ LintLevelSource::CommandLine(_, _) => {
  diag_builder.note("`forbid` lint level was set on command line");
  }
  }
@@ -276,7 +278,7 @@ impl<'s> LintLevelsBuilder<'s> {
  let name = meta_item.path.segments.last().expect("empty lint name").ident.name;
  match store.check_lint_name(&name.as_str(), tool_name) {
  CheckLintNameResult::Ok(ids) => {
- let src = LintSource::Node(name, li.span(), reason);
+ let src = LintLevelSource::Node(name, li.span(), reason);
  for &id in ids {
  self.check_gated_lint(id, attr.span);
  self.insert_spec(&mut specs, id, (level, src));
@@ -287,7 +289,7 @@ impl<'s> LintLevelsBuilder<'s> {
  match result {
  Ok(ids) => {
  let complete_name = &format!("{}::{}", tool_name.unwrap(), name);
- let src = LintSource::Node(
+ let src = LintLevelSource::Node(
  Symbol::intern(complete_name),
  li.span(),
  reason,
@@ -324,7 +326,7 @@ impl<'s> LintLevelsBuilder<'s> {
  },
  );
 
- let src = LintSource::Node(
+ let src = LintLevelSource::Node(
  Symbol::intern(&new_lint_name),
  li.span(),
  reason,
@@ -403,7 +405,7 @@ impl<'s> LintLevelsBuilder<'s> {
  }
 
  let (lint_attr_name, lint_attr_span) = match *src {
- LintSource::Node(name, span, _) => (name, span),
+ LintLevelSource::Node(name, span, _) => (name, span),
  _ => continue,
  };
 
@@ -460,7 +462,7 @@ impl<'s> LintLevelsBuilder<'s> {
  }
 
  /// Find the lint level for a lint.
- pub fn lint_level(&self, lint: &'static Lint) -> (Level, LintSource) {
+ pub fn lint_level(&self, lint: &'static Lint) -> (Level, LintLevelSource) {
  self.sets.get_lint_level(lint, self.cur, None, self.sess)
  }
 

compiler/rustc_lint/src/lib.rs

@@ -70,7 +70,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_session::lint::builtin::{
  BARE_TRAIT_OBJECTS, BROKEN_INTRA_DOC_LINKS, ELIDED_LIFETIMES_IN_PATHS,
  EXPLICIT_OUTLIVES_REQUIREMENTS, INVALID_CODEBLOCK_ATTRIBUTES, INVALID_HTML_TAGS,
- MISSING_DOC_CODE_EXAMPLES, NON_AUTOLINKS, PRIVATE_DOC_TESTS,
+ INVALID_RUST_CODEBLOCK, MISSING_DOC_CODE_EXAMPLES, NON_AUTOLINKS, PRIVATE_DOC_TESTS,
 };
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::Span;
@@ -319,6 +319,7 @@ fn register_builtins(store: &mut LintStore, no_interleave_lints: bool) {
  BROKEN_INTRA_DOC_LINKS,
  PRIVATE_INTRA_DOC_LINKS,
  INVALID_CODEBLOCK_ATTRIBUTES,
+ INVALID_RUST_CODEBLOCK,
  MISSING_DOC_CODE_EXAMPLES,
  PRIVATE_DOC_TESTS,
  INVALID_HTML_TAGS