Auto merge of #50056 - alexcrichton:update-cargo, r=Mark-Simulacrum
Update the Cargo submodule
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 73d4188..c5dd3cd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -136,6 +136,8 @@
### Building
[building]: #building
+A default configuration shall use around 3.5 GB of disk space, whereas building a debug configuration may require more than 30 GB.
+
Dependencies
- [build dependencies](README.md#building-from-source)
- `gdb` 6.2.0 minimum, 7.1 or later recommended for test builds
diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs
index 7ac9b14..b9c8212 100644
--- a/src/bootstrap/builder.rs
+++ b/src/bootstrap/builder.rs
@@ -310,7 +310,8 @@
tool::Compiletest, tool::RemoteTestServer, tool::RemoteTestClient,
tool::RustInstaller, tool::Cargo, tool::Rls, tool::Rustdoc, tool::Clippy,
native::Llvm, tool::Rustfmt, tool::Miri, native::Lld),
- Kind::Check => describe!(check::Std, check::Test, check::Rustc, check::CodegenBackend),
+ Kind::Check => describe!(check::Std, check::Test, check::Rustc, check::CodegenBackend,
+ check::Rustdoc),
Kind::Test => describe!(test::Tidy, test::Bootstrap, test::Ui, test::RunPass,
test::CompileFail, test::ParseFail, test::RunFail, test::RunPassValgrind,
test::MirOpt, test::Codegen, test::CodegenUnits, test::Incremental, test::Debuginfo,
diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs
index e7c6ec8..64354ae 100644
--- a/src/bootstrap/check.rs
+++ b/src/bootstrap/check.rs
@@ -12,6 +12,7 @@
use compile::{run_cargo, std_cargo, test_cargo, rustc_cargo, rustc_cargo_env, add_to_sysroot};
use builder::{RunConfig, Builder, ShouldRun, Step};
+use tool::{self, prepare_tool_cargo};
use {Compiler, Mode};
use cache::{INTERNER, Interned};
use std::path::PathBuf;
@@ -41,6 +42,7 @@
let out_dir = builder.stage_out(compiler, Mode::Libstd);
builder.clear_if_dirty(&out_dir, &builder.rustc(compiler));
+
let mut cargo = builder.cargo(compiler, Mode::Libstd, target, "check");
std_cargo(builder, &compiler, target, &mut cargo);
@@ -170,11 +172,12 @@
}
fn run(self, builder: &Builder) {
- let target = self.target;
let compiler = builder.compiler(0, builder.config.build);
+ let target = self.target;
let out_dir = builder.stage_out(compiler, Mode::Libtest);
builder.clear_if_dirty(&out_dir, &libstd_stamp(builder, compiler, target));
+
let mut cargo = builder.cargo(compiler, Mode::Libtest, target, "check");
test_cargo(builder, &compiler, target, &mut cargo);
@@ -190,6 +193,54 @@
}
}
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Rustdoc {
+ pub target: Interned<String>,
+}
+
+impl Step for Rustdoc {
+ type Output = ();
+ const ONLY_HOSTS: bool = true;
+ const DEFAULT: bool = true;
+
+ fn should_run(run: ShouldRun) -> ShouldRun {
+ run.path("src/tools/rustdoc")
+ }
+
+ fn make_run(run: RunConfig) {
+ run.builder.ensure(Rustdoc {
+ target: run.target,
+ });
+ }
+
+ fn run(self, builder: &Builder) {
+ let compiler = builder.compiler(0, builder.config.build);
+ let target = self.target;
+
+ let mut cargo = prepare_tool_cargo(builder,
+ compiler,
+ target,
+ "check",
+ "src/tools/rustdoc");
+
+ let _folder = builder.fold_output(|| format!("stage{}-rustdoc", compiler.stage));
+ println!("Checking rustdoc artifacts ({} -> {})", &compiler.host, target);
+ run_cargo(builder,
+ &mut cargo,
+ &rustdoc_stamp(builder, compiler, target),
+ true);
+
+ let libdir = builder.sysroot_libdir(compiler, target);
+ add_to_sysroot(&builder, &libdir, &rustdoc_stamp(builder, compiler, target));
+
+ builder.ensure(tool::CleanTools {
+ compiler,
+ target,
+ mode: Mode::Tool,
+ });
+ }
+}
+
/// Cargo's output path for the standard library in a given stage, compiled
/// by a particular compiler for the specified target.
pub fn libstd_stamp(builder: &Builder, compiler: Compiler, target: Interned<String>) -> PathBuf {
@@ -217,3 +268,9 @@
builder.cargo_out(compiler, Mode::Librustc, target)
.join(format!(".librustc_trans-{}-check.stamp", backend))
}
+
+/// Cargo's output path for rustdoc in a given stage, compiled by a particular
+/// compiler for the specified target.
+pub fn rustdoc_stamp(builder: &Builder, compiler: Compiler, target: Interned<String>) -> PathBuf {
+ builder.cargo_out(compiler, Mode::Tool, target).join(".rustdoc-check.stamp")
+}
diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs
index 2c2cf74..d952cb5 100644
--- a/src/bootstrap/native.rs
+++ b/src/bootstrap/native.rs
@@ -149,6 +149,7 @@
.define("WITH_POLLY", "OFF")
.define("LLVM_ENABLE_TERMINFO", "OFF")
.define("LLVM_ENABLE_LIBEDIT", "OFF")
+ .define("LLVM_ENABLE_LIBXML2", "OFF")
.define("LLVM_PARALLEL_COMPILE_JOBS", builder.jobs().to_string())
.define("LLVM_TARGET_ARCH", target.split('-').next().unwrap())
.define("LLVM_DEFAULT_TARGET_TRIPLE", target);
diff --git a/src/liballoc/btree/map.rs b/src/liballoc/btree/map.rs
index 82cbec0..3984379 100644
--- a/src/liballoc/btree/map.rs
+++ b/src/liballoc/btree/map.rs
@@ -2155,8 +2155,8 @@
/// assert_eq!(map["poneyland"], 43);
/// ```
#[stable(feature = "entry_and_modify", since = "1.26.0")]
- pub fn and_modify<F>(self, mut f: F) -> Self
- where F: FnMut(&mut V)
+ pub fn and_modify<F>(self, f: F) -> Self
+ where F: FnOnce(&mut V)
{
match self {
Occupied(mut entry) => {
diff --git a/src/liballoc/str.rs b/src/liballoc/str.rs
index 0e70846..686a040 100644
--- a/src/liballoc/str.rs
+++ b/src/liballoc/str.rs
@@ -2140,48 +2140,6 @@
unsafe { String::from_utf8_unchecked(buf) }
}
- /// Returns true if this `str` is entirely whitespace, and false otherwise.
- ///
- /// 'Whitespace' is defined according to the terms of the Unicode Derived Core
- /// Property `White_Space`.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert!(" \t ".is_whitespace());
- ///
- /// // a non-breaking space
- /// assert!("\u{A0}".is_whitespace());
- ///
- /// assert!(!" 越".is_whitespace());
- /// ```
- #[stable(feature = "unicode_methods_on_intrinsics", since = "1.27.0")]
- #[inline]
- pub fn is_whitespace(&self) -> bool {
- StrExt::is_whitespace(self)
- }
-
- /// Returns true if this `str` is entirely alphanumeric, and false otherwise.
- ///
- /// 'Alphanumeric'-ness is defined in terms of the Unicode General Categories
- /// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
- ///
- /// # Examples
- ///
- /// Basic usage:
- ///
- /// ```
- /// assert!("٣7৬Kو藏".is_alphanumeric());
- /// assert!(!"¾①".is_alphanumeric());
- /// ```
- #[stable(feature = "unicode_methods_on_intrinsics", since = "1.27.0")]
- #[inline]
- pub fn is_alphanumeric(&self) -> bool {
- StrExt::is_alphanumeric(self)
- }
-
/// Checks if all characters in this string are within the ASCII range.
///
/// # Examples
diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs
index cf3842d..7aba8b5 100644
--- a/src/libcore/sync/atomic.rs
+++ b/src/libcore/sync/atomic.rs
@@ -990,9 +990,7 @@
#[$stable_debug]
impl fmt::Debug for $atomic_type {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.debug_tuple(stringify!($atomic_type))
- .field(&self.load(Ordering::SeqCst))
- .finish()
+ fmt::Debug::fmt(&self.load(Ordering::SeqCst), f)
}
}
@@ -2090,7 +2088,7 @@
#[stable(feature = "atomic_debug", since = "1.3.0")]
impl fmt::Debug for AtomicBool {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.debug_tuple("AtomicBool").field(&self.load(Ordering::SeqCst)).finish()
+ fmt::Debug::fmt(&self.load(Ordering::SeqCst), f)
}
}
@@ -2098,7 +2096,7 @@
#[stable(feature = "atomic_debug", since = "1.3.0")]
impl<T> fmt::Debug for AtomicPtr<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.debug_tuple("AtomicPtr").field(&self.load(Ordering::SeqCst)).finish()
+ fmt::Debug::fmt(&self.load(Ordering::SeqCst), f)
}
}
diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs
index 1b90707..b4f3943 100644
--- a/src/librustc/dep_graph/dep_node.rs
+++ b/src/librustc/dep_graph/dep_node.rs
@@ -556,7 +556,6 @@
[input] DefSpan(DefId),
[] LookupStability(DefId),
[] LookupDeprecationEntry(DefId),
- [] ItemBodyNestedBodies(DefId),
[] ConstIsRvaluePromotableToStatic(DefId),
[] RvaluePromotableMap(DefId),
[] ImplParent(DefId),
@@ -567,6 +566,7 @@
[] ItemAttrs(DefId),
[] TransFnAttrs(DefId),
[] FnArgNames(DefId),
+ [] RenderedConst(DefId),
[] DylibDepFormats(CrateNum),
[] IsPanicRuntime(CrateNum),
[] IsCompilerBuiltins(CrateNum),
@@ -615,7 +615,6 @@
[input] GetLangItems,
[] DefinedLangItems(CrateNum),
[] MissingLangItems(CrateNum),
- [] ExternConstBody(DefId),
[] VisibleParentMap,
[input] MissingExternCrateItem(CrateNum),
[input] UsedCrateSource(CrateNum),
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
index b88185c..9520ed3 100644
--- a/src/librustc/hir/map/mod.rs
+++ b/src/librustc/hir/map/mod.rs
@@ -30,14 +30,11 @@
use hir::*;
use hir::print::Nested;
use hir::svh::Svh;
-use util::nodemap::{DefIdMap, FxHashMap};
+use util::nodemap::FxHashMap;
-use arena::SyncTypedArena;
use std::io;
use ty::TyCtxt;
-use rustc_data_structures::sync::Lock;
-
pub mod blocks;
mod collector;
mod def_collector;
@@ -219,7 +216,6 @@
pub struct Forest {
krate: Crate,
pub dep_graph: DepGraph,
- inlined_bodies: SyncTypedArena<Body>
}
impl Forest {
@@ -227,7 +223,6 @@
Forest {
krate,
dep_graph: dep_graph.clone(),
- inlined_bodies: SyncTypedArena::new()
}
}
@@ -264,9 +259,6 @@
definitions: &'hir Definitions,
- /// Bodies inlined from other crates are cached here.
- inlined_bodies: Lock<DefIdMap<&'hir Body>>,
-
/// The reverse mapping of `node_to_hir_id`.
hir_to_node_id: FxHashMap<HirId, NodeId>,
}
@@ -923,21 +915,6 @@
}
}
- pub fn get_inlined_body_untracked(&self, def_id: DefId) -> Option<&'hir Body> {
- self.inlined_bodies.borrow().get(&def_id).cloned()
- }
-
- pub fn intern_inlined_body(&self, def_id: DefId, body: Body) -> &'hir Body {
- let mut inlined_bodies = self.inlined_bodies.borrow_mut();
- if let Some(&b) = inlined_bodies.get(&def_id) {
- debug_assert_eq!(&body, b);
- return b;
- }
- let body = self.forest.inlined_bodies.alloc(body);
- inlined_bodies.insert(def_id, body);
- body
- }
-
/// Returns the name associated with the given NodeId's AST.
pub fn name(&self, id: NodeId) -> Name {
match self.get(id) {
@@ -1195,7 +1172,6 @@
map,
hir_to_node_id,
definitions,
- inlined_bodies: Lock::new(DefIdMap()),
};
hir_id_validator::check_crate(&map);
diff --git a/src/librustc/ich/impls_cstore.rs b/src/librustc/ich/impls_cstore.rs
index d885bd4..96d7cb6 100644
--- a/src/librustc/ich/impls_cstore.rs
+++ b/src/librustc/ich/impls_cstore.rs
@@ -11,8 +11,6 @@
//! This module contains `HashStable` implementations for various data types
//! from rustc::middle::cstore in no particular order.
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult};
-
use middle;
impl_stable_hash_for!(enum middle::cstore::DepKind {
@@ -64,29 +62,3 @@
rlib,
rmeta
});
-
-impl<HCX> HashStable<HCX> for middle::cstore::ExternBodyNestedBodies {
- fn hash_stable<W: StableHasherResult>(&self,
- hcx: &mut HCX,
- hasher: &mut StableHasher<W>) {
- let middle::cstore::ExternBodyNestedBodies {
- nested_bodies: _,
- fingerprint,
- } = *self;
-
- fingerprint.hash_stable(hcx, hasher);
- }
-}
-
-impl<'a, HCX> HashStable<HCX> for middle::cstore::ExternConstBody<'a> {
- fn hash_stable<W: StableHasherResult>(&self,
- hcx: &mut HCX,
- hasher: &mut StableHasher<W>) {
- let middle::cstore::ExternConstBody {
- body: _,
- fingerprint,
- } = *self;
-
- fingerprint.hash_stable(hcx, hasher);
- }
-}
diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs
index 292ec18..60e197e 100644
--- a/src/librustc/middle/cstore.rs
+++ b/src/librustc/middle/cstore.rs
@@ -22,19 +22,16 @@
//! are *mostly* used as a part of that interface, but these should
//! probably get a better home if someone can find one.
-use hir;
use hir::def;
use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use hir::map as hir_map;
use hir::map::definitions::{Definitions, DefKey, DefPathTable};
use hir::svh::Svh;
-use ich;
use ty::{self, TyCtxt};
use session::{Session, CrateDisambiguator};
use session::search_paths::PathKind;
use std::any::Any;
-use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use syntax::ast;
use syntax::ext::base::SyntaxExtension;
@@ -209,26 +206,6 @@
-> Result<MetadataRef, String>;
}
-#[derive(Clone)]
-pub struct ExternConstBody<'tcx> {
- pub body: &'tcx hir::Body,
-
- // It would require a lot of infrastructure to enable stable-hashing Bodies
- // from other crates, so we hash on export and just store the fingerprint
- // with them.
- pub fingerprint: ich::Fingerprint,
-}
-
-#[derive(Clone)]
-pub struct ExternBodyNestedBodies {
- pub nested_bodies: Lrc<BTreeMap<hir::BodyId, hir::Body>>,
-
- // It would require a lot of infrastructure to enable stable-hashing Bodies
- // from other crates, so we hash on export and just store the fingerprint
- // with them.
- pub fingerprint: ich::Fingerprint,
-}
-
/// A store of Rust crates, through with their metadata
/// can be accessed.
///
diff --git a/src/librustc/ty/maps/config.rs b/src/librustc/ty/maps/config.rs
index 664c84f..fea7de9 100644
--- a/src/librustc/ty/maps/config.rs
+++ b/src/librustc/ty/maps/config.rs
@@ -283,12 +283,6 @@
}
}
-impl<'tcx> QueryDescription<'tcx> for queries::item_body_nested_bodies<'tcx> {
- fn describe(tcx: TyCtxt, def_id: DefId) -> String {
- format!("nested item bodies of `{}`", tcx.item_path_str(def_id))
- }
-}
-
impl<'tcx> QueryDescription<'tcx> for queries::const_is_rvalue_promotable_to_static<'tcx> {
fn describe(tcx: TyCtxt, def_id: DefId) -> String {
format!("const checking if rvalue is promotable to static `{}`",
diff --git a/src/librustc/ty/maps/mod.rs b/src/librustc/ty/maps/mod.rs
index 2325b18..0ab9f16 100644
--- a/src/librustc/ty/maps/mod.rs
+++ b/src/librustc/ty/maps/mod.rs
@@ -17,9 +17,8 @@
use infer::canonical::{self, Canonical};
use lint;
use middle::borrowck::BorrowCheckResult;
-use middle::cstore::{ExternCrate, LinkagePreference, NativeLibrary,
- ExternBodyNestedBodies, ForeignModule};
-use middle::cstore::{NativeLibraryKind, DepKind, CrateSource, ExternConstBody};
+use middle::cstore::{ExternCrate, LinkagePreference, NativeLibrary, ForeignModule};
+use middle::cstore::{NativeLibraryKind, DepKind, CrateSource};
use middle::privacy::AccessLevels;
use middle::reachable::ReachableSet;
use middle::region;
@@ -254,9 +253,11 @@
[] fn item_attrs: ItemAttrs(DefId) -> Lrc<[ast::Attribute]>,
[] fn trans_fn_attrs: trans_fn_attrs(DefId) -> TransFnAttrs,
[] fn fn_arg_names: FnArgNames(DefId) -> Vec<ast::Name>,
+ /// Gets the rendered value of the specified constant or associated constant.
+ /// Used by rustdoc.
+ [] fn rendered_const: RenderedConst(DefId) -> String,
[] fn impl_parent: ImplParent(DefId) -> Option<DefId>,
[] fn trait_of_item: TraitOfItem(DefId) -> Option<DefId>,
- [] fn item_body_nested_bodies: ItemBodyNestedBodies(DefId) -> ExternBodyNestedBodies,
[] fn const_is_rvalue_promotable_to_static: ConstIsRvaluePromotableToStatic(DefId) -> bool,
[] fn rvalue_promotable_map: RvaluePromotableMap(DefId) -> Lrc<ItemLocalSet>,
[] fn is_mir_available: IsMirAvailable(DefId) -> bool,
@@ -376,7 +377,6 @@
[] fn get_lang_items: get_lang_items_node(CrateNum) -> Lrc<LanguageItems>,
[] fn defined_lang_items: DefinedLangItems(CrateNum) -> Lrc<Vec<(DefId, usize)>>,
[] fn missing_lang_items: MissingLangItems(CrateNum) -> Lrc<Vec<LangItem>>,
- [] fn extern_const_body: ExternConstBody(DefId) -> ExternConstBody<'tcx>,
[] fn visible_parent_map: visible_parent_map_node(CrateNum)
-> Lrc<DefIdMap<DefId>>,
[] fn missing_extern_crate_item: MissingExternCrateItem(CrateNum) -> bool,
diff --git a/src/librustc/ty/maps/plumbing.rs b/src/librustc/ty/maps/plumbing.rs
index 4f69259..8d6c747 100644
--- a/src/librustc/ty/maps/plumbing.rs
+++ b/src/librustc/ty/maps/plumbing.rs
@@ -1048,7 +1048,6 @@
DepKind::LookupDeprecationEntry => {
force!(lookup_deprecation_entry, def_id!());
}
- DepKind::ItemBodyNestedBodies => { force!(item_body_nested_bodies, def_id!()); }
DepKind::ConstIsRvaluePromotableToStatic => {
force!(const_is_rvalue_promotable_to_static, def_id!());
}
@@ -1063,6 +1062,7 @@
DepKind::ItemAttrs => { force!(item_attrs, def_id!()); }
DepKind::TransFnAttrs => { force!(trans_fn_attrs, def_id!()); }
DepKind::FnArgNames => { force!(fn_arg_names, def_id!()); }
+ DepKind::RenderedConst => { force!(rendered_const, def_id!()); }
DepKind::DylibDepFormats => { force!(dylib_dependency_formats, krate!()); }
DepKind::IsPanicRuntime => { force!(is_panic_runtime, krate!()); }
DepKind::IsCompilerBuiltins => { force!(is_compiler_builtins, krate!()); }
@@ -1119,7 +1119,6 @@
DepKind::GetLangItems => { force!(get_lang_items, LOCAL_CRATE); }
DepKind::DefinedLangItems => { force!(defined_lang_items, krate!()); }
DepKind::MissingLangItems => { force!(missing_lang_items, krate!()); }
- DepKind::ExternConstBody => { force!(extern_const_body, def_id!()); }
DepKind::VisibleParentMap => { force!(visible_parent_map, LOCAL_CRATE); }
DepKind::MissingExternCrateItem => {
force!(missing_extern_crate_item, krate!());
diff --git a/src/librustc_metadata/astencode.rs b/src/librustc_metadata/astencode.rs
deleted file mode 100644
index 71b1564..0000000
--- a/src/librustc_metadata/astencode.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2012-2015 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use rustc::hir::intravisit::{Visitor, NestedVisitorMap};
-
-use isolated_encoder::IsolatedEncoder;
-use schema::*;
-
-use rustc::hir;
-use rustc::ty::{self, TyCtxt};
-
-use rustc::ich::Fingerprint;
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-
-#[derive(RustcEncodable, RustcDecodable)]
-pub struct Ast<'tcx> {
- pub body: Lazy<hir::Body>,
- pub tables: Lazy<ty::TypeckTables<'tcx>>,
- pub nested_bodies: LazySeq<hir::Body>,
- pub rvalue_promotable_to_static: bool,
- pub stable_bodies_hash: Fingerprint,
-}
-
-impl_stable_hash_for!(struct Ast<'tcx> {
- body,
- tables,
- nested_bodies,
- rvalue_promotable_to_static,
- stable_bodies_hash
-});
-
-impl<'a, 'b, 'tcx> IsolatedEncoder<'a, 'b, 'tcx> {
- pub fn encode_body(&mut self, body_id: hir::BodyId) -> Lazy<Ast<'tcx>> {
- let body = self.tcx.hir.body(body_id);
-
- // In order to avoid having to hash hir::Bodies from extern crates, we
- // hash them here, during export, and store the hash with metadata.
- let stable_bodies_hash = {
- let mut hcx = self.tcx.create_stable_hashing_context();
- let mut hasher = StableHasher::new();
-
- hcx.while_hashing_hir_bodies(true, |hcx| {
- body.hash_stable(hcx, &mut hasher);
- });
-
- hasher.finish()
- };
-
- let lazy_body = self.lazy(body);
- let body_owner_def_id = self.tcx.hir.body_owner_def_id(body_id);
- let tables = self.tcx.typeck_tables_of(body_owner_def_id);
- let lazy_tables = self.lazy(tables);
-
- let mut visitor = NestedBodyCollector {
- tcx: self.tcx,
- bodies_found: Vec::new(),
- };
- visitor.visit_body(body);
- let lazy_nested_bodies = self.lazy_seq_ref_from_slice(&visitor.bodies_found);
-
- let rvalue_promotable_to_static =
- self.tcx.const_is_rvalue_promotable_to_static(body_owner_def_id);
-
- self.lazy(&Ast {
- body: lazy_body,
- tables: lazy_tables,
- nested_bodies: lazy_nested_bodies,
- rvalue_promotable_to_static,
- stable_bodies_hash,
- })
- }
-}
-
-struct NestedBodyCollector<'a, 'tcx: 'a> {
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- bodies_found: Vec<&'tcx hir::Body>,
-}
-
-impl<'a, 'tcx: 'a> Visitor<'tcx> for NestedBodyCollector<'a, 'tcx> {
- fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
- NestedVisitorMap::None
- }
-
- fn visit_nested_body(&mut self, body: hir::BodyId) {
- let body = self.tcx.hir.body(body);
- self.bodies_found.push(body);
- self.visit_body(body);
- }
-}
diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs
index 2c995d2f..a11b95c 100644
--- a/src/librustc_metadata/cstore_impl.rs
+++ b/src/librustc_metadata/cstore_impl.rs
@@ -142,7 +142,6 @@
mir_const_qualif => {
(cdata.mir_const_qualif(def_id.index), Lrc::new(IdxSetBuf::new_empty(0)))
}
- typeck_tables_of => { cdata.item_body_tables(def_id.index, tcx) }
fn_sig => { cdata.fn_sig(def_id.index, tcx) }
inherent_impls => { Lrc::new(cdata.get_inherent_implementations_for_type(def_id.index)) }
is_const_fn => { cdata.is_const_fn(def_id.index) }
@@ -161,9 +160,9 @@
// This is only used by rustdoc anyway, which shouldn't have
// incremental recompilation ever enabled.
fn_arg_names => { cdata.get_fn_arg_names(def_id.index) }
+ rendered_const => { cdata.get_rendered_const(def_id.index) }
impl_parent => { cdata.get_parent_impl(def_id.index) }
trait_of_item => { cdata.get_trait_of_item(def_id.index) }
- item_body_nested_bodies => { cdata.item_body_nested_bodies(tcx, def_id.index) }
const_is_rvalue_promotable_to_static => {
cdata.const_is_rvalue_promotable_to_static(def_id.index)
}
@@ -243,11 +242,6 @@
defined_lang_items => { Lrc::new(cdata.get_lang_items()) }
missing_lang_items => { Lrc::new(cdata.get_missing_lang_items()) }
- extern_const_body => {
- debug!("item_body({:?}): inlining item", def_id);
- cdata.extern_const_body(tcx, def_id.index)
- }
-
missing_extern_crate_item => {
let r = match *cdata.extern_crate.borrow() {
Some(extern_crate) if !extern_crate.direct => true,
diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs
index 936d680..0147e8d 100644
--- a/src/librustc_metadata/decoder.rs
+++ b/src/librustc_metadata/decoder.rs
@@ -17,8 +17,7 @@
use rustc::hir::map::{DefKey, DefPath, DefPathData, DefPathHash,
DisambiguatedDefPathData};
use rustc::hir;
-use rustc::middle::cstore::{LinkagePreference, ExternConstBody,
- ExternBodyNestedBodies};
+use rustc::middle::cstore::LinkagePreference;
use rustc::middle::exported_symbols::{ExportedSymbol, SymbolExportLevel};
use rustc::hir::def::{self, Def, CtorKind};
use rustc::hir::def_id::{CrateNum, DefId, DefIndex,
@@ -33,7 +32,6 @@
use rustc::util::captures::Captures;
use rustc::util::nodemap::FxHashMap;
-use std::collections::BTreeMap;
use std::io;
use std::mem;
use std::u32;
@@ -433,7 +431,7 @@
impl<'tcx> EntryKind<'tcx> {
fn to_def(&self, did: DefId) -> Option<Def> {
Some(match *self {
- EntryKind::Const(_) => Def::Const(did),
+ EntryKind::Const(..) => Def::Const(did),
EntryKind::AssociatedConst(..) => Def::AssociatedConst(did),
EntryKind::ImmStatic |
EntryKind::ForeignImmStatic => Def::Static(did, false),
@@ -794,54 +792,12 @@
}
}
- pub fn extern_const_body(&self,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- id: DefIndex)
- -> ExternConstBody<'tcx> {
- assert!(!self.is_proc_macro(id));
- let ast = self.entry(id).ast.unwrap();
- let def_id = self.local_def_id(id);
- let ast = ast.decode((self, tcx));
- let body = ast.body.decode((self, tcx));
- ExternConstBody {
- body: tcx.hir.intern_inlined_body(def_id, body),
- fingerprint: ast.stable_bodies_hash,
- }
- }
-
- pub fn item_body_tables(&self,
- id: DefIndex,
- tcx: TyCtxt<'a, 'tcx, 'tcx>)
- -> &'tcx ty::TypeckTables<'tcx> {
- let ast = self.entry(id).ast.unwrap().decode(self);
- tcx.alloc_tables(ast.tables.decode((self, tcx)))
- }
-
- pub fn item_body_nested_bodies(&self,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- id: DefIndex)
- -> ExternBodyNestedBodies {
- if let Some(ref ast) = self.entry(id).ast {
- let mut ast = ast.decode(self);
- let nested_bodies: BTreeMap<_, _> = ast.nested_bodies
- .decode((self, tcx.sess))
- .map(|body| (body.id(), body))
- .collect();
- ExternBodyNestedBodies {
- nested_bodies: Lrc::new(nested_bodies),
- fingerprint: ast.stable_bodies_hash,
- }
- } else {
- ExternBodyNestedBodies {
- nested_bodies: Lrc::new(BTreeMap::new()),
- fingerprint: Fingerprint::ZERO,
- }
- }
- }
-
pub fn const_is_rvalue_promotable_to_static(&self, id: DefIndex) -> bool {
- self.entry(id).ast.expect("const item missing `ast`")
- .decode(self).rvalue_promotable_to_static
+ match self.entry(id).kind {
+ EntryKind::AssociatedConst(_, data, _) |
+ EntryKind::Const(data, _) => data.ast_promotable,
+ _ => bug!(),
+ }
}
pub fn is_item_mir_available(&self, id: DefIndex) -> bool {
@@ -861,10 +817,10 @@
pub fn mir_const_qualif(&self, id: DefIndex) -> u8 {
match self.entry(id).kind {
- EntryKind::Const(qualif) |
- EntryKind::AssociatedConst(AssociatedContainer::ImplDefault, qualif) |
- EntryKind::AssociatedConst(AssociatedContainer::ImplFinal, qualif) => {
- qualif
+ EntryKind::Const(qualif, _) |
+ EntryKind::AssociatedConst(AssociatedContainer::ImplDefault, qualif, _) |
+ EntryKind::AssociatedConst(AssociatedContainer::ImplFinal, qualif, _) => {
+ qualif.mir
}
_ => bug!(),
}
@@ -877,7 +833,7 @@
let name = def_key.disambiguated_data.data.get_opt_name().unwrap();
let (kind, container, has_self) = match item.kind {
- EntryKind::AssociatedConst(container, _) => {
+ EntryKind::AssociatedConst(container, _, _) => {
(ty::AssociatedKind::Const, container, false)
}
EntryKind::Method(data) => {
@@ -1076,6 +1032,14 @@
lazy_seq.decode((self, tcx)).collect()
}
+ pub fn get_rendered_const(&self, id: DefIndex) -> String {
+ match self.entry(id).kind {
+ EntryKind::Const(_, data) |
+ EntryKind::AssociatedConst(_, _, data) => data.decode(self).0,
+ _ => bug!(),
+ }
+ }
+
pub fn wasm_custom_sections(&self) -> Vec<DefId> {
let sections = self.root
.wasm_custom_sections
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index 67c180e..b65e9a7 100644
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -622,7 +622,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: None,
mir: self.encode_optimized_mir(def_id),
}
}
@@ -660,7 +659,6 @@
generics: None,
predicates: None,
- ast: None,
mir: None
}
}
@@ -701,7 +699,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: None,
mir: None,
}
}
@@ -759,7 +756,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: None,
mir: self.encode_optimized_mir(def_id),
}
}
@@ -795,7 +791,18 @@
let kind = match trait_item.kind {
ty::AssociatedKind::Const => {
- EntryKind::AssociatedConst(container, 0)
+ let const_qualif =
+ if let hir::TraitItemKind::Const(_, Some(body)) = ast_item.node {
+ self.const_qualif(0, body)
+ } else {
+ ConstQualif { mir: 0, ast_promotable: false }
+ };
+
+ let rendered =
+ hir::print::to_string(&self.tcx.hir, |s| s.print_trait_item(ast_item));
+ let rendered_const = self.lazy(&RenderedConst(rendered));
+
+ EntryKind::AssociatedConst(container, const_qualif, rendered_const)
}
ty::AssociatedKind::Method => {
let fn_data = if let hir::TraitItemKind::Method(_, ref m) = ast_item.node {
@@ -855,11 +862,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: if let hir::TraitItemKind::Const(_, Some(body)) = ast_item.node {
- Some(self.encode_body(body))
- } else {
- None
- },
mir: self.encode_optimized_mir(def_id),
}
}
@@ -869,6 +871,13 @@
!self.tcx.sess.opts.output_types.should_trans()
}
+ fn const_qualif(&self, mir: u8, body_id: hir::BodyId) -> ConstQualif {
+ let body_owner_def_id = self.tcx.hir.body_owner_def_id(body_id);
+ let ast_promotable = self.tcx.const_is_rvalue_promotable_to_static(body_owner_def_id);
+
+ ConstQualif { mir, ast_promotable }
+ }
+
fn encode_info_for_impl_item(&mut self, def_id: DefId) -> Entry<'tcx> {
debug!("IsolatedEncoder::encode_info_for_impl_item({:?})", def_id);
let tcx = self.tcx;
@@ -886,8 +895,15 @@
let kind = match impl_item.kind {
ty::AssociatedKind::Const => {
- EntryKind::AssociatedConst(container,
- self.tcx.at(ast_item.span).mir_const_qualif(def_id).0)
+ if let hir::ImplItemKind::Const(_, body_id) = ast_item.node {
+ let mir = self.tcx.at(ast_item.span).mir_const_qualif(def_id).0;
+
+ EntryKind::AssociatedConst(container,
+ self.const_qualif(mir, body_id),
+ self.encode_rendered_const_for_body(body_id))
+ } else {
+ bug!()
+ }
}
ty::AssociatedKind::Method => {
let fn_data = if let hir::ImplItemKind::Method(ref sig, body) = ast_item.node {
@@ -908,20 +924,20 @@
ty::AssociatedKind::Type => EntryKind::AssociatedType(container)
};
- let (ast, mir) = if let hir::ImplItemKind::Const(_, body) = ast_item.node {
- (Some(body), true)
- } else if let hir::ImplItemKind::Method(ref sig, body) = ast_item.node {
- let generics = self.tcx.generics_of(def_id);
- let types = generics.parent_types as usize + generics.types.len();
- let needs_inline = (types > 0 || tcx.trans_fn_attrs(def_id).requests_inline()) &&
- !self.metadata_output_only();
- let is_const_fn = sig.constness == hir::Constness::Const;
- let ast = if is_const_fn { Some(body) } else { None };
- let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir;
- (ast, needs_inline || is_const_fn || always_encode_mir)
- } else {
- (None, false)
- };
+ let mir =
+ if let hir::ImplItemKind::Const(..) = ast_item.node {
+ true
+ } else if let hir::ImplItemKind::Method(ref sig, _) = ast_item.node {
+ let generics = self.tcx.generics_of(def_id);
+ let types = generics.parent_types as usize + generics.types.len();
+ let needs_inline = (types > 0 || tcx.trans_fn_attrs(def_id).requests_inline()) &&
+ !self.metadata_output_only();
+ let is_const_fn = sig.constness == hir::Constness::Const;
+ let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir;
+ needs_inline || is_const_fn || always_encode_mir
+ } else {
+ false
+ };
Entry {
kind,
@@ -942,7 +958,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: ast.map(|body| self.encode_body(body)),
mir: if mir { self.encode_optimized_mir(def_id) } else { None },
}
}
@@ -999,6 +1014,13 @@
self.tcx.lookup_deprecation(def_id).map(|depr| self.lazy(&depr))
}
+ fn encode_rendered_const_for_body(&mut self, body_id: hir::BodyId) -> Lazy<RenderedConst> {
+ let body = self.tcx.hir.body(body_id);
+ let rendered = hir::print::to_string(&self.tcx.hir, |s| s.print_expr(&body.value));
+ let rendered_const = &RenderedConst(rendered);
+ self.lazy(rendered_const)
+ }
+
fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) -> Entry<'tcx> {
let tcx = self.tcx;
@@ -1007,8 +1029,12 @@
let kind = match item.node {
hir::ItemStatic(_, hir::MutMutable, _) => EntryKind::MutStatic,
hir::ItemStatic(_, hir::MutImmutable, _) => EntryKind::ImmStatic,
- hir::ItemConst(..) => {
- EntryKind::Const(tcx.at(item.span).mir_const_qualif(def_id).0)
+ hir::ItemConst(_, body_id) => {
+ let mir = tcx.at(item.span).mir_const_qualif(def_id).0;
+ EntryKind::Const(
+ self.const_qualif(mir, body_id),
+ self.encode_rendered_const_for_body(body_id)
+ )
}
hir::ItemFn(_, _, constness, .., body) => {
let data = FnData {
@@ -1191,13 +1217,6 @@
_ => None,
},
- ast: match item.node {
- hir::ItemConst(_, body) |
- hir::ItemFn(_, _, hir::Constness::Const, _, _, body) => {
- Some(self.encode_body(body))
- }
- _ => None,
- },
mir: match item.node {
hir::ItemStatic(..) => {
self.encode_optimized_mir(def_id)
@@ -1240,7 +1259,6 @@
variances: LazySeq::empty(),
generics: None,
predicates: None,
- ast: None,
mir: None,
}
}
@@ -1269,7 +1287,6 @@
generics: None,
predicates: None,
- ast: None,
mir: None,
}
}
@@ -1292,7 +1309,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: None,
mir: None,
}
}
@@ -1337,7 +1353,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: None,
- ast: None,
mir: self.encode_optimized_mir(def_id),
}
}
@@ -1346,10 +1361,12 @@
debug!("IsolatedEncoder::encode_info_for_embedded_const({:?})", def_id);
let tcx = self.tcx;
let id = tcx.hir.as_local_node_id(def_id).unwrap();
- let body = tcx.hir.body_owned_by(id);
+ let body_id = tcx.hir.body_owned_by(id);
+ let const_data = self.encode_rendered_const_for_body(body_id);
+ let mir = tcx.mir_const_qualif(def_id).0;
Entry {
- kind: EntryKind::Const(tcx.mir_const_qualif(def_id).0),
+ kind: EntryKind::Const(self.const_qualif(mir, body_id), const_data),
visibility: self.lazy(&ty::Visibility::Public),
span: self.lazy(&tcx.def_span(def_id)),
attributes: LazySeq::empty(),
@@ -1363,7 +1380,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: Some(self.encode_body(body)),
mir: self.encode_optimized_mir(def_id),
}
}
@@ -1565,7 +1581,6 @@
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
- ast: None,
mir: None,
}
}
diff --git a/src/librustc_metadata/isolated_encoder.rs b/src/librustc_metadata/isolated_encoder.rs
index 689c190..88594af 100644
--- a/src/librustc_metadata/isolated_encoder.rs
+++ b/src/librustc_metadata/isolated_encoder.rs
@@ -55,10 +55,4 @@
{
self.ecx.lazy_seq_ref(slice.iter())
}
-
- pub fn lazy_seq_ref_from_slice<T>(&mut self, slice: &[&T]) -> LazySeq<T>
- where T: Encodable
- {
- self.ecx.lazy_seq_ref(slice.iter().map(|x| *x))
- }
}
diff --git a/src/librustc_metadata/lib.rs b/src/librustc_metadata/lib.rs
index cbbc9d7..9ecb3fd 100644
--- a/src/librustc_metadata/lib.rs
+++ b/src/librustc_metadata/lib.rs
@@ -44,7 +44,6 @@
mod diagnostics;
-mod astencode;
mod index_builder;
mod index;
mod encoder;
diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs
index 23ea5e4..5d6db1a 100644
--- a/src/librustc_metadata/schema.rs
+++ b/src/librustc_metadata/schema.rs
@@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use astencode;
use index;
use rustc::hir;
@@ -266,7 +265,6 @@
pub generics: Option<Lazy<ty::Generics>>,
pub predicates: Option<Lazy<ty::GenericPredicates<'tcx>>>,
- pub ast: Option<Lazy<astencode::Ast<'tcx>>>,
pub mir: Option<Lazy<mir::Mir<'tcx>>>,
}
@@ -283,13 +281,12 @@
variances,
generics,
predicates,
- ast,
mir
});
#[derive(Copy, Clone, RustcEncodable, RustcDecodable)]
pub enum EntryKind<'tcx> {
- Const(u8),
+ Const(ConstQualif, Lazy<RenderedConst>),
ImmStatic,
MutStatic,
ForeignImmStatic,
@@ -313,7 +310,7 @@
Impl(Lazy<ImplData<'tcx>>),
Method(Lazy<MethodData<'tcx>>),
AssociatedType(AssociatedContainer),
- AssociatedConst(AssociatedContainer, u8),
+ AssociatedConst(AssociatedContainer, ConstQualif, Lazy<RenderedConst>),
}
impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for EntryKind<'gcx> {
@@ -333,8 +330,9 @@
EntryKind::Type => {
// Nothing else to hash here.
}
- EntryKind::Const(qualif) => {
+ EntryKind::Const(qualif, ref const_data) => {
qualif.hash_stable(hcx, hasher);
+ const_data.hash_stable(hcx, hasher);
}
EntryKind::Enum(ref repr_options) => {
repr_options.hash_stable(hcx, hasher);
@@ -375,7 +373,7 @@
EntryKind::AssociatedType(associated_container) => {
associated_container.hash_stable(hcx, hasher);
}
- EntryKind::AssociatedConst(associated_container, qualif) => {
+ EntryKind::AssociatedConst(associated_container, qualif, _) => {
associated_container.hash_stable(hcx, hasher);
qualif.hash_stable(hcx, hasher);
}
@@ -383,6 +381,29 @@
}
}
+/// Additional data for EntryKind::Const and EntryKind::AssociatedConst
+#[derive(Clone, Copy, RustcEncodable, RustcDecodable)]
+pub struct ConstQualif {
+ pub mir: u8,
+ pub ast_promotable: bool,
+}
+
+impl_stable_hash_for!(struct ConstQualif { mir, ast_promotable });
+
+/// Contains a constant which has been rendered to a String.
+/// Used by rustdoc.
+#[derive(RustcEncodable, RustcDecodable)]
+pub struct RenderedConst(pub String);
+
+impl<'a> HashStable<StableHashingContext<'a>> for RenderedConst {
+ #[inline]
+ fn hash_stable<W: StableHasherResult>(&self,
+ hcx: &mut StableHashingContext<'a>,
+ hasher: &mut StableHasher<W>) {
+ self.0.hash_stable(hcx, hasher);
+ }
+}
+
#[derive(RustcEncodable, RustcDecodable)]
pub struct ModData {
pub reexports: LazySeq<def::Export>,
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index c5ff14e..a5ddd50 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -260,7 +260,7 @@
self.param_env,
def_id,
substs,
- ).ok_or(EvalErrorKind::TypeckError.into()) // turn error prop into a panic to expose associated type in const issue
+ ).ok_or_else(|| EvalErrorKind::TypeckError.into()) // turn error prop into a panic to expose associated type in const issue
}
pub(super) fn type_is_sized(&self, ty: Ty<'tcx>) -> bool {
@@ -279,9 +279,9 @@
trace!("load mir {:?}", instance);
match instance {
ty::InstanceDef::Item(def_id) => {
- self.tcx.maybe_optimized_mir(def_id).ok_or_else(|| {
+ self.tcx.maybe_optimized_mir(def_id).ok_or_else(||
EvalErrorKind::NoMirFor(self.tcx.item_path_str(def_id)).into()
- })
+ )
}
_ => Ok(self.tcx.instance_mir(instance)),
}
@@ -691,7 +691,7 @@
self.param_env,
def_id,
substs,
- ).ok_or(EvalErrorKind::TypeckError.into());
+ ).ok_or_else(|| EvalErrorKind::TypeckError.into());
let fn_ptr = self.memory.create_fn_alloc(instance?);
let valty = ValTy {
value: Value::ByVal(PrimVal::Ptr(fn_ptr)),
@@ -1689,7 +1689,7 @@
impl<'mir, 'tcx> Frame<'mir, 'tcx> {
pub fn get_local(&self, local: mir::Local) -> EvalResult<'tcx, Value> {
- self.locals[local].ok_or(EvalErrorKind::DeadLocal.into())
+ self.locals[local].ok_or_else(|| EvalErrorKind::DeadLocal.into())
}
fn set_local(&mut self, local: mir::Local, value: Value) -> EvalResult<'tcx> {
diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs
index aeefd5a..591732f 100644
--- a/src/librustc_mir/transform/qualify_consts.rs
+++ b/src/librustc_mir/transform/qualify_consts.rs
@@ -964,7 +964,7 @@
let (msg, note) = if let UnstableFeatures::Disallow =
self.tcx.sess.opts.unstable_features {
(format!("calls in {}s are limited to \
- struct and enum constructors",
+ tuple structs and tuple variants",
self.mode),
Some("a limited form of compile-time function \
evaluation is available on a nightly \
@@ -972,7 +972,7 @@
} else {
(format!("calls in {}s are limited \
to constant functions, \
- struct and enum constructors",
+ tuple structs and tuple variants",
self.mode),
None)
};
diff --git a/src/librustc_trans/back/linker.rs b/src/librustc_trans/back/linker.rs
index ebcf06d..e001e80 100644
--- a/src/librustc_trans/back/linker.rs
+++ b/src/librustc_trans/back/linker.rs
@@ -960,6 +960,7 @@
fn finalize(&mut self) -> Command {
self.cmd.arg("--threads");
+ self.cmd.arg("-z").arg("stack-size=1048576");
// FIXME we probably shouldn't pass this but instead pass an explicit
// whitelist of symbols we'll allow to be undefined. Unfortunately
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 090adc2..32f23e9 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -10,10 +10,7 @@
//! Support for inlining external documentation into the current AST.
-use std::collections::BTreeMap;
-use std::io;
use std::iter::once;
-use rustc_data_structures::sync::Lrc;
use syntax::ast;
use rustc::hir;
@@ -408,27 +405,8 @@
}
}
-struct InlinedConst {
- nested_bodies: Lrc<BTreeMap<hir::BodyId, hir::Body>>
-}
-
-impl hir::print::PpAnn for InlinedConst {
- fn nested(&self, state: &mut hir::print::State, nested: hir::print::Nested)
- -> io::Result<()> {
- if let hir::print::Nested::Body(body) = nested {
- state.print_expr(&self.nested_bodies[&body].value)
- } else {
- Ok(())
- }
- }
-}
-
pub fn print_inlined_const(cx: &DocContext, did: DefId) -> String {
- let body = cx.tcx.extern_const_body(did).body;
- let inlined = InlinedConst {
- nested_bodies: cx.tcx.item_body_nested_bodies(did).nested_bodies
- };
- hir::print::to_string(&inlined, |s| s.print_expr(&body.value))
+ cx.tcx.rendered_const(did)
}
fn build_const(cx: &DocContext, did: DefId) -> clean::Constant {
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index 600e9ea..8cd5f37 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -437,7 +437,7 @@
for line in s.lines() {
let trimline = line.trim();
- let header = trimline.is_whitespace() ||
+ let header = trimline.chars().all(|c| c.is_whitespace()) ||
trimline.starts_with("#![") ||
trimline.starts_with("#[macro_use] extern crate") ||
trimline.starts_with("extern crate");
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index 14ef856..4fe5c11 100644
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -2126,8 +2126,8 @@
/// assert_eq!(map["poneyland"], 43);
/// ```
#[stable(feature = "entry_and_modify", since = "1.26.0")]
- pub fn and_modify<F>(self, mut f: F) -> Self
- where F: FnMut(&mut V)
+ pub fn and_modify<F>(self, f: F) -> Self
+ where F: FnOnce(&mut V)
{
match self {
Occupied(mut entry) => {
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index ff63c9a..0397c32 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -271,8 +271,16 @@
'u' => {
assert_eq!(lit.as_bytes()[2], b'{');
let idx = lit.find('}').unwrap();
- let s = &lit[3..idx].chars().filter(|&c| c != '_').collect::<String>();
- let v = u32::from_str_radix(&s, 16).unwrap();
+
+ // All digits and '_' are ascii, so treat each byte as a char.
+ let mut v: u32 = 0;
+ for c in lit[3..idx].bytes() {
+ let c = char::from(c);
+ if c != '_' {
+ let x = c.to_digit(16).unwrap();
+ v = v.checked_mul(16).unwrap().checked_add(x).unwrap();
+ }
+ }
let c = char::from_u32(v).unwrap_or_else(|| {
if let Some((span, diag)) = diag {
let mut diag = diag.struct_span_err(span, "invalid unicode character escape");
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 2688a1a..4439438 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -26,6 +26,7 @@
use tokenstream;
use std::{cmp, fmt};
+use std::mem;
use rustc_data_structures::sync::{Lrc, Lock};
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]
@@ -88,6 +89,12 @@
ByteStr(_) | ByteStrRaw(..) => "byte string"
}
}
+
+ // See comments in `interpolated_to_tokenstream` for why we care about
+ // *probably* equal here rather than actual equality
+ fn probably_equal_for_proc_macro(&self, other: &Lit) -> bool {
+ mem::discriminant(self) == mem::discriminant(other)
+ }
}
pub(crate) fn ident_can_begin_expr(ident: ast::Ident, is_raw: bool) -> bool {
@@ -530,14 +537,6 @@
// stream they came from. Here we attempt to extract these
// lossless token streams before we fall back to the
// stringification.
- //
- // During early phases of the compiler, though, the AST could
- // get modified directly (e.g. attributes added or removed) and
- // the internal cache of tokens my not be invalidated or
- // updated. Consequently if the "lossless" token stream
- // disagrees with our actuall stringification (which has
- // historically been much more battle-tested) then we go with
- // the lossy stream anyway (losing span information).
let mut tokens = None;
match nt.0 {
@@ -569,13 +568,96 @@
let source = pprust::token_to_string(self);
parse_stream_from_source_str(FileName::MacroExpansion, source, sess, Some(span))
});
+
+ // During early phases of the compiler the AST could get modified
+ // directly (e.g. attributes added or removed) and the internal cache
+ // of tokens my not be invalidated or updated. Consequently if the
+ // "lossless" token stream disagrees with our actual stringification
+ // (which has historically been much more battle-tested) then we go
+ // with the lossy stream anyway (losing span information).
+ //
+ // Note that the comparison isn't `==` here to avoid comparing spans,
+ // but it *also* is a "probable" equality which is a pretty weird
+ // definition. We mostly want to catch actual changes to the AST
+ // like a `#[cfg]` being processed or some weird `macro_rules!`
+ // expansion.
+ //
+ // What we *don't* want to catch is the fact that a user-defined
+ // literal like `0xf` is stringified as `15`, causing the cached token
+ // stream to not be literal `==` token-wise (ignoring spans) to the
+ // token stream we got from stringification.
+ //
+ // Instead the "probably equal" check here is "does each token
+ // recursively have the same discriminant?" We basically don't look at
+ // the token values here and assume that such fine grained modifications
+ // of token streams doesn't happen.
if let Some(tokens) = tokens {
- if tokens.eq_unspanned(&tokens_for_real) {
+ if tokens.probably_equal_for_proc_macro(&tokens_for_real) {
return tokens
}
}
return tokens_for_real
}
+
+ // See comments in `interpolated_to_tokenstream` for why we care about
+ // *probably* equal here rather than actual equality
+ pub fn probably_equal_for_proc_macro(&self, other: &Token) -> bool {
+ if mem::discriminant(self) != mem::discriminant(other) {
+ return false
+ }
+ match (self, other) {
+ (&Eq, &Eq) |
+ (&Lt, &Lt) |
+ (&Le, &Le) |
+ (&EqEq, &EqEq) |
+ (&Ne, &Ne) |
+ (&Ge, &Ge) |
+ (&Gt, &Gt) |
+ (&AndAnd, &AndAnd) |
+ (&OrOr, &OrOr) |
+ (&Not, &Not) |
+ (&Tilde, &Tilde) |
+ (&At, &At) |
+ (&Dot, &Dot) |
+ (&DotDot, &DotDot) |
+ (&DotDotDot, &DotDotDot) |
+ (&DotDotEq, &DotDotEq) |
+ (&DotEq, &DotEq) |
+ (&Comma, &Comma) |
+ (&Semi, &Semi) |
+ (&Colon, &Colon) |
+ (&ModSep, &ModSep) |
+ (&RArrow, &RArrow) |
+ (&LArrow, &LArrow) |
+ (&FatArrow, &FatArrow) |
+ (&Pound, &Pound) |
+ (&Dollar, &Dollar) |
+ (&Question, &Question) |
+ (&Whitespace, &Whitespace) |
+ (&Comment, &Comment) |
+ (&Eof, &Eof) => true,
+
+ (&BinOp(a), &BinOp(b)) |
+ (&BinOpEq(a), &BinOpEq(b)) => a == b,
+
+ (&OpenDelim(a), &OpenDelim(b)) |
+ (&CloseDelim(a), &CloseDelim(b)) => a == b,
+
+ (&DocComment(a), &DocComment(b)) |
+ (&Shebang(a), &Shebang(b)) => a == b,
+
+ (&Lifetime(a), &Lifetime(b)) => a.name == b.name,
+ (&Ident(a, b), &Ident(c, d)) => a.name == c.name && b == d,
+
+ (&Literal(ref a, b), &Literal(ref c, d)) => {
+ b == d && a.probably_equal_for_proc_macro(c)
+ }
+
+ (&Interpolated(_), &Interpolated(_)) => false,
+
+ _ => panic!("forgot to add a token?"),
+ }
+ }
}
#[derive(Clone, RustcEncodable, RustcDecodable, Eq, Hash)]
diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs
index 6ac04b3..e2b5c4e 100644
--- a/src/libsyntax/tokenstream.rs
+++ b/src/libsyntax/tokenstream.rs
@@ -124,6 +124,24 @@
}
}
+ // See comments in `interpolated_to_tokenstream` for why we care about
+ // *probably* equal here rather than actual equality
+ //
+ // This is otherwise the same as `eq_unspanned`, only recursing with a
+ // different method.
+ pub fn probably_equal_for_proc_macro(&self, other: &TokenTree) -> bool {
+ match (self, other) {
+ (&TokenTree::Token(_, ref tk), &TokenTree::Token(_, ref tk2)) => {
+ tk.probably_equal_for_proc_macro(tk2)
+ }
+ (&TokenTree::Delimited(_, ref dl), &TokenTree::Delimited(_, ref dl2)) => {
+ dl.delim == dl2.delim &&
+ dl.stream().probably_equal_for_proc_macro(&dl2.stream())
+ }
+ (_, _) => false,
+ }
+ }
+
/// Retrieve the TokenTree's span.
pub fn span(&self) -> Span {
match *self {
@@ -250,6 +268,22 @@
t1.next().is_none() && t2.next().is_none()
}
+ // See comments in `interpolated_to_tokenstream` for why we care about
+ // *probably* equal here rather than actual equality
+ //
+ // This is otherwise the same as `eq_unspanned`, only recursing with a
+ // different method.
+ pub fn probably_equal_for_proc_macro(&self, other: &TokenStream) -> bool {
+ let mut t1 = self.trees();
+ let mut t2 = other.trees();
+ for (t1, t2) in t1.by_ref().zip(t2.by_ref()) {
+ if !t1.probably_equal_for_proc_macro(&t2) {
+ return false;
+ }
+ }
+ t1.next().is_none() && t2.next().is_none()
+ }
+
/// Precondition: `self` consists of a single token tree.
/// Returns true if the token tree is a joint operation w.r.t. `proc_macro::TokenNode`.
pub fn as_tree(self) -> (TokenTree, bool /* joint? */) {
diff --git a/src/stdsimd b/src/stdsimd
index effdcd0..1ea18a5 160000
--- a/src/stdsimd
+++ b/src/stdsimd
@@ -1 +1 @@
-Subproject commit effdcd0132d17b6c4badc67b4b6d3fdf749a2d22
+Subproject commit 1ea18a5cb431e24aa838b652ac305acc5e394d6b
diff --git a/src/test/compile-fail-fulldeps/proc-macro/attribute-with-error.rs b/src/test/compile-fail-fulldeps/proc-macro/attribute-with-error.rs
index 00a2781..edfedeb 100644
--- a/src/test/compile-fail-fulldeps/proc-macro/attribute-with-error.rs
+++ b/src/test/compile-fail-fulldeps/proc-macro/attribute-with-error.rs
@@ -21,6 +21,8 @@
fn test1() {
let a: i32 = "foo";
//~^ ERROR: mismatched types
+ let b: i32 = "f'oo";
+ //~^ ERROR: mismatched types
}
fn test2() {
diff --git a/src/test/compile-fail/issue-43105.rs b/src/test/compile-fail/issue-43105.rs
index c0af3b4..6fa65a5 100644
--- a/src/test/compile-fail/issue-43105.rs
+++ b/src/test/compile-fail/issue-43105.rs
@@ -11,7 +11,7 @@
fn xyz() -> u8 { 42 }
const NUM: u8 = xyz();
-//~^ ERROR calls in constants are limited to constant functions, struct and enum constructors
+//~^ ERROR calls in constants are limited to constant functions, tuple structs and tuple variants
//~| ERROR constant evaluation error
fn main() {
diff --git a/src/test/compile-fail/issue32829.rs b/src/test/compile-fail/issue32829.rs
index e0b847f..9a84322 100644
--- a/src/test/compile-fail/issue32829.rs
+++ b/src/test/compile-fail/issue32829.rs
@@ -7,6 +7,9 @@
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+
+// ignore-tidy-linelength
+
#![feature(const_fn)]
const bad : u32 = {
@@ -20,7 +23,7 @@
{
invalid();
//~^ ERROR: blocks in constants are limited to items and tail expressions
- //~^^ ERROR: calls in constants are limited to constant functions, struct and enum
+ //~^^ ERROR: calls in constants are limited to constant functions, tuple structs and tuple variants
0
}
};
@@ -44,7 +47,7 @@
{
invalid();
//~^ ERROR: blocks in statics are limited to items and tail expressions
- //~^^ ERROR: calls in statics are limited to constant functions, struct and enum
+ //~^^ ERROR: calls in statics are limited to constant functions, tuple structs and tuple variants
0
}
};
@@ -68,7 +71,7 @@
{
invalid();
//~^ ERROR: blocks in statics are limited to items and tail expressions
- //~^^ ERROR: calls in statics are limited to constant functions, struct and enum
+ //~^^ ERROR: calls in statics are limited to constant functions, tuple structs and tuple variants
0
}
};
diff --git a/src/test/ui/const-fn-error.stderr b/src/test/ui/const-fn-error.stderr
index 077c4d6..767f28f 100644
--- a/src/test/ui/const-fn-error.stderr
+++ b/src/test/ui/const-fn-error.stderr
@@ -4,7 +4,7 @@
LL | let mut sum = 0;
| ^
-error[E0015]: calls in constant functions are limited to constant functions, struct and enum constructors
+error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
--> $DIR/const-fn-error.rs:18:14
|
LL | for i in 0..x {
diff --git a/src/test/ui/mir_check_nonconst.rs b/src/test/ui/mir_check_nonconst.rs
new file mode 100644
index 0000000..898ee8b
--- /dev/null
+++ b/src/test/ui/mir_check_nonconst.rs
@@ -0,0 +1,21 @@
+// Copyright 2017 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(dead_code)]
+
+struct Foo { a: u8 }
+fn bar() -> Foo {
+ Foo { a: 5 }
+}
+
+static foo: Foo = bar();
+//~^ ERROR calls in statics are limited to constant functions, tuple structs and tuple variants
+
+fn main() {}
diff --git a/src/test/ui/mir_check_nonconst.stderr b/src/test/ui/mir_check_nonconst.stderr
new file mode 100644
index 0000000..1fddaf3
--- /dev/null
+++ b/src/test/ui/mir_check_nonconst.stderr
@@ -0,0 +1,9 @@
+error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants
+ --> $DIR/mir_check_nonconst.rs:18:19
+ |
+LL | static foo: Foo = bar();
+ | ^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0015`.
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index c16dbd0..0f4d247 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2880,8 +2880,10 @@
}
}
- let expected_output_path = self.expected_output_path(kind);
- let output_file = self.output_base_name().with_file_name(&expected_output_path);
+ let expected_output = self.expected_output_path(kind);
+ // #50113: output is abspath; only want filename component.
+ let expected_output = expected_output.file_name().expect("output path requires file name");
+ let output_file = self.output_base_name().with_file_name(&expected_output);
match File::create(&output_file).and_then(|mut f| f.write_all(actual.as_bytes())) {
Ok(()) => {}
Err(e) => self.fatal(&format!(
