[submodule "src/compiler-rt"]
path = src/compiler-rt
url = https://github.com/rust-lang/compiler-rt.git
-[submodule "src/rt/hoedown"]
- path = src/rt/hoedown
- url = https://github.com/rust-lang/hoedown.git
- branch = rust-2015-09-21-do-not-delete
[submodule "src/jemalloc"]
path = src/jemalloc
url = https://github.com/rust-lang/jemalloc.git
script:
- >
if [ "$ALLOW_PR" = "" ] && [ "$TRAVIS_BRANCH" != "auto" ]; then
- echo skipping, not a full build;
- elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
- travis_retry stamp sh -c 'git submodule deinit -f . && git submodule update --init' &&
- stamp src/ci/run.sh;
+ echo skipping, not a full build
else
- travis_retry stamp sh -c 'git submodule deinit -f . && git submodule update --init' &&
- stamp src/ci/docker/run.sh $IMAGE;
+ stamp src/ci/init_repo.sh . "$HOME/rustsrc" &&
+ if [ "$TRAVIS_OS_NAME" = "osx" ]; then
+ stamp src/ci/run.sh;
+ else
+ stamp src/ci/docker/run.sh $IMAGE;
+ fi
fi
after_success:
- dmesg | grep -i kill
# Save tagged docker images we created and load them if they're available
+# Travis saves caches whether the build failed or not, nuke rustsrc if
+# the failure was while updating it (as it may be in an bad state)
+# https://github.com/travis-ci/travis-ci/issues/4472
before_cache:
- docker history -q rust-ci |
grep -v missing |
xargs docker save |
gzip > $HOME/docker/rust-ci.tar.gz
+ - if [ ! -f $HOME/rustsrc/cache_valid1 ]; then
+ echo "WARNING rustsrc cache was invalid when saving";
+ rm -rf $HOME/rustsrc && mkdir $HOME/rustsrc;
+ fi
before_install:
- zcat $HOME/docker/rust-ci.tar.gz | docker load || true
+ - mkdir -p $HOME/rustsrc
notifications:
email: false
cache:
directories:
- $HOME/docker
+ - $HOME/rustsrc
before_deploy:
- mkdir -p deploy/$TRAVIS_COMMIT
RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-ninja
SCRIPT: python x.py test
MINGW_URL: https://s3.amazonaws.com/rust-lang-ci/rust-ci-mirror
- MINGW_ARCHIVE: i686-6.3.0-release-win32-dwarf-rt_v5-rev1.7z
+ MINGW_ARCHIVE: i686-6.2.0-release-win32-dwarf-rt_v5-rev1.7z
MINGW_DIR: mingw32
- MSYS_BITS: 64
SCRIPT: python x.py test
RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-gnu --enable-ninja
MINGW_URL: https://s3.amazonaws.com/rust-lang-ci/rust-ci-mirror
- MINGW_ARCHIVE: x86_64-6.3.0-release-win32-seh-rt_v5-rev1.7z
+ MINGW_ARCHIVE: x86_64-6.2.0-release-win32-seh-rt_v5-rev1.7z
MINGW_DIR: mingw64
# 32/64 bit MSVC and GNU deployment
RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-extended --enable-ninja
SCRIPT: python x.py dist
MINGW_URL: https://s3.amazonaws.com/rust-lang-ci/rust-ci-mirror
- MINGW_ARCHIVE: i686-6.3.0-release-win32-dwarf-rt_v5-rev1.7z
+ MINGW_ARCHIVE: i686-6.2.0-release-win32-dwarf-rt_v5-rev1.7z
MINGW_DIR: mingw32
DEPLOY: 1
- MSYS_BITS: 64
SCRIPT: python x.py dist
RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-gnu --enable-extended --enable-ninja
MINGW_URL: https://s3.amazonaws.com/rust-lang-ci/rust-ci-mirror
- MINGW_ARCHIVE: x86_64-6.3.0-release-win32-seh-rt_v5-rev1.7z
+ MINGW_ARCHIVE: x86_64-6.2.0-release-win32-seh-rt_v5-rev1.7z
MINGW_DIR: mingw64
DEPLOY: 1
- set SCCACHE_ERROR_LOG=%CD%/sccache.log
test_script:
- - appveyor-retry sh -c 'git submodule deinit -f . && git submodule update --init'
+ - mkdir C:\cache\rustsrc
+ - sh src/ci/init_repo.sh . /c/cache/rustsrc
- set SRC=.
- set NO_CCACHE=1
- sh src/ci/run.sh
- cat %CD%/sccache.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"
-Subproject commit c995e9eb5acf3976ae8674a0dc6d9e958053d9fd
+Subproject commit 4e95c6b41eca3388f54dd5f7787366ad2df637b5
[[package]]
name = "aho-corasick"
-version = "0.6.2"
+version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
dependencies = [
"build_helper 0.1.0",
"core 0.0.0",
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.0.0",
]
[[package]]
name = "bitflags"
-version = "0.8.0"
+version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
"build_helper 0.1.0",
"cmake 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)",
"filetime 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
"getopts 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.21 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "clap"
-version = "2.21.1"
+version = "2.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"ansi_term 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
"atty 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "bitflags 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bitflags 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
"strsim 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
"term_size 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-segmentation 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
version = "0.1.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
dependencies = [
"build_helper 0.1.0",
"core 0.0.0",
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
version = "0.0.0"
dependencies = [
"build_helper 0.1.0",
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
[[package]]
name = "gcc"
-version = "0.3.44"
+version = "0.3.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
[[package]]
name = "handlebars"
-version = "0.25.1"
+version = "0.25.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "lazy_static 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"pest 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"quick-error 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
[[package]]
name = "lazy_static"
-version = "0.2.4"
+version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
version = "0.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "clap 2.21.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clap 2.22.1 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "handlebars 0.25.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "handlebars 0.25.2 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"open 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"pulldown-cmark 0.0.8 (registry+https://github.com/rust-lang/crates.io-index)",
"getopts 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
]
+[[package]]
+name = "pulldown-cmark"
+version = "0.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
[[package]]
name = "qemu-test-client"
version = "0.1.0"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "aho-corasick 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "aho-corasick 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"regex-syntax 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"thread_local 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
name = "rustbook"
version = "0.1.0"
dependencies = [
- "clap 2.21.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "clap 2.22.1 (registry+https://github.com/rust-lang/crates.io-index)",
"mdbook 0.0.18 (registry+https://github.com/rust-lang/crates.io-index)",
]
version = "0.0.0"
dependencies = [
"build_helper 0.1.0",
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc_bitflags 0.0.0",
]
"arena 0.0.0",
"build_helper 0.1.0",
"env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pulldown-cmark 0.0.14 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc 0.0.0",
"rustc_back 0.0.0",
"rustc_const_eval 0.0.0",
"collections 0.0.0",
"compiler_builtins 0.0.0",
"core 0.0.0",
- "gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.0.0",
"panic_abort 0.0.0",
"panic_unwind 0.0.0",
source = "registry+https://github.com/rust-lang/crates.io-index"
[metadata]
-"checksum aho-corasick 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0638fd549427caa90c499814196d1b9e3725eb4d15d7339d6de073a680ed0ca2"
+"checksum aho-corasick 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "500909c4f87a9e52355b26626d890833e9e1d53ac566db76c36faa984b889699"
"checksum ansi_term 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "23ac7c30002a5accbf7e8987d0632fa6de155b7c3d39d0067317a391e00a2ef6"
"checksum atty 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d912da0db7fa85514874458ca3651fe2cddace8d0b0505571dbdcd41ab490159"
"checksum bitflags 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4f67931368edf3a9a51d29886d245f1c3db2f1ef0dcc9e35ff70341b78c10d23"
-"checksum bitflags 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "826e1ab483fc81a8143faa7203c4a3c02888ebd1a782e37e41fa34753ba9a162"
-"checksum clap 2.21.1 (registry+https://github.com/rust-lang/crates.io-index)" = "74a80f603221c9cd9aa27a28f52af452850051598537bb6b359c38a7d61e5cda"
+"checksum bitflags 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1370e9fc2a6ae53aea8b7a5110edbd08836ed87c88736dfabccade1c2b44bff4"
+"checksum clap 2.22.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e17a4a72ffea176f77d6e2db609c6c919ef221f23862c9915e687fb54d833485"
"checksum cmake 0.1.22 (registry+https://github.com/rust-lang/crates.io-index)" = "d18d68987ed4c516dcc3e7913659bfa4076f5182eea4a7e0038bb060953e76ac"
"checksum dtoa 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "80c8b71fd71146990a9742fc06dcbbde19161a267e0ad4e572c35162f4578c90"
"checksum env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e3856f1697098606fc6cb97a93de88ca3f3bc35bb878c725920e6e82ecf05e83"
"checksum filetime 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "5363ab8e4139b8568a6237db5248646e5a8a2f89bd5ccb02092182b11fd3e922"
-"checksum gcc 0.3.44 (registry+https://github.com/rust-lang/crates.io-index)" = "a32cd40070d7611ab76343dcb3204b2bb28c8a9450989a83a3d590248142f439"
+"checksum gcc 0.3.45 (registry+https://github.com/rust-lang/crates.io-index)" = "40899336fb50db0c78710f53e87afc54d8c7266fb76262fecc78ca1a7f09deae"
"checksum getopts 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9047cfbd08a437050b363d35ef160452c5fe8ea5187ae0a624708c91581d685"
-"checksum handlebars 0.25.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b2249f6f0dc5a3bb2b3b1a8f797dfccbc4b053344d773d654ad565e51427d335"
+"checksum handlebars 0.25.2 (registry+https://github.com/rust-lang/crates.io-index)" = "663e1728d8037fb0d4e13bcd1b1909fb5d913690a9929eb385922df157c2ff8f"
"checksum itoa 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eb2f404fbc66fd9aac13e998248505e7ecb2ad8e44ab6388684c5fb11c6c251c"
"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
-"checksum lazy_static 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "7291b1dd97d331f752620b02dfdbc231df7fc01bf282a00769e1cdb963c460dc"
+"checksum lazy_static 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "4732c563b9a21a406565c4747daa7b46742f082911ae4753f390dc9ec7ee1a97"
"checksum libc 0.2.21 (registry+https://github.com/rust-lang/crates.io-index)" = "88ee81885f9f04bff991e306fea7c1c60a5f0f9e409e99f6b40e3311a3363135"
"checksum log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "5141eca02775a762cc6cd564d8d2c50f67c0ea3a372cbf1c51592b3e029e10ad"
"checksum mdbook 0.0.18 (registry+https://github.com/rust-lang/crates.io-index)" = "06a68e8738e42b38a02755d3ce5fa12d559e17acb238e4326cbc3cc056e65280"
"checksum num_cpus 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)" = "cee7e88156f3f9e19bdd598f8d6c9db7bf4078f99f8381f43a55b09648d1a6e3"
"checksum open 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3478ed1686bd1300c8a981a940abc92b06fac9cbef747f4c668d4e032ff7b842"
"checksum pest 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0a6dda33d67c26f0aac90d324ab2eb7239c819fc7b2552fe9faa4fe88441edc8"
+"checksum pulldown-cmark 0.0.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9ab1e588ef8efd702c7ed9d2bd774db5e6f4d878bb5a1a9f371828fbdff6973"
"checksum pulldown-cmark 0.0.8 (registry+https://github.com/rust-lang/crates.io-index)" = "1058d7bb927ca067656537eec4e02c2b4b70eaaa129664c5b90c111e20326f41"
"checksum quick-error 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0aad603e8d7fb67da22dbdf1f4b826ce8829e406124109e73cf1b2454b93a71c"
"checksum regex 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4278c17d0f6d62dfef0ab00028feb45bd7d2102843f80763474eeb1be8a10c01"
.arg(sysroot)
.env(bootstrap::util::dylib_path_var(),
env::join_paths(&dylib_path).unwrap());
+
+ // Pass the `rustbuild` feature flag to crates which rustbuild is
+ // building. See the comment in bootstrap/lib.rs where this env var is
+ // set for more details.
+ if env::var_os("RUSTBUILD_UNSTABLE").is_some() {
+ cmd.arg("--cfg").arg("rustbuild");
+ }
+
std::process::exit(match cmd.status() {
Ok(s) => s.code().unwrap_or(1),
Err(e) => panic!("\n\nfailed to run {:?}: {}\n\n", cmd, e),
.arg(ADB_TEST_DIR));
let target_dir = format!("{}/{}", ADB_TEST_DIR, target);
- build.run(Command::new("adb").args(&["shell", "mkdir", &target_dir[..]]));
+ build.run(Command::new("adb").args(&["shell", "mkdir", &target_dir]));
for f in t!(build.sysroot_libdir(compiler, target).read_dir()) {
let f = t!(f);
--env DEPLOY_ALT=$DEPLOY_ALT \
--env LOCAL_USER_ID=`id -u` \
--volume "$HOME/.cargo:/cargo" \
+ --volume "$HOME/rustsrc:$HOME/rustsrc" \
--privileged \
--rm \
rust-ci \
--- /dev/null
+#!/bin/bash
+# Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <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.
+
+set -o errexit
+set -o pipefail
+set -o nounset
+
+set -o xtrace
+
+ci_dir=$(cd $(dirname $0) && pwd)
+. "$ci_dir/shared.sh"
+
+REPO_DIR="$1"
+CACHE_DIR="$2"
+
+cache_src_dir="$CACHE_DIR/src"
+# If the layout of the cache directory changes, bump the number here
+# (and anywhere else this file is referenced) so the cache is wiped
+cache_valid_file="$CACHE_DIR/cache_valid1"
+
+if [ ! -d "$REPO_DIR" -o ! -d "$REPO_DIR/.git" ]; then
+ echo "Error: $REPO_DIR does not exist or is not a git repo"
+ exit 1
+fi
+cd $REPO_DIR
+if [ ! -d "$CACHE_DIR" ]; then
+ echo "Error: $CACHE_DIR does not exist or is not an absolute path"
+ exit 1
+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"
+else
+ rm "$cache_valid_file"
+fi
+
+# Update the cache (a pristine copy of the rust source master)
+if [ ! -d "$cache_src_dir/.git" ]; then
+ retry sh -c "rm -rf $cache_src_dir && mkdir -p $cache_src_dir && \
+ git clone https://github.com/rust-lang/rust.git $cache_src_dir"
+fi
+retry sh -c "cd $cache_src_dir && git reset --hard && git pull"
+retry sh -c "cd $cache_src_dir && \
+ git submodule deinit -f . && git submodule sync && git submodule update --init"
+
+# Cache was updated without errors, mark it as valid
+touch "$cache_valid_file"
+
+# Update the submodules of the repo we're in, using the pristine repo as
+# a cache for any object files
+# No, `git submodule foreach` won't work:
+# http://stackoverflow.com/questions/12641469/list-submodules-in-a-git-repository
+modules="$(git config --file .gitmodules --get-regexp '\.path$' | cut -d' ' -f2)"
+for module in $modules; do
+ if [ ! -d "$cache_src_dir/$module" ]; then
+ echo "WARNING: $module not found in pristine repo"
+ retry sh -c "git submodule deinit -f $module && git submodule update --init $module"
+ continue
+ fi
+ retry sh -c "git submodule deinit -f $module && \
+ git submodule update --init --reference $cache_src_dir/$module $module"
+done
-#!/bin/bash
+#!/bin/false
# Copyright 2016 The Rust Project Developers. See the COPYRIGHT
# file at the top-level directory of this distribution and at
# http://rust-lang.org/COPYRIGHT.
# option. This file may not be copied, modified, or distributed
# except according to those terms.
+# This file is intended to be sourced with `. shared.sh` or
+# `source shared.sh`, hence the invalid shebang and not being
+# marked as an executable file in git.
+
# See http://unix.stackexchange.com/questions/82598
function retry {
+ echo "Attempting with retry:" "$@"
local n=1
local max=5
- local delay=15
while true; do
- echo "Attempting:" "$@"
"$@" && break || {
if [[ $n -lt $max ]]; then
((n++))
-Subproject commit 9bd223ca406b1170a24942d6474f9e8a56f4a420
+Subproject commit a2c56870d4dc589237102cc5e0fe7b9ebd0d14a1
-Subproject commit d08fe97d12b41c1ed8cc7701e545864132783941
+Subproject commit 616b98444ff4eb5260deee95ee3e090dfd98b947
-Subproject commit 516549972d61c8946542d1a34afeae97167ff77b
+Subproject commit acedc32cacae80cf2f4925753a4ce7f7ffd7c86a
- [abi_vectorcall](abi-vectorcall.md)
- [abi_x86_interrupt](abi-x86-interrupt.md)
- [advanced_slice_patterns](advanced-slice-patterns.md)
+- [alloc](alloc.md)
- [alloc_jemalloc](alloc-jemalloc.md)
- [alloc_system](alloc-system.md)
- [allocator](allocator.md)
- [allow_internal_unstable](allow-internal-unstable.md)
+- [as_unsafe_cell](as-unsafe-cell.md)
+- [ascii_ctype](ascii-ctype.md)
- [asm](asm.md)
- [associated_consts](associated-consts.md)
- [associated_type_defaults](associated-type-defaults.md)
- [attr_literals](attr-literals.md)
+- [binary_heap_extras](binary-heap-extras.md)
+- [binary_heap_peek_mut_pop](binary-heap-peek-mut-pop.md)
+- [borrow_state](borrow-state.md)
+- [box_heap](box-heap.md)
- [box_patterns](box-patterns.md)
- [box_syntax](box-syntax.md)
+- [c_void_variant](c-void-variant.md)
+- [catch_expr](catch-expr.md)
- [cfg_target_feature](cfg-target-feature.md)
- [cfg_target_has_atomic](cfg-target-has-atomic.md)
- [cfg_target_thread_local](cfg-target-thread-local.md)
- [cfg_target_vendor](cfg-target-vendor.md)
+- [char_escape_debug](char-escape-debug.md)
+- [closure_to_fn_coercion](closure-to-fn-coercion.md)
+- [coerce_unsized](coerce-unsized.md)
+- [collection_placement](collection-placement.md)
+- [collections](collections.md)
+- [collections_range](collections-range.md)
+- [command_envs](command-envs.md)
- [compiler_builtins](compiler-builtins.md)
+- [compiler_builtins_lib](compiler-builtins-lib.md)
- [concat_idents](concat-idents.md)
+- [concat_idents_macro](concat-idents-macro.md)
- [conservative_impl_trait](conservative-impl-trait.md)
- [const_fn](const-fn.md)
- [const_indexing](const-indexing.md)
+- [core_char_ext](core-char-ext.md)
+- [core_float](core-float.md)
+- [core_intrinsics](core-intrinsics.md)
+- [core_panic](core-panic.md)
+- [core_private_bignum](core-private-bignum.md)
+- [core_private_diy_float](core-private-diy-float.md)
+- [core_slice_ext](core-slice-ext.md)
+- [core_str_ext](core-str-ext.md)
- [custom_attribute](custom-attribute.md)
- [custom_derive](custom-derive.md)
+- [dec2flt](dec2flt.md)
+- [decode_utf8](decode-utf8.md)
- [default_type_parameter_fallback](default-type-parameter-fallback.md)
+- [derive_clone_copy](derive-clone-copy.md)
+- [derive_eq](derive-eq.md)
+- [discriminant_value](discriminant-value.md)
- [drop_types_in_const](drop-types-in-const.md)
- [dropck_eyepatch](dropck-eyepatch.md)
- [dropck_parametricity](dropck-parametricity.md)
+- [enumset](enumset.md)
+- [error_type_id](error-type-id.md)
+- [exact_size_is_empty](exact-size-is-empty.md)
- [exclusive_range_pattern](exclusive-range-pattern.md)
-- [field_init_shorthand](field-init-shorthand.md)
+- [fd](fd.md)
+- [fd_read](fd-read.md)
+- [fixed_size_array](fixed-size-array.md)
+- [float_extras](float-extras.md)
+- [flt2dec](flt2dec.md)
+- [fmt_flags_align](fmt-flags-align.md)
+- [fmt_internals](fmt-internals.md)
+- [fn_traits](fn-traits.md)
+- [fnbox](fnbox.md)
- [fundamental](fundamental.md)
+- [fused](fused.md)
+- [future_atomic_orderings](future-atomic-orderings.md)
- [generic_param_attrs](generic-param-attrs.md)
+- [get_type_id](get-type-id.md)
+- [heap_api](heap-api.md)
+- [i128](i128.md)
- [i128_type](i128-type.md)
+- [inclusive_range](inclusive-range.md)
- [inclusive_range_syntax](inclusive-range-syntax.md)
+- [int_error_internals](int-error-internals.md)
+- [integer_atomics](integer-atomics.md)
+- [into_boxed_c_str](into-boxed-c-str.md)
+- [into_boxed_os_str](into-boxed-os-str.md)
+- [into_boxed_path](into-boxed-path.md)
- [intrinsics](intrinsics.md)
+- [io](io.md)
+- [io_error_internals](io-error-internals.md)
+- [ip](ip.md)
+- [is_unique](is-unique.md)
+- [iter_rfind](iter-rfind.md)
- [lang_items](lang-items.md)
+- [libstd_io_internals](libstd-io-internals.md)
+- [libstd_sys_internals](libstd-sys-internals.md)
+- [libstd_thread_internals](libstd-thread-internals.md)
- [link_args](link-args.md)
- [link_cfg](link-cfg.md)
- [link_llvm_intrinsics](link-llvm-intrinsics.md)
- [linkage](linkage.md)
+- [linked_list_extras](linked-list-extras.md)
- [log_syntax](log-syntax.md)
+- [lookup_host](lookup-host.md)
- [loop_break_value](loop-break-value.md)
- [macro_reexport](macro-reexport.md)
- [main](main.md)
+- [map_entry_recover_keys](map-entry-recover-keys.md)
+- [mpsc_select](mpsc-select.md)
+- [n16](n16.md)
- [naked_functions](naked-functions.md)
- [needs_allocator](needs-allocator.md)
- [needs_panic_runtime](needs-panic-runtime.md)
- [never_type](never-type.md)
+- [never_type_impls](never-type-impls.md)
- [no_core](no-core.md)
- [no_debug](no-debug.md)
- [non_ascii_idents](non-ascii-idents.md)
+- [nonzero](nonzero.md)
- [omit_gdb_pretty_printer_section](omit-gdb-pretty-printer-section.md)
- [on_unimplemented](on-unimplemented.md)
+- [once_poison](once-poison.md)
+- [oom](oom.md)
- [optin_builtin_traits](optin-builtin-traits.md)
+- [option_entry](option-entry.md)
+- [osstring_shrink_to_fit](osstring-shrink-to-fit.md)
+- [panic_abort](panic-abort.md)
- [panic_runtime](panic-runtime.md)
+- [panic_unwind](panic-unwind.md)
+- [pattern](pattern.md)
+- [peek](peek.md)
+- [placement_in](placement-in.md)
- [placement_in_syntax](placement-in-syntax.md)
+- [placement_new_protocol](placement-new-protocol.md)
- [platform_intrinsics](platform-intrinsics.md)
- [plugin](plugin.md)
- [plugin_registrar](plugin-registrar.md)
- [prelude_import](prelude-import.md)
+- [print](print.md)
- [proc_macro](proc-macro.md)
+- [proc_macro_internals](proc-macro-internals.md)
+- [process_try_wait](process-try-wait.md)
+- [pub_restricted](pub-restricted.md)
+- [question_mark_carrier](question-mark-carrier.md)
- [quote](quote.md)
+- [rand](rand.md)
+- [range_contains](range-contains.md)
+- [raw](raw.md)
+- [rc_would_unwrap](rc-would-unwrap.md)
- [relaxed_adts](relaxed-adts.md)
- [repr_simd](repr-simd.md)
+- [retain_hash_collection](retain-hash-collection.md)
+- [rt](rt.md)
- [rustc_attrs](rustc-attrs.md)
- [rustc_diagnostic_macros](rustc-diagnostic-macros.md)
+- [rustc_private](rustc-private.md)
+- [rustdoc](rustdoc.md)
- [rvalue_static_promotion](rvalue-static-promotion.md)
- [sanitizer_runtime](sanitizer-runtime.md)
+- [sanitizer_runtime_lib](sanitizer-runtime-lib.md)
+- [set_stdio](set-stdio.md)
+- [shared](shared.md)
- [simd](simd.md)
- [simd_ffi](simd-ffi.md)
+- [sip_hash_13](sip-hash-13.md)
+- [slice_concat_ext](slice-concat-ext.md)
+- [slice_get_slice](slice-get-slice.md)
- [slice_patterns](slice-patterns.md)
+- [sort_internals](sort-internals.md)
- [sort_unstable](sort-unstable.md)
- [specialization](specialization.md)
- [staged_api](staged-api.md)
- [start](start.md)
- [static_nobundle](static-nobundle.md)
-- [static_recursion](static-recursion.md)
+- [step_by](step-by.md)
+- [step_trait](step-trait.md)
- [stmt_expr_attributes](stmt-expr-attributes.md)
+- [str_escape](str-escape.md)
+- [str_internals](str-internals.md)
- [struct_field_attributes](struct-field-attributes.md)
- [structural_match](structural-match.md)
- [target_feature](target-feature.md)
- [test](test.md)
+- [thread_id](thread-id.md)
- [thread_local](thread-local.md)
+- [thread_local_internals](thread-local-internals.md)
+- [thread_local_state](thread-local-state.md)
- [trace_macros](trace-macros.md)
+- [trusted_len](trusted-len.md)
+- [try_from](try-from.md)
- [type_ascription](type-ascription.md)
- [unboxed_closures](unboxed-closures.md)
+- [unicode](unicode.md)
+- [unique](unique.md)
+- [unsize](unsize.md)
- [untagged_unions](untagged-unions.md)
- [unwind_attributes](unwind-attributes.md)
+- [update_panic_count](update-panic-count.md)
- [use_extern_macros](use-extern-macros.md)
+- [utf8_error_error_len](utf8-error-error-len.md)
+- [vec_remove_item](vec-remove-item.md)
+- [windows_c](windows-c.md)
+- [windows_handle](windows-handle.md)
+- [windows_net](windows-net.md)
+- [windows_stdio](windows-stdio.md)
- [windows_subsystem](windows-subsystem.md)
+- [zero_one](zero-one.md)
--- /dev/null
+# `alloc`
+
+The tracking issue for this feature is: [#27783]
+
+[#27783]: https://github.com/rust-lang/rust/issues/27783
+
+------------------------
--- /dev/null
+# `as_unsafe_cell`
+
+The tracking issue for this feature is: [#27708]
+
+[#27708]: https://github.com/rust-lang/rust/issues/27708
+
+------------------------
--- /dev/null
+# `ascii_ctype`
+
+The tracking issue for this feature is: [#39658]
+
+[#39658]: https://github.com/rust-lang/rust/issues/39658
--- /dev/null
+# `binary_heap_extras`
+
+The tracking issue for this feature is: [#28147]
+
+[#28147]: https://github.com/rust-lang/rust/issues/28147
+
+------------------------
--- /dev/null
+# `binary_heap_peek_mut_pop`
+
+The tracking issue for this feature is: [#38863]
+
+[#38863]: https://github.com/rust-lang/rust/issues/38863
+
+------------------------
--- /dev/null
+# `borrow_state`
+
+The tracking issue for this feature is: [#27733]
+
+[#27733]: https://github.com/rust-lang/rust/issues/27733
+
+------------------------
--- /dev/null
+# `box_heap`
+
+The tracking issue for this feature is: [#27779]
+
+[#27779]: https://github.com/rust-lang/rust/issues/27779
+
+------------------------
--- /dev/null
+# `c_void_variant`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `catch_expr`
+
+The tracking issue for this feature is: [#31436]
+
+[#31436]: https://github.com/rust-lang/rust/issues/31436
+
+------------------------
--- /dev/null
+# `char_escape_debug`
+
+The tracking issue for this feature is: [#35068]
+
+[#35068]: https://github.com/rust-lang/rust/issues/35068
+
+------------------------
--- /dev/null
+# `closure_to_fn_coercion`
+
+The tracking issue for this feature is: [#39817]
+
+[#39817]: https://github.com/rust-lang/rust/issues/39817
+
+------------------------
--- /dev/null
+# `coerce_unsized`
+
+The tracking issue for this feature is: [#27732]
+
+[#27732]: https://github.com/rust-lang/rust/issues/27732
+
+------------------------
--- /dev/null
+# `collection_placement`
+
+The tracking issue for this feature is: [#30172]
+
+[#30172]: https://github.com/rust-lang/rust/issues/30172
+
+------------------------
--- /dev/null
+# `collections_range`
+
+The tracking issue for this feature is: [#30877]
+
+[#30877]: https://github.com/rust-lang/rust/issues/30877
+
+------------------------
--- /dev/null
+# `collections`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `command_envs`
+
+The tracking issue for this feature is: [#38526]
+
+[#38526]: https://github.com/rust-lang/rust/issues/38526
+
+------------------------
--- /dev/null
+# `compiler_builtins_lib`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `concat_idents_macro`
+
+The tracking issue for this feature is: [#29599]
+
+[#29599]: https://github.com/rust-lang/rust/issues/29599
+
+------------------------
--- /dev/null
+# `core_char_ext`
+
+The tracking issue for this feature is: [#32110]
+
+[#32110]: https://github.com/rust-lang/rust/issues/32110
+
+------------------------
--- /dev/null
+# `core_float`
+
+The tracking issue for this feature is: [#32110]
+
+[#32110]: https://github.com/rust-lang/rust/issues/32110
+
+------------------------
--- /dev/null
+# `core_intrinsics`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `core_panic`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `core_private_bignum`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `core_private_diy_float`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `core_slice_ext`
+
+The tracking issue for this feature is: [#32110]
+
+[#32110]: https://github.com/rust-lang/rust/issues/32110
+
+------------------------
--- /dev/null
+# `core_str_ext`
+
+The tracking issue for this feature is: [#32110]
+
+[#32110]: https://github.com/rust-lang/rust/issues/32110
+
+------------------------
--- /dev/null
+# `dec2flt`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `decode_utf8`
+
+The tracking issue for this feature is: [#27783]
+
+[#27783]: https://github.com/rust-lang/rust/issues/27783
+
+------------------------
--- /dev/null
+# `derive_clone_copy`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `derive_eq`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `discriminant_value`
+
+The tracking issue for this feature is: [#24263]
+
+[#24263]: https://github.com/rust-lang/rust/issues/24263
+
+------------------------
--- /dev/null
+# `enumset`
+
+The tracking issue for this feature is: [#37966]
+
+[#37966]: https://github.com/rust-lang/rust/issues/37966
+
+------------------------
--- /dev/null
+# `error_type_id`
+
+The tracking issue for this feature is: [#27745]
+
+[#27745]: https://github.com/rust-lang/rust/issues/27745
+
+------------------------
--- /dev/null
+# `exact_size_is_empty`
+
+The tracking issue for this feature is: [#35428]
+
+[#35428]: https://github.com/rust-lang/rust/issues/35428
+
+------------------------
--- /dev/null
+# `fd_read`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `fd`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
+++ /dev/null
-# `field_init_shorthand`
-
-The tracking issue for this feature is: [#37340]
-
-[#37340]: https://github.com/rust-lang/rust/issues/37340
-
-------------------------
-
-
-
--- /dev/null
+# `fixed_size_array`
+
+The tracking issue for this feature is: [#27778]
+
+[#27778]: https://github.com/rust-lang/rust/issues/27778
+
+------------------------
--- /dev/null
+# `float_extras`
+
+The tracking issue for this feature is: [#27752]
+
+[#27752]: https://github.com/rust-lang/rust/issues/27752
+
+------------------------
--- /dev/null
+# `flt2dec`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `fmt_flags_align`
+
+The tracking issue for this feature is: [#27726]
+
+[#27726]: https://github.com/rust-lang/rust/issues/27726
+
+------------------------
--- /dev/null
+# `fmt_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `fn_traits`
+
+The tracking issue for this feature is: [#29625]
+
+[#29625]: https://github.com/rust-lang/rust/issues/29625
+
+------------------------
--- /dev/null
+# `fnbox`
+
+The tracking issue for this feature is: [#28796]
+
+[#28796]: https://github.com/rust-lang/rust/issues/28796
+
+------------------------
--- /dev/null
+# `fused`
+
+The tracking issue for this feature is: [#35602]
+
+[#35602]: https://github.com/rust-lang/rust/issues/35602
+
+------------------------
--- /dev/null
+# `future_atomic_orderings`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `get_type_id`
+
+The tracking issue for this feature is: [#27745]
+
+[#27745]: https://github.com/rust-lang/rust/issues/27745
+
+------------------------
--- /dev/null
+# `heap_api`
+
+The tracking issue for this feature is: [#27700]
+
+[#27700]: https://github.com/rust-lang/rust/issues/27700
+
+------------------------
--- /dev/null
+# `i128`
+
+The tracking issue for this feature is: [#35118]
+
+[#35118]: https://github.com/rust-lang/rust/issues/35118
+
+------------------------
--- /dev/null
+# `inclusive_range`
+
+The tracking issue for this feature is: [#28237]
+
+[#28237]: https://github.com/rust-lang/rust/issues/28237
+
+------------------------
--- /dev/null
+# `int_error_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `integer_atomics`
+
+The tracking issue for this feature is: [#32976]
+
+[#32976]: https://github.com/rust-lang/rust/issues/32976
+
+------------------------
--- /dev/null
+# `into_boxed_c_str`
+
+The tracking issue for this feature is: [#40380]
+
+[#40380]: https://github.com/rust-lang/rust/issues/40380
+
+------------------------
--- /dev/null
+# `into_boxed_os_str`
+
+The tracking issue for this feature is: [#into_boxed_os_str]
+
+[#into_boxed_os_str]: https://github.com/rust-lang/rust/issues/40380
+
+------------------------
--- /dev/null
+# `into_boxed_path`
+
+The tracking issue for this feature is: [#40380]
+
+[#40380]: https://github.com/rust-lang/rust/issues/40380
+
+------------------------
--- /dev/null
+# `io_error_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `io`
+
+The tracking issue for this feature is: [#27802]
+
+[#27802]: https://github.com/rust-lang/rust/issues/27802
+
+------------------------
--- /dev/null
+# `ip`
+
+The tracking issue for this feature is: [#27709]
+
+[#27709]: https://github.com/rust-lang/rust/issues/27709
+
+------------------------
--- /dev/null
+# `is_unique`
+
+The tracking issue for this feature is: [#28356]
+
+[#28356]: https://github.com/rust-lang/rust/issues/28356
+
+------------------------
--- /dev/null
+# `iter_rfind`
+
+The tracking issue for this feature is: [#39480]
+
+[#39480]: https://github.com/rust-lang/rust/issues/39480
+
+------------------------
--- /dev/null
+# `libstd_io_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `libstd_sys_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `libstd_thread_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `linked_list_extras`
+
+The tracking issue for this feature is: [#27794]
+
+[#27794]: https://github.com/rust-lang/rust/issues/27794
+
+------------------------
--- /dev/null
+# `lookup_host`
+
+The tracking issue for this feature is: [#27705]
+
+[#27705]: https://github.com/rust-lang/rust/issues/27705
+
+------------------------
--- /dev/null
+# `map_entry_recover_keys`
+
+The tracking issue for this feature is: [#34285]
+
+[#34285]: https://github.com/rust-lang/rust/issues/34285
--- /dev/null
+# `mpsc_select`
+
+The tracking issue for this feature is: [#27800]
+
+[#27800]: https://github.com/rust-lang/rust/issues/27800
--- /dev/null
+# `n16`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `never_type_impls`
+
+The tracking issue for this feature is: [#35121]
+
+[#35121]: https://github.com/rust-lang/rust/issues/35121
+
+------------------------
--- /dev/null
+# `nonzero`
+
+The tracking issue for this feature is: [#27730]
+
+[#27730]: https://github.com/rust-lang/rust/issues/27730
+
+------------------------
--- /dev/null
+# `once_poison`
+
+The tracking issue for this feature is: [#33577]
+
+[#33577]: https://github.com/rust-lang/rust/issues/33577
+
+------------------------
--- /dev/null
+# `oom`
+
+The tracking issue for this feature is: [#27700]
+
+[#27700]: https://github.com/rust-lang/rust/issues/27700
+
+------------------------
--- /dev/null
+# `option_entry`
+
+The tracking issue for this feature is: [#39288]
+
+[#39288]: https://github.com/rust-lang/rust/issues/39288
+
+------------------------
--- /dev/null
+# `osstring_shrink_to_fit`
+
+The tracking issue for this feature is: [#40421]
+
+[#40421]: https://github.com/rust-lang/rust/issues/40421
+
+------------------------
--- /dev/null
+# `panic_abort`
+
+The tracking issue for this feature is: [#32837]
+
+[#32837]: https://github.com/rust-lang/rust/issues/32837
+
+------------------------
--- /dev/null
+# `panic_unwind`
+
+The tracking issue for this feature is: [#32837]
+
+[#32837]: https://github.com/rust-lang/rust/issues/32837
+
+------------------------
--- /dev/null
+# `pattern`
+
+The tracking issue for this feature is: [#27721]
+
+[#27721]: https://github.com/rust-lang/rust/issues/27721
+
+------------------------
--- /dev/null
+# `peek`
+
+The tracking issue for this feature is: [#38980]
+
+[#38980]: https://github.com/rust-lang/rust/issues/38980
+
+------------------------
--- /dev/null
+# `placement_in`
+
+The tracking issue for this feature is: [#27779]
+
+[#27779]: https://github.com/rust-lang/rust/issues/27779
+
+------------------------
--- /dev/null
+# `placement_new_protocol`
+
+The tracking issue for this feature is: [#27779]
+
+[#27779]: https://github.com/rust-lang/rust/issues/27779
+
+------------------------
--- /dev/null
+# `print`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `proc_macro_internals`
+
+The tracking issue for this feature is: [#27812]
+
+[#27812]: https://github.com/rust-lang/rust/issues/27812
+
+------------------------
--- /dev/null
+# `process_try_wait`
+
+The tracking issue for this feature is: [#38903]
+
+[#38903]: https://github.com/rust-lang/rust/issues/38903
+
+------------------------
--- /dev/null
+# `pub_restricted`
+
+The tracking issue for this feature is: [#32409]
+
+[#38356]: https://github.com/rust-lang/rust/issues/32409
+
+------------------------
--- /dev/null
+# `question_mark_carrier`
+
+The tracking issue for this feature is: [#31436]
+
+[#31436]: https://github.com/rust-lang/rust/issues/31436
+
+------------------------
--- /dev/null
+# `rand`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `range_contains`
+
+The tracking issue for this feature is: [#32311]
+
+[#32311]: https://github.com/rust-lang/rust/issues/32311
+
+------------------------
--- /dev/null
+# `raw`
+
+The tracking issue for this feature is: [#27751]
+
+[#27751]: https://github.com/rust-lang/rust/issues/27751
+
+------------------------
--- /dev/null
+# `rc_would_unwrap`
+
+The tracking issue for this feature is: [#28356]
+
+[#28356]: https://github.com/rust-lang/rust/issues/28356
--- /dev/null
+# `retain_hash_collection`
+
+The tracking issue for this feature is: [#36648]
+
+[#36648]: https://github.com/rust-lang/rust/issues/36648
+
+------------------------
--- /dev/null
+# `rt`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `rustc_private`
+
+The tracking issue for this feature is: [#27812]
+
+[#27812]: https://github.com/rust-lang/rust/issues/27812
+
+------------------------
--- /dev/null
+# `rustdoc`
+
+The tracking issue for this feature is: [#27812]
+
+[#27812]: https://github.com/rust-lang/rust/issues/27812
+
+------------------------
--- /dev/null
+# `sanitizer_runtime_lib`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `set_stdio`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `shared`
+
+The tracking issue for this feature is: [#27730]
+
+[#27730]: https://github.com/rust-lang/rust/issues/27730
+
+------------------------
--- /dev/null
+# `sip_hash_13`
+
+The tracking issue for this feature is: [#34767]
+
+[#34767]: https://github.com/rust-lang/rust/issues/34767
+
+------------------------
--- /dev/null
+# `slice_concat_ext`
+
+The tracking issue for this feature is: [#27747]
+
+[#27747]: https://github.com/rust-lang/rust/issues/27747
+
+------------------------
--- /dev/null
+# `slice_get_slice`
+
+The tracking issue for this feature is: [#35729]
+
+[#35729]: https://github.com/rust-lang/rust/issues/35729
+
+------------------------
--- /dev/null
+# `sort_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
+++ /dev/null
-# `static_recursion`
-
-The tracking issue for this feature is: [#29719]
-
-[#29719]: https://github.com/rust-lang/rust/issues/29719
-
-------------------------
-
-
-
--- /dev/null
+# `step_by`
+
+The tracking issue for this feature is: [#27741]
+
+[#27741]: https://github.com/rust-lang/rust/issues/27741
+
+------------------------
--- /dev/null
+# `step_trait`
+
+The tracking issue for this feature is: [#27741]
+
+[#27741]: https://github.com/rust-lang/rust/issues/27741
+
+------------------------
--- /dev/null
+# `str_escape`
+
+The tracking issue for this feature is: [#27791]
+
+[#27791]: https://github.com/rust-lang/rust/issues/27791
+
+------------------------
--- /dev/null
+# `str_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `thread_id`
+
+The tracking issue for this feature is: [#21507]
+
+[#21507]: https://github.com/rust-lang/rust/issues/21507
+
+------------------------
--- /dev/null
+# `thread_local_internals`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `thread_local_state`
+
+The tracking issue for this feature is: [#27716]
+
+[#27716]: https://github.com/rust-lang/rust/issues/27716
+
+------------------------
--- /dev/null
+# `trusted_len`
+
+The tracking issue for this feature is: [#37572]
+
+[#37572]: https://github.com/rust-lang/rust/issues/37572
+
+------------------------
--- /dev/null
+# `try_from`
+
+The tracking issue for this feature is: [#33417]
+
+[#33417]: https://github.com/rust-lang/rust/issues/33417
+
+------------------------
--- /dev/null
+# `unicode`
+
+The tracking issue for this feature is: [#27783]
+
+[#27783]: https://github.com/rust-lang/rust/issues/27783
+
+------------------------
--- /dev/null
+# `unique`
+
+The tracking issue for this feature is: [#27730]
+
+[#27730]: https://github.com/rust-lang/rust/issues/27730
+
+------------------------
--- /dev/null
+# `unsize`
+
+The tracking issue for this feature is: [#27732]
+
+[#27732]: https://github.com/rust-lang/rust/issues/27732
+
+------------------------
--- /dev/null
+# `update_panic_count`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `utf8_error_error_len`
+
+The tracking issue for this feature is: [#40494]
+
+[#40494]: https://github.com/rust-lang/rust/issues/40494
+
+------------------------
--- /dev/null
+# `vec_remove_item`
+
+The tracking issue for this feature is: [#40062]
+
+[#40062]: https://github.com/rust-lang/rust/issues/40062
+
+------------------------
--- /dev/null
+# `windows_c`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `windows_handle`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `windows_net`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `windows_stdio`
+
+This feature is internal to the Rust compiler and is not intended for general use.
+
+------------------------
--- /dev/null
+# `zero_one`
+
+The tracking issue for this feature is: [#27739]
+
+[#27739]: https://github.com/rust-lang/rust/issues/27739
+
+------------------------
let toknum = &s[content_end + 3 .. toknum_end];
let not_found = format!("didn't find token {:?} in the map", toknum);
- let proto_tok = tokens.get(toknum).expect(¬_found[..]);
+ let proto_tok = tokens.get(toknum).expect(¬_found);
let nm = Symbol::intern(content);
let mut token_file = File::open(&Path::new(&args.next().unwrap())).unwrap();
let mut token_list = String::new();
token_file.read_to_string(&mut token_list).unwrap();
- let token_map = parse_token_list(&token_list[..]);
+ let token_map = parse_token_list(&token_list);
let stdin = std::io::stdin();
let lock = stdin.lock();
let lines = lock.lines();
let antlr_tokens = lines.map(|l| parse_antlr_token(l.unwrap().trim(),
&token_map,
- &surrogate_pairs_pos[..],
+ &surrogate_pairs_pos,
has_bom));
for antlr_tok in antlr_tokens {
thread::spawn(move || {
check_links(&n);
let a: &[_] = &[&1, &2, &3];
- assert_eq!(a, &n.iter().collect::<Vec<_>>()[..]);
+ assert_eq!(a, &*n.iter().collect::<Vec<_>>());
})
.join()
.ok()
//! Unicode string slices.
//!
+//! The `&str` type is one of the two main string types, the other being `String`.
+//! Unlike its `String` counterpart, its contents are borrowed.
+//!
+//! # Basic Usage
+//!
+//! A basic string declaration of `&str` type:
+//!
+//! ```
+//! let hello_world = "Hello, World!";
+//! ```
+//!
+//! Here we have declared a string literal, also known as a string slice.
+//! String literals have a static lifetime, which means the string `hello_world`
+//! is guaranteed to be valid for the duration of the entire program.
+//! We can explicitly specify `hello_world`'s lifetime as well:
+//!
+//! ```
+//! let hello_world: &'static str = "Hello, world!";
+//! ```
+//!
//! *[See also the `str` primitive type](../../std/primitive.str.html).*
-
#![stable(feature = "rust1", since = "1.0.0")]
// Many of the usings in this module are only used in the test configuration.
impl<T> FromIterator<T> for Vec<T> {
#[inline]
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
- <Self as SpecExtend<_, _>>::from_iter(iter.into_iter())
+ <Self as SpecExtend<T, I::IntoIter>>::from_iter(iter.into_iter())
}
}
impl<T> Extend<T> for Vec<T> {
#[inline]
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
- self.spec_extend(iter.into_iter())
+ <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter())
}
}
vector
}
};
- vector.spec_extend(iterator);
+ <Vec<T> as SpecExtend<T, I>>::spec_extend(&mut vector, iterator);
vector
}
impl<T, I> SpecExtend<T, I> for Vec<T>
where I: TrustedLen<Item=T>,
{
- fn from_iter(iterator: I) -> Self {
+ default fn from_iter(iterator: I) -> Self {
let mut vector = Vec::new();
vector.spec_extend(iterator);
vector
}
}
+impl<T> SpecExtend<T, IntoIter<T>> for Vec<T> {
+ fn from_iter(iterator: IntoIter<T>) -> Self {
+ // A common case is passing a vector into a function which immediately
+ // re-collects into a vector. We can short circuit this if the IntoIter
+ // has not been advanced at all.
+ if *iterator.buf == iterator.ptr as *mut T {
+ unsafe {
+ let vec = Vec::from_raw_parts(*iterator.buf as *mut T,
+ iterator.len(),
+ iterator.cap);
+ mem::forget(iterator);
+ vec
+ }
+ } else {
+ let mut vector = Vec::new();
+ vector.spec_extend(iterator);
+ vector
+ }
+ }
+}
+
impl<'a, T: 'a, I> SpecExtend<&'a T, I> for Vec<T>
where I: Iterator<Item=&'a T>,
T: Clone,
let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { vec.place_back() <- mkpanic(); }));
assert_eq!(vec.len(), 3);
}
+
+#[test]
+fn from_into_inner() {
+ let vec = vec![1, 2, 3];
+ let ptr = vec.as_ptr();
+ let vec = vec.into_iter().collect::<Vec<_>>();
+ assert_eq!(vec, [1, 2, 3]);
+ assert_eq!(vec.as_ptr(), ptr);
+
+ let ptr = &vec[1] as *const _;
+ let mut it = vec.into_iter();
+ it.next().unwrap();
+ let vec = it.collect::<Vec<_>>();
+ assert_eq!(vec, [2, 3]);
+ assert!(ptr != vec.as_ptr());
+}
/// with the character encoding that IANA calls ISO-8859-1.
/// This encoding is compatible with ASCII.
///
-/// Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hypen),
+/// Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hyphen),
/// which leaves some "blanks", byte values that are not assigned to any character.
/// ISO-8859-1 (the IANA one) assigns them to the C0 and C1 control codes.
///
}
}
+/// A helper struct for reverse ordering.
+///
+/// This struct is a helper to be used with functions like `Vec::sort_by_key` and
+/// can be used to reverse order a part of a key.
+///
+/// Example usage:
+///
+/// ```
+/// #![feature(reverse_cmp_key)]
+/// use std::cmp::Reverse;
+///
+/// let mut v = vec![1, 2, 3, 4, 5, 6];
+/// v.sort_by_key(|&num| (num > 3, Reverse(num)));
+/// assert_eq!(v, vec![3, 2, 1, 6, 5, 4]);
+/// ```
+#[derive(PartialEq, Eq, Debug)]
+#[unstable(feature = "reverse_cmp_key", issue = "40893")]
+pub struct Reverse<T>(pub T);
+
+#[unstable(feature = "reverse_cmp_key", issue = "40893")]
+impl<T: PartialOrd> PartialOrd for Reverse<T> {
+ #[inline]
+ fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering> {
+ other.0.partial_cmp(&self.0)
+ }
+}
+
+#[unstable(feature = "reverse_cmp_key", issue = "40893")]
+impl<T: Ord> Ord for Reverse<T> {
+ #[inline]
+ fn cmp(&self, other: &Reverse<T>) -> Ordering {
+ other.0.cmp(&self.0)
+ }
+}
+
/// Trait for types that form a [total order](https://en.wikipedia.org/wiki/Total_order).
///
/// An order is a total order if it is (for all `a`, `b` and `c`):
fn drop(&mut self);
}
-/// The `Add` trait is used to specify the functionality of `+`.
+/// The addition operator `+`.
///
/// # Examples
///
add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `Sub` trait is used to specify the functionality of `-`.
+/// The subtraction operator `-`.
///
/// # Examples
///
sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `Mul` trait is used to specify the functionality of `*`.
+/// The multiplication operator `*`.
///
/// # Examples
///
mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `Div` trait is used to specify the functionality of `/`.
+/// The division operator `/`.
///
/// # Examples
///
div_impl_float! { f32 f64 }
-/// The `Rem` trait is used to specify the functionality of `%`.
+/// The remainder operator `%`.
///
/// # Examples
///
rem_impl_float! { f32 f64 }
-/// The `Neg` trait is used to specify the functionality of unary `-`.
+/// The unary negation operator `-`.
///
/// # Examples
///
// neg_impl_unsigned! { usize u8 u16 u32 u64 }
neg_impl_numeric! { isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `Not` trait is used to specify the functionality of unary `!`.
+/// The unary logical negation operator `!`.
///
/// # Examples
///
not_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
-/// The `BitAnd` trait is used to specify the functionality of `&`.
+/// The bitwise AND operator `&`.
///
/// # Examples
///
bitand_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
-/// The `BitOr` trait is used to specify the functionality of `|`.
+/// The bitwise OR operator `|`.
///
/// # Examples
///
bitor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
-/// The `BitXor` trait is used to specify the functionality of `^`.
+/// The bitwise XOR operator `^`.
///
/// # Examples
///
bitxor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
-/// The `Shl` trait is used to specify the functionality of `<<`.
+/// The left shift operator `<<`.
///
/// # Examples
///
shl_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 isize i128 }
-/// The `Shr` trait is used to specify the functionality of `>>`.
+/// The right shift operator `>>`.
///
/// # Examples
///
shr_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }
-/// The `AddAssign` trait is used to specify the functionality of `+=`.
+/// The addition assignment operator `+=`.
///
/// # Examples
///
add_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `SubAssign` trait is used to specify the functionality of `-=`.
+/// The subtraction assignment operator `-=`.
///
/// # Examples
///
sub_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `MulAssign` trait is used to specify the functionality of `*=`.
+/// The multiplication assignment operator `*=`.
///
/// # Examples
///
mul_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `DivAssign` trait is used to specify the functionality of `/=`.
+/// The division assignment operator `/=`.
///
/// # Examples
///
div_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `RemAssign` trait is used to specify the functionality of `%=`.
+/// The remainder assignment operator `%=`.
///
/// # Examples
///
rem_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
-/// The `BitAndAssign` trait is used to specify the functionality of `&=`.
+/// The bitwise AND assignment operator `&=`.
///
/// # Examples
///
bitand_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
-/// The `BitOrAssign` trait is used to specify the functionality of `|=`.
+/// The bitwise OR assignment operator `|=`.
///
/// # Examples
///
bitor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
-/// The `BitXorAssign` trait is used to specify the functionality of `^=`.
+/// The bitwise XOR assignment operator `^=`.
///
/// # Examples
///
bitxor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
-/// The `ShlAssign` trait is used to specify the functionality of `<<=`.
+/// The left shift assignment operator `<<=`.
///
/// # Examples
///
shl_assign_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }
-/// The `ShrAssign` trait is used to specify the functionality of `>>=`.
+/// The right shift assignment operator `>>=`.
///
/// # Examples
///
///
/// assert_eq!(1909, good_year);
/// assert_eq!(0, bad_year);
+ /// ```
///
/// [`parse`]: ../../std/primitive.str.html#method.parse
/// [`FromStr`]: ../../std/str/trait.FromStr.html
- /// ```
#[inline]
#[stable(feature = "result_unwrap_or_default", since = "1.16.0")]
pub fn unwrap_or_default(self) -> T {
#[cold]
fn break_patterns<T>(v: &mut [T]) {
let len = v.len();
-
if len >= 8 {
- // A random number will be taken modulo this one. The modulus is a power of two so that we
- // can simply take bitwise "and", thus avoiding costly CPU operations.
- let modulus = (len / 4).next_power_of_two();
- debug_assert!(modulus >= 1 && modulus <= len / 2);
-
- // Pseudorandom number generation from the "Xorshift RNGs" paper by George Marsaglia.
- let mut random = len;
- random ^= random << 13;
- random ^= random >> 17;
- random ^= random << 5;
- random &= modulus - 1;
- debug_assert!(random < len / 2);
-
- // The first index.
- let a = len / 4 * 2;
- debug_assert!(a >= 1 && a < len - 2);
-
- // The second index.
- let b = len / 4 + random;
- debug_assert!(b >= 1 && b < len - 2);
-
- // Swap neighbourhoods of `a` and `b`.
+ // Pseudorandom number generator from the "Xorshift RNGs" paper by George Marsaglia.
+ let mut random = len as u32;
+ let mut gen_u32 = || {
+ random ^= random << 13;
+ random ^= random >> 17;
+ random ^= random << 5;
+ random
+ };
+ let mut gen_usize = || {
+ if mem::size_of::<usize>() <= 4 {
+ gen_u32() as usize
+ } else {
+ (((gen_u32() as u64) << 32) | (gen_u32() as u64)) as usize
+ }
+ };
+
+ // Take random numbers modulo this number.
+ // The number fits into `usize` because `len` is not greater than `isize::MAX`.
+ let modulus = len.next_power_of_two();
+
+ // Some pivot candidates will be in the nearby of this index. Let's randomize them.
+ let pos = len / 4 * 2;
+
for i in 0..3 {
- v.swap(a - 1 + i, b - 1 + i);
+ // Generate a random number modulo `len`. However, in order to avoid costly operations
+ // we first take it modulo a power of two, and then decrease by `len` until it fits
+ // into the range `[0, len - 1]`.
+ let mut other = gen_usize() & (modulus - 1);
+ while other >= len {
+ other -= len;
+ }
+
+ v.swap(pos - 1 + i, other);
}
}
}
/// [`from_str`]: #tymethod.from_str
/// [`str`]: ../../std/primitive.str.html
/// [`parse`]: ../../std/primitive.str.html#method.parse
+///
+/// # Examples
+///
+/// Basic implementation of `FromStr` on an example `Point` type:
+///
+/// ```
+/// use std::str::FromStr;
+/// use std::num::ParseIntError;
+///
+/// #[derive(Debug, PartialEq)]
+/// struct Point {
+/// x: i32,
+/// y: i32
+/// }
+///
+/// impl FromStr for Point {
+/// type Err = ParseIntError;
+///
+/// fn from_str(s: &str) -> Result<Self, Self::Err> {
+/// let coords: Vec<&str> = s.trim_matches(|p| p == '(' || p == ')' )
+/// .split(",")
+/// .collect();
+///
+/// let x_fromstr = coords[0].parse::<i32>()?;
+/// let y_fromstr = coords[1].parse::<i32>()?;
+///
+/// Ok(Point { x: x_fromstr, y: y_fromstr })
+/// }
+/// }
+///
+/// let p = Point::from_str("(1,2)");
+/// assert_eq!(p.unwrap(), Point{ x: 1, y: 2} )
+/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub trait FromStr: Sized {
/// The associated error which can be returned from parsing.
}
}
-/// An error returned when parsing a `bool` from a string fails.
+/// An error returned when parsing a `bool` using [`from_str`] fails
+///
+/// [`from_str`]: ../../std/primitive.bool.html#method.from_str
#[derive(Debug, Clone, PartialEq, Eq)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct ParseBoolError { _priv: () }
pub fn to_dot_string(&self) -> String {
match self {
&LabelStr(ref s) => format!("\"{}\"", s.escape_default()),
- &EscStr(ref s) => format!("\"{}\"", LabelText::escape_str(&s[..])),
+ &EscStr(ref s) => format!("\"{}\"", LabelText::escape_str(&s)),
&HtmlStr(ref s) => format!("<{}>", s),
}
}
let mut prefix = self.pre_escaped_content().into_owned();
let suffix = suffix.pre_escaped_content();
prefix.push_str(r"\n\n");
- prefix.push_str(&suffix[..]);
+ prefix.push_str(&suffix);
EscStr(prefix.into_cow())
}
}
type Node = Node;
type Edge = &'a Edge;
fn graph_id(&'a self) -> Id<'a> {
- Id::new(&self.name[..]).unwrap()
+ Id::new(self.name).unwrap()
}
fn node_id(&'a self, n: &Node) -> Id<'a> {
id_name(n)
-Subproject commit 64d954c6a76e896fbf7ed5c17e77c40e388abe84
+Subproject commit 05a2d197356ef253dfd985166576619ac9b6947f
CoherenceCheckImpl(D),
CoherenceOverlapCheck(D),
CoherenceOverlapCheckSpecial(D),
- CoherenceOverlapInherentCheck(D),
CoherenceOrphanCheck(D),
Variance,
WfCheck(D),
CoherenceCheckImpl(ref d) => op(d).map(CoherenceCheckImpl),
CoherenceOverlapCheck(ref d) => op(d).map(CoherenceOverlapCheck),
CoherenceOverlapCheckSpecial(ref d) => op(d).map(CoherenceOverlapCheckSpecial),
- CoherenceOverlapInherentCheck(ref d) => op(d).map(CoherenceOverlapInherentCheck),
CoherenceOrphanCheck(ref d) => op(d).map(CoherenceOrphanCheck),
WfCheck(ref d) => op(d).map(WfCheck),
TypeckItemType(ref d) => op(d).map(TypeckItemType),
pub fn keys(&self) -> Vec<M::Key> {
self.map.keys().cloned().collect()
}
-
- /// Append `elem` to the vector stored for `k`, creating a new vector if needed.
- /// This is considered a write to `k`.
- ///
- /// NOTE: Caution is required when using this method. You should
- /// be sure that nobody is **reading from the vector** while you
- /// are writing to it. Eventually, it'd be nice to remove this.
- pub fn push<E: Clone>(&mut self, k: M::Key, elem: E)
- where M: DepTrackingMapConfig<Value=Vec<E>>
- {
- self.write(&k);
- self.map.entry(k)
- .or_insert(Vec::new())
- .push(elem);
- }
}
impl<M: DepTrackingMapConfig> MemoizationMap for RefCell<DepTrackingMap<M>> {
E0398: r##"
In Rust 1.3, the default object lifetime bounds are expected to change, as
-described in RFC #1156 [1]. You are getting a warning because the compiler
+described in [RFC 1156]. You are getting a warning because the compiler
thinks it is possible that this change will cause a compilation error in your
code. It is possible, though unlikely, that this is a false alarm.
This explicitly states that you expect the trait object `SomeTrait` to contain
references (with a maximum lifetime of `'a`).
-[1]: https://github.com/rust-lang/rfcs/pull/1156
+[RFC 1156]: https://github.com/rust-lang/rfcs/blob/master/text/1156-adjust-default-object-bounds.md
"##,
E0452: r##"
**item** (`typeof(foo)`), which is zero-sized, and the target type (`fn()`)
is a function pointer, which is not zero-sized.
This pattern should be rewritten. There are a few possible ways to do this:
+
- change the original fn declaration to match the expected signature,
and do the cast in the fn body (the prefered option)
- cast the fn item fo a fn pointer before calling transmute, as shown here:
FunctionRetTy::Default(span) => hir::DefaultReturn(span),
},
variadic: decl.variadic,
+ has_implicit_self: decl.inputs.get(0).map_or(false, |arg| {
+ match arg.ty.node {
+ TyKind::ImplicitSelf => true,
+ TyKind::Rptr(_, ref mt) => mt.ty.node == TyKind::ImplicitSelf,
+ _ => false
+ }
+ })
})
}
pub inputs: HirVec<P<Ty>>,
pub output: FunctionRetTy,
pub variadic: bool,
+ /// True if this function has an `self`, `&self` or `&mut self` receiver
+ /// (but not a `self: Xxx` one).
+ pub has_implicit_self: bool,
}
#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
impl Encodable for Fingerprint {
#[inline]
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- for &byte in &self.0[..] {
+ for &byte in &self.0 {
s.emit_u8(byte)?;
}
Ok(())
#[inline]
fn decode<D: Decoder>(d: &mut D) -> Result<Fingerprint, D::Error> {
let mut result = Fingerprint([0u8; FINGERPRINT_LENGTH]);
- for byte in &mut result.0[..] {
+ for byte in &mut result.0 {
*byte = d.read_u8()?;
}
Ok(result)
{
debug!("note_issue_32330: terr={:?}", terr);
match *terr {
- TypeError::RegionsInsufficientlyPolymorphic(_, &Region::ReVar(vid)) |
- TypeError::RegionsOverlyPolymorphic(_, &Region::ReVar(vid)) => {
- match self.region_vars.var_origin(vid) {
- RegionVariableOrigin::EarlyBoundRegion(_, _, Some(Issue32330 {
- fn_def_id,
- region_name
- })) => {
- diag.note(
- &format!("lifetime parameter `{0}` declared on fn `{1}` \
- appears only in the return type, \
- but here is required to be higher-ranked, \
- which means that `{0}` must appear in both \
- argument and return types",
- region_name,
- self.tcx.item_path_str(fn_def_id)));
- diag.note(
- &format!("this error is the result of a recent bug fix; \
- for more information, see issue #33685 \
- <https://github.com/rust-lang/rust/issues/33685>"));
- }
- _ => { }
- }
+ TypeError::RegionsInsufficientlyPolymorphic(_, _, Some(box Issue32330 {
+ fn_def_id, region_name
+ })) |
+ TypeError::RegionsOverlyPolymorphic(_, _, Some(box Issue32330 {
+ fn_def_id, region_name
+ })) => {
+ diag.note(
+ &format!("lifetime parameter `{0}` declared on fn `{1}` \
+ appears only in the return type, \
+ but here is required to be higher-ranked, \
+ which means that `{0}` must appear in both \
+ argument and return types",
+ region_name,
+ self.tcx.item_path_str(fn_def_id)));
+ diag.note(
+ &format!("this error is the result of a recent bug fix; \
+ for more information, see issue #33685 \
+ <https://github.com/rust-lang/rust/issues/33685>"));
}
- _ => { }
+ _ => {}
}
}
InferCtxt,
LateBoundRegion,
HigherRankedType,
+ RegionVariableOrigin,
SubregionOrigin,
SkolemizationMap};
use super::combine::CombineFields;
skol_br,
tainted_region);
+ let issue_32330 = if let &ty::ReVar(vid) = tainted_region {
+ match self.region_vars.var_origin(vid) {
+ RegionVariableOrigin::EarlyBoundRegion(_, _, issue_32330) => {
+ issue_32330.map(Box::new)
+ }
+ _ => None
+ }
+ } else {
+ None
+ };
+
if overly_polymorphic {
debug!("Overly polymorphic!");
return Err(TypeError::RegionsOverlyPolymorphic(skol_br,
- tainted_region));
+ tainted_region,
+ issue_32330));
} else {
debug!("Not as polymorphic!");
return Err(TypeError::RegionsInsufficientlyPolymorphic(skol_br,
- tainted_region));
+ tainted_region,
+ issue_32330));
}
}
}
use std::default::Default as StdDefault;
use std::mem;
use std::fmt;
-use std::ops::Deref;
use syntax::attr;
use syntax::ast;
use syntax::symbol::Symbol;
Allow => bug!("earlier conditional return should handle Allow case")
};
let hyphen_case_lint_name = name.replace("_", "-");
- if lint_flag_val.as_str().deref() == name {
+ if lint_flag_val.as_str() == name {
err.note(&format!("requested on the command line with `{} {}`",
flag, hyphen_case_lint_name));
} else {
},
Node(lint_attr_name, src) => {
def = Some(src);
- if lint_attr_name.as_str().deref() != name {
+ if lint_attr_name.as_str() != name {
let level_str = level.as_str();
err.note(&format!("#[{}({})] implied by #[{}({})]",
level_str, name, level_str, lint_attr_name));
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>;
- fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>;
// trait info
fn implementations_of_trait(&self, filter: Option<DefId>) -> Vec<DefId>;
{ bug!("item_generics_cloned") }
fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute> { bug!("item_attrs") }
fn fn_arg_names(&self, did: DefId) -> Vec<ast::Name> { bug!("fn_arg_names") }
- fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId> { vec![] }
// trait info
fn implementations_of_trait(&self, filter: Option<DefId>) -> Vec<DefId> { vec![] }
pub type cmt<'tcx> = Rc<cmt_<'tcx>>;
+pub enum ImmutabilityBlame<'tcx> {
+ ImmLocal(ast::NodeId),
+ ClosureEnv(ast::NodeId),
+ LocalDeref(ast::NodeId),
+ AdtFieldDeref(&'tcx ty::AdtDef, &'tcx ty::FieldDef)
+}
+
impl<'tcx> cmt_<'tcx> {
- pub fn get_def(&self) -> Option<ast::NodeId> {
- match self.cat {
- Categorization::Deref(ref cmt, ..) |
- Categorization::Interior(ref cmt, _) |
- Categorization::Downcast(ref cmt, _) => {
- if let Categorization::Local(nid) = cmt.cat {
- Some(nid)
- } else {
- None
- }
+ fn resolve_field(&self, field_name: FieldName) -> (&'tcx ty::AdtDef, &'tcx ty::FieldDef)
+ {
+ let adt_def = self.ty.ty_adt_def().unwrap_or_else(|| {
+ bug!("interior cmt {:?} is not an ADT", self)
+ });
+ let variant_def = match self.cat {
+ Categorization::Downcast(_, variant_did) => {
+ adt_def.variant_with_id(variant_did)
}
- _ => None
- }
+ _ => {
+ assert!(adt_def.is_univariant());
+ &adt_def.variants[0]
+ }
+ };
+ let field_def = match field_name {
+ NamedField(name) => variant_def.field_named(name),
+ PositionalField(idx) => &variant_def.fields[idx]
+ };
+ (adt_def, field_def)
}
- pub fn get_field(&self, name: ast::Name) -> Option<DefId> {
+ pub fn immutability_blame(&self) -> Option<ImmutabilityBlame<'tcx>> {
match self.cat {
- Categorization::Deref(ref cmt, ..) |
- Categorization::Interior(ref cmt, _) |
- Categorization::Downcast(ref cmt, _) => {
- if let Categorization::Local(_) = cmt.cat {
- if let ty::TyAdt(def, _) = self.ty.sty {
- if def.is_struct() {
- return def.struct_variant().find_field_named(name).map(|x| x.did);
+ Categorization::Deref(ref base_cmt, _, BorrowedPtr(ty::ImmBorrow, _)) |
+ Categorization::Deref(ref base_cmt, _, Implicit(ty::ImmBorrow, _)) => {
+ // try to figure out where the immutable reference came from
+ match base_cmt.cat {
+ Categorization::Local(node_id) =>
+ Some(ImmutabilityBlame::LocalDeref(node_id)),
+ Categorization::Interior(ref base_cmt, InteriorField(field_name)) => {
+ let (adt_def, field_def) = base_cmt.resolve_field(field_name);
+ Some(ImmutabilityBlame::AdtFieldDeref(adt_def, field_def))
+ }
+ Categorization::Upvar(Upvar { id, .. }) => {
+ if let NoteClosureEnv(..) = self.note {
+ Some(ImmutabilityBlame::ClosureEnv(id.closure_expr_id))
+ } else {
+ None
}
}
- None
- } else {
- cmt.get_field(name)
+ _ => None
}
}
- _ => None
- }
- }
-
- pub fn get_field_name(&self) -> Option<ast::Name> {
- match self.cat {
- Categorization::Interior(_, ref ik) => {
- if let InteriorKind::InteriorField(FieldName::NamedField(name)) = *ik {
- Some(name)
- } else {
- None
- }
+ Categorization::Local(node_id) => {
+ Some(ImmutabilityBlame::ImmLocal(node_id))
}
- Categorization::Deref(ref cmt, ..) |
- Categorization::Downcast(ref cmt, _) => {
- cmt.get_field_name()
+ Categorization::Rvalue(..) |
+ Categorization::Upvar(..) |
+ Categorization::Deref(.., UnsafePtr(..)) => {
+ // This should not be reachable up to inference limitations.
+ None
}
- _ => None,
- }
- }
-
- pub fn get_arg_if_immutable(&self, map: &hir_map::Map) -> Option<ast::NodeId> {
- match self.cat {
- Categorization::Deref(ref cmt, ..) |
- Categorization::Interior(ref cmt, _) |
- Categorization::Downcast(ref cmt, _) => {
- if let Categorization::Local(nid) = cmt.cat {
- if let ty::TyAdt(_, _) = self.ty.sty {
- if let ty::TyRef(_, ty::TypeAndMut{mutbl: MutImmutable, ..}) = cmt.ty.sty {
- return Some(nid);
- }
- }
- None
- } else {
- cmt.get_arg_if_immutable(map)
- }
+ Categorization::Interior(ref base_cmt, _) |
+ Categorization::Downcast(ref base_cmt, _) |
+ Categorization::Deref(ref base_cmt, _, _) => {
+ base_cmt.immutability_blame()
+ }
+ Categorization::StaticItem => {
+ // Do we want to do something here?
+ None
}
- _ => None
}
}
}
#[derive(Copy, Clone, Debug)]
pub enum AliasableReason {
AliasableBorrowed,
- AliasableClosure(ast::NodeId), // Aliasable due to capture Fn closure env
- AliasableOther,
- UnaliasableImmutable, // Created as needed upon seeing ImmutableUnique
AliasableStatic,
AliasableStaticMut,
}
Categorization::Deref(ref b, _, Implicit(ty::MutBorrow, _)) |
Categorization::Deref(ref b, _, BorrowedPtr(ty::UniqueImmBorrow, _)) |
Categorization::Deref(ref b, _, Implicit(ty::UniqueImmBorrow, _)) |
+ Categorization::Deref(ref b, _, Unique) |
Categorization::Downcast(ref b, _) |
Categorization::Interior(ref b, _) => {
// Aliasability depends on base cmt
b.freely_aliasable()
}
- Categorization::Deref(ref b, _, Unique) => {
- let sub = b.freely_aliasable();
- if b.mutbl.is_mutable() {
- // Aliasability depends on base cmt alone
- sub
- } else {
- // Do not allow mutation through an immutable box.
- ImmutableUnique(Box::new(sub))
- }
- }
-
Categorization::Rvalue(..) |
Categorization::Local(..) |
Categorization::Upvar(..) |
}
}
- Categorization::Deref(ref base, _, BorrowedPtr(ty::ImmBorrow, _)) |
- Categorization::Deref(ref base, _, Implicit(ty::ImmBorrow, _)) => {
- match base.cat {
- Categorization::Upvar(Upvar{ id, .. }) =>
- FreelyAliasable(AliasableClosure(id.closure_expr_id)),
- _ => FreelyAliasable(AliasableBorrowed)
- }
+ Categorization::Deref(_, _, BorrowedPtr(ty::ImmBorrow, _)) |
+ Categorization::Deref(_, _, Implicit(ty::ImmBorrow, _)) => {
+ FreelyAliasable(AliasableBorrowed)
}
}
}
if !self.stability.borrow().active_features.contains(feature) {
let msg = match *reason {
Some(ref r) => format!("use of unstable library feature '{}': {}",
- &feature.as_str(), &r),
+ feature.as_str(), &r),
None => format!("use of unstable library feature '{}'", &feature)
};
emit_feature_err(&self.sess.parse_sess, &feature.as_str(), span,
RawPtr(hir::Mutability),
}
+/// Information for `CoerceUnsized` impls, storing information we
+/// have computed about the coercion.
+///
+/// This struct can be obtained via the `coerce_impl_info` query.
+/// Demanding this struct also has the side-effect of reporting errors
+/// for inappropriate impls.
+#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)]
+pub struct CoerceUnsizedInfo {
+ /// If this is a "custom coerce" impl, then what kind of custom
+ /// coercion is it? This applies to impls of `CoerceUnsized` for
+ /// structs, primarily, where we store a bit of info about which
+ /// fields need to be coerced.
+ pub custom_kind: Option<CustomCoerceUnsized>
+}
+
#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)]
pub enum CustomCoerceUnsized {
/// Records the index of the field being coerced.
RegionsDoesNotOutlive(&'tcx Region, &'tcx Region),
RegionsNotSame(&'tcx Region, &'tcx Region),
RegionsNoOverlap(&'tcx Region, &'tcx Region),
- RegionsInsufficientlyPolymorphic(BoundRegion, &'tcx Region),
- RegionsOverlyPolymorphic(BoundRegion, &'tcx Region),
+ RegionsInsufficientlyPolymorphic(BoundRegion, &'tcx Region, Option<Box<ty::Issue32330>>),
+ RegionsOverlyPolymorphic(BoundRegion, &'tcx Region, Option<Box<ty::Issue32330>>),
Sorts(ExpectedFound<Ty<'tcx>>),
IntMismatch(ExpectedFound<ty::IntVarValue>),
FloatMismatch(ExpectedFound<ast::FloatTy>),
RegionsNoOverlap(..) => {
write!(f, "lifetimes do not intersect")
}
- RegionsInsufficientlyPolymorphic(br, _) => {
+ RegionsInsufficientlyPolymorphic(br, _, _) => {
write!(f, "expected bound lifetime parameter {}, \
found concrete lifetime", br)
}
- RegionsOverlyPolymorphic(br, _) => {
+ RegionsOverlyPolymorphic(br, _, _) => {
write!(f, "expected concrete lifetime, \
found bound lifetime parameter {}", br)
}
self.note_and_explain_region(db, "...does not overlap ",
region2, "");
}
- RegionsInsufficientlyPolymorphic(_, conc_region) => {
+ RegionsInsufficientlyPolymorphic(_, conc_region, _) => {
self.note_and_explain_region(db, "concrete lifetime that was found is ",
conc_region, "");
}
- RegionsOverlyPolymorphic(_, &ty::ReVar(_)) => {
+ RegionsOverlyPolymorphic(_, &ty::ReVar(_), _) => {
// don't bother to print out the message below for
// inference variables, it's not very illuminating.
}
- RegionsOverlyPolymorphic(_, conc_region) => {
+ RegionsOverlyPolymorphic(_, conc_region, _) => {
self.note_and_explain_region(db, "expected concrete lifetime is ",
conc_region, "");
}
use middle::const_val::ConstVal;
use middle::privacy::AccessLevels;
use mir;
-use ty::{self, Ty, TyCtxt};
+use session::CompileResult;
+use ty::{self, CrateInherentImpls, Ty, TyCtxt};
use rustc_data_structures::indexed_vec::IndexVec;
use std::cell::{RefCell, RefMut};
}
}
-impl<'tcx> QueryDescription for queries::coherent_inherent_impls<'tcx> {
+impl<'tcx> QueryDescription for queries::crate_inherent_impls<'tcx> {
+ fn describe(_: TyCtxt, k: CrateNum) -> String {
+ format!("all inherent impls defined in crate `{:?}`", k)
+ }
+}
+
+impl<'tcx> QueryDescription for queries::crate_inherent_impls_overlap_check<'tcx> {
fn describe(_: TyCtxt, _: CrateNum) -> String {
- format!("coherence checking all inherent impls")
+ format!("check for overlap between inherent impls defined in this crate")
}
}
}
}
+impl<'tcx> QueryDescription for queries::typeck_item_bodies<'tcx> {
+ fn describe(_: TyCtxt, _: CrateNum) -> String {
+ format!("type-checking all item bodies")
+ }
+}
+
+
macro_rules! define_maps {
(<$tcx:tt>
$($(#[$attr:meta])*
/// Maps a DefId of a type to a list of its inherent impls.
/// Contains implementations of methods that are inherent to a type.
/// Methods in these implementations don't need to be exported.
- pub inherent_impls: InherentImpls(DefId) -> Vec<DefId>,
+ pub inherent_impls: InherentImpls(DefId) -> Rc<Vec<DefId>>,
/// Maps from the def-id of a function/method or const/static
/// to its MIR. Mutation is done at an item granularity to
pub closure_type: ItemSignature(DefId) -> ty::PolyFnSig<'tcx>,
/// Caches CoerceUnsized kinds for impls on custom types.
- pub custom_coerce_unsized_kind: ItemSignature(DefId)
- -> ty::adjustment::CustomCoerceUnsized,
+ pub coerce_unsized_info: ItemSignature(DefId)
+ -> ty::adjustment::CoerceUnsizedInfo,
+
+ pub typeck_item_bodies: typeck_item_bodies_dep_node(CrateNum) -> CompileResult,
pub typeck_tables: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>,
pub coherent_trait: coherent_trait_dep_node((CrateNum, DefId)) -> (),
- pub coherent_inherent_impls: coherent_inherent_impls_dep_node(CrateNum) -> (),
+ /// Gets a complete map from all types to their inherent impls.
+ /// Not meant to be used directly outside of coherence.
+ /// (Defined only for LOCAL_CRATE)
+ pub crate_inherent_impls: crate_inherent_impls_dep_node(CrateNum) -> CrateInherentImpls,
+
+ /// Checks all types in the krate for overlap in their inherent impls. Reports errors.
+ /// Not meant to be used directly outside of coherence.
+ /// (Defined only for LOCAL_CRATE)
+ pub crate_inherent_impls_overlap_check: crate_inherent_impls_dep_node(CrateNum) -> (),
/// Results of evaluating monomorphic constants embedded in
/// other items, such as enum variant explicit discriminants.
DepNode::CoherenceCheckTrait(def_id)
}
-fn coherent_inherent_impls_dep_node(_: CrateNum) -> DepNode<DefId> {
+fn crate_inherent_impls_dep_node(_: CrateNum) -> DepNode<DefId> {
DepNode::Coherence
}
fn mir_shim(instance: ty::InstanceDef) -> DepNode<DefId> {
instance.dep_node()
}
+
+fn typeck_item_bodies_dep_node(_: CrateNum) -> DepNode<DefId> {
+ DepNode::TypeckBodiesKrate
+}
use ty::util::IntTypeExt;
use ty::walk::TypeWalker;
use util::common::MemoizationMap;
-use util::nodemap::{NodeSet, FxHashMap};
+use util::nodemap::{NodeSet, DefIdMap, FxHashMap};
use serialize::{self, Encodable, Encoder};
use std::borrow::Cow;
})
}
- pub fn custom_coerce_unsized_kind(self, did: DefId) -> adjustment::CustomCoerceUnsized {
- queries::custom_coerce_unsized_kind::get(self, DUMMY_SP, did)
+ pub fn coerce_unsized_info(self, did: DefId) -> adjustment::CoerceUnsizedInfo {
+ queries::coerce_unsized_info::get(self, DUMMY_SP, did)
}
pub fn associated_item(self, def_id: DefId) -> AssociatedItem {
def.flags.get().intersects(TraitFlags::HAS_DEFAULT_IMPL)
}
- /// Populates the type context with all the inherent implementations for
- /// the given type if necessary.
- pub fn populate_inherent_implementations_for_type_if_necessary(self,
- span: Span,
- type_id: DefId) {
- if type_id.is_local() {
- // Make sure coherence of inherent impls ran already.
- ty::queries::coherent_inherent_impls::force(self, span, LOCAL_CRATE);
- return
- }
-
- // The type is not local, hence we are reading this out of
- // metadata and don't need to track edges.
- let _ignore = self.dep_graph.in_ignore();
-
- if self.populated_external_types.borrow().contains(&type_id) {
- return
- }
-
- debug!("populate_inherent_implementations_for_type_if_necessary: searching for {:?}",
- type_id);
-
- let inherent_impls = self.sess.cstore.inherent_implementations_for_type(type_id);
-
- self.maps.inherent_impls.borrow_mut().insert(type_id, inherent_impls);
- self.populated_external_types.borrow_mut().insert(type_id);
- }
-
/// Populates the type context with all the implementations for the given
/// trait if necessary.
pub fn populate_implementations_for_trait_if_necessary(self, trait_id: DefId) {
..*providers
};
}
+
+
+/// A map for the local crate mapping each type to a vector of its
+/// inherent impls. This is not meant to be used outside of coherence;
+/// rather, you should request the vector for a specific type via
+/// `ty::queries::inherent_impls::get(def_id)` so as to minimize your
+/// dependencies (constructing this map requires touching the entire
+/// crate).
+#[derive(Clone, Debug)]
+pub struct CrateInherentImpls {
+ pub inherent_impls: DefIdMap<Rc<Vec<DefId>>>,
+}
+
RegionsNoOverlap(a, b) => {
return tcx.lift(&(a, b)).map(|(a, b)| RegionsNoOverlap(a, b))
}
- RegionsInsufficientlyPolymorphic(a, b) => {
- return tcx.lift(&b).map(|b| RegionsInsufficientlyPolymorphic(a, b))
+ RegionsInsufficientlyPolymorphic(a, b, ref c) => {
+ let c = c.clone();
+ return tcx.lift(&b).map(|b| RegionsInsufficientlyPolymorphic(a, b, c))
}
- RegionsOverlyPolymorphic(a, b) => {
- return tcx.lift(&b).map(|b| RegionsOverlyPolymorphic(a, b))
+ RegionsOverlyPolymorphic(a, b, ref c) => {
+ let c = c.clone();
+ return tcx.lift(&b).map(|b| RegionsOverlyPolymorphic(a, b, c))
}
IntMismatch(x) => IntMismatch(x),
FloatMismatch(x) => FloatMismatch(x),
// First, filter out duplicates
moved.sort();
moved.dedup();
- debug!("fragments 1 moved: {:?}", path_lps(&moved[..]));
+ debug!("fragments 1 moved: {:?}", path_lps(&moved));
assigned.sort();
assigned.dedup();
- debug!("fragments 1 assigned: {:?}", path_lps(&assigned[..]));
+ debug!("fragments 1 assigned: {:?}", path_lps(&assigned));
// Second, build parents from the moved and assigned.
for m in &moved {
parents.sort();
parents.dedup();
- debug!("fragments 2 parents: {:?}", path_lps(&parents[..]));
+ debug!("fragments 2 parents: {:?}", path_lps(&parents));
// Third, filter the moved and assigned fragments down to just the non-parents
- moved.retain(|f| non_member(*f, &parents[..]));
- debug!("fragments 3 moved: {:?}", path_lps(&moved[..]));
+ moved.retain(|f| non_member(*f, &parents));
+ debug!("fragments 3 moved: {:?}", path_lps(&moved));
- assigned.retain(|f| non_member(*f, &parents[..]));
- debug!("fragments 3 assigned: {:?}", path_lps(&assigned[..]));
+ assigned.retain(|f| non_member(*f, &parents));
+ debug!("fragments 3 assigned: {:?}", path_lps(&assigned));
// Fourth, build the leftover from the moved, assigned, and parents.
for m in &moved {
unmoved.sort();
unmoved.dedup();
- debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved[..]));
+ debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved));
// Fifth, filter the leftover fragments down to its core.
unmoved.retain(|f| match *f {
AllButOneFrom(_) => true,
- Just(mpi) => non_member(mpi, &parents[..]) &&
- non_member(mpi, &moved[..]) &&
- non_member(mpi, &assigned[..])
+ Just(mpi) => non_member(mpi, &parents) &&
+ non_member(mpi, &moved) &&
+ non_member(mpi, &assigned)
});
- debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved[..]));
+ debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved));
// Swap contents back in.
fragments.unmoved_fragments = unmoved;
// user knows what they're doing in these cases.
Ok(())
}
- (mc::Aliasability::ImmutableUnique(_), ty::MutBorrow) => {
- bccx.report_aliasability_violation(
- borrow_span,
- loan_cause,
- mc::AliasableReason::UnaliasableImmutable,
- cmt);
- Err(())
- }
(mc::Aliasability::FreelyAliasable(alias_cause), ty::UniqueImmBorrow) |
(mc::Aliasability::FreelyAliasable(alias_cause), ty::MutBorrow) => {
bccx.report_aliasability_violation(
self.move_error_collector.report_potential_errors(self.bccx);
}
}
-
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
+use rustc::middle::mem_categorization::ImmutabilityBlame;
use rustc::middle::region;
use rustc::ty::{self, TyCtxt};
&flowed_moves.move_data,
owner_id);
- check_loans::check_loans(bccx, &loan_dfcx, &flowed_moves, &all_loans[..], body);
+ check_loans::check_loans(bccx, &loan_dfcx, &flowed_moves, &all_loans, body);
}
fn build_borrowck_dataflow_data<'a, 'tcx>(this: &mut BorrowckCtxt<'a, 'tcx>,
self.tcx.sess.span_err_with_code(s, msg, code);
}
- pub fn bckerr_to_diag(&self, err: &BckError<'tcx>) -> DiagnosticBuilder<'a> {
+ fn bckerr_to_diag(&self, err: &BckError<'tcx>) -> DiagnosticBuilder<'a> {
let span = err.span.clone();
- let mut immutable_field = None;
- let mut local_def = None;
- let msg = &match err.code {
+ let msg = match err.code {
err_mutbl => {
let descr = match err.cmt.note {
mc::NoteClosureEnv(_) | mc::NoteUpvarRef(_) => {
BorrowViolation(euv::AutoUnsafe) |
BorrowViolation(euv::ForLoop) |
BorrowViolation(euv::MatchDiscriminant) => {
- // Check for this field's definition to see if it is an immutable reference
- // and suggest making it mutable if that is the case.
- immutable_field = err.cmt.get_field_name()
- .and_then(|name| err.cmt.get_field(name))
- .and_then(|did| self.tcx.hir.as_local_node_id(did))
- .and_then(|nid| {
- if let hir_map::Node::NodeField(ref field) = self.tcx.hir.get(nid) {
- return self.suggest_mut_for_immutable(&field.ty)
- .map(|msg| (self.tcx.hir.span(nid), msg));
- }
- None
- });
- local_def = err.cmt.get_def()
- .and_then(|nid| {
- if !self.tcx.hir.is_argument(nid) {
- Some(self.tcx.hir.span(nid))
- } else {
- None
- }
- });
-
format!("cannot borrow {} as mutable", descr)
}
BorrowViolation(euv::ClosureInvocation) => {
}
};
- let mut db = self.struct_span_err(span, msg);
- if let Some((span, msg)) = immutable_field {
- db.span_label(span, &msg);
- }
- if let Some(let_span) = local_def {
- if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(let_span) {
- db.span_label(let_span, &format!("consider changing this to `mut {}`", snippet));
- }
- }
- db
+ self.struct_span_err(span, &msg)
}
pub fn report_aliasability_violation(&self,
}
};
- let mut err = match cause {
- mc::AliasableOther => {
- struct_span_err!(
- self.tcx.sess, span, E0385,
- "{} in an aliasable location", prefix)
- }
- mc::AliasableReason::UnaliasableImmutable => {
- struct_span_err!(
- self.tcx.sess, span, E0386,
- "{} in an immutable container", prefix)
+ match cause {
+ mc::AliasableStatic |
+ mc::AliasableStaticMut => {
+ // This path cannot occur. It happens when we have an
+ // `&mut` or assignment to a static. But in the case
+ // of `static X`, we get a mutability violation first,
+ // and never get here. In the case of `static mut X`,
+ // that is unsafe and hence the aliasability error is
+ // ignored.
+ span_bug!(span, "aliasability violation for static `{}`", prefix)
}
- mc::AliasableClosure(id) => {
+ mc::AliasableBorrowed => {}
+ };
+ let blame = cmt.immutability_blame();
+ let mut err = match blame {
+ Some(ImmutabilityBlame::ClosureEnv(id)) => {
let mut err = struct_span_err!(
self.tcx.sess, span, E0387,
"{} in a captured outer variable in an `Fn` closure", prefix);
- if let BorrowViolation(euv::ClosureCapture(_)) = kind {
+
+ // FIXME: the distinction between these 2 messages looks wrong.
+ let help = if let BorrowViolation(euv::ClosureCapture(_)) = kind {
// The aliasability violation with closure captures can
// happen for nested closures, so we know the enclosing
// closure incorrectly accepts an `Fn` while it needs to
// be `FnMut`.
- span_help!(&mut err, self.tcx.hir.span(id),
- "consider changing this to accept closures that implement `FnMut`");
+ "consider changing this to accept closures that implement `FnMut`"
+
} else {
- span_help!(&mut err, self.tcx.hir.span(id),
- "consider changing this closure to take self by mutable reference");
- }
+ "consider changing this closure to take self by mutable reference"
+ };
+ err.span_help(self.tcx.hir.span(id), help);
err
}
- mc::AliasableStatic |
- mc::AliasableStaticMut => {
- // This path cannot occur. It happens when we have an
- // `&mut` or assignment to a static. But in the case
- // of `static X`, we get a mutability violation first,
- // and never get here. In the case of `static mut X`,
- // that is unsafe and hence the aliasability error is
- // ignored.
- span_bug!(span, "aliasability violation for static `{}`", prefix)
- }
- mc::AliasableBorrowed => {
- let mut e = struct_span_err!(
+ _ => {
+ let mut err = struct_span_err!(
self.tcx.sess, span, E0389,
"{} in a `&` reference", prefix);
- e.span_label(span, &"assignment into an immutable reference");
- if let Some(nid) = cmt.get_arg_if_immutable(&self.tcx.hir) {
- self.immutable_argument_should_be_mut(nid, &mut e);
- }
- e
+ err.span_label(span, &"assignment into an immutable reference");
+ err
}
};
+ self.note_immutability_blame(&mut err, blame);
if is_closure {
err.help("closures behind references must be called via `&mut`");
}
/// Given a type, if it is an immutable reference, return a suggestion to make it mutable
- fn suggest_mut_for_immutable(&self, pty: &hir::Ty) -> Option<String> {
+ fn suggest_mut_for_immutable(&self, pty: &hir::Ty, is_implicit_self: bool) -> Option<String> {
// Check wether the argument is an immutable reference
+ debug!("suggest_mut_for_immutable({:?}, {:?})", pty, is_implicit_self);
if let hir::TyRptr(lifetime, hir::MutTy {
mutbl: hir::Mutability::MutImmutable,
ref ty
}) = pty.node {
// Account for existing lifetimes when generating the message
- if !lifetime.is_elided() {
- if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(ty.span) {
- if let Ok(lifetime_snippet) = self.tcx.sess.codemap()
- .span_to_snippet(lifetime.span) {
- return Some(format!("use `&{} mut {}` here to make mutable",
- lifetime_snippet,
- snippet));
- }
- }
- } else if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(pty.span) {
- if snippet.starts_with("&") {
- return Some(format!("use `{}` here to make mutable",
- snippet.replace("&", "&mut ")));
- }
+ let pointee_snippet = match self.tcx.sess.codemap().span_to_snippet(ty.span) {
+ Ok(snippet) => snippet,
+ _ => return None
+ };
+
+ let lifetime_snippet = if !lifetime.is_elided() {
+ format!("{} ", match self.tcx.sess.codemap().span_to_snippet(lifetime.span) {
+ Ok(lifetime_snippet) => lifetime_snippet,
+ _ => return None
+ })
} else {
- bug!("couldn't find a snippet for span: {:?}", pty.span);
- }
+ String::new()
+ };
+ Some(format!("use `&{}mut {}` here to make mutable",
+ lifetime_snippet,
+ if is_implicit_self { "self" } else { &*pointee_snippet }))
+ } else {
+ None
}
- None
}
- fn immutable_argument_should_be_mut(&self, nid: ast::NodeId, db: &mut DiagnosticBuilder) {
- let parent = self.tcx.hir.get_parent_node(nid);
+ fn local_binding_mode(&self, node_id: ast::NodeId) -> hir::BindingMode {
+ let pat = match self.tcx.hir.get(node_id) {
+ hir_map::Node::NodeLocal(pat) => pat,
+ node => bug!("bad node for local: {:?}", node)
+ };
+
+ match pat.node {
+ hir::PatKind::Binding(mode, ..) => mode,
+ _ => bug!("local is not a binding: {:?}", pat)
+ }
+ }
+
+ fn local_ty(&self, node_id: ast::NodeId) -> (Option<&hir::Ty>, bool) {
+ let parent = self.tcx.hir.get_parent_node(node_id);
let parent_node = self.tcx.hir.get(parent);
// The parent node is like a fn
if let Some(fn_like) = FnLikeNode::from_node(parent_node) {
// `nid`'s parent's `Body`
let fn_body = self.tcx.hir.body(fn_like.body());
- // Get the position of `nid` in the arguments list
- let arg_pos = fn_body.arguments.iter().position(|arg| arg.pat.id == nid);
+ // Get the position of `node_id` in the arguments list
+ let arg_pos = fn_body.arguments.iter().position(|arg| arg.pat.id == node_id);
if let Some(i) = arg_pos {
// The argument's `Ty`
- let arg_ty = &fn_like.decl().inputs[i];
- if let Some(msg) = self.suggest_mut_for_immutable(&arg_ty) {
- db.span_label(arg_ty.span, &msg);
+ (Some(&fn_like.decl().inputs[i]),
+ i == 0 && fn_like.decl().has_implicit_self)
+ } else {
+ (None, false)
+ }
+ } else {
+ (None, false)
+ }
+ }
+
+ fn note_immutability_blame(&self,
+ db: &mut DiagnosticBuilder,
+ blame: Option<ImmutabilityBlame>) {
+ match blame {
+ None => {}
+ Some(ImmutabilityBlame::ClosureEnv(_)) => {}
+ Some(ImmutabilityBlame::ImmLocal(node_id)) => {
+ let let_span = self.tcx.hir.span(node_id);
+ if let hir::BindingMode::BindByValue(..) = self.local_binding_mode(node_id) {
+ if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(let_span) {
+ let (_, is_implicit_self) = self.local_ty(node_id);
+ if is_implicit_self && snippet != "self" {
+ // avoid suggesting `mut &self`.
+ return
+ }
+ db.span_label(
+ let_span,
+ &format!("consider changing this to `mut {}`", snippet)
+ );
+ }
+ }
+ }
+ Some(ImmutabilityBlame::LocalDeref(node_id)) => {
+ let let_span = self.tcx.hir.span(node_id);
+ match self.local_binding_mode(node_id) {
+ hir::BindingMode::BindByRef(..) => {
+ let snippet = self.tcx.sess.codemap().span_to_snippet(let_span);
+ if let Ok(snippet) = snippet {
+ db.span_label(
+ let_span,
+ &format!("consider changing this to `{}`",
+ snippet.replace("ref ", "ref mut "))
+ );
+ }
+ }
+ hir::BindingMode::BindByValue(..) => {
+ if let (Some(local_ty), is_implicit_self) = self.local_ty(node_id) {
+ if let Some(msg) =
+ self.suggest_mut_for_immutable(local_ty, is_implicit_self) {
+ db.span_label(local_ty.span, &msg);
+ }
+ }
+ }
+ }
+ }
+ Some(ImmutabilityBlame::AdtFieldDeref(_, field)) => {
+ let node_id = match self.tcx.hir.as_local_node_id(field.did) {
+ Some(node_id) => node_id,
+ None => return
+ };
+
+ if let hir_map::Node::NodeField(ref field) = self.tcx.hir.get(node_id) {
+ if let Some(msg) = self.suggest_mut_for_immutable(&field.ty, false) {
+ db.span_label(field.ty.span, &msg);
+ }
}
}
}
}
}
- pub fn note_and_explain_bckerr(&self, db: &mut DiagnosticBuilder, err: BckError<'tcx>) {
+ fn note_and_explain_bckerr(&self, db: &mut DiagnosticBuilder, err: BckError<'tcx>) {
let error_span = err.span.clone();
match err.code {
- err_mutbl => self.note_and_explain_mutbl_error(db, &err, &error_span),
+ err_mutbl => {
+ self.note_and_explain_mutbl_error(db, &err, &error_span);
+ self.note_immutability_blame(db, err.cmt.immutability_blame());
+ }
err_out_of_scope(super_scope, sub_scope, cause) => {
let (value_kind, value_msg) = match err.cmt.cat {
mc::Categorization::Rvalue(..) =>
_ => {
if let Categorization::Deref(..) = err.cmt.cat {
db.span_label(*error_span, &"cannot borrow as mutable");
- if let Some(local_id) = err.cmt.get_arg_if_immutable(&self.tcx.hir) {
- self.immutable_argument_should_be_mut(local_id, db);
- } else if let Categorization::Deref(ref inner_cmt, ..) = err.cmt.cat {
- if let Categorization::Local(local_id) = inner_cmt.cat {
- self.immutable_argument_should_be_mut(local_id, db);
- }
- }
} else if let Categorization::Local(local_id) = err.cmt.cat {
let span = self.tcx.hir.span(local_id);
if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(span) {
db.span_label(*error_span, &format!("cannot reborrow mutably"));
db.span_label(*error_span, &format!("try removing `&mut` here"));
} else {
- if snippet.starts_with("ref ") {
- db.span_label(span, &format!("use `{}` here to make mutable",
- snippet.replace("ref ", "ref mut ")));
- } else if snippet != "self" {
- db.span_label(span,
- &format!("use `mut {}` here to make mutable",
- snippet));
- }
db.span_label(*error_span, &format!("cannot borrow mutably"));
}
} else {
```
"##,
-E0386: r##"
+/*E0386: r##"
This error occurs when an attempt is made to mutate the target of a mutable
reference stored inside an immutable container.
let y: Box<Cell<_>> = Box::new(Cell::new(x));
y.set(2);
```
-"##,
+"##,*/
E0387: r##"
This error occurs when an attempt is made to mutate or mutably reference data
}
register_diagnostics! {
- E0385, // {} in an aliasable location
+// E0385, // {} in an aliasable location
E0524, // two closures require unique access to `..` at the same time
}
set.push_str(", ");
}
let loan_str = self.borrowck_ctxt.loan_path_to_string(&lp);
- set.push_str(&loan_str[..]);
+ set.push_str(&loan_str);
saw_some = true;
true
});
}).collect();
let wild_patterns: Vec<_> = wild_patterns_owned.iter().collect();
let matrix = Matrix(m.iter().flat_map(|r| {
- specialize(cx, &r[..], &ctor, &wild_patterns)
+ specialize(cx, &r, &ctor, &wild_patterns)
}).collect());
match specialize(cx, v, &ctor, &wild_patterns) {
- Some(v) => match is_useful(cx, &matrix, &v[..], witness) {
+ Some(v) => match is_useful(cx, &matrix, &v, witness) {
UsefulWithWitness(witnesses) => UsefulWithWitness(
witnesses.into_iter()
.map(|witness| witness.apply_constructor(cx, &ctor, lty))
for &(pat, hir_pat) in pats {
let v = vec![pat];
- match is_useful(cx, &seen, &v[..], LeaveOutWitness) {
+ match is_useful(cx, &seen, &v, LeaveOutWitness) {
NotUseful => {
match source {
hir::MatchSource::IfLetDesugar { .. } => {
type Target = [A::Element];
fn deref(&self) -> &Self::Target {
match *self {
- AccumulateVec::Array(ref v) => &v[..],
- AccumulateVec::Heap(ref v) => &v[..],
+ AccumulateVec::Array(ref v) => v,
+ AccumulateVec::Heap(ref v) => v,
}
}
}
impl<A: Array> DerefMut for AccumulateVec<A> {
fn deref_mut(&mut self) -> &mut [A::Element] {
match *self {
- AccumulateVec::Array(ref mut v) => &mut v[..],
- AccumulateVec::Heap(ref mut v) => &mut v[..],
+ AccumulateVec::Array(ref mut v) => v,
+ AccumulateVec::Heap(ref mut v) => v,
}
}
}
#[test]
fn test_encode() {
fn test(n: u64, base: u64) {
- assert_eq!(Ok(n), u64::from_str_radix(&encode(n, base)[..], base as u32));
+ assert_eq!(Ok(n), u64::from_str_radix(&encode(n, base), base as u32));
}
for base in 2..37 {
impl ::std::fmt::Debug for Blake2bCtx {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
try!(write!(fmt, "hash: "));
- for v in &self.h[..] {
+ for v in &self.h {
try!(write!(fmt, "{:x}", v));
}
Ok(())
impl<T: Idx> Deref for IdxSetBuf<T> {
type Target = IdxSet<T>;
fn deref(&self) -> &IdxSet<T> {
- unsafe { IdxSet::from_slice(&self.bits[..]) }
+ unsafe { IdxSet::from_slice(&self.bits) }
}
}
impl<T: Idx> DerefMut for IdxSetBuf<T> {
fn deref_mut(&mut self) -> &mut IdxSet<T> {
- unsafe { IdxSet::from_slice_mut(&mut self.bits[..]) }
+ unsafe { IdxSet::from_slice_mut(&mut self.bits) }
}
}
}
pub fn words(&self) -> &[Word] {
- &self.bits[..]
+ &self.bits
}
pub fn words_mut(&mut self) -> &mut [Word] {
- &mut self.bits[..]
+ &mut self.bits
}
pub fn clone_from(&mut self, other: &IdxSet<T>) {
}
fn keep_ast(sess: &Session) -> bool {
- sess.opts.debugging_opts.keep_ast ||
- sess.opts.debugging_opts.save_analysis ||
- sess.opts.debugging_opts.save_analysis_csv ||
- sess.opts.debugging_opts.save_analysis_api
+ sess.opts.debugging_opts.keep_ast || ::save_analysis(sess)
}
/// The name used for source code that doesn't originate in a file
use rustc_resolve as resolve;
use rustc_save_analysis as save;
+use rustc_save_analysis::DumpHandler;
use rustc_trans::back::link;
use rustc_trans::back::write::{create_target_machine, RELOC_MODEL_ARGS, CODE_GEN_MODEL_ARGS};
use rustc::dep_graph::DepGraph;
// Extract input (string or file and optional path) from matches.
fn make_input(free_matches: &[String]) -> Option<(Input, Option<PathBuf>)> {
if free_matches.len() == 1 {
- let ifile = &free_matches[0][..];
+ let ifile = &free_matches[0];
if ifile == "-" {
let mut src = String::new();
io::stdin().read_to_string(&mut src).unwrap();
state.expanded_crate.unwrap(),
state.analysis.unwrap(),
state.crate_name.unwrap(),
- state.out_dir,
- save_analysis_format(state.session))
+ DumpHandler::new(save_analysis_format(state.session),
+ state.out_dir,
+ state.crate_name.unwrap()))
});
};
control.after_analysis.run_callback_on_error = true;
for lint in lints {
let name = lint.name_lower().replace("_", "-");
println!(" {} {:7.7} {}",
- padded(&name[..]),
+ padded(&name),
lint.default_level.as_str(),
lint.desc);
}
.map(|x| x.to_string().replace("_", "-"))
.collect::<Vec<String>>()
.join(", ");
- println!(" {} {}", padded(&name[..]), desc);
+ println!(" {} {}", padded(&name), desc);
}
println!("\n");
};
.into_iter()
.map(|x| x.opt_group)
.collect();
- let matches = match getopts::getopts(&args[..], &all_groups) {
+ let matches = match getopts::getopts(&args, &all_groups) {
Ok(m) => m,
Err(f) => early_error(ErrorOutputType::default(), &f.to_string()),
};
format!("we would appreciate a bug report: {}", BUG_REPORT_URL)];
for note in &xs {
handler.emit(&MultiSpan::new(),
- ¬e[..],
+ ¬e,
errors::Level::Note);
}
if match env::var_os("RUST_BACKTRACE") {
-> NodesMatchingUII<'a, 'hir> {
match *self {
ItemViaNode(node_id) => NodesMatchingDirect(Some(node_id).into_iter()),
- ItemViaPath(ref parts) => NodesMatchingSuffix(map.nodes_matching_suffix(&parts[..])),
+ ItemViaPath(ref parts) => NodesMatchingSuffix(map.nodes_matching_suffix(&parts)),
}
}
user_option,
self.reconstructed_input(),
is_wrong_because);
- sess.fatal(&message[..])
+ sess.fatal(&message)
};
let mut saw_node = ast::DUMMY_NODE_ID;
fn expand_err_details(r: io::Result<()>) -> io::Result<()> {
r.map_err(|ioerr| {
io::Error::new(io::ErrorKind::Other,
- &format!("graphviz::render failed: {}", ioerr)[..])
+ format!("graphviz::render failed: {}", ioerr))
})
}
}
pub fn t_param(&self, index: u32) -> Ty<'tcx> {
let name = format!("T{}", index);
- self.infcx.tcx.mk_param(index, Symbol::intern(&name[..]))
+ self.infcx.tcx.mk_param(index, Symbol::intern(&name))
}
pub fn re_early_bound(&self, index: u32, name: &'static str) -> &'tcx ty::Region {
let rustc_version_str_len = rustc_version_str_len[0] as usize;
let mut buffer = Vec::with_capacity(rustc_version_str_len);
buffer.resize(rustc_version_str_len, 0);
- file.read_exact(&mut buffer[..])?;
+ file.read_exact(&mut buffer)?;
- if &buffer[..] != rustc_version().as_bytes() {
+ if buffer != rustc_version().as_bytes() {
report_format_mismatch(sess, path, "Different compiler version");
return Ok(None);
}
} else {
format!("{} `{}` should have a camel case name such as `{}`", sort, name, c)
};
- cx.span_lint(NON_CAMEL_CASE_TYPES, span, &m[..]);
+ cx.span_lint(NON_CAMEL_CASE_TYPES, span, &m);
}
}
}
attr.check_name("doc") &&
match attr.meta_item_list() {
None => false,
- Some(l) => attr::list_contains_name(&l[..], "hidden"),
+ Some(l) => attr::list_contains_name(&l, "hidden"),
}
});
self.doc_hidden_stack.push(doc_hidden);
ty::TyBool => return,
ty::TyAdt(def, _) => {
let attrs = cx.tcx.get_attrs(def.did);
- check_must_use(cx, &attrs[..], s.span)
+ check_must_use(cx, &attrs, s.span)
}
_ => false,
};
cfg.flag(flag);
}
- for component in &components[..] {
+ for component in &components {
let mut flag = String::from("-DLLVM_COMPONENT_");
flag.push_str(&component.to_uppercase());
cfg.flag(&flag);
if !is_crossed {
cmd.arg("--system-libs");
}
- cmd.args(&components[..]);
+ cmd.args(&components);
for lib in output(&mut cmd).split_whitespace() {
let name = if lib.starts_with("-l") {
name,
config::host_triple(),
self.sess.opts.target_triple);
- span_fatal!(self.sess, span, E0456, "{}", &message[..]);
+ span_fatal!(self.sess, span, E0456, "{}", &message);
}
let root = ekrate.metadata.get_root();
}
associated_item => { cdata.get_associated_item(def_id.index) }
impl_trait_ref => { cdata.get_impl_trait(def_id.index, tcx) }
- custom_coerce_unsized_kind => {
- cdata.get_custom_coerce_unsized_kind(def_id.index).unwrap_or_else(|| {
- bug!("custom_coerce_unsized_kind: `{:?}` is missing its kind", def_id);
+ coerce_unsized_info => {
+ cdata.get_coerce_unsized_info(def_id.index).unwrap_or_else(|| {
+ bug!("coerce_unsized_info: `{:?}` is missing its info", def_id);
})
}
mir => {
typeck_tables => { cdata.item_body_tables(def_id.index, tcx) }
closure_kind => { cdata.closure_kind(def_id.index) }
closure_type => { cdata.closure_ty(def_id.index, tcx) }
+ inherent_impls => { Rc::new(cdata.get_inherent_implementations_for_type(def_id.index)) }
}
impl CrateStore for cstore::CStore {
self.get_crate_data(did.krate).get_fn_arg_names(did.index)
}
- fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>
- {
- self.dep_graph.read(DepNode::MetaData(def_id));
- self.get_crate_data(def_id.krate).get_inherent_implementations_for_type(def_id.index)
- }
-
fn implementations_of_trait(&self, filter: Option<DefId>) -> Vec<DefId>
{
if let Some(def_id) = filter {
self.get_impl_data(id).polarity
}
- pub fn get_custom_coerce_unsized_kind(&self,
- id: DefIndex)
- -> Option<ty::adjustment::CustomCoerceUnsized> {
- self.get_impl_data(id).coerce_unsized_kind
+ pub fn get_coerce_unsized_info(&self,
+ id: DefIndex)
+ -> Option<ty::adjustment::CoerceUnsizedInfo> {
+ self.get_impl_data(id).coerce_unsized_info
}
pub fn get_impl_trait(&self,
let data = ImplData {
polarity: hir::ImplPolarity::Positive,
parent_impl: None,
- coerce_unsized_kind: None,
+ coerce_unsized_info: None,
trait_ref: tcx.impl_trait_ref(def_id).map(|trait_ref| self.lazy(&trait_ref)),
};
None
};
+ // if this is an impl of `CoerceUnsized`, create its
+ // "unsized info", else just store None
+ let coerce_unsized_info =
+ trait_ref.and_then(|t| {
+ if Some(t.def_id) == tcx.lang_items.coerce_unsized_trait() {
+ Some(ty::queries::coerce_unsized_info::get(tcx, item.span, def_id))
+ } else {
+ None
+ }
+ });
+
let data = ImplData {
polarity: polarity,
parent_impl: parent,
- coerce_unsized_kind: tcx.maps.custom_coerce_unsized_kind
- .borrow()
- .get(&def_id)
- .cloned(),
+ coerce_unsized_info: coerce_unsized_info,
trait_ref: trait_ref.map(|trait_ref| self.lazy(&trait_ref)),
};
self.encode_fields(def_id);
}
hir::ItemImpl(..) => {
- for &trait_item_def_id in &self.tcx.associated_item_def_ids(def_id)[..] {
+ for &trait_item_def_id in self.tcx.associated_item_def_ids(def_id).iter() {
self.record(trait_item_def_id,
EncodeContext::encode_info_for_impl_item,
trait_item_def_id);
}
}
hir::ItemTrait(..) => {
- for &item_def_id in &self.tcx.associated_item_def_ids(def_id)[..] {
+ for &item_def_id in self.tcx.associated_item_def_ids(def_id).iter() {
self.record(item_def_id,
EncodeContext::encode_info_for_trait_item,
item_def_id);
Some(file) => file,
};
let (hash, found_kind) =
- if file.starts_with(&rlib_prefix[..]) && file.ends_with(".rlib") {
+ if file.starts_with(&rlib_prefix) && file.ends_with(".rlib") {
(&file[(rlib_prefix.len())..(file.len() - ".rlib".len())], CrateFlavor::Rlib)
- } else if file.starts_with(&rlib_prefix[..]) && file.ends_with(".rmeta") {
+ } else if file.starts_with(&rlib_prefix) && file.ends_with(".rmeta") {
(&file[(rlib_prefix.len())..(file.len() - ".rmeta".len())], CrateFlavor::Rmeta)
} else if file.starts_with(&dylib_prefix) &&
file.ends_with(&dypair.1) {
(&file[(dylib_prefix.len())..(file.len() - dypair.1.len())], CrateFlavor::Dylib)
} else {
- if file.starts_with(&staticlib_prefix[..]) && file.ends_with(&staticpair.1) {
+ if file.starts_with(&staticlib_prefix) && file.ends_with(&staticpair.1) {
staticlibs.push(CrateMismatch {
path: path.to_path_buf(),
got: "static".to_string(),
pub struct ImplData<'tcx> {
pub polarity: hir::ImplPolarity,
pub parent_impl: Option<DefId>,
- pub coerce_unsized_kind: Option<ty::adjustment::CustomCoerceUnsized>,
+
+ /// This is `Some` only for impls of `CoerceUnsized`.
+ pub coerce_unsized_info: Option<ty::adjustment::CoerceUnsizedInfo>,
pub trait_ref: Option<Lazy<ty::TraitRef<'tcx>>>,
}
// inside this crate, so continue would spew "macro undefined"
// errors
Err(err) => {
- self.sess.span_fatal(span, &err[..])
+ self.sess.span_fatal(span, &err)
}
};
unsafe {
let registrar =
- match lib.symbol(&symbol[..]) {
+ match lib.symbol(&symbol) {
Ok(registrar) => {
mem::transmute::<*mut u8,PluginRegistrarFun>(registrar)
}
// again fatal if we can't register macros
Err(err) => {
- self.sess.span_fatal(span, &err[..])
+ self.sess.span_fatal(span, &err)
}
};
E0422: r##"
You are trying to use an identifier that is either undefined or not a struct.
Erroneous code example:
-``` compile_fail,E0422
+
+```compile_fail,E0422
fn main () {
let x = Foo { x: 1, y: 2 };
}
```
+
In this case, `Foo` is undefined, so it inherently isn't anything, and
definitely not a struct.
+
```compile_fail
fn main () {
let foo = 1;
let x = foo { x: 1, y: 2 };
}
```
+
In this case, `foo` is defined, but is not a struct, so Rust can't use it as
one.
"##,
fn is_local(&self) -> bool {
self.normal_ancestor_id.is_local()
}
+
+ fn nearest_item_scope(&'a self) -> Module<'a> {
+ if self.is_trait() { self.parent.unwrap() } else { self }
+ }
}
impl<'a> fmt::Debug for ModuleData<'a> {
expansion: mark,
};
expansion.visit_with(&mut visitor);
- self.current_module.unresolved_invocations.borrow_mut().remove(&mark);
invocation.expansion.set(visitor.legacy_scope);
}
Err(Determinacy::Determined)
},
};
- self.current_module.macro_resolutions.borrow_mut()
+ self.current_module.nearest_item_scope().macro_resolutions.borrow_mut()
.push((path.into_boxed_slice(), span));
return def;
}
}
};
- self.current_module.legacy_macro_resolutions.borrow_mut()
+ self.current_module.nearest_item_scope().legacy_macro_resolutions.borrow_mut()
.push((scope, path[0], span, kind));
result
let strs = pairs.map(|(f, v)| format!(",{},\"{}\"", f, escape(String::from(v))));
strs.fold(String::new(), |mut s, ss| {
- s.push_str(&ss[..]);
+ s.push_str(&ss);
s
})
}
use data::{self, VariableKind};
use dump::Dump;
-pub struct JsonDumper<'b, W: Write + 'b> {
- output: &'b mut W,
+pub struct JsonDumper<O: DumpOutput> {
result: Analysis,
+ output: O,
}
-impl<'b, W: Write> JsonDumper<'b, W> {
- pub fn new(writer: &'b mut W) -> JsonDumper<'b, W> {
- JsonDumper { output: writer, result: Analysis::new() }
- }
+pub trait DumpOutput {
+ fn dump(&mut self, result: &Analysis);
}
-impl<'b, W: Write> Drop for JsonDumper<'b, W> {
- fn drop(&mut self) {
- if let Err(_) = write!(self.output, "{}", as_json(&self.result)) {
+pub struct WriteOutput<'b, W: Write + 'b> {
+ output: &'b mut W,
+}
+
+impl<'b, W: Write> DumpOutput for WriteOutput<'b, W> {
+ fn dump(&mut self, result: &Analysis) {
+ if let Err(_) = write!(self.output, "{}", as_json(&result)) {
error!("Error writing output");
}
}
}
+pub struct CallbackOutput<'b> {
+ callback: &'b mut FnMut(&Analysis),
+}
+
+impl<'b> DumpOutput for CallbackOutput<'b> {
+ fn dump(&mut self, result: &Analysis) {
+ (self.callback)(result)
+ }
+}
+
+impl<'b, W: Write> JsonDumper<WriteOutput<'b, W>> {
+ pub fn new(writer: &'b mut W) -> JsonDumper<WriteOutput<'b, W>> {
+ JsonDumper { output: WriteOutput { output: writer }, result: Analysis::new() }
+ }
+}
+
+impl<'b> JsonDumper<CallbackOutput<'b>> {
+ pub fn with_callback(callback: &'b mut FnMut(&Analysis)) -> JsonDumper<CallbackOutput<'b>> {
+ JsonDumper { output: CallbackOutput { callback: callback }, result: Analysis::new() }
+ }
+}
+
+impl<O: DumpOutput> Drop for JsonDumper<O> {
+ fn drop(&mut self) {
+ self.output.dump(&self.result);
+ }
+}
+
macro_rules! impl_fn {
($fn_name: ident, $data_type: ident, $bucket: ident) => {
fn $fn_name(&mut self, data: $data_type) {
}
}
-impl<'b, W: Write + 'b> Dump for JsonDumper<'b, W> {
+impl<'b, O: DumpOutput + 'b> Dump for JsonDumper<O> {
fn crate_prelude(&mut self, data: CratePreludeData) {
self.result.prelude = Some(data)
}
use rustc::hir::map::Node;
use rustc::hir::def_id::DefId;
use rustc::session::config::CrateType::CrateTypeExecutable;
+use rustc::session::Session;
use rustc::ty::{self, TyCtxt};
use std::env;
}
}
-pub fn process_crate<'l, 'tcx>(tcx: TyCtxt<'l, 'tcx, 'tcx>,
- krate: &ast::Crate,
- analysis: &'l ty::CrateAnalysis,
- cratename: &str,
- odir: Option<&Path>,
- format: Format) {
- let _ignore = tcx.dep_graph.in_ignore();
+/// Defines what to do with the results of saving the analysis.
+pub trait SaveHandler {
+ fn save<'l, 'tcx>(&mut self,
+ save_ctxt: SaveContext<'l, 'tcx>,
+ krate: &ast::Crate,
+ cratename: &str);
+}
- assert!(analysis.glob_map.is_some());
+/// Dump the save-analysis results to a file.
+pub struct DumpHandler<'a> {
+ format: Format,
+ odir: Option<&'a Path>,
+ cratename: String
+}
- info!("Dumping crate {}", cratename);
+impl<'a> DumpHandler<'a> {
+ pub fn new(format: Format, odir: Option<&'a Path>, cratename: &str) -> DumpHandler<'a> {
+ DumpHandler {
+ format: format,
+ odir: odir,
+ cratename: cratename.to_owned()
+ }
+ }
- // find a path to dump our data to
- let mut root_path = match env::var_os("RUST_SAVE_ANALYSIS_FOLDER") {
- Some(val) => PathBuf::from(val),
- None => match odir {
- Some(val) => val.join("save-analysis"),
- None => PathBuf::from("save-analysis-temp"),
- },
- };
+ fn output_file(&self, sess: &Session) -> File {
+ let mut root_path = match env::var_os("RUST_SAVE_ANALYSIS_FOLDER") {
+ Some(val) => PathBuf::from(val),
+ None => match self.odir {
+ Some(val) => val.join("save-analysis"),
+ None => PathBuf::from("save-analysis-temp"),
+ },
+ };
- if let Err(e) = std::fs::create_dir_all(&root_path) {
- tcx.sess.err(&format!("Could not create directory {}: {}",
- root_path.display(),
- e));
+ if let Err(e) = std::fs::create_dir_all(&root_path) {
+ error!("Could not create directory {}: {}", root_path.display(), e);
+ }
+
+ {
+ let disp = root_path.display();
+ info!("Writing output to {}", disp);
+ }
+
+ let executable = sess.crate_types.borrow().iter().any(|ct| *ct == CrateTypeExecutable);
+ let mut out_name = if executable {
+ "".to_owned()
+ } else {
+ "lib".to_owned()
+ };
+ out_name.push_str(&self.cratename);
+ out_name.push_str(&sess.opts.cg.extra_filename);
+ out_name.push_str(self.format.extension());
+ root_path.push(&out_name);
+ let output_file = File::create(&root_path).unwrap_or_else(|e| {
+ let disp = root_path.display();
+ sess.fatal(&format!("Could not open {}: {}", disp, e));
+ });
+ root_path.pop();
+ output_file
}
+}
+
+impl<'a> SaveHandler for DumpHandler<'a> {
+ fn save<'l, 'tcx>(&mut self,
+ save_ctxt: SaveContext<'l, 'tcx>,
+ krate: &ast::Crate,
+ cratename: &str) {
+ macro_rules! dump {
+ ($new_dumper: expr) => {{
+ let mut dumper = $new_dumper;
+ let mut visitor = DumpVisitor::new(save_ctxt, &mut dumper);
+
+ visitor.dump_crate_info(cratename, krate);
+ visit::walk_crate(&mut visitor, krate);
+ }}
+ }
+
+ let output = &mut self.output_file(&save_ctxt.tcx.sess);
- {
- let disp = root_path.display();
- info!("Writing output to {}", disp);
+ match self.format {
+ Format::Csv => dump!(CsvDumper::new(output)),
+ Format::Json => dump!(JsonDumper::new(output)),
+ Format::JsonApi => dump!(JsonApiDumper::new(output)),
+ }
}
+}
- // Create output file.
- let executable = tcx.sess.crate_types.borrow().iter().any(|ct| *ct == CrateTypeExecutable);
- let mut out_name = if executable {
- "".to_owned()
- } else {
- "lib".to_owned()
- };
- out_name.push_str(&cratename);
- out_name.push_str(&tcx.sess.opts.cg.extra_filename);
- out_name.push_str(format.extension());
- root_path.push(&out_name);
- let mut output_file = File::create(&root_path).unwrap_or_else(|e| {
- let disp = root_path.display();
- tcx.sess.fatal(&format!("Could not open {}: {}", disp, e));
- });
- root_path.pop();
- let output = &mut output_file;
+/// Call a callback with the results of save-analysis.
+pub struct CallbackHandler<'b> {
+ pub callback: &'b mut FnMut(&rls_data::Analysis),
+}
+
+impl<'b> SaveHandler for CallbackHandler<'b> {
+ fn save<'l, 'tcx>(&mut self,
+ save_ctxt: SaveContext<'l, 'tcx>,
+ krate: &ast::Crate,
+ cratename: &str) {
+ macro_rules! dump {
+ ($new_dumper: expr) => {{
+ let mut dumper = $new_dumper;
+ let mut visitor = DumpVisitor::new(save_ctxt, &mut dumper);
+
+ visitor.dump_crate_info(cratename, krate);
+ visit::walk_crate(&mut visitor, krate);
+ }}
+ }
+
+ // We're using the JsonDumper here because it has the format of the
+ // save-analysis results that we will pass to the callback. IOW, we are
+ // using the JsonDumper to collect the save-analysis results, but not
+ // actually to dump them to a file. This is all a bit convoluted and
+ // there is certainly a simpler design here trying to get out (FIXME).
+ dump!(JsonDumper::with_callback(self.callback))
+ }
+}
+
+pub fn process_crate<'l, 'tcx, H: SaveHandler>(tcx: TyCtxt<'l, 'tcx, 'tcx>,
+ krate: &ast::Crate,
+ analysis: &'l ty::CrateAnalysis,
+ cratename: &str,
+ mut handler: H) {
+ let _ignore = tcx.dep_graph.in_ignore();
+
+ assert!(analysis.glob_map.is_some());
+
+ info!("Dumping crate {}", cratename);
let save_ctxt = SaveContext {
tcx: tcx,
span_utils: SpanUtils::new(&tcx.sess),
};
- macro_rules! dump {
- ($new_dumper: expr) => {{
- let mut dumper = $new_dumper;
- let mut visitor = DumpVisitor::new(save_ctxt, &mut dumper);
-
- visitor.dump_crate_info(cratename, krate);
- visit::walk_crate(&mut visitor, krate);
- }}
- }
-
- match format {
- Format::Csv => dump!(CsvDumper::new(output)),
- Format::Json => dump!(JsonDumper::new(output)),
- Format::JsonApi => dump!(JsonApiDumper::new(output)),
- }
+ handler.save(save_ctxt, krate, cratename)
}
// Utility functions for the module.
match sig.inputs().last().unwrap().sty {
ty::TyTuple(ref tupled_arguments, _) => {
inputs = &sig.inputs()[0..sig.inputs().len() - 1];
- &tupled_arguments[..]
+ &tupled_arguments
}
_ => {
bug!("argument to function with \"rust-call\" ABI \
variant_fill].iter().cloned().collect();
match name {
None => {
- Type::struct_(cx, &fields[..], false)
+ Type::struct_(cx, &fields, false)
}
Some(name) => {
let mut llty = Type::named_struct(cx, name);
- llty.set_struct_body(&fields[..], false);
+ llty.set_struct_body(&fields, false);
llty
}
}
alignment: Alignment,
) -> ValueRef {
let llptrptr = bcx.gepi(scrutinee,
- &discrfield.iter().map(|f| *f as usize).collect::<Vec<_>>()[..]);
+ &discrfield.iter().map(|f| *f as usize).collect::<Vec<_>>());
let llptr = bcx.load(llptrptr, alignment.to_align());
let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
bcx.icmp(cmp, llptr, C_null(val_ty(llptr)))
base::call_memset(bcx, llptr, fill_byte, size, align, false);
} else {
let path = discrfield.iter().map(|&i| i as usize).collect::<Vec<_>>();
- let llptrptr = bcx.gepi(val, &path[..]);
+ let llptrptr = bcx.gepi(val, &path);
let llptrty = val_ty(llptrptr).element_type();
bcx.store(C_null(llptrty), llptrptr, None);
}
.chain(arch_clobbers.iter().map(|s| s.to_string()))
.collect::<Vec<String>>().join(",");
- debug!("Asm Constraints: {}", &all_constraints[..]);
+ debug!("Asm Constraints: {}", &all_constraints);
// Depending on how many outputs we have, the return type is different
let num_outputs = output_types.len();
let output_type = match num_outputs {
0 => Type::void(bcx.ccx),
1 => output_types[0],
- _ => Type::struct_(bcx.ccx, &output_types[..], false)
+ _ => Type::struct_(bcx.ccx, &output_types, false)
};
let dialect = match ia.dialect {
for path in search_paths {
debug!("looking for {} inside {:?}", name, path);
- let test = path.join(&oslibname[..]);
+ let test = path.join(&oslibname);
if test.exists() { return test }
if oslibname != unixlibname {
- let test = path.join(&unixlibname[..]);
+ let test = path.join(&unixlibname);
if test.exists() { return test }
}
}
attrs: &[ast::Attribute],
input: &Input) -> String {
let validate = |s: String, span: Option<Span>| {
- cstore::validate_crate_name(sess, &s[..], span);
+ cstore::validate_crate_name(sess, &s, span);
s
};
let msg = format!("--crate-name and #[crate_name] are \
required to match, but `{}` != `{}`",
s, name);
- sess.span_err(attr.span, &msg[..]);
+ sess.span_err(attr.span, &msg);
}
}
return validate(s.clone(), None);
outputs: &OutputFilenames)
-> Vec<PathBuf> {
trans.modules.iter().map(|module| {
- outputs.temp_path(OutputType::Object, Some(&module.name[..]))
+ outputs.temp_path(OutputType::Object, Some(&module.name))
}).collect()
}
e))
}
- let bc_data_deflated = flate::deflate_bytes(&bc_data[..]);
+ let bc_data_deflated = flate::deflate_bytes(&bc_data);
let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) {
Ok(file) => file,
pname,
prog.status))
.note(&format!("{:?}", &cmd))
- .note(&escape_string(&output[..]))
+ .note(&escape_string(&output))
.emit();
sess.abort_if_errors();
}
- info!("linker stderr:\n{}", escape_string(&prog.stderr[..]));
- info!("linker stdout:\n{}", escape_string(&prog.stdout[..]));
+ info!("linker stderr:\n{}", escape_string(&prog.stderr));
+ info!("linker stdout:\n{}", escape_string(&prog.stdout));
},
Err(e) => {
sess.struct_err(&format!("could not exec the linker `{}`: {}", pname, e))
}
let export_threshold =
- symbol_export::crates_export_threshold(&sess.crate_types.borrow()[..]);
+ symbol_export::crates_export_threshold(&sess.crate_types.borrow());
let symbol_filter = &|&(ref name, level): &(String, _)| {
if symbol_export::is_below_threshold(level, export_threshold) {
bc_decoded.len() as libc::size_t) {
write::llvm_err(sess.diagnostic(),
format!("failed to load bc of `{}`",
- &name[..]));
+ name));
}
});
}
let libs = config.used_crates.clone();
let libs = libs.into_iter().filter_map(|(_, l)| l.option()).collect::<Vec<_>>();
- let rpaths = get_rpaths(config, &libs[..]);
- flags.extend_from_slice(&rpaths_to_flags(&rpaths[..]));
+ let rpaths = get_rpaths(config, &libs);
+ flags.extend_from_slice(&rpaths_to_flags(&rpaths));
// Use DT_RUNPATH instead of DT_RPATH if available
if config.linker_is_gnu {
}
}
- log_rpaths("relative", &rel_rpaths[..]);
- log_rpaths("fallback", &fallback_rpaths[..]);
+ log_rpaths("relative", &rel_rpaths);
+ log_rpaths("fallback", &fallback_rpaths);
let mut rpaths = rel_rpaths;
- rpaths.extend_from_slice(&fallback_rpaths[..]);
+ rpaths.extend_from_slice(&fallback_rpaths);
// Remove duplicates
- let rpaths = minimize_rpaths(&rpaths[..]);
+ let rpaths = minimize_rpaths(&rpaths);
return rpaths;
}
let mut set = HashSet::new();
let mut minimized = Vec::new();
for rpath in rpaths {
- if set.insert(&rpath[..]) {
+ if set.insert(rpath) {
minimized.push(rpath.clone());
}
}
cnum: CrateNum)
-> &[(String, SymbolExportLevel)] {
match self.exports.get(&cnum) {
- Some(exports) => &exports[..],
+ Some(exports) => exports,
None => &[]
}
}
{
for &(ref name, export_level) in self.exported_symbols(cnum) {
if is_below_threshold(export_level, export_threshold) {
- f(&name[..], export_level)
+ f(&name, export_level)
}
}
}
if !result.is_empty() &&
result.as_bytes()[0] != '_' as u8 &&
! (result.as_bytes()[0] as char).is_xid_start() {
- return format!("_{}", &result[..]);
+ return format!("_{}", result);
}
return result;
Some(ref code) => {
handler.emit_with_code(&MultiSpan::new(),
&diag.msg,
- &code[..],
+ &code,
diag.lvl);
},
None => {
let fdata_sections = ffunction_sections;
let code_model_arg = match sess.opts.cg.code_model {
- Some(ref s) => &s[..],
- None => &sess.target.target.options.code_model[..],
+ Some(ref s) => &s,
+ None => &sess.target.target.options.code_model,
};
let code_model = match CODE_GEN_MODEL_ARGS.iter().find(
let msg = llvm::build_string(|s| llvm::LLVMRustWriteSMDiagnosticToString(diag, s))
.expect("non-UTF8 SMDiagnostic");
- report_inline_asm(cgcx, &msg[..], cookie);
+ report_inline_asm(cgcx, &msg, cookie);
}
unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_void) {
if trans.modules.len() == 1 {
// 1) Only one codegen unit. In this case it's no difficulty
// to copy `foo.0.x` to `foo.x`.
- let module_name = Some(&(trans.modules[0].name)[..]);
+ let module_name = Some(&trans.modules[0].name[..]);
let path = crate_output.temp_path(output_type, module_name);
copy_gracefully(&path,
&crate_output.path(output_type));
if metadata_config.emit_bc && !user_wants_bitcode {
let path = crate_output.temp_path(OutputType::Bitcode,
- Some(&trans.metadata_module.name[..]));
+ Some(&trans.metadata_module.name));
remove(sess, &path);
}
}
n_bytes: ValueRef,
align: u32) {
let ccx = b.ccx;
- let ptr_width = &ccx.sess().target.target.target_pointer_width[..];
+ let ptr_width = &ccx.sess().target.target.target_pointer_width;
let key = format!("llvm.memcpy.p0i8.p0i8.i{}", ptr_width);
let memcpy = ccx.get_intrinsic(&key);
let src_ptr = b.pointercast(src, Type::i8p(ccx));
size: ValueRef,
align: ValueRef,
volatile: bool) -> ValueRef {
- let ptr_width = &b.ccx.sess().target.target.target_pointer_width[..];
+ let ptr_width = &b.ccx.sess().target.target.target_pointer_width;
let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
let llintrinsicfn = b.ccx.get_intrinsic(&intrinsic_key);
let volatile = C_bool(b.ccx, volatile);
let mut compressed = cstore.metadata_encoding_version().to_vec();
compressed.extend_from_slice(&flate::deflate_bytes(&metadata));
- let llmeta = C_bytes_in_context(cx.metadata_llcx(), &compressed[..]);
+ let llmeta = C_bytes_in_context(cx.metadata_llcx(), &compressed);
let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false);
let name = cx.metadata_symbol_name();
let buf = CString::new(name).unwrap();
symbol_map: &SymbolMap<'tcx>,
exported_symbols: &ExportedSymbols) {
let export_threshold =
- symbol_export::crates_export_threshold(&sess.crate_types.borrow()[..]);
+ symbol_export::crates_export_threshold(&sess.crate_types.borrow());
let exported_symbols = exported_symbols
.exported_symbols(LOCAL_CRATE)
(generics.parent_types == 0 && generics.types.is_empty()) &&
// Functions marked with #[inline] are only ever translated
// with "internal" linkage and are never exported.
- !attr::requests_inline(&attributes[..])
+ !attr::requests_inline(&attributes)
}
_ => false
cgus.dedup();
for &(ref cgu_name, linkage) in cgus.iter() {
output.push_str(" ");
- output.push_str(&cgu_name[..]);
+ output.push_str(&cgu_name);
let linkage_abbrev = match linkage {
llvm::Linkage::ExternalLinkage => "External",
} else {
let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::<Vec<ValueRef>>();
self.count_insn("gepi");
- self.inbounds_gep(base, &v[..])
+ self.inbounds_gep(base, &v)
}
}
let s = format!("{} ({})",
text,
self.ccx.sess().codemap().span_to_string(sp));
- debug!("{}", &s[..]);
- self.add_comment(&s[..]);
+ debug!("{}", s);
+ self.add_comment(&s);
}
}
match fulfill_obligation(scx, DUMMY_SP, trait_ref) {
traits::VtableImpl(traits::VtableImplData { impl_def_id, .. }) => {
- scx.tcx().custom_coerce_unsized_kind(impl_def_id)
+ scx.tcx().coerce_unsized_info(impl_def_id).custom_kind.unwrap()
}
vtable => {
bug!("invalid CoerceUnsized vtable: {:?}", vtable);
}
fn assemble_inherent_impl_candidates_for_type(&mut self, def_id: DefId) {
- // Read the inherent implementation candidates for this type from the
- // metadata if necessary.
- self.tcx.populate_inherent_implementations_for_type_if_necessary(self.span, def_id);
-
- if let Some(impl_infos) = self.tcx.maps.inherent_impls.borrow().get(&def_id) {
- for &impl_def_id in impl_infos.iter() {
- self.assemble_inherent_impl_probe(impl_def_id);
- }
+ let impl_def_ids = ty::queries::inherent_impls::get(self.tcx, self.span, def_id);
+ for &impl_def_id in impl_def_ids.iter() {
+ self.assemble_inherent_impl_probe(impl_def_id);
}
}
use dep_graph::DepNode;
use fmt_macros::{Parser, Piece, Position};
use hir::def::{Def, CtorKind};
-use hir::def_id::{DefId, LOCAL_CRATE};
+use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use rustc::infer::{self, InferCtxt, InferOk, RegionVariableOrigin, TypeTrace};
use rustc::infer::type_variable::{self, TypeVariableOrigin};
use rustc::ty::subst::{Kind, Subst, Substs};
}
pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CompileResult {
- return tcx.sess.track_errors(|| {
- tcx.dep_graph.with_task(DepNode::TypeckBodiesKrate, tcx, (), check_item_bodies_task);
- });
+ ty::queries::typeck_item_bodies::get(tcx, DUMMY_SP, LOCAL_CRATE)
+}
- fn check_item_bodies_task<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, (): ()) {
+fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) -> CompileResult {
+ debug_assert!(crate_num == LOCAL_CRATE);
+ tcx.sess.track_errors(|| {
tcx.visit_all_bodies_in_krate(|body_owner_def_id, _body_id| {
tcx.item_tables(body_owner_def_id);
});
- }
+ })
}
pub fn provide(providers: &mut Providers) {
*providers = Providers {
+ typeck_item_bodies,
typeck_tables,
closure_type,
closure_kind,
use rustc::ty::{self, Ty, TyCtxt};
use rustc::ty::ParameterEnvironment;
use rustc::ty::TypeFoldable;
+use rustc::ty::adjustment::CoerceUnsizedInfo;
use rustc::ty::subst::Subst;
use rustc::ty::util::CopyImplementationError;
use rustc::infer;
}
fn visit_implementation_of_coerce_unsized<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- coerce_unsized_trait: DefId,
+ _: DefId,
impl_did: DefId) {
debug!("visit_implementation_of_coerce_unsized: impl_did={:?}",
impl_did);
+ // Just compute this for the side-effects, in particular reporting
+ // errors; other parts of the code may demand it for the info of
+ // course.
+ if impl_did.is_local() {
+ let span = tcx.def_span(impl_did);
+ ty::queries::coerce_unsized_info::get(tcx, span, impl_did);
+ }
+}
+
+pub fn coerce_unsized_info<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ impl_did: DefId)
+ -> CoerceUnsizedInfo {
+ debug!("compute_coerce_unsized_info(impl_did={:?})", impl_did);
+ let coerce_unsized_trait = tcx.lang_items.coerce_unsized_trait().unwrap();
+
let unsize_trait = match tcx.lang_items.require(UnsizeTraitLangItem) {
Ok(id) => id,
Err(err) => {
}
};
- let impl_node_id = if let Some(n) = tcx.hir.as_local_node_id(impl_did) {
- n
- } else {
- debug!("visit_implementation_of_coerce_unsized(): impl not \
- in this crate");
- return;
- };
+ // this provider should only get invoked for local def-ids
+ let impl_node_id = tcx.hir.as_local_node_id(impl_did).unwrap_or_else(|| {
+ bug!("coerce_unsized_info: invoked for non-local def-id {:?}", impl_did)
+ });
let source = tcx.item_type(impl_did);
let trait_ref = tcx.impl_trait_ref(impl_did).unwrap();
+ assert_eq!(trait_ref.def_id, coerce_unsized_trait);
let target = trait_ref.substs.type_at(1);
debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (bound)",
source,
let target = target.subst(tcx, ¶m_env.free_substs);
assert!(!source.has_escaping_regions());
+ let err_info = CoerceUnsizedInfo { custom_kind: None };
+
debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (free)",
source,
target);
definition; expected {}, found {}",
source_path,
target_path);
- return;
+ return err_info;
}
let fields = &def_a.struct_variant().fields;
"the trait `CoerceUnsized` may only be implemented \
for a coercion between structures with one field \
being coerced, none found");
- return;
+ return err_info;
} else if diff_fields.len() > 1 {
let item = tcx.hir.expect_item(impl_node_id);
let span = if let ItemImpl(.., Some(ref t), _, _) = item.node {
.join(", ")));
err.span_label(span, &format!("requires multiple coercions"));
err.emit();
- return;
+ return err_info;
}
let (i, a, b) = diff_fields[0];
E0376,
"the trait `CoerceUnsized` may only be implemented \
for a coercion between structures");
- return;
+ return err_info;
}
};
.caller_bounds);
infcx.resolve_regions_and_report_errors(&free_regions, impl_node_id);
- if let Some(kind) = kind {
- tcx.maps.custom_coerce_unsized_kind.borrow_mut().insert(impl_did, kind);
+ CoerceUnsizedInfo {
+ custom_kind: kind
}
- });
+ })
}
+++ /dev/null
-// 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.
-
-use rustc::dep_graph::DepNode;
-use rustc::hir::def_id::DefId;
-use rustc::hir;
-use rustc::hir::itemlikevisit::ItemLikeVisitor;
-use rustc::lint;
-use rustc::traits::{self, Reveal};
-use rustc::ty::{self, TyCtxt};
-
-use syntax::ast;
-use syntax_pos::Span;
-
-struct InherentCollect<'a, 'tcx: 'a> {
- tcx: TyCtxt<'a, 'tcx, 'tcx>
-}
-
-impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for InherentCollect<'a, 'tcx> {
- fn visit_item(&mut self, item: &hir::Item) {
- let (unsafety, ty) = match item.node {
- hir::ItemImpl(unsafety, .., None, ref ty, _) => (unsafety, ty),
- _ => return
- };
-
- match unsafety {
- hir::Unsafety::Normal => {
- // OK
- }
- hir::Unsafety::Unsafe => {
- span_err!(self.tcx.sess,
- item.span,
- E0197,
- "inherent impls cannot be declared as unsafe");
- }
- }
-
- let def_id = self.tcx.hir.local_def_id(item.id);
- let self_ty = self.tcx.item_type(def_id);
- match self_ty.sty {
- ty::TyAdt(def, _) => {
- self.check_def_id(item, def.did);
- }
- ty::TyDynamic(ref data, ..) if data.principal().is_some() => {
- self.check_def_id(item, data.principal().unwrap().def_id());
- }
- ty::TyChar => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.char_impl(),
- "char",
- "char",
- item.span);
- }
- ty::TyStr => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.str_impl(),
- "str",
- "str",
- item.span);
- }
- ty::TySlice(_) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.slice_impl(),
- "slice",
- "[T]",
- item.span);
- }
- ty::TyRawPtr(ty::TypeAndMut { ty: _, mutbl: hir::MutImmutable }) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.const_ptr_impl(),
- "const_ptr",
- "*const T",
- item.span);
- }
- ty::TyRawPtr(ty::TypeAndMut { ty: _, mutbl: hir::MutMutable }) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.mut_ptr_impl(),
- "mut_ptr",
- "*mut T",
- item.span);
- }
- ty::TyInt(ast::IntTy::I8) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.i8_impl(),
- "i8",
- "i8",
- item.span);
- }
- ty::TyInt(ast::IntTy::I16) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.i16_impl(),
- "i16",
- "i16",
- item.span);
- }
- ty::TyInt(ast::IntTy::I32) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.i32_impl(),
- "i32",
- "i32",
- item.span);
- }
- ty::TyInt(ast::IntTy::I64) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.i64_impl(),
- "i64",
- "i64",
- item.span);
- }
- ty::TyInt(ast::IntTy::I128) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.i128_impl(),
- "i128",
- "i128",
- item.span);
- }
- ty::TyInt(ast::IntTy::Is) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.isize_impl(),
- "isize",
- "isize",
- item.span);
- }
- ty::TyUint(ast::UintTy::U8) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.u8_impl(),
- "u8",
- "u8",
- item.span);
- }
- ty::TyUint(ast::UintTy::U16) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.u16_impl(),
- "u16",
- "u16",
- item.span);
- }
- ty::TyUint(ast::UintTy::U32) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.u32_impl(),
- "u32",
- "u32",
- item.span);
- }
- ty::TyUint(ast::UintTy::U64) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.u64_impl(),
- "u64",
- "u64",
- item.span);
- }
- ty::TyUint(ast::UintTy::U128) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.u128_impl(),
- "u128",
- "u128",
- item.span);
- }
- ty::TyUint(ast::UintTy::Us) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.usize_impl(),
- "usize",
- "usize",
- item.span);
- }
- ty::TyFloat(ast::FloatTy::F32) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.f32_impl(),
- "f32",
- "f32",
- item.span);
- }
- ty::TyFloat(ast::FloatTy::F64) => {
- self.check_primitive_impl(def_id,
- self.tcx.lang_items.f64_impl(),
- "f64",
- "f64",
- item.span);
- }
- ty::TyError => {
- return;
- }
- _ => {
- struct_span_err!(self.tcx.sess,
- ty.span,
- E0118,
- "no base type found for inherent implementation")
- .span_label(ty.span, &format!("impl requires a base type"))
- .note(&format!("either implement a trait on it or create a newtype \
- to wrap it instead"))
- .emit();
- return;
- }
- }
- }
-
- fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) {
- }
-
- fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) {
- }
-}
-
-impl<'a, 'tcx> InherentCollect<'a, 'tcx> {
- fn check_def_id(&self, item: &hir::Item, def_id: DefId) {
- if def_id.is_local() {
- // Add the implementation to the mapping from implementation to base
- // type def ID, if there is a base type for this implementation and
- // the implementation does not have any associated traits.
- let impl_def_id = self.tcx.hir.local_def_id(item.id);
-
- // Subtle: it'd be better to collect these into a local map
- // and then write the vector only once all items are known,
- // but that leads to degenerate dep-graphs. The problem is
- // that the write of that big vector winds up having reads
- // from *all* impls in the krate, since we've lost the
- // precision basically. This would be ok in the firewall
- // model so once we've made progess towards that we can modify
- // the strategy here. In the meantime, using `push` is ok
- // because we are doing this as a pre-pass before anyone
- // actually reads from `inherent_impls` -- and we know this is
- // true beacuse we hold the refcell lock.
- self.tcx.maps.inherent_impls.borrow_mut().push(def_id, impl_def_id);
- } else {
- struct_span_err!(self.tcx.sess,
- item.span,
- E0116,
- "cannot define inherent `impl` for a type outside of the crate \
- where the type is defined")
- .span_label(item.span,
- &format!("impl for type defined outside of crate."))
- .note("define and implement a trait or new type instead")
- .emit();
- }
- }
-
- fn check_primitive_impl(&self,
- impl_def_id: DefId,
- lang_def_id: Option<DefId>,
- lang: &str,
- ty: &str,
- span: Span) {
- match lang_def_id {
- Some(lang_def_id) if lang_def_id == impl_def_id => {
- // OK
- }
- _ => {
- struct_span_err!(self.tcx.sess,
- span,
- E0390,
- "only a single inherent implementation marked with `#[lang = \
- \"{}\"]` is allowed for the `{}` primitive",
- lang,
- ty)
- .span_help(span, "consider using a trait to implement these methods")
- .emit();
- }
- }
- }
-}
-
-struct InherentOverlapChecker<'a, 'tcx: 'a> {
- tcx: TyCtxt<'a, 'tcx, 'tcx>
-}
-
-impl<'a, 'tcx> InherentOverlapChecker<'a, 'tcx> {
- fn check_for_common_items_in_impls(&self, impl1: DefId, impl2: DefId) {
- #[derive(Copy, Clone, PartialEq)]
- enum Namespace {
- Type,
- Value,
- }
-
- let name_and_namespace = |def_id| {
- let item = self.tcx.associated_item(def_id);
- (item.name, match item.kind {
- ty::AssociatedKind::Type => Namespace::Type,
- ty::AssociatedKind::Const |
- ty::AssociatedKind::Method => Namespace::Value,
- })
- };
-
- let impl_items1 = self.tcx.associated_item_def_ids(impl1);
- let impl_items2 = self.tcx.associated_item_def_ids(impl2);
-
- for &item1 in &impl_items1[..] {
- let (name, namespace) = name_and_namespace(item1);
-
- for &item2 in &impl_items2[..] {
- if (name, namespace) == name_and_namespace(item2) {
- let msg = format!("duplicate definitions with name `{}`", name);
- let node_id = self.tcx.hir.as_local_node_id(item1).unwrap();
- self.tcx.sess.add_lint(lint::builtin::OVERLAPPING_INHERENT_IMPLS,
- node_id,
- self.tcx.span_of_impl(item1).unwrap(),
- msg);
- }
- }
- }
- }
-
- fn check_for_overlapping_inherent_impls(&self, ty_def_id: DefId) {
- let _task = self.tcx.dep_graph.in_task(DepNode::CoherenceOverlapInherentCheck(ty_def_id));
-
- let inherent_impls = self.tcx.maps.inherent_impls.borrow();
- let impls = match inherent_impls.get(&ty_def_id) {
- Some(impls) => impls,
- None => return,
- };
-
- for (i, &impl1_def_id) in impls.iter().enumerate() {
- for &impl2_def_id in &impls[(i + 1)..] {
- self.tcx.infer_ctxt((), Reveal::UserFacing).enter(|infcx| {
- if traits::overlapping_impls(&infcx, impl1_def_id, impl2_def_id).is_some() {
- self.check_for_common_items_in_impls(impl1_def_id, impl2_def_id)
- }
- });
- }
- }
- }
-}
-
-impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for InherentOverlapChecker<'a, 'tcx> {
- fn visit_item(&mut self, item: &'v hir::Item) {
- match item.node {
- hir::ItemEnum(..) |
- hir::ItemStruct(..) |
- hir::ItemTrait(..) |
- hir::ItemUnion(..) => {
- let type_def_id = self.tcx.hir.local_def_id(item.id);
- self.check_for_overlapping_inherent_impls(type_def_id);
- }
- _ => {}
- }
- }
-
- fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) {
- }
-
- fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) {
- }
-}
-
-pub fn check<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- tcx.visit_all_item_likes_in_krate(DepNode::CoherenceCheckImpl,
- &mut InherentCollect { tcx });
- tcx.visit_all_item_likes_in_krate(DepNode::CoherenceOverlapCheckSpecial,
- &mut InherentOverlapChecker { tcx });
-}
--- /dev/null
+// 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.
+
+//! The code in this module gathers up all of the inherent impls in
+//! the current crate and organizes them in a map. It winds up
+//! touching the whole crate and thus must be recomputed completely
+//! for any change, but it is very cheap to compute. In practice, most
+//! code in the compiler never *directly* requests this map. Instead,
+//! it requests the inherent impls specific to some type (via
+//! `ty::queries::inherent_impls::get(def_id)`). That value, however,
+//! is computed by selecting an idea from this table.
+
+use rustc::dep_graph::DepNode;
+use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
+use rustc::hir;
+use rustc::hir::itemlikevisit::ItemLikeVisitor;
+use rustc::ty::{self, CrateInherentImpls, TyCtxt};
+use rustc::util::nodemap::DefIdMap;
+
+use std::rc::Rc;
+use syntax::ast;
+use syntax_pos::{DUMMY_SP, Span};
+
+/// On-demand query: yields a map containing all types mapped to their inherent impls.
+pub fn crate_inherent_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ crate_num: CrateNum)
+ -> CrateInherentImpls {
+ assert_eq!(crate_num, LOCAL_CRATE);
+
+ let krate = tcx.hir.krate();
+ let mut collect = InherentCollect {
+ tcx,
+ impls_map: CrateInherentImpls {
+ inherent_impls: DefIdMap()
+ }
+ };
+ krate.visit_all_item_likes(&mut collect);
+ collect.impls_map
+}
+
+/// On-demand query: yields a vector of the inherent impls for a specific type.
+pub fn inherent_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ ty_def_id: DefId)
+ -> Rc<Vec<DefId>> {
+ assert!(ty_def_id.is_local());
+
+ // NB. Until we adopt the red-green dep-tracking algorithm (see
+ // [the plan] for details on that), we do some hackery here to get
+ // the dependencies correct. Basically, we use a `with_ignore` to
+ // read the result we want. If we didn't have the `with_ignore`,
+ // we would wind up with a dependency on the entire crate, which
+ // we don't want. Then we go and add dependencies on all the impls
+ // in the result (which is what we wanted).
+ //
+ // The result is a graph with an edge from `Hir(I)` for every impl
+ // `I` defined on some type `T` to `CoherentInherentImpls(T)`,
+ // thus ensuring that if any of those impls change, the set of
+ // inherent impls is considered dirty.
+ //
+ // [the plan]: https://github.com/rust-lang/rust-roadmap/issues/4
+
+ let result = tcx.dep_graph.with_ignore(|| {
+ let crate_map = ty::queries::crate_inherent_impls::get(tcx, DUMMY_SP, ty_def_id.krate);
+ match crate_map.inherent_impls.get(&ty_def_id) {
+ Some(v) => v.clone(),
+ None => Rc::new(vec![]),
+ }
+ });
+
+ for &impl_def_id in &result[..] {
+ tcx.dep_graph.read(DepNode::Hir(impl_def_id));
+ }
+
+ result
+}
+
+struct InherentCollect<'a, 'tcx: 'a> {
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ impls_map: CrateInherentImpls,
+}
+
+impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for InherentCollect<'a, 'tcx> {
+ fn visit_item(&mut self, item: &hir::Item) {
+ let (unsafety, ty) = match item.node {
+ hir::ItemImpl(unsafety, .., None, ref ty, _) => (unsafety, ty),
+ _ => return
+ };
+
+ match unsafety {
+ hir::Unsafety::Normal => {
+ // OK
+ }
+ hir::Unsafety::Unsafe => {
+ span_err!(self.tcx.sess,
+ item.span,
+ E0197,
+ "inherent impls cannot be declared as unsafe");
+ }
+ }
+
+ let def_id = self.tcx.hir.local_def_id(item.id);
+ let self_ty = self.tcx.item_type(def_id);
+ match self_ty.sty {
+ ty::TyAdt(def, _) => {
+ self.check_def_id(item, def.did);
+ }
+ ty::TyDynamic(ref data, ..) if data.principal().is_some() => {
+ self.check_def_id(item, data.principal().unwrap().def_id());
+ }
+ ty::TyChar => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.char_impl(),
+ "char",
+ "char",
+ item.span);
+ }
+ ty::TyStr => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.str_impl(),
+ "str",
+ "str",
+ item.span);
+ }
+ ty::TySlice(_) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.slice_impl(),
+ "slice",
+ "[T]",
+ item.span);
+ }
+ ty::TyRawPtr(ty::TypeAndMut { ty: _, mutbl: hir::MutImmutable }) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.const_ptr_impl(),
+ "const_ptr",
+ "*const T",
+ item.span);
+ }
+ ty::TyRawPtr(ty::TypeAndMut { ty: _, mutbl: hir::MutMutable }) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.mut_ptr_impl(),
+ "mut_ptr",
+ "*mut T",
+ item.span);
+ }
+ ty::TyInt(ast::IntTy::I8) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.i8_impl(),
+ "i8",
+ "i8",
+ item.span);
+ }
+ ty::TyInt(ast::IntTy::I16) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.i16_impl(),
+ "i16",
+ "i16",
+ item.span);
+ }
+ ty::TyInt(ast::IntTy::I32) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.i32_impl(),
+ "i32",
+ "i32",
+ item.span);
+ }
+ ty::TyInt(ast::IntTy::I64) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.i64_impl(),
+ "i64",
+ "i64",
+ item.span);
+ }
+ ty::TyInt(ast::IntTy::I128) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.i128_impl(),
+ "i128",
+ "i128",
+ item.span);
+ }
+ ty::TyInt(ast::IntTy::Is) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.isize_impl(),
+ "isize",
+ "isize",
+ item.span);
+ }
+ ty::TyUint(ast::UintTy::U8) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.u8_impl(),
+ "u8",
+ "u8",
+ item.span);
+ }
+ ty::TyUint(ast::UintTy::U16) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.u16_impl(),
+ "u16",
+ "u16",
+ item.span);
+ }
+ ty::TyUint(ast::UintTy::U32) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.u32_impl(),
+ "u32",
+ "u32",
+ item.span);
+ }
+ ty::TyUint(ast::UintTy::U64) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.u64_impl(),
+ "u64",
+ "u64",
+ item.span);
+ }
+ ty::TyUint(ast::UintTy::U128) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.u128_impl(),
+ "u128",
+ "u128",
+ item.span);
+ }
+ ty::TyUint(ast::UintTy::Us) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.usize_impl(),
+ "usize",
+ "usize",
+ item.span);
+ }
+ ty::TyFloat(ast::FloatTy::F32) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.f32_impl(),
+ "f32",
+ "f32",
+ item.span);
+ }
+ ty::TyFloat(ast::FloatTy::F64) => {
+ self.check_primitive_impl(def_id,
+ self.tcx.lang_items.f64_impl(),
+ "f64",
+ "f64",
+ item.span);
+ }
+ ty::TyError => {
+ return;
+ }
+ _ => {
+ struct_span_err!(self.tcx.sess,
+ ty.span,
+ E0118,
+ "no base type found for inherent implementation")
+ .span_label(ty.span, &format!("impl requires a base type"))
+ .note(&format!("either implement a trait on it or create a newtype \
+ to wrap it instead"))
+ .emit();
+ return;
+ }
+ }
+ }
+
+ fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) {
+ }
+
+ fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) {
+ }
+}
+
+impl<'a, 'tcx> InherentCollect<'a, 'tcx> {
+ fn check_def_id(&mut self, item: &hir::Item, def_id: DefId) {
+ if def_id.is_local() {
+ // Add the implementation to the mapping from implementation to base
+ // type def ID, if there is a base type for this implementation and
+ // the implementation does not have any associated traits.
+ let impl_def_id = self.tcx.hir.local_def_id(item.id);
+ let mut rc_vec = self.impls_map.inherent_impls
+ .entry(def_id)
+ .or_insert_with(|| Rc::new(vec![]));
+
+ // At this point, there should not be any clones of the
+ // `Rc`, so we can still safely push into it in place:
+ Rc::get_mut(&mut rc_vec).unwrap().push(impl_def_id);
+ } else {
+ struct_span_err!(self.tcx.sess,
+ item.span,
+ E0116,
+ "cannot define inherent `impl` for a type outside of the crate \
+ where the type is defined")
+ .span_label(item.span,
+ &format!("impl for type defined outside of crate."))
+ .note("define and implement a trait or new type instead")
+ .emit();
+ }
+ }
+
+ fn check_primitive_impl(&self,
+ impl_def_id: DefId,
+ lang_def_id: Option<DefId>,
+ lang: &str,
+ ty: &str,
+ span: Span) {
+ match lang_def_id {
+ Some(lang_def_id) if lang_def_id == impl_def_id => {
+ // OK
+ }
+ _ => {
+ struct_span_err!(self.tcx.sess,
+ span,
+ E0390,
+ "only a single inherent implementation marked with `#[lang = \
+ \"{}\"]` is allowed for the `{}` primitive",
+ lang,
+ ty)
+ .span_help(span, "consider using a trait to implement these methods")
+ .emit();
+ }
+ }
+ }
+}
+
--- /dev/null
+// 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.
+
+use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
+use rustc::hir;
+use rustc::hir::itemlikevisit::ItemLikeVisitor;
+use rustc::lint;
+use rustc::traits::{self, Reveal};
+use rustc::ty::{self, TyCtxt};
+
+use syntax_pos::DUMMY_SP;
+
+pub fn crate_inherent_impls_overlap_check<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ crate_num: CrateNum) {
+ assert_eq!(crate_num, LOCAL_CRATE);
+ let krate = tcx.hir.krate();
+ krate.visit_all_item_likes(&mut InherentOverlapChecker { tcx });
+}
+
+struct InherentOverlapChecker<'a, 'tcx: 'a> {
+ tcx: TyCtxt<'a, 'tcx, 'tcx>
+}
+
+impl<'a, 'tcx> InherentOverlapChecker<'a, 'tcx> {
+ fn check_for_common_items_in_impls(&self, impl1: DefId, impl2: DefId) {
+ #[derive(Copy, Clone, PartialEq)]
+ enum Namespace {
+ Type,
+ Value,
+ }
+
+ let name_and_namespace = |def_id| {
+ let item = self.tcx.associated_item(def_id);
+ (item.name, match item.kind {
+ ty::AssociatedKind::Type => Namespace::Type,
+ ty::AssociatedKind::Const |
+ ty::AssociatedKind::Method => Namespace::Value,
+ })
+ };
+
+ let impl_items1 = self.tcx.associated_item_def_ids(impl1);
+ let impl_items2 = self.tcx.associated_item_def_ids(impl2);
+
+ for &item1 in &impl_items1[..] {
+ let (name, namespace) = name_and_namespace(item1);
+
+ for &item2 in &impl_items2[..] {
+ if (name, namespace) == name_and_namespace(item2) {
+ let msg = format!("duplicate definitions with name `{}`", name);
+ let node_id = self.tcx.hir.as_local_node_id(item1).unwrap();
+ self.tcx.sess.add_lint(lint::builtin::OVERLAPPING_INHERENT_IMPLS,
+ node_id,
+ self.tcx.span_of_impl(item1).unwrap(),
+ msg);
+ }
+ }
+ }
+ }
+
+ fn check_for_overlapping_inherent_impls(&self, ty_def_id: DefId) {
+ let impls = ty::queries::inherent_impls::get(self.tcx, DUMMY_SP, ty_def_id);
+
+ for (i, &impl1_def_id) in impls.iter().enumerate() {
+ for &impl2_def_id in &impls[(i + 1)..] {
+ self.tcx.infer_ctxt((), Reveal::UserFacing).enter(|infcx| {
+ if traits::overlapping_impls(&infcx, impl1_def_id, impl2_def_id).is_some() {
+ self.check_for_common_items_in_impls(impl1_def_id, impl2_def_id)
+ }
+ });
+ }
+ }
+ }
+}
+
+impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for InherentOverlapChecker<'a, 'tcx> {
+ fn visit_item(&mut self, item: &'v hir::Item) {
+ match item.node {
+ hir::ItemEnum(..) |
+ hir::ItemStruct(..) |
+ hir::ItemTrait(..) |
+ hir::ItemUnion(..) => {
+ let type_def_id = self.tcx.hir.local_def_id(item.id);
+ self.check_for_overlapping_inherent_impls(type_def_id);
+ }
+ _ => {}
+ }
+ }
+
+ fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) {
+ }
+
+ fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) {
+ }
+}
+
use syntax_pos::DUMMY_SP;
mod builtin;
-mod inherent;
+mod inherent_impls;
+mod inherent_impls_overlap;
mod orphan;
mod overlap;
mod unsafety;
}
pub fn provide(providers: &mut Providers) {
+ use self::builtin::coerce_unsized_info;
+ use self::inherent_impls::{crate_inherent_impls, inherent_impls};
+ use self::inherent_impls_overlap::crate_inherent_impls_overlap_check;
+
*providers = Providers {
coherent_trait,
- coherent_inherent_impls,
+ crate_inherent_impls,
+ inherent_impls,
+ crate_inherent_impls_overlap_check,
+ coerce_unsized_info,
..*providers
};
}
builtin::check_trait(tcx, def_id);
}
-fn coherent_inherent_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, _: CrateNum) {
- inherent::check(tcx);
-}
-
pub fn check_coherence<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
let _task = tcx.dep_graph.in_task(DepNode::Coherence);
for &trait_def_id in tcx.hir.krate().trait_impls.keys() {
orphan::check(tcx);
overlap::check_default_impls(tcx);
- ty::queries::coherent_inherent_impls::get(tcx, DUMMY_SP, LOCAL_CRATE);
+ // these queries are executed for side-effects (error reporting):
+ ty::queries::crate_inherent_impls::get(tcx, DUMMY_SP, LOCAL_CRATE);
+ ty::queries::crate_inherent_impls_overlap_check::get(tcx, DUMMY_SP, LOCAL_CRATE);
}
and [RFC 809] for more details.
[RFC 470]: https://github.com/rust-lang/rfcs/pull/470
-[RFC 809]: https://github.com/rust-lang/rfcs/pull/809
+[RFC 809]: https://github.com/rust-lang/rfcs/blob/master/text/0809-box-and-in-for-stdlib.md
"##,
E0067: r##"
```
Note that type parameters for enum-variant constructors go after the variant,
-not after the enum (Option::None::<u32>, not Option::<u32>::None).
+not after the enum (`Option::None::<u32>`, not `Option::<u32>::None`).
"##,
E0110: r##"
For information on the design of the orphan rules, see [RFC 1023].
-[RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
+[RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md
"##,
E0118: r##"
E0192: r##"
Negative impls are only allowed for traits with default impls. For more
-information see the [opt-in builtin traits RFC](https://github.com/rust-lang/
-rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
+information see the [opt-in builtin traits RFC][RFC 19].
+
+[RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
"##,
E0193: r##"
Inherent associated types were part of [RFC 195] but are not yet implemented.
See [the tracking issue][iss8995] for the status of this implementation.
-[RFC 195]: https://github.com/rust-lang/rfcs/pull/195
+[RFC 195]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md
[iss8995]: https://github.com/rust-lang/rust/issues/8995
"##,
For information on the design of the orphan rules, see [RFC 1023].
-[RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
+[RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md
"##,
/*
E0318: r##"
Default impls for a trait must be located in the same crate where the trait was
-defined. For more information see the [opt-in builtin traits RFC](https://github
-.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
+defined. For more information see the [opt-in builtin traits RFC][RFC 19].
+
+[RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
"##,
E0321: r##"
```
If you are defining your own smart pointer type and would like to enable
-conversion from a sized to an unsized type with the [DST coercion system]
-(https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md), use
-[`CoerceUnsized`](https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html)
-instead.
+conversion from a sized to an unsized type with the
+[DST coercion system][RFC 982], use [`CoerceUnsized`] instead.
```
#![feature(coerce_unsized)]
impl<T, U> CoerceUnsized<MyType<U>> for MyType<T>
where T: CoerceUnsized<U> {}
```
+
+[RFC 982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
+[`CoerceUnsized`]: https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html
"##,
E0329: r##"
E0380: r##"
Default impls are only allowed for traits with no methods or associated items.
-For more information see the [opt-in builtin traits RFC](https://github.com/rust
--lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
+For more information see the [opt-in builtin traits RFC][RFC 19].
+
+[RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
"##,
E0390: r##"
authors = ["The Rust Project Developers"]
name = "rustdoc"
version = "0.0.0"
-build = "build.rs"
[lib]
name = "rustdoc"
serialize = { path = "../libserialize" }
syntax = { path = "../libsyntax" }
syntax_pos = { path = "../libsyntax_pos" }
+pulldown-cmark = { version = "0.0.14", default-features = false }
[build-dependencies]
build_helper = { path = "../build_helper" }
+++ /dev/null
-// Copyright 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.
-
-extern crate build_helper;
-extern crate gcc;
-
-fn main() {
- let src_dir = std::path::Path::new("../rt/hoedown/src");
- build_helper::rerun_if_changed_anything_in_dir(src_dir);
- let mut cfg = gcc::Config::new();
- cfg.file("../rt/hoedown/src/autolink.c")
- .file("../rt/hoedown/src/buffer.c")
- .file("../rt/hoedown/src/document.c")
- .file("../rt/hoedown/src/escape.c")
- .file("../rt/hoedown/src/html.c")
- .file("../rt/hoedown/src/html_blocks.c")
- .file("../rt/hoedown/src/html_smartypants.c")
- .file("../rt/hoedown/src/stack.c")
- .file("../rt/hoedown/src/version.c")
- .include(src_dir)
- .compile("libhoedown.a");
-}
pub fn build_impls(cx: &DocContext, did: DefId) -> Vec<clean::Item> {
let tcx = cx.tcx;
- tcx.populate_inherent_implementations_for_type_if_necessary(DUMMY_SP, did);
let mut impls = Vec::new();
- if let Some(i) = tcx.maps.inherent_impls.borrow().get(&did) {
- for &did in i.iter() {
- build_impl(cx, did, &mut impls);
- }
+ for &did in ty::queries::inherent_impls::get(tcx, DUMMY_SP, did).iter() {
+ build_impl(cx, did, &mut impls);
}
+
// If this is the first time we've inlined something from another crate, then
// we inline *all* impls from all the crates into this crate. Note that there's
// currently no way for us to filter this based on type, and we likely need
//! Markdown formatting for rustdoc
//!
-//! This module implements markdown formatting through the hoedown C-library
-//! (bundled into the rust runtime). This module self-contains the C bindings
-//! and necessary legwork to render markdown, and exposes all of the
+//! This module implements markdown formatting through the pulldown-cmark
+//! rust-library. This module exposes all of the
//! functionality through a unit-struct, `Markdown`, which has an implementation
//! of `fmt::Display`. Example usage:
//!
//! ```rust,ignore
-//! use rustdoc::html::markdown::Markdown;
+//! use rustdoc::html::markdown::{Markdown, MarkdownOutputStyle};
//!
//! let s = "My *markdown* _text_";
-//! let html = format!("{}", Markdown(s));
+//! let html = format!("{}", Markdown(s, MarkdownOutputStyle::Fancy));
//! // ... something using html
//! ```
#![allow(non_camel_case_types)]
-use libc;
use std::ascii::AsciiExt;
use std::cell::RefCell;
use std::default::Default;
-use std::ffi::CString;
use std::fmt::{self, Write};
-use std::slice;
use std::str;
use syntax::feature_gate::UnstableFeatures;
use syntax::codemap::Span;
use html::escape::Escape;
use test;
+use pulldown_cmark::{self, Event, Parser, Tag};
+
+#[derive(Copy, Clone)]
+pub enum MarkdownOutputStyle {
+ Compact,
+ Fancy,
+}
+
+impl MarkdownOutputStyle {
+ pub fn is_compact(&self) -> bool {
+ match *self {
+ MarkdownOutputStyle::Compact => true,
+ _ => false,
+ }
+ }
+
+ pub fn is_fancy(&self) -> bool {
+ match *self {
+ MarkdownOutputStyle::Fancy => true,
+ _ => false,
+ }
+ }
+}
+
/// A unit struct which has the `fmt::Display` trait implemented. When
/// formatted, this struct will emit the HTML corresponding to the rendered
/// version of the contained markdown string.
-pub struct Markdown<'a>(pub &'a str);
+// The second parameter is whether we need a shorter version or not.
+pub struct Markdown<'a>(pub &'a str, pub MarkdownOutputStyle);
/// A unit struct like `Markdown`, that renders the markdown with a
/// table of contents.
pub struct MarkdownWithToc<'a>(pub &'a str);
/// A unit struct like `Markdown`, that renders the markdown escaping HTML tags.
pub struct MarkdownHtml<'a>(pub &'a str);
-const DEF_OUNIT: libc::size_t = 64;
-const HOEDOWN_EXT_NO_INTRA_EMPHASIS: libc::c_uint = 1 << 11;
-const HOEDOWN_EXT_TABLES: libc::c_uint = 1 << 0;
-const HOEDOWN_EXT_FENCED_CODE: libc::c_uint = 1 << 1;
-const HOEDOWN_EXT_AUTOLINK: libc::c_uint = 1 << 3;
-const HOEDOWN_EXT_STRIKETHROUGH: libc::c_uint = 1 << 4;
-const HOEDOWN_EXT_SUPERSCRIPT: libc::c_uint = 1 << 8;
-const HOEDOWN_EXT_FOOTNOTES: libc::c_uint = 1 << 2;
-const HOEDOWN_HTML_ESCAPE: libc::c_uint = 1 << 1;
-
-const HOEDOWN_EXTENSIONS: libc::c_uint =
- HOEDOWN_EXT_NO_INTRA_EMPHASIS | HOEDOWN_EXT_TABLES |
- HOEDOWN_EXT_FENCED_CODE | HOEDOWN_EXT_AUTOLINK |
- HOEDOWN_EXT_STRIKETHROUGH | HOEDOWN_EXT_SUPERSCRIPT |
- HOEDOWN_EXT_FOOTNOTES;
-
-enum hoedown_document {}
-
-type blockcodefn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_buffer, *const hoedown_renderer_data,
- libc::size_t);
-
-type blockquotefn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_renderer_data, libc::size_t);
-
-type headerfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
- libc::c_int, *const hoedown_renderer_data,
- libc::size_t);
-
-type blockhtmlfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_renderer_data, libc::size_t);
-
-type codespanfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_renderer_data, libc::size_t) -> libc::c_int;
-
-type linkfn = extern "C" fn (*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_buffer, *const hoedown_buffer,
- *const hoedown_renderer_data, libc::size_t) -> libc::c_int;
-
-type entityfn = extern "C" fn (*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_renderer_data, libc::size_t);
-
-type normaltextfn = extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_renderer_data, libc::size_t);
-
-#[repr(C)]
-struct hoedown_renderer_data {
- opaque: *mut libc::c_void,
-}
-
-#[repr(C)]
-struct hoedown_renderer {
- opaque: *mut libc::c_void,
-
- blockcode: Option<blockcodefn>,
- blockquote: Option<blockquotefn>,
- header: Option<headerfn>,
-
- other_block_level_callbacks: [libc::size_t; 11],
-
- blockhtml: Option<blockhtmlfn>,
-
- /* span level callbacks - NULL or return 0 prints the span verbatim */
- autolink: libc::size_t, // unused
- codespan: Option<codespanfn>,
- other_span_level_callbacks_1: [libc::size_t; 7],
- link: Option<linkfn>,
- other_span_level_callbacks_2: [libc::size_t; 6],
-
- /* low level callbacks - NULL copies input directly into the output */
- entity: Option<entityfn>,
- normal_text: Option<normaltextfn>,
-
- /* header and footer */
- other_callbacks: [libc::size_t; 2],
-}
-
-#[repr(C)]
-struct hoedown_html_renderer_state {
- opaque: *mut libc::c_void,
- toc_data: html_toc_data,
- flags: libc::c_uint,
- link_attributes: Option<extern "C" fn(*mut hoedown_buffer,
- *const hoedown_buffer,
- *const hoedown_renderer_data)>,
-}
-
-#[repr(C)]
-struct html_toc_data {
- header_count: libc::c_int,
- current_level: libc::c_int,
- level_offset: libc::c_int,
- nesting_level: libc::c_int,
-}
-
-struct MyOpaque {
- dfltblk: extern "C" fn(*mut hoedown_buffer, *const hoedown_buffer,
- *const hoedown_buffer, *const hoedown_renderer_data,
- libc::size_t),
- toc_builder: Option<TocBuilder>,
-}
-
-#[repr(C)]
-struct hoedown_buffer {
- data: *const u8,
- size: libc::size_t,
- asize: libc::size_t,
- unit: libc::size_t,
-}
-
-extern {
- fn hoedown_html_renderer_new(render_flags: libc::c_uint,
- nesting_level: libc::c_int)
- -> *mut hoedown_renderer;
- fn hoedown_html_renderer_free(renderer: *mut hoedown_renderer);
-
- fn hoedown_document_new(rndr: *const hoedown_renderer,
- extensions: libc::c_uint,
- max_nesting: libc::size_t) -> *mut hoedown_document;
- fn hoedown_document_render(doc: *mut hoedown_document,
- ob: *mut hoedown_buffer,
- document: *const u8,
- doc_size: libc::size_t);
- fn hoedown_document_free(md: *mut hoedown_document);
-
- fn hoedown_buffer_new(unit: libc::size_t) -> *mut hoedown_buffer;
- fn hoedown_buffer_put(b: *mut hoedown_buffer, c: *const libc::c_char,
- n: libc::size_t);
- fn hoedown_buffer_puts(b: *mut hoedown_buffer, c: *const libc::c_char);
- fn hoedown_buffer_free(b: *mut hoedown_buffer);
-
-}
-
-// hoedown_buffer helpers
-impl hoedown_buffer {
- fn as_bytes(&self) -> &[u8] {
- unsafe { slice::from_raw_parts(self.data, self.size as usize) }
- }
-}
-
/// Returns Some(code) if `s` is a line that should be stripped from
/// documentation but used in example code. `code` is the portion of
/// `s` that should be used in tests. (None for lines that should be
RefCell::new(None)
});
+macro_rules! event_loop_break {
+ ($parser:expr, $toc_builder:expr, $shorter:expr, $buf:expr, $escape:expr, $id:expr,
+ $($end_event:pat)|*) => {{
+ fn inner(id: &mut Option<&mut String>, s: &str) {
+ if let Some(ref mut id) = *id {
+ id.push_str(s);
+ }
+ }
+ while let Some(event) = $parser.next() {
+ match event {
+ $($end_event)|* => break,
+ Event::Text(ref s) => {
+ inner($id, s);
+ if $escape {
+ $buf.push_str(&format!("{}", Escape(s)));
+ } else {
+ $buf.push_str(s);
+ }
+ }
+ Event::SoftBreak | Event::HardBreak if !$buf.is_empty() => {
+ $buf.push(' ');
+ }
+ x => {
+ looper($parser, &mut $buf, Some(x), $toc_builder, $shorter, $id);
+ }
+ }
+ }
+ }}
+}
pub fn render(w: &mut fmt::Formatter,
s: &str,
print_toc: bool,
- html_flags: libc::c_uint) -> fmt::Result {
- extern fn block(ob: *mut hoedown_buffer, orig_text: *const hoedown_buffer,
- lang: *const hoedown_buffer, data: *const hoedown_renderer_data,
- line: libc::size_t) {
- unsafe {
- if orig_text.is_null() { return }
-
- let opaque = (*data).opaque as *mut hoedown_html_renderer_state;
- let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque);
- let text = (*orig_text).as_bytes();
- let origtext = str::from_utf8(text).unwrap();
- let origtext = origtext.trim_left();
- debug!("docblock: ==============\n{:?}\n=======", text);
- let rendered = if lang.is_null() || origtext.is_empty() {
- false
- } else {
- let rlang = (*lang).as_bytes();
- let rlang = str::from_utf8(rlang).unwrap();
- if !LangString::parse(rlang).rust {
- (my_opaque.dfltblk)(ob, orig_text, lang,
- opaque as *const hoedown_renderer_data,
- line);
- true
- } else {
- false
+ shorter: MarkdownOutputStyle) -> fmt::Result {
+ fn code_block(parser: &mut Parser, buffer: &mut String, lang: &str) {
+ let mut origtext = String::new();
+ while let Some(event) = parser.next() {
+ match event {
+ Event::End(Tag::CodeBlock(_)) => break,
+ Event::Text(ref s) => {
+ origtext.push_str(s);
}
- };
+ _ => {}
+ }
+ }
+ let origtext = origtext.trim_left();
+ debug!("docblock: ==============\n{:?}\n=======", origtext);
- let lines = origtext.lines().filter(|l| {
- stripped_filtered_line(*l).is_none()
- });
- let text = lines.collect::<Vec<&str>>().join("\n");
- if rendered { return }
- PLAYGROUND.with(|play| {
- // insert newline to clearly separate it from the
- // previous block so we can shorten the html output
- let mut s = String::from("\n");
- let playground_button = play.borrow().as_ref().and_then(|&(ref krate, ref url)| {
- if url.is_empty() {
- return None;
- }
- let test = origtext.lines().map(|l| {
- stripped_filtered_line(l).unwrap_or(l)
- }).collect::<Vec<&str>>().join("\n");
- let krate = krate.as_ref().map(|s| &**s);
- let test = test::maketest(&test, krate, false,
- &Default::default());
- let channel = if test.contains("#![feature(") {
- "&version=nightly"
+ let lines = origtext.lines().filter(|l| {
+ stripped_filtered_line(*l).is_none()
+ });
+ let text = lines.collect::<Vec<&str>>().join("\n");
+ let block_info = if lang.is_empty() {
+ LangString::all_false()
+ } else {
+ LangString::parse(lang)
+ };
+ if !block_info.rust {
+ buffer.push_str(&format!("<pre><code class=\"language-{}\">{}</code></pre>",
+ lang, text));
+ return
+ }
+ PLAYGROUND.with(|play| {
+ // insert newline to clearly separate it from the
+ // previous block so we can shorten the html output
+ buffer.push('\n');
+ let playground_button = play.borrow().as_ref().and_then(|&(ref krate, ref url)| {
+ if url.is_empty() {
+ return None;
+ }
+ let test = origtext.lines().map(|l| {
+ stripped_filtered_line(l).unwrap_or(l)
+ }).collect::<Vec<&str>>().join("\n");
+ let krate = krate.as_ref().map(|s| &**s);
+ let test = test::maketest(&test, krate, false,
+ &Default::default());
+ let channel = if test.contains("#![feature(") {
+ "&version=nightly"
+ } else {
+ ""
+ };
+ // These characters don't need to be escaped in a URI.
+ // FIXME: use a library function for percent encoding.
+ fn dont_escape(c: u8) -> bool {
+ (b'a' <= c && c <= b'z') ||
+ (b'A' <= c && c <= b'Z') ||
+ (b'0' <= c && c <= b'9') ||
+ c == b'-' || c == b'_' || c == b'.' ||
+ c == b'~' || c == b'!' || c == b'\'' ||
+ c == b'(' || c == b')' || c == b'*'
+ }
+ let mut test_escaped = String::new();
+ for b in test.bytes() {
+ if dont_escape(b) {
+ test_escaped.push(char::from(b));
} else {
- ""
- };
- // These characters don't need to be escaped in a URI.
- // FIXME: use a library function for percent encoding.
- fn dont_escape(c: u8) -> bool {
- (b'a' <= c && c <= b'z') ||
- (b'A' <= c && c <= b'Z') ||
- (b'0' <= c && c <= b'9') ||
- c == b'-' || c == b'_' || c == b'.' ||
- c == b'~' || c == b'!' || c == b'\'' ||
- c == b'(' || c == b')' || c == b'*'
+ write!(test_escaped, "%{:02X}", b).unwrap();
}
- let mut test_escaped = String::new();
- for b in test.bytes() {
- if dont_escape(b) {
- test_escaped.push(char::from(b));
- } else {
- write!(test_escaped, "%{:02X}", b).unwrap();
- }
- }
- Some(format!(
- r#"<a class="test-arrow" target="_blank" href="{}?code={}{}">Run</a>"#,
- url, test_escaped, channel
- ))
- });
- s.push_str(&highlight::render_with_highlighting(
- &text,
- Some("rust-example-rendered"),
- None,
- playground_button.as_ref().map(String::as_str)));
- let output = CString::new(s).unwrap();
- hoedown_buffer_puts(ob, output.as_ptr());
- })
- }
+ }
+ Some(format!(
+ r#"<a class="test-arrow" target="_blank" href="{}?code={}{}">Run</a>"#,
+ url, test_escaped, channel
+ ))
+ });
+ buffer.push_str(&highlight::render_with_highlighting(
+ &text,
+ Some("rust-example-rendered"),
+ None,
+ playground_button.as_ref().map(String::as_str)));
+ });
}
- extern fn header(ob: *mut hoedown_buffer, text: *const hoedown_buffer,
- level: libc::c_int, data: *const hoedown_renderer_data,
- _: libc::size_t) {
- // hoedown does this, we may as well too
- unsafe { hoedown_buffer_puts(ob, "\n\0".as_ptr() as *const _); }
+ fn heading(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle, level: i32) {
+ let mut ret = String::new();
+ let mut id = String::new();
+ event_loop_break!(parser, toc_builder, shorter, ret, true, &mut Some(&mut id),
+ Event::End(Tag::Header(_)));
+ ret = ret.trim_right().to_owned();
- // Extract the text provided
- let s = if text.is_null() {
- "".to_owned()
- } else {
- let s = unsafe { (*text).as_bytes() };
- str::from_utf8(&s).unwrap().to_owned()
- };
-
- // Discard '<em>', '<code>' tags and some escaped characters,
- // transform the contents of the header into a hyphenated string
- // without non-alphanumeric characters other than '-' and '_'.
- //
- // This is a terrible hack working around how hoedown gives us rendered
- // html for text rather than the raw text.
- let mut id = s.clone();
- let repl_sub = vec!["<em>", "</em>", "<code>", "</code>",
- "<strong>", "</strong>",
- "<", ">", "&", "'", """];
- for sub in repl_sub {
- id = id.replace(sub, "");
- }
let id = id.chars().filter_map(|c| {
if c.is_alphanumeric() || c == '-' || c == '_' {
if c.is_ascii() {
}
}).collect::<String>();
- let opaque = unsafe { (*data).opaque as *mut hoedown_html_renderer_state };
- let opaque = unsafe { &mut *((*opaque).opaque as *mut MyOpaque) };
-
let id = derive_id(id);
- let sec = opaque.toc_builder.as_mut().map_or("".to_owned(), |builder| {
- format!("{} ", builder.push(level as u32, s.clone(), id.clone()))
+ let sec = toc_builder.as_mut().map_or("".to_owned(), |builder| {
+ format!("{} ", builder.push(level as u32, ret.clone(), id.clone()))
});
// Render the HTML
- let text = format!("<h{lvl} id='{id}' class='section-header'>\
- <a href='#{id}'>{sec}{}</a></h{lvl}>",
- s, lvl = level, id = id, sec = sec);
-
- let text = CString::new(text).unwrap();
- unsafe { hoedown_buffer_puts(ob, text.as_ptr()) }
- }
-
- extern fn codespan(
- ob: *mut hoedown_buffer,
- text: *const hoedown_buffer,
- _: *const hoedown_renderer_data,
- _: libc::size_t
- ) -> libc::c_int {
- let content = if text.is_null() {
- "".to_owned()
- } else {
- let bytes = unsafe { (*text).as_bytes() };
- let s = str::from_utf8(bytes).unwrap();
- collapse_whitespace(s)
- };
+ buffer.push_str(&format!("<h{lvl} id=\"{id}\" class=\"section-header\">\
+ <a href=\"#{id}\">{sec}{}</a></h{lvl}>",
+ ret, lvl = level, id = id, sec = sec));
+ }
- let content = format!("<code>{}</code>", Escape(&content));
- let element = CString::new(content).unwrap();
- unsafe { hoedown_buffer_puts(ob, element.as_ptr()); }
- // Return anything except 0, which would mean "also print the code span verbatim".
- 1
+ fn inline_code(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle, id: &mut Option<&mut String>) {
+ let mut content = String::new();
+ event_loop_break!(parser, toc_builder, shorter, content, false, id, Event::End(Tag::Code));
+ buffer.push_str(&format!("<code>{}</code>",
+ Escape(&collapse_whitespace(content.trim_right()))));
}
- unsafe {
- let ob = hoedown_buffer_new(DEF_OUNIT);
- let renderer = hoedown_html_renderer_new(html_flags, 0);
- let mut opaque = MyOpaque {
- dfltblk: (*renderer).blockcode.unwrap(),
- toc_builder: if print_toc {Some(TocBuilder::new())} else {None}
- };
- (*((*renderer).opaque as *mut hoedown_html_renderer_state)).opaque
- = &mut opaque as *mut _ as *mut libc::c_void;
- (*renderer).blockcode = Some(block);
- (*renderer).header = Some(header);
- (*renderer).codespan = Some(codespan);
+ fn link(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle, url: &str, mut title: String,
+ id: &mut Option<&mut String>) {
+ event_loop_break!(parser, toc_builder, shorter, title, true, id,
+ Event::End(Tag::Link(_, _)));
+ buffer.push_str(&format!("<a href=\"{}\">{}</a>", url, title));
+ }
- let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
- hoedown_document_render(document, ob, s.as_ptr(),
- s.len() as libc::size_t);
- hoedown_document_free(document);
+ fn paragraph(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle, id: &mut Option<&mut String>) {
+ let mut content = String::new();
+ event_loop_break!(parser, toc_builder, shorter, content, true, id,
+ Event::End(Tag::Paragraph));
+ buffer.push_str(&format!("<p>{}</p>", content.trim_right()));
+ }
- hoedown_html_renderer_free(renderer);
+ fn table_cell(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle) {
+ let mut content = String::new();
+ event_loop_break!(parser, toc_builder, shorter, content, true, &mut None,
+ Event::End(Tag::TableHead) |
+ Event::End(Tag::Table(_)) |
+ Event::End(Tag::TableRow) |
+ Event::End(Tag::TableCell));
+ buffer.push_str(&format!("<td>{}</td>", content.trim()));
+ }
- let mut ret = opaque.toc_builder.map_or(Ok(()), |builder| {
- write!(w, "<nav id=\"TOC\">{}</nav>", builder.into_toc())
- });
+ fn table_row(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle) {
+ let mut content = String::new();
+ while let Some(event) = parser.next() {
+ match event {
+ Event::End(Tag::TableHead) |
+ Event::End(Tag::Table(_)) |
+ Event::End(Tag::TableRow) => break,
+ Event::Start(Tag::TableCell) => {
+ table_cell(parser, &mut content, toc_builder, shorter);
+ }
+ x => {
+ looper(parser, &mut content, Some(x), toc_builder, shorter, &mut None);
+ }
+ }
+ }
+ buffer.push_str(&format!("<tr>{}</tr>", content));
+ }
- if ret.is_ok() {
- let buf = (*ob).as_bytes();
- ret = w.write_str(str::from_utf8(buf).unwrap());
+ fn table_head(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle) {
+ let mut content = String::new();
+ while let Some(event) = parser.next() {
+ match event {
+ Event::End(Tag::TableHead) | Event::End(Tag::Table(_)) => break,
+ Event::Start(Tag::TableCell) => {
+ table_cell(parser, &mut content, toc_builder, shorter);
+ }
+ x => {
+ looper(parser, &mut content, Some(x), toc_builder, shorter, &mut None);
+ }
+ }
+ }
+ if !content.is_empty() {
+ buffer.push_str(&format!("<thead><tr>{}</tr></thead>", content.replace("td>", "th>")));
}
- hoedown_buffer_free(ob);
- ret
}
-}
-pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Span) {
- extern fn block(_ob: *mut hoedown_buffer,
- text: *const hoedown_buffer,
- lang: *const hoedown_buffer,
- data: *const hoedown_renderer_data,
- line: libc::size_t) {
- unsafe {
- if text.is_null() { return }
- let block_info = if lang.is_null() {
- LangString::all_false()
- } else {
- let lang = (*lang).as_bytes();
- let s = str::from_utf8(lang).unwrap();
- LangString::parse(s)
- };
- if !block_info.rust { return }
- let text = (*text).as_bytes();
- let opaque = (*data).opaque as *mut hoedown_html_renderer_state;
- let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
- let text = str::from_utf8(text).unwrap();
- let lines = text.lines().map(|l| {
- stripped_filtered_line(l).unwrap_or(l)
- });
- let text = lines.collect::<Vec<&str>>().join("\n");
- let line = tests.get_line() + line;
- let filename = tests.get_filename();
- tests.add_test(text.to_owned(),
- block_info.should_panic, block_info.no_run,
- block_info.ignore, block_info.test_harness,
- block_info.compile_fail, block_info.error_codes,
- line, filename);
+ fn table(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle) {
+ let mut content = String::new();
+ let mut rows = String::new();
+ while let Some(event) = parser.next() {
+ match event {
+ Event::End(Tag::Table(_)) => break,
+ Event::Start(Tag::TableHead) => {
+ table_head(parser, &mut content, toc_builder, shorter);
+ }
+ Event::Start(Tag::TableRow) => {
+ table_row(parser, &mut rows, toc_builder, shorter);
+ }
+ _ => {}
+ }
}
+ buffer.push_str(&format!("<table>{}{}</table>",
+ content,
+ if shorter.is_compact() || rows.is_empty() {
+ String::new()
+ } else {
+ format!("<tbody>{}</tbody>", rows)
+ }));
}
- extern fn header(_ob: *mut hoedown_buffer,
- text: *const hoedown_buffer,
- level: libc::c_int, data: *const hoedown_renderer_data,
- _: libc::size_t) {
- unsafe {
- let opaque = (*data).opaque as *mut hoedown_html_renderer_state;
- let tests = &mut *((*opaque).opaque as *mut ::test::Collector);
- if text.is_null() {
- tests.register_header("", level as u32);
- } else {
- let text = (*text).as_bytes();
- let text = str::from_utf8(text).unwrap();
- tests.register_header(text, level as u32);
+ fn blockquote(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle) {
+ let mut content = String::new();
+ event_loop_break!(parser, toc_builder, shorter, content, true, &mut None,
+ Event::End(Tag::BlockQuote));
+ buffer.push_str(&format!("<blockquote>{}</blockquote>", content.trim_right()));
+ }
+
+ fn list_item(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle) {
+ let mut content = String::new();
+ while let Some(event) = parser.next() {
+ match event {
+ Event::End(Tag::Item) => break,
+ Event::Text(ref s) => {
+ content.push_str(&format!("{}", Escape(s)));
+ }
+ x => {
+ looper(parser, &mut content, Some(x), toc_builder, shorter, &mut None);
+ }
+ }
+ }
+ buffer.push_str(&format!("<li>{}</li>", content));
+ }
+
+ fn list(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle) {
+ let mut content = String::new();
+ while let Some(event) = parser.next() {
+ match event {
+ Event::End(Tag::List(_)) => break,
+ Event::Start(Tag::Item) => {
+ list_item(parser, &mut content, toc_builder, shorter);
+ }
+ x => {
+ looper(parser, &mut content, Some(x), toc_builder, shorter, &mut None);
+ }
+ }
+ }
+ buffer.push_str(&format!("<ul>{}</ul>", content));
+ }
+
+ fn emphasis(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle, id: &mut Option<&mut String>) {
+ let mut content = String::new();
+ event_loop_break!(parser, toc_builder, shorter, content, false, id,
+ Event::End(Tag::Emphasis));
+ buffer.push_str(&format!("<em>{}</em>", content));
+ }
+
+ fn strong(parser: &mut Parser, buffer: &mut String, toc_builder: &mut Option<TocBuilder>,
+ shorter: MarkdownOutputStyle, id: &mut Option<&mut String>) {
+ let mut content = String::new();
+ event_loop_break!(parser, toc_builder, shorter, content, false, id,
+ Event::End(Tag::Strong));
+ buffer.push_str(&format!("<strong>{}</strong>", content));
+ }
+
+ fn looper<'a>(parser: &'a mut Parser, buffer: &mut String, next_event: Option<Event<'a>>,
+ toc_builder: &mut Option<TocBuilder>, shorter: MarkdownOutputStyle,
+ id: &mut Option<&mut String>) -> bool {
+ if let Some(event) = next_event {
+ match event {
+ Event::Start(Tag::CodeBlock(lang)) => {
+ code_block(parser, buffer, &*lang);
+ }
+ Event::Start(Tag::Header(level)) => {
+ heading(parser, buffer, toc_builder, shorter, level);
+ }
+ Event::Start(Tag::Code) => {
+ inline_code(parser, buffer, toc_builder, shorter, id);
+ }
+ Event::Start(Tag::Paragraph) => {
+ paragraph(parser, buffer, toc_builder, shorter, id);
+ }
+ Event::Start(Tag::Link(ref url, ref t)) => {
+ link(parser, buffer, toc_builder, shorter, url, t.as_ref().to_owned(), id);
+ }
+ Event::Start(Tag::Table(_)) => {
+ table(parser, buffer, toc_builder, shorter);
+ }
+ Event::Start(Tag::BlockQuote) => {
+ blockquote(parser, buffer, toc_builder, shorter);
+ }
+ Event::Start(Tag::List(_)) => {
+ list(parser, buffer, toc_builder, shorter);
+ }
+ Event::Start(Tag::Emphasis) => {
+ emphasis(parser, buffer, toc_builder, shorter, id);
+ }
+ Event::Start(Tag::Strong) => {
+ strong(parser, buffer, toc_builder, shorter, id);
+ }
+ Event::Html(h) | Event::InlineHtml(h) => {
+ buffer.push_str(&*h);
+ }
+ _ => {}
}
+ shorter.is_fancy()
+ } else {
+ false
+ }
+ }
+
+ let mut toc_builder = if print_toc {
+ Some(TocBuilder::new())
+ } else {
+ None
+ };
+ let mut buffer = String::new();
+ let mut parser = Parser::new_ext(s, pulldown_cmark::OPTION_ENABLE_TABLES);
+ loop {
+ let next_event = parser.next();
+ if !looper(&mut parser, &mut buffer, next_event, &mut toc_builder, shorter, &mut None) {
+ break
}
}
+ let mut ret = toc_builder.map_or(Ok(()), |builder| {
+ write!(w, "<nav id=\"TOC\">{}</nav>", builder.into_toc())
+ });
+
+ if ret.is_ok() {
+ ret = w.write_str(&buffer);
+ }
+ ret
+}
+pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector, position: Span) {
tests.set_position(position);
- unsafe {
- let ob = hoedown_buffer_new(DEF_OUNIT);
- let renderer = hoedown_html_renderer_new(0, 0);
- (*renderer).blockcode = Some(block);
- (*renderer).header = Some(header);
- (*((*renderer).opaque as *mut hoedown_html_renderer_state)).opaque
- = tests as *mut _ as *mut libc::c_void;
-
- let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
- hoedown_document_render(document, ob, doc.as_ptr(),
- doc.len() as libc::size_t);
- hoedown_document_free(document);
-
- hoedown_html_renderer_free(renderer);
- hoedown_buffer_free(ob);
+
+ let mut parser = Parser::new(doc);
+ let mut prev_offset = 0;
+ let mut nb_lines = 0;
+ let mut register_header = None;
+ 'main: while let Some(event) = parser.next() {
+ match event {
+ Event::Start(Tag::CodeBlock(s)) => {
+ let block_info = if s.is_empty() {
+ LangString::all_false()
+ } else {
+ LangString::parse(&*s)
+ };
+ if !block_info.rust {
+ continue
+ }
+ let mut test_s = String::new();
+ let mut offset = None;
+ loop {
+ let event = parser.next();
+ if let Some(event) = event {
+ match event {
+ Event::End(Tag::CodeBlock(_)) => break,
+ Event::Text(ref s) => {
+ test_s.push_str(s);
+ if offset.is_none() {
+ offset = Some(parser.get_offset());
+ }
+ }
+ _ => {}
+ }
+ } else {
+ break 'main;
+ }
+ }
+ let offset = offset.unwrap_or(0);
+ let lines = test_s.lines().map(|l| {
+ stripped_filtered_line(l).unwrap_or(l)
+ });
+ let text = lines.collect::<Vec<&str>>().join("\n");
+ nb_lines += doc[prev_offset..offset].lines().count();
+ let line = tests.get_line() + (nb_lines - 1);
+ let filename = tests.get_filename();
+ tests.add_test(text.to_owned(),
+ block_info.should_panic, block_info.no_run,
+ block_info.ignore, block_info.test_harness,
+ block_info.compile_fail, block_info.error_codes,
+ line, filename);
+ prev_offset = offset;
+ }
+ Event::Start(Tag::Header(level)) => {
+ register_header = Some(level as u32);
+ }
+ Event::Text(ref s) if register_header.is_some() => {
+ let level = register_header.unwrap();
+ if s.is_empty() {
+ tests.register_header("", level);
+ } else {
+ tests.register_header(s, level);
+ }
+ register_header = None;
+ }
+ _ => {}
+ }
}
}
impl<'a> fmt::Display for Markdown<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- let Markdown(md) = *self;
+ let Markdown(md, shorter) = *self;
// This is actually common enough to special-case
if md.is_empty() { return Ok(()) }
- render(fmt, md, false, 0)
+ render(fmt, md, false, shorter)
}
}
impl<'a> fmt::Display for MarkdownWithToc<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let MarkdownWithToc(md) = *self;
- render(fmt, md, true, 0)
+ render(fmt, md, true, MarkdownOutputStyle::Fancy)
}
}
let MarkdownHtml(md) = *self;
// This is actually common enough to special-case
if md.is_empty() { return Ok(()) }
- render(fmt, md, false, HOEDOWN_HTML_ESCAPE)
+ render(fmt, md, false, MarkdownOutputStyle::Fancy)
}
}
pub fn plain_summary_line(md: &str) -> String {
- extern fn link(_ob: *mut hoedown_buffer,
- _link: *const hoedown_buffer,
- _title: *const hoedown_buffer,
- content: *const hoedown_buffer,
- data: *const hoedown_renderer_data,
- _: libc::size_t) -> libc::c_int
- {
- unsafe {
- if !content.is_null() && (*content).size > 0 {
- let ob = (*data).opaque as *mut hoedown_buffer;
- hoedown_buffer_put(ob, (*content).data as *const libc::c_char,
- (*content).size);
- }
- }
- 1
- }
-
- extern fn normal_text(_ob: *mut hoedown_buffer,
- text: *const hoedown_buffer,
- data: *const hoedown_renderer_data,
- _: libc::size_t)
- {
- unsafe {
- let ob = (*data).opaque as *mut hoedown_buffer;
- hoedown_buffer_put(ob, (*text).data as *const libc::c_char,
- (*text).size);
- }
+ struct ParserWrapper<'a> {
+ inner: Parser<'a>,
+ is_in: isize,
+ is_first: bool,
}
- unsafe {
- let ob = hoedown_buffer_new(DEF_OUNIT);
- let mut plain_renderer: hoedown_renderer = ::std::mem::zeroed();
- let renderer: *mut hoedown_renderer = &mut plain_renderer;
- (*renderer).opaque = ob as *mut libc::c_void;
- (*renderer).link = Some(link);
- (*renderer).normal_text = Some(normal_text);
+ impl<'a> Iterator for ParserWrapper<'a> {
+ type Item = String;
- let document = hoedown_document_new(renderer, HOEDOWN_EXTENSIONS, 16);
- hoedown_document_render(document, ob, md.as_ptr(),
- md.len() as libc::size_t);
- hoedown_document_free(document);
- let plain_slice = (*ob).as_bytes();
- let plain = str::from_utf8(plain_slice).unwrap_or("").to_owned();
- hoedown_buffer_free(ob);
- plain
+ fn next(&mut self) -> Option<String> {
+ let next_event = self.inner.next();
+ if next_event.is_none() {
+ return None
+ }
+ let next_event = next_event.unwrap();
+ let (ret, is_in) = match next_event {
+ Event::Start(Tag::Paragraph) => (None, 1),
+ Event::Start(Tag::Link(_, ref t)) if !self.is_first => {
+ (Some(t.as_ref().to_owned()), 1)
+ }
+ Event::Start(Tag::Code) => (Some("`".to_owned()), 1),
+ Event::End(Tag::Code) => (Some("`".to_owned()), -1),
+ Event::Start(Tag::Header(_)) => (None, 1),
+ Event::Text(ref s) if self.is_in > 0 => (Some(s.as_ref().to_owned()), 0),
+ Event::End(Tag::Link(_, ref t)) => (Some(t.as_ref().to_owned()), -1),
+ Event::End(Tag::Paragraph) | Event::End(Tag::Header(_)) => (None, -1),
+ _ => (None, 0),
+ };
+ if is_in > 0 || (is_in < 0 && self.is_in > 0) {
+ self.is_in += is_in;
+ }
+ if ret.is_some() {
+ self.is_first = false;
+ ret
+ } else {
+ Some(String::new())
+ }
+ }
+ }
+ let mut s = String::with_capacity(md.len() * 3 / 2);
+ let mut p = ParserWrapper {
+ inner: Parser::new(md),
+ is_in: 0,
+ is_first: true,
+ };
+ while let Some(t) = p.next() {
+ if !t.is_empty() {
+ s.push_str(&t);
+ }
}
+ s
}
#[cfg(test)]
mod tests {
- use super::{LangString, Markdown, MarkdownHtml};
+ use super::{LangString, Markdown, MarkdownHtml, MarkdownOutputStyle};
use super::plain_summary_line;
use html::render::reset_ids;
#[test]
fn issue_17736() {
let markdown = "# title";
- format!("{}", Markdown(markdown));
+ format!("{}", Markdown(markdown, MarkdownOutputStyle::Fancy));
reset_ids(true);
}
#[test]
fn test_header() {
fn t(input: &str, expect: &str) {
- let output = format!("{}", Markdown(input));
- assert_eq!(output, expect);
+ let output = format!("{}", Markdown(input, MarkdownOutputStyle::Fancy));
+ assert_eq!(output, expect, "original: {}", input);
reset_ids(true);
}
- t("# Foo bar", "\n<h1 id='foo-bar' class='section-header'>\
- <a href='#foo-bar'>Foo bar</a></h1>");
- t("## Foo-bar_baz qux", "\n<h2 id='foo-bar_baz-qux' class=\'section-\
- header'><a href='#foo-bar_baz-qux'>Foo-bar_baz qux</a></h2>");
+ t("# Foo bar", "<h1 id=\"foo-bar\" class=\"section-header\">\
+ <a href=\"#foo-bar\">Foo bar</a></h1>");
+ t("## Foo-bar_baz qux", "<h2 id=\"foo-bar_baz-qux\" class=\"section-\
+ header\"><a href=\"#foo-bar_baz-qux\">Foo-bar_baz qux</a></h2>");
t("### **Foo** *bar* baz!?!& -_qux_-%",
- "\n<h3 id='foo-bar-baz--_qux_-' class='section-header'>\
- <a href='#foo-bar-baz--_qux_-'><strong>Foo</strong> \
- <em>bar</em> baz!?!& -_qux_-%</a></h3>");
- t("####**Foo?** & \\*bar?!* _`baz`_ ❤ #qux",
- "\n<h4 id='foo--bar--baz--qux' class='section-header'>\
- <a href='#foo--bar--baz--qux'><strong>Foo?</strong> & *bar?!* \
+ "<h3 id=\"foo-bar-baz--qux-\" class=\"section-header\">\
+ <a href=\"#foo-bar-baz--qux-\"><strong>Foo</strong> \
+ <em>bar</em> baz!?!& -<em>qux</em>-%</a></h3>");
+ t("#### **Foo?** & \\*bar?!* _`baz`_ ❤ #qux",
+ "<h4 id=\"foo--bar--baz--qux\" class=\"section-header\">\
+ <a href=\"#foo--bar--baz--qux\"><strong>Foo?</strong> & *bar?!* \
<em><code>baz</code></em> ❤ #qux</a></h4>");
}
#[test]
fn test_header_ids_multiple_blocks() {
fn t(input: &str, expect: &str) {
- let output = format!("{}", Markdown(input));
- assert_eq!(output, expect);
+ let output = format!("{}", Markdown(input, MarkdownOutputStyle::Fancy));
+ assert_eq!(output, expect, "original: {}", input);
}
let test = || {
- t("# Example", "\n<h1 id='example' class='section-header'>\
- <a href='#example'>Example</a></h1>");
- t("# Panics", "\n<h1 id='panics' class='section-header'>\
- <a href='#panics'>Panics</a></h1>");
- t("# Example", "\n<h1 id='example-1' class='section-header'>\
- <a href='#example-1'>Example</a></h1>");
- t("# Main", "\n<h1 id='main-1' class='section-header'>\
- <a href='#main-1'>Main</a></h1>");
- t("# Example", "\n<h1 id='example-2' class='section-header'>\
- <a href='#example-2'>Example</a></h1>");
- t("# Panics", "\n<h1 id='panics-1' class='section-header'>\
- <a href='#panics-1'>Panics</a></h1>");
+ t("# Example", "<h1 id=\"example\" class=\"section-header\">\
+ <a href=\"#example\">Example</a></h1>");
+ t("# Panics", "<h1 id=\"panics\" class=\"section-header\">\
+ <a href=\"#panics\">Panics</a></h1>");
+ t("# Example", "<h1 id=\"example-1\" class=\"section-header\">\
+ <a href=\"#example-1\">Example</a></h1>");
+ t("# Main", "<h1 id=\"main-1\" class=\"section-header\">\
+ <a href=\"#main-1\">Main</a></h1>");
+ t("# Example", "<h1 id=\"example-2\" class=\"section-header\">\
+ <a href=\"#example-2\">Example</a></h1>");
+ t("# Panics", "<h1 id=\"panics-1\" class=\"section-header\">\
+ <a href=\"#panics-1\">Panics</a></h1>");
};
test();
reset_ids(true);
fn test_plain_summary_line() {
fn t(input: &str, expect: &str) {
let output = plain_summary_line(input);
- assert_eq!(output, expect);
+ assert_eq!(output, expect, "original: {}", input);
}
t("hello [Rust](https://www.rust-lang.org) :)", "hello Rust :)");
fn test_markdown_html_escape() {
fn t(input: &str, expect: &str) {
let output = format!("{}", MarkdownHtml(input));
- assert_eq!(output, expect);
+ assert_eq!(output, expect, "original: {}", input);
}
- t("`Struct<'a, T>`", "<p><code>Struct<'a, T></code></p>\n");
- t("Struct<'a, T>", "<p>Struct<'a, T></p>\n");
+ t("`Struct<'a, T>`", "<p><code>Struct<'a, T></code></p>");
+ t("Struct<'a, T>", "<p>Struct<'a, T></p>");
}
}
use html::format::{VisSpace, Method, UnsafetySpace, MutableSpace};
use html::format::fmt_impl_for_trait_page;
use html::item_type::ItemType;
-use html::markdown::{self, Markdown, MarkdownHtml};
+use html::markdown::{self, Markdown, MarkdownHtml, MarkdownOutputStyle};
use html::{highlight, layout};
/// A pair of name and its optional document.
} else {
format!("{}", &plain_summary_line(Some(s)))
};
- write!(w, "<div class='docblock'>{}</div>", Markdown(&markdown))?;
+ write!(w, "<div class='docblock'>{}</div>",
+ Markdown(&markdown, MarkdownOutputStyle::Fancy))?;
}
Ok(())
}
fn document_full(w: &mut fmt::Formatter, item: &clean::Item) -> fmt::Result {
if let Some(s) = get_doc_value(item) {
write!(w, "<div class='docblock'>{}</div>",
- Markdown(&format!("{}{}", md_render_assoc_item(item), s)))?;
+ Markdown(&format!("{}{}", md_render_assoc_item(item), s),
+ MarkdownOutputStyle::Fancy))?;
}
Ok(())
}
</tr>",
name = *myitem.name.as_ref().unwrap(),
stab_docs = stab_docs,
- docs = shorter(Some(&Markdown(doc_value).to_string())),
+ docs = shorter(Some(&Markdown(doc_value,
+ MarkdownOutputStyle::Compact).to_string())),
class = myitem.type_(),
stab = myitem.stability_class().unwrap_or("".to_string()),
unsafety_flag = unsafety_flag,
if attr.is_word() {
Some(format!("{}", name))
} else if let Some(v) = attr.value_str() {
- Some(format!("{} = {:?}", name, &v.as_str()[..]))
+ Some(format!("{} = {:?}", name, v.as_str()))
} else if let Some(values) = attr.meta_item_list() {
let display: Vec<_> = values.iter().filter_map(|attr| {
attr.meta_item().and_then(|mi| render_attribute(mi))
for attr in &it.attrs.other_attrs {
let name = attr.name().unwrap();
- if !ATTRIBUTE_WHITELIST.contains(&&name.as_str()[..]) {
+ if !ATTRIBUTE_WHITELIST.contains(&&*name.as_str()) {
continue;
}
if let Some(s) = render_attribute(&attr.meta().unwrap()) {
write!(w, "</span>")?;
write!(w, "</h3>\n")?;
if let Some(ref dox) = i.impl_item.doc_value() {
- write!(w, "<div class='docblock'>{}</div>", Markdown(dox))?;
+ write!(w, "<div class='docblock'>{}</div>", Markdown(dox, MarkdownOutputStyle::Fancy))?;
}
}
// except according to those terms.
#![crate_name = "rustdoc"]
-#![unstable(feature = "rustdoc", issue = "27812")]
+#![unstable(feature = "rustc_private", issue = "27812")]
#![crate_type = "dylib"]
#![crate_type = "rlib"]
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
extern crate std_unicode;
#[macro_use] extern crate log;
extern crate rustc_errors as errors;
+extern crate pulldown_cmark;
extern crate serialize as rustc_serialize; // used by deriving
use html::render::reset_ids;
use html::escape::Escape;
use html::markdown;
-use html::markdown::{Markdown, MarkdownWithToc, find_testable_code};
+use html::markdown::{Markdown, MarkdownWithToc, MarkdownOutputStyle, find_testable_code};
use test::{TestOptions, Collector};
-/// Separate any lines at the start of the file that begin with `%`.
+/// Separate any lines at the start of the file that begin with `# ` or `%`.
fn extract_leading_metadata<'a>(s: &'a str) -> (Vec<&'a str>, &'a str) {
let mut metadata = Vec::new();
let mut count = 0;
+
for line in s.lines() {
- if line.starts_with("%") {
- // remove %<whitespace>
+ if line.starts_with("# ") || line.starts_with("%") {
+ // trim the whitespace after the symbol
metadata.push(line[1..].trim_left());
count += line.len() + 1;
} else {
return (metadata, &s[count..]);
}
}
- // if we're here, then all lines were metadata % lines.
+
+ // if we're here, then all lines were metadata `# ` or `%` lines.
(metadata, "")
}
if metadata.is_empty() {
let _ = writeln!(
&mut io::stderr(),
- "rustdoc: invalid markdown file: expecting initial line with `% ...TITLE...`"
+ "rustdoc: invalid markdown file: no initial lines starting with `# ` or `%`"
);
return 5;
}
let rendered = if include_toc {
format!("{}", MarkdownWithToc(text))
} else {
- format!("{}", Markdown(text))
+ format!("{}", Markdown(text, MarkdownOutputStyle::Fancy))
};
let err = write!(
use ops::Range;
use iter::FusedIterator;
-/// Extension methods for ASCII-subset only operations on string slices.
+/// Extension methods for ASCII-subset only operations.
///
/// Be aware that operations on seemingly non-ASCII characters can sometimes
/// have unexpected results. Consider this example:
///
/// let ascii = 'a';
/// let utf8 = '❤';
+ /// let int_ascii = 97;
///
/// assert!(ascii.is_ascii());
/// assert!(!utf8.is_ascii());
+ /// assert!(int_ascii.is_ascii());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn is_ascii(&self) -> bool;
- /// Makes a copy of the string in ASCII upper case.
+ /// Makes a copy of the value in its ASCII upper case equivalent.
///
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
/// but non-ASCII letters are unchanged.
///
- /// To uppercase the string in-place, use [`make_ascii_uppercase`].
+ /// To uppercase the value in-place, use [`make_ascii_uppercase`].
///
/// To uppercase ASCII characters in addition to non-ASCII characters, use
/// [`str::to_uppercase`].
///
/// let ascii = 'a';
/// let utf8 = '❤';
+ /// let int_ascii = 97;
///
/// assert_eq!('A', ascii.to_ascii_uppercase());
/// assert_eq!('❤', utf8.to_ascii_uppercase());
+ /// assert_eq!(65, int_ascii.to_ascii_uppercase());
/// ```
///
/// [`make_ascii_uppercase`]: #tymethod.make_ascii_uppercase
#[stable(feature = "rust1", since = "1.0.0")]
fn to_ascii_uppercase(&self) -> Self::Owned;
- /// Makes a copy of the string in ASCII lower case.
+ /// Makes a copy of the value in its ASCII lower case equivalent.
///
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
/// but non-ASCII letters are unchanged.
///
- /// To lowercase the string in-place, use [`make_ascii_lowercase`].
+ /// To lowercase the value in-place, use [`make_ascii_lowercase`].
///
/// To lowercase ASCII characters in addition to non-ASCII characters, use
/// [`str::to_lowercase`].
///
/// let ascii = 'A';
/// let utf8 = '❤';
+ /// let int_ascii = 65;
///
/// assert_eq!('a', ascii.to_ascii_lowercase());
/// assert_eq!('❤', utf8.to_ascii_lowercase());
+ /// assert_eq!(97, int_ascii.to_ascii_lowercase());
/// ```
///
/// [`make_ascii_lowercase`]: #tymethod.make_ascii_lowercase
#[stable(feature = "rust1", since = "1.0.0")]
fn to_ascii_lowercase(&self) -> Self::Owned;
- /// Checks that two strings are an ASCII case-insensitive match.
+ /// Checks that two values are an ASCII case-insensitive match.
///
/// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
- /// but without allocating and copying temporary strings.
+ /// but without allocating and copying temporaries.
///
/// # Examples
///
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
/// but non-ASCII letters are unchanged.
///
- /// To return a new uppercased string without modifying the existing one, use
+ /// To return a new uppercased value without modifying the existing one, use
/// [`to_ascii_uppercase`].
///
/// # Examples
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
/// but non-ASCII letters are unchanged.
///
- /// To return a new lowercased string without modifying the existing one, use
+ /// To return a new lowercased value without modifying the existing one, use
/// [`to_ascii_lowercase`].
///
/// # Examples
impl<T> Cursor<T> {
/// Creates a new cursor wrapping the provided underlying I/O object.
///
+ /// Cursor initial position is `0` even if underlying object (e.
+ /// g. `Vec`) is not empty. So writing to cursor starts with
+ /// overwriting `Vec` content, not with appending to it.
+ ///
/// # Examples
///
/// ```
use iter;
use slice;
-/// Representation of a socket address for networking applications.
+/// An internet socket address, either IPv4 or IPv6.
///
-/// A socket address can either represent the IPv4 or IPv6 protocol and is
-/// paired with at least a port number as well. Each protocol may have more
-/// specific information about the address available to it as well.
+/// Internet socket addresses consist of an [IP address], a 16-bit port number, as well
+/// as possibly some version-dependent additional information. See [`SocketAddrV4`]'s and
+/// [`SocketAddrV6`]'s respective documentation for more details.
+///
+/// [IP address]: ../../std/net/enum.IpAddr.html
+/// [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html
+/// [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html
+///
+/// # Examples
+///
+/// ```
+/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+///
+/// let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+///
+/// assert_eq!("127.0.0.1:8080".parse(), Ok(socket));
+/// assert_eq!(socket.port(), 8080);
+/// assert_eq!(socket.is_ipv4(), true);
+/// ```
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum SocketAddr {
- /// An IPv4 socket address which is a (ip, port) combination.
+ /// An IPv4 socket address.
#[stable(feature = "rust1", since = "1.0.0")]
V4(#[stable(feature = "rust1", since = "1.0.0")] SocketAddrV4),
/// An IPv6 socket address.
V6(#[stable(feature = "rust1", since = "1.0.0")] SocketAddrV6),
}
-/// An IPv4 socket address which is a (ip, port) combination.
+/// An IPv4 socket address.
+///
+/// IPv4 socket addresses consist of an [IPv4 address] and a 16-bit port number, as
+/// stated in [IETF RFC 793].
+///
+/// See [`SocketAddr`] for a type encompassing both IPv4 and IPv6 socket addresses.
+///
+/// [IETF RFC 793]: https://tools.ietf.org/html/rfc793
+/// [IPv4 address]: ../../std/net/struct.Ipv4Addr.html
+/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html
+///
+/// # Examples
+///
+/// ```
+/// use std::net::{Ipv4Addr, SocketAddrV4};
+///
+/// let socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);
+///
+/// assert_eq!("127.0.0.1:8080".parse(), Ok(socket));
+/// assert_eq!(socket.ip(), &Ipv4Addr::new(127, 0, 0, 1));
+/// assert_eq!(socket.port(), 8080);
+/// ```
#[derive(Copy)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct SocketAddrV4 { inner: c::sockaddr_in }
/// An IPv6 socket address.
+///
+/// IPv6 socket addresses consist of an [Ipv6 address], a 16-bit port number, as well
+/// as fields containing the traffic class, the flow label, and a scope identifier
+/// (see [IETF RFC 2553, Section 3.3] for more details).
+///
+/// See [`SocketAddr`] for a type encompassing both IPv4 and IPv6 socket addresses.
+///
+/// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3
+/// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html
+/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html
+///
+/// # Examples
+///
+/// ```
+/// use std::net::{Ipv6Addr, SocketAddrV6};
+///
+/// let socket = SocketAddrV6::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 8080, 0, 0);
+///
+/// assert_eq!("[2001:db8::1]:8080".parse(), Ok(socket));
+/// assert_eq!(socket.ip(), &Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
+/// assert_eq!(socket.port(), 8080);
+/// ```
#[derive(Copy)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct SocketAddrV6 { inner: c::sockaddr_in6 }
impl SocketAddr {
- /// Creates a new socket address from the (ip, port) pair.
+ /// Creates a new socket address from an [IP address] and a port number.
+ ///
+ /// [IP address]: ../../std/net/enum.IpAddr.html
///
/// # Examples
///
}
}
- /// Change the IP address associated with this socket address.
+ /// Changes the IP address associated with this socket address.
///
/// # Examples
///
}
}
- /// Change the port number associated with this socket address.
+ /// Changes the port number associated with this socket address.
///
/// # Examples
///
}
}
- /// Returns true if the IP in this `SocketAddr` is a valid IPv4 address,
- /// false if it's a valid IPv6 address.
+ /// Returns [`true`] if the [IP address] in this `SocketAddr` is an
+ /// [IPv4 address], and [`false`] otherwise.
+ ///
+ /// [`true`]: ../../std/primitive.bool.html
+ /// [`false`]: ../../std/primitive.bool.html
+ /// [IP address]: ../../std/net/enum.IpAddr.html
+ /// [IPv4 address]: ../../std/net/enum.IpAddr.html#variant.V4
///
/// # Examples
///
}
}
- /// Returns true if the IP in this `SocketAddr` is a valid IPv6 address,
- /// false if it's a valid IPv4 address.
+ /// Returns [`true`] if the [IP address] in this `SocketAddr` is an
+ /// [IPv6 address], and [`false`] otherwise.
+ ///
+ /// [`true`]: ../../std/primitive.bool.html
+ /// [`false`]: ../../std/primitive.bool.html
+ /// [IP address]: ../../std/net/enum.IpAddr.html
+ /// [IPv6 address]: ../../std/net/enum.IpAddr.html#variant.V6
///
/// # Examples
///
}
impl SocketAddrV4 {
- /// Creates a new socket address from the (ip, port) pair.
+ /// Creates a new socket address from an [IPv4 address] and a port number.
+ ///
+ /// [IPv4 address]: ../../std/net/struct.Ipv4Addr.html
///
/// # Examples
///
}
}
- /// Change the IP address associated with this socket address.
+ /// Changes the IP address associated with this socket address.
///
/// # Examples
///
ntoh(self.inner.sin_port)
}
- /// Change the port number associated with this socket address.
+ /// Changes the port number associated with this socket address.
///
/// # Examples
///
}
impl SocketAddrV6 {
- /// Creates a new socket address from the ip/port/flowinfo/scope_id
- /// components.
+ /// Creates a new socket address from an [IPv6 address], a 16-bit port number,
+ /// and the `flowinfo` and `scope_id` fields.
+ ///
+ /// For more information on the meaning and layout of the `flowinfo` and `scope_id`
+ /// parameters, see [IETF RFC 2553, Section 3.3].
+ ///
+ /// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3
+ /// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html
///
/// # Examples
///
}
}
- /// Change the IP address associated with this socket address.
+ /// Changes the IP address associated with this socket address.
///
/// # Examples
///
ntoh(self.inner.sin6_port)
}
- /// Change the port number associated with this socket address.
+ /// Changes the port number associated with this socket address.
///
/// # Examples
///
self.inner.sin6_port = hton(new_port);
}
- /// Returns the flow information associated with this address,
- /// corresponding to the `sin6_flowinfo` field in C.
+ /// Returns the flow information associated with this address.
+ ///
+ /// This information corresponds to the `sin6_flowinfo` field in C's `netinet/in.h`,
+ /// as specified in [IETF RFC 2553, Section 3.3].
+ /// It combines information about the flow label and the traffic class as specified
+ /// in [IETF RFC 2460], respectively [Section 6] and [Section 7].
+ ///
+ /// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3
+ /// [IETF RFC 2460]: https://tools.ietf.org/html/rfc2460
+ /// [Section 6]: https://tools.ietf.org/html/rfc2460#section-6
+ /// [Section 7]: https://tools.ietf.org/html/rfc2460#section-7
///
/// # Examples
///
self.inner.sin6_flowinfo
}
- /// Change the flow information associated with this socket address.
+ /// Changes the flow information associated with this socket address.
+ ///
+ /// See the [`flowinfo`] method's documentation for more details.
+ ///
+ /// [`flowinfo`]: #method.flowinfo
///
/// # Examples
///
self.inner.sin6_flowinfo = new_flowinfo;
}
- /// Returns the scope ID associated with this address,
- /// corresponding to the `sin6_scope_id` field in C.
+ /// Returns the scope ID associated with this address.
+ ///
+ /// This information corresponds to the `sin6_scope_id` field in C's `netinet/in.h`,
+ /// as specified in [IETF RFC 2553, Section 3.3].
+ ///
+ /// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3
///
/// # Examples
///
/// Change the scope ID associated with this socket address.
///
+ /// See the [`scope_id`] method's documentation for more details.
+ ///
+ /// [`scope_id`]: #method.scope_id
+ ///
/// # Examples
///
/// ```
}
/// A trait for objects which can be converted or resolved to one or more
-/// `SocketAddr` values.
+/// [`SocketAddr`] values.
///
/// This trait is used for generic address resolution when constructing network
/// objects. By default it is implemented for the following types:
///
-/// * `SocketAddr`, `SocketAddrV4`, `SocketAddrV6` - `to_socket_addrs` is
-/// identity function.
+/// * [`SocketAddr`]: [`to_socket_addrs`] is the identity function.
///
-/// * `(IpvNAddr, u16)` - `to_socket_addrs` constructs `SocketAddr` trivially.
+/// * [`SocketAddrV4`], [`SocketAddrV6`], `(`[`IpAddr`]`, `[`u16`]`)`,
+/// `(`[`Ipv4Addr`]`, `[`u16`]`)`, `(`[`Ipv6Addr`]`, `[`u16`]`)`:
+/// [`to_socket_addrs`] constructs a [`SocketAddr`] trivially.
///
-/// * `(&str, u16)` - the string should be either a string representation of an
-/// IP address expected by `FromStr` implementation for `IpvNAddr` or a host
+/// * `(`[`&str`]`, `[`u16`]`)`: the string should be either a string representation
+/// of an [`IpAddr`] address as expected by [`FromStr`] implementation or a host
/// name.
///
-/// * `&str` - the string should be either a string representation of a
-/// `SocketAddr` as expected by its `FromStr` implementation or a string like
-/// `<host_name>:<port>` pair where `<port>` is a `u16` value.
+/// * [`&str`]: the string should be either a string representation of a
+/// [`SocketAddr`] as expected by its [`FromStr`] implementation or a string like
+/// `<host_name>:<port>` pair where `<port>` is a [`u16`] value.
///
-/// This trait allows constructing network objects like `TcpStream` or
-/// `UdpSocket` easily with values of various types for the bind/connection
+/// This trait allows constructing network objects like [`TcpStream`] or
+/// [`UdpSocket`] easily with values of various types for the bind/connection
/// address. It is needed because sometimes one type is more appropriate than
/// the other: for simple uses a string like `"localhost:12345"` is much nicer
-/// than manual construction of the corresponding `SocketAddr`, but sometimes
-/// `SocketAddr` value is *the* main source of the address, and converting it to
+/// than manual construction of the corresponding [`SocketAddr`], but sometimes
+/// [`SocketAddr`] value is *the* main source of the address, and converting it to
/// some other type (e.g. a string) just for it to be converted back to
-/// `SocketAddr` in constructor methods is pointless.
+/// [`SocketAddr`] in constructor methods is pointless.
///
/// Addresses returned by the operating system that are not IP addresses are
/// silently ignored.
///
-/// Some examples:
+/// [`FromStr`]: ../../std/str/trait.FromStr.html
+/// [`IpAddr`]: ../../std/net/enum.IpAddr.html
+/// [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html
+/// [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html
+/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html
+/// [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html
+/// [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html
+/// [`&str`]: ../../std/primitive.str.html
+/// [`TcpStream`]: ../../std/net/struct.TcpStream.html
+/// [`to_socket_addrs`]: #tymethod.to_socket_addrs
+/// [`UdpSocket`]: ../../std/net/struct.UdpSocket.html
+/// [`u16`]: ../../std/primitive.u16.html
+///
+/// # Examples
///
/// ```no_run
/// use std::net::{SocketAddrV4, TcpStream, UdpSocket, TcpListener, Ipv4Addr};
///
/// Note that this function may block the current thread while resolution is
/// performed.
- ///
- /// # Errors
- ///
- /// Any errors encountered during resolution will be returned as an `Err`.
#[stable(feature = "rust1", since = "1.0.0")]
fn to_socket_addrs(&self) -> io::Result<Self::Iter>;
}
use sys::net::netc as c;
use sys_common::{AsInner, FromInner};
-/// An IP address, either an IPv4 or IPv6 address.
+/// An IP address, either IPv4 or IPv6.
///
-/// # Examples
+/// This enum can contain either an [`Ipv4Addr`] or an [`Ipv6Addr`], see their
+/// respective documentation for more details.
///
-/// Constructing an IPv4 address:
+/// [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html
+/// [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html
///
-/// ```
-/// use std::net::{IpAddr, Ipv4Addr};
+/// # Examples
///
-/// IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
/// ```
+/// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
///
-/// Constructing an IPv6 address:
+/// let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
+/// let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
///
-/// ```
-/// use std::net::{IpAddr, Ipv6Addr};
+/// assert_eq!("127.0.0.1".parse(), Ok(localhost_v4));
+/// assert_eq!("::1".parse(), Ok(localhost_v6));
///
-/// IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
+/// assert_eq!(localhost_v4.is_ipv6(), false);
+/// assert_eq!(localhost_v4.is_ipv4(), true);
/// ```
#[stable(feature = "ip_addr", since = "1.7.0")]
#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash, PartialOrd, Ord)]
pub enum IpAddr {
- /// Representation of an IPv4 address.
+ /// An IPv4 address.
#[stable(feature = "ip_addr", since = "1.7.0")]
V4(#[stable(feature = "ip_addr", since = "1.7.0")] Ipv4Addr),
- /// Representation of an IPv6 address.
+ /// An IPv6 address.
#[stable(feature = "ip_addr", since = "1.7.0")]
V6(#[stable(feature = "ip_addr", since = "1.7.0")] Ipv6Addr),
}
-/// Representation of an IPv4 address.
+/// An IPv4 address.
+///
+/// IPv4 addresses are defined as 32-bit integers in [IETF RFC 791].
+/// They are usually represented as four octets.
+///
+/// See [`IpAddr`] for a type encompassing both IPv4 and IPv6 addresses.
+///
+/// [IETF RFC 791]: https://tools.ietf.org/html/rfc791
+/// [`IpAddr`]: ../../std/net/enum.IpAddr.html
+///
+/// # Textual representation
+///
+/// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal
+/// notation, divided by `.` (this is called "dot-decimal notation").
+///
+/// [`FromStr`]: ../../std/str/trait.FromStr.html
+///
+/// # Examples
+///
+/// ```
+/// use std::net::Ipv4Addr;
+///
+/// let localhost = Ipv4Addr::new(127, 0, 0, 1);
+/// assert_eq!("127.0.0.1".parse(), Ok(localhost));
+/// assert_eq!(localhost.is_loopback(), true);
+/// ```
#[derive(Copy)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Ipv4Addr {
inner: c::in_addr,
}
-/// Representation of an IPv6 address.
+/// An IPv6 address.
+///
+/// IPv6 addresses are defined as 128-bit integers in [IETF RFC 4291].
+/// They are usually represented as eight 16-bit segments.
+///
+/// See [`IpAddr`] for a type encompassing both IPv4 and IPv6 addresses.
+///
+/// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291
+/// [`IpAddr`]: ../../std/net/enum.IpAddr.html
+///
+/// # Textual representation
+///
+/// `Ipv6Addr` provides a [`FromStr`] implementation. There are many ways to represent
+/// an IPv6 address in text, but in general, each segments is written in hexadecimal
+/// notation, and segments are separated by `:`. For more information, see
+/// [IETF RFC 5952].
+///
+/// [`FromStr`]: ../../std/str/trait.FromStr.html
+/// [IETF RFC 5952]: https://tools.ietf.org/html/rfc5952
+///
+/// # Examples
+///
+/// ```
+/// use std::net::Ipv6Addr;
+///
+/// let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+/// assert_eq!("::1".parse(), Ok(localhost));
+/// assert_eq!(localhost.is_loopback(), true);
+/// ```
#[derive(Copy)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Ipv6Addr {
}
impl IpAddr {
- /// Returns true for the special 'unspecified' address ([IPv4], [IPv6]).
+ /// Returns [`true`] for the special 'unspecified' address.
+ ///
+ /// See the documentation for [`Ipv4Addr::is_unspecified`][IPv4] and
+ /// [`Ipv6Addr::is_unspecified`][IPv6] for more details.
///
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_unspecified
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_unspecified
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
}
}
- /// Returns true if this is a loopback address ([IPv4], [IPv6]).
+ /// Returns [`true`] if this is a loopback address.
+ ///
+ /// See the documentation for [`Ipv4Addr::is_loopback`][IPv4] and
+ /// [`Ipv6Addr::is_loopback`][IPv6] for more details.
///
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_loopback
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_loopback
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
}
}
- /// Returns true if the address appears to be globally routable ([IPv4], [IPv6]).
+ /// Returns [`true`] if the address appears to be globally routable.
+ ///
+ /// See the documentation for [`Ipv4Addr::is_global`][IPv4] and
+ /// [`Ipv6Addr::is_global`][IPv6] for more details.
///
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_global
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_global
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
}
}
- /// Returns true if this is a multicast address ([IPv4], [IPv6]).
+ /// Returns [`true`] if this is a multicast address.
+ ///
+ /// See the documentation for [`Ipv4Addr::is_multicast`][IPv4] and
+ /// [`Ipv6Addr::is_multicast`][IPv6] for more details.
///
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_multicast
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_multicast
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
}
}
- /// Returns true if this address is in a range designated for documentation ([IPv4], [IPv6]).
+ /// Returns [`true`] if this address is in a range designated for documentation.
+ ///
+ /// See the documentation for [`Ipv4Addr::is_documentation`][IPv4] and
+ /// [`Ipv6Addr::is_documentation`][IPv6] for more details.
///
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_documentation
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_documentation
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
}
}
- /// Returns true if this address is a valid IPv4 address, false if it's a valid IPv6 address.
+ /// Returns [`true`] if this address is an [IPv4 address], and [`false`] otherwise.
+ ///
+ /// [`true`]: ../../std/primitive.bool.html
+ /// [`false`]: ../../std/primitive.bool.html
+ /// [IPv4 address]: #variant.V4
///
/// # Examples
///
}
}
- /// Returns true if this address is a valid IPv6 address, false if it's a valid IPv4 address.
+ /// Returns [`true`] if this address is an [IPv6 address], and [`false`] otherwise.
+ ///
+ /// [`true`]: ../../std/primitive.bool.html
+ /// [`false`]: ../../std/primitive.bool.html
+ /// [IPv6 address]: #variant.V6
///
/// # Examples
///
[(bits >> 24) as u8, (bits >> 16) as u8, (bits >> 8) as u8, bits as u8]
}
- /// Returns true for the special 'unspecified' address (0.0.0.0).
+ /// Returns [`true`] for the special 'unspecified' address (0.0.0.0).
///
/// This property is defined in _UNIX Network Programming, Second Edition_,
/// W. Richard Stevens, p. 891; see also [ip7].
///
/// [ip7]: http://man7.org/linux/man-pages/man7/ip.7.html
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
self.inner.s_addr == 0
}
- /// Returns true if this is a loopback address (127.0.0.0/8).
+ /// Returns [`true`] if this is a loopback address (127.0.0.0/8).
///
- /// This property is defined by [RFC 1122].
+ /// This property is defined by [IETF RFC 1122].
///
- /// [RFC 1122]: https://tools.ietf.org/html/rfc1122
+ /// [IETF RFC 1122]: https://tools.ietf.org/html/rfc1122
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
self.octets()[0] == 127
}
- /// Returns true if this is a private address.
+ /// Returns [`true`] if this is a private address.
///
- /// The private address ranges are defined in [RFC 1918] and include:
+ /// The private address ranges are defined in [IETF RFC 1918] and include:
///
/// - 10.0.0.0/8
/// - 172.16.0.0/12
/// - 192.168.0.0/16
///
- /// [RFC 1918]: https://tools.ietf.org/html/rfc1918
+ /// [IETF RFC 1918]: https://tools.ietf.org/html/rfc1918
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
}
}
- /// Returns true if the address is link-local (169.254.0.0/16).
+ /// Returns [`true`] if the address is link-local (169.254.0.0/16).
///
- /// This property is defined by [RFC 3927].
+ /// This property is defined by [IETF RFC 3927].
///
- /// [RFC 3927]: https://tools.ietf.org/html/rfc3927
+ /// [IETF RFC 3927]: https://tools.ietf.org/html/rfc3927
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
self.octets()[0] == 169 && self.octets()[1] == 254
}
- /// Returns true if the address appears to be globally routable.
+ /// Returns [`true`] if the address appears to be globally routable.
/// See [iana-ipv4-special-registry][ipv4-sr].
///
/// The following return false:
/// - the unspecified address (0.0.0.0)
///
/// [ipv4-sr]: http://goo.gl/RaZ7lg
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
!self.is_broadcast() && !self.is_documentation() && !self.is_unspecified()
}
- /// Returns true if this is a multicast address (224.0.0.0/4).
+ /// Returns [`true`] if this is a multicast address (224.0.0.0/4).
///
/// Multicast addresses have a most significant octet between 224 and 239,
- /// and is defined by [RFC 5771].
+ /// and is defined by [IETF RFC 5771].
///
- /// [RFC 5771]: https://tools.ietf.org/html/rfc5771
+ /// [IETF RFC 5771]: https://tools.ietf.org/html/rfc5771
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
self.octets()[0] >= 224 && self.octets()[0] <= 239
}
- /// Returns true if this is a broadcast address (255.255.255.255).
+ /// Returns [`true`] if this is a broadcast address (255.255.255.255).
///
- /// A broadcast address has all octets set to 255 as defined in [RFC 919].
+ /// A broadcast address has all octets set to 255 as defined in [IETF RFC 919].
///
- /// [RFC 919]: https://tools.ietf.org/html/rfc919
+ /// [IETF RFC 919]: https://tools.ietf.org/html/rfc919
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
self.octets()[2] == 255 && self.octets()[3] == 255
}
- /// Returns true if this address is in a range designated for documentation.
+ /// Returns [`true`] if this address is in a range designated for documentation.
///
- /// This is defined in [RFC 5737]:
+ /// This is defined in [IETF RFC 5737]:
///
/// - 192.0.2.0/24 (TEST-NET-1)
/// - 198.51.100.0/24 (TEST-NET-2)
/// - 203.0.113.0/24 (TEST-NET-3)
///
- /// [RFC 5737]: https://tools.ietf.org/html/rfc5737
+ /// [IETF RFC 5737]: https://tools.ietf.org/html/rfc5737
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
}
}
- /// Converts this address to an IPv4-compatible IPv6 address.
+ /// Converts this address to an IPv4-compatible [IPv6 address].
///
/// a.b.c.d becomes ::a.b.c.d
///
+ /// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html
+ ///
/// # Examples
///
/// ```
((self.octets()[2] as u16) << 8) | self.octets()[3] as u16)
}
- /// Converts this address to an IPv4-mapped IPv6 address.
+ /// Converts this address to an IPv4-mapped [IPv6 address].
///
/// a.b.c.d becomes ::ffff:a.b.c.d
///
+ /// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html
+ ///
/// # Examples
///
/// ```
]
}
- /// Returns true for the special 'unspecified' address (::).
+ /// Returns [`true`] for the special 'unspecified' address (::).
///
- /// This property is defined in [RFC 4291].
+ /// This property is defined in [IETF RFC 4291].
///
- /// [RFC 4291]: https://tools.ietf.org/html/rfc4291
+ /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
self.segments() == [0, 0, 0, 0, 0, 0, 0, 0]
}
- /// Returns true if this is a loopback address (::1).
+ /// Returns [`true`] if this is a loopback address (::1).
///
- /// This property is defined in [RFC 4291].
+ /// This property is defined in [IETF RFC 4291].
///
- /// [RFC 4291]: https://tools.ietf.org/html/rfc4291
+ /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
self.segments() == [0, 0, 0, 0, 0, 0, 0, 1]
}
- /// Returns true if the address appears to be globally routable.
+ /// Returns [`true`] if the address appears to be globally routable.
///
- /// The following return false:
+ /// The following return [`false`]:
///
/// - the loopback address
/// - link-local, site-local, and unique local unicast addresses
/// - interface-, link-, realm-, admin- and site-local multicast addresses
///
+ /// [`true`]: ../../std/primitive.bool.html
+ /// [`false`]: ../../std/primitive.bool.html
+ ///
/// # Examples
///
/// ```
}
}
- /// Returns true if this is a unique local address (fc00::/7).
+ /// Returns [`true`] if this is a unique local address (fc00::/7).
///
- /// This property is defined in [RFC 4193].
+ /// This property is defined in [IETF RFC 4193].
///
- /// [RFC 4193]: https://tools.ietf.org/html/rfc4193
+ /// [IETF RFC 4193]: https://tools.ietf.org/html/rfc4193
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
(self.segments()[0] & 0xfe00) == 0xfc00
}
- /// Returns true if the address is unicast and link-local (fe80::/10).
+ /// Returns [`true`] if the address is unicast and link-local (fe80::/10).
///
- /// This property is defined in [RFC 4291].
+ /// This property is defined in [IETF RFC 4291].
///
- /// [RFC 4291]: https://tools.ietf.org/html/rfc4291
+ /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
(self.segments()[0] & 0xffc0) == 0xfe80
}
- /// Returns true if this is a deprecated unicast site-local address
+ /// Returns [`true`] if this is a deprecated unicast site-local address
/// (fec0::/10).
///
+ /// [`true`]: ../../std/primitive.bool.html
+ ///
/// # Examples
///
/// ```
(self.segments()[0] & 0xffc0) == 0xfec0
}
- /// Returns true if this is an address reserved for documentation
+ /// Returns [`true`] if this is an address reserved for documentation
/// (2001:db8::/32).
///
- /// This property is defined in [RFC 3849].
+ /// This property is defined in [IETF RFC 3849].
///
- /// [RFC 3849]: https://tools.ietf.org/html/rfc3849
+ /// [IETF RFC 3849]: https://tools.ietf.org/html/rfc3849
+ /// [`true`]: ../../std/primitive.bool.html
///
/// # Examples
///
(self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
}
- /// Returns true if the address is a globally routable unicast address.
+ /// Returns [`true`] if the address is a globally routable unicast address.
///
/// The following return false:
///
/// - the unspecified address
/// - the address range reserved for documentation
///
+ /// [`true`]: ../../std/primitive.bool.html
+ ///
/// # Examples
///
/// ```
}
}
- /// Returns true if this is a multicast address (ff00::/8).
+ /// Returns [`true`] if this is a multicast address (ff00::/8).
+ ///
+ /// This property is defined by [IETF RFC 4291].
///
- /// This property is defined by [RFC 4291].
+ /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291
+ /// [`true`]: ../../std/primitive.bool.html
///
- /// [RFC 4291]: https://tools.ietf.org/html/rfc4291
/// # Examples
///
/// ```
(self.segments()[0] & 0xff00) == 0xff00
}
- /// Converts this address to an IPv4 address. Returns None if this address is
+ /// Converts this address to an [IPv4 address]. Returns [`None`] if this address is
/// neither IPv4-compatible or IPv4-mapped.
///
/// ::a.b.c.d and ::ffff:a.b.c.d become a.b.c.d
///
+ /// [IPv4 address]: ../../std/net/struct.Ipv4Addr.html
+ /// [`None`]: ../../std/option/enum.Option.html#variant.None
+ ///
+ /// # Examples
+ ///
/// ```
/// use std::net::{Ipv4Addr, Ipv6Addr};
///
// except according to those terms.
//! Networking primitives for TCP/UDP communication.
+//!
+//! This module provides networking functionality for the Transmission Control and User
+//! Datagram Protocols, as well as types for IP and socket addresses.
+//!
+//! # Organization
+//!
+//! * [`TcpListener`] and [`TcpStream`] provide functionality for communication over TCP
+//! * [`UdpSocket`] provides functionality for communication over UDP
+//! * [`IpAddr`] represents IP addresses of either IPv4 or IPv6; [`Ipv4Addr`] and
+//! [`Ipv6Addr`] are respectively IPv4 and IPv6 addresses
+//! * [`SocketAddr`] represents socket addresses of either IPv4 or IPv6; [`SocketAddrV4`]
+//! and [`SocketAddrV6`] are respectively IPv4 and IPv6 socket addresses
+//! * [`ToSocketAddrs`] is a trait that used for generic address resolution when interacting
+//! with networking objects like [`TcpListener`], [`TcpStream`] or [`UdpSocket`]
+//! * Other types are return or parameter types for various methods in this module
+//!
+//! [`IpAddr`]: ../../std/net/enum.IpAddr.html
+//! [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html
+//! [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html
+//! [`SocketAddr`]: ../../std/net/enum.SocketAddr.html
+//! [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html
+//! [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html
+//! [`TcpListener`]: ../../std/net/struct.TcpListener.html
+//! [`TcpStream`]: ../../std/net/struct.TcpStream.html
+//! [`ToSocketAddrs`]: ../../std/net/trait.ToSocketAddrs.html
+//! [`UdpSocket`]: ../../std/net/struct.UdpSocket.html
#![stable(feature = "rust1", since = "1.0.0")]
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum Shutdown {
- /// Indicates that the reading portion of this stream/socket should be shut
- /// down. All currently blocked and future reads will return `Ok(0)`.
+ /// The reading portion of the [`TcpStream`] should be shut down.
+ ///
+ /// All currently blocked and future [reads] will return [`Ok(0)`].
+ ///
+ /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
+ /// [reads]: ../../std/io/trait.Read.html
+ /// [`Ok(0)`]: ../../std/result/enum.Result.html#variant.Ok
#[stable(feature = "rust1", since = "1.0.0")]
Read,
- /// Indicates that the writing portion of this stream/socket should be shut
- /// down. All currently blocked and future writes will return an error.
+ /// The writing portion of the [`TcpStream`] should be shut down.
+ ///
+ /// All currently blocked and future [writes] will return an error.
+ ///
+ /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
+ /// [writes]: ../../std/io/trait.Write.html
#[stable(feature = "rust1", since = "1.0.0")]
Write,
- /// Shut down both the reading and writing portions of this stream.
+ /// Both the reading and the writing portions of the [`TcpStream`] should be shut down.
+ ///
+ /// See [`Shutdown::Read`] and [`Shutdown::Write`] for more information.
///
- /// See `Shutdown::Read` and `Shutdown::Write` for more information.
+ /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
+ /// [`Shutdown::Read`]: #variant.Read
+ /// [`Shutdown::Write`]: #variant.Write
#[stable(feature = "rust1", since = "1.0.0")]
Both,
}
}
}
-/// An error returned when parsing an IP address or a socket address.
+/// An error which can be returned when parsing an IP address or a socket address.
+///
+/// This error is used as the error type for the [`FromStr`] implementation for
+/// [`IpAddr`], [`Ipv4Addr`], [`Ipv6Addr`], [`SocketAddr`], [`SocketAddrV4`], and
+/// [`SocketAddrV6`].
+///
+/// [`FromStr`]: ../../std/str/trait.FromStr.html
+/// [`IpAddr`]: ../../std/net/enum.IpAddr.html
+/// [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html
+/// [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html
+/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html
+/// [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html
+/// [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html
#[stable(feature = "rust1", since = "1.0.0")]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AddrParseError(());
use sys_common::{AsInner, FromInner, IntoInner};
use time::Duration;
-/// A structure which represents a TCP stream between a local socket and a
-/// remote socket.
+/// A TCP stream between a local and a remote socket.
///
-/// The socket will be closed when the value is dropped.
+/// After creating a `TcpStream` by either [`connect`]ing to a remote host or
+/// [`accept`]ing a connection on a [`TcpListener`], data can be transmitted
+/// by [reading] and [writing] to it.
+///
+/// The connection will be closed when the value is dropped. The reading and writing
+/// portions of the connection can also be shut down individually with the [`shutdown`]
+/// method.
+///
+/// The Transmission Control Protocol is specified in [IETF RFC 793].
+///
+/// [`accept`]: ../../std/net/struct.TcpListener.html#method.accept
+/// [`connect`]: #method.connect
+/// [IETF RFC 793]: https://tools.ietf.org/html/rfc793
+/// [reading]: ../../std/io/trait.Read.html
+/// [`shutdown`]: #method.shutdown
+/// [`TcpListener`]: ../../std/net/struct.TcpListener.html
+/// [writing]: ../../std/io/trait.Write.html
///
/// # Examples
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct TcpStream(net_imp::TcpStream);
-/// A structure representing a socket server.
+/// A TCP socket server, listening for connections.
+///
+/// After creating a `TcpListener` by [`bind`]ing it to a socket address, it listens
+/// for incoming TCP connections. These can be accepted by calling [`accept`] or by
+/// iterating over the [`Incoming`] iterator returned by [`incoming`].
+///
+/// The socket will be closed when the value is dropped.
+///
+/// The Transmission Control Protocol is specified in [IETF RFC 793].
+///
+/// [`accept`]: #method.accept
+/// [`bind`]: #method.bind
+/// [IETF RFC 793]: https://tools.ietf.org/html/rfc793
+/// [`Incoming`]: ../../std/net/struct.Incoming.html
+/// [`incoming`]: #method.incoming
///
/// # Examples
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct TcpListener(net_imp::TcpListener);
-/// An infinite iterator over the connections from a `TcpListener`.
-///
-/// This iterator will infinitely yield [`Some`] of the accepted connections. It
-/// is equivalent to calling `accept` in a loop.
+/// An iterator that infinitely [`accept`]s connections on a [`TcpListener`].
///
/// This `struct` is created by the [`incoming`] method on [`TcpListener`].
+/// See its documentation for more.
///
-/// [`Some`]: ../../std/option/enum.Option.html#variant.Some
-/// [`incoming`]: struct.TcpListener.html#method.incoming
-/// [`TcpListener`]: struct.TcpListener.html
+/// [`accept`]: ../../std/net/struct.TcpListener.html#method.accept
+/// [`incoming`]: ../../std/net/struct.TcpListener.html#method.incoming
+/// [`TcpListener`]: ../../std/net/struct.TcpListener.html
#[stable(feature = "rust1", since = "1.0.0")]
#[derive(Debug)]
pub struct Incoming<'a> { listener: &'a TcpListener }
/// Opens a TCP connection to a remote host.
///
/// `addr` is an address of the remote host. Anything which implements
- /// `ToSocketAddrs` trait can be supplied for the address; see this trait
+ /// [`ToSocketAddrs`] trait can be supplied for the address; see this trait
/// documentation for concrete examples.
- /// In case `ToSocketAddrs::to_socket_addrs()` returns more than one entry,
+ /// In case [`ToSocketAddrs::to_socket_addrs()`] returns more than one entry,
/// then the first valid and reachable address is used.
///
+ /// [`ToSocketAddrs`]: ../../std/net/trait.ToSocketAddrs.html
+ /// [`ToSocketAddrs::to_socket_addrs()`]:
+ /// ../../std/net/trait.ToSocketAddrs.html#tymethod.to_socket_addrs
+ ///
/// # Examples
///
/// ```no_run
///
/// Binding with a port number of 0 will request that the OS assigns a port
/// to this listener. The port allocated can be queried via the
- /// `local_addr` method.
+ /// [`local_addr`] method.
///
- /// The address type can be any implementor of `ToSocketAddrs` trait. See
+ /// The address type can be any implementor of [`ToSocketAddrs`] trait. See
/// its documentation for concrete examples.
///
+ /// [`local_addr`]: #method.local_addr
+ /// [`ToSocketAddrs`]: ../../std/net/trait.ToSocketAddrs.html
+ ///
/// # Examples
///
/// ```no_run
/// Creates a new independently owned handle to the underlying socket.
///
- /// The returned `TcpListener` is a reference to the same socket that this
+ /// The returned [`TcpListener`] is a reference to the same socket that this
/// object references. Both handles can be used to accept incoming
/// connections and options set on one listener will affect the other.
///
+ /// [`TcpListener`]: ../../std/net/struct.TcpListener.html
+ ///
/// # Examples
///
/// ```no_run
/// Accept a new incoming connection from this listener.
///
/// This function will block the calling thread until a new TCP connection
- /// is established. When established, the corresponding `TcpStream` and the
+ /// is established. When established, the corresponding [`TcpStream`] and the
/// remote peer's address will be returned.
///
+ /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
+ ///
/// # Examples
///
/// ```no_run
/// listener.
///
/// The returned iterator will never return [`None`] and will also not yield
- /// the peer's [`SocketAddr`] structure.
+ /// the peer's [`SocketAddr`] structure. Iterating over it is equivalent to
+ /// calling [`accept`] in a loop.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html
+ /// [`accept`]: #method.accept
///
/// # Examples
///
use sys_common::{AsInner, FromInner, IntoInner};
use time::Duration;
-/// A User Datagram Protocol socket.
+/// A UDP socket.
///
-/// This is an implementation of a bound UDP socket. This supports both IPv4 and
-/// IPv6 addresses, and there is no corresponding notion of a server because UDP
-/// is a datagram protocol.
+/// After creating a `UdpSocket` by [`bind`]ing it to a socket address, data can be
+/// [sent to] and [received from] any other socket address.
+///
+/// Although UDP is a connectionless protocol, this implementation provides an interface
+/// to set an address where data should be sent and received from. After setting a remote
+/// address with [`connect`], data can be sent to and received from that address with
+/// [`send`] and [`recv`].
+///
+/// As stated in the User Datagram Protocol's specification in [IETF RFC 768], UDP is
+/// an unordered, unreliable protocol; refer to [`TcpListener`] and [`TcpStream`] for TCP
+/// primitives.
+///
+/// [`bind`]: #method.bind
+/// [`connect`]: #method.connect
+/// [IETF RFC 768]: https://tools.ietf.org/html/rfc768
+/// [`recv`]: #method.recv
+/// [received from]: #method.recv_from
+/// [`send`]: #method.send
+/// [sent to]: #method.send_to
+/// [`TcpListener`]: ../../std/net/struct.TcpListener.html
+/// [`TcpStream`]: ../../std/net/struct.TcpStream.html
///
/// # Examples
///
/// Receives data on the socket from the remote address to which it is
/// connected.
///
- /// The `connect` method will connect this socket to a remote address. This
+ /// The [`connect`] method will connect this socket to a remote address. This
/// method will fail if the socket is not connected.
///
+ /// [`connect`]: #method.connect
+ ///
/// # Examples
///
/// ```no_run
use fmt;
-#[cfg(any(target_os = "android",
- target_os = "emscripten",
+#[cfg(any(target_os = "emscripten",
all(target_os = "linux", any(target_arch = "aarch64",
target_arch = "arm",
target_arch = "powerpc",
target_arch = "powerpc64",
target_arch = "s390x")),
+ all(target_os = "android", any(target_arch = "aarch64",
+ target_arch = "arm")),
all(target_os = "fuchsia", target_arch = "aarch64")))]
#[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = u8;
-#[cfg(not(any(target_os = "android",
- target_os = "emscripten",
+#[cfg(not(any(target_os = "emscripten",
all(target_os = "linux", any(target_arch = "aarch64",
target_arch = "arm",
target_arch = "powerpc",
target_arch = "powerpc64",
target_arch = "s390x")),
+ all(target_os = "android", any(target_arch = "aarch64",
+ target_arch = "arm")),
all(target_os = "fuchsia", target_arch = "aarch64"))))]
#[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = i8;
#[stable(feature = "raw_os", since = "1.1.0")] pub type c_schar = i8;
/// A synchronization primitive which can be used to run a one-time global
/// initialization. Useful for one-time initialization for FFI or related
-/// functionality. This type can only be constructed with the `ONCE_INIT`
+/// functionality. This type can only be constructed with the [`ONCE_INIT`]
/// value.
///
+/// [`ONCE_INIT`]: constant.ONCE_INIT.html
+///
/// # Examples
///
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl Send for Once {}
-/// State yielded to the `call_once_force` method which can be used to query
-/// whether the `Once` was previously poisoned or not.
+/// State yielded to the [`call_once_force`] method which can be used to query
+/// whether the [`Once`] was previously poisoned or not.
+///
+/// [`call_once_force`]: struct.Once.html#method.call_once_force
+/// [`Once`]: struct.Once.html
#[unstable(feature = "once_poison", issue = "33577")]
#[derive(Debug)]
pub struct OnceState {
poisoned: bool,
}
-/// Initialization value for static `Once` values.
+/// Initialization value for static [`Once`] values.
+///
+/// [`Once`]: struct.Once.html
+///
+/// # Examples
+///
+/// ```
+/// use std::sync::{Once, ONCE_INIT};
+///
+/// static START: Once = ONCE_INIT;
+/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub const ONCE_INIT: Once = Once::new();
self.call_inner(false, &mut |_| f.take().unwrap()());
}
- /// Performs the same function as `call_once` except ignores poisoning.
+ /// Performs the same function as [`call_once`] except ignores poisoning.
+ ///
+ /// [`call_once`]: struct.Once.html#method.call_once
///
/// If this `Once` has been poisoned (some initialization panicked) then
/// this function will continue to attempt to call initialization functions
/// until one of them doesn't panic.
///
- /// The closure `f` is yielded a structure which can be used to query the
+ /// The closure `f` is yielded a [`OnceState`] structure which can be used to query the
/// state of this `Once` (whether initialization has previously panicked or
/// not).
+ ///
+ /// [`OnceState`]: struct.OnceState.html
#[unstable(feature = "once_poison", issue = "33577")]
pub fn call_once_force<F>(&'static self, f: F) where F: FnOnce(&OnceState) {
// same as above, just with a different parameter to `call_inner`.
}
impl OnceState {
- /// Returns whether the associated `Once` has been poisoned.
+ /// Returns whether the associated [`Once`] has been poisoned.
///
- /// Once an initalization routine for a `Once` has panicked it will forever
+ /// Once an initalization routine for a [`Once`] has panicked it will forever
/// indicate to future forced initialization routines that it is poisoned.
+ ///
+ /// [`Once`]: struct.Once.html
#[unstable(feature = "once_poison", issue = "33577")]
pub fn poisoned(&self) -> bool {
self.poisoned
let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
let (addr, len) = sockaddr_un(path)?;
- cvt(libc::bind(*inner.as_inner(), &addr as *const _ as *const _, len))?;
+ cvt(libc::bind(*inner.as_inner(), &addr as *const _ as *const _, len as _))?;
cvt(libc::listen(*inner.as_inner(), 128))?;
Ok(UnixListener(inner))
let socket = UnixDatagram::unbound()?;
let (addr, len) = sockaddr_un(path)?;
- cvt(libc::bind(*socket.0.as_inner(), &addr as *const _ as *const _, len))?;
+ cvt(libc::bind(*socket.0.as_inner(), &addr as *const _ as *const _, len as _))?;
Ok(socket)
}
}
}
+ // Android with api less than 21 define sig* functions inline, so it is not
+ // available for dynamic link. Implementing sigemptyset and sigaddset allow us
+ // to support older Android version (independent of libc version).
+ // The following implementations are based on https://git.io/vSkNf
+
#[cfg(not(target_os = "android"))]
extern {
+ #[cfg_attr(target_os = "netbsd", link_name = "__sigemptyset14")]
+ fn sigemptyset(set: *mut libc::sigset_t) -> libc::c_int;
+
#[cfg_attr(target_os = "netbsd", link_name = "__sigaddset14")]
fn sigaddset(set: *mut libc::sigset_t, signum: libc::c_int) -> libc::c_int;
}
+ #[cfg(target_os = "android")]
+ unsafe fn sigemptyset(set: *mut libc::sigset_t) -> libc::c_int {
+ libc::memset(set as *mut _, 0, mem::size_of::<libc::sigset_t>());
+ return 0;
+ }
+
#[cfg(target_os = "android")]
unsafe fn sigaddset(set: *mut libc::sigset_t, signum: libc::c_int) -> libc::c_int {
use slice;
let mut set: libc::sigset_t = mem::uninitialized();
let mut old_set: libc::sigset_t = mem::uninitialized();
- t!(cvt(libc::sigemptyset(&mut set)));
+ t!(cvt(sigemptyset(&mut set)));
t!(cvt(sigaddset(&mut set, libc::SIGINT)));
t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set, &mut old_set)));
// need to clean things up now to avoid confusing the program
// we're about to run.
let mut set: libc::sigset_t = mem::uninitialized();
- t!(cvt(libc::sigemptyset(&mut set)));
+ if cfg!(target_os = "android") {
+ // Implementing sigemptyset allow us to support older Android
+ // versions. See the comment about Android and sig* functions in
+ // process_common.rs
+ libc::memset(&mut set as *mut _ as *mut _,
+ 0,
+ mem::size_of::<libc::sigset_t>());
+ } else {
+ t!(cvt(libc::sigemptyset(&mut set)));
+ }
t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set,
ptr::null_mut())));
let ret = sys::signal(libc::SIGPIPE, libc::SIG_DFL);
// INVALID_HANDLE_VALUE.
Stdio::Inherit => {
match stdio::get(stdio_id) {
- Ok(io) => io.handle().duplicate(0, true,
- c::DUPLICATE_SAME_ACCESS),
+ Ok(io) => {
+ let io = Handle::new(io.handle());
+ let ret = io.duplicate(0, true,
+ c::DUPLICATE_SAME_ACCESS);
+ io.into_raw();
+ return ret
+ }
Err(..) => Ok(Handle::new(c::INVALID_HANDLE_VALUE)),
}
}
use sys::handle::Handle;
use sys_common::io::read_to_end_uninitialized;
-pub struct NoClose(Option<Handle>);
-
pub enum Output {
- Console(NoClose),
- Pipe(NoClose),
+ Console(c::HANDLE),
+ Pipe(c::HANDLE),
}
pub struct Stdin {
- handle: Output,
utf8: Mutex<io::Cursor<Vec<u8>>>,
}
-pub struct Stdout(Output);
-pub struct Stderr(Output);
+pub struct Stdout;
+pub struct Stderr;
pub fn get(handle: c::DWORD) -> io::Result<Output> {
let handle = unsafe { c::GetStdHandle(handle) };
if handle == c::INVALID_HANDLE_VALUE {
Err(io::Error::last_os_error())
} else if handle.is_null() {
- Err(io::Error::new(io::ErrorKind::Other,
- "no stdio handle available for this process"))
+ Err(io::Error::from_raw_os_error(c::ERROR_INVALID_HANDLE as i32))
} else {
- let ret = NoClose::new(handle);
let mut out = 0;
match unsafe { c::GetConsoleMode(handle, &mut out) } {
- 0 => Ok(Output::Pipe(ret)),
- _ => Ok(Output::Console(ret)),
+ 0 => Ok(Output::Pipe(handle)),
+ _ => Ok(Output::Console(handle)),
}
}
}
-fn write(out: &Output, data: &[u8]) -> io::Result<usize> {
- let handle = match *out {
- Output::Console(ref c) => c.get().raw(),
- Output::Pipe(ref p) => return p.get().write(data),
+fn write(handle: c::DWORD, data: &[u8]) -> io::Result<usize> {
+ let handle = match try!(get(handle)) {
+ Output::Console(c) => c,
+ Output::Pipe(p) => {
+ let handle = Handle::new(p);
+ let ret = handle.write(data);
+ handle.into_raw();
+ return ret
+ }
};
+
// As with stdin on windows, stdout often can't handle writes of large
// sizes. For an example, see #14940. For this reason, don't try to
// write the entire output buffer on windows.
impl Stdin {
pub fn new() -> io::Result<Stdin> {
- get(c::STD_INPUT_HANDLE).map(|handle| {
- Stdin {
- handle: handle,
- utf8: Mutex::new(Cursor::new(Vec::new())),
- }
+ Ok(Stdin {
+ utf8: Mutex::new(Cursor::new(Vec::new())),
})
}
pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
- let handle = match self.handle {
- Output::Console(ref c) => c.get().raw(),
- Output::Pipe(ref p) => return p.get().read(buf),
+ let handle = match try!(get(c::STD_INPUT_HANDLE)) {
+ Output::Console(c) => c,
+ Output::Pipe(p) => {
+ let handle = Handle::new(p);
+ let ret = handle.read(buf);
+ handle.into_raw();
+ return ret
+ }
};
let mut utf8 = self.utf8.lock().unwrap();
// Read more if the buffer is empty
Ok(utf8) => utf8.into_bytes(),
Err(..) => return Err(invalid_encoding()),
};
- if let Output::Console(_) = self.handle {
- if let Some(&last_byte) = data.last() {
- if last_byte == CTRL_Z {
- data.pop();
- }
+ if let Some(&last_byte) = data.last() {
+ if last_byte == CTRL_Z {
+ data.pop();
}
}
*utf8 = Cursor::new(data);
impl Stdout {
pub fn new() -> io::Result<Stdout> {
- get(c::STD_OUTPUT_HANDLE).map(Stdout)
+ Ok(Stdout)
}
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
- write(&self.0, data)
+ write(c::STD_OUTPUT_HANDLE, data)
}
pub fn flush(&self) -> io::Result<()> {
impl Stderr {
pub fn new() -> io::Result<Stderr> {
- get(c::STD_ERROR_HANDLE).map(Stderr)
+ Ok(Stderr)
}
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
- write(&self.0, data)
+ write(c::STD_ERROR_HANDLE, data)
}
pub fn flush(&self) -> io::Result<()> {
}
}
-impl NoClose {
- fn new(handle: c::HANDLE) -> NoClose {
- NoClose(Some(Handle::new(handle)))
- }
-
- fn get(&self) -> &Handle { self.0.as_ref().unwrap() }
-}
-
-impl Drop for NoClose {
- fn drop(&mut self) {
- self.0.take().unwrap().into_raw();
- }
-}
-
impl Output {
- pub fn handle(&self) -> &Handle {
- let nc = match *self {
- Output::Console(ref c) => c,
- Output::Pipe(ref c) => c,
- };
- nc.0.as_ref().unwrap()
+ pub fn handle(&self) -> c::HANDLE {
+ match *self {
+ Output::Console(c) => c,
+ Output::Pipe(c) => c,
+ }
}
}
// Bind our new socket
let (addrp, len) = addr.into_inner();
- cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })?;
+ cvt(unsafe { c::bind(*sock.as_inner(), addrp, len as _) })?;
// Start listening
cvt(unsafe { c::listen(*sock.as_inner(), 128) })?;
let sock = Socket::new(addr, c::SOCK_DGRAM)?;
let (addrp, len) = addr.into_inner();
- cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })?;
+ cvt(unsafe { c::bind(*sock.as_inner(), addrp, len as _) })?;
Ok(UdpSocket { inner: sock })
}
/// Returns an iterator that yields the uppercase equivalent of a `char`
/// as one or more `char`s.
///
- /// If a character does not have a uppercase equivalent, the same character
+ /// If a character does not have an uppercase equivalent, the same character
/// will be returned back by the iterator.
///
/// This performs complex unconditional mappings with no tailoring: it maps
- /// one Unicode character to its lowercase equivalent according to the
+ /// one Unicode character to its uppercase equivalent according to the
/// [Unicode database] and the additional complex mappings
/// [`SpecialCasing.txt`]. Conditional mappings (based on context or
/// language) are not considered here.
impl<'a, 'b> Folder for PlaceholderExpander<'a, 'b> {
fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
match item.node {
- ast::ItemKind::Mac(ref mac) if !mac.node.path.segments.is_empty() => {}
ast::ItemKind::Mac(_) => return self.remove(item.id).make_items(),
+ ast::ItemKind::MacroDef(_) => return SmallVector::one(item),
_ => {}
}
};
let mut p = Parser::new(cx.parse_sess(), tts, Some(directory), false);
p.root_module_name = cx.current_expansion.module.mod_path.last()
- .map(|id| (*id.name.as_str()).to_owned());
+ .map(|id| id.name.as_str().to_string());
p.check_unknown_macro_variable();
// Let the context choose how to interpret the result.
impl GatedCfg {
pub fn gate(cfg: &ast::MetaItem) -> Option<GatedCfg> {
- let name = &*cfg.name().as_str();
+ let name = cfg.name().as_str();
GATED_CFGS.iter()
.position(|info| info.0 == name)
.map(|idx| {
impl<'a> Context<'a> {
fn check_attribute(&self, attr: &ast::Attribute, is_macro: bool) {
debug!("check_attribute(attr = {:?})", attr);
- let name = unwrap_or!(attr.name(), return);
-
+ let name = unwrap_or!(attr.name(), return).as_str();
for &(n, ty, ref gateage) in BUILTIN_ATTRIBUTES {
if name == n {
if let &Gated(_, ref name, ref desc, ref has_feature) = gateage {
return;
}
}
- if name.as_str().starts_with("rustc_") {
+ if name.starts_with("rustc_") {
gate_feature!(self, rustc_attrs, attr.span,
"unless otherwise specified, attributes \
with the prefix `rustc_` \
are reserved for internal compiler diagnostics");
- } else if name.as_str().starts_with("derive_") {
+ } else if name.starts_with("derive_") {
gate_feature!(self, custom_derive, attr.span, EXPLAIN_DERIVE_UNDERSCORE);
} else if !attr::is_known(attr) {
// Only run the custom attribute lint during regular
fn push_directory(&mut self, id: Ident, attrs: &[Attribute]) {
if let Some(path) = attr::first_attr_value_str_by_name(attrs, "path") {
- self.directory.path.push(&*path.as_str());
+ self.directory.path.push(&path.as_str());
self.directory.ownership = DirectoryOwnership::Owned;
} else {
- self.directory.path.push(&*id.name.as_str());
+ self.directory.path.push(&id.name.as_str());
}
}
pub fn submod_path_from_attr(attrs: &[ast::Attribute], dir_path: &Path) -> Option<PathBuf> {
- attr::first_attr_value_str_by_name(attrs, "path").map(|d| dir_path.join(&*d.as_str()))
+ attr::first_attr_value_str_by_name(attrs, "path").map(|d| dir_path.join(&d.as_str()))
}
/// Returns either a path to a module, or .
}
}
-impl<'a> PartialEq<&'a str> for Symbol {
- fn eq(&self, other: &&str) -> bool {
- *self.as_str() == **other
+impl<T: ::std::ops::Deref<Target=str>> PartialEq<T> for Symbol {
+ fn eq(&self, other: &T) -> bool {
+ self.as_str() == other.deref()
}
}
/// destroyed. In particular, they must not access string contents. This can
/// be fixed in the future by just leaking all strings until thread death
/// somehow.
-#[derive(Clone, PartialEq, Hash, PartialOrd, Eq, Ord)]
+#[derive(Clone, Hash, PartialOrd, Eq, Ord)]
pub struct InternedString {
string: &'static str,
}
+impl<U: ?Sized> ::std::convert::AsRef<U> for InternedString where str: ::std::convert::AsRef<U> {
+ fn as_ref(&self) -> &U {
+ self.string.as_ref()
+ }
+}
+
+impl<T: ::std::ops::Deref<Target = str>> ::std::cmp::PartialEq<T> for InternedString {
+ fn eq(&self, other: &T) -> bool {
+ self.string == other.deref()
+ }
+}
+
+impl ::std::cmp::PartialEq<InternedString> for str {
+ fn eq(&self, other: &InternedString) -> bool {
+ self == other.string
+ }
+}
+
+impl<'a> ::std::cmp::PartialEq<InternedString> for &'a str {
+ fn eq(&self, other: &InternedString) -> bool {
+ *self == other.string
+ }
+}
+
+impl ::std::cmp::PartialEq<InternedString> for String {
+ fn eq(&self, other: &InternedString) -> bool {
+ self == other.string
+ }
+}
+
+impl<'a> ::std::cmp::PartialEq<InternedString> for &'a String {
+ fn eq(&self, other: &InternedString) -> bool {
+ *self == other.string
+ }
+}
+
impl !Send for InternedString { }
impl ::std::ops::Deref for InternedString {
fn is_test_crate(krate: &ast::Crate) -> bool {
match attr::find_crate_name(&krate.attrs) {
- Some(s) if "test" == &*s.as_str() => true,
+ Some(s) if "test" == s.as_str() => true,
_ => false
}
}
+++ /dev/null
-Subproject commit da282f1bb7277b4d30fa1599ee29ad8eb4dd2a92
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(rustdoc)]
+#![feature(rustc_private)]
extern crate rustdoc;
x; //~ value moved here
let y = Int(2);
- //~^use `mut y` here to make mutable
+ //~^ consider changing this to `mut y`
y //~ error: cannot borrow immutable local variable `y` as mutable
//~| cannot borrow
+=
let mut x: isize = 1;
let y: Box<_> = box &mut x;
let p = &y;
- ***p = 2; //~ ERROR cannot assign to data in an immutable container
+ ***p = 2; //~ ERROR cannot assign to data in a `&` reference
drop(p);
}
let p = &y;
let q = &***p;
**y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
- //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
let p = &y;
let q = &***p;
**y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
- //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
let p = &y.a;
let q = &***p;
**y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
- //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
let p = &y.a;
let q = &***p;
**y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
- //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
match op {
Some(ref v) => { let a = &mut v; },
//~^ ERROR:cannot borrow immutable
- //~| use `ref mut v` here to make mutable
+ //~| cannot borrow mutably
None => {},
}
}
--- /dev/null
+// 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.
+
+#![feature(closure_to_fn_coercion)]
+
+fn main() {
+ let bar: fn(&mut u32) = |_| {}; //~ ERROR mismatched types
+ //~| expected concrete lifetime, found bound lifetime parameter
+
+ fn foo(x: Box<Fn(&i32)>) {}
+ let bar = Box::new(|x: &i32| {}) as Box<Fn(_)>;
+ foo(bar); //~ ERROR mismatched types
+ //~| expected concrete lifetime, found bound lifetime parameter
+}
--- /dev/null
+// 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.
+
+trait T { m!(); } //~ ERROR cannot find macro `m!` in this scope
+
+struct S;
+impl S { m!(); } //~ ERROR cannot find macro `m!` in this scope
+
+fn main() {}
}
fn func(arg: S) {
- //~^ here to make mutable
+ //~^ consider changing this to `mut arg`
arg.mutate();
//~^ ERROR cannot borrow immutable argument
//~| cannot borrow mutably
fn main() {
let local = S;
- //~^ here to make mutable
+ //~^ consider changing this to `mut local`
local.mutate();
//~^ ERROR cannot borrow immutable local variable
//~| cannot borrow mutably
--- /dev/null
+// 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.
+
+#![feature(rustc_private)]
+
+extern crate rustc_back;
+
+use std::fs::File;
+use std::io::{Read, Write};
+
+use rustc_back::tempdir::TempDir;
+
+#[cfg(unix)]
+fn switch_stdout_to(file: File) {
+ use std::os::unix::prelude::*;
+
+ extern {
+ fn dup2(old: i32, new: i32) -> i32;
+ }
+
+ unsafe {
+ assert_eq!(dup2(file.as_raw_fd(), 1), 1);
+ }
+}
+
+#[cfg(windows)]
+fn switch_stdout_to(file: File) {
+ use std::os::windows::prelude::*;
+
+ extern "system" {
+ fn SetStdHandle(nStdHandle: u32, handle: *mut u8) -> i32;
+ }
+
+ const STD_OUTPUT_HANDLE: u32 = (-11i32) as u32;
+
+ unsafe {
+ let rc = SetStdHandle(STD_OUTPUT_HANDLE,
+ file.into_raw_handle() as *mut _);
+ assert!(rc != 0);
+ }
+}
+
+fn main() {
+ let td = TempDir::new("foo").unwrap();
+ let path = td.path().join("bar");
+ let f = File::create(&path).unwrap();
+
+ println!("foo");
+ std::io::stdout().flush().unwrap();
+ switch_stdout_to(f);
+ println!("bar");
+ std::io::stdout().flush().unwrap();
+
+ let mut contents = String::new();
+ File::open(&path).unwrap().read_to_string(&mut contents).unwrap();
+ assert_eq!(contents, "bar\n");
+}
--- /dev/null
+// 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.
+
+macro_rules! m {
+ ($e:expr) => {
+ macro_rules! n { () => { $e } }
+ }
+}
+
+fn main() {
+ m!(foo!());
+}
--> $DIR/huge_multispan_highlight.rs:100:18
|
12 | let x = "foo";
- | - use `mut x` here to make mutable
+ | - consider changing this to `mut x`
...
100 | let y = &mut x;
| ^ cannot borrow mutably
error: cannot borrow immutable argument `self` as mutable
--> $DIR/issue-31424.rs:23:15
|
+22 | fn bar(self: &mut Self) {
+ | ---- consider changing this to `mut self`
23 | (&mut self).bar();
| ^^^^ cannot borrow mutably
--- /dev/null
+// 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.
+
+struct Foo {
+ pub v: Vec<String>
+}
+
+fn main() {
+ let f = Foo { v: Vec::new() };
+ f.v.push("cat".to_string());
+}
+
+
+struct S {
+ x: i32,
+}
+fn foo() {
+ let s = S { x: 42 };
+ s.x += 1;
+}
+
+fn bar(s: S) {
+ s.x += 1;
+}
--- /dev/null
+error: cannot borrow immutable field `f.v` as mutable
+ --> $DIR/issue-35937.rs:17:5
+ |
+16 | let f = Foo { v: Vec::new() };
+ | - consider changing this to `mut f`
+17 | f.v.push("cat".to_string());
+ | ^^^ cannot mutably borrow immutable field
+
+error: cannot assign to immutable field `s.x`
+ --> $DIR/issue-35937.rs:26:5
+ |
+25 | let s = S { x: 42 };
+ | - consider changing this to `mut s`
+26 | s.x += 1;
+ | ^^^^^^^^ cannot mutably borrow immutable field
+
+error: cannot assign to immutable field `s.x`
+ --> $DIR/issue-35937.rs:30:5
+ |
+29 | fn bar(s: S) {
+ | - consider changing this to `mut s`
+30 | s.x += 1;
+ | ^^^^^^^^ cannot mutably borrow immutable field
+
+error: aborting due to 3 previous errors
+
--> $DIR/issue-38147-2.rs:17:9
|
12 | s: &'a String
- | ------------- use `&'a mut String` here to make mutable
+ | ---------- use `&'a mut String` here to make mutable
...
17 | self.s.push('x');
| ^^^^^^ cannot borrow as mutable
--> $DIR/issue-38147-3.rs:17:9
|
12 | s: &'a String
- | ------------- use `&'a mut String` here to make mutable
+ | ---------- use `&'a mut String` here to make mutable
...
-16 | fn f(&self) {
- | ----- use `&mut self` here to make mutable
17 | self.s.push('x');
| ^^^^^^ cannot borrow as mutable
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-enum X {
+pub enum X {
Y
}
-struct Z {
+pub struct Z {
x: X
}
let z = Z { x: X::Y };
let _ = &mut z.x;
}
+
+impl Z {
+ fn foo<'z>(&'z self) {
+ let _ = &mut self.x;
+ }
+
+ fn foo1(&self, other: &Z) {
+ let _ = &mut self.x;
+ let _ = &mut other.x;
+ }
+
+ fn foo2<'a>(&'a self, other: &Z) {
+ let _ = &mut self.x;
+ let _ = &mut other.x;
+ }
+
+ fn foo3<'a>(self: &'a Self, other: &Z) {
+ let _ = &mut self.x;
+ let _ = &mut other.x;
+ }
+
+ fn foo4(other: &Z) {
+ let _ = &mut other.x;
+ }
+
+}
+
+pub fn with_arg(z: Z, w: &Z) {
+ let _ = &mut z.x;
+ let _ = &mut w.x;
+}
21 | let _ = &mut z.x;
| ^^^ cannot mutably borrow immutable field
-error: aborting due to previous error
+error: cannot borrow immutable field `self.x` as mutable
+ --> $DIR/issue-39544.rs:26:22
+ |
+25 | fn foo<'z>(&'z self) {
+ | -------- use `&'z mut self` here to make mutable
+26 | let _ = &mut self.x;
+ | ^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `self.x` as mutable
+ --> $DIR/issue-39544.rs:30:22
+ |
+29 | fn foo1(&self, other: &Z) {
+ | ----- use `&mut self` here to make mutable
+30 | let _ = &mut self.x;
+ | ^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `other.x` as mutable
+ --> $DIR/issue-39544.rs:31:22
+ |
+29 | fn foo1(&self, other: &Z) {
+ | -- use `&mut Z` here to make mutable
+30 | let _ = &mut self.x;
+31 | let _ = &mut other.x;
+ | ^^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `self.x` as mutable
+ --> $DIR/issue-39544.rs:35:22
+ |
+34 | fn foo2<'a>(&'a self, other: &Z) {
+ | -------- use `&'a mut self` here to make mutable
+35 | let _ = &mut self.x;
+ | ^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `other.x` as mutable
+ --> $DIR/issue-39544.rs:36:22
+ |
+34 | fn foo2<'a>(&'a self, other: &Z) {
+ | -- use `&mut Z` here to make mutable
+35 | let _ = &mut self.x;
+36 | let _ = &mut other.x;
+ | ^^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `self.x` as mutable
+ --> $DIR/issue-39544.rs:40:22
+ |
+39 | fn foo3<'a>(self: &'a Self, other: &Z) {
+ | -------- use `&'a mut Self` here to make mutable
+40 | let _ = &mut self.x;
+ | ^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `other.x` as mutable
+ --> $DIR/issue-39544.rs:41:22
+ |
+39 | fn foo3<'a>(self: &'a Self, other: &Z) {
+ | -- use `&mut Z` here to make mutable
+40 | let _ = &mut self.x;
+41 | let _ = &mut other.x;
+ | ^^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `other.x` as mutable
+ --> $DIR/issue-39544.rs:45:22
+ |
+44 | fn foo4(other: &Z) {
+ | -- use `&mut Z` here to make mutable
+45 | let _ = &mut other.x;
+ | ^^^^^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `z.x` as mutable
+ --> $DIR/issue-39544.rs:51:18
+ |
+50 | pub fn with_arg(z: Z, w: &Z) {
+ | - consider changing this to `mut z`
+51 | let _ = &mut z.x;
+ | ^^^ cannot mutably borrow immutable field
+
+error: cannot borrow immutable field `w.x` as mutable
+ --> $DIR/issue-39544.rs:52:18
+ |
+50 | pub fn with_arg(z: Z, w: &Z) {
+ | -- use `&mut Z` here to make mutable
+51 | let _ = &mut z.x;
+52 | let _ = &mut w.x;
+ | ^^^ cannot mutably borrow immutable field
+
+error: aborting due to 11 previous errors
--- /dev/null
+// 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.
+
+fn main() {
+ let mut buf = &[1, 2, 3, 4];
+ buf.iter_mut();
+}
--- /dev/null
+error: cannot borrow immutable borrowed content `*buf` as mutable
+ --> $DIR/issue-40823.rs:13:5
+ |
+13 | buf.iter_mut();
+ | ^^^ cannot borrow as mutable
+
+error: aborting due to previous error
+
--> $DIR/borrowck-borrow-overloaded-auto-deref-mut.rs:63:24
|
62 | fn deref_mut_field1(x: Own<Point>) {
- | - use `mut x` here to make mutable
+ | - consider changing this to `mut x`
63 | let __isize = &mut x.y; //~ ERROR cannot borrow
| ^ cannot borrow mutably
--> $DIR/borrowck-borrow-overloaded-auto-deref-mut.rs:98:5
|
97 | fn assign_field1<'a>(x: Own<Point>) {
- | - use `mut x` here to make mutable
+ | - consider changing this to `mut x`
98 | x.y = 3; //~ ERROR cannot borrow
| ^ cannot borrow mutably
--> $DIR/borrowck-borrow-overloaded-auto-deref-mut.rs:119:5
|
118 | fn deref_mut_method1(x: Own<Point>) {
- | - use `mut x` here to make mutable
+ | - consider changing this to `mut x`
119 | x.set(0, 0); //~ ERROR cannot borrow
| ^ cannot borrow mutably
--> $DIR/borrowck-borrow-overloaded-auto-deref-mut.rs:139:6
|
138 | fn assign_method1<'a>(x: Own<Point>) {
- | - use `mut x` here to make mutable
+ | - consider changing this to `mut x`
139 | *x.y_mut() = 3; //~ ERROR cannot borrow
| ^ cannot borrow mutably
--> $DIR/borrowck-borrow-overloaded-deref-mut.rs:39:25
|
38 | fn deref_mut1(x: Own<isize>) {
- | - use `mut x` here to make mutable
+ | - consider changing this to `mut x`
39 | let __isize = &mut *x; //~ ERROR cannot borrow
| ^ cannot borrow mutably
--> $DIR/borrowck-borrow-overloaded-deref-mut.rs:59:6
|
58 | fn assign1<'a>(x: Own<isize>) {
- | - use `mut x` here to make mutable
+ | - consider changing this to `mut x`
59 | *x = 3; //~ ERROR cannot borrow
| ^ cannot borrow mutably
error: cannot borrow immutable `Box` content `*x` as mutable
--> $DIR/borrowck-object-mutability.rs:29:5
|
+27 | fn owned_receiver(x: Box<Foo>) {
+ | - consider changing this to `mut x`
+28 | x.borrowed();
29 | x.borrowed_mut(); //~ ERROR cannot borrow
| ^ cannot borrow as mutable
let mut cmd = Command::new(prog);
cmd.args(args)
.stdout(Stdio::piped())
- .stderr(Stdio::piped());
-
- // Why oh why do we sometimes make a pipe and sometimes inherit the stdin
- // stream, well that's an excellent question! In theory it should suffice to
- // always create a pipe here and be done with it. Unfortunately though
- // there's apparently something odd with the gdb that comes with gcc 6.3.0
- // on MinGW. Tracked at rust-lang/rust#40184 when stdin is piped here
- // (unconditionally) then all gdb tests will fail on MinGW when using gcc
- // 6.3.0. WHen using an inherited stdin though they happen to all work!
- //
- // As to why this fixes the issue, well, I have no idea. If you can remove
- // this branch and unconditionally use `piped` and it gets past @bors please
- // feel free to send a PR!
- if input.is_some() || !cfg!(windows) {
- cmd.stdin(Stdio::piped());
- } else {
- cmd.stdin(Stdio::inherit());
- }
+ .stderr(Stdio::piped())
+ .stdin(Stdio::piped());
add_target_env(&mut cmd, lib_path, aux_path);
for (key, val) in env {
use syntax::diagnostics::metadata::{get_metadata_dir, ErrorMetadataMap, ErrorMetadata};
-use rustdoc::html::markdown::{Markdown, PLAYGROUND};
+use rustdoc::html::markdown::{Markdown, MarkdownOutputStyle, PLAYGROUND};
use rustc_serialize::json;
enum OutputFormat {
// Description rendered as markdown.
match info.description {
- Some(ref desc) => write!(output, "{}", Markdown(desc))?,
+ Some(ref desc) => write!(output, "{}", Markdown(desc, MarkdownOutputStyle::Fancy))?,
None => write!(output, "<p>No description.</p>\n")?,
}
projects / rust.git / commitdiff