Rollup of 8 pull requests

Cargo.lock

@@ -3746,6 +3746,7 @@ dependencies = [
  "rustc_errors",
  "rustc_feature",
  "rustc_lexer",
+ "rustc_lint_defs",
  "rustc_macros",
  "rustc_parse",
  "rustc_serialize",

compiler/rustc_ast_lowering/src/item.rs

@@ -319,10 +319,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
  ItemKind::Mod(ref m) => hir::ItemKind::Mod(self.lower_mod(m)),
  ItemKind::ForeignMod(ref fm) => {
  if fm.abi.is_none() {
- self.maybe_lint_missing_abi(span, id, abi::Abi::C);
+ self.maybe_lint_missing_abi(span, id, abi::Abi::C { unwind: false });
  }
  hir::ItemKind::ForeignMod {
- abi: fm.abi.map_or(abi::Abi::C, |abi| self.lower_abi(abi)),
+ abi: fm.abi.map_or(abi::Abi::C { unwind: false }, |abi| self.lower_abi(abi)),
  items: self
  .arena
  .alloc_from_iter(fm.items.iter().map(|x| self.lower_foreign_item_ref(x))),
@@ -1315,8 +1315,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
  match ext {
  Extern::None => abi::Abi::Rust,
  Extern::Implicit => {
- self.maybe_lint_missing_abi(span, id, abi::Abi::C);
- abi::Abi::C
+ self.maybe_lint_missing_abi(span, id, abi::Abi::C { unwind: false });
+ abi::Abi::C { unwind: false }
  }
  Extern::Explicit(abi) => self.lower_abi(abi),
  }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -156,6 +156,39 @@ impl<'a> PostExpansionVisitor<'a> {
  "efiapi ABI is experimental and subject to change"
  );
  }
+ // FFI Unwinding ABI's
+ "C-unwind" => {
+ gate_feature_post!(
+ &self,
+ c_unwind,
+ span,
+ "C-unwind ABI is experimental and subject to change"
+ );
+ }
+ "stdcall-unwind" => {
+ gate_feature_post!(
+ &self,
+ c_unwind,
+ span,
+ "stdcall-unwind ABI is experimental and subject to change"
+ );
+ }
+ "system-unwind" => {
+ gate_feature_post!(
+ &self,
+ c_unwind,
+ span,
+ "system-unwind ABI is experimental and subject to change"
+ );
+ }
+ "thiscall-unwind" => {
+ gate_feature_post!(
+ &self,
+ c_unwind,
+ span,
+ "thiscall-unwind ABI is experimental and subject to change"
+ );
+ }
  abi => self
  .sess
  .parse_sess

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -101,7 +101,7 @@ fn clif_sig_from_fn_sig<'tcx>(
  requires_caller_location: bool,
 ) -> Signature {
  let abi = match sig.abi {
- Abi::System => Abi::C,
+ Abi::System { unwind: false } => Abi::C { unwind: false },
  abi => abi,
  };
  let (call_conv, inputs, output): (CallConv, Vec<Ty<'tcx>>, Ty<'tcx>) = match abi {
@@ -110,7 +110,7 @@ fn clif_sig_from_fn_sig<'tcx>(
  sig.inputs().to_vec(),
  sig.output(),
  ),
- Abi::C | Abi::Unadjusted => (
+ Abi::C { unwind: false } | Abi::Unadjusted => (
  CallConv::triple_default(triple),
  sig.inputs().to_vec(),
  sig.output(),
@@ -126,7 +126,7 @@ fn clif_sig_from_fn_sig<'tcx>(
  inputs.extend(extra_args.types());
  (CallConv::triple_default(triple), inputs, sig.output())
  }
- Abi::System => unreachable!(),
+ Abi::System { .. } => unreachable!(),
  Abi::RustIntrinsic => (
  CallConv::triple_default(triple),
  sig.inputs().to_vec(),
@@ -664,7 +664,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
 
  // FIXME find a cleaner way to support varargs
  if fn_sig.c_variadic {
- if fn_sig.abi != Abi::C {
+ if !matches!(fn_sig.abi, Abi::C { .. }) {
  fx.tcx.sess.span_fatal(
  span,
  &format!("Variadic call for non-C abi {:?}", fn_sig.abi),

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -2211,8 +2211,13 @@ fn add_apple_sdk(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor) {
  return;
  }
  };
- let arch_name = llvm_target.split('-').next().expect("LLVM target must have a hyphen");
- cmd.args(&["-arch", arch_name, "-isysroot", &sdk_root, "-Wl,-syslibroot", &sdk_root]);
+ if llvm_target.contains("macabi") {
+ cmd.args(&["-target", llvm_target])
+ } else {
+ let arch_name = llvm_target.split('-').next().expect("LLVM target must have a hyphen");
+ cmd.args(&["-arch", arch_name])
+ }
+ cmd.args(&["-isysroot", &sdk_root, "-Wl,-syslibroot", &sdk_root]);
 }
 
 fn get_apple_sdk_root(sdk_name: &str) -> Result<String, String> {

compiler/rustc_expand/Cargo.toml

@@ -18,6 +18,7 @@ rustc_attr = { path = "../rustc_attr" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
+rustc_lint_defs = { path = "../rustc_lint_defs" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_lexer = { path = "../rustc_lexer" }
 rustc_parse = { path = "../rustc_parse" }

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -11,12 +11,14 @@ use crate::mbe::transcribe::transcribe;
 use rustc_ast as ast;
 use rustc_ast::token::{self, NonterminalKind, NtTT, Token, TokenKind::*};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream};
+use rustc_ast::NodeId;
 use rustc_ast_pretty::pprust;
 use rustc_attr::{self as attr, TransparencyError};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_feature::Features;
+use rustc_lint_defs::builtin::SEMICOLON_IN_EXPRESSIONS_FROM_MACROS;
 use rustc_parse::parser::Parser;
 use rustc_session::parse::ParseSess;
 use rustc_session::Session;
@@ -37,6 +39,7 @@ crate struct ParserAnyMacro<'a> {
  site_span: Span,
  /// The ident of the macro we're parsing
  macro_ident: Ident,
+ lint_node_id: NodeId,
  arm_span: Span,
 }
 
@@ -110,7 +113,8 @@ fn emit_frag_parse_err(
 
 impl<'a> ParserAnyMacro<'a> {
  crate fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) -> AstFragment {
- let ParserAnyMacro { site_span, macro_ident, ref mut parser, arm_span } = *self;
+ let ParserAnyMacro { site_span, macro_ident, ref mut parser, lint_node_id, arm_span } =
+ *self;
  let snapshot = &mut parser.clone();
  let fragment = match parse_ast_fragment(parser, kind) {
  Ok(f) => f,
@@ -124,6 +128,12 @@ impl<'a> ParserAnyMacro<'a> {
  // `macro_rules! m { () => { panic!(); } }` isn't parsed by `.parse_expr()`,
  // but `m!()` is allowed in expression positions (cf. issue #34706).
  if kind == AstFragmentKind::Expr && parser.token == token::Semi {
+ parser.sess.buffer_lint(
+ SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
+ parser.token.span,
+ lint_node_id,
+ "trailing semicolon in macro used in expression position",
+ );
  parser.bump();
  }
 
@@ -276,6 +286,7 @@ fn generic_extension<'cx>(
 
  let mut p = Parser::new(sess, tts, false, None);
  p.last_type_ascription = cx.current_expansion.prior_type_ascription;
+ let lint_node_id = cx.resolver.lint_node_id(cx.current_expansion.id);
 
  // Let the context choose how to interpret the result.
  // Weird, but useful for X-macros.
@@ -287,6 +298,7 @@ fn generic_extension<'cx>(
  // macro leaves unparsed tokens.
  site_span: sp,
  macro_ident: name,
+ lint_node_id,
  arm_span,
  });
  }

compiler/rustc_feature/src/active.rs

@@ -631,6 +631,10 @@ declare_features! (
 
  /// Allows using `pointer` and `reference` in intra-doc links
  (active, intra_doc_pointers, "1.51.0", Some(80896), None),
+
+ /// Allows `extern "C-unwind" fn` to enable unwinding across ABI boundaries.
+ (active, c_unwind, "1.51.0", Some(74990), None),
+
  // -------------------------------------------------------------------------
  // feature-group-end: actual feature gates
  // -------------------------------------------------------------------------

compiler/rustc_lint/src/context.rs

@@ -746,6 +746,14 @@ impl<'tcx> LateContext<'tcx> {
  hir::QPath::Resolved(_, ref path) => path.res,
  hir::QPath::TypeRelative(..) | hir::QPath::LangItem(..) => self
  .maybe_typeck_results()
+ .filter(|typeck_results| typeck_results.hir_owner == id.owner)
+ .or_else(|| {
+ if self.tcx.has_typeck_results(id.owner.to_def_id()) {
+ Some(self.tcx.typeck(id.owner))
+ } else {
+ None
+ }
+ })
  .and_then(|typeck_results| typeck_results.type_dependent_def(id))
  .map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)),
  }

compiler/rustc_lint/src/late.rs

@@ -140,13 +140,17 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
  fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) {
  let generics = self.context.generics.take();
  self.context.generics = it.kind.generics();
+ let old_cached_typeck_results = self.context.cached_typeck_results.take();
+ let old_enclosing_body = self.context.enclosing_body.take();
  self.with_lint_attrs(it.hir_id, &it.attrs, |cx| {
  cx.with_param_env(it.hir_id, |cx| {
  lint_callback!(cx, check_item, it);
  hir_visit::walk_item(cx, it);
  lint_callback!(cx, check_item_post, it);
  });
  });
+ self.context.enclosing_body = old_enclosing_body;
+ self.context.cached_typeck_results.set(old_cached_typeck_results);
  self.context.generics = generics;
  }
 

compiler/rustc_lint_defs/src/builtin.rs

@@ -1,3 +1,4 @@
+// ignore-tidy-filelength
 //! Some lints that are built in to the compiler.
 //!
 //! These are the built-in lints that are emitted direct in the main
@@ -2833,6 +2834,52 @@ declare_lint! {
  "detects `#[unstable]` on stable trait implementations for stable types"
 }
 
+declare_lint! {
+ /// The `semicolon_in_expressions_from_macros` lint detects trailing semicolons
+ /// in macro bodies when the macro is invoked in expression position.
+ /// This was previous accepted, but is being phased out.
+ ///
+ /// ### Example
+ ///
+ /// ```rust,compile_fail
+ /// #![deny(semicolon_in_expressions_from_macros)]
+ /// macro_rules! foo {
+ /// () => { true; }
+ /// }
+ ///
+ /// fn main() {
+ /// let val = match true {
+ /// true => false,
+ /// _ => foo!()
+ /// };
+ /// }
+ /// ```
+ ///
+ /// {{produces}}
+ ///
+ /// ### Explanation
+ ///
+ /// Previous, Rust ignored trailing semicolon in a macro
+ /// body when a macro was invoked in expression position.
+ /// However, this makes the treatment of semicolons in the language
+ /// inconsistent, and could lead to unexpected runtime behavior
+ /// in some circumstances (e.g. if the macro author expects
+ /// a value to be dropped).
+ ///
+ /// This is a [future-incompatible] lint to transition this
+ /// to a hard error in the future. See [issue #79813] for more details.
+ ///
+ /// [issue #79813]: https:/rust-lang/rust/issues/79813
+ /// [future-incompatible]: ../index.md#future-incompatible-lints
+ pub SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
+ Allow,
+ "trailing semicolon in macro body used as expression",
+ @future_incompatible = FutureIncompatibleInfo {
+ reference: "issue #79813 <https:/rust-lang/rust/issues/79813>",
+ edition: None,
+ };
+}
+
 declare_lint_pass! {
  /// Does nothing as a lint pass, but registers some `Lint`s
  /// that are used by other parts of the compiler.
@@ -2920,6 +2967,7 @@ declare_lint_pass! {
  USELESS_DEPRECATED,
  UNSUPPORTED_NAKED_FUNCTIONS,
  MISSING_ABI,
+ SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
  ]
 }
 

compiler/rustc_middle/src/ty/layout.rs

@@ -2546,6 +2546,7 @@ fn fn_can_unwind(
  panic_strategy: PanicStrategy,
  codegen_fn_attr_flags: CodegenFnAttrFlags,
  call_conv: Conv,
+ abi: SpecAbi,
 ) -> bool {
  if panic_strategy != PanicStrategy::Unwind {
  // In panic=abort mode we assume nothing can unwind anywhere, so
@@ -2570,17 +2571,33 @@ fn fn_can_unwind(
  //
  // 2. A Rust item using a non-Rust ABI (like `extern "C" fn foo() { ... }`).
  //
- // Foreign items (case 1) are assumed to not unwind; it is
- // UB otherwise. (At least for now; see also
- // rust-lang/rust#63909 and Rust RFC 2753.)
- //
- // Items defined in Rust with non-Rust ABIs (case 2) are also
- // not supposed to unwind. Whether this should be enforced
- // (versus stating it is UB) and *how* it would be enforced
- // is currently under discussion; see rust-lang/rust#58794.
- //
- // In either case, we mark item as explicitly nounwind.
- false
+ // In both of these cases, we should refer to the ABI to determine whether or not we
+ // should unwind. See Rust RFC 2945 for more information on this behavior, here:
+ // https:/rust-lang/rfcs/blob/master/text/2945-c-unwind-abi.md
+ use SpecAbi::*;
+ match abi {
+ C { unwind } | Stdcall { unwind } | System { unwind } | Thiscall { unwind } => {
+ unwind
+ }
+ Cdecl
+ | Fastcall
+ | Vectorcall
+ | Aapcs
+ | Win64
+ | SysV64
+ | PtxKernel
+ | Msp430Interrupt
+ | X86Interrupt
+ | AmdGpuKernel
+ | EfiApi
+ | AvrInterrupt
+ | AvrNonBlockingInterrupt
+ | RustIntrinsic
+ | PlatformIntrinsic
+ | Unadjusted => false,
+ // In the `if` above, we checked for functions with the Rust calling convention.
+ Rust | RustCall => unreachable!(),
+ }
  }
  }
 }
@@ -2638,14 +2655,14 @@ where
  RustIntrinsic | PlatformIntrinsic | Rust | RustCall => Conv::Rust,
 
  // It's the ABI's job to select this, not ours.
- System => bug!("system abi should be selected elsewhere"),
+ System { .. } => bug!("system abi should be selected elsewhere"),
  EfiApi => bug!("eficall abi should be selected elsewhere"),
 
- Stdcall => Conv::X86Stdcall,
+ Stdcall { .. } => Conv::X86Stdcall,
  Fastcall => Conv::X86Fastcall,
  Vectorcall => Conv::X86VectorCall,
- Thiscall => Conv::X86ThisCall,
- C => Conv::C,
+ Thiscall { .. } => Conv::X86ThisCall,
+ C { .. } => Conv::C,
  Unadjusted => Conv::C,
  Win64 => Conv::X86_64Win64,
  SysV64 => Conv::X86_64SysV,
@@ -2806,7 +2823,12 @@ where
  c_variadic: sig.c_variadic,
  fixed_count: inputs.len(),
  conv,
- can_unwind: fn_can_unwind(cx.tcx().sess.panic_strategy(), codegen_fn_attr_flags, conv),
+ can_unwind: fn_can_unwind(
+ cx.tcx().sess.panic_strategy(),
+ codegen_fn_attr_flags,
+ conv,
+ sig.abi,
+ ),
  };
  fn_abi.adjust_for_abi(cx, sig.abi);
  debug!("FnAbi::new_internal = {:?}", fn_abi);