diff --git a/mk/main.mk b/mk/main.mk index 3448c0aa0caf7..aa70f4a2985f2 100644 --- a/mk/main.mk +++ b/mk/main.mk @@ -18,7 +18,7 @@ CFG_RELEASE_NUM=1.11.0 # An optional number to put after the label, e.g. '.2' -> '-beta.2' # NB Make sure it starts with a dot to conform to semver pre-release # versions (section 9) -CFG_PRERELEASE_VERSION=.2 +CFG_PRERELEASE_VERSION=.3 # Append a version-dependent hash to each library, so we can install different # versions in the same place diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index 7a572fdadc3d7..590220f0c8b64 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -75,7 +75,6 @@ use debuginfo::{self, DebugLoc, ToDebugLoc}; use declare; use expr; use glue; -use inline; use machine; use machine::{llalign_of_min, llsize_of, llsize_of_real}; use meth; @@ -1407,19 +1406,17 @@ impl<'blk, 'tcx> FunctionContext<'blk, 'tcx> { pub fn new(ccx: &'blk CrateContext<'blk, 'tcx>, llfndecl: ValueRef, fn_ty: FnType, - definition: Option<(Instance<'tcx>, &ty::FnSig<'tcx>, Abi)>, + definition: Option<(Instance<'tcx>, &ty::FnSig<'tcx>, Abi, ast::NodeId)>, block_arena: &'blk TypedArena>) -> FunctionContext<'blk, 'tcx> { - let (param_substs, def_id) = match definition { - Some((instance, _, _)) => { + let (param_substs, def_id, inlined_id) = match definition { + Some((instance, _, _, inlined_id)) => { common::validate_substs(instance.substs); - (instance.substs, Some(instance.def)) + (instance.substs, Some(instance.def), Some(inlined_id)) } - None => (ccx.tcx().mk_substs(Substs::empty()), None) + None => (ccx.tcx().mk_substs(Substs::empty()), None, None) }; - let inlined_did = def_id.and_then(|def_id| inline::get_local_instance(ccx, def_id)); - let inlined_id = inlined_did.and_then(|id| ccx.tcx().map.as_local_node_id(id)); let local_id = def_id.and_then(|id| ccx.tcx().map.as_local_node_id(id)); debug!("FunctionContext::new({})", @@ -1454,7 +1451,7 @@ impl<'blk, 'tcx> FunctionContext<'blk, 'tcx> { }; let debug_context = if let (false, Some(definition)) = (no_debug, definition) { - let (instance, sig, abi) = definition; + let (instance, sig, abi, _) = definition; debuginfo::create_function_debug_context(ccx, instance, sig, abi, llfndecl) } else { debuginfo::empty_function_debug_context(ccx) @@ -1850,7 +1847,11 @@ pub fn trans_closure<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let (arena, fcx): (TypedArena<_>, FunctionContext); arena = TypedArena::new(); - fcx = FunctionContext::new(ccx, llfndecl, fn_ty, Some((instance, sig, abi)), &arena); + fcx = FunctionContext::new(ccx, + llfndecl, + fn_ty, + Some((instance, sig, abi, inlined_id)), + &arena); if fcx.mir.is_some() { return mir::trans_mir(&fcx); diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index eaf82f5f43ded..6f0334f4779b3 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -124,7 +124,7 @@ pub fn strip_unconfigured_items(mut krate: ast::Crate, sess: &ParseSess, should_ }; let err_count = sess.span_diagnostic.err_count(); - let krate_attrs = strip_unconfigured.process_cfg_attrs(krate.attrs.clone()); + let krate_attrs = strip_unconfigured.configure(krate.attrs.clone()).unwrap_or_default(); features = get_features(&sess.span_diagnostic, &krate_attrs); if err_count < sess.span_diagnostic.err_count() { krate.attrs = krate_attrs.clone(); // Avoid reconfiguring malformed `cfg_attr`s diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 92670cd9def90..70d924cf46d06 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -820,6 +820,12 @@ impl<'a> ExtCtxt<'a> { /// compilation on error, merely emits a non-fatal error and returns None. pub fn expr_to_string(cx: &mut ExtCtxt, expr: P, err_msg: &str) -> Option<(InternedString, ast::StrStyle)> { + // Update `expr.span`'s expn_id now in case expr is an `include!` macro invocation. + let expr = expr.map(|mut expr| { + expr.span.expn_id = cx.backtrace; + expr + }); + // we want to be able to handle e.g. concat("foo", "bar") let expr = cx.expander().fold_expr(expr); match expr.node { diff --git a/src/test/compile-fail/macro-expanded-include/foo/mod.rs b/src/test/compile-fail/macro-expanded-include/foo/mod.rs index 57b7b72a1d435..888bdf5179a23 100644 --- a/src/test/compile-fail/macro-expanded-include/foo/mod.rs +++ b/src/test/compile-fail/macro-expanded-include/foo/mod.rs @@ -13,3 +13,7 @@ macro_rules! m { () => { include!("file.txt"); } } + +macro_rules! n { + () => { unsafe { asm!(include_str!("file.txt")); } } +} diff --git a/src/test/compile-fail/macro-expanded-include/test.rs b/src/test/compile-fail/macro-expanded-include/test.rs index 7ab9dd19b1b70..e1e85ddb2c1b1 100644 --- a/src/test/compile-fail/macro-expanded-include/test.rs +++ b/src/test/compile-fail/macro-expanded-include/test.rs @@ -8,12 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(rustc_attrs)] +#![feature(asm, rustc_attrs)] +#![allow(unused)] #[macro_use] mod foo; m!(); +fn f() { n!(); } #[rustc_error] fn main() {} //~ ERROR compilation successful diff --git a/src/test/run-pass/auxiliary/xcrate_generic_fn_nested_return.rs b/src/test/run-pass/auxiliary/xcrate_generic_fn_nested_return.rs new file mode 100644 index 0000000000000..48fb05f7779d2 --- /dev/null +++ b/src/test/run-pass/auxiliary/xcrate_generic_fn_nested_return.rs @@ -0,0 +1,26 @@ +// Copyright 2016 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +pub struct Request { + pub id: String, + pub arg: String, +} + +pub fn decode() -> Result { + (|| { + Ok(Request { + id: "hi".to_owned(), + arg: match Err(()) { + Ok(v) => v, + Err(e) => return Err(e) + }, + }) + })() +} diff --git a/src/test/run-pass/issue-34932.rs b/src/test/run-pass/issue-34932.rs new file mode 100644 index 0000000000000..e83939e7aec6b --- /dev/null +++ b/src/test/run-pass/issue-34932.rs @@ -0,0 +1,23 @@ +// Copyright 2016 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// compile-flags:--test +// rustc-env:RUSTC_BOOTSTRAP_KEY= +// ignore-pretty : (#23623) problems when ending with // comments + +#![cfg(any())] // This test should be configured away +#![feature(rustc_attrs)] // Test that this is allowed on stable/beta +#![feature(iter_arith_traits)] // Test that this is not unused +#![deny(unused_features)] + +#[test] +fn dummy() { + let () = "this should not reach type-checking"; +} diff --git a/src/test/run-pass/xcrate_generic_fn_nested_return.rs b/src/test/run-pass/xcrate_generic_fn_nested_return.rs new file mode 100644 index 0000000000000..181c91686823d --- /dev/null +++ b/src/test/run-pass/xcrate_generic_fn_nested_return.rs @@ -0,0 +1,17 @@ +// Copyright 2016 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// aux-build:xcrate_generic_fn_nested_return.rs + +extern crate xcrate_generic_fn_nested_return as test; + +pub fn main() { + assert!(test::decode::<()>().is_err()); +}