mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-01 06:51:58 +00:00
Auto merge of #41138 - frewsxcv:rollup, r=frewsxcv
Rollup of 9 pull requests - Successful merges: #40797, #41047, #41056, #41061, #41075, #41080, #41120, #41130, #41131 - Failed merges:
This commit is contained in:
bors
commit
53f4bc311b
@ -141,15 +141,18 @@ install:
|
||||
- set SCCACHE_ERROR_LOG=%CD%/sccache.log
|
||||
|
||||
test_script:
|
||||
- appveyor-retry sh -c 'git submodule deinit -f . && git submodule update --init'
|
||||
- if not exist C:\cache\rustsrc\NUL mkdir C:\cache\rustsrc
|
||||
- sh src/ci/init_repo.sh . /c/cache/rustsrc
|
||||
- set SRC=.
|
||||
- set NO_CCACHE=1
|
||||
- sh src/ci/run.sh
|
||||
|
||||
on_failure:
|
||||
- cat %CD%/sccache.log
|
||||
- cat %CD%\sccache.log
|
||||
- cat C:\Users\appveyor\AppData\Local\Temp\1\build-cache-logs\*.log
|
||||
|
||||
cache:
|
||||
- C:\cache\rustsrc
|
||||
- "build/i686-pc-windows-msvc/llvm -> src/rustllvm/llvm-rebuild-trigger"
|
||||
- "build/x86_64-pc-windows-msvc/llvm -> src/rustllvm/llvm-rebuild-trigger"
|
||||
- "i686-pc-windows-msvc/llvm -> src/rustllvm/llvm-rebuild-trigger"
|
||||
|
||||
@ -433,29 +433,32 @@ pub fn rust_src(build: &Build) {
|
||||
copy(&build.src.join(item), &dst_src.join(item));
|
||||
}
|
||||
|
||||
// Get cargo-vendor installed, if it isn't already.
|
||||
let mut has_cargo_vendor = false;
|
||||
let mut cmd = Command::new(&build.cargo);
|
||||
for line in output(cmd.arg("install").arg("--list")).lines() {
|
||||
has_cargo_vendor |= line.starts_with("cargo-vendor ");
|
||||
}
|
||||
if !has_cargo_vendor {
|
||||
// If we're building from git sources, we need to vendor a complete distribution.
|
||||
if build.src_is_git {
|
||||
// Get cargo-vendor installed, if it isn't already.
|
||||
let mut has_cargo_vendor = false;
|
||||
let mut cmd = Command::new(&build.cargo);
|
||||
cmd.arg("install")
|
||||
.arg("--force")
|
||||
.arg("--debug")
|
||||
.arg("--vers").arg(CARGO_VENDOR_VERSION)
|
||||
.arg("cargo-vendor")
|
||||
.env("RUSTC", &build.rustc);
|
||||
for line in output(cmd.arg("install").arg("--list")).lines() {
|
||||
has_cargo_vendor |= line.starts_with("cargo-vendor ");
|
||||
}
|
||||
if !has_cargo_vendor {
|
||||
let mut cmd = Command::new(&build.cargo);
|
||||
cmd.arg("install")
|
||||
.arg("--force")
|
||||
.arg("--debug")
|
||||
.arg("--vers").arg(CARGO_VENDOR_VERSION)
|
||||
.arg("cargo-vendor")
|
||||
.env("RUSTC", &build.rustc);
|
||||
build.run(&mut cmd);
|
||||
}
|
||||
|
||||
// Vendor all Cargo dependencies
|
||||
let mut cmd = Command::new(&build.cargo);
|
||||
cmd.arg("vendor")
|
||||
.current_dir(&dst_src.join("src"));
|
||||
build.run(&mut cmd);
|
||||
}
|
||||
|
||||
// Vendor all Cargo dependencies
|
||||
let mut cmd = Command::new(&build.cargo);
|
||||
cmd.arg("vendor")
|
||||
.current_dir(&dst_src.join("src"));
|
||||
build.run(&mut cmd);
|
||||
|
||||
// Create source tarball in rust-installer format
|
||||
let mut cmd = Command::new(SH_CMD);
|
||||
cmd.arg(sanitize_sh(&build.src.join("src/rust-installer/gen-installer.sh")))
|
||||
|
||||
@ -162,6 +162,7 @@ pub struct Build {
|
||||
cxx: HashMap<String, gcc::Tool>,
|
||||
crates: HashMap<String, Crate>,
|
||||
is_sudo: bool,
|
||||
src_is_git: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
@ -233,6 +234,7 @@ impl Build {
|
||||
};
|
||||
let rust_info = channel::GitInfo::new(&src);
|
||||
let cargo_info = channel::GitInfo::new(&src.join("cargo"));
|
||||
let src_is_git = src.join(".git").exists();
|
||||
|
||||
Build {
|
||||
flags: flags,
|
||||
@ -251,6 +253,7 @@ impl Build {
|
||||
lldb_version: None,
|
||||
lldb_python_dir: None,
|
||||
is_sudo: is_sudo,
|
||||
src_is_git: src_is_git,
|
||||
}
|
||||
}
|
||||
|
||||
@ -307,10 +310,7 @@ impl Build {
|
||||
OutOfSync,
|
||||
}
|
||||
|
||||
if !self.config.submodules {
|
||||
return
|
||||
}
|
||||
if fs::metadata(self.src.join(".git")).is_err() {
|
||||
if !self.src_is_git || !self.config.submodules {
|
||||
return
|
||||
}
|
||||
let git = || {
|
||||
|
||||
@ -65,7 +65,7 @@ pub fn check(build: &mut Build) {
|
||||
|
||||
// If we've got a git directory we're gona need git to update
|
||||
// submodules and learn about various other aspects.
|
||||
if fs::metadata(build.src.join(".git")).is_ok() {
|
||||
if build.src_is_git {
|
||||
need_cmd("git".as_ref());
|
||||
}
|
||||
|
||||
|
||||
@ -152,18 +152,13 @@ For targets: `powerpc-unknown-linux-gnu`
|
||||
- Path and misc options > Patches origin = Bundled, then local
|
||||
- Path and misc options > Local patch directory = /tmp/patches
|
||||
- Target options > Target Architecture = powerpc
|
||||
- Target options > Emit assembly for CPU = power4 -- (+)
|
||||
- Target options > Tune for CPU = power6 -- (+)
|
||||
- Target options > Emit assembly for CPU = powerpc -- pure 32-bit PowerPC
|
||||
- Operating System > Target OS = linux
|
||||
- Operating System > Linux kernel version = 2.6.32.68 -- ~RHEL6 kernel
|
||||
- C-library > glibc version = 2.12.2 -- ~RHEL6 glibc
|
||||
- C compiler > gcc version = 4.9.3
|
||||
- C compiler > Core gcc extra config = --with-cpu-32=power4 --with-cpu=default32 -- (+)
|
||||
- C compiler > gcc extra config = --with-cpu-32=power4 --with-cpu=default32 -- (+)
|
||||
- C compiler > C++ = ENABLE -- to cross compile LLVM
|
||||
|
||||
(+) These CPU options match the configuration of the toolchains in RHEL6.
|
||||
|
||||
## `powerpc64-linux-gnu.config`
|
||||
|
||||
For targets: `powerpc64-unknown-linux-gnu`
|
||||
|
||||
@ -14,13 +14,14 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
xz-utils \
|
||||
swig \
|
||||
libedit-dev \
|
||||
libncurses5-dev
|
||||
libncurses5-dev \
|
||||
patch
|
||||
|
||||
RUN curl -L https://cmake.org/files/v3.8/cmake-3.8.0-rc1-Linux-x86_64.tar.gz | \
|
||||
tar xzf - -C /usr/local --strip-components=1
|
||||
|
||||
WORKDIR /tmp
|
||||
COPY shared.sh build-toolchain.sh /tmp/
|
||||
COPY shared.sh build-toolchain.sh compiler-rt-dso-handle.patch /tmp/
|
||||
RUN /tmp/build-toolchain.sh
|
||||
|
||||
RUN curl -OL https://github.com/Yelp/dumb-init/releases/download/v1.2.0/dumb-init_1.2.0_amd64.deb && \
|
||||
|
||||
@ -9,26 +9,31 @@
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
# ignore-tidy-linelength
|
||||
|
||||
set -ex
|
||||
source shared.sh
|
||||
|
||||
# Download sources
|
||||
SRCS=(
|
||||
"https://fuchsia.googlesource.com/magenta magenta ac69119"
|
||||
"https://fuchsia.googlesource.com/third_party/llvm llvm 5463083"
|
||||
"https://fuchsia.googlesource.com/third_party/clang llvm/tools/clang 4ff7b4b"
|
||||
"https://fuchsia.googlesource.com/third_party/lld llvm/tools/lld fd465a3"
|
||||
"https://fuchsia.googlesource.com/third_party/lldb llvm/tools/lldb 6bb11f8"
|
||||
"https://fuchsia.googlesource.com/third_party/compiler-rt llvm/runtimes/compiler-rt 52d4ecc"
|
||||
"https://fuchsia.googlesource.com/third_party/libcxx llvm/runtimes/libcxx e891cc8"
|
||||
"https://fuchsia.googlesource.com/third_party/libcxxabi llvm/runtimes/libcxxabi f0f0257"
|
||||
"https://fuchsia.googlesource.com/third_party/libunwind llvm/runtimes/libunwind 50bddc1"
|
||||
"https://fuchsia.googlesource.com/magenta magenta d17073dc8de344ead3b65e8cc6a12280dec38c84"
|
||||
"https://llvm.googlesource.com/llvm llvm 3f58a16d8eec385e2b3ebdfbb84ff9d3bf27e025"
|
||||
"https://llvm.googlesource.com/clang llvm/tools/clang 727ea63e6e82677f6e10e05e08bc7d6bdbae3111"
|
||||
"https://llvm.googlesource.com/lld llvm/tools/lld a31286c1366e5e89b8872803fded13805a1a084b"
|
||||
"https://llvm.googlesource.com/lldb llvm/tools/lldb 0b2384abec4cb99ad66687712e07dee4dd9d187e"
|
||||
"https://llvm.googlesource.com/compiler-rt llvm/runtimes/compiler-rt 9093a35c599fe41278606a20b51095ea8bd5a081"
|
||||
"https://llvm.googlesource.com/libcxx llvm/runtimes/libcxx 607e0c71ec4f7fd377ad3f6c47b08dbe89f66eaa"
|
||||
"https://llvm.googlesource.com/libcxxabi llvm/runtimes/libcxxabi 0a3a1a8a5ca5ef69e0f6b7d5b9d13e63e6fd2c19"
|
||||
"https://llvm.googlesource.com/libunwind llvm/runtimes/libunwind e128003563d99d9ee62247c4cee40f07d21c03e3"
|
||||
)
|
||||
|
||||
fetch() {
|
||||
mkdir -p $2
|
||||
pushd $2 > /dev/null
|
||||
curl -sL $1/+archive/$3.tar.gz | tar xzf -
|
||||
git init
|
||||
git remote add origin $1
|
||||
git fetch --depth=1 origin $3
|
||||
git reset --hard FETCH_HEAD
|
||||
popd > /dev/null
|
||||
}
|
||||
|
||||
@ -36,6 +41,11 @@ for i in "${SRCS[@]}"; do
|
||||
fetch $i
|
||||
done
|
||||
|
||||
# Remove this once https://reviews.llvm.org/D28791 is resolved
|
||||
cd llvm/runtimes/compiler-rt
|
||||
patch -Np1 < /tmp/compiler-rt-dso-handle.patch
|
||||
cd ../../..
|
||||
|
||||
# Build toolchain
|
||||
cd llvm
|
||||
mkdir build
|
||||
|
||||
41
src/ci/docker/dist-fuchsia/compiler-rt-dso-handle.patch
Normal file
41
src/ci/docker/dist-fuchsia/compiler-rt-dso-handle.patch
Normal file
@ -0,0 +1,41 @@
|
||||
diff --git a/lib/builtins/CMakeLists.txt b/lib/builtins/CMakeLists.txt
|
||||
index fc4384af2..b442264c0 100644
|
||||
--- a/lib/builtins/CMakeLists.txt
|
||||
+++ b/lib/builtins/CMakeLists.txt
|
||||
@@ -194,6 +194,12 @@ if(APPLE)
|
||||
atomic_thread_fence.c)
|
||||
endif()
|
||||
|
||||
+if(FUCHSIA)
|
||||
+ set(GENERIC_SOURCES
|
||||
+ ${GENERIC_SOURCES}
|
||||
+ dso_handle.c)
|
||||
+endif()
|
||||
+
|
||||
if(NOT WIN32 OR MINGW)
|
||||
set(GENERIC_SOURCES
|
||||
${GENERIC_SOURCES}
|
||||
diff --git a/lib/builtins/dso_handle.c b/lib/builtins/dso_handle.c
|
||||
new file mode 100644
|
||||
index 000000000..7766cd0aa
|
||||
--- /dev/null
|
||||
+++ b/lib/builtins/dso_handle.c
|
||||
@@ -0,0 +1,18 @@
|
||||
+/* ===-- dso_handle.c - Provide __dso_handle -------------------------------===
|
||||
+ *
|
||||
+ * The LLVM Compiler Infrastructure
|
||||
+ *
|
||||
+ * This file is dual licensed under the MIT and the University of Illinois Open
|
||||
+ * Source Licenses. See LICENSE.TXT for details.
|
||||
+ *
|
||||
+ * ===----------------------------------------------------------------------===
|
||||
+ */
|
||||
+
|
||||
+/* __dso_handle symbol is mandated by C++ ABI with a value which is an address
|
||||
+ * in one of the object's segments, and as such this symbol has to be included
|
||||
+ * statically and cannot be a part of a shared library. Traditionally, it has
|
||||
+ * been defined in crtbegin.o but there's no principled reason for it to be
|
||||
+ * there. We defined this symbol in the builtin library which is built as a
|
||||
+ * static library and always included in the final link.
|
||||
+ */
|
||||
+__attribute__((visibility("hidden"))) void *const __dso_handle;
|
||||
@ -101,8 +101,8 @@ CT_ARCH_SUPPORTS_WITH_FLOAT=y
|
||||
CT_ARCH_DEFAULT_BE=y
|
||||
CT_ARCH_DEFAULT_32=y
|
||||
CT_ARCH_ABI=""
|
||||
CT_ARCH_CPU="power4"
|
||||
CT_ARCH_TUNE="power6"
|
||||
CT_ARCH_CPU="powerpc"
|
||||
CT_ARCH_TUNE=""
|
||||
CT_ARCH_BE=y
|
||||
# CT_ARCH_LE is not set
|
||||
CT_ARCH_32=y
|
||||
@ -391,8 +391,8 @@ CT_CC_GCC_HAS_LIBSANITIZER=y
|
||||
CT_CC_GCC_VERSION="4.9.3"
|
||||
# CT_CC_LANG_FORTRAN is not set
|
||||
CT_CC_GCC_ENABLE_CXX_FLAGS=""
|
||||
CT_CC_GCC_CORE_EXTRA_CONFIG_ARRAY="--with-cpu-32=power4 --with-cpu=default32"
|
||||
CT_CC_GCC_EXTRA_CONFIG_ARRAY="--with-cpu-32=power4 --with-cpu=default32"
|
||||
CT_CC_GCC_CORE_EXTRA_CONFIG_ARRAY=""
|
||||
CT_CC_GCC_EXTRA_CONFIG_ARRAY=""
|
||||
CT_CC_GCC_EXTRA_ENV_ARRAY=""
|
||||
CT_CC_GCC_STATIC_LIBSTDCXX=y
|
||||
# CT_CC_GCC_SYSTEM_ZLIB is not set
|
||||
|
||||
@ -38,9 +38,20 @@ fi
|
||||
|
||||
# Wipe the cache if it's not valid, or mark it as invalid while we update it
|
||||
if [ ! -f "$cache_valid_file" ]; then
|
||||
rm -rf "$CACHE_DIR" && mkdir "$CACHE_DIR"
|
||||
rm -rf "$CACHE_DIR"
|
||||
mkdir "$CACHE_DIR"
|
||||
else
|
||||
rm "$cache_valid_file"
|
||||
stat_lines=$(cd "$cache_src_dir" && git status --porcelain | wc -l)
|
||||
stat_ec=$(cd "$cache_src_dir" && git status >/dev/null 2>&1 && echo $?)
|
||||
if [ ! -d "$cache_src_dir/.git" -o $stat_lines != 0 -o $stat_ec != 0 ]; then
|
||||
# Something is badly wrong - the cache valid file is here, but something
|
||||
# about the git repo is fishy. Nuke it all, just in case
|
||||
echo "WARNING: $cache_valid_file exists but bad repo: l:$stat_lines, ec:$stat_ec"
|
||||
rm -rf "$CACHE_DIR"
|
||||
mkdir "$CACHE_DIR"
|
||||
else
|
||||
rm "$cache_valid_file"
|
||||
fi
|
||||
fi
|
||||
|
||||
# Update the cache (a pristine copy of the rust source master)
|
||||
|
||||
@ -2697,7 +2697,7 @@ impl<'a> LoweringContext<'a> {
|
||||
fn pat_ident_binding_mode(&mut self, span: Span, name: Name, bm: hir::BindingMode)
|
||||
-> P<hir::Pat> {
|
||||
let id = self.next_id();
|
||||
let parent_def = self.parent_def;
|
||||
let parent_def = self.parent_def.unwrap();
|
||||
let def_id = {
|
||||
let defs = self.resolver.definitions();
|
||||
let def_path_data = DefPathData::Binding(name.as_str());
|
||||
|
||||
@ -40,11 +40,9 @@ impl<'a> DefCollector<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn collect_root(&mut self) {
|
||||
let root = self.create_def_with_parent(None,
|
||||
CRATE_NODE_ID,
|
||||
DefPathData::CrateRoot,
|
||||
ITEM_LIKE_SPACE);
|
||||
pub fn collect_root(&mut self, crate_name: &str, crate_disambiguator: &str) {
|
||||
let root = self.definitions.create_root_def(crate_name,
|
||||
crate_disambiguator);
|
||||
assert_eq!(root, CRATE_DEF_INDEX);
|
||||
self.parent_def = Some(root);
|
||||
}
|
||||
@ -54,20 +52,11 @@ impl<'a> DefCollector<'a> {
|
||||
data: DefPathData,
|
||||
address_space: DefIndexAddressSpace)
|
||||
-> DefIndex {
|
||||
let parent_def = self.parent_def;
|
||||
let parent_def = self.parent_def.unwrap();
|
||||
debug!("create_def(node_id={:?}, data={:?}, parent_def={:?})", node_id, data, parent_def);
|
||||
self.definitions.create_def_with_parent(parent_def, node_id, data, address_space)
|
||||
}
|
||||
|
||||
fn create_def_with_parent(&mut self,
|
||||
parent: Option<DefIndex>,
|
||||
node_id: NodeId,
|
||||
data: DefPathData,
|
||||
address_space: DefIndexAddressSpace)
|
||||
-> DefIndex {
|
||||
self.definitions.create_def_with_parent(parent, node_id, data, address_space)
|
||||
}
|
||||
|
||||
pub fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_def: DefIndex, f: F) {
|
||||
let parent = self.parent_def;
|
||||
self.parent_def = Some(parent_def);
|
||||
|
||||
@ -21,7 +21,7 @@ use rustc_data_structures::indexed_vec::IndexVec;
|
||||
use rustc_data_structures::stable_hasher::StableHasher;
|
||||
use serialize::{Encodable, Decodable, Encoder, Decoder};
|
||||
use std::fmt::Write;
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::hash::Hash;
|
||||
use syntax::ast;
|
||||
use syntax::symbol::{Symbol, InternedString};
|
||||
use ty::TyCtxt;
|
||||
@ -34,6 +34,7 @@ use util::nodemap::NodeMap;
|
||||
pub struct DefPathTable {
|
||||
index_to_key: [Vec<DefKey>; 2],
|
||||
key_to_index: FxHashMap<DefKey, DefIndex>,
|
||||
def_path_hashes: [Vec<u64>; 2],
|
||||
}
|
||||
|
||||
// Unfortunately we have to provide a manual impl of Clone because of the
|
||||
@ -44,6 +45,8 @@ impl Clone for DefPathTable {
|
||||
index_to_key: [self.index_to_key[0].clone(),
|
||||
self.index_to_key[1].clone()],
|
||||
key_to_index: self.key_to_index.clone(),
|
||||
def_path_hashes: [self.def_path_hashes[0].clone(),
|
||||
self.def_path_hashes[1].clone()],
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -52,6 +55,7 @@ impl DefPathTable {
|
||||
|
||||
fn allocate(&mut self,
|
||||
key: DefKey,
|
||||
def_path_hash: u64,
|
||||
address_space: DefIndexAddressSpace)
|
||||
-> DefIndex {
|
||||
let index = {
|
||||
@ -62,6 +66,9 @@ impl DefPathTable {
|
||||
index
|
||||
};
|
||||
self.key_to_index.insert(key, index);
|
||||
self.def_path_hashes[address_space.index()].push(def_path_hash);
|
||||
debug_assert!(self.def_path_hashes[address_space.index()].len() ==
|
||||
self.index_to_key[address_space.index()].len());
|
||||
index
|
||||
}
|
||||
|
||||
@ -71,6 +78,12 @@ impl DefPathTable {
|
||||
[index.as_array_index()].clone()
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn def_path_hash(&self, index: DefIndex) -> u64 {
|
||||
self.def_path_hashes[index.address_space().index()]
|
||||
[index.as_array_index()]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn def_index_for_def_key(&self, key: &DefKey) -> Option<DefIndex> {
|
||||
self.key_to_index.get(key).cloned()
|
||||
@ -116,17 +129,28 @@ impl DefPathTable {
|
||||
|
||||
impl Encodable for DefPathTable {
|
||||
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
|
||||
// Index to key
|
||||
self.index_to_key[DefIndexAddressSpace::Low.index()].encode(s)?;
|
||||
self.index_to_key[DefIndexAddressSpace::High.index()].encode(s)
|
||||
self.index_to_key[DefIndexAddressSpace::High.index()].encode(s)?;
|
||||
|
||||
// DefPath hashes
|
||||
self.def_path_hashes[DefIndexAddressSpace::Low.index()].encode(s)?;
|
||||
self.def_path_hashes[DefIndexAddressSpace::High.index()].encode(s)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Decodable for DefPathTable {
|
||||
fn decode<D: Decoder>(d: &mut D) -> Result<DefPathTable, D::Error> {
|
||||
let index_to_key_lo: Vec<DefKey> = Decodable::decode(d)?;
|
||||
let index_to_key_high: Vec<DefKey> = Decodable::decode(d)?;
|
||||
let index_to_key_hi: Vec<DefKey> = Decodable::decode(d)?;
|
||||
|
||||
let index_to_key = [index_to_key_lo, index_to_key_high];
|
||||
let def_path_hashes_lo: Vec<u64> = Decodable::decode(d)?;
|
||||
let def_path_hashes_hi: Vec<u64> = Decodable::decode(d)?;
|
||||
|
||||
let index_to_key = [index_to_key_lo, index_to_key_hi];
|
||||
let def_path_hashes = [def_path_hashes_lo, def_path_hashes_hi];
|
||||
|
||||
let mut key_to_index = FxHashMap();
|
||||
|
||||
@ -141,6 +165,7 @@ impl Decodable for DefPathTable {
|
||||
Ok(DefPathTable {
|
||||
index_to_key: index_to_key,
|
||||
key_to_index: key_to_index,
|
||||
def_path_hashes: def_path_hashes,
|
||||
})
|
||||
}
|
||||
}
|
||||
@ -184,6 +209,29 @@ pub struct DefKey {
|
||||
pub disambiguated_data: DisambiguatedDefPathData,
|
||||
}
|
||||
|
||||
impl DefKey {
|
||||
fn compute_stable_hash(&self, parent_hash: u64) -> u64 {
|
||||
let mut hasher = StableHasher::new();
|
||||
|
||||
// We hash a 0u8 here to disambiguate between regular DefPath hashes,
|
||||
// and the special "root_parent" below.
|
||||
0u8.hash(&mut hasher);
|
||||
parent_hash.hash(&mut hasher);
|
||||
self.disambiguated_data.hash(&mut hasher);
|
||||
hasher.finish()
|
||||
}
|
||||
|
||||
fn root_parent_stable_hash(crate_name: &str, crate_disambiguator: &str) -> u64 {
|
||||
let mut hasher = StableHasher::new();
|
||||
// Disambiguate this from a regular DefPath hash,
|
||||
// see compute_stable_hash() above.
|
||||
1u8.hash(&mut hasher);
|
||||
crate_name.hash(&mut hasher);
|
||||
crate_disambiguator.hash(&mut hasher);
|
||||
hasher.finish()
|
||||
}
|
||||
}
|
||||
|
||||
/// Pair of `DefPathData` and an integer disambiguator. The integer is
|
||||
/// normally 0, but in the event that there are multiple defs with the
|
||||
/// same `parent` and `data`, we use this field to disambiguate
|
||||
@ -271,19 +319,6 @@ impl DefPath {
|
||||
|
||||
s
|
||||
}
|
||||
|
||||
pub fn deterministic_hash(&self, tcx: TyCtxt) -> u64 {
|
||||
debug!("deterministic_hash({:?})", self);
|
||||
let mut state = StableHasher::new();
|
||||
self.deterministic_hash_to(tcx, &mut state);
|
||||
state.finish()
|
||||
}
|
||||
|
||||
pub fn deterministic_hash_to<H: Hasher>(&self, tcx: TyCtxt, state: &mut H) {
|
||||
tcx.original_crate_name(self.krate).as_str().hash(state);
|
||||
tcx.crate_disambiguator(self.krate).as_str().hash(state);
|
||||
self.data.hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
|
||||
@ -338,6 +373,7 @@ impl Definitions {
|
||||
table: DefPathTable {
|
||||
index_to_key: [vec![], vec![]],
|
||||
key_to_index: FxHashMap(),
|
||||
def_path_hashes: [vec![], vec![]],
|
||||
},
|
||||
node_to_def_index: NodeMap(),
|
||||
def_index_to_node: [vec![], vec![]],
|
||||
@ -359,6 +395,11 @@ impl Definitions {
|
||||
self.table.def_key(index)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn def_path_hash(&self, index: DefIndex) -> u64 {
|
||||
self.table.def_path_hash(index)
|
||||
}
|
||||
|
||||
pub fn def_index_for_def_key(&self, key: DefKey) -> Option<DefIndex> {
|
||||
self.table.def_index_for_def_key(&key)
|
||||
}
|
||||
@ -398,12 +439,38 @@ impl Definitions {
|
||||
self.node_to_hir_id[node_id]
|
||||
}
|
||||
|
||||
/// Add a definition with a parent definition.
|
||||
pub fn create_root_def(&mut self,
|
||||
crate_name: &str,
|
||||
crate_disambiguator: &str)
|
||||
-> DefIndex {
|
||||
let key = DefKey {
|
||||
parent: None,
|
||||
disambiguated_data: DisambiguatedDefPathData {
|
||||
data: DefPathData::CrateRoot,
|
||||
disambiguator: 0
|
||||
}
|
||||
};
|
||||
|
||||
let parent_hash = DefKey::root_parent_stable_hash(crate_name,
|
||||
crate_disambiguator);
|
||||
let def_path_hash = key.compute_stable_hash(parent_hash);
|
||||
|
||||
// Create the definition.
|
||||
let address_space = super::ITEM_LIKE_SPACE;
|
||||
let index = self.table.allocate(key, def_path_hash, address_space);
|
||||
assert!(self.def_index_to_node[address_space.index()].is_empty());
|
||||
self.def_index_to_node[address_space.index()].push(ast::CRATE_NODE_ID);
|
||||
self.node_to_def_index.insert(ast::CRATE_NODE_ID, index);
|
||||
|
||||
index
|
||||
}
|
||||
|
||||
/// Add a definition with a parent definition.
|
||||
pub fn create_def_with_parent(&mut self,
|
||||
parent: Option<DefIndex>,
|
||||
parent: DefIndex,
|
||||
node_id: ast::NodeId,
|
||||
data: DefPathData,
|
||||
// is_owner: bool)
|
||||
address_space: DefIndexAddressSpace)
|
||||
-> DefIndex {
|
||||
debug!("create_def_with_parent(parent={:?}, node_id={:?}, data={:?})",
|
||||
@ -415,12 +482,13 @@ impl Definitions {
|
||||
data,
|
||||
self.table.def_key(self.node_to_def_index[&node_id]));
|
||||
|
||||
assert_eq!(parent.is_some(), data != DefPathData::CrateRoot);
|
||||
// The root node must be created with create_root_def()
|
||||
assert!(data != DefPathData::CrateRoot);
|
||||
|
||||
// Find a unique DefKey. This basically means incrementing the disambiguator
|
||||
// until we get no match.
|
||||
let mut key = DefKey {
|
||||
parent: parent,
|
||||
parent: Some(parent),
|
||||
disambiguated_data: DisambiguatedDefPathData {
|
||||
data: data,
|
||||
disambiguator: 0
|
||||
@ -431,10 +499,13 @@ impl Definitions {
|
||||
key.disambiguated_data.disambiguator += 1;
|
||||
}
|
||||
|
||||
let parent_hash = self.table.def_path_hash(parent);
|
||||
let def_path_hash = key.compute_stable_hash(parent_hash);
|
||||
|
||||
debug!("create_def_with_parent: after disambiguation, key = {:?}", key);
|
||||
|
||||
// Create the definition.
|
||||
let index = self.table.allocate(key, address_space);
|
||||
let index = self.table.allocate(key, def_path_hash, address_space);
|
||||
assert_eq!(index.as_array_index(),
|
||||
self.def_index_to_node[address_space.index()].len());
|
||||
self.def_index_to_node[address_space.index()].push(node_id);
|
||||
|
||||
@ -1,36 +0,0 @@
|
||||
// Copyright 2012-2014 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 hir::def_id::DefId;
|
||||
use ty::TyCtxt;
|
||||
use util::nodemap::DefIdMap;
|
||||
|
||||
pub struct DefPathHashes<'a, 'tcx: 'a> {
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
data: DefIdMap<u64>,
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> DefPathHashes<'a, 'tcx> {
|
||||
pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
|
||||
DefPathHashes {
|
||||
tcx: tcx,
|
||||
data: DefIdMap()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn hash(&mut self, def_id: DefId) -> u64 {
|
||||
let tcx = self.tcx;
|
||||
*self.data.entry(def_id)
|
||||
.or_insert_with(|| {
|
||||
let def_path = tcx.def_path(def_id);
|
||||
def_path.deterministic_hash(tcx)
|
||||
})
|
||||
}
|
||||
}
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
use hir;
|
||||
use hir::def_id::DefId;
|
||||
use ich::{self, CachingCodemapView, DefPathHashes};
|
||||
use ich::{self, CachingCodemapView};
|
||||
use session::config::DebugInfoLevel::NoDebugInfo;
|
||||
use ty;
|
||||
|
||||
@ -32,7 +32,6 @@ use rustc_data_structures::accumulate_vec::AccumulateVec;
|
||||
/// things (e.g. each DefId/DefPath is only hashed once).
|
||||
pub struct StableHashingContext<'a, 'tcx: 'a> {
|
||||
tcx: ty::TyCtxt<'a, 'tcx, 'tcx>,
|
||||
def_path_hashes: DefPathHashes<'a, 'tcx>,
|
||||
codemap: CachingCodemapView<'tcx>,
|
||||
hash_spans: bool,
|
||||
hash_bodies: bool,
|
||||
@ -64,7 +63,6 @@ impl<'a, 'tcx: 'a> StableHashingContext<'a, 'tcx> {
|
||||
|
||||
StableHashingContext {
|
||||
tcx: tcx,
|
||||
def_path_hashes: DefPathHashes::new(tcx),
|
||||
codemap: CachingCodemapView::new(tcx),
|
||||
hash_spans: hash_spans_initial,
|
||||
hash_bodies: true,
|
||||
@ -111,7 +109,7 @@ impl<'a, 'tcx: 'a> StableHashingContext<'a, 'tcx> {
|
||||
|
||||
#[inline]
|
||||
pub fn def_path_hash(&mut self, def_id: DefId) -> u64 {
|
||||
self.def_path_hashes.hash(def_id)
|
||||
self.tcx.def_path_hash(def_id)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
||||
@ -11,12 +11,10 @@
|
||||
//! ICH - Incremental Compilation Hash
|
||||
|
||||
pub use self::fingerprint::Fingerprint;
|
||||
pub use self::def_path_hash::DefPathHashes;
|
||||
pub use self::caching_codemap_view::CachingCodemapView;
|
||||
pub use self::hcx::{StableHashingContext, NodeIdHashingMode};
|
||||
|
||||
mod fingerprint;
|
||||
mod def_path_hash;
|
||||
mod caching_codemap_view;
|
||||
mod hcx;
|
||||
|
||||
|
||||
@ -172,7 +172,7 @@ pub trait CrateStore {
|
||||
fn stability(&self, def: DefId) -> Option<attr::Stability>;
|
||||
fn deprecation(&self, def: DefId) -> Option<attr::Deprecation>;
|
||||
fn visibility(&self, def: DefId) -> ty::Visibility;
|
||||
fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>>;
|
||||
fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>>;
|
||||
fn item_generics_cloned(&self, def: DefId) -> ty::Generics;
|
||||
fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>;
|
||||
fn fn_arg_names(&self, did: DefId) -> Vec<ast::Name>;
|
||||
@ -230,6 +230,7 @@ pub trait CrateStore {
|
||||
-> Option<DefId>;
|
||||
fn def_key(&self, def: DefId) -> DefKey;
|
||||
fn def_path(&self, def: DefId) -> hir_map::DefPath;
|
||||
fn def_path_hash(&self, def: DefId) -> u64;
|
||||
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>;
|
||||
fn item_children(&self, did: DefId) -> Vec<def::Export>;
|
||||
fn load_macro(&self, did: DefId, sess: &Session) -> LoadedMacro;
|
||||
@ -302,7 +303,7 @@ impl CrateStore for DummyCrateStore {
|
||||
fn stability(&self, def: DefId) -> Option<attr::Stability> { bug!("stability") }
|
||||
fn deprecation(&self, def: DefId) -> Option<attr::Deprecation> { bug!("deprecation") }
|
||||
fn visibility(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
|
||||
fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>> {
|
||||
fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>> {
|
||||
bug!("visible_parent_map")
|
||||
}
|
||||
fn item_generics_cloned(&self, def: DefId) -> ty::Generics
|
||||
@ -377,6 +378,9 @@ impl CrateStore for DummyCrateStore {
|
||||
fn def_path(&self, def: DefId) -> hir_map::DefPath {
|
||||
bug!("relative_def_path")
|
||||
}
|
||||
fn def_path_hash(&self, def: DefId) -> u64 {
|
||||
bug!("wa")
|
||||
}
|
||||
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name> { bug!("struct_field_names") }
|
||||
fn item_children(&self, did: DefId) -> Vec<def::Export> { bug!("item_children") }
|
||||
fn load_macro(&self, did: DefId, sess: &Session) -> LoadedMacro { bug!("load_macro") }
|
||||
|
||||
@ -2227,6 +2227,15 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn def_path_hash(self, def_id: DefId) -> u64 {
|
||||
if def_id.is_local() {
|
||||
self.hir.definitions().def_path_hash(def_id.index)
|
||||
} else {
|
||||
self.sess.cstore.def_path_hash(def_id)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn def_span(self, def_id: DefId) -> Span {
|
||||
if let Some(id) = self.hir.as_local_node_id(def_id) {
|
||||
self.hir.span(id)
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
use hir::def_id::{DefId, LOCAL_CRATE};
|
||||
use hir::map::DefPathData;
|
||||
use infer::InferCtxt;
|
||||
use hir::map as hir_map;
|
||||
// use hir::map as hir_map;
|
||||
use traits::{self, Reveal};
|
||||
use ty::{self, Ty, TyCtxt, TypeAndMut, TypeFlags, TypeFoldable};
|
||||
use ty::ParameterEnvironment;
|
||||
@ -441,13 +441,11 @@ impl<'a, 'gcx, 'tcx, W> TypeIdHasher<'a, 'gcx, 'tcx, W>
|
||||
|
||||
fn def_id(&mut self, did: DefId) {
|
||||
// Hash the DefPath corresponding to the DefId, which is independent
|
||||
// of compiler internal state.
|
||||
let path = self.tcx.def_path(did);
|
||||
self.def_path(&path)
|
||||
}
|
||||
|
||||
pub fn def_path(&mut self, def_path: &hir_map::DefPath) {
|
||||
def_path.deterministic_hash_to(self.tcx, &mut self.state);
|
||||
// of compiler internal state. We already have a stable hash value of
|
||||
// all DefPaths available via tcx.def_path_hash(), so we just feed that
|
||||
// into the hasher.
|
||||
let hash = self.tcx.def_path_hash(did);
|
||||
self.hash(hash);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -347,7 +347,7 @@ ALIASABLE(*LV, MQ) // M-Deref-Unique
|
||||
ALIASABLE(LV, MQ)
|
||||
```
|
||||
|
||||
### Checking mutability of immutable pointer types
|
||||
### Checking aliasability of immutable pointer types
|
||||
|
||||
Immutable pointer types like `&T` are aliasable, and hence can only be
|
||||
borrowed immutably:
|
||||
@ -357,7 +357,7 @@ ALIASABLE(*LV, imm) // M-Deref-Borrowed-Imm
|
||||
TYPE(LV) = &Ty
|
||||
```
|
||||
|
||||
### Checking mutability of mutable pointer types
|
||||
### Checking aliasability of mutable pointer types
|
||||
|
||||
`&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
|
||||
|
||||
@ -633,7 +633,7 @@ Here is a concrete example of a bug this rule prevents:
|
||||
|
||||
```rust
|
||||
// Test region-reborrow-from-shorter-mut-ref.rs:
|
||||
fn copy_pointer<'a,'b,T>(x: &'a mut &'b mut T) -> &'b mut T {
|
||||
fn copy_borrowed_ptr<'a,'b,T>(x: &'a mut &'b mut T) -> &'b mut T {
|
||||
&mut **p // ERROR due to clause (1)
|
||||
}
|
||||
fn main() {
|
||||
|
||||
@ -647,8 +647,12 @@ pub fn phase_2_configure_and_expand<F>(sess: &Session,
|
||||
let mut crate_loader = CrateLoader::new(sess, &cstore, crate_name);
|
||||
crate_loader.preprocess(&krate);
|
||||
let resolver_arenas = Resolver::arenas();
|
||||
let mut resolver =
|
||||
Resolver::new(sess, &krate, make_glob_map, &mut crate_loader, &resolver_arenas);
|
||||
let mut resolver = Resolver::new(sess,
|
||||
&krate,
|
||||
crate_name,
|
||||
make_glob_map,
|
||||
&mut crate_loader,
|
||||
&resolver_arenas);
|
||||
resolver.whitelisted_legacy_custom_derives = whitelisted_legacy_custom_derives;
|
||||
syntax_ext::register_builtins(&mut resolver, syntax_exts, sess.features.borrow().quote);
|
||||
|
||||
|
||||
@ -99,6 +99,13 @@ impl<'a, 'tcx: 'a> ComputeItemHashesVisitor<'a, 'tcx> {
|
||||
item_like: T)
|
||||
where T: HashStable<StableHashingContext<'a, 'tcx>>
|
||||
{
|
||||
if !hash_bodies && !self.hcx.tcx().sess.opts.build_dep_graph() {
|
||||
// If we just need the hashes in order to compute the SVH, we don't
|
||||
// need have two hashes per item. Just the one containing also the
|
||||
// item's body is sufficient.
|
||||
return
|
||||
}
|
||||
|
||||
let mut hasher = IchHasher::new();
|
||||
self.hcx.while_hashing_hir_bodies(hash_bodies, |hcx| {
|
||||
item_like.hash_stable(hcx, &mut hasher);
|
||||
@ -143,7 +150,7 @@ impl<'a, 'tcx: 'a> ComputeItemHashesVisitor<'a, 'tcx> {
|
||||
(item_dep_node, item_hash)
|
||||
})
|
||||
.collect();
|
||||
item_hashes.sort(); // avoid artificial dependencies on item ordering
|
||||
item_hashes.sort_unstable(); // avoid artificial dependencies on item ordering
|
||||
item_hashes.hash(&mut crate_state);
|
||||
}
|
||||
|
||||
|
||||
@ -23,6 +23,7 @@
|
||||
#![feature(staged_api)]
|
||||
#![feature(rand)]
|
||||
#![feature(conservative_impl_trait)]
|
||||
#![feature(sort_unstable)]
|
||||
#![cfg_attr(stage0, feature(pub_restricted))]
|
||||
|
||||
extern crate graphviz;
|
||||
|
||||
@ -186,10 +186,6 @@ impl<'a,'tcx> DefIdDirectoryBuilder<'a,'tcx> {
|
||||
.clone()
|
||||
}
|
||||
|
||||
pub fn lookup_def_path(&self, id: DefPathIndex) -> &DefPath {
|
||||
&self.directory.paths[id.index as usize]
|
||||
}
|
||||
|
||||
pub fn map(&mut self, node: &DepNode<DefId>) -> DepNode<DefPathIndex> {
|
||||
node.map_def(|&def_id| Some(self.add(def_id))).unwrap()
|
||||
}
|
||||
|
||||
@ -258,8 +258,6 @@ pub fn encode_metadata_hashes(tcx: TyCtxt,
|
||||
index_map: FxHashMap()
|
||||
};
|
||||
|
||||
let mut def_id_hashes = FxHashMap();
|
||||
|
||||
for (index, target) in preds.reduced_graph.all_nodes().iter().enumerate() {
|
||||
let index = NodeIndex(index);
|
||||
let def_id = match *target.data {
|
||||
@ -267,15 +265,6 @@ pub fn encode_metadata_hashes(tcx: TyCtxt,
|
||||
_ => continue,
|
||||
};
|
||||
|
||||
let mut def_id_hash = |def_id: DefId| -> u64 {
|
||||
*def_id_hashes.entry(def_id)
|
||||
.or_insert_with(|| {
|
||||
let index = builder.add(def_id);
|
||||
let path = builder.lookup_def_path(index);
|
||||
path.deterministic_hash(tcx)
|
||||
})
|
||||
};
|
||||
|
||||
// To create the hash for each item `X`, we don't hash the raw
|
||||
// bytes of the metadata (though in principle we
|
||||
// could). Instead, we walk the predecessors of `MetaData(X)`
|
||||
@ -295,7 +284,7 @@ pub fn encode_metadata_hashes(tcx: TyCtxt,
|
||||
.map(|index| preds.reduced_graph.node_data(index))
|
||||
.filter(|dep_node| HashContext::is_hashable(dep_node))
|
||||
.map(|dep_node| {
|
||||
let hash_dep_node = dep_node.map_def(|&def_id| Some(def_id_hash(def_id)))
|
||||
let hash_dep_node = dep_node.map_def(|&def_id| Some(tcx.def_path_hash(def_id)))
|
||||
.unwrap();
|
||||
let hash = preds.hashes[dep_node];
|
||||
(hash_dep_node, hash)
|
||||
|
||||
@ -73,7 +73,7 @@ provide! { <'tcx> tcx, def_id, cdata
|
||||
predicates => { cdata.get_predicates(def_id.index, tcx) }
|
||||
super_predicates => { cdata.get_super_predicates(def_id.index, tcx) }
|
||||
trait_def => {
|
||||
tcx.alloc_trait_def(cdata.get_trait_def(def_id.index, tcx))
|
||||
tcx.alloc_trait_def(cdata.get_trait_def(def_id.index))
|
||||
}
|
||||
adt_def => { cdata.get_adt_def(def_id.index, tcx) }
|
||||
adt_destructor => {
|
||||
@ -370,6 +370,10 @@ impl CrateStore for cstore::CStore {
|
||||
self.get_crate_data(def.krate).def_path(def.index)
|
||||
}
|
||||
|
||||
fn def_path_hash(&self, def: DefId) -> u64 {
|
||||
self.get_crate_data(def.krate).def_path_hash(def.index)
|
||||
}
|
||||
|
||||
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
|
||||
{
|
||||
self.dep_graph.read(DepNode::MetaData(def));
|
||||
@ -507,12 +511,19 @@ impl CrateStore for cstore::CStore {
|
||||
/// 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 sufficiently visible parent (considering
|
||||
/// modules that re-export the external item to be parents).
|
||||
fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>> {
|
||||
let mut visible_parent_map = self.visible_parent_map.borrow_mut();
|
||||
if !visible_parent_map.is_empty() { return visible_parent_map; }
|
||||
fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>> {
|
||||
{
|
||||
let visible_parent_map = self.visible_parent_map.borrow();
|
||||
if !visible_parent_map.is_empty() {
|
||||
return visible_parent_map;
|
||||
}
|
||||
}
|
||||
|
||||
use std::collections::vec_deque::VecDeque;
|
||||
use std::collections::hash_map::Entry;
|
||||
|
||||
let mut visible_parent_map = self.visible_parent_map.borrow_mut();
|
||||
|
||||
for cnum in (1 .. self.next_crate_num().as_usize()).map(CrateNum::new) {
|
||||
let cdata = self.get_crate_data(cnum);
|
||||
|
||||
@ -556,6 +567,7 @@ impl CrateStore for cstore::CStore {
|
||||
}
|
||||
}
|
||||
|
||||
visible_parent_map
|
||||
drop(visible_parent_map);
|
||||
self.visible_parent_map.borrow()
|
||||
}
|
||||
}
|
||||
|
||||
@ -492,10 +492,7 @@ impl<'a, 'tcx> CrateMetadata {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_trait_def(&self,
|
||||
item_id: DefIndex,
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>)
|
||||
-> ty::TraitDef {
|
||||
pub fn get_trait_def(&self, item_id: DefIndex) -> ty::TraitDef {
|
||||
let data = match self.entry(item_id).kind {
|
||||
EntryKind::Trait(data) => data.decode(self),
|
||||
_ => bug!(),
|
||||
@ -504,7 +501,7 @@ impl<'a, 'tcx> CrateMetadata {
|
||||
let def = ty::TraitDef::new(self.local_def_id(item_id),
|
||||
data.unsafety,
|
||||
data.paren_sugar,
|
||||
self.def_path(item_id).deterministic_hash(tcx));
|
||||
self.def_path_table.def_path_hash(item_id));
|
||||
|
||||
if data.has_default_impl {
|
||||
def.record_has_default_impl();
|
||||
@ -1053,6 +1050,7 @@ impl<'a, 'tcx> CrateMetadata {
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn def_key(&self, index: DefIndex) -> DefKey {
|
||||
self.def_path_table.def_key(index)
|
||||
}
|
||||
@ -1063,6 +1061,11 @@ impl<'a, 'tcx> CrateMetadata {
|
||||
DefPath::make(self.cnum, id, |parent| self.def_path_table.def_key(parent))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn def_path_hash(&self, index: DefIndex) -> u64 {
|
||||
self.def_path_table.def_path_hash(index)
|
||||
}
|
||||
|
||||
/// Imports the codemap from an external crate into the codemap of the crate
|
||||
/// currently being compiled (the "local crate").
|
||||
///
|
||||
|
||||
@ -1289,6 +1289,7 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> {
|
||||
impl<'a> Resolver<'a> {
|
||||
pub fn new(session: &'a Session,
|
||||
krate: &Crate,
|
||||
crate_name: &str,
|
||||
make_glob_map: MakeGlobMap,
|
||||
crate_loader: &'a mut CrateLoader,
|
||||
arenas: &'a ResolverArenas<'a>)
|
||||
@ -1303,7 +1304,8 @@ impl<'a> Resolver<'a> {
|
||||
module_map.insert(DefId::local(CRATE_DEF_INDEX), graph_root);
|
||||
|
||||
let mut definitions = Definitions::new();
|
||||
DefCollector::new(&mut definitions).collect_root();
|
||||
DefCollector::new(&mut definitions)
|
||||
.collect_root(crate_name, &session.local_crate_disambiguator().as_str());
|
||||
|
||||
let mut invocations = FxHashMap();
|
||||
invocations.insert(Mark::root(),
|
||||
|
||||
@ -101,13 +101,13 @@ use common::SharedCrateContext;
|
||||
use monomorphize::Instance;
|
||||
|
||||
use rustc::middle::weak_lang_items;
|
||||
use rustc::hir::def_id::LOCAL_CRATE;
|
||||
use rustc::hir::def_id::DefId;
|
||||
use rustc::hir::map as hir_map;
|
||||
use rustc::ty::{self, Ty, TypeFoldable};
|
||||
use rustc::ty::fold::TypeVisitor;
|
||||
use rustc::ty::item_path::{self, ItemPathBuffer, RootMode};
|
||||
use rustc::ty::subst::Substs;
|
||||
use rustc::hir::map::definitions::{DefPath, DefPathData};
|
||||
use rustc::hir::map::definitions::DefPathData;
|
||||
use rustc::util::common::record_time;
|
||||
|
||||
use syntax::attr;
|
||||
@ -115,8 +115,8 @@ use syntax::symbol::{Symbol, InternedString};
|
||||
|
||||
fn get_symbol_hash<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
|
||||
|
||||
// path to the item this name is for
|
||||
def_path: &DefPath,
|
||||
// the DefId of the item this name is for
|
||||
def_id: Option<DefId>,
|
||||
|
||||
// type of the item, without any generic
|
||||
// parameters substituted; this is
|
||||
@ -128,8 +128,7 @@ fn get_symbol_hash<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
|
||||
// if any.
|
||||
substs: Option<&'tcx Substs<'tcx>>)
|
||||
-> String {
|
||||
debug!("get_symbol_hash(def_path={:?}, parameters={:?})",
|
||||
def_path, substs);
|
||||
debug!("get_symbol_hash(def_id={:?}, parameters={:?})", def_id, substs);
|
||||
|
||||
let tcx = scx.tcx();
|
||||
|
||||
@ -139,7 +138,7 @@ fn get_symbol_hash<'a, 'tcx>(scx: &SharedCrateContext<'a, 'tcx>,
|
||||
// the main symbol name is not necessarily unique; hash in the
|
||||
// compiler's internal def-path, guaranteeing each symbol has a
|
||||
// truly unique path
|
||||
hasher.def_path(def_path);
|
||||
hasher.hash(def_id.map(|def_id| tcx.def_path_hash(def_id)));
|
||||
|
||||
// Include the main item-type. Note that, in this case, the
|
||||
// assertions about `needs_subst` may not hold, but this item-type
|
||||
@ -224,8 +223,6 @@ pub fn symbol_name<'a, 'tcx>(instance: Instance<'tcx>,
|
||||
return scx.tcx().item_name(def_id).as_str().to_string();
|
||||
}
|
||||
|
||||
let def_path = scx.tcx().def_path(def_id);
|
||||
|
||||
// We want to compute the "type" of this item. Unfortunately, some
|
||||
// kinds of items (e.g., closures) don't have an entry in the
|
||||
// item-type array. So walk back up the find the closest parent
|
||||
@ -256,10 +253,10 @@ pub fn symbol_name<'a, 'tcx>(instance: Instance<'tcx>,
|
||||
// and should not matter anyhow.
|
||||
let instance_ty = scx.tcx().erase_regions(&instance_ty);
|
||||
|
||||
let hash = get_symbol_hash(scx, &def_path, instance_ty, Some(substs));
|
||||
let hash = get_symbol_hash(scx, Some(def_id), instance_ty, Some(substs));
|
||||
|
||||
let mut buffer = SymbolPathBuffer {
|
||||
names: Vec::with_capacity(def_path.data.len())
|
||||
names: Vec::new()
|
||||
};
|
||||
|
||||
item_path::with_forced_absolute_paths(|| {
|
||||
@ -288,11 +285,7 @@ pub fn exported_name_from_type_and_prefix<'a, 'tcx>(scx: &SharedCrateContext<'a,
|
||||
t: Ty<'tcx>,
|
||||
prefix: &str)
|
||||
-> String {
|
||||
let empty_def_path = DefPath {
|
||||
data: vec![],
|
||||
krate: LOCAL_CRATE,
|
||||
};
|
||||
let hash = get_symbol_hash(scx, &empty_def_path, t, None);
|
||||
let hash = get_symbol_hash(scx, None, t, None);
|
||||
let path = [Symbol::intern(prefix).as_str()];
|
||||
mangle(path.iter().cloned(), &hash)
|
||||
}
|
||||
|
||||
@ -806,7 +806,7 @@ fn trait_def<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
err.emit();
|
||||
}
|
||||
|
||||
let def_path_hash = tcx.def_path(def_id).deterministic_hash(tcx);
|
||||
let def_path_hash = tcx.def_path_hash(def_id);
|
||||
let def = ty::TraitDef::new(def_id, unsafety, paren_sugar, def_path_hash);
|
||||
|
||||
if tcx.hir.trait_is_auto(def_id) {
|
||||
|
||||
@ -951,14 +951,21 @@
|
||||
if (relatedDoc.is(".docblock")) {
|
||||
if (relatedDoc.is(":visible")) {
|
||||
if (animate === true) {
|
||||
relatedDoc.slideUp({duration: 'fast', easing: 'linear'});
|
||||
toggle.children(".toggle-label").fadeIn();
|
||||
relatedDoc.slideUp({
|
||||
duration: 'fast',
|
||||
easing: 'linear',
|
||||
complete: function() {
|
||||
toggle.children(".toggle-label").fadeIn();
|
||||
toggle.parent(".toggle-wrapper").addClass("collapsed");
|
||||
toggle.children(".inner").text(labelForToggleButton(true));
|
||||
},
|
||||
});
|
||||
} else {
|
||||
relatedDoc.hide();
|
||||
toggle.children(".toggle-label").show();
|
||||
toggle.parent(".toggle-wrapper").addClass("collapsed");
|
||||
toggle.children(".inner").text(labelForToggleButton(true));
|
||||
}
|
||||
toggle.parent(".toggle-wrapper").addClass("collapsed");
|
||||
toggle.children(".inner").text(labelForToggleButton(true));
|
||||
} else {
|
||||
relatedDoc.slideDown({duration: 'fast', easing: 'linear'});
|
||||
toggle.parent(".toggle-wrapper").removeClass("collapsed");
|
||||
|
||||
@ -356,7 +356,7 @@ impl ops::Deref for CString {
|
||||
type Target = CStr;
|
||||
|
||||
fn deref(&self) -> &CStr {
|
||||
unsafe { mem::transmute(self.as_bytes_with_nul()) }
|
||||
unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) }
|
||||
}
|
||||
}
|
||||
|
||||
@ -583,7 +583,8 @@ impl CStr {
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr {
|
||||
let len = libc::strlen(ptr);
|
||||
mem::transmute(slice::from_raw_parts(ptr, len as usize + 1))
|
||||
let ptr = ptr as *const u8;
|
||||
CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(ptr, len as usize + 1))
|
||||
}
|
||||
|
||||
/// Creates a C string wrapper from a byte slice.
|
||||
|
||||
11
src/test/run-pass/auxiliary/issue_41053.rs
Normal file
11
src/test/run-pass/auxiliary/issue_41053.rs
Normal file
@ -0,0 +1,11 @@
|
||||
// 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.
|
||||
|
||||
pub struct Test;
|
||||
30
src/test/run-pass/issue-41053.rs
Normal file
30
src/test/run-pass/issue-41053.rs
Normal file
@ -0,0 +1,30 @@
|
||||
// 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.
|
||||
|
||||
// aux-build:issue_41053.rs
|
||||
|
||||
pub trait Trait { fn foo(&self) {} }
|
||||
|
||||
pub struct Foo;
|
||||
|
||||
impl Iterator for Foo {
|
||||
type Item = Box<Trait>;
|
||||
fn next(&mut self) -> Option<Box<Trait>> {
|
||||
extern crate issue_41053;
|
||||
impl ::Trait for issue_41053::Test {
|
||||
fn foo(&self) {}
|
||||
}
|
||||
Some(Box::new(issue_41053::Test))
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
Foo.next().unwrap().foo();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user