From adfebed9db8d280487a8056f5b56331e3af7a33a Mon Sep 17 00:00:00 2001 From: Samuel Holland Date: Mon, 28 Aug 2017 11:22:11 -0500 Subject: [PATCH 01/14] Explicitly run perl for OpenSSL Configure OpenSSL's Configure script is missing a shebang. On some platforms, execve falls back to execution with the shell. Some other platforms, like musl, will fail with an exec format error. Avoid this by calling perl explicitly (since it's a perl script). --- src/bootstrap/native.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs index 0a307e72bf61d..dfbef044fee86 100644 --- a/src/bootstrap/native.rs +++ b/src/bootstrap/native.rs @@ -388,7 +388,8 @@ impl Step for Openssl { drop(fs::remove_dir_all(&dst)); build.run(Command::new("tar").arg("xf").arg(&tarball).current_dir(&out)); - let mut configure = Command::new(obj.join("Configure")); + let mut configure = Command::new("perl"); + configure.arg(obj.join("Configure")); configure.arg(format!("--prefix={}", dst.display())); configure.arg("no-dso"); configure.arg("no-ssl2"); From 1ffc3ddfe2353feccc62a63de2db1a8356195e3f Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Wed, 6 Sep 2017 08:28:15 +1200 Subject: [PATCH 02/14] Attempt to fix the component manifest problem for rls-preview cc #44270 --- src/bootstrap/dist.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs index 05d59e7d59565..2e243b022c314 100644 --- a/src/bootstrap/dist.rs +++ b/src/bootstrap/dist.rs @@ -1088,8 +1088,14 @@ impl Step for Rls { .arg("--output-dir").arg(&distdir(build)) .arg("--non-installed-overlay").arg(&overlay) .arg(format!("--package-name={}-{}", name, target)) - .arg("--component-name=rls") .arg("--legacy-manifest-dirs=rustlib,cargo"); + + if build.config.channel == "nightly" { + cmd.arg("--component-name=rls"); + } else { + cmd.arg("--component-name=rls-preview"); + } + build.run(&mut cmd); distdir(build).join(format!("{}-{}.tar.gz", name, target)) } From 55f90877ee9b2bce604c12838155c4b748dea571 Mon Sep 17 00:00:00 2001 From: Oliver Middleton Date: Wed, 6 Sep 2017 16:20:44 +0100 Subject: [PATCH 03/14] rustdoc: Don't counts ids twice when using --enable-commonmark --- src/librustdoc/html/render.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index cc84e340c74f8..83818e0600ec7 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1752,9 +1752,13 @@ fn render_markdown(w: &mut fmt::Formatter, prefix: &str, scx: &SharedContext) -> fmt::Result { - let hoedown_output = format!("{}", Markdown(md_text, RenderType::Hoedown)); // We only emit warnings if the user has opted-in to Pulldown rendering. let output = if render_type == RenderType::Pulldown { + // Save the state of USED_ID_MAP so it only gets updated once even + // though we're rendering twice. + let orig_used_id_map = USED_ID_MAP.with(|map| map.borrow().clone()); + let hoedown_output = format!("{}", Markdown(md_text, RenderType::Hoedown)); + USED_ID_MAP.with(|map| *map.borrow_mut() = orig_used_id_map); let pulldown_output = format!("{}", Markdown(md_text, RenderType::Pulldown)); let differences = html_diff::get_differences(&pulldown_output, &hoedown_output); let differences = differences.into_iter() @@ -1775,7 +1779,7 @@ fn render_markdown(w: &mut fmt::Formatter, pulldown_output } else { - hoedown_output + format!("{}", Markdown(md_text, RenderType::Hoedown)) }; write!(w, "
{}{}
", prefix, output) From b4d0f6177188c6d00d124bd6246612bea6e3295b Mon Sep 17 00:00:00 2001 From: Tobias Bucher Date: Thu, 7 Sep 2017 11:26:23 +0200 Subject: [PATCH 04/14] Clarify the behavior of UDP sockets wrt. multiple addresses in `connect` --- src/libstd/net/udp.rs | 25 +++++++++---------------- 1 file changed, 9 insertions(+), 16 deletions(-) diff --git a/src/libstd/net/udp.rs b/src/libstd/net/udp.rs index 35001833383c0..e791f0ec63429 100644 --- a/src/libstd/net/udp.rs +++ b/src/libstd/net/udp.rs @@ -586,8 +586,11 @@ impl UdpSocket { /// receive data from the specified address. /// /// If `addr` yields multiple addresses, `connect` will be attempted with - /// each of the addresses until a connection is successful. If none of - /// the addresses are able to be connected, the error returned from the + /// each of the addresses until the underlying OS function returns no + /// error. Note that usually, a successful `connect` call does not specify + /// that there is a remote server listening on the port, rather, such an + /// error would only be detected after the first send. If the OS returns an + /// error for each of the specified addresses, the error returned from the /// last connection attempt (the last address) is returned. /// /// # Examples @@ -602,20 +605,10 @@ impl UdpSocket { /// socket.connect("127.0.0.1:8080").expect("connect function failed"); /// ``` /// - /// Create a UDP socket bound to `127.0.0.1:3400` and connect the socket to - /// `127.0.0.1:8080`. If that connection fails, then the UDP socket will - /// connect to `127.0.0.1:8081`: - /// - /// ```no_run - /// use std::net::{SocketAddr, UdpSocket}; - /// - /// let socket = UdpSocket::bind("127.0.0.1:3400").expect("couldn't bind to address"); - /// let connect_addrs = [ - /// SocketAddr::from(([127, 0, 0, 1], 8080)), - /// SocketAddr::from(([127, 0, 0, 1], 8081)), - /// ]; - /// socket.connect(&connect_addrs[..]).expect("connect function failed"); - /// ``` + /// Unlike in the TCP case, passing an array of addresses to the `connect` + /// function of a UDP socket is not a useful thing to do: The OS will be + /// unable to determine whether something is listening on the remote + /// address without the application sending data. #[stable(feature = "net2_mutators", since = "1.9.0")] pub fn connect(&self, addr: A) -> io::Result<()> { super::each_addr(addr, |addr| self.0.connect(addr)) From cd1bf6df4a992d50203385a488cb9ef7251eae5d Mon Sep 17 00:00:00 2001 From: smt923 Date: Sun, 10 Sep 2017 04:10:19 +0100 Subject: [PATCH 05/14] Added short examples for 'str::from_utf8_mut' --- src/libcore/str/mod.rs | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 62e84c9ebd017..bac3d509c1714 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -302,6 +302,36 @@ pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> { } /// Converts a mutable slice of bytes to a mutable string slice. +/// +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// use std::str; +/// +/// // "Hello, Rust!" as a mutable vector +/// let mut hellorust = vec![72, 101, 108, 108, 111, 44, 32, 82, 117, 115, 116, 33]; +/// +/// // As we know these bytes are valid, we can use `unwrap()` +/// let outstr = str::from_utf8_mut(&mut hellorust).unwrap(); +/// +/// assert_eq!("Hello, Rust!", outstr); +/// ``` +/// +/// # Incorrect bytes: +/// +/// ``` +/// use std::str; +/// +/// // Some invalid bytes in a mutable vector +/// let mut invalid = vec![128, 223]; +/// +/// assert!(str::from_utf8_mut(&mut invalid).is_err()); +/// ``` +/// See the docs for [`Utf8Error`][error] for more details on the kinds of +/// errors that can be returned. +/// #[stable(feature = "str_mut_extras", since = "1.20.0")] pub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> { run_utf8_validation(v)?; From 51bbd6957523fbda1db57fd0d92f356a0ed6ac08 Mon Sep 17 00:00:00 2001 From: smt923 Date: Sun, 10 Sep 2017 04:33:24 +0100 Subject: [PATCH 06/14] Fix incorrect markdown title --- src/libcore/str/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index bac3d509c1714..f0dde8fc342d9 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -319,7 +319,7 @@ pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> { /// assert_eq!("Hello, Rust!", outstr); /// ``` /// -/// # Incorrect bytes: +/// Incorrect bytes: /// /// ``` /// use std::str; From f20b030f02b1124cc3ff76cc906baba6588738e1 Mon Sep 17 00:00:00 2001 From: smt923 Date: Sun, 10 Sep 2017 14:08:20 +0100 Subject: [PATCH 07/14] Fix trailing whitespace --- src/libcore/str/mod.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index f0dde8fc342d9..a9e72d6a4a8c5 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -331,7 +331,6 @@ pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> { /// ``` /// See the docs for [`Utf8Error`][error] for more details on the kinds of /// errors that can be returned. -/// #[stable(feature = "str_mut_extras", since = "1.20.0")] pub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> { run_utf8_validation(v)?; From bc1a4c635703e08f0ee5830b389b2b804e82d76b Mon Sep 17 00:00:00 2001 From: Tommy Ip Date: Sat, 9 Sep 2017 13:08:26 +0100 Subject: [PATCH 08/14] Add doc example to String::as_mut_str Fixes #44429. --- src/liballoc/string.rs | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/src/liballoc/string.rs b/src/liballoc/string.rs index ddb23b2ef37bf..9fef66f2c0aae 100644 --- a/src/liballoc/string.rs +++ b/src/liballoc/string.rs @@ -749,7 +749,22 @@ impl String { self } - /// Extracts a string slice containing the entire string. + /// Converts a `String` into a mutable string slice. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::ascii::AsciiExt; + /// + /// let mut s = String::from("foobar"); + /// let s_mut_str = s.as_mut_str(); + /// + /// s_mut_str.make_ascii_uppercase(); + /// + /// assert_eq!("FOOBAR", s_mut_str); + /// ``` #[inline] #[stable(feature = "string_as_str", since = "1.7.0")] pub fn as_mut_str(&mut self) -> &mut str { From 303b7c2410d4b9039d0b5cb3badaa64e1cd0fede Mon Sep 17 00:00:00 2001 From: smt923 Date: Sun, 10 Sep 2017 14:12:23 +0100 Subject: [PATCH 09/14] Fix markdown link for Utf8Error --- src/libcore/str/mod.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index a9e72d6a4a8c5..e731156afa0c4 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -318,7 +318,7 @@ pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> { /// /// assert_eq!("Hello, Rust!", outstr); /// ``` -/// +/// /// Incorrect bytes: /// /// ``` @@ -331,6 +331,8 @@ pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> { /// ``` /// See the docs for [`Utf8Error`][error] for more details on the kinds of /// errors that can be returned. +/// +/// [error]: struct.Utf8Error.html #[stable(feature = "str_mut_extras", since = "1.20.0")] pub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> { run_utf8_validation(v)?; From 204414bcf4d3e040c1d3187dfaf6b5781b186ed0 Mon Sep 17 00:00:00 2001 From: smt923 Date: Sun, 10 Sep 2017 14:25:23 +0100 Subject: [PATCH 10/14] Actually fix the trailing whitespace --- src/libcore/str/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index e731156afa0c4..ce33160839076 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -323,7 +323,7 @@ pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> { /// /// ``` /// use std::str; -/// +/// /// // Some invalid bytes in a mutable vector /// let mut invalid = vec![128, 223]; /// From 01e9712a77f6f756bb72825600c60e3e6a5760ac Mon Sep 17 00:00:00 2001 From: Michael Woerister Date: Tue, 5 Sep 2017 16:48:24 +0200 Subject: [PATCH 11/14] Remove the `cstore` reference from Session in order to prepare encapsulating CrateStore access in tcx. --- src/librustc/hir/lowering.rs | 9 +++++-- src/librustc/middle/resolve_lifetime.rs | 13 +++++++--- src/librustc/session/config.rs | 17 +++++------- src/librustc/session/mod.rs | 14 +++------- src/librustc/ty/context.rs | 17 +++++++++--- src/librustc/ty/item_path.rs | 2 +- src/librustc/ty/mod.rs | 8 +++--- src/librustc_driver/driver.rs | 26 +++++++++++++------ src/librustc_driver/lib.rs | 27 ++++++++++++++------ src/librustc_driver/pretty.rs | 9 +++++++ src/librustc_driver/test.rs | 6 ++--- src/librustc_metadata/cstore_impl.rs | 8 +++--- src/librustc_resolve/build_reduced_graph.rs | 26 +++++++++---------- src/librustc_resolve/lib.rs | 8 ++++-- src/librustc_resolve/macros.rs | 2 +- src/librustc_resolve/resolve_imports.rs | 2 +- src/librustc_trans/back/link.rs | 10 +++++--- src/librustc_trans/base.rs | 2 +- src/librustdoc/core.rs | 3 ++- src/librustdoc/test.rs | 4 +-- src/test/run-make/issue-19371/foo.rs | 2 +- src/test/run-pass-fulldeps/compiler-calls.rs | 2 ++ 22 files changed, 132 insertions(+), 85 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index db86c4f93ee52..9b4ab10be9399 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -46,6 +46,7 @@ use hir::map::definitions::DefPathData; use hir::def_id::{DefIndex, DefId, CRATE_DEF_INDEX}; use hir::def::{Def, PathResolution}; use lint::builtin::PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES; +use middle::cstore::CrateStore; use rustc_data_structures::indexed_vec::IndexVec; use session::Session; use util::common::FN_OUTPUT_NAME; @@ -75,6 +76,8 @@ pub struct LoweringContext<'a> { // Use to assign ids to hir nodes that do not directly correspond to an ast node sess: &'a Session, + cstore: &'a CrateStore, + // As we walk the AST we must keep track of the current 'parent' def id (in // the form of a DefIndex) so that if we create a new node which introduces // a definition, then we can properly create the def id. @@ -119,6 +122,7 @@ pub trait Resolver { } pub fn lower_crate(sess: &Session, + cstore: &CrateStore, krate: &Crate, resolver: &mut Resolver) -> hir::Crate { @@ -130,6 +134,7 @@ pub fn lower_crate(sess: &Session, LoweringContext { crate_root: std_inject::injected_crate_name(krate), sess, + cstore, parent_def: None, resolver, name_map: FxHashMap(), @@ -535,7 +540,7 @@ impl<'a> LoweringContext<'a> { if id.is_local() { self.resolver.definitions().def_key(id.index) } else { - self.sess.cstore.def_key(id) + self.cstore.def_key(id) } } @@ -787,7 +792,7 @@ impl<'a> LoweringContext<'a> { return n; } assert!(!def_id.is_local()); - let n = self.sess.cstore.item_generics_cloned_untracked(def_id).regions.len(); + let n = self.cstore.item_generics_cloned_untracked(def_id).regions.len(); self.type_def_lifetime_params.insert(def_id, n); n }); diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index c53e255f0cdab..657c30289ebb5 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -16,9 +16,10 @@ //! way. Therefore we break lifetime name resolution into a separate pass. use hir::map::Map; -use session::Session; use hir::def::Def; use hir::def_id::DefId; +use middle::cstore::CrateStore; +use session::Session; use ty; use std::cell::Cell; @@ -160,6 +161,7 @@ pub struct NamedRegionMap { struct LifetimeContext<'a, 'tcx: 'a> { sess: &'a Session, + cstore: &'a CrateStore, hir_map: &'a Map<'tcx>, map: &'a mut NamedRegionMap, scope: ScopeRef<'a>, @@ -251,6 +253,7 @@ type ScopeRef<'a> = &'a Scope<'a>; const ROOT_SCOPE: ScopeRef<'static> = &Scope::Root; pub fn krate(sess: &Session, + cstore: &CrateStore, hir_map: &Map) -> Result { let krate = hir_map.krate(); @@ -262,6 +265,7 @@ pub fn krate(sess: &Session, sess.track_errors(|| { let mut visitor = LifetimeContext { sess, + cstore, hir_map, map: &mut map, scope: ROOT_SCOPE, @@ -765,12 +769,13 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { fn with(&mut self, wrap_scope: Scope, f: F) where F: for<'b> FnOnce(ScopeRef, &mut LifetimeContext<'b, 'tcx>), { - let LifetimeContext {sess, hir_map, ref mut map, ..} = *self; + let LifetimeContext {sess, cstore, hir_map, ref mut map, ..} = *self; let labels_in_fn = replace(&mut self.labels_in_fn, vec![]); let xcrate_object_lifetime_defaults = replace(&mut self.xcrate_object_lifetime_defaults, DefIdMap()); let mut this = LifetimeContext { sess, + cstore, hir_map, map: *map, scope: &wrap_scope, @@ -932,7 +937,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { let def_key = if def_id.is_local() { this.hir_map.def_key(def_id) } else { - this.sess.cstore.def_key(def_id) + this.cstore.def_key(def_id) }; DefId { krate: def_id.krate, @@ -976,7 +981,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { let unsubst = if let Some(id) = self.hir_map.as_local_node_id(def_id) { &map.object_lifetime_defaults[&id] } else { - let cstore = &self.sess.cstore; + let cstore = self.cstore; self.xcrate_object_lifetime_defaults.entry(def_id).or_insert_with(|| { cstore.item_generics_cloned_untracked(def_id).types.into_iter().map(|def| { def.object_lifetime_default diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 577c905a1d5a6..0882e8f6277c9 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1953,13 +1953,12 @@ mod tests { use errors; use getopts; use lint; - use middle::cstore::{self, DummyCrateStore}; + use middle::cstore; use session::config::{build_configuration, build_session_options_and_crate_config}; use session::build_session; use std::collections::{BTreeMap, BTreeSet}; use std::iter::FromIterator; use std::path::PathBuf; - use std::rc::Rc; use super::{OutputType, OutputTypes, Externs}; use rustc_back::{PanicStrategy, RelroLevel}; use syntax::symbol::Symbol; @@ -1991,7 +1990,7 @@ mod tests { }; let registry = errors::registry::Registry::new(&[]); let (sessopts, cfg) = build_session_options_and_crate_config(matches); - let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); let cfg = build_configuration(&sess, cfg); assert!(cfg.contains(&(Symbol::intern("test"), None))); } @@ -2010,8 +2009,7 @@ mod tests { }; let registry = errors::registry::Registry::new(&[]); let (sessopts, cfg) = build_session_options_and_crate_config(matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); let cfg = build_configuration(&sess, cfg); let mut test_items = cfg.iter().filter(|&&(name, _)| name == "test"); assert!(test_items.next().is_some()); @@ -2027,8 +2025,7 @@ mod tests { ]).unwrap(); let registry = errors::registry::Registry::new(&[]); let (sessopts, _) = build_session_options_and_crate_config(&matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); assert!(!sess.diagnostic().can_emit_warnings); } @@ -2039,8 +2036,7 @@ mod tests { ]).unwrap(); let registry = errors::registry::Registry::new(&[]); let (sessopts, _) = build_session_options_and_crate_config(&matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); assert!(sess.diagnostic().can_emit_warnings); } @@ -2050,8 +2046,7 @@ mod tests { ]).unwrap(); let registry = errors::registry::Registry::new(&[]); let (sessopts, _) = build_session_options_and_crate_config(&matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); assert!(sess.diagnostic().can_emit_warnings); } } diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 129a9f5575008..1f9cb2b03100f 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -15,7 +15,6 @@ use dep_graph::DepGraph; use hir::def_id::{CrateNum, DefIndex}; use lint; -use middle::cstore::CrateStore; use middle::allocator::AllocatorKind; use middle::dependency_format; use session::search_paths::PathKind; @@ -63,7 +62,6 @@ pub struct Session { pub target: config::Config, pub host: Target, pub opts: config::Options, - pub cstore: Rc, pub parse_sess: ParseSess, // For a library crate, this is always none pub entry_fn: RefCell>, @@ -621,8 +619,7 @@ impl Session { pub fn build_session(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, - registry: errors::registry::Registry, - cstore: Rc) + registry: errors::registry::Registry) -> Session { let file_path_mapping = sopts.file_path_mapping(); @@ -630,7 +627,6 @@ pub fn build_session(sopts: config::Options, dep_graph, local_crate_source_file, registry, - cstore, Rc::new(codemap::CodeMap::new(file_path_mapping)), None) } @@ -639,7 +635,6 @@ pub fn build_session_with_codemap(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, registry: errors::registry::Registry, - cstore: Rc, codemap: Rc, emitter_dest: Option>) -> Session { @@ -680,16 +675,14 @@ pub fn build_session_with_codemap(sopts: config::Options, dep_graph, local_crate_source_file, diagnostic_handler, - codemap, - cstore) + codemap) } pub fn build_session_(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, span_diagnostic: errors::Handler, - codemap: Rc, - cstore: Rc) + codemap: Rc) -> Session { let host = match Target::search(config::host_triple()) { Ok(t) => t, @@ -726,7 +719,6 @@ pub fn build_session_(sopts: config::Options, target: target_cfg, host, opts: sopts, - cstore, parse_sess: p_s, // For a library crate, this is always none entry_fn: RefCell::new(None), diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 18f286ebf5576..ae6605c30e78c 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -21,6 +21,7 @@ use hir::map as hir_map; use hir::map::DefPathHash; use lint::{self, Lint}; use ich::{self, StableHashingContext, NodeIdHashingMode}; +use middle::cstore::CrateStore; use middle::free_region::FreeRegionMap; use middle::lang_items; use middle::resolve_lifetime::{self, ObjectLifetimeDefault}; @@ -805,8 +806,11 @@ pub struct GlobalCtxt<'tcx> { global_arenas: &'tcx GlobalArenas<'tcx>, global_interners: CtxtInterners<'tcx>, + cstore: &'tcx CrateStore, + pub sess: &'tcx Session, + pub trans_trait_caches: traits::trans::TransTraitCaches<'tcx>, pub dep_graph: DepGraph, @@ -903,6 +907,10 @@ impl<'tcx> GlobalCtxt<'tcx> { } impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { + pub fn cstore_untracked(&self) -> &CrateStore { + &*self.cstore + } + pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics { self.global_arenas.generics.alloc(generics) } @@ -978,6 +986,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { /// value (types, substs, etc.) can only be used while `ty::tls` has a valid /// reference to the context, to allow formatting values that need it. pub fn create_and_enter(s: &'tcx Session, + cstore: &'tcx CrateStore, local_providers: ty::maps::Providers<'tcx>, extern_providers: ty::maps::Providers<'tcx>, mir_passes: Rc, @@ -994,16 +1003,15 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { let interners = CtxtInterners::new(arena); let common_types = CommonTypes::new(&interners); let dep_graph = hir.dep_graph.clone(); - let max_cnum = s.cstore.crates_untracked().iter().map(|c| c.as_usize()).max().unwrap_or(0); + let max_cnum = cstore.crates_untracked().iter().map(|c| c.as_usize()).max().unwrap_or(0); let mut providers = IndexVec::from_elem_n(extern_providers, max_cnum + 1); providers[LOCAL_CRATE] = local_providers; let def_path_hash_to_def_id = if s.opts.build_dep_graph() { - let upstream_def_path_tables: Vec<(CrateNum, Rc<_>)> = s - .cstore + let upstream_def_path_tables: Vec<(CrateNum, Rc<_>)> = cstore .crates_untracked() .iter() - .map(|&cnum| (cnum, s.cstore.def_path_table(cnum))) + .map(|&cnum| (cnum, cstore.def_path_table(cnum))) .collect(); let def_path_tables = || { @@ -1033,6 +1041,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { tls::enter_global(GlobalCtxt { sess: s, + cstore, trans_trait_caches: traits::trans::TransTraitCaches::new(dep_graph.clone()), global_arenas: arenas, global_interners: interners, diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index d9d311b14a36e..f6d87b0e1dce5 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -151,7 +151,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - cur_path.push(self.sess.cstore.def_key(cur_def) + cur_path.push(self.cstore_untracked().def_key(cur_def) .disambiguated_data.data.get_opt_name().unwrap_or_else(|| Symbol::intern("").as_str())); match visible_parent_map.get(&cur_def) { diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 5c29f4f24db6b..db7bed87d6a04 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2184,7 +2184,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if id.is_local() { self.hir.def_key(id) } else { - self.sess.cstore.def_key(id) + self.cstore_untracked().def_key(id) } } @@ -2197,7 +2197,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if id.is_local() { self.hir.def_path(id) } else { - self.sess.cstore.def_path(id) + self.cstore_untracked().def_path(id) } } @@ -2206,7 +2206,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if def_id.is_local() { self.hir.definitions().def_path_hash(def_id.index) } else { - self.sess.cstore.def_path_hash(def_id) + self.cstore_untracked().def_path_hash(def_id) } } @@ -2216,7 +2216,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } else if id.index == CRATE_DEF_INDEX { self.original_crate_name(id.krate).as_str() } else { - let def_key = self.sess.cstore.def_key(id); + let def_key = self.cstore_untracked().def_key(id); // The name of a StructCtor is that of its struct parent. if let hir_map::DefPathData::StructCtor = def_key.disambiguated_data.data { self.item_name(DefId { diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index b4dde2120a840..5a35de7b6aa2b 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -21,6 +21,7 @@ use rustc::session::config::{self, Input, OutputFilenames, OutputType}; use rustc::session::search_paths::PathKind; use rustc::lint; use rustc::middle::{self, stability, reachable}; +use rustc::middle::cstore::CrateStore; use rustc::middle::privacy::AccessLevels; use rustc::mir::transform::{MIR_CONST, MIR_VALIDATED, MIR_OPTIMIZED, Passes}; use rustc::ty::{self, TyCtxt, Resolutions, GlobalArenas}; @@ -200,6 +201,7 @@ pub fn compile_input(sess: &Session, }; phase_3_run_analysis_passes(sess, + cstore, hir_map, analysis, resolutions, @@ -272,7 +274,7 @@ pub fn compile_input(sess: &Session, phase5_result); phase5_result?; - phase_6_link_output(sess, &trans, &outputs); + phase_6_link_output(sess, cstore, &trans, &outputs); // Now that we won't touch anything in the incremental compilation directory // any more, we can finalize it (which involves renaming it) @@ -385,7 +387,7 @@ pub struct CompileState<'a, 'tcx: 'a> { pub session: &'tcx Session, pub krate: Option, pub registry: Option>, - pub cstore: Option<&'a CStore>, + pub cstore: Option<&'tcx CStore>, pub crate_name: Option<&'a str>, pub output_filenames: Option<&'a OutputFilenames>, pub out_dir: Option<&'a Path>, @@ -433,7 +435,7 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> { out_dir: &'a Option, out_file: &'a Option, krate: ast::Crate, - cstore: &'a CStore) + cstore: &'tcx CStore) -> Self { CompileState { // Initialize the registry before moving `krate` @@ -449,7 +451,7 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> { session: &'tcx Session, out_dir: &'a Option, out_file: &'a Option, - cstore: &'a CStore, + cstore: &'tcx CStore, expanded_crate: &'a ast::Crate, crate_name: &'a str) -> Self { @@ -468,7 +470,7 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> { out_file: &'a Option, arena: &'tcx DroplessArena, arenas: &'tcx GlobalArenas<'tcx>, - cstore: &'a CStore, + cstore: &'tcx CStore, hir_map: &'a hir_map::Map<'tcx>, analysis: &'a ty::CrateAnalysis, resolutions: &'a Resolutions, @@ -696,6 +698,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, let mut crate_loader = CrateLoader::new(sess, &cstore, crate_name); let resolver_arenas = Resolver::arenas(); let mut resolver = Resolver::new(sess, + cstore, &krate, crate_name, make_glob_map, @@ -844,7 +847,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, // Lower ast -> hir. let hir_forest = time(time_passes, "lowering ast -> hir", || { - let hir_crate = lower_crate(sess, &krate, &mut resolver); + let hir_crate = lower_crate(sess, cstore, &krate, &mut resolver); if sess.opts.debugging_opts.hir_stats { hir_stats::print_hir_stats(&hir_crate); @@ -886,6 +889,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, /// miscellaneous analysis passes on the crate. Return various /// structures carrying the results of the analysis. pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, + cstore: &'tcx CrateStore, hir_map: hir_map::Map<'tcx>, mut analysis: ty::CrateAnalysis, resolutions: Resolutions, @@ -915,7 +919,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, let named_region_map = time(time_passes, "lifetime resolution", - || middle::resolve_lifetime::krate(sess, &hir_map))?; + || middle::resolve_lifetime::krate(sess, cstore, &hir_map))?; time(time_passes, "looking for entry point", @@ -1012,6 +1016,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, passes.push_pass(MIR_OPTIMIZED, mir::transform::dump_mir::Marker("PreTrans")); TyCtxt::create_and_enter(sess, + cstore, local_providers, extern_providers, Rc::new(passes), @@ -1148,10 +1153,15 @@ pub fn phase_5_run_llvm_passes(sess: &Session, /// This should produce either a finished executable or library. #[cfg(feature="llvm")] pub fn phase_6_link_output(sess: &Session, + cstore: &CrateStore, trans: &trans::CrateTranslation, outputs: &OutputFilenames) { time(sess.time_passes(), "linking", || { - ::rustc_trans::back::link::link_binary(sess, trans, outputs, &trans.crate_name.as_str()) + ::rustc_trans::back::link::link_binary(sess, + cstore, + trans, + outputs, + &trans.crate_name.as_str()) }); } diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 78b20a73b83c3..099dda17823e6 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -72,6 +72,7 @@ use rustc::session::config::nightly_options; use rustc::session::{early_error, early_warn}; use rustc::lint::Lint; use rustc::lint; +use rustc::middle::cstore::CrateStore; use rustc_metadata::locator; use rustc_metadata::cstore::CStore; use rustc::util::common::{time, ErrorReported}; @@ -299,7 +300,7 @@ pub fn run_compiler<'a>(args: &[String], let loader = file_loader.unwrap_or(box RealFileLoader); let codemap = Rc::new(CodeMap::with_file_loader(loader, sopts.file_path_mapping())); let mut sess = session::build_session_with_codemap( - sopts, &dep_graph, input_file_path, descriptions, cstore.clone(), codemap, emitter_dest, + sopts, &dep_graph, input_file_path, descriptions, codemap, emitter_dest, ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); @@ -308,7 +309,12 @@ pub fn run_compiler<'a>(args: &[String], target_features::add_configuration(&mut cfg, &sess); sess.parse_sess.config = cfg; - do_or_return!(callbacks.late_callback(&matches, &sess, &input, &odir, &ofile), Some(sess)); + do_or_return!(callbacks.late_callback(&matches, + &sess, + &*cstore, + &input, + &odir, + &ofile), Some(sess)); let plugins = sess.opts.debugging_opts.extra_plugins.clone(); let control = callbacks.build_controller(&sess, &matches); @@ -400,6 +406,7 @@ pub trait CompilerCalls<'a> { fn late_callback(&mut self, _: &getopts::Matches, _: &Session, + _: &CrateStore, _: &Input, _: &Option, _: &Option) @@ -574,12 +581,10 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { return None; } let dep_graph = DepGraph::new(sopts.build_dep_graph()); - let cstore = Rc::new(CStore::new(box ::MetadataLoader)); let mut sess = build_session(sopts.clone(), &dep_graph, None, - descriptions.clone(), - cstore.clone()); + descriptions.clone()); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); let mut cfg = config::build_configuration(&sess, cfg.clone()); @@ -601,12 +606,13 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { fn late_callback(&mut self, matches: &getopts::Matches, sess: &Session, + cstore: &CrateStore, input: &Input, odir: &Option, ofile: &Option) -> Compilation { RustcDefaultCalls::print_crate_info(sess, Some(input), odir, ofile) - .and_then(|| RustcDefaultCalls::list_metadata(sess, matches, input)) + .and_then(|| RustcDefaultCalls::list_metadata(sess, cstore, matches, input)) } fn build_controller(&mut self, @@ -627,6 +633,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { }; control.after_hir_lowering.callback = box move |state| { pretty::print_after_hir_lowering(state.session, + state.cstore.unwrap(), state.hir_map.unwrap(), state.analysis.unwrap(), state.resolutions.unwrap(), @@ -711,7 +718,11 @@ fn save_analysis(sess: &Session) -> bool { } impl RustcDefaultCalls { - pub fn list_metadata(sess: &Session, matches: &getopts::Matches, input: &Input) -> Compilation { + pub fn list_metadata(sess: &Session, + cstore: &CrateStore, + matches: &getopts::Matches, + input: &Input) + -> Compilation { let r = matches.opt_strs("Z"); if r.contains(&("ls".to_string())) { match input { @@ -720,7 +731,7 @@ impl RustcDefaultCalls { let mut v = Vec::new(); locator::list_file_metadata(&sess.target.target, path, - sess.cstore.metadata_loader(), + cstore.metadata_loader(), &mut v) .unwrap(); println!("{}", String::from_utf8(v).unwrap()); diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index 6a58b7fb75360..82dda2d2aa162 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -21,6 +21,7 @@ use rustc::ty::{self, TyCtxt, GlobalArenas, Resolutions}; use rustc::cfg; use rustc::cfg::graphviz::LabelledCFG; use rustc::dep_graph::DepGraph; +use rustc::middle::cstore::CrateStore; use rustc::session::Session; use rustc::session::config::Input; use rustc_borrowck as borrowck; @@ -198,6 +199,7 @@ impl PpSourceMode { } fn call_with_pp_support_hir<'tcx, A, F>(&self, sess: &'tcx Session, + cstore: &'tcx CrateStore, hir_map: &hir_map::Map<'tcx>, analysis: &ty::CrateAnalysis, resolutions: &Resolutions, @@ -226,6 +228,7 @@ impl PpSourceMode { } PpmTyped => { abort_on_err(driver::phase_3_run_analysis_passes(sess, + cstore, hir_map.clone(), analysis.clone(), resolutions.clone(), @@ -875,6 +878,7 @@ pub fn print_after_parsing(sess: &Session, } pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, + cstore: &'tcx CrateStore, hir_map: &hir_map::Map<'tcx>, analysis: &ty::CrateAnalysis, resolutions: &Resolutions, @@ -891,6 +895,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, if ppm.needs_analysis() { print_with_analysis(sess, + cstore, hir_map, analysis, resolutions, @@ -929,6 +934,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, (PpmHir(s), None) => { let out: &mut Write = &mut out; s.call_with_pp_support_hir(sess, + cstore, hir_map, analysis, resolutions, @@ -952,6 +958,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, (PpmHir(s), Some(uii)) => { let out: &mut Write = &mut out; s.call_with_pp_support_hir(sess, + cstore, hir_map, analysis, resolutions, @@ -993,6 +1000,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, // with a different callback than the standard driver, so that isn't easy. // Instead, we call that function ourselves. fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session, + cstore: &'a CrateStore, hir_map: &hir_map::Map<'tcx>, analysis: &ty::CrateAnalysis, resolutions: &Resolutions, @@ -1013,6 +1021,7 @@ fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session, let mut out = Vec::new(); abort_on_err(driver::phase_3_run_analysis_passes(sess, + cstore, hir_map.clone(), analysis.clone(), resolutions.clone(), diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 8038045f762d5..10a6113d04f60 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -109,8 +109,7 @@ fn test_env(source_string: &str, &dep_graph, None, diagnostic_handler, - Rc::new(CodeMap::new(FilePathMapping::empty())), - cstore.clone()); + Rc::new(CodeMap::new(FilePathMapping::empty()))); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); let input = config::Input::Str { @@ -138,8 +137,9 @@ fn test_env(source_string: &str, let hir_map = hir_map::map_crate(&mut hir_forest, defs); // run just enough stuff to build a tcx: - let named_region_map = resolve_lifetime::krate(&sess, &hir_map); + let named_region_map = resolve_lifetime::krate(&sess, &*cstore, &hir_map); TyCtxt::create_and_enter(&sess, + &*cstore, ty::maps::Providers::default(), ty::maps::Providers::default(), Rc::new(Passes::new()), diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index c3742fc1d03d8..7579a58ed23fd 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -60,7 +60,7 @@ macro_rules! provide { $tcx.dep_graph.read(dep_node); - let $cdata = $tcx.sess.cstore.crate_data_as_rc_any($def_id.krate); + let $cdata = $tcx.cstore_untracked().crate_data_as_rc_any($def_id.krate); let $cdata = $cdata.downcast_ref::() .expect("CrateStore crated ata is not a CrateMetadata"); $compute @@ -277,12 +277,12 @@ pub fn provide_local<'tcx>(providers: &mut Providers<'tcx>) { }, extern_mod_stmt_cnum: |tcx, id| { let id = tcx.hir.definitions().find_node_for_hir_id(id); - tcx.sess.cstore.extern_mod_stmt_cnum_untracked(id) + tcx.cstore_untracked().extern_mod_stmt_cnum_untracked(id) }, all_crate_nums: |tcx, cnum| { assert_eq!(cnum, LOCAL_CRATE); - Rc::new(tcx.sess.cstore.crates_untracked()) + Rc::new(tcx.cstore_untracked().crates_untracked()) }, // Returns a map from a sufficiently visible external item (i.e. an @@ -344,7 +344,7 @@ pub fn provide_local<'tcx>(providers: &mut Providers<'tcx>) { postorder_cnums: |tcx, cnum| { assert_eq!(cnum, LOCAL_CRATE); - Rc::new(tcx.sess.cstore.postorder_cnums_untracked()) + Rc::new(tcx.cstore_untracked().postorder_cnums_untracked()) }, ..*providers diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 35e7522db0184..a4d1ae1621571 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -254,7 +254,7 @@ impl<'a> Resolver<'a> { self.crate_loader.process_item(item, &self.definitions); // n.b. we don't need to look at the path option here, because cstore already did - let crate_id = self.session.cstore.extern_mod_stmt_cnum_untracked(item.id).unwrap(); + let crate_id = self.cstore.extern_mod_stmt_cnum_untracked(item.id).unwrap(); let module = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX }); self.populate_module_if_necessary(module); @@ -450,7 +450,7 @@ impl<'a> Resolver<'a> { let ident = child.ident; let def = child.def; let def_id = def.def_id(); - let vis = self.session.cstore.visibility_untracked(def_id); + let vis = self.cstore.visibility_untracked(def_id); let span = child.span; let expansion = Mark::root(); // FIXME(jseyfried) intercrate hygiene match def { @@ -472,7 +472,7 @@ impl<'a> Resolver<'a> { self.define(parent, ident, ValueNS, (def, vis, DUMMY_SP, expansion)); if let Some(struct_def_id) = - self.session.cstore.def_key(def_id).parent + self.cstore.def_key(def_id).parent .map(|index| DefId { krate: def_id.krate, index: index }) { self.struct_constructors.insert(struct_def_id, (def, vis)); } @@ -486,12 +486,12 @@ impl<'a> Resolver<'a> { span); self.define(parent, ident, TypeNS, (module, vis, DUMMY_SP, expansion)); - for child in self.session.cstore.item_children_untracked(def_id, self.session) { + for child in self.cstore.item_children_untracked(def_id, self.session) { let ns = if let Def::AssociatedTy(..) = child.def { TypeNS } else { ValueNS }; self.define(module, child.ident, ns, (child.def, ty::Visibility::Public, DUMMY_SP, expansion)); - if self.session.cstore.associated_item_cloned_untracked(child.def.def_id()) + if self.cstore.associated_item_cloned_untracked(child.def.def_id()) .method_has_self_argument { self.has_self.insert(child.def.def_id()); } @@ -502,7 +502,7 @@ impl<'a> Resolver<'a> { self.define(parent, ident, TypeNS, (def, vis, DUMMY_SP, expansion)); // Record field names for error reporting. - let field_names = self.session.cstore.struct_field_names_untracked(def_id); + let field_names = self.cstore.struct_field_names_untracked(def_id); self.insert_field_names(def_id, field_names); } Def::Macro(..) => { @@ -517,15 +517,15 @@ impl<'a> Resolver<'a> { return self.module_map[&def_id] } - let macros_only = self.session.cstore.dep_kind_untracked(def_id.krate).macros_only(); + let macros_only = self.cstore.dep_kind_untracked(def_id.krate).macros_only(); if let Some(&module) = self.extern_module_map.get(&(def_id, macros_only)) { return module; } let (name, parent) = if def_id.index == CRATE_DEF_INDEX { - (self.session.cstore.crate_name_untracked(def_id.krate).as_str(), None) + (self.cstore.crate_name_untracked(def_id.krate).as_str(), None) } else { - let def_key = self.session.cstore.def_key(def_id); + let def_key = self.cstore.def_key(def_id); (def_key.disambiguated_data.data.get_opt_name().unwrap(), Some(self.get_module(DefId { index: def_key.parent.unwrap(), ..def_id }))) }; @@ -559,7 +559,7 @@ impl<'a> Resolver<'a> { return ext.clone(); } - let macro_def = match self.session.cstore.load_macro_untracked(def_id, &self.session) { + let macro_def = match self.cstore.load_macro_untracked(def_id, &self.session) { LoadedMacro::MacroDef(macro_def) => macro_def, LoadedMacro::ProcMacro(ext) => return ext, }; @@ -576,7 +576,7 @@ impl<'a> Resolver<'a> { pub fn populate_module_if_necessary(&mut self, module: Module<'a>) { if module.populated.get() { return } let def_id = module.def_id().unwrap(); - for child in self.session.cstore.item_children_untracked(def_id, self.session) { + for child in self.cstore.item_children_untracked(def_id, self.session) { self.build_reduced_graph_for_external_crate_def(module, child); } module.populated.set(true) @@ -607,7 +607,7 @@ impl<'a> Resolver<'a> { span_err!(self.session, item.span, E0468, "an `extern crate` loading macros must be at the crate root"); } else if !self.use_extern_macros && !used && - self.session.cstore.dep_kind_untracked(module.def_id().unwrap().krate) + self.cstore.dep_kind_untracked(module.def_id().unwrap().krate) .macros_only() { let msg = "proc macro crates and `#[no_link]` crates have no effect without \ `#[macro_use]`"; @@ -651,7 +651,7 @@ impl<'a> Resolver<'a> { } } for (name, span) in legacy_imports.reexports { - self.session.cstore.export_macros_untracked(module.def_id().unwrap().krate); + self.cstore.export_macros_untracked(module.def_id().unwrap().krate); let ident = Ident::with_empty_ctxt(name); let result = self.resolve_ident_in_module(module, ident, MacroNS, false, false, span); if let Ok(binding) = result { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 2183c9124e7f4..ee97002f6be56 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -31,7 +31,7 @@ use self::RibKind::*; use rustc::hir::map::{Definitions, DefCollector}; use rustc::hir::{self, PrimTy, TyBool, TyChar, TyFloat, TyInt, TyUint, TyStr}; -use rustc::middle::cstore::CrateLoader; +use rustc::middle::cstore::{CrateStore, CrateLoader}; use rustc::session::Session; use rustc::lint; use rustc::hir::def::*; @@ -1176,6 +1176,7 @@ impl PrimitiveTypeTable { /// The main resolver class. pub struct Resolver<'a> { session: &'a Session, + cstore: &'a CrateStore, pub definitions: Definitions, @@ -1343,7 +1344,7 @@ impl<'a, 'b: 'a> ty::DefIdTree for &'a Resolver<'b> { fn parent(self, id: DefId) -> Option { match id.krate { LOCAL_CRATE => self.definitions.def_key(id.index).parent, - _ => self.session.cstore.def_key(id).parent, + _ => self.cstore.def_key(id).parent, }.map(|index| DefId { index: index, ..id }) } } @@ -1383,6 +1384,7 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> { impl<'a> Resolver<'a> { pub fn new(session: &'a Session, + cstore: &'a CrateStore, krate: &Crate, crate_name: &str, make_glob_map: MakeGlobMap, @@ -1414,6 +1416,8 @@ impl<'a> Resolver<'a> { Resolver { session, + cstore, + definitions, // The outermost module has def ID 0; this is not reflected in the diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index c083a0ff58855..064032b888499 100644 --- a/src/librustc_resolve/macros.rs +++ b/src/librustc_resolve/macros.rs @@ -778,7 +778,7 @@ impl<'a> Resolver<'a> { _ => return, }; - let crate_name = self.session.cstore.crate_name_untracked(krate); + let crate_name = self.cstore.crate_name_untracked(krate); self.session.struct_span_err(use_span, warn_msg) .help(&format!("instead, import the procedural macro like any other item: \ diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 7524b7e8c6c21..ac35a9063ac8a 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -844,7 +844,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { let def = binding.def(); if def != Def::Err { if !def.def_id().is_local() { - self.session.cstore.export_macros_untracked(def.def_id().krate); + self.cstore.export_macros_untracked(def.def_id().krate); } if let Def::Macro(..) = def { if let Some(&span) = exported_macro_names.get(&ident.modern()) { diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 5d45aafe78d25..efb56ab5a6cac 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -185,7 +185,11 @@ pub fn link_binary(sess: &Session, bug!("invalid output type `{:?}` for target os `{}`", crate_type, sess.opts.target_triple); } - let mut out_files = link_binary_output(sess, trans, crate_type, outputs, crate_name); + let mut out_files = link_binary_output(sess, + trans, + crate_type, + outputs, + crate_name); out_filenames.append(&mut out_files); } @@ -346,8 +350,8 @@ fn link_binary_output(sess: &Session, tmpdir.path()); } _ => { - link_natively(sess, crate_type, &objects, &out_filename, trans, - outputs, tmpdir.path()); + link_natively(sess, crate_type, &objects, &out_filename, + trans, outputs, tmpdir.path()); } } out_filenames.push(out_filename); diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index 6cfde9c7bbc73..c3a4745bc3dcb 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -775,7 +775,7 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, EncodedMetadataHashes::new()); } - let cstore = &tcx.sess.cstore; + let cstore = tcx.cstore_untracked(); let (metadata, hashes) = cstore.encode_metadata(tcx, &link_meta, exported_symbols); diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 742d4bf197ee2..81396d41606a8 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -148,7 +148,7 @@ pub fn run_core(search_paths: SearchPaths, let _ignore = dep_graph.in_ignore(); let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader)); let mut sess = session::build_session_( - sessopts, &dep_graph, cpath, diagnostic_handler, codemap, cstore.clone() + sessopts, &dep_graph, cpath, diagnostic_handler, codemap ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); @@ -181,6 +181,7 @@ pub fn run_core(search_paths: SearchPaths, let hir_map = hir_map::map_crate(&mut hir_forest, defs); abort_on_err(driver::phase_3_run_analysis_passes(&sess, + &*cstore, hir_map, analysis, resolutions, diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 700bbe23bab72..9b76a713b1769 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -87,7 +87,7 @@ pub fn run(input: &str, let _ignore = dep_graph.in_ignore(); let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader)); let mut sess = session::build_session_( - sessopts, &dep_graph, Some(input_path.clone()), handler, codemap.clone(), cstore.clone(), + sessopts, &dep_graph, Some(input_path.clone()), handler, codemap.clone() ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); @@ -240,7 +240,7 @@ fn run_test(test: &str, cratename: &str, filename: &str, cfgs: Vec, libs let dep_graph = DepGraph::new(false); let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader)); let mut sess = session::build_session_( - sessopts, &dep_graph, None, diagnostic_handler, codemap, cstore.clone(), + sessopts, &dep_graph, None, diagnostic_handler, codemap ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); diff --git a/src/test/run-make/issue-19371/foo.rs b/src/test/run-make/issue-19371/foo.rs index 9caf83d995444..2e3fb785748f3 100644 --- a/src/test/run-make/issue-19371/foo.rs +++ b/src/test/run-make/issue-19371/foo.rs @@ -60,7 +60,7 @@ fn basic_sess(sysroot: PathBuf) -> (Session, Rc) { let descriptions = Registry::new(&rustc::DIAGNOSTICS); let dep_graph = DepGraph::new(opts.build_dep_graph()); let cstore = Rc::new(CStore::new(Box::new(rustc_trans::LlvmMetadataLoader))); - let sess = build_session(opts, &dep_graph, None, descriptions, cstore.clone()); + let sess = build_session(opts, &dep_graph, None, descriptions); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); (sess, cstore) diff --git a/src/test/run-pass-fulldeps/compiler-calls.rs b/src/test/run-pass-fulldeps/compiler-calls.rs index 4a397621ceb53..b5c1ee099037c 100644 --- a/src/test/run-pass-fulldeps/compiler-calls.rs +++ b/src/test/run-pass-fulldeps/compiler-calls.rs @@ -21,6 +21,7 @@ extern crate rustc_driver; extern crate syntax; extern crate rustc_errors as errors; +use rustc::middle::cstore::CrateStore; use rustc::session::Session; use rustc::session::config::{self, Input}; use rustc_driver::{driver, CompilerCalls, Compilation}; @@ -47,6 +48,7 @@ impl<'a> CompilerCalls<'a> for TestCalls { fn late_callback(&mut self, _: &getopts::Matches, _: &Session, + _: &CrateStore, _: &Input, _: &Option, _: &Option) From 224d47d9ee17389f1c1de678ce45bfc9b0cbee7d Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 7 Sep 2017 13:21:46 -0700 Subject: [PATCH 12/14] rustc: Make `CrateStore` private to `TyCtxt` This commit removes the `cstore_untracked` method, making the `CrateStore` trait object entirely private to the `ty/context.rs` module. --- src/librustc/ty/context.rs | 68 ++++++++++++++++++++++++++-- src/librustc/ty/item_path.rs | 2 +- src/librustc/ty/mod.rs | 32 +------------ src/librustc_driver/driver.rs | 4 +- src/librustc_metadata/cstore_impl.rs | 16 +------ src/librustc_trans/base.rs | 7 +-- src/librustdoc/build.rs | 1 + src/librustdoc/core.rs | 2 +- src/librustdoc/visit_ast.rs | 10 ++-- 9 files changed, 77 insertions(+), 65 deletions(-) diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index ae6605c30e78c..f471408fe75f3 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -21,7 +21,8 @@ use hir::map as hir_map; use hir::map::DefPathHash; use lint::{self, Lint}; use ich::{self, StableHashingContext, NodeIdHashingMode}; -use middle::cstore::CrateStore; +use middle::cstore::{CrateStore, LinkMeta, EncodedMetadataHashes}; +use middle::cstore::EncodedMetadata; use middle::free_region::FreeRegionMap; use middle::lang_items; use middle::resolve_lifetime::{self, ObjectLifetimeDefault}; @@ -51,6 +52,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher, use arena::{TypedArena, DroplessArena}; use rustc_data_structures::indexed_vec::IndexVec; +use std::any::Any; use std::borrow::Borrow; use std::cell::{Cell, RefCell}; use std::cmp::Ordering; @@ -907,10 +909,6 @@ impl<'tcx> GlobalCtxt<'tcx> { } impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { - pub fn cstore_untracked(&self) -> &CrateStore { - &*self.cstore - } - pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics { self.global_arenas.generics.alloc(generics) } @@ -1134,6 +1132,54 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { pub fn crates(self) -> Rc> { self.all_crate_nums(LOCAL_CRATE) } + + pub fn def_key(self, id: DefId) -> hir_map::DefKey { + if id.is_local() { + self.hir.def_key(id) + } else { + self.cstore.def_key(id) + } + } + + /// Convert a `DefId` into its fully expanded `DefPath` (every + /// `DefId` is really just an interned def-path). + /// + /// Note that if `id` is not local to this crate, the result will + /// be a non-local `DefPath`. + pub fn def_path(self, id: DefId) -> hir_map::DefPath { + if id.is_local() { + self.hir.def_path(id) + } else { + self.cstore.def_path(id) + } + } + + #[inline] + pub fn def_path_hash(self, def_id: DefId) -> hir_map::DefPathHash { + if def_id.is_local() { + self.hir.definitions().def_path_hash(def_id.index) + } else { + self.cstore.def_path_hash(def_id) + } + } + + pub fn metadata_encoding_version(self) -> Vec { + self.cstore.metadata_encoding_version().to_vec() + } + + // Note that this is *untracked* and should only be used within the query + // system if the result is otherwise tracked through queries + pub fn crate_data_as_rc_any(self, cnum: CrateNum) -> Rc { + self.cstore.crate_data_as_rc_any(cnum) + } +} + +impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { + pub fn encode_metadata(self, link_meta: &LinkMeta, reachable: &NodeSet) + -> (EncodedMetadata, EncodedMetadataHashes) + { + self.cstore.encode_metadata(self, link_meta, reachable) + } } impl<'gcx: 'tcx, 'tcx> GlobalCtxt<'gcx> { @@ -2069,4 +2115,16 @@ pub fn provide(providers: &mut ty::maps::Providers) { let id = tcx.hir.definitions().def_index_to_hir_id(id.index); tcx.stability().local_deprecation_entry(id) }; + providers.extern_mod_stmt_cnum = |tcx, id| { + let id = tcx.hir.definitions().find_node_for_hir_id(id); + tcx.cstore.extern_mod_stmt_cnum_untracked(id) + }; + providers.all_crate_nums = |tcx, cnum| { + assert_eq!(cnum, LOCAL_CRATE); + Rc::new(tcx.cstore.crates_untracked()) + }; + providers.postorder_cnums = |tcx, cnum| { + assert_eq!(cnum, LOCAL_CRATE); + Rc::new(tcx.cstore.postorder_cnums_untracked()) + }; } diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index f6d87b0e1dce5..cab5125494862 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -151,7 +151,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - cur_path.push(self.cstore_untracked().def_key(cur_def) + cur_path.push(self.def_key(cur_def) .disambiguated_data.data.get_opt_name().unwrap_or_else(|| Symbol::intern("").as_str())); match visible_parent_map.get(&cur_def) { diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index db7bed87d6a04..761143a50a2c5 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2180,43 +2180,13 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - pub fn def_key(self, id: DefId) -> hir_map::DefKey { - if id.is_local() { - self.hir.def_key(id) - } else { - self.cstore_untracked().def_key(id) - } - } - - /// Convert a `DefId` into its fully expanded `DefPath` (every - /// `DefId` is really just an interned def-path). - /// - /// Note that if `id` is not local to this crate, the result will - /// be a non-local `DefPath`. - pub fn def_path(self, id: DefId) -> hir_map::DefPath { - if id.is_local() { - self.hir.def_path(id) - } else { - self.cstore_untracked().def_path(id) - } - } - - #[inline] - pub fn def_path_hash(self, def_id: DefId) -> hir_map::DefPathHash { - if def_id.is_local() { - self.hir.definitions().def_path_hash(def_id.index) - } else { - self.cstore_untracked().def_path_hash(def_id) - } - } - pub fn item_name(self, id: DefId) -> InternedString { if let Some(id) = self.hir.as_local_node_id(id) { self.hir.name(id).as_str() } else if id.index == CRATE_DEF_INDEX { self.original_crate_name(id.krate).as_str() } else { - let def_key = self.cstore_untracked().def_key(id); + let def_key = self.def_key(id); // The name of a StructCtor is that of its struct parent. if let hir_map::DefPathData::StructCtor = def_key.disambiguated_data.data { self.item_name(DefId { diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 5a35de7b6aa2b..c41d5beec6877 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -274,7 +274,7 @@ pub fn compile_input(sess: &Session, phase5_result); phase5_result?; - phase_6_link_output(sess, cstore, &trans, &outputs); + phase_6_link_output(sess, &trans, &outputs); // Now that we won't touch anything in the incremental compilation directory // any more, we can finalize it (which involves renaming it) @@ -1153,12 +1153,10 @@ pub fn phase_5_run_llvm_passes(sess: &Session, /// This should produce either a finished executable or library. #[cfg(feature="llvm")] pub fn phase_6_link_output(sess: &Session, - cstore: &CrateStore, trans: &trans::CrateTranslation, outputs: &OutputFilenames) { time(sess.time_passes(), "linking", || { ::rustc_trans::back::link::link_binary(sess, - cstore, trans, outputs, &trans.crate_name.as_str()) diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index 7579a58ed23fd..74e4ffcdfffdc 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -60,7 +60,7 @@ macro_rules! provide { $tcx.dep_graph.read(dep_node); - let $cdata = $tcx.cstore_untracked().crate_data_as_rc_any($def_id.krate); + let $cdata = $tcx.crate_data_as_rc_any($def_id.krate); let $cdata = $cdata.downcast_ref::() .expect("CrateStore crated ata is not a CrateMetadata"); $compute @@ -275,15 +275,6 @@ pub fn provide_local<'tcx>(providers: &mut Providers<'tcx>) { assert_eq!(cnum, LOCAL_CRATE); Rc::new(link_args::collect(tcx)) }, - extern_mod_stmt_cnum: |tcx, id| { - let id = tcx.hir.definitions().find_node_for_hir_id(id); - tcx.cstore_untracked().extern_mod_stmt_cnum_untracked(id) - }, - - all_crate_nums: |tcx, cnum| { - assert_eq!(cnum, LOCAL_CRATE); - Rc::new(tcx.cstore_untracked().crates_untracked()) - }, // Returns a map from a sufficiently visible external item (i.e. an // external item that is visible from at least one local module) to a @@ -342,11 +333,6 @@ pub fn provide_local<'tcx>(providers: &mut Providers<'tcx>) { Rc::new(visible_parent_map) }, - postorder_cnums: |tcx, cnum| { - assert_eq!(cnum, LOCAL_CRATE); - Rc::new(tcx.cstore_untracked().postorder_cnums_untracked()) - }, - ..*providers }; } diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index c3a4745bc3dcb..4c611cccf581f 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -775,16 +775,13 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, EncodedMetadataHashes::new()); } - let cstore = tcx.cstore_untracked(); - let (metadata, hashes) = cstore.encode_metadata(tcx, - &link_meta, - exported_symbols); + let (metadata, hashes) = tcx.encode_metadata(link_meta, exported_symbols); if kind == MetadataKind::Uncompressed { return (metadata_llcx, metadata_llmod, metadata, hashes); } assert!(kind == MetadataKind::Compressed); - let mut compressed = cstore.metadata_encoding_version().to_vec(); + let mut compressed = tcx.metadata_encoding_version(); DeflateEncoder::new(&mut compressed, Compression::Fast) .write_all(&metadata.raw_data).unwrap(); diff --git a/src/librustdoc/build.rs b/src/librustdoc/build.rs index 130c6fd01a8d8..386550f511a52 100644 --- a/src/librustdoc/build.rs +++ b/src/librustdoc/build.rs @@ -25,6 +25,7 @@ fn main() { .file("../rt/hoedown/src/stack.c") .file("../rt/hoedown/src/version.c") .include(src_dir) + .warnings(false) .compile("libhoedown.a"); } diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 81396d41606a8..d7ce5e262ce38 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -215,7 +215,7 @@ pub fn run_core(search_paths: SearchPaths, debug!("crate: {:?}", tcx.hir.krate()); let krate = { - let mut v = RustdocVisitor::new(&ctxt); + let mut v = RustdocVisitor::new(&*cstore, &ctxt); v.visit(tcx.hir.krate()); v.clean(&ctxt) }; diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index d354d726ff703..4fed218ba0871 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -21,7 +21,7 @@ use syntax_pos::Span; use rustc::hir::map as hir_map; use rustc::hir::def::Def; use rustc::hir::def_id::{DefId, LOCAL_CRATE}; -use rustc::middle::cstore::LoadedMacro; +use rustc::middle::cstore::{LoadedMacro, CrateStore}; use rustc::middle::privacy::AccessLevel; use rustc::util::nodemap::FxHashSet; @@ -40,6 +40,7 @@ use doctree::*; // framework from syntax? pub struct RustdocVisitor<'a, 'tcx: 'a> { + cstore: &'tcx CrateStore, pub module: Module, pub attrs: hir::HirVec, pub cx: &'a core::DocContext<'a, 'tcx>, @@ -51,7 +52,8 @@ pub struct RustdocVisitor<'a, 'tcx: 'a> { } impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { - pub fn new(cx: &'a core::DocContext<'a, 'tcx>) -> RustdocVisitor<'a, 'tcx> { + pub fn new(cstore: &'tcx CrateStore, + cx: &'a core::DocContext<'a, 'tcx>) -> RustdocVisitor<'a, 'tcx> { // If the root is reexported, terminate all recursion. let mut stack = FxHashSet(); stack.insert(ast::CRATE_NODE_ID); @@ -63,6 +65,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { inlining: false, inside_public_path: true, reexported_macros: FxHashSet(), + cstore, } } @@ -208,8 +211,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { } let imported_from = self.cx.tcx.original_crate_name(def_id.krate); - let cstore = &self.cx.sess().cstore; - let def = match cstore.load_macro_untracked(def_id, self.cx.sess()) { + let def = match self.cstore.load_macro_untracked(def_id, self.cx.sess()) { LoadedMacro::MacroDef(macro_def) => macro_def, // FIXME(jseyfried): document proc macro reexports LoadedMacro::ProcMacro(..) => continue, From 69b949455d6f447c573b48fb4525813af93c9ed1 Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Sun, 10 Sep 2017 13:21:37 -0400 Subject: [PATCH 13/14] Alphabetize current label explanations So that you can scroll down the list of labels along with these explanations. --- CONTRIBUTING.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 7441d51055ffb..6d150c05d8bb2 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -400,6 +400,9 @@ labels to triage issues: * Magenta, **B**-prefixed labels identify bugs which are **blockers**. +* Dark blue, **beta-** labels track changes which need to be backported into + the beta branches. + * Green, **E**-prefixed labels explain the level of **experience** necessary to fix the issue. @@ -407,18 +410,15 @@ labels to triage issues: [I-nominated][inom] label indicates that an issue has been nominated for prioritizing at the next triage meeting. +* The purple **metabug** label marks lists of bugs collected by other + categories. + * Orange, **P**-prefixed labels indicate a bug's **priority**. These labels are only assigned during triage meetings, and replace the [I-nominated][inom] label. * Blue, **T**-prefixed bugs denote which **team** the issue belongs to. -* Dark blue, **beta-** labels track changes which need to be backported into - the beta branches. - -* The purple **metabug** label marks lists of bugs collected by other - categories. - If you're looking for somewhere to start, check out the [E-easy][eeasy] tag. [inom]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-nominated From 28fc93fc4392423a66b45ba2aae26285bb3f5bf5 Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Sun, 10 Sep 2017 13:31:08 -0400 Subject: [PATCH 14/14] Add explanations for undocumented labels --- CONTRIBUTING.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6d150c05d8bb2..741ced8f0912d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -403,9 +403,15 @@ labels to triage issues: * Dark blue, **beta-** labels track changes which need to be backported into the beta branches. +* Light purple, **C**-prefixed labels represent the **category** of an issue. + * Green, **E**-prefixed labels explain the level of **experience** necessary to fix the issue. +* The dark blue **final-comment-period** label marks bugs that are using the + RFC signoff functionality of [rfcbot][rfcbot] and are currenty in the final + comment period. + * Red, **I**-prefixed labels indicate the **importance** of the issue. The [I-nominated][inom] label indicates that an issue has been nominated for prioritizing at the next triage meeting. @@ -413,10 +419,26 @@ labels to triage issues: * The purple **metabug** label marks lists of bugs collected by other categories. +* Purple gray, **O**-prefixed labels are the **operating system** or platform + that this issue is specific to. + * Orange, **P**-prefixed labels indicate a bug's **priority**. These labels are only assigned during triage meetings, and replace the [I-nominated][inom] label. +* The gray **proposed-final-comment-period** label marks bugs that are using + the RFC signoff functionality of [rfcbot][rfcbot] and are currently awaiting + signoff of all team members in order to enter the final comment period. + +* Pink, **regression**-prefixed labels track regressions from stable to the + release channels. + +* The light orange **relnotes** label marks issues that should be documented in + the release notes of the next release. + +* Gray, **S**-prefixed labels are used for tracking the **status** of pull + requests. + * Blue, **T**-prefixed bugs denote which **team** the issue belongs to. If you're looking for somewhere to start, check out the [E-easy][eeasy] tag. @@ -424,6 +446,7 @@ If you're looking for somewhere to start, check out the [E-easy][eeasy] tag. [inom]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-nominated [eeasy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy [lru]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc +[rfcbot]: https://github.com/dikaiosune/rust-dashboard/blob/master/RFCBOT.md ## Out-of-tree Contributions