A pair of regression tests for issues that seem to have been fixed since they were originally filed.
make_dir $h/test/debuginfo-gdb
make_dir $h/test/debuginfo-lldb
make_dir $h/test/codegen
+ make_dir $h/test/rustdoc
done
# Configure submodules
ONLY_RLIB_unicode := 1
ONLY_RLIB_rustc_bitflags := 1
+# Documented-by-default crates
+DOC_CRATES := std alloc collections core libc unicode
+
################################################################################
# You should not need to edit below this line
################################################################################
-# On channels where the only usable crate is std, only build documentation for
-# std. This keeps distributions small and doesn't clutter up the API docs with
-# confusing internal details from the crates behind the facade.
-#
-# (Disabled while cmr figures out how to change rustdoc to make reexports work
-# slightly nicer. Otherwise, all cross-crate links to Vec will go to
-# libcollections, breaking them, and [src] links for anything reexported will
-# not work.)
-
-#ifeq ($(CFG_RELEASE_CHANNEL),stable)
-#DOC_CRATES := std
-#else
-#ifeq ($(CFG_RELEASE_CHANNEL),beta)
-#DOC_CRATES := std
-#else
-DOC_CRATES := $(filter-out rustc, \
- $(filter-out rustc_trans, \
- $(filter-out rustc_typeck, \
- $(filter-out rustc_borrowck, \
- $(filter-out rustc_resolve, \
- $(filter-out rustc_driver, \
- $(filter-out rustc_privacy, \
- $(filter-out rustc_lint, \
- $(filter-out log, \
- $(filter-out getopts, \
- $(filter-out syntax, $(CRATES))))))))))))
-#endif
-#endif
-COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \
- rustc_typeck rustc_driver syntax rustc_privacy \
- rustc_lint
-
# This macro creates some simple definitions for each crate being built, just
# some munging of all of the parameters above.
#
doc/$(1)/:
$$(Q)mkdir -p $$@
-$(2) += doc/$(1)/index.html
doc/$(1)/index.html: CFG_COMPILER_HOST_TRIPLE = $(CFG_TARGET)
doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1)) doc/$(1)/
@$$(call E, rustdoc: $$@)
$$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(CFG_BUILD)) \
- $$(RUSTDOC) --cfg dox --cfg stage2 $$<
+ $$(RUSTDOC) --cfg dox --cfg stage2 $$(RUSTFLAGS_$(1)) $$<
endef
-$(foreach crate,$(DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),DOC_TARGETS)))
+$(foreach crate,$(CRATES),$(eval $(call DEF_LIB_DOC,$(crate))))
+COMPILER_DOC_TARGETS := $(CRATES:%=doc/%/index.html)
ifdef CFG_COMPILER_DOCS
- $(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPILER_DOC_TARGETS)))
+ DOC_TARGETS += $(COMPILER_DOC_TARGETS)
+else
+ DOC_TARGETS += $(DOC_CRATES:%=doc/%/index.html)
endif
ifdef CFG_DISABLE_DOCS
DEPS_collectionstest :=
$(eval $(call RUST_CRATE,collectionstest))
-TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) collectionstest coretest
+TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) \
+ collectionstest coretest
TEST_DOC_CRATES = $(DOC_CRATES)
-TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve rustc_trans rustc_lint,\
+TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve \
+ rustc_trans rustc_lint,\
$(HOST_CRATES))
TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
check-stage$(1)-T-$(2)-H-$(3)-rpass-full-exec \
check-stage$(1)-T-$(2)-H-$(3)-cfail-full-exec \
check-stage$(1)-T-$(2)-H-$(3)-rmake-exec \
+ check-stage$(1)-T-$(2)-H-$(3)-rustdocck-exec \
check-stage$(1)-T-$(2)-H-$(3)-crates-exec \
check-stage$(1)-T-$(2)-H-$(3)-doc-crates-exec \
check-stage$(1)-T-$(2)-H-$(3)-bench-exec \
DEBUGINFO_LLDB_RS := $(wildcard $(S)src/test/debuginfo/*.rs)
CODEGEN_RS := $(wildcard $(S)src/test/codegen/*.rs)
CODEGEN_CC := $(wildcard $(S)src/test/codegen/*.cc)
+RUSTDOCCK_RS := $(wildcard $(S)src/test/rustdoc/*.rs)
# perf tests are the same as bench tests only they run under
# a performance monitor.
DEBUGINFO_GDB_TESTS := $(DEBUGINFO_GDB_RS)
DEBUGINFO_LLDB_TESTS := $(DEBUGINFO_LLDB_RS)
CODEGEN_TESTS := $(CODEGEN_RS) $(CODEGEN_CC)
+RUSTDOCCK_TESTS := $(RUSTDOCCK_RS)
CTEST_SRC_BASE_rpass = run-pass
CTEST_BUILD_BASE_rpass = run-pass
CTEST_MODE_codegen = codegen
CTEST_RUNTOOL_codegen = $(CTEST_RUNTOOL)
+CTEST_SRC_BASE_rustdocck = rustdoc
+CTEST_BUILD_BASE_rustdocck = rustdoc
+CTEST_MODE_rustdocck = rustdoc
+CTEST_RUNTOOL_rustdocck = $(CTEST_RUNTOOL)
+
# CTEST_DISABLE_$(TEST_GROUP), if set, will cause the test group to be
# disabled and the associated message to be printed as a warning
# during attempts to run those tests.
--compile-lib-path $$(HLIB$(1)_H_$(3)) \
--run-lib-path $$(TLIB$(1)_T_$(2)_H_$(3)) \
--rustc-path $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
+ --rustdoc-path $$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) \
--clang-path $(if $(CFG_CLANG),$(CFG_CLANG),clang) \
--llvm-bin-path $(CFG_LLVM_INST_DIR_$(CFG_BUILD))/bin \
--aux-base $$(S)src/test/auxiliary/ \
--stage-id stage$(1)-$(2) \
--target $(2) \
--host $(3) \
+ --python $$(CFG_PYTHON) \
--gdb-version="$(CFG_GDB_VERSION)" \
--lldb-version="$(CFG_LLDB_VERSION)" \
--android-cross-path=$(CFG_ANDROID_CROSS_PATH) \
$(S)src/etc/lldb_batchmode.py \
$(S)src/etc/lldb_rust_formatters.py
CTEST_DEPS_codegen_$(1)-T-$(2)-H-$(3) = $$(CODEGEN_TESTS)
+CTEST_DEPS_rustdocck_$(1)-T-$(2)-H-$(3) = $$(RUSTDOCCK_TESTS) \
+ $$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) \
+ $(S)src/etc/htmldocck.py
endef
endef
-CTEST_NAMES = rpass rpass-valgrind rpass-full cfail-full rfail cfail pfail bench perf debuginfo-gdb debuginfo-lldb codegen
+CTEST_NAMES = rpass rpass-valgrind rpass-full cfail-full rfail cfail pfail \
+ bench perf debuginfo-gdb debuginfo-lldb codegen rustdocck
$(foreach host,$(CFG_HOST), \
$(eval $(foreach target,$(CFG_TARGET), \
bench \
perf \
rmake \
+ rustdocck \
debuginfo-gdb \
debuginfo-lldb \
codegen \
Pretty,
DebugInfoGdb,
DebugInfoLldb,
- Codegen
+ Codegen,
+ Rustdoc,
}
impl FromStr for Mode {
"debuginfo-lldb" => Ok(DebugInfoLldb),
"debuginfo-gdb" => Ok(DebugInfoGdb),
"codegen" => Ok(Codegen),
+ "rustdoc" => Ok(Rustdoc),
_ => Err(()),
}
}
DebugInfoGdb => "debuginfo-gdb",
DebugInfoLldb => "debuginfo-lldb",
Codegen => "codegen",
+ Rustdoc => "rustdoc",
}, f)
}
}
// The rustc executable
pub rustc_path: PathBuf,
+ // The rustdoc executable
+ pub rustdoc_path: PathBuf,
+
+ // The python executable
+ pub python: String,
+
// The clang executable
pub clang_path: Option<PathBuf>,
vec!(reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
reqopt("", "run-lib-path", "path to target shared libraries", "PATH"),
reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH"),
+ reqopt("", "rustdoc-path", "path to rustdoc to use for compiling", "PATH"),
+ reqopt("", "python", "path to python to use for doc tests", "PATH"),
optopt("", "clang-path", "path to executable for codegen tests", "PATH"),
optopt("", "valgrind-path", "path to Valgrind executable for Valgrind tests", "PROGRAM"),
optflag("", "force-valgrind", "fail if Valgrind tests cannot be run under Valgrind"),
compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
run_lib_path: matches.opt_str("run-lib-path").unwrap(),
rustc_path: opt_path(matches, "rustc-path"),
+ rustdoc_path: opt_path(matches, "rustdoc-path"),
+ python: matches.opt_str("python").unwrap(),
clang_path: matches.opt_str("clang-path").map(|s| PathBuf::from(&s)),
valgrind_path: matches.opt_str("valgrind-path"),
force_valgrind: matches.opt_present("force-valgrind"),
logv(c, format!("compile_lib_path: {:?}", config.compile_lib_path));
logv(c, format!("run_lib_path: {:?}", config.run_lib_path));
logv(c, format!("rustc_path: {:?}", config.rustc_path.display()));
+ logv(c, format!("rustdoc_path: {:?}", config.rustdoc_path.display()));
logv(c, format!("src_base: {:?}", config.src_base.display()));
logv(c, format!("build_base: {:?}", config.build_base.display()));
logv(c, format!("stage_id: {}", config.stage_id));
use common::Config;
use common::{CompileFail, ParseFail, Pretty, RunFail, RunPass, RunPassValgrind};
-use common::{Codegen, DebugInfoLldb, DebugInfoGdb};
+use common::{Codegen, DebugInfoLldb, DebugInfoGdb, Rustdoc};
use errors;
use header::TestProps;
use header;
let props = header::load_props(&testfile);
debug!("loaded props");
match config.mode {
- CompileFail => run_cfail_test(&config, &props, &testfile),
- ParseFail => run_cfail_test(&config, &props, &testfile),
- RunFail => run_rfail_test(&config, &props, &testfile),
- RunPass => run_rpass_test(&config, &props, &testfile),
- RunPassValgrind => run_valgrind_test(&config, &props, &testfile),
- Pretty => run_pretty_test(&config, &props, &testfile),
- DebugInfoGdb => run_debuginfo_gdb_test(&config, &props, &testfile),
- DebugInfoLldb => run_debuginfo_lldb_test(&config, &props, &testfile),
- Codegen => run_codegen_test(&config, &props, &testfile, mm),
+ CompileFail => run_cfail_test(&config, &props, &testfile),
+ ParseFail => run_cfail_test(&config, &props, &testfile),
+ RunFail => run_rfail_test(&config, &props, &testfile),
+ RunPass => run_rpass_test(&config, &props, &testfile),
+ RunPassValgrind => run_valgrind_test(&config, &props, &testfile),
+ Pretty => run_pretty_test(&config, &props, &testfile),
+ DebugInfoGdb => run_debuginfo_gdb_test(&config, &props, &testfile),
+ DebugInfoLldb => run_debuginfo_lldb_test(&config, &props, &testfile),
+ Codegen => run_codegen_test(&config, &props, &testfile, mm),
+ Rustdoc => run_rustdoc_test(&config, &props, &testfile),
}
}
-> ProcRes {
// Prepare the lldb_batchmode which executes the debugger script
let lldb_script_path = rust_src_root.join("src/etc/lldb_batchmode.py");
+ cmd2procres(config,
+ test_executable,
+ Command::new(&config.python)
+ .arg(&lldb_script_path)
+ .arg(test_executable)
+ .arg(debugger_script)
+ .env("PYTHONPATH",
+ config.lldb_python_dir.as_ref().unwrap()))
+ }
+}
- let mut cmd = Command::new("python");
- cmd.arg(&lldb_script_path)
- .arg(test_executable)
- .arg(debugger_script)
- .env("PYTHONPATH", config.lldb_python_dir.as_ref().unwrap());
-
- let (status, out, err) = match cmd.output() {
- Ok(Output { status, stdout, stderr }) => {
- (status,
- String::from_utf8(stdout).unwrap(),
- String::from_utf8(stderr).unwrap())
- },
- Err(e) => {
- fatal(&format!("Failed to setup Python process for \
- LLDB script: {}", e))
- }
- };
+fn cmd2procres(config: &Config, test_executable: &Path, cmd: &mut Command)
+ -> ProcRes {
+ let (status, out, err) = match cmd.output() {
+ Ok(Output { status, stdout, stderr }) => {
+ (status,
+ String::from_utf8(stdout).unwrap(),
+ String::from_utf8(stderr).unwrap())
+ },
+ Err(e) => {
+ fatal(&format!("Failed to setup Python process for \
+ LLDB script: {}", e))
+ }
+ };
- dump_output(config, test_executable, &out, &err);
- return ProcRes {
- status: Status::Normal(status),
- stdout: out,
- stderr: err,
- cmdline: format!("{:?}", cmd)
- };
+ dump_output(config, test_executable, &out, &err);
+ ProcRes {
+ status: Status::Normal(status),
+ stdout: out,
+ stderr: err,
+ cmdline: format!("{:?}", cmd)
}
}
compose_and_run_compiler(config, props, testfile, args, None)
}
+fn document(config: &Config, props: &TestProps,
+ testfile: &Path, extra_args: &[String]) -> (ProcRes, PathBuf) {
+ let aux_dir = aux_output_dir_name(config, testfile);
+ let out_dir = output_base_name(config, testfile);
+ let _ = fs::remove_dir_all(&out_dir);
+ ensure_dir(&out_dir);
+ let mut args = vec!["-L".to_string(),
+ aux_dir.to_str().unwrap().to_string(),
+ "-o".to_string(),
+ out_dir.to_str().unwrap().to_string(),
+ testfile.to_str().unwrap().to_string()];
+ args.extend(extra_args.iter().cloned());
+ args.extend(split_maybe_args(&props.compile_flags).into_iter());
+ let args = ProcArgs {
+ prog: config.rustdoc_path.to_str().unwrap().to_string(),
+ args: args,
+ };
+ (compose_and_run_compiler(config, props, testfile, args, None), out_dir)
+}
+
fn exec_compiled_test(config: &Config, props: &TestProps,
testfile: &Path) -> ProcRes {
}
}
-fn compose_and_run_compiler(
- config: &Config,
- props: &TestProps,
- testfile: &Path,
- args: ProcArgs,
- input: Option<String>) -> ProcRes {
-
+fn compose_and_run_compiler(config: &Config, props: &TestProps,
+ testfile: &Path, args: ProcArgs,
+ input: Option<String>) -> ProcRes {
if !props.aux_builds.is_empty() {
ensure_dir(&aux_output_dir_name(config, testfile));
}
let aux_dir = aux_output_dir_name(config, testfile);
// FIXME (#9639): This needs to handle non-utf8 paths
- let extra_link_args = vec!("-L".to_string(), aux_dir.to_str().unwrap().to_string());
+ let extra_link_args = vec!["-L".to_string(),
+ aux_dir.to_str().unwrap().to_string()];
for rel_ab in &props.aux_builds {
let abs_ab = config.aux_base.join(rel_ab);
f
}
-fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) ->
- ProcArgs {
+fn make_run_args(config: &Config, props: &TestProps, testfile: &Path)
+ -> ProcArgs {
// If we've got another tool to run under (valgrind),
// then split apart its command
let mut args = split_maybe_args(&config.runtool);
"UTF-8"
}
}
+
+fn run_rustdoc_test(config: &Config, props: &TestProps, testfile: &Path) {
+ let (proc_res, out_dir) = document(config, props, testfile, &[]);
+ if !proc_res.status.success() {
+ fatal_proc_rec("rustdoc failed!", &proc_res);
+ }
+ let root = find_rust_src_root(config).unwrap();
+
+ let res = cmd2procres(config,
+ testfile,
+ Command::new(&config.python)
+ .arg(root.join("src/etc/htmldocck.py"))
+ .arg(out_dir)
+ .arg(testfile));
+ if !res.status.success() {
+ fatal_proc_rec("htmldocck failed!", &res);
+ }
+}
details that are important here. The first is that it's indented with four
spaces, not tabs. Please configure your editor of choice to insert four spaces
with the tab key. We provide some [sample configurations for various
-editors](https://github.com/rust-lang/rust/tree/master/src/etc/CONFIGS.md).
+editors][configs].
+
+[configs]: https://github.com/rust-lang/rust/tree/master/src/etc/CONFIGS.md
The second point is the `println!()` part. This is calling a Rust *macro*,
which is how metaprogramming is done in Rust. If it were a function instead, it
firstlineno = firstlineno or lineno
if line.endswith('\\'):
- lastline = line[:-1]
+ if lastline is None:
+ lastline = line[:-1]
catenated += line[:-1]
else:
yield firstlineno, catenated + line
}
}
+// Ensure that the result of e.g. joining a thread can be printed and
+// hence used with `unwrap`. May eventually no longer be needed if
+// dispatch works with upcasting.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl fmt::Debug for Any + Send {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.pad("Any")
+ }
+}
+
impl Any {
/// Returns true if the boxed type is the same as `T`
#[stable(feature = "rust1", since = "1.0.0")]
// NB: the stabilization and documentation for this trait is in
// unicode/char.rs, not here
#[allow(missing_docs)] // docs in libunicode/u_char.rs
+#[doc(hidden)]
pub trait CharExt {
fn is_digit(self, radix: u32) -> bool;
fn to_digit(self, radix: u32) -> Option<u32>;
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> Pointer for *const T {
fn fmt(&self, f: &mut Formatter) -> Result {
+ let old_width = f.width;
+ let old_flags = f.flags;
+
+ // The alternate flag is already treated by LowerHex as being special-
+ // it denotes whether to prefix with 0x. We use it to work out whether
+ // or not to zero extend, and then unconditionally set it to get the
+ // prefix.
+ if f.flags & 1 << (FlagV1::Alternate as u32) > 0 {
+ f.flags |= 1 << (FlagV1::SignAwareZeroPad as u32);
+
+ if let None = f.width {
+ // The formats need two extra bytes, for the 0x
+ if cfg!(target_pointer_width = "32") {
+ f.width = Some(10);
+ } else {
+ f.width = Some(18);
+ }
+ }
+ }
f.flags |= 1 << (FlagV1::Alternate as u32);
+
let ret = LowerHex::fmt(&(*self as usize), f);
- f.flags &= !(1 << (FlagV1::Alternate as u32));
+
+ f.width = old_width;
+ f.flags = old_flags;
+
ret
}
}
pub fn overflowing_sub<T>(a: T, b: T) -> T;
/// Returns (a * b) mod 2^N, where N is the width of N in bits.
pub fn overflowing_mul<T>(a: T, b: T) -> T;
+
+ /// Returns the value of the discriminant for the variant in 'v',
+ /// cast to a `u64`; if `T` has no discriminant, returns 0.
+ // SNAP 5520801
+ #[cfg(not(stage0))]
+ pub fn discriminant_value<T>(v: &T) -> u64;
}
#[doc(hidden)]
mod core {
+ pub use intrinsics;
pub use panicking;
pub use fmt;
pub use clone;
/// Iterators:
///
/// ```
-/// # #![feature(core)]
/// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3
/// for i in 0.. {
/// if 3*i < i { panic!("u32 overflow"); }
// `unused_self`. Removing it requires #8888 to be fixed.
#[unstable(feature = "core",
reason = "distribution of methods between core/std is unclear")]
+#[doc(hidden)]
pub trait Float
: Copy + Clone
+ NumCast
//! of unsafe pointers in Rust.
#![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "pointer")]
use mem;
use clone::Clone;
/// Extension methods for slices.
#[allow(missing_docs)] // docs in libcollections
+#[doc(hidden)]
pub trait SliceExt {
type Item;
/// Methods for string slices
#[allow(missing_docs)]
+#[doc(hidden)]
pub trait StrExt {
// NB there are no docs here are they're all located on the StrExt trait in
// libcollections, not here.
encode_paren_sugar(rbml_w, trait_def.paren_sugar);
encode_defaulted(rbml_w, ty::trait_has_default_impl(tcx, def_id));
encode_associated_type_names(rbml_w, &trait_def.associated_type_names);
- encode_generics(rbml_w, ecx, &trait_def.generics, &trait_predicates, tag_item_generics);
+ encode_generics(rbml_w, ecx, &trait_def.generics, &trait_predicates,
+ tag_item_generics);
encode_predicates(rbml_w, ecx, &ty::lookup_super_predicates(tcx, def_id),
tag_item_super_predicates);
encode_trait_ref(rbml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref);
use llvm::{SequentiallyConsistent, Acquire, Release, AtomicXchg, ValueRef, TypeKind};
use middle::subst;
use middle::subst::FnSpace;
+use trans::adt;
use trans::base::*;
use trans::build::*;
use trans::callee;
}
}
+ (_, "discriminant_value") => {
+ let val_ty = substs.types.get(FnSpace, 0);
+ match val_ty.sty {
+ ty::ty_enum(..) => {
+ let repr = adt::represent_type(ccx, *val_ty);
+ adt::trans_get_discr(bcx, &*repr, llargs[0], Some(llret_ty))
+ }
+ _ => C_null(llret_ty)
+ }
+ }
+
// This requires that atomic intrinsics follow a specific naming pattern:
// "atomic_<operation>[_<ordering>]", and no ordering means SeqCst
(_, name) if name.starts_with("atomic_") => {
"assume" => (0, vec![tcx.types.bool], ty::mk_nil(tcx)),
+ "discriminant_value" => (1, vec![
+ ty::mk_imm_rptr(tcx,
+ tcx.mk_region(ty::ReLateBound(ty::DebruijnIndex::new(1),
+ ty::BrAnon(0))),
+ param(ccx, 0))], tcx.types.u64),
+
ref other => {
span_err!(tcx.sess, it.span, E0093,
"unrecognized intrinsic function: `{}`", *other);
//! Support for inlining external documentation into the current AST.
+use std::collections::HashSet;
+
use syntax::ast;
use syntax::ast_util;
use syntax::attr::AttrMetaMethods;
let def = ty::lookup_trait_def(tcx, did);
let trait_items = ty::trait_items(tcx, did).clean(cx);
let predicates = ty::lookup_predicates(tcx, did);
+ let generics = (&def.generics, &predicates, subst::TypeSpace).clean(cx);
+ let generics = filter_non_trait_generics(did, generics);
+ let (generics, supertrait_bounds) = separate_supertrait_bounds(generics);
clean::Trait {
unsafety: def.unsafety,
- generics: (&def.generics, &predicates, subst::TypeSpace).clean(cx),
+ generics: generics,
items: trait_items,
- bounds: vec![], // supertraits can be found in the list of predicates
+ bounds: supertrait_bounds,
}
}
fn build_external_function(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::Function {
let t = ty::lookup_item_type(tcx, did);
- let (decl, style) = match t.ty.sty {
- ty::ty_bare_fn(_, ref f) => ((did, &f.sig).clean(cx), f.unsafety),
+ let (decl, style, abi) = match t.ty.sty {
+ ty::ty_bare_fn(_, ref f) => ((did, &f.sig).clean(cx), f.unsafety, f.abi),
_ => panic!("bad function"),
};
let predicates = ty::lookup_predicates(tcx, did);
decl: decl,
generics: (&t.generics, &predicates, subst::FnSpace).clean(cx),
unsafety: style,
+ abi: abi,
}
}
let did = assoc_ty.def_id;
let type_scheme = ty::lookup_item_type(tcx, did);
let predicates = ty::lookup_predicates(tcx, did);
- // Not sure the choice of ParamSpace actually matters here, because an
- // associated type won't have generics on the LHS
- let typedef = (type_scheme, predicates, subst::ParamSpace::TypeSpace).clean(cx);
+ // Not sure the choice of ParamSpace actually matters here,
+ // because an associated type won't have generics on the LHS
+ let typedef = (type_scheme, predicates,
+ subst::ParamSpace::TypeSpace).clean(cx);
Some(clean::Item {
name: Some(assoc_ty.name.clean(cx)),
inner: clean::TypedefItem(typedef),
is_crate: false,
};
- // FIXME: this doesn't handle reexports inside the module itself.
- // Should they be handled?
fn fill_in(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId,
items: &mut Vec<clean::Item>) {
+ // If we're reexporting a reexport it may actually reexport something in
+ // two namespaces, so the target may be listed twice. Make sure we only
+ // visit each node at most once.
+ let mut visited = HashSet::new();
csearch::each_child_of_item(&tcx.sess.cstore, did, |def, _, vis| {
match def {
decoder::DlDef(def::DefForeignMod(did)) => {
fill_in(cx, tcx, did, items);
}
decoder::DlDef(def) if vis == ast::Public => {
+ if !visited.insert(def) { return }
match try_inline_def(cx, tcx, def) {
Some(i) => items.extend(i.into_iter()),
None => {}
expr: "\n\n\n".to_string(), // trigger the "[definition]" links
}
}
+
+/// A trait's generics clause actually contains all of the predicates for all of
+/// its associated types as well. We specifically move these clauses to the
+/// associated types instead when displaying, so when we're genering the
+/// generics for the trait itself we need to be sure to remove them.
+///
+/// The inverse of this filtering logic can be found in the `Clean`
+/// implementation for `AssociatedType`
+fn filter_non_trait_generics(trait_did: ast::DefId, mut g: clean::Generics)
+ -> clean::Generics {
+ g.where_predicates.retain(|pred| {
+ match *pred {
+ clean::WherePredicate::BoundPredicate {
+ ty: clean::QPath {
+ self_type: box clean::Generic(ref s),
+ trait_: box clean::ResolvedPath { did, .. },
+ name: ref _name,
+ }, ..
+ } => *s != "Self" || did != trait_did,
+ _ => true,
+ }
+ });
+ return g;
+}
+
+/// Supertrait bounds for a trait are also listed in the generics coming from
+/// the metadata for a crate, so we want to separate those out and create a new
+/// list of explicit supertrait bounds to render nicely.
+fn separate_supertrait_bounds(mut g: clean::Generics)
+ -> (clean::Generics, Vec<clean::TyParamBound>) {
+ let mut ty_bounds = Vec::new();
+ g.where_predicates.retain(|pred| {
+ match *pred {
+ clean::WherePredicate::BoundPredicate {
+ ty: clean::Generic(ref s),
+ ref bounds
+ } if *s == "Self" => {
+ ty_bounds.extend(bounds.iter().cloned());
+ false
+ }
+ _ => true,
+ }
+ });
+ (g, ty_bounds)
+}
use rustc::middle::ty;
use rustc::middle::stability;
+use std::collections::HashMap;
+use std::path::PathBuf;
use std::rc::Rc;
use std::u32;
-use std::path::PathBuf;
use core::DocContext;
use doctree;
pub static SCHEMA_VERSION: &'static str = "0.8.3";
mod inline;
+mod simplify;
// extract the stability index for a node from tcx, if possible
fn get_stability(cx: &DocContext, def_id: ast::DefId) -> Option<Stability> {
pub module: Option<Item>,
pub externs: Vec<(ast::CrateNum, ExternalCrate)>,
pub primitives: Vec<PrimitiveType>,
+ pub external_traits: HashMap<ast::DefId, Trait>,
}
impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
module: Some(module),
externs: externs,
primitives: primitives,
+ external_traits: cx.external_traits.borrow_mut().take()
+ .unwrap_or(HashMap::new()),
}
}
}
TraitBound(PolyTrait, ast::TraitBoundModifier)
}
+impl TyParamBound {
+ fn maybe_sized(cx: &DocContext) -> TyParamBound {
+ use syntax::ast::TraitBoundModifier as TBM;
+ let mut sized_bound = ty::BuiltinBound::BoundSized.clean(cx);
+ if let TyParamBound::TraitBound(_, ref mut tbm) = sized_bound {
+ *tbm = TBM::Maybe
+ };
+ sized_bound
+ }
+
+ fn is_sized_bound(&self, cx: &DocContext) -> bool {
+ use syntax::ast::TraitBoundModifier as TBM;
+ if let Some(tcx) = cx.tcx_opt() {
+ let sized_did = match tcx.lang_items.sized_trait() {
+ Some(did) => did,
+ None => return false
+ };
+ if let TyParamBound::TraitBound(PolyTrait {
+ trait_: Type::ResolvedPath { did, .. }, ..
+ }, TBM::None) = *self {
+ if did == sized_did {
+ return true
+ }
+ }
+ }
+ false
+ }
+}
+
impl Clean<TyParamBound> for ast::TyParamBound {
fn clean(&self, cx: &DocContext) -> TyParamBound {
match *self {
fn clean(&self, cx: &DocContext) -> Type {
let trait_ = match self.trait_ref.clean(cx) {
TyParamBound::TraitBound(t, _) => t.trait_,
- TyParamBound::RegionBound(_) => panic!("cleaning a trait got a region??"),
+ TyParamBound::RegionBound(_) => {
+ panic!("cleaning a trait got a region")
+ }
};
Type::QPath {
name: self.item_name.clean(cx),
subst::ParamSpace) {
fn clean(&self, cx: &DocContext) -> Generics {
use std::collections::HashSet;
- use syntax::ast::TraitBoundModifier as TBM;
use self::WherePredicate as WP;
- fn has_sized_bound(bounds: &[TyParamBound], cx: &DocContext) -> bool {
- if let Some(tcx) = cx.tcx_opt() {
- let sized_did = match tcx.lang_items.sized_trait() {
- Some(did) => did,
- None => return false
- };
- for bound in bounds {
- if let TyParamBound::TraitBound(PolyTrait {
- trait_: Type::ResolvedPath { did, .. }, ..
- }, TBM::None) = *bound {
- if did == sized_did {
- return true
- }
- }
- }
- }
- false
- }
-
let (gens, preds, space) = *self;
- // Bounds in the type_params and lifetimes fields are repeated in the predicates
- // field (see rustc_typeck::collect::ty_generics), so remove them.
+ // Bounds in the type_params and lifetimes fields are repeated in the
+ // predicates field (see rustc_typeck::collect::ty_generics), so remove
+ // them.
let stripped_typarams = gens.types.get_slice(space).iter().map(|tp| {
tp.clean(cx)
}).collect::<Vec<_>>();
srp.clean(cx)
}).collect::<Vec<_>>();
- let where_predicates = preds.predicates.get_slice(space).to_vec().clean(cx);
+ let mut where_predicates = preds.predicates.get_slice(space)
+ .to_vec().clean(cx);
- // Type parameters have a Sized bound by default unless removed with ?Sized.
- // Scan through the predicates and mark any type parameter with a Sized
- // bound, removing the bounds as we find them.
+ // Type parameters and have a Sized bound by default unless removed with
+ // ?Sized. Scan through the predicates and mark any type parameter with
+ // a Sized bound, removing the bounds as we find them.
+ //
+ // Note that associated types also have a sized bound by default, but we
+ // don't actually konw the set of associated types right here so that's
+ // handled in cleaning associated types
let mut sized_params = HashSet::new();
- let mut where_predicates = where_predicates.into_iter().filter_map(|pred| {
- if let WP::BoundPredicate { ty: Type::Generic(ref g), ref bounds } = pred {
- if has_sized_bound(&**bounds, cx) {
- sized_params.insert(g.clone());
- return None
+ where_predicates.retain(|pred| {
+ match *pred {
+ WP::BoundPredicate { ty: Generic(ref g), ref bounds } => {
+ if bounds.iter().any(|b| b.is_sized_bound(cx)) {
+ sized_params.insert(g.clone());
+ false
+ } else {
+ true
+ }
}
+ _ => true,
}
- Some(pred)
- }).collect::<Vec<_>>();
+ });
- // Finally, run through the type parameters again and insert a ?Sized unbound for
- // any we didn't find to be Sized.
+ // Run through the type parameters again and insert a ?Sized
+ // unbound for any we didn't find to be Sized.
for tp in &stripped_typarams {
if !sized_params.contains(&tp.name) {
- let mut sized_bound = ty::BuiltinBound::BoundSized.clean(cx);
- if let TyParamBound::TraitBound(_, ref mut tbm) = sized_bound {
- *tbm = TBM::Maybe
- };
where_predicates.push(WP::BoundPredicate {
ty: Type::Generic(tp.name.clone()),
- bounds: vec![sized_bound]
+ bounds: vec![TyParamBound::maybe_sized(cx)],
})
}
}
// and instead see `where T: Foo + Bar + Sized + 'a`
Generics {
- type_params: stripped_typarams,
+ type_params: simplify::ty_params(stripped_typarams),
lifetimes: stripped_lifetimes,
- where_predicates: where_predicates
+ where_predicates: simplify::where_clauses(cx, where_predicates),
}
}
}
pub decl: FnDecl,
pub generics: Generics,
pub unsafety: ast::Unsafety,
+ pub abi: abi::Abi
}
impl Clean<Item> for doctree::Function {
decl: self.decl.clean(cx),
generics: self.generics.clean(cx),
unsafety: self.unsafety,
+ abi: self.abi,
}),
}
}
}
};
+ let generics = (&self.generics, &self.predicates,
+ subst::FnSpace).clean(cx);
+ let decl = (self.def_id, &sig).clean(cx);
+ let provided = match self.container {
+ ty::ImplContainer(..) => false,
+ ty::TraitContainer(did) => {
+ ty::provided_trait_methods(cx.tcx(), did).iter().any(|m| {
+ m.def_id == self.def_id
+ })
+ }
+ };
+ let inner = if provided {
+ MethodItem(Method {
+ unsafety: self.fty.unsafety,
+ generics: generics,
+ self_: self_,
+ decl: decl,
+ abi: self.fty.abi
+ })
+ } else {
+ TyMethodItem(TyMethod {
+ unsafety: self.fty.unsafety,
+ generics: generics,
+ self_: self_,
+ decl: decl,
+ abi: self.fty.abi
+ })
+ };
+
Item {
name: Some(self.name.clean(cx)),
visibility: Some(ast::Inherited),
def_id: self.def_id,
attrs: inline::load_attrs(cx, cx.tcx(), self.def_id),
source: Span::empty(),
- inner: TyMethodItem(TyMethod {
- unsafety: self.fty.unsafety,
- generics: (&self.generics, &self.predicates, subst::FnSpace).clean(cx),
- self_: self_,
- decl: (self.def_id, &sig).clean(cx),
- abi: self.fty.abi
- })
+ inner: inner,
}
}
}
Slice,
Array,
PrimitiveTuple,
+ PrimitiveRawPointer,
}
#[derive(Clone, RustcEncodable, RustcDecodable, Copy, Debug)]
TypeTypedef,
}
+impl Type {
+ pub fn primitive_type(&self) -> Option<PrimitiveType> {
+ match *self {
+ Primitive(p) | BorrowedRef { type_: box Primitive(p), ..} => Some(p),
+ Vector(..) | BorrowedRef{ type_: box Vector(..), .. } => Some(Slice),
+ FixedVector(..) | BorrowedRef { type_: box FixedVector(..), .. } => {
+ Some(Array)
+ }
+ Tuple(..) => Some(PrimitiveTuple),
+ RawPointer(..) => Some(PrimitiveRawPointer),
+ _ => None,
+ }
+ }
+}
+
impl PrimitiveType {
fn from_str(s: &str) -> Option<PrimitiveType> {
match s {
"array" => Some(Array),
"slice" => Some(Slice),
"tuple" => Some(PrimitiveTuple),
+ "pointer" => Some(PrimitiveRawPointer),
_ => None,
}
}
Array => "array",
Slice => "slice",
PrimitiveTuple => "tuple",
+ PrimitiveRawPointer => "pointer",
}
}
}
ty::ty_tup(ref t) => Tuple(t.clean(cx)),
- ty::ty_projection(ref data) => {
- let trait_ref = match data.trait_ref.clean(cx) {
- TyParamBound::TraitBound(t, _) => t.trait_,
- TyParamBound::RegionBound(_) => panic!("cleaning a trait got a region??"),
- };
- Type::QPath {
- name: data.item_name.clean(cx),
- self_type: box data.trait_ref.self_ty().clean(cx),
- trait_: box trait_ref,
- }
- }
+ ty::ty_projection(ref data) => data.clean(cx),
ty::ty_param(ref p) => Generic(token::get_name(p.name).to_string()),
pub segments: Vec<PathSegment>,
}
+impl Path {
+ pub fn singleton(name: String) -> Path {
+ Path {
+ global: false,
+ segments: vec![PathSegment {
+ name: name,
+ params: PathParameters::AngleBracketed {
+ lifetimes: Vec::new(),
+ types: Vec::new(),
+ bindings: Vec::new()
+ }
+ }]
+ }
+ }
+}
+
impl Clean<Path> for ast::Path {
fn clean(&self, cx: &DocContext) -> Path {
Path {
impl Clean<Vec<Item>> for ast::ForeignMod {
fn clean(&self, cx: &DocContext) -> Vec<Item> {
- self.items.clean(cx)
+ let mut items = self.items.clean(cx);
+ for item in &mut items {
+ match item.inner {
+ ForeignFunctionItem(ref mut f) => f.abi = self.abi,
+ _ => {}
+ }
+ }
+ items
}
}
decl: decl.clean(cx),
generics: generics.clean(cx),
unsafety: ast::Unsafety::Unsafe,
+ abi: abi::Rust,
})
}
ast::ForeignItemStatic(ref ty, mutbl) => {
impl Clean<Item> for ty::AssociatedType {
fn clean(&self, cx: &DocContext) -> Item {
+ // When loading a cross-crate associated type, the bounds for this type
+ // are actually located on the trait/impl itself, so we need to load
+ // all of the generics from there and then look for bounds that are
+ // applied to this associated type in question.
+ let predicates = ty::lookup_predicates(cx.tcx(), self.container.id());
+ let generics = match self.container {
+ ty::TraitContainer(did) => {
+ let def = ty::lookup_trait_def(cx.tcx(), did);
+ (&def.generics, &predicates, subst::TypeSpace).clean(cx)
+ }
+ ty::ImplContainer(did) => {
+ let ty = ty::lookup_item_type(cx.tcx(), did);
+ (&ty.generics, &predicates, subst::TypeSpace).clean(cx)
+ }
+ };
+ let my_name = self.name.clean(cx);
+ let mut bounds = generics.where_predicates.iter().filter_map(|pred| {
+ let (name, self_type, trait_, bounds) = match *pred {
+ WherePredicate::BoundPredicate {
+ ty: QPath { ref name, ref self_type, ref trait_ },
+ ref bounds
+ } => (name, self_type, trait_, bounds),
+ _ => return None,
+ };
+ if *name != my_name { return None }
+ match **trait_ {
+ ResolvedPath { did, .. } if did == self.container.id() => {}
+ _ => return None,
+ }
+ match **self_type {
+ Generic(ref s) if *s == "Self" => {}
+ _ => return None,
+ }
+ Some(bounds)
+ }).flat_map(|i| i.iter().cloned()).collect::<Vec<_>>();
+
+ // Our Sized/?Sized bound didn't get handled when creating the generics
+ // because we didn't actually get our whole set of bounds until just now
+ // (some of them may have come from the trait). If we do have a sized
+ // bound, we remove it, and if we don't then we add the `?Sized` bound
+ // at the end.
+ match bounds.iter().position(|b| b.is_sized_bound(cx)) {
+ Some(i) => { bounds.remove(i); }
+ None => bounds.push(TyParamBound::maybe_sized(cx)),
+ }
+
Item {
source: DUMMY_SP.clean(cx),
name: Some(self.name.clean(cx)),
- attrs: Vec::new(),
- // FIXME(#20727): bounds are missing and need to be filled in from the
- // predicates on the trait itself
- inner: AssociatedTypeItem(vec![], None),
- visibility: None,
+ attrs: inline::load_attrs(cx, cx.tcx(), self.def_id),
+ inner: AssociatedTypeItem(bounds, None),
+ visibility: self.vis.clean(cx),
def_id: self.def_id,
- stability: None,
+ stability: stability::lookup(cx.tcx(), self.def_id).clean(cx),
}
}
}
-impl<'a> Clean<Typedef> for (ty::TypeScheme<'a>, ty::GenericPredicates<'a>, ParamSpace) {
+impl<'a> Clean<Typedef> for (ty::TypeScheme<'a>, ty::GenericPredicates<'a>,
+ ParamSpace) {
fn clean(&self, cx: &DocContext) -> Typedef {
let (ref ty_scheme, ref predicates, ps) = *self;
Typedef {
--- /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.
+
+//! Simplification of where clauses and parameter bounds into a prettier and
+//! more canonical form.
+//!
+//! Currently all cross-crate-inlined function use `middle::ty` to reconstruct
+//! the AST (e.g. see all of `clean::inline`), but this is not always a
+//! non-lossy transformation. The current format of storage for where clauses
+//! for functions and such is simply a list of predicates. One example of this
+//! is that the AST predicate of:
+//!
+//! where T: Trait<Foo=Bar>
+//!
+//! is encoded as:
+//!
+//! where T: Trait, <T as Trait>::Foo = Bar
+//!
+//! This module attempts to reconstruct the original where and/or parameter
+//! bounds by special casing scenarios such as these. Fun!
+
+use std::mem;
+use std::collections::HashMap;
+
+use rustc::middle::subst;
+use rustc::middle::ty;
+use syntax::ast;
+
+use clean::PathParameters as PP;
+use clean::WherePredicate as WP;
+use clean::{self, Clean};
+use core::DocContext;
+
+pub fn where_clauses(cx: &DocContext, clauses: Vec<WP>) -> Vec<WP> {
+ // First, partition the where clause into its separate components
+ let mut params = HashMap::new();
+ let mut lifetimes = Vec::new();
+ let mut equalities = Vec::new();
+ let mut tybounds = Vec::new();
+ for clause in clauses {
+ match clause {
+ WP::BoundPredicate { ty, bounds } => {
+ match ty {
+ clean::Generic(s) => params.entry(s).or_insert(Vec::new())
+ .extend(bounds),
+ t => tybounds.push((t, ty_bounds(bounds))),
+ }
+ }
+ WP::RegionPredicate { lifetime, bounds } => {
+ lifetimes.push((lifetime, bounds));
+ }
+ WP::EqPredicate { lhs, rhs } => equalities.push((lhs, rhs)),
+ }
+ }
+
+ // Simplify the type parameter bounds on all the generics
+ let mut params = params.into_iter().map(|(k, v)| {
+ (k, ty_bounds(v))
+ }).collect::<HashMap<_, _>>();
+
+ // Look for equality predicates on associated types that can be merged into
+ // general bound predicates
+ equalities.retain(|&(ref lhs, ref rhs)| {
+ let (self_, trait_, name) = match *lhs {
+ clean::QPath { ref self_type, ref trait_, ref name } => {
+ (self_type, trait_, name)
+ }
+ _ => return true,
+ };
+ let generic = match **self_ {
+ clean::Generic(ref s) => s,
+ _ => return true,
+ };
+ let trait_did = match **trait_ {
+ clean::ResolvedPath { did, .. } => did,
+ _ => return true,
+ };
+ let bounds = match params.get_mut(generic) {
+ Some(bound) => bound,
+ None => return true,
+ };
+ !bounds.iter_mut().any(|b| {
+ let trait_ref = match *b {
+ clean::TraitBound(ref mut tr, _) => tr,
+ clean::RegionBound(..) => return false,
+ };
+ let (did, path) = match trait_ref.trait_ {
+ clean::ResolvedPath { did, ref mut path, ..} => (did, path),
+ _ => return false,
+ };
+ // If this QPath's trait `trait_did` is the same as, or a supertrait
+ // of, the bound's trait `did` then we can keep going, otherwise
+ // this is just a plain old equality bound.
+ if !trait_is_same_or_supertrait(cx, did, trait_did) {
+ return false
+ }
+ let last = path.segments.last_mut().unwrap();
+ match last.params {
+ PP::AngleBracketed { ref mut bindings, .. } => {
+ bindings.push(clean::TypeBinding {
+ name: name.clone(),
+ ty: rhs.clone(),
+ });
+ }
+ PP::Parenthesized { ref mut output, .. } => {
+ assert!(output.is_none());
+ *output = Some(rhs.clone());
+ }
+ };
+ true
+ })
+ });
+
+ // And finally, let's reassemble everything
+ let mut clauses = Vec::new();
+ clauses.extend(lifetimes.into_iter().map(|(lt, bounds)| {
+ WP::RegionPredicate { lifetime: lt, bounds: bounds }
+ }));
+ clauses.extend(params.into_iter().map(|(k, v)| {
+ WP::BoundPredicate {
+ ty: clean::Generic(k),
+ bounds: v,
+ }
+ }));
+ clauses.extend(tybounds.into_iter().map(|(ty, bounds)| {
+ WP::BoundPredicate { ty: ty, bounds: bounds }
+ }));
+ clauses.extend(equalities.into_iter().map(|(lhs, rhs)| {
+ WP::EqPredicate { lhs: lhs, rhs: rhs }
+ }));
+ clauses
+}
+
+pub fn ty_params(mut params: Vec<clean::TyParam>) -> Vec<clean::TyParam> {
+ for param in params.iter_mut() {
+ param.bounds = ty_bounds(mem::replace(&mut param.bounds, Vec::new()));
+ }
+ return params;
+}
+
+fn ty_bounds(bounds: Vec<clean::TyParamBound>) -> Vec<clean::TyParamBound> {
+ bounds
+}
+
+fn trait_is_same_or_supertrait(cx: &DocContext, child: ast::DefId,
+ trait_: ast::DefId) -> bool {
+ if child == trait_ {
+ return true
+ }
+ let def = ty::lookup_trait_def(cx.tcx(), child);
+ let predicates = ty::lookup_predicates(cx.tcx(), child);
+ let generics = (&def.generics, &predicates, subst::TypeSpace).clean(cx);
+ generics.where_predicates.iter().filter_map(|pred| {
+ match *pred {
+ clean::WherePredicate::BoundPredicate {
+ ty: clean::Generic(ref s),
+ ref bounds
+ } if *s == "Self" => Some(bounds),
+ _ => None,
+ }
+ }).flat_map(|bounds| bounds.iter()).any(|bound| {
+ let poly_trait = match *bound {
+ clean::TraitBound(ref t, _) => t,
+ _ => return false,
+ };
+ match poly_trait.trait_ {
+ clean::ResolvedPath { did, .. } => {
+ trait_is_same_or_supertrait(cx, did, trait_)
+ }
+ _ => false,
+ }
+ })
+}
pub exported_items: privacy::ExportedItems,
pub public_items: privacy::PublicItems,
pub external_paths: ExternalPaths,
- pub external_traits: RefCell<Option<HashMap<ast::DefId, clean::Trait>>>,
pub external_typarams: RefCell<Option<HashMap<ast::DefId, String>>>,
pub inlined: RefCell<Option<HashSet<ast::DefId>>>,
}
exported_items: exported_items,
public_items: public_items,
external_paths: RefCell::new(None),
- external_traits: RefCell::new(None),
external_typarams: RefCell::new(None),
inlined: RefCell::new(None),
};
let external_paths = ctxt.external_paths.borrow_mut().take();
*analysis.external_paths.borrow_mut() = external_paths;
- let map = ctxt.external_traits.borrow_mut().take();
- *analysis.external_traits.borrow_mut() = map;
let map = ctxt.external_typarams.borrow_mut().take();
*analysis.external_typarams.borrow_mut() = map;
let map = ctxt.inlined.borrow_mut().take();
use syntax;
use syntax::codemap::Span;
+use syntax::abi;
use syntax::ast;
use syntax::attr;
use syntax::ast::{Ident, NodeId};
pub unsafety: ast::Unsafety,
pub whence: Span,
pub generics: ast::Generics,
+ pub abi: abi::Abi,
}
pub struct Typedef {
// except according to those terms.
use clean::*;
-use std::iter::Extend;
+use std::collections::HashMap;
use std::mem::{replace, swap};
pub trait DocFolder : Sized {
c.module = match replace(&mut c.module, None) {
Some(module) => self.fold_item(module), None => None
};
+ let external_traits = replace(&mut c.external_traits, HashMap::new());
+ c.external_traits = external_traits.into_iter().map(|(k, mut v)| {
+ let items = replace(&mut v.items, Vec::new());
+ v.items = items.into_iter().filter_map(|i| self.fold_item(i))
+ .collect();
+ (k, v)
+ }).collect();
return c;
}
}
use std::fmt;
use std::iter::repeat;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::ast_util;
pub struct TyParamBounds<'a>(pub &'a [clean::TyParamBound]);
/// Wrapper struct for emitting a comma-separated list of items
pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
+pub struct AbiSpace(pub Abi);
impl VisSpace {
pub fn get(&self) -> Option<ast::Visibility> {
}
}
+pub fn href(did: ast::DefId) -> Option<(String, ItemType, Vec<String>)> {
+ let cache = cache();
+ let loc = CURRENT_LOCATION_KEY.with(|l| l.borrow().clone());
+ let &(ref fqp, shortty) = match cache.paths.get(&did) {
+ Some(p) => p,
+ None => return None,
+ };
+ let mut url = if ast_util::is_local(did) || cache.inlined.contains(&did) {
+ repeat("../").take(loc.len()).collect::<String>()
+ } else {
+ match cache.extern_locations[&did.krate] {
+ render::Remote(ref s) => s.to_string(),
+ render::Local => repeat("../").take(loc.len()).collect::<String>(),
+ render::Unknown => return None,
+ }
+ };
+ for component in &fqp[..fqp.len() - 1] {
+ url.push_str(component);
+ url.push_str("/");
+ }
+ match shortty {
+ ItemType::Module => {
+ url.push_str(fqp.last().unwrap());
+ url.push_str("/index.html");
+ }
+ _ => {
+ url.push_str(shortty.to_static_str());
+ url.push_str(".");
+ url.push_str(fqp.last().unwrap());
+ url.push_str(".html");
+ }
+ }
+ Some((url, shortty, fqp.to_vec()))
+}
+
/// Used when rendering a `ResolvedPath` structure. This invokes the `path`
/// rendering function with the necessary arguments for linking to a local path.
-fn resolved_path(w: &mut fmt::Formatter, did: ast::DefId, p: &clean::Path,
+fn resolved_path(w: &mut fmt::Formatter, did: ast::DefId, path: &clean::Path,
print_all: bool) -> fmt::Result {
- path(w, p, print_all,
- |cache, loc| {
- if ast_util::is_local(did) || cache.inlined.contains(&did) {
- Some(repeat("../").take(loc.len()).collect::<String>())
- } else {
- match cache.extern_locations[&did.krate] {
- render::Remote(ref s) => Some(s.to_string()),
- render::Local => {
- Some(repeat("../").take(loc.len()).collect::<String>())
- }
- render::Unknown => None,
- }
- }
- },
- |cache| {
- match cache.paths.get(&did) {
- None => None,
- Some(&(ref fqp, shortty)) => Some((fqp.clone(), shortty))
- }
- })
-}
-
-fn path<F, G>(w: &mut fmt::Formatter,
- path: &clean::Path,
- print_all: bool,
- root: F,
- info: G)
- -> fmt::Result where
- F: FnOnce(&render::Cache, &[String]) -> Option<String>,
- G: FnOnce(&render::Cache) -> Option<(Vec<String>, ItemType)>,
-{
- // The generics will get written to both the title and link
let last = path.segments.last().unwrap();
- let generics = format!("{}", last.params);
-
- let loc = CURRENT_LOCATION_KEY.with(|l| l.borrow().clone());
- let cache = cache();
- let abs_root = root(&*cache, &loc);
let rel_root = match &*path.segments[0].name {
"self" => Some("./".to_string()),
_ => None,
Some(root) => {
let mut root = String::from_str(&root);
for seg in &path.segments[..amt] {
- if "super" == seg.name ||
- "self" == seg.name {
+ if "super" == seg.name || "self" == seg.name {
try!(write!(w, "{}::", seg.name));
} else {
root.push_str(&seg.name);
}
}
- match info(&*cache) {
- // This is a documented path, link to it!
- Some((ref fqp, shortty)) if abs_root.is_some() => {
- let mut url = String::from_str(&abs_root.unwrap());
- let to_link = &fqp[..fqp.len() - 1];
- for component in to_link {
- url.push_str(component);
- url.push_str("/");
- }
- match shortty {
- ItemType::Module => {
- url.push_str(fqp.last().unwrap());
- url.push_str("/index.html");
- }
- _ => {
- url.push_str(shortty.to_static_str());
- url.push_str(".");
- url.push_str(fqp.last().unwrap());
- url.push_str(".html");
- }
- }
-
+ match href(did) {
+ Some((url, shortty, fqp)) => {
try!(write!(w, "<a class='{}' href='{}' title='{}'>{}</a>",
shortty, url, fqp.connect("::"), last.name));
}
-
- _ => {
- try!(write!(w, "{}", last.name));
- }
+ _ => try!(write!(w, "{}", last.name)),
}
- try!(write!(w, "{}", generics));
+ try!(write!(w, "{}", last.params));
Ok(())
}
}
clean::Bottom => f.write_str("!"),
clean::RawPointer(m, ref t) => {
- write!(f, "*{}{}", RawMutableSpace(m), **t)
+ primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
+ &format!("*{}{}", RawMutableSpace(m), **t))
}
clean::BorrowedRef{ lifetime: ref l, mutability, type_: ref ty} => {
let lt = match *l {
}
Ok(())
}
+ // It's pretty unsightly to look at `<A as B>::C` in output, and
+ // we've got hyperlinking on our side, so try to avoid longer
+ // notation as much as possible by making `C` a hyperlink to trait
+ // `B` to disambiguate.
+ //
+ // FIXME: this is still a lossy conversion and there should probably
+ // be a better way of representing this in general? Most of
+ // the ugliness comes from inlining across crates where
+ // everything comes in as a fully resolved QPath (hard to
+ // look at).
+ clean::QPath {
+ ref name,
+ ref self_type,
+ trait_: box clean::ResolvedPath { did, ref typarams, .. },
+ } => {
+ try!(write!(f, "{}::", self_type));
+ let path = clean::Path::singleton(name.clone());
+ try!(resolved_path(f, did, &path, false));
+
+ // FIXME: `typarams` are not rendered, and this seems bad?
+ drop(typarams);
+ Ok(())
+ }
clean::QPath { ref name, ref self_type, ref trait_ } => {
write!(f, "<{} as {}>::{}", self_type, trait_, name)
}
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.source {
Some(did) => {
- let path = clean::Path {
- global: false,
- segments: vec!(clean::PathSegment {
- name: self.name.clone(),
- params: clean::PathParameters::AngleBracketed {
- lifetimes: Vec::new(),
- types: Vec::new(),
- bindings: Vec::new()
- }
- })
- };
+ let path = clean::Path::singleton(self.name.clone());
resolved_path(f, did, &path, false)
}
_ => write!(f, "{}", self.name),
}
}
+impl fmt::Display for AbiSpace {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self.0 {
+ Abi::Rust => Ok(()),
+ Abi::C => write!(f, "extern "),
+ abi => write!(f, "extern {} ", abi),
+ }
+ }
+}
+
impl<'a> fmt::Display for Stability<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Stability(stab) = *self;
use libc;
use std::ascii::AsciiExt;
-use std::ffi::CString;
use std::cell::RefCell;
use std::collections::HashMap;
+use std::default::Default;
+use std::ffi::CString;
use std::fmt;
use std::slice;
use std::str;
/// left as-is.)
fn stripped_filtered_line<'a>(s: &'a str) -> Option<&'a str> {
let trimmed = s.trim();
- if trimmed.starts_with("# ") {
+ if trimmed == "#" {
+ Some("")
+ } else if trimmed.starts_with("# ") {
Some(&trimmed[2..])
} else {
None
stripped_filtered_line(l).unwrap_or(l)
}).collect::<Vec<&str>>().connect("\n");
let krate = krate.as_ref().map(|s| &**s);
- let test = test::maketest(&test, krate, false, false, true);
+ let test = test::maketest(&test, krate, false,
+ &Default::default());
s.push_str(&format!("<span class='rusttest'>{}</span>", Escape(&test)));
});
s.push_str(&highlight::highlight(&text,
use std::io::prelude::*;
use std::io::{self, BufWriter, BufReader};
use std::iter::repeat;
+use std::mem;
use std::path::{PathBuf, Path};
use std::str;
use std::sync::Arc;
use doctree;
use fold::DocFolder;
use html::format::{VisSpace, Method, UnsafetySpace, MutableSpace, Stability};
-use html::format::{ConciseStability, TyParamBounds, WhereClause};
+use html::format::{ConciseStability, TyParamBounds, WhereClause, href, AbiSpace};
use html::highlight;
use html::item_type::ItemType;
use html::layout;
pub stability: Option<clean::Stability>,
}
+impl Impl {
+ fn trait_did(&self) -> Option<ast::DefId> {
+ self.impl_.trait_.as_ref().and_then(|tr| {
+ if let clean::ResolvedPath { did, .. } = *tr {Some(did)} else {None}
+ })
+ }
+}
+
/// This cache is used to store information about the `clean::Crate` being
/// rendered in order to provide more useful documentation. This contains
/// information like all implementors of a trait, all traits a type implements,
return write!(f, "null")
}
- let inputs: Vec<String> = self.inputs.iter().map(|ref t| format!("{}", t)).collect();
+ let inputs: Vec<String> = self.inputs.iter().map(|ref t| {
+ format!("{}", t)
+ }).collect();
try!(write!(f, "{{\"inputs\":[{}],\"output\":", inputs.connect(",")));
match self.output {
privmod: false,
public_items: public_items,
orphan_methods: Vec::new(),
- traits: analysis.as_ref().map(|a| {
- a.external_traits.borrow_mut().take().unwrap()
- }).unwrap_or(HashMap::new()),
+ traits: mem::replace(&mut krate.external_traits, HashMap::new()),
typarams: analysis.as_ref().map(|a| {
a.external_typarams.borrow_mut().take().unwrap()
}).unwrap_or(HashMap::new()),
let path = match self.paths.get(&did) {
Some(&(_, ItemType::Trait)) =>
Some(&self.stack[..self.stack.len() - 1]),
- // The current stack not necessarily has correlation for
- // where the type was defined. On the other hand,
- // `paths` always has the right information if present.
+ // The current stack not necessarily has correlation
+ // for where the type was defined. On the other
+ // hand, `paths` always has the right
+ // information if present.
Some(&(ref fqp, ItemType::Struct)) |
Some(&(ref fqp, ItemType::Enum)) =>
Some(&fqp[..fqp.len() - 1]),
self.parent_stack.push(did);
true
}
- _ => false
+ ref t => {
+ match t.primitive_type() {
+ Some(prim) => {
+ let did = ast_util::local_def(prim.to_node_id());
+ self.parent_stack.push(did);
+ true
+ }
+ _ => false,
+ }
+ }
}
}
_ => false
Some(item) => {
match item {
clean::Item{ attrs, inner: clean::ImplItem(i), .. } => {
- use clean::{Primitive, Vector, ResolvedPath, BorrowedRef};
- use clean::PrimitiveType::{Array, Slice, PrimitiveTuple};
- use clean::{FixedVector, Tuple};
-
// extract relevant documentation for this impl
let dox = match attrs.into_iter().find(|a| {
match *a {
// Figure out the id of this impl. This may map to a
// primitive rather than always to a struct/enum.
let did = match i.for_ {
- ResolvedPath { did, .. } => Some(did),
-
- // References to primitives are picked up as well to
- // recognize implementations for &str, this may not
- // be necessary in a DST world.
- Primitive(p) |
- BorrowedRef { type_: box Primitive(p), ..} =>
- {
- Some(ast_util::local_def(p.to_node_id()))
+ clean::ResolvedPath { did, .. } |
+ clean::BorrowedRef {
+ type_: box clean::ResolvedPath { did, .. }, ..
+ } => {
+ Some(did)
}
- FixedVector(..) |
- BorrowedRef { type_: box FixedVector(..), .. } =>
- {
- Some(ast_util::local_def(Array.to_node_id()))
+ ref t => {
+ t.primitive_type().map(|p| {
+ ast_util::local_def(p.to_node_id())
+ })
}
-
- // In a DST world, we may only need Vector, but for now we
- // also pick up borrowed references
- Vector(..) |
- BorrowedRef{ type_: box Vector(..), .. } =>
- {
- Some(ast_util::local_def(Slice.to_node_id()))
- }
-
- Tuple(..) => {
- let id = PrimitiveTuple.to_node_id();
- Some(ast_util::local_def(id))
- }
-
- _ => None,
};
if let Some(did) = did {
fn ignore_private_item(&self, it: &clean::Item) -> bool {
match it.inner {
clean::ModuleItem(ref m) => {
- (m.items.len() == 0 && it.doc_value().is_none()) ||
+ (m.items.len() == 0 &&
+ it.doc_value().is_none() &&
+ it.visibility != Some(ast::Public)) ||
(self.passes.contains("strip-private") && it.visibility != Some(ast::Public))
}
clean::PrimitiveItem(..) => it.visibility != Some(ast::Public),
fn item_function(w: &mut fmt::Formatter, it: &clean::Item,
f: &clean::Function) -> fmt::Result {
- try!(write!(w, "<pre class='rust fn'>{vis}{unsafety}fn \
+ try!(write!(w, "<pre class='rust fn'>{vis}{unsafety}{abi}fn \
{name}{generics}{decl}{where_clause}</pre>",
vis = VisSpace(it.visibility),
unsafety = UnsafetySpace(f.unsafety),
+ abi = AbiSpace(f.abi),
name = it.name.as_ref().unwrap(),
generics = f.generics,
where_clause = WhereClause(&f.generics),
try!(write!(w, "{{\n"));
for t in &types {
try!(write!(w, " "));
- try!(render_method(w, t));
+ try!(render_method(w, t, MethodLink::Anchor));
try!(write!(w, ";\n"));
}
if types.len() > 0 && required.len() > 0 {
}
for m in &required {
try!(write!(w, " "));
- try!(render_method(w, m));
+ try!(render_method(w, m, MethodLink::Anchor));
try!(write!(w, ";\n"));
}
if required.len() > 0 && provided.len() > 0 {
}
for m in &provided {
try!(write!(w, " "));
- try!(render_method(w, m));
+ try!(render_method(w, m, MethodLink::Anchor));
try!(write!(w, " {{ ... }}\n"));
}
try!(write!(w, "}}"));
shortty(m),
*m.name.as_ref().unwrap(),
ConciseStability(&m.stability)));
- try!(render_method(w, m));
+ try!(render_method(w, m, MethodLink::Anchor));
try!(write!(w, "</code></h3>"));
try!(document(w, m));
Ok(())
try!(write!(w, "</div>"));
}
+ // If there are methods directly on this trait object, render them here.
+ try!(render_methods(w, it));
+
let cache = cache();
try!(write!(w, "
<h2 id='implementors'>Implementors</h2>
Ok(())
}
-fn render_method(w: &mut fmt::Formatter, meth: &clean::Item) -> fmt::Result {
+fn render_method(w: &mut fmt::Formatter, meth: &clean::Item,
+ link: MethodLink) -> fmt::Result {
fn method(w: &mut fmt::Formatter, it: &clean::Item,
unsafety: ast::Unsafety, abi: abi::Abi,
g: &clean::Generics, selfty: &clean::SelfTy,
- d: &clean::FnDecl) -> fmt::Result {
+ d: &clean::FnDecl, link: MethodLink) -> fmt::Result {
use syntax::abi::Abi;
- write!(w, "{}{}fn <a href='#{ty}.{name}' class='fnname'>{name}</a>\
+ let name = it.name.as_ref().unwrap();
+ let anchor = format!("#{}.{}", shortty(it), name);
+ let href = match link {
+ MethodLink::Anchor => anchor,
+ MethodLink::GotoSource(did) => {
+ href(did).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
+ }
+ };
+ write!(w, "{}{}fn <a href='{href}' class='fnname'>{name}</a>\
{generics}{decl}{where_clause}",
match unsafety {
ast::Unsafety::Unsafe => "unsafe ",
Abi::Rust => String::new(),
a => format!("extern {} ", a.to_string())
},
- ty = shortty(it),
- name = it.name.as_ref().unwrap(),
+ href = href,
+ name = name,
generics = *g,
decl = Method(selfty, d),
where_clause = WhereClause(g))
}
match meth.inner {
clean::TyMethodItem(ref m) => {
- method(w, meth, m.unsafety, m.abi, &m.generics, &m.self_, &m.decl)
+ method(w, meth, m.unsafety, m.abi, &m.generics, &m.self_, &m.decl,
+ link)
}
clean::MethodItem(ref m) => {
- method(w, meth, m.unsafety, m.abi, &m.generics, &m.self_, &m.decl)
+ method(w, meth, m.unsafety, m.abi, &m.generics, &m.self_, &m.decl,
+ link)
}
clean::AssociatedTypeItem(ref bounds, ref default) => {
assoc_type(w, meth, bounds, default)
Ok(())
}
+#[derive(Copy, Clone)]
+enum MethodLink {
+ Anchor,
+ GotoSource(ast::DefId),
+}
+
fn render_methods(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result {
- match cache().impls.get(&it.def_id) {
- Some(v) => {
- let (non_trait, traits): (Vec<_>, _) = v.iter().cloned()
- .partition(|i| i.impl_.trait_.is_none());
- if non_trait.len() > 0 {
- try!(write!(w, "<h2 id='methods'>Methods</h2>"));
- for i in &non_trait {
- try!(render_impl(w, i));
- }
- }
- if traits.len() > 0 {
- try!(write!(w, "<h2 id='implementations'>Trait \
- Implementations</h2>"));
- let (derived, manual): (Vec<_>, _) = traits.into_iter()
- .partition(|i| i.impl_.derived);
- for i in &manual {
- try!(render_impl(w, i));
- }
- if derived.len() > 0 {
- try!(write!(w, "<h3 id='derived_implementations'>Derived Implementations \
- </h3>"));
- for i in &derived {
- try!(render_impl(w, i));
- }
- }
+ let v = match cache().impls.get(&it.def_id) {
+ Some(v) => v.clone(),
+ None => return Ok(()),
+ };
+ let (non_trait, traits): (Vec<_>, _) = v.into_iter()
+ .partition(|i| i.impl_.trait_.is_none());
+ if non_trait.len() > 0 {
+ try!(write!(w, "<h2 id='methods'>Methods</h2>"));
+ for i in &non_trait {
+ try!(render_impl(w, i, MethodLink::Anchor));
+ }
+ }
+ if traits.len() > 0 {
+ try!(write!(w, "<h2 id='implementations'>Trait \
+ Implementations</h2>"));
+ let (derived, manual): (Vec<_>, _) = traits.into_iter()
+ .partition(|i| i.impl_.derived);
+ for i in &manual {
+ let did = i.trait_did().unwrap();
+ try!(render_impl(w, i, MethodLink::GotoSource(did)));
+ }
+ if derived.len() > 0 {
+ try!(write!(w, "<h3 id='derived_implementations'>\
+ Derived Implementations \
+ </h3>"));
+ for i in &derived {
+ let did = i.trait_did().unwrap();
+ try!(render_impl(w, i, MethodLink::GotoSource(did)));
}
}
- None => {}
}
Ok(())
}
-fn render_impl(w: &mut fmt::Formatter, i: &Impl) -> fmt::Result {
+fn render_impl(w: &mut fmt::Formatter, i: &Impl, link: MethodLink)
+ -> fmt::Result {
try!(write!(w, "<h3 class='impl'>{}<code>impl{} ",
ConciseStability(&i.stability),
i.impl_.generics));
- match i.impl_.polarity {
- Some(clean::ImplPolarity::Negative) => try!(write!(w, "!")),
- _ => {}
+ if let Some(clean::ImplPolarity::Negative) = i.impl_.polarity {
+ try!(write!(w, "!"));
}
- match i.impl_.trait_ {
- Some(ref ty) => try!(write!(w, "{} for ", *ty)),
- None => {}
+ if let Some(ref ty) = i.impl_.trait_ {
+ try!(write!(w, "{} for ", *ty));
}
- try!(write!(w, "{}{}</code></h3>", i.impl_.for_, WhereClause(&i.impl_.generics)));
- match i.dox {
- Some(ref dox) => {
- try!(write!(w, "<div class='docblock'>{}</div>",
- Markdown(dox)));
- }
- None => {}
+ try!(write!(w, "{}{}</code></h3>", i.impl_.for_,
+ WhereClause(&i.impl_.generics)));
+ if let Some(ref dox) = i.dox {
+ try!(write!(w, "<div class='docblock'>{}</div>", Markdown(dox)));
}
- fn doctraititem(w: &mut fmt::Formatter, item: &clean::Item, dox: bool)
- -> fmt::Result {
+ fn doctraititem(w: &mut fmt::Formatter, item: &clean::Item,
+ dox: bool, link: MethodLink) -> fmt::Result {
match item.inner {
clean::MethodItem(..) | clean::TyMethodItem(..) => {
try!(write!(w, "<h4 id='method.{}' class='{}'>{}<code>",
*item.name.as_ref().unwrap(),
shortty(item),
ConciseStability(&item.stability)));
- try!(render_method(w, item));
+ try!(render_method(w, item, link));
try!(write!(w, "</code></h4>\n"));
}
clean::TypedefItem(ref tydef) => {
}
try!(write!(w, "<div class='impl-items'>"));
- for trait_item in &i.impl_.items {
- try!(doctraititem(w, trait_item, true));
+ for trait_item in i.impl_.items.iter() {
+ try!(doctraititem(w, trait_item, true, link));
}
fn render_default_methods(w: &mut fmt::Formatter,
+ did: ast::DefId,
t: &clean::Trait,
i: &clean::Impl) -> fmt::Result {
for trait_item in &t.items {
None => {}
}
- try!(doctraititem(w, trait_item, false));
+ try!(doctraititem(w, trait_item, false,
+ MethodLink::GotoSource(did)));
}
Ok(())
}
// default methods which weren't overridden in the implementation block.
// FIXME: this also needs to be done for associated types, whenever defaults
// for them work.
- match i.impl_.trait_ {
- Some(clean::ResolvedPath { did, .. }) => {
- try!({
- match cache().traits.get(&did) {
- Some(t) => try!(render_default_methods(w, t, &i.impl_)),
- None => {}
- }
- Ok(())
- })
+ if let Some(clean::ResolvedPath { did, .. }) = i.impl_.trait_ {
+ if let Some(t) = cache().traits.get(&did) {
+ try!(render_default_methods(w, did, t, &i.impl_));
}
- Some(..) | None => {}
}
try!(write!(w, "</div>"));
Ok(())
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::default::Default;
use std::fs::File;
-use std::io;
use std::io::prelude::*;
+use std::io;
use std::path::{PathBuf, Path};
use core;
use html::escape::Escape;
use html::markdown;
use html::markdown::{Markdown, MarkdownWithToc, find_testable_code, reset_headers};
-use test::Collector;
+use test::{TestOptions, Collector};
/// Separate any lines at the start of the file that begin with `%`.
fn extract_leading_metadata<'a>(s: &'a str) -> (Vec<&'a str>, &'a str) {
let input_str = load_or_return!(input, 1, 2);
let playground = matches.opt_str("markdown-playground-url");
if playground.is_some() {
- markdown::PLAYGROUND_KRATE.with(|s| { *s.borrow_mut() = None; });
+ markdown::PLAYGROUND_KRATE.with(|s| { *s.borrow_mut() = Some(None); });
}
let playground = playground.unwrap_or("".to_string());
mut test_args: Vec<String>) -> isize {
let input_str = load_or_return!(input, 1, 2);
- let mut collector = Collector::new(input.to_string(), libs, externs, true, false);
+ let mut opts = TestOptions::default();
+ opts.no_crate_inject = true;
+ let mut collector = Collector::new(input.to_string(), libs, externs,
+ true, opts);
find_testable_code(&input_str, &mut collector);
test_args.insert(0, "rustdoctest".to_string());
testing::test_main(&test_args, collector.tests);
use passes;
use visit_ast::RustdocVisitor;
+#[derive(Clone, Default)]
+pub struct TestOptions {
+ pub no_crate_inject: bool,
+ pub attrs: Vec<String>,
+}
+
pub fn run(input: &str,
cfgs: Vec<String>,
libs: SearchPaths,
"rustdoc-test", None)
.expect("phase_2_configure_and_expand aborted in rustdoc!");
- let inject_crate = should_inject_crate(&krate);
+ let opts = scrape_test_config(&krate);
let ctx = core::DocContext {
krate: &krate,
libs,
externs,
false,
- inject_crate);
+ opts);
collector.fold_crate(krate);
test_args.insert(0, "rustdoctest".to_string());
}
// Look for #![doc(test(no_crate_inject))], used by crates in the std facade
-fn should_inject_crate(krate: &::syntax::ast::Crate) -> bool {
+fn scrape_test_config(krate: &::syntax::ast::Crate) -> TestOptions {
use syntax::attr::AttrMetaMethods;
+ use syntax::print::pprust;
- let mut inject_crate = true;
-
- for attr in &krate.attrs {
- if attr.check_name("doc") {
- for list in attr.meta_item_list().into_iter() {
- for attr in list {
- if attr.check_name("test") {
- for list in attr.meta_item_list().into_iter() {
- for attr in list {
- if attr.check_name("no_crate_inject") {
- inject_crate = false;
- }
- }
- }
- }
+ let mut opts = TestOptions {
+ no_crate_inject: false,
+ attrs: Vec::new(),
+ };
+
+ let attrs = krate.attrs.iter().filter(|a| a.check_name("doc"))
+ .filter_map(|a| a.meta_item_list())
+ .flat_map(|l| l.iter())
+ .filter(|a| a.check_name("test"))
+ .filter_map(|a| a.meta_item_list())
+ .flat_map(|l| l.iter());
+ for attr in attrs {
+ if attr.check_name("no_crate_inject") {
+ opts.no_crate_inject = true;
+ }
+ if attr.check_name("attr") {
+ if let Some(l) = attr.meta_item_list() {
+ for item in l {
+ opts.attrs.push(pprust::meta_item_to_string(item));
}
}
}
}
- return inject_crate;
+ return opts;
}
-#[allow(deprecated)]
fn runtest(test: &str, cratename: &str, libs: SearchPaths,
externs: core::Externs,
should_panic: bool, no_run: bool, as_test_harness: bool,
- inject_crate: bool) {
+ opts: &TestOptions) {
// the test harness wants its own `main` & top level functions, so
// never wrap the test in `fn main() { ... }`
- let test = maketest(test, Some(cratename), true, as_test_harness,
- inject_crate);
+ let test = maketest(test, Some(cratename), as_test_harness, opts);
let input = config::Input::Str(test.to_string());
let sessopts = config::Options {
}
}
-pub fn maketest(s: &str, cratename: Option<&str>, lints: bool,
- dont_insert_main: bool, inject_crate: bool) -> String {
+pub fn maketest(s: &str, cratename: Option<&str>, dont_insert_main: bool,
+ opts: &TestOptions) -> String {
let (crate_attrs, everything_else) = partition_source(s);
let mut prog = String::new();
// are intended to be crate attributes.
prog.push_str(&crate_attrs);
- if lints {
- prog.push_str(r"
-#![allow(unused_variables, unused_assignments, unused_mut, unused_attributes, dead_code)]
-");
+ // Next, any attributes for other aspects such as lints.
+ for attr in &opts.attrs {
+ prog.push_str(&format!("#![{}]\n", attr));
}
// Don't inject `extern crate std` because it's already injected by the
// compiler.
- if !s.contains("extern crate") && inject_crate {
+ if !s.contains("extern crate") && !opts.no_crate_inject {
match cratename {
Some(cratename) => {
if s.contains(cratename) {
- prog.push_str(&format!("extern crate {};\n",
- cratename));
+ prog.push_str(&format!("extern crate {};\n", cratename));
}
}
None => {}
use_headers: bool,
current_header: Option<String>,
cratename: String,
- inject_crate: bool
+ opts: TestOptions,
}
impl Collector {
pub fn new(cratename: String, libs: SearchPaths, externs: core::Externs,
- use_headers: bool, inject_crate: bool) -> Collector {
+ use_headers: bool, opts: TestOptions) -> Collector {
Collector {
tests: Vec::new(),
names: Vec::new(),
use_headers: use_headers,
current_header: None,
cratename: cratename,
- inject_crate: inject_crate
+ opts: opts,
}
}
let libs = self.libs.clone();
let externs = self.externs.clone();
let cratename = self.cratename.to_string();
- let inject_crate = self.inject_crate;
+ let opts = self.opts.clone();
debug!("Creating test {}: {}", name, test);
self.tests.push(testing::TestDescAndFn {
desc: testing::TestDesc {
name: testing::DynTestName(name),
ignore: should_ignore,
- should_panic: testing::ShouldPanic::No, // compiler failures are test failures
+ // compiler failures are test failures
+ should_panic: testing::ShouldPanic::No,
},
testfn: testing::DynTestFn(Box::new(move|| {
runtest(&test,
should_panic,
no_run,
as_test_harness,
- inject_crate);
+ &opts);
}))
});
}
//! usable for clean
use std::collections::HashSet;
+use std::mem;
use syntax::abi;
use syntax::ast;
pub cx: &'a core::DocContext<'tcx>,
pub analysis: Option<&'a core::CrateAnalysis>,
view_item_stack: HashSet<ast::NodeId>,
+ inlining_from_glob: bool,
}
impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
cx: cx,
analysis: analysis,
view_item_stack: stack,
+ inlining_from_glob: false,
}
}
pub fn visit_fn(&mut self, item: &ast::Item,
name: ast::Ident, fd: &ast::FnDecl,
- unsafety: &ast::Unsafety, _abi: &abi::Abi,
+ unsafety: &ast::Unsafety, abi: &abi::Abi,
gen: &ast::Generics) -> Function {
debug!("Visiting fn");
Function {
whence: item.span,
generics: gen.clone(),
unsafety: *unsafety,
+ abi: *abi,
}
}
let ret = match tcx.map.get(def.node) {
ast_map::NodeItem(it) => {
if glob {
+ let prev = mem::replace(&mut self.inlining_from_glob, true);
match it.node {
ast::ItemMod(ref m) => {
for i in &m.items {
ast::ItemEnum(..) => {}
_ => { panic!("glob not mapped to a module or enum"); }
}
+ self.inlining_from_glob = prev;
} else {
self.visit_item(it, renamed, om);
}
vis: item.vis,
stab: self.stability(item.id),
};
- om.impls.push(i);
+ // Don't duplicate impls when inlining glob imports, we'll pick
+ // them up regardless of where they're located.
+ if !self.inlining_from_glob {
+ om.impls.push(i);
+ }
},
ast::ItemDefaultImpl(unsafety, ref trait_ref) => {
let i = DefaultImpl {
attrs: item.attrs.clone(),
whence: item.span,
};
- om.def_traits.push(i);
+ // see comment above about ItemImpl
+ if !self.inlining_from_glob {
+ om.def_traits.push(i);
+ }
}
ast::ItemForeignMod(ref fm) => {
om.foreigns.push(fm.clone());
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
/// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
/// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
/// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
/// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// let b: HashSet<_> = [4, 2, 3, 4].iter().cloned().collect();
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
///
/// let set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
///
/// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
///
/// let sup: HashSet<_> = [1, 2, 3].iter().cloned().collect();
/// # Examples
///
/// ```
- /// # #![feature(core)]
/// use std::collections::HashSet;
///
/// let sub: HashSet<_> = [1, 2].iter().cloned().collect();
//! Collection types.
//!
-//! Rust's standard collection library provides efficient implementations of the most common
-//! general purpose programming data structures. By using the standard implementations,
-//! it should be possible for two libraries to communicate without significant data conversion.
-//!
-//! To get this out of the way: you should probably just use `Vec` or `HashMap`. These two
-//! collections cover most use cases for generic data storage and processing. They are
-//! exceptionally good at doing what they do. All the other collections in the standard
-//! library have specific use cases where they are the optimal choice, but these cases are
-//! borderline *niche* in comparison. Even when `Vec` and `HashMap` are technically suboptimal,
-//! they're probably a good enough choice to get started.
+//! Rust's standard collection library provides efficient implementations of the
+//! most common general purpose programming data structures. By using the
+//! standard implementations, it should be possible for two libraries to
+//! communicate without significant data conversion.
+//!
+//! To get this out of the way: you should probably just use `Vec` or `HashMap`.
+//! These two collections cover most use cases for generic data storage and
+//! processing. They are exceptionally good at doing what they do. All the other
+//! collections in the standard library have specific use cases where they are
+//! the optimal choice, but these cases are borderline *niche* in comparison.
+//! Even when `Vec` and `HashMap` are technically suboptimal, they're probably a
+//! good enough choice to get started.
//!
//! Rust's collections can be grouped into four major categories:
//!
//!
//! # When Should You Use Which Collection?
//!
-//! These are fairly high-level and quick break-downs of when each collection should be
-//! considered. Detailed discussions of strengths and weaknesses of individual collections
-//! can be found on their own documentation pages.
+//! These are fairly high-level and quick break-downs of when each collection
+//! should be considered. Detailed discussions of strengths and weaknesses of
+//! individual collections can be found on their own documentation pages.
//!
//! ### Use a `Vec` when:
-//! * You want to collect items up to be processed or sent elsewhere later, and don't care about
-//! any properties of the actual values being stored.
-//! * You want a sequence of elements in a particular order, and will only be appending to
-//! (or near) the end.
+//! * You want to collect items up to be processed or sent elsewhere later, and
+//! don't care about any properties of the actual values being stored.
+//! * You want a sequence of elements in a particular order, and will only be
+//! appending to (or near) the end.
//! * You want a stack.
//! * You want a resizable array.
//! * You want a heap-allocated array.
//!
//! ### Use a `VecDeque` when:
-//! * You want a `Vec` that supports efficient insertion at both ends of the sequence.
+//! * You want a `Vec` that supports efficient insertion at both ends of the
+//! sequence.
//! * You want a queue.
//! * You want a double-ended queue (deque).
//!
//! ### Use a `LinkedList` when:
-//! * You want a `Vec` or `VecDeque` of unknown size, and can't tolerate amortization.
+//! * You want a `Vec` or `VecDeque` of unknown size, and can't tolerate
+//! amortization.
//! * You want to efficiently split and append lists.
-//! * You are *absolutely* certain you *really*, *truly*, want a doubly linked list.
+//! * You are *absolutely* certain you *really*, *truly*, want a doubly linked
+//! list.
//!
//! ### Use a `HashMap` when:
//! * You want to associate arbitrary keys with an arbitrary value.
//!
//! ### Use a `BTreeMap` when:
//! * You're interested in what the smallest or largest key-value pair is.
-//! * You want to find the largest or smallest key that is smaller or larger than something
+//! * You want to find the largest or smallest key that is smaller or larger
+//! than something
//! * You want to be able to get all of the entries in order on-demand.
//! * You want a sorted map.
//!
//! * You want a `BitVec`, but want `Set` properties
//!
//! ### Use a `BinaryHeap` when:
-//! * You want to store a bunch of elements, but only ever want to process the "biggest"
-//! or "most important" one at any given time.
+//!
+//! * You want to store a bunch of elements, but only ever want to process the
+//! "biggest" or "most important" one at any given time.
//! * You want a priority queue.
//!
//! # Performance
//!
-//! Choosing the right collection for the job requires an understanding of what each collection
-//! is good at. Here we briefly summarize the performance of different collections for certain
-//! important operations. For further details, see each type's documentation, and note that the
-//! names of actual methods may differ from the tables below on certain collections.
+//! Choosing the right collection for the job requires an understanding of what
+//! each collection is good at. Here we briefly summarize the performance of
+//! different collections for certain important operations. For further details,
+//! see each type's documentation, and note that the names of actual methods may
+//! differ from the tables below on certain collections.
//!
-//! Throughout the documentation, we will follow a few conventions. For all operations,
-//! the collection's size is denoted by n. If another collection is involved in the operation, it
-//! contains m elements. Operations which have an *amortized* cost are suffixed with a `*`.
-//! Operations with an *expected* cost are suffixed with a `~`.
+//! Throughout the documentation, we will follow a few conventions. For all
+//! operations, the collection's size is denoted by n. If another collection is
+//! involved in the operation, it contains m elements. Operations which have an
+//! *amortized* cost are suffixed with a `*`. Operations with an *expected*
+//! cost are suffixed with a `~`.
//!
-//! All amortized costs are for the potential need to resize when capacity is exhausted.
-//! If a resize occurs it will take O(n) time. Our collections never automatically shrink,
-//! so removal operations aren't amortized. Over a sufficiently large series of
-//! operations, the average cost per operation will deterministically equal the given cost.
+//! All amortized costs are for the potential need to resize when capacity is
+//! exhausted. If a resize occurs it will take O(n) time. Our collections never
+//! automatically shrink, so removal operations aren't amortized. Over a
+//! sufficiently large series of operations, the average cost per operation will
+//! deterministically equal the given cost.
//!
-//! Only HashMap has expected costs, due to the probabilistic nature of hashing. It is
-//! theoretically possible, though very unlikely, for HashMap to experience worse performance.
+//! Only HashMap has expected costs, due to the probabilistic nature of hashing.
+//! It is theoretically possible, though very unlikely, for HashMap to
+//! experience worse performance.
//!
//! ## Sequences
//!
//!
//! ## Maps
//!
-//! For Sets, all operations have the cost of the equivalent Map operation. For BitSet,
+//! For Sets, all operations have the cost of the equivalent Map operation. For
+//! BitSet,
//! refer to VecMap.
//!
//! | | get | insert | remove | predecessor |
//! | BTreeMap | O(log n) | O(log n) | O(log n) | O(log n) |
//! | VecMap | O(1) | O(1)? | O(1) | O(n) |
//!
-//! Note that VecMap is *incredibly* inefficient in terms of space. The O(1) insertion time
-//! assumes space for the element is already allocated. Otherwise, a large key may require a
-//! massive reallocation, with no direct relation to the number of elements in the collection.
-//! VecMap should only be seriously considered for small keys.
+//! Note that VecMap is *incredibly* inefficient in terms of space. The O(1)
+//! insertion time assumes space for the element is already allocated.
+//! Otherwise, a large key may require a massive reallocation, with no direct
+//! relation to the number of elements in the collection. VecMap should only be
+//! seriously considered for small keys.
//!
//! Note also that BTreeMap's precise preformance depends on the value of B.
//!
//! # Correct and Efficient Usage of Collections
//!
-//! Of course, knowing which collection is the right one for the job doesn't instantly
-//! permit you to use it correctly. Here are some quick tips for efficient and correct
-//! usage of the standard collections in general. If you're interested in how to use a
-//! specific collection in particular, consult its documentation for detailed discussion
-//! and code examples.
+//! Of course, knowing which collection is the right one for the job doesn't
+//! instantly permit you to use it correctly. Here are some quick tips for
+//! efficient and correct usage of the standard collections in general. If
+//! you're interested in how to use a specific collection in particular, consult
+//! its documentation for detailed discussion and code examples.
//!
//! ## Capacity Management
//!
-//! Many collections provide several constructors and methods that refer to "capacity".
-//! These collections are generally built on top of an array. Optimally, this array would be
-//! exactly the right size to fit only the elements stored in the collection, but for the
-//! collection to do this would be very inefficient. If the backing array was exactly the
-//! right size at all times, then every time an element is inserted, the collection would
-//! have to grow the array to fit it. Due to the way memory is allocated and managed on most
-//! computers, this would almost surely require allocating an entirely new array and
-//! copying every single element from the old one into the new one. Hopefully you can
-//! see that this wouldn't be very efficient to do on every operation.
-//!
-//! Most collections therefore use an *amortized* allocation strategy. They generally let
-//! themselves have a fair amount of unoccupied space so that they only have to grow
-//! on occasion. When they do grow, they allocate a substantially larger array to move
-//! the elements into so that it will take a while for another grow to be required. While
-//! this strategy is great in general, it would be even better if the collection *never*
-//! had to resize its backing array. Unfortunately, the collection itself doesn't have
-//! enough information to do this itself. Therefore, it is up to us programmers to give it
-//! hints.
-//!
-//! Any `with_capacity` constructor will instruct the collection to allocate enough space
-//! for the specified number of elements. Ideally this will be for exactly that many
-//! elements, but some implementation details may prevent this. `Vec` and `VecDeque` can
-//! be relied on to allocate exactly the requested amount, though. Use `with_capacity`
-//! when you know exactly how many elements will be inserted, or at least have a
-//! reasonable upper-bound on that number.
-//!
-//! When anticipating a large influx of elements, the `reserve` family of methods can
-//! be used to hint to the collection how much room it should make for the coming items.
-//! As with `with_capacity`, the precise behavior of these methods will be specific to
-//! the collection of interest.
-//!
-//! For optimal performance, collections will generally avoid shrinking themselves.
-//! If you believe that a collection will not soon contain any more elements, or
-//! just really need the memory, the `shrink_to_fit` method prompts the collection
-//! to shrink the backing array to the minimum size capable of holding its elements.
-//!
-//! Finally, if ever you're interested in what the actual capacity of the collection is,
-//! most collections provide a `capacity` method to query this information on demand.
-//! This can be useful for debugging purposes, or for use with the `reserve` methods.
+//! Many collections provide several constructors and methods that refer to
+//! "capacity". These collections are generally built on top of an array.
+//! Optimally, this array would be exactly the right size to fit only the
+//! elements stored in the collection, but for the collection to do this would
+//! be very inefficient. If the backing array was exactly the right size at all
+//! times, then every time an element is inserted, the collection would have to
+//! grow the array to fit it. Due to the way memory is allocated and managed on
+//! most computers, this would almost surely require allocating an entirely new
+//! array and copying every single element from the old one into the new one.
+//! Hopefully you can see that this wouldn't be very efficient to do on every
+//! operation.
+//!
+//! Most collections therefore use an *amortized* allocation strategy. They
+//! generally let themselves have a fair amount of unoccupied space so that they
+//! only have to grow on occasion. When they do grow, they allocate a
+//! substantially larger array to move the elements into so that it will take a
+//! while for another grow to be required. While this strategy is great in
+//! general, it would be even better if the collection *never* had to resize its
+//! backing array. Unfortunately, the collection itself doesn't have enough
+//! information to do this itself. Therefore, it is up to us programmers to give
+//! it hints.
+//!
+//! Any `with_capacity` constructor will instruct the collection to allocate
+//! enough space for the specified number of elements. Ideally this will be for
+//! exactly that many elements, but some implementation details may prevent
+//! this. `Vec` and `VecDeque` can be relied on to allocate exactly the
+//! requested amount, though. Use `with_capacity` when you know exactly how many
+//! elements will be inserted, or at least have a reasonable upper-bound on that
+//! number.
+//!
+//! When anticipating a large influx of elements, the `reserve` family of
+//! methods can be used to hint to the collection how much room it should make
+//! for the coming items. As with `with_capacity`, the precise behavior of
+//! these methods will be specific to the collection of interest.
+//!
+//! For optimal performance, collections will generally avoid shrinking
+//! themselves. If you believe that a collection will not soon contain any more
+//! elements, or just really need the memory, the `shrink_to_fit` method prompts
+//! the collection to shrink the backing array to the minimum size capable of
+//! holding its elements.
+//!
+//! Finally, if ever you're interested in what the actual capacity of the
+//! collection is, most collections provide a `capacity` method to query this
+//! information on demand. This can be useful for debugging purposes, or for
+//! use with the `reserve` methods.
//!
//! ## Iterators
//!
-//! Iterators are a powerful and robust mechanism used throughout Rust's standard
-//! libraries. Iterators provide a sequence of values in a generic, safe, efficient
-//! and convenient way. The contents of an iterator are usually *lazily* evaluated,
-//! so that only the values that are actually needed are ever actually produced, and
-//! no allocation need be done to temporarily store them. Iterators are primarily
-//! consumed using a `for` loop, although many functions also take iterators where
-//! a collection or sequence of values is desired.
-//!
-//! All of the standard collections provide several iterators for performing bulk
-//! manipulation of their contents. The three primary iterators almost every collection
-//! should provide are `iter`, `iter_mut`, and `into_iter`. Some of these are not
-//! provided on collections where it would be unsound or unreasonable to provide them.
+//! Iterators are a powerful and robust mechanism used throughout Rust's
+//! standard libraries. Iterators provide a sequence of values in a generic,
+//! safe, efficient and convenient way. The contents of an iterator are usually
+//! *lazily* evaluated, so that only the values that are actually needed are
+//! ever actually produced, and no allocation need be done to temporarily store
+//! them. Iterators are primarily consumed using a `for` loop, although many
+//! functions also take iterators where a collection or sequence of values is
+//! desired.
+//!
+//! All of the standard collections provide several iterators for performing
+//! bulk manipulation of their contents. The three primary iterators almost
+//! every collection should provide are `iter`, `iter_mut`, and `into_iter`.
+//! Some of these are not provided on collections where it would be unsound or
+//! unreasonable to provide them.
//!
//! `iter` provides an iterator of immutable references to all the contents of a
-//! collection in the most "natural" order. For sequence collections like `Vec`, this
-//! means the items will be yielded in increasing order of index starting at 0. For ordered
-//! collections like `BTreeMap`, this means that the items will be yielded in sorted order.
-//! For unordered collections like `HashMap`, the items will be yielded in whatever order
-//! the internal representation made most convenient. This is great for reading through
-//! all the contents of the collection.
+//! collection in the most "natural" order. For sequence collections like `Vec`,
+//! this means the items will be yielded in increasing order of index starting
+//! at 0. For ordered collections like `BTreeMap`, this means that the items
+//! will be yielded in sorted order. For unordered collections like `HashMap`,
+//! the items will be yielded in whatever order the internal representation made
+//! most convenient. This is great for reading through all the contents of the
+//! collection.
//!
//! ```
//! let vec = vec![1, 2, 3, 4];
//! }
//! ```
//!
-//! `iter_mut` provides an iterator of *mutable* references in the same order as `iter`.
-//! This is great for mutating all the contents of the collection.
+//! `iter_mut` provides an iterator of *mutable* references in the same order as
+//! `iter`. This is great for mutating all the contents of the collection.
//!
//! ```
//! let mut vec = vec![1, 2, 3, 4];
//! }
//! ```
//!
-//! `into_iter` transforms the actual collection into an iterator over its contents
-//! by-value. This is great when the collection itself is no longer needed, and the
-//! values are needed elsewhere. Using `extend` with `into_iter` is the main way that
-//! contents of one collection are moved into another. Calling `collect` on an iterator
-//! itself is also a great way to convert one collection into another. Both of these
-//! methods should internally use the capacity management tools discussed in the
-//! previous section to do this as efficiently as possible.
+//! `into_iter` transforms the actual collection into an iterator over its
+//! contents by-value. This is great when the collection itself is no longer
+//! needed, and the values are needed elsewhere. Using `extend` with `into_iter`
+//! is the main way that contents of one collection are moved into another.
+//! Calling `collect` on an iterator itself is also a great way to convert one
+//! collection into another. Both of these methods should internally use the
+//! capacity management tools discussed in the previous section to do this as
+//! efficiently as possible.
//!
//! ```
//! let mut vec1 = vec![1, 2, 3, 4];
//! let buf: VecDeque<_> = vec.into_iter().collect();
//! ```
//!
-//! Iterators also provide a series of *adapter* methods for performing common tasks to
-//! sequences. Among the adapters are functional favorites like `map`, `fold`, `skip`,
-//! and `take`. Of particular interest to collections is the `rev` adapter, that
-//! reverses any iterator that supports this operation. Most collections provide reversible
-//! iterators as the way to iterate over them in reverse order.
+//! Iterators also provide a series of *adapter* methods for performing common
+//! tasks to sequences. Among the adapters are functional favorites like `map`,
+//! `fold`, `skip`, and `take`. Of particular interest to collections is the
+//! `rev` adapter, that reverses any iterator that supports this operation. Most
+//! collections provide reversible iterators as the way to iterate over them in
+//! reverse order.
//!
//! ```
//! let vec = vec![1, 2, 3, 4];
//! }
//! ```
//!
-//! Several other collection methods also return iterators to yield a sequence of results
-//! but avoid allocating an entire collection to store the result in. This provides maximum
-//! flexibility as `collect` or `extend` can be called to "pipe" the sequence into any
-//! collection if desired. Otherwise, the sequence can be looped over with a `for` loop. The
-//! iterator can also be discarded after partial use, preventing the computation of the unused
-//! items.
+//! Several other collection methods also return iterators to yield a sequence
+//! of results but avoid allocating an entire collection to store the result in.
+//! This provides maximum flexibility as `collect` or `extend` can be called to
+//! "pipe" the sequence into any collection if desired. Otherwise, the sequence
+//! can be looped over with a `for` loop. The iterator can also be discarded
+//! after partial use, preventing the computation of the unused items.
//!
//! ## Entries
//!
-//! The `entry` API is intended to provide an efficient mechanism for manipulating
-//! the contents of a map conditionally on the presence of a key or not. The primary
-//! motivating use case for this is to provide efficient accumulator maps. For instance,
-//! if one wishes to maintain a count of the number of times each key has been seen,
-//! they will have to perform some conditional logic on whether this is the first time
-//! the key has been seen or not. Normally, this would require a `find` followed by an
-//! `insert`, effectively duplicating the search effort on each insertion.
-//!
-//! When a user calls `map.entry(&key)`, the map will search for the key and then yield
-//! a variant of the `Entry` enum.
-//!
-//! If a `Vacant(entry)` is yielded, then the key *was not* found. In this case the
-//! only valid operation is to `insert` a value into the entry. When this is done,
-//! the vacant entry is consumed and converted into a mutable reference to the
-//! the value that was inserted. This allows for further manipulation of the value
-//! beyond the lifetime of the search itself. This is useful if complex logic needs to
-//! be performed on the value regardless of whether the value was just inserted.
-//!
-//! If an `Occupied(entry)` is yielded, then the key *was* found. In this case, the user
-//! has several options: they can `get`, `insert`, or `remove` the value of the occupied
-//! entry. Additionally, they can convert the occupied entry into a mutable reference
-//! to its value, providing symmetry to the vacant `insert` case.
+//! The `entry` API is intended to provide an efficient mechanism for
+//! manipulating the contents of a map conditionally on the presence of a key or
+//! not. The primary motivating use case for this is to provide efficient
+//! accumulator maps. For instance, if one wishes to maintain a count of the
+//! number of times each key has been seen, they will have to perform some
+//! conditional logic on whether this is the first time the key has been seen or
+//! not. Normally, this would require a `find` followed by an `insert`,
+//! effectively duplicating the search effort on each insertion.
+//!
+//! When a user calls `map.entry(&key)`, the map will search for the key and
+//! then yield a variant of the `Entry` enum.
+//!
+//! If a `Vacant(entry)` is yielded, then the key *was not* found. In this case
+//! the only valid operation is to `insert` a value into the entry. When this is
+//! done, the vacant entry is consumed and converted into a mutable reference to
+//! the the value that was inserted. This allows for further manipulation of the
+//! value beyond the lifetime of the search itself. This is useful if complex
+//! logic needs to be performed on the value regardless of whether the value was
+//! just inserted.
+//!
+//! If an `Occupied(entry)` is yielded, then the key *was* found. In this case,
+//! the user has several options: they can `get`, `insert`, or `remove` the
+//! value of the occupied entry. Additionally, they can convert the occupied
+//! entry into a mutable reference to its value, providing symmetry to the
+//! vacant `insert` case.
//!
//! ### Examples
//!
-//! Here are the two primary ways in which `entry` is used. First, a simple example
-//! where the logic performed on the values is trivial.
+//! Here are the two primary ways in which `entry` is used. First, a simple
+//! example where the logic performed on the values is trivial.
//!
//! #### Counting the number of times each character in a string occurs
//!
//! ```
-//! # #![feature(collections)]
-//! use std::collections::btree_map::{BTreeMap, Entry};
+//! use std::collections::btree_map::BTreeMap;
//!
//! let mut count = BTreeMap::new();
//! let message = "she sells sea shells by the sea shore";
//! }
//! ```
//!
-//! When the logic to be performed on the value is more complex, we may simply use
-//! the `entry` API to ensure that the value is initialized, and perform the logic
-//! afterwards.
+//! When the logic to be performed on the value is more complex, we may simply
+//! use the `entry` API to ensure that the value is initialized, and perform the
+//! logic afterwards.
//!
//! #### Tracking the inebriation of customers at a bar
//!
//! ```
-//! # #![feature(collections)]
-//! use std::collections::btree_map::{BTreeMap, Entry};
+//! use std::collections::btree_map::BTreeMap;
//!
//! // A client of the bar. They have an id and a blood alcohol level.
//! struct Person { id: u32, blood_alcohol: f32 }
/// Options and flags which can be used to configure how a file is opened.
///
-/// This builder exposes the ability to configure how a `File` is opened and what operations are
-/// permitted on the open file. The `File::open` and `File::create` methods are aliases for
-/// commonly used options using this builder.
+/// This builder exposes the ability to configure how a `File` is opened and
+/// what operations are permitted on the open file. The `File::open` and
+/// `File::create` methods are aliases for commonly used options using this
+/// builder.
///
-/// Generally speaking, when using `OpenOptions`, you'll first call `new()`, then chain calls to
-/// methods to set each option, then call `open()`, passing the path of the file you're trying to
-/// open. This will give you a [`io::Result`][result] with a [`File`][file] inside that you can
-/// further operate on.
+/// Generally speaking, when using `OpenOptions`, you'll first call `new()`,
+/// then chain calls to methods to set each option, then call `open()`, passing
+/// the path of the file you're trying to open. This will give you a
+/// [`io::Result`][result] with a [`File`][file] inside that you can further
+/// operate on.
///
/// [result]: ../io/type.Result.html
/// [file]: struct.File.html
/// Opening a file to read:
///
/// ```no_run
-/// use std::fs;
/// use std::fs::OpenOptions;
///
/// let file = OpenOptions::new().read(true).open("foo.txt");
/// ```
///
-/// Opening a file for both reading and writing, as well as creating it if it doesn't exist:
+/// Opening a file for both reading and writing, as well as creating it if it
+/// doesn't exist:
///
/// ```
-/// use std::fs;
/// use std::fs::OpenOptions;
///
/// let file = OpenOptions::new()
/// ```no_run
/// use std::fs;
///
-/// fs::copy("foo.txt", "bar.txt");
+/// # fn foo() -> std::io::Result<()> {
+/// try!(fs::copy("foo.txt", "bar.txt"));
+/// # Ok(()) }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<u64> {
//! by adding a glob import to the top of I/O heavy modules:
//!
//! ```
+//! # #![allow(unused_imports)]
//! use std::io::prelude::*;
//! ```
//!
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-#![doc(test(no_crate_inject))]
+#![doc(test(no_crate_inject, attr(deny(warnings))))]
+#![doc(test(attr(allow(dead_code, deprecated, unused_variables, unused_mut))))]
#![feature(alloc)]
#![feature(box_syntax)]
/// Some examples:
///
/// ```no_run
-/// # #![feature(net)]
/// use std::net::{SocketAddrV4, TcpStream, UdpSocket, TcpListener, Ipv4Addr};
///
/// fn main() {
/// let tcp_l = TcpListener::bind("localhost:12345");
///
/// let mut udp_s = UdpSocket::bind(("127.0.0.1", port)).unwrap();
-/// udp_s.send_to(&[7], (ip, 23451));
+/// udp_s.send_to(&[7], (ip, 23451)).unwrap();
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// # Examples
///
/// ```no_run
-/// # #![feature(net)]
/// use std::io::prelude::*;
/// use std::net::TcpStream;
///
/// # Examples
///
/// ```no_run
-/// # #![feature(net)]
/// use std::net::{TcpListener, TcpStream};
/// use std::thread;
///
/// # Examples
///
/// ```no_run
-/// # #![feature(net)]
/// use std::net::UdpSocket;
///
/// # fn foo() -> std::io::Result<()> {
/// [subnormal][subnormal], or `NaN`.
///
/// ```
- /// # #![feature(std_misc)]
/// use std::f32;
///
/// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32
/// Convert radians to degrees.
///
/// ```
- /// # #![feature(std_misc, core)]
+ /// # #![feature(std_misc)]
/// use std::f32::{self, consts};
///
/// let angle = consts::PI;
/// * Else: `self - other`
///
/// ```
- /// # #![feature(std_misc)]
/// use std::f32;
///
/// let x = 3.0f32;
/// Take the cubic root of a number.
///
/// ```
- /// # #![feature(std_misc)]
/// use std::f32;
///
/// let x = 8.0f32;
/// number is close to zero.
///
/// ```
- /// use std::f64;
- ///
/// let x = 7.0f64;
///
/// // e^(ln(7)) - 1
/// [subnormal][subnormal], or `NaN`.
///
/// ```
- /// # #![feature(std_misc)]
/// use std::num::Float;
/// use std::f32;
///
/// predicate instead.
///
/// ```
- /// # #![feature(core)]
/// use std::num::{Float, FpCategory};
/// use std::f32;
///
/// number is `Float::nan()`.
///
/// ```
- /// # #![feature(std_misc)]
/// use std::num::Float;
/// use std::f64;
///
/// - `Float::nan()` if the number is `Float::nan()`
///
/// ```
- /// # #![feature(std_misc)]
/// use std::num::Float;
/// use std::f64;
///
/// Convert radians to degrees.
///
/// ```
- /// # #![feature(std_misc, core)]
/// use std::num::Float;
/// use std::f64::consts;
///
/// Convert degrees to radians.
///
/// ```
- /// # #![feature(std_misc, core)]
+ /// # #![feature(std_misc)]
/// use std::num::Float;
/// use std::f64::consts;
///
/// Computes the sine of a number (in radians).
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// Computes the cosine of a number (in radians).
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// Computes the tangent of a number (in radians).
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// [-1, 1].
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// [-1, 1].
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// `(sin(x), cos(x))`.
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// the operations were performed separately.
///
/// ```
- /// # #![feature(std_misc, core)]
/// use std::num::Float;
/// use std::f64;
///
/// Hyperbolic sine function.
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// Hyperbolic cosine function.
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// Hyperbolic tangent function.
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
/// Inverse hyperbolic tangent function.
///
/// ```
- /// # #![feature(core)]
/// use std::num::Float;
/// use std::f64;
///
//! * Read lines from stdin
//!
//! ```rust
-//! # #![feature(old_io, old_path)]
+//! # #![feature(old_io)]
//! use std::old_io as io;
//! use std::old_io::*;
//!
/// Some examples:
///
/// ```rust,no_run
-/// # #![feature(old_io, core, convert)]
+/// # #![feature(old_io)]
/// # #![allow(unused_must_use)]
///
/// use std::old_io::{TcpStream, TcpListener};
/// let server = Path::new("/path/to/my/socket");
/// let stream = UnixListener::bind(&server);
/// for mut client in stream.listen().incoming() {
- /// client.write(&[1, 2, 3, 4]);
+ /// let _ = client.write(&[1, 2, 3, 4]);
/// }
/// # }
/// ```
/// # Examples
///
/// ```
- /// # #![feature(old_io, core, convert)]
+ /// # #![feature(old_io)]
/// use std::old_io::Command;
///
/// let output = match Command::new("cat").arg("foot.txt").output() {
//!
//! ## Examples
//!
-//! ```rust
+//! ```rust,ignore
//! # #![feature(old_path, old_io)]
//! use std::old_io::fs::PathExtensions;
//! use std::old_path::{Path, GenericPath};
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// # #![feature(old_path)]
- /// use std::old_path::{Path, GenericPath};
- /// # foo();
- /// # #[cfg(windows)] fn foo() {}
- /// # #[cfg(unix)] fn foo() {
+ /// # fn main() {
+ /// use std::old_path::Path;
/// let path = Path::new("foo/bar");
/// # }
/// ```
///
/// # Examples
///
- /// ```
+ /// ```no_run
/// # #![feature(old_path)]
- /// use std::old_path::{Path, GenericPath};
- /// # foo();
- /// # #[cfg(windows)] fn foo() {}
- /// # #[cfg(unix)] fn foo() {
+ /// # fn main() {
+ /// use std::old_path::Path;
/// let x: &[u8] = b"foo\0";
/// assert!(Path::new_opt(x).is_none());
/// # }
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
///
/// # Examples
///
- /// ```
+ /// ```ignore
/// # #![feature(old_path)]
/// use std::old_path::{Path, GenericPath};
/// # foo();
use ffi::OsStr;
use fmt;
use io::{self, Error, ErrorKind};
-use libc;
use path;
use sync::mpsc::{channel, Receiver};
use sys::pipe2::{self, AnonPipe};
use sys::process2::Command as CommandImp;
use sys::process2::Process as ProcessImp;
use sys::process2::ExitStatus as ExitStatusImp;
+use sys::process2::Stdio as StdioImp2;
use sys_common::{AsInner, AsInnerMut};
use thread;
/// # Examples
///
/// ```should_panic
-/// # #![feature(process)]
-///
/// use std::process::Command;
///
/// let output = Command::new("/bin/cat").arg("file.txt").output().unwrap_or_else(|e| {
fn spawn_inner(&self, default_io: StdioImp) -> io::Result<Child> {
let (their_stdin, our_stdin) = try!(
- setup_io(self.stdin.as_ref().unwrap_or(&default_io), 0, true)
+ setup_io(self.stdin.as_ref().unwrap_or(&default_io), true)
);
let (their_stdout, our_stdout) = try!(
- setup_io(self.stdout.as_ref().unwrap_or(&default_io), 1, false)
+ setup_io(self.stdout.as_ref().unwrap_or(&default_io), false)
);
let (their_stderr, our_stderr) = try!(
- setup_io(self.stderr.as_ref().unwrap_or(&default_io), 2, false)
+ setup_io(self.stderr.as_ref().unwrap_or(&default_io), false)
);
match ProcessImp::spawn(&self.inner, their_stdin, their_stdout, their_stderr) {
/// # Examples
///
/// ```
- /// # #![feature(process)]
/// use std::process::Command;
- ///
- /// let output = Command::new("cat").arg("foot.txt").output().unwrap_or_else(|e| {
+ /// let output = Command::new("cat").arg("foo.txt").output().unwrap_or_else(|e| {
/// panic!("failed to execute process: {}", e)
/// });
///
/// # Examples
///
/// ```
- /// # #![feature(process)]
/// use std::process::Command;
///
/// let status = Command::new("ls").status().unwrap_or_else(|e| {
fn as_inner_mut(&mut self) -> &mut CommandImp { &mut self.inner }
}
-fn setup_io(io: &StdioImp, fd: libc::c_int, readable: bool)
- -> io::Result<(Option<AnonPipe>, Option<AnonPipe>)>
+fn setup_io(io: &StdioImp, readable: bool)
+ -> io::Result<(StdioImp2, Option<AnonPipe>)>
{
use self::StdioImp::*;
Ok(match *io {
- Null => {
- (None, None)
- }
- Inherit => {
- (Some(AnonPipe::from_fd(fd)), None)
- }
+ Null => (StdioImp2::None, None),
+ Inherit => (StdioImp2::Inherit, None),
Piped => {
- let (reader, writer) = try!(unsafe { pipe2::anon_pipe() });
+ let (reader, writer) = try!(pipe2::anon_pipe());
if readable {
- (Some(reader), Some(writer))
+ (StdioImp2::Piped(reader), Some(writer))
} else {
- (Some(writer), Some(reader))
+ (StdioImp2::Piped(writer), Some(reader))
}
}
})
target_os = "dragonfly",
target_os = "bitrig",
target_os = "openbsd"))]
-pub const FIONBIO: libc::c_ulong = 0x8004667e;
-#[cfg(any(all(target_os = "linux",
- any(target_arch = "x86",
- target_arch = "x86_64",
- target_arch = "arm",
- target_arch = "aarch64")),
- target_os = "android"))]
-pub const FIONBIO: libc::c_ulong = 0x5421;
-#[cfg(all(target_os = "linux",
- any(target_arch = "mips",
- target_arch = "mipsel",
- target_arch = "powerpc")))]
-pub const FIONBIO: libc::c_ulong = 0x667e;
-
-#[cfg(any(target_os = "macos",
- target_os = "ios",
- target_os = "freebsd",
- target_os = "dragonfly",
- target_os = "bitrig",
- target_os = "openbsd"))]
-pub const FIOCLEX: libc::c_ulong = 0x20006601;
+mod consts {
+ use libc;
+ pub const FIONBIO: libc::c_ulong = 0x8004667e;
+ pub const FIOCLEX: libc::c_ulong = 0x20006601;
+ pub const FIONCLEX: libc::c_ulong = 0x20006602;
+}
#[cfg(any(all(target_os = "linux",
any(target_arch = "x86",
target_arch = "x86_64",
target_arch = "arm",
target_arch = "aarch64")),
target_os = "android"))]
-pub const FIOCLEX: libc::c_ulong = 0x5451;
+mod consts {
+ use libc;
+ pub const FIONBIO: libc::c_ulong = 0x5421;
+ pub const FIOCLEX: libc::c_ulong = 0x5451;
+ pub const FIONCLEX: libc::c_ulong = 0x5450;
+}
#[cfg(all(target_os = "linux",
any(target_arch = "mips",
target_arch = "mipsel",
target_arch = "powerpc")))]
-pub const FIOCLEX: libc::c_ulong = 0x6601;
+mod consts {
+ use libc;
+ pub const FIONBIO: libc::c_ulong = 0x667e;
+ pub const FIOCLEX: libc::c_ulong = 0x6601;
+ pub const FIONCLEX: libc::c_ulong = 0x6600;
+}
+pub use self::consts::*;
#[cfg(any(target_os = "macos",
target_os = "ios",
pub fn utimes(filename: *const libc::c_char,
times: *const libc::timeval) -> libc::c_int;
pub fn gai_strerror(errcode: libc::c_int) -> *const libc::c_char;
+ pub fn setgroups(ngroups: libc::c_int,
+ ptr: *const libc::c_void) -> libc::c_int;
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
use io;
use libc::{self, c_int, size_t, c_void};
use mem;
+use sys::c;
use sys::cvt;
use sys_common::AsInner;
}));
Ok(ret as usize)
}
+
+ pub fn set_cloexec(&self) {
+ unsafe {
+ let ret = c::ioctl(self.fd, c::FIOCLEX);
+ debug_assert_eq!(ret, 0);
+ }
+ }
}
impl AsInner<c_int> for FileDesc {
impl Drop for FileDesc {
fn drop(&mut self) {
- // closing stdio file handles makes no sense, so never do it. Also, note
- // that errors are ignored when closing a file descriptor. The reason
- // for this is that if an error occurs we don't actually know if the
- // file descriptor was closed or not, and if we retried (for something
- // like EINTR), we might close another valid file descriptor (opened
- // after we closed ours.
- if self.fd > libc::STDERR_FILENO {
- let _ = unsafe { libc::close(self.fd) };
- }
+ // Note that errors are ignored when closing a file descriptor. The
+ // reason for this is that if an error occurs we don't actually know if
+ // the file descriptor was closed or not, and if we retried (for
+ // something like EINTR), we might close another valid file descriptor
+ // (opened after we closed ours.
+ let _ = unsafe { libc::close(self.fd) };
}
}
impl File {
pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+ let path = try!(cstr(path));
+ File::open_c(&path, opts)
+ }
+
+ pub fn open_c(path: &CStr, opts: &OpenOptions) -> io::Result<File> {
let flags = opts.flags | match (opts.read, opts.write) {
(true, true) => libc::O_RDWR,
(false, true) => libc::O_WRONLY,
(true, false) |
(false, false) => libc::O_RDONLY,
};
- let path = try!(cstr(path));
let fd = try!(cvt_r(|| unsafe {
libc::open(path.as_ptr(), flags, opts.mode)
}));
- Ok(File(FileDesc::new(fd)))
+ let fd = FileDesc::new(fd);
+ fd.set_cloexec();
+ Ok(File(fd))
}
+ pub fn into_fd(self) -> FileDesc { self.0 }
+
pub fn file_attr(&self) -> io::Result<FileAttr> {
let mut stat: libc::stat = unsafe { mem::zeroed() };
try!(cvt(unsafe { libc::fstat(self.0.raw(), &mut stat) }));
};
unsafe {
let fd = try!(cvt(libc::socket(fam, ty, 0)));
- Ok(Socket(FileDesc::new(fd)))
+ let fd = FileDesc::new(fd);
+ fd.set_cloexec();
+ Ok(Socket(fd))
}
}
let fd = try!(cvt_r(|| unsafe {
libc::accept(self.0.raw(), storage, len)
}));
- Ok(Socket(FileDesc::new(fd)))
+ let fd = FileDesc::new(fd);
+ fd.set_cloexec();
+ Ok(Socket(fd))
}
pub fn duplicate(&self) -> io::Result<Socket> {
- cvt(unsafe { libc::dup(self.0.raw()) }).map(|fd| {
- Socket(FileDesc::new(fd))
- })
+ let fd = try!(cvt(unsafe { libc::dup(self.0.raw()) }));
+ let fd = FileDesc::new(fd);
+ fd.set_cloexec();
+ Ok(Socket(fd))
}
pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
pub struct AnonPipe(FileDesc);
-pub unsafe fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> {
+pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> {
let mut fds = [0; 2];
- if libc::pipe(fds.as_mut_ptr()) == 0 {
- Ok((AnonPipe::from_fd(fds[0]),
- AnonPipe::from_fd(fds[1])))
+ if unsafe { libc::pipe(fds.as_mut_ptr()) == 0 } {
+ Ok((AnonPipe::from_fd(fds[0]), AnonPipe::from_fd(fds[1])))
} else {
Err(io::Error::last_os_error())
}
impl AnonPipe {
pub fn from_fd(fd: libc::c_int) -> AnonPipe {
- AnonPipe(FileDesc::new(fd))
+ let fd = FileDesc::new(fd);
+ fd.set_cloexec();
+ AnonPipe(fd)
}
pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
self.0.write(buf)
}
- pub fn raw(&self) -> libc::c_int {
- self.0.raw()
+ pub fn into_fd(self) -> FileDesc {
+ self.0
}
}
use collections::HashMap;
use env;
-use ffi::{OsString, OsStr, CString};
+use ffi::{OsString, OsStr, CString, CStr};
use fmt;
use io::{self, Error, ErrorKind};
use libc::{self, pid_t, c_void, c_int, gid_t, uid_t};
-use mem;
use ptr;
use sys::pipe2::AnonPipe;
use sys::{self, retry, c, cvt};
+use sys::fs2::{File, OpenOptions};
////////////////////////////////////////////////////////////////////////////////
// Command
pid: pid_t
}
+pub enum Stdio {
+ Inherit,
+ Piped(AnonPipe),
+ None,
+}
+
const CLOEXEC_MSG_FOOTER: &'static [u8] = b"NOEX";
impl Process {
}
pub fn spawn(cfg: &Command,
- in_fd: Option<AnonPipe>, out_fd: Option<AnonPipe>, err_fd: Option<AnonPipe>)
- -> io::Result<Process>
- {
- use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
-
- mod rustrt {
- extern {
- pub fn rust_unset_sigprocmask();
+ in_fd: Stdio,
+ out_fd: Stdio,
+ err_fd: Stdio) -> io::Result<Process> {
+ let dirp = cfg.cwd.as_ref().map(|c| c.as_ptr()).unwrap_or(ptr::null());
+
+ let (envp, _a, _b) = make_envp(cfg.env.as_ref());
+ let (argv, _a) = make_argv(&cfg.program, &cfg.args);
+ let (input, output) = try!(sys::pipe2::anon_pipe());
+
+ let pid = unsafe {
+ match libc::fork() {
+ 0 => {
+ drop(input);
+ Process::child_after_fork(cfg, output, argv, envp, dirp,
+ in_fd, out_fd, err_fd)
+ }
+ n if n < 0 => return Err(Error::last_os_error()),
+ n => n,
+ }
+ };
+
+ let p = Process{ pid: pid };
+ drop(output);
+ let mut bytes = [0; 8];
+
+ // loop to handle EINTR
+ loop {
+ match input.read(&mut bytes) {
+ Ok(0) => return Ok(p),
+ Ok(8) => {
+ assert!(combine(CLOEXEC_MSG_FOOTER) == combine(&bytes[4.. 8]),
+ "Validation on the CLOEXEC pipe failed: {:?}", bytes);
+ let errno = combine(&bytes[0.. 4]);
+ assert!(p.wait().is_ok(),
+ "wait() should either return Ok or panic");
+ return Err(Error::from_raw_os_error(errno))
+ }
+ Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
+ Err(e) => {
+ assert!(p.wait().is_ok(),
+ "wait() should either return Ok or panic");
+ panic!("the CLOEXEC pipe failed: {:?}", e)
+ },
+ Ok(..) => { // pipe I/O up to PIPE_BUF bytes should be atomic
+ assert!(p.wait().is_ok(),
+ "wait() should either return Ok or panic");
+ panic!("short read on the CLOEXEC pipe")
+ }
}
}
- unsafe fn set_cloexec(fd: c_int) {
- let ret = c::ioctl(fd, c::FIOCLEX);
- assert_eq!(ret, 0);
- }
+ fn combine(arr: &[u8]) -> i32 {
+ let a = arr[0] as u32;
+ let b = arr[1] as u32;
+ let c = arr[2] as u32;
+ let d = arr[3] as u32;
- #[cfg(all(target_os = "android", target_arch = "aarch64"))]
- unsafe fn getdtablesize() -> c_int {
- libc::sysconf(libc::consts::os::sysconf::_SC_OPEN_MAX) as c_int
+ ((a << 24) | (b << 16) | (c << 8) | (d << 0)) as i32
}
+ }
- #[cfg(not(all(target_os = "android", target_arch = "aarch64")))]
- unsafe fn getdtablesize() -> c_int {
- libc::funcs::bsd44::getdtablesize()
+ // And at this point we've reached a special time in the life of the
+ // child. The child must now be considered hamstrung and unable to
+ // do anything other than syscalls really. Consider the following
+ // scenario:
+ //
+ // 1. Thread A of process 1 grabs the malloc() mutex
+ // 2. Thread B of process 1 forks(), creating thread C
+ // 3. Thread C of process 2 then attempts to malloc()
+ // 4. The memory of process 2 is the same as the memory of
+ // process 1, so the mutex is locked.
+ //
+ // This situation looks a lot like deadlock, right? It turns out
+ // that this is what pthread_atfork() takes care of, which is
+ // presumably implemented across platforms. The first thing that
+ // threads to *before* forking is to do things like grab the malloc
+ // mutex, and then after the fork they unlock it.
+ //
+ // Despite this information, libnative's spawn has been witnessed to
+ // deadlock on both OSX and FreeBSD. I'm not entirely sure why, but
+ // all collected backtraces point at malloc/free traffic in the
+ // child spawned process.
+ //
+ // For this reason, the block of code below should contain 0
+ // invocations of either malloc of free (or their related friends).
+ //
+ // As an example of not having malloc/free traffic, we don't close
+ // this file descriptor by dropping the FileDesc (which contains an
+ // allocation). Instead we just close it manually. This will never
+ // have the drop glue anyway because this code never returns (the
+ // child will either exec() or invoke libc::exit)
+ unsafe fn child_after_fork(cfg: &Command,
+ mut output: AnonPipe,
+ argv: *const *const libc::c_char,
+ envp: *const libc::c_void,
+ dirp: *const libc::c_char,
+ in_fd: Stdio,
+ out_fd: Stdio,
+ err_fd: Stdio) -> ! {
+ fn fail(output: &mut AnonPipe) -> ! {
+ let errno = sys::os::errno() as u32;
+ let bytes = [
+ (errno >> 24) as u8,
+ (errno >> 16) as u8,
+ (errno >> 8) as u8,
+ (errno >> 0) as u8,
+ CLOEXEC_MSG_FOOTER[0], CLOEXEC_MSG_FOOTER[1],
+ CLOEXEC_MSG_FOOTER[2], CLOEXEC_MSG_FOOTER[3]
+ ];
+ // pipe I/O up to PIPE_BUF bytes should be atomic, and then we want
+ // to be sure we *don't* run at_exit destructors as we're being torn
+ // down regardless
+ assert!(output.write(&bytes).is_ok());
+ unsafe { libc::_exit(1) }
}
- let dirp = cfg.cwd.as_ref().map(|c| c.as_ptr()).unwrap_or(ptr::null());
-
- with_envp(cfg.env.as_ref(), |envp: *const c_void| {
- with_argv(&cfg.program, &cfg.args, |argv: *const *const libc::c_char| unsafe {
- let (input, mut output) = try!(sys::pipe2::anon_pipe());
-
- // We may use this in the child, so perform allocations before the
- // fork
- let devnull = b"/dev/null\0";
-
- set_cloexec(output.raw());
-
- let pid = fork();
- if pid < 0 {
- return Err(Error::last_os_error())
- } else if pid > 0 {
- #[inline]
- fn combine(arr: &[u8]) -> i32 {
- let a = arr[0] as u32;
- let b = arr[1] as u32;
- let c = arr[2] as u32;
- let d = arr[3] as u32;
-
- ((a << 24) | (b << 16) | (c << 8) | (d << 0)) as i32
- }
-
- let p = Process{ pid: pid };
- drop(output);
- let mut bytes = [0; 8];
-
- // loop to handle EINTER
- loop {
- match input.read(&mut bytes) {
- Ok(8) => {
- assert!(combine(CLOEXEC_MSG_FOOTER) == combine(&bytes[4.. 8]),
- "Validation on the CLOEXEC pipe failed: {:?}", bytes);
- let errno = combine(&bytes[0.. 4]);
- assert!(p.wait().is_ok(),
- "wait() should either return Ok or panic");
- return Err(Error::from_raw_os_error(errno))
- }
- Ok(0) => return Ok(p),
- Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
- Err(e) => {
- assert!(p.wait().is_ok(),
- "wait() should either return Ok or panic");
- panic!("the CLOEXEC pipe failed: {:?}", e)
- },
- Ok(..) => { // pipe I/O up to PIPE_BUF bytes should be atomic
- assert!(p.wait().is_ok(),
- "wait() should either return Ok or panic");
- panic!("short read on the CLOEXEC pipe")
- }
- }
+ let setup = |src: Stdio, dst: c_int| {
+ let fd = match src {
+ Stdio::Inherit => return true,
+ Stdio::Piped(pipe) => pipe.into_fd(),
+
+ // If a stdio file descriptor is set to be ignored, we open up
+ // /dev/null into that file descriptor. Otherwise, the first
+ // file descriptor opened up in the child would be numbered as
+ // one of the stdio file descriptors, which is likely to wreak
+ // havoc.
+ Stdio::None => {
+ let mut opts = OpenOptions::new();
+ opts.read(dst == libc::STDIN_FILENO);
+ opts.write(dst != libc::STDIN_FILENO);
+ let devnull = CStr::from_ptr(b"/dev/null\0".as_ptr()
+ as *const _);
+ if let Ok(f) = File::open_c(devnull, &opts) {
+ f.into_fd()
+ } else {
+ return false
}
}
+ };
+ retry(|| libc::dup2(fd.raw(), dst)) != -1
+ };
- // And at this point we've reached a special time in the life of the
- // child. The child must now be considered hamstrung and unable to
- // do anything other than syscalls really. Consider the following
- // scenario:
- //
- // 1. Thread A of process 1 grabs the malloc() mutex
- // 2. Thread B of process 1 forks(), creating thread C
- // 3. Thread C of process 2 then attempts to malloc()
- // 4. The memory of process 2 is the same as the memory of
- // process 1, so the mutex is locked.
- //
- // This situation looks a lot like deadlock, right? It turns out
- // that this is what pthread_atfork() takes care of, which is
- // presumably implemented across platforms. The first thing that
- // threads to *before* forking is to do things like grab the malloc
- // mutex, and then after the fork they unlock it.
- //
- // Despite this information, libnative's spawn has been witnessed to
- // deadlock on both OSX and FreeBSD. I'm not entirely sure why, but
- // all collected backtraces point at malloc/free traffic in the
- // child spawned process.
- //
- // For this reason, the block of code below should contain 0
- // invocations of either malloc of free (or their related friends).
- //
- // As an example of not having malloc/free traffic, we don't close
- // this file descriptor by dropping the FileDesc (which contains an
- // allocation). Instead we just close it manually. This will never
- // have the drop glue anyway because this code never returns (the
- // child will either exec() or invoke libc::exit)
- let _ = libc::close(input.raw());
-
- fn fail(output: &mut AnonPipe) -> ! {
- let errno = sys::os::errno() as u32;
- let bytes = [
- (errno >> 24) as u8,
- (errno >> 16) as u8,
- (errno >> 8) as u8,
- (errno >> 0) as u8,
- CLOEXEC_MSG_FOOTER[0], CLOEXEC_MSG_FOOTER[1],
- CLOEXEC_MSG_FOOTER[2], CLOEXEC_MSG_FOOTER[3]
- ];
- // pipe I/O up to PIPE_BUF bytes should be atomic
- assert!(output.write(&bytes).is_ok());
- unsafe { libc::_exit(1) }
- }
-
- rustrt::rust_unset_sigprocmask();
-
- // If a stdio file descriptor is set to be ignored, we don't
- // actually close it, but rather open up /dev/null into that
- // file descriptor. Otherwise, the first file descriptor opened
- // up in the child would be numbered as one of the stdio file
- // descriptors, which is likely to wreak havoc.
- let setup = |src: Option<AnonPipe>, dst: c_int| {
- let src = match src {
- None => {
- let flags = if dst == libc::STDIN_FILENO {
- libc::O_RDONLY
- } else {
- libc::O_RDWR
- };
- libc::open(devnull.as_ptr() as *const _, flags, 0)
- }
- Some(obj) => {
- let fd = obj.raw();
- // Leak the memory and the file descriptor. We're in the
- // child now an all our resources are going to be
- // cleaned up very soon
- mem::forget(obj);
- fd
- }
- };
- src != -1 && retry(|| dup2(src, dst)) != -1
- };
-
- if !setup(in_fd, libc::STDIN_FILENO) { fail(&mut output) }
- if !setup(out_fd, libc::STDOUT_FILENO) { fail(&mut output) }
- if !setup(err_fd, libc::STDERR_FILENO) { fail(&mut output) }
-
- // close all other fds
- for fd in (3..getdtablesize()).rev() {
- if fd != output.raw() {
- let _ = close(fd as c_int);
- }
- }
+ if !setup(in_fd, libc::STDIN_FILENO) { fail(&mut output) }
+ if !setup(out_fd, libc::STDOUT_FILENO) { fail(&mut output) }
+ if !setup(err_fd, libc::STDERR_FILENO) { fail(&mut output) }
- match cfg.gid {
- Some(u) => {
- if libc::setgid(u as libc::gid_t) != 0 {
- fail(&mut output);
- }
- }
- None => {}
- }
- match cfg.uid {
- Some(u) => {
- // When dropping privileges from root, the `setgroups` call
- // will remove any extraneous groups. If we don't call this,
- // then even though our uid has dropped, we may still have
- // groups that enable us to do super-user things. This will
- // fail if we aren't root, so don't bother checking the
- // return value, this is just done as an optimistic
- // privilege dropping function.
- extern {
- fn setgroups(ngroups: libc::c_int,
- ptr: *const libc::c_void) -> libc::c_int;
- }
- let _ = setgroups(0, ptr::null());
-
- if libc::setuid(u as libc::uid_t) != 0 {
- fail(&mut output);
- }
- }
- None => {}
- }
- if cfg.detach {
- // Don't check the error of setsid because it fails if we're the
- // process leader already. We just forked so it shouldn't return
- // error, but ignore it anyway.
- let _ = libc::setsid();
- }
- if !dirp.is_null() && chdir(dirp) == -1 {
- fail(&mut output);
- }
- if !envp.is_null() {
- *sys::os::environ() = envp as *const _;
- }
- let _ = execvp(*argv, argv as *mut _);
+ if let Some(u) = cfg.gid {
+ if libc::setgid(u as libc::gid_t) != 0 {
fail(&mut output);
- })
- })
+ }
+ }
+ if let Some(u) = cfg.uid {
+ // When dropping privileges from root, the `setgroups` call
+ // will remove any extraneous groups. If we don't call this,
+ // then even though our uid has dropped, we may still have
+ // groups that enable us to do super-user things. This will
+ // fail if we aren't root, so don't bother checking the
+ // return value, this is just done as an optimistic
+ // privilege dropping function.
+ let _ = c::setgroups(0, ptr::null());
+
+ if libc::setuid(u as libc::uid_t) != 0 {
+ fail(&mut output);
+ }
+ }
+ if cfg.detach {
+ // Don't check the error of setsid because it fails if we're the
+ // process leader already. We just forked so it shouldn't return
+ // error, but ignore it anyway.
+ let _ = libc::setsid();
+ }
+ if !dirp.is_null() && libc::chdir(dirp) == -1 {
+ fail(&mut output);
+ }
+ if !envp.is_null() {
+ *sys::os::environ() = envp as *const _;
+ }
+ let _ = libc::execvp(*argv, argv as *mut _);
+ fail(&mut output)
}
pub fn wait(&self) -> io::Result<ExitStatus> {
}
}
-fn with_argv<T,F>(prog: &CString, args: &[CString], cb: F) -> T
- where F : FnOnce(*const *const libc::c_char) -> T
+fn make_argv(prog: &CString, args: &[CString])
+ -> (*const *const libc::c_char, Vec<*const libc::c_char>)
{
let mut ptrs: Vec<*const libc::c_char> = Vec::with_capacity(args.len()+1);
// Add a terminating null pointer (required by libc).
ptrs.push(ptr::null());
- cb(ptrs.as_ptr())
+ (ptrs.as_ptr(), ptrs)
}
-fn with_envp<T, F>(env: Option<&HashMap<OsString, OsString>>, cb: F) -> T
- where F : FnOnce(*const c_void) -> T
+fn make_envp(env: Option<&HashMap<OsString, OsString>>)
+ -> (*const c_void, Vec<Vec<u8>>, Vec<*const libc::c_char>)
{
// On posixy systems we can pass a char** for envp, which is a
// null-terminated array of "k=v\0" strings. Since we must create
// these strings locally, yet expose a raw pointer to them, we
// create a temporary vector to own the CStrings that outlives the
// call to cb.
- match env {
- Some(env) => {
- let mut tmps = Vec::with_capacity(env.len());
-
- for pair in env {
- let mut kv = Vec::new();
- kv.push_all(pair.0.as_bytes());
- kv.push('=' as u8);
- kv.push_all(pair.1.as_bytes());
- kv.push(0); // terminating null
- tmps.push(kv);
- }
+ if let Some(env) = env {
+ let mut tmps = Vec::with_capacity(env.len());
+
+ for pair in env {
+ let mut kv = Vec::new();
+ kv.push_all(pair.0.as_bytes());
+ kv.push('=' as u8);
+ kv.push_all(pair.1.as_bytes());
+ kv.push(0); // terminating null
+ tmps.push(kv);
+ }
- // As with `with_argv`, this is unsafe, since cb could leak the pointers.
- let mut ptrs: Vec<*const libc::c_char> =
- tmps.iter()
- .map(|tmp| tmp.as_ptr() as *const libc::c_char)
- .collect();
- ptrs.push(ptr::null());
+ let mut ptrs: Vec<*const libc::c_char> =
+ tmps.iter()
+ .map(|tmp| tmp.as_ptr() as *const libc::c_char)
+ .collect();
+ ptrs.push(ptr::null());
- cb(ptrs.as_ptr() as *const c_void)
- }
- _ => cb(ptr::null())
+ (ptrs.as_ptr() as *const _, tmps, ptrs)
+ } else {
+ (0 as *const _, Vec::new(), Vec::new())
}
}
fd: c_int
}
-pub unsafe fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> {
+pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> {
// Windows pipes work subtly differently than unix pipes, and their
// inheritance has to be handled in a different way that I do not
// fully understand. Here we explicitly make the pipe non-inheritable,
// which means to pass it to a subprocess they need to be duplicated
// first, as in std::run.
let mut fds = [0; 2];
- match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint,
- (libc::O_BINARY | libc::O_NOINHERIT) as c_int) {
- 0 => {
- assert!(fds[0] != -1 && fds[0] != 0);
- assert!(fds[1] != -1 && fds[1] != 0);
+ unsafe {
+ match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint,
+ (libc::O_BINARY | libc::O_NOINHERIT) as c_int) {
+ 0 => {
+ assert!(fds[0] != -1 && fds[0] != 0);
+ assert!(fds[1] != -1 && fds[1] != 0);
- Ok((AnonPipe::from_fd(fds[0]), AnonPipe::from_fd(fds[1])))
+ Ok((AnonPipe::from_fd(fds[0]), AnonPipe::from_fd(fds[1])))
+ }
+ _ => Err(io::Error::last_os_error()),
}
- _ => Err(io::Error::last_os_error()),
}
}
handle: Handle,
}
+pub enum Stdio {
+ Inherit,
+ Piped(AnonPipe),
+ None,
+}
+
impl Process {
#[allow(deprecated)]
pub fn spawn(cfg: &Command,
- in_fd: Option<AnonPipe>, out_fd: Option<AnonPipe>, err_fd: Option<AnonPipe>)
- -> io::Result<Process>
+ in_fd: Stdio,
+ out_fd: Stdio,
+ err_fd: Stdio) -> io::Result<Process>
{
use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
use libc::consts::os::extra::{
let cur_proc = GetCurrentProcess();
- // Similarly to unix, we don't actually leave holes for the stdio file
- // descriptors, but rather open up /dev/null equivalents. These
- // equivalents are drawn from libuv's windows process spawning.
- let set_fd = |fd: &Option<AnonPipe>, slot: &mut HANDLE,
+ let set_fd = |fd: &Stdio, slot: &mut HANDLE,
is_stdin: bool| {
match *fd {
- None => {
+ Stdio::Inherit => {}
+
+ // Similarly to unix, we don't actually leave holes for the
+ // stdio file descriptors, but rather open up /dev/null
+ // equivalents. These equivalents are drawn from libuv's
+ // windows process spawning.
+ Stdio::None => {
let access = if is_stdin {
libc::FILE_GENERIC_READ
} else {
return Err(Error::last_os_error())
}
}
- Some(ref pipe) => {
+ Stdio::Piped(ref pipe) => {
let orig = pipe.raw();
- if orig == INVALID_HANDLE_VALUE {
- return Err(Error::last_os_error())
- }
if DuplicateHandle(cur_proc, orig, cur_proc, slot,
0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
return Err(Error::last_os_error())
})
});
- assert!(CloseHandle(si.hStdInput) != 0);
- assert!(CloseHandle(si.hStdOutput) != 0);
- assert!(CloseHandle(si.hStdError) != 0);
+ if !in_fd.inherited() {
+ assert!(CloseHandle(si.hStdInput) != 0);
+ }
+ if !out_fd.inherited() {
+ assert!(CloseHandle(si.hStdOutput) != 0);
+ }
+ if !err_fd.inherited() {
+ assert!(CloseHandle(si.hStdError) != 0);
+ }
match create_err {
Some(err) => return Err(err),
}
}
+impl Stdio {
+ fn inherited(&self) -> bool {
+ match *self { Stdio::Inherit => true, _ => false }
+ }
+}
+
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub struct ExitStatus(i32);
(static $name:ident: $t:ty = $init:expr) => (
static $name: ::std::thread::LocalKey<$t> = {
use std::cell::UnsafeCell as __UnsafeCell;
- use std::thread::__local::__impl::KeyInner as __KeyInner;
+ use std::thread::__local::KeyInner as __KeyInner;
use std::option::Option as __Option;
use std::option::Option::None as __None;
(pub static $name:ident: $t:ty = $init:expr) => (
pub static $name: ::std::thread::LocalKey<$t> = {
use std::cell::UnsafeCell as __UnsafeCell;
- use std::thread::__local::__impl::KeyInner as __KeyInner;
+ use std::thread::__local::KeyInner as __KeyInner;
use std::option::Option as __Option;
use std::option::Option::None as __None;
#[cfg_attr(all(any(target_os = "macos", target_os = "linux"),
not(target_arch = "aarch64")),
thread_local)]
- static $name: ::std::thread::__local::__impl::KeyInner<$t> =
+ static $name: ::std::thread::__local::KeyInner<$t> =
__thread_local_inner!($init, $t);
);
(pub static $name:ident: $t:ty = $init:expr) => (
#[cfg_attr(all(any(target_os = "macos", target_os = "linux"),
not(target_arch = "aarch64")),
thread_local)]
- pub static $name: ::std::thread::__local::__impl::KeyInner<$t> =
+ pub static $name: ::std::thread::__local::KeyInner<$t> =
__thread_local_inner!($init, $t);
);
($init:expr, $t:ty) => ({
#[cfg(all(any(target_os = "macos", target_os = "linux"), not(target_arch = "aarch64")))]
- const _INIT: ::std::thread::__local::__impl::KeyInner<$t> = {
- ::std::thread::__local::__impl::KeyInner {
+ const _INIT: ::std::thread::__local::KeyInner<$t> = {
+ ::std::thread::__local::KeyInner {
inner: ::std::cell::UnsafeCell { value: $init },
dtor_registered: ::std::cell::UnsafeCell { value: false },
dtor_running: ::std::cell::UnsafeCell { value: false },
#[allow(trivial_casts)]
#[cfg(any(not(any(target_os = "macos", target_os = "linux")), target_arch = "aarch64"))]
- const _INIT: ::std::thread::__local::__impl::KeyInner<$t> = {
- ::std::thread::__local::__impl::KeyInner {
+ const _INIT: ::std::thread::__local::KeyInner<$t> = {
+ ::std::thread::__local::KeyInner {
inner: ::std::cell::UnsafeCell { value: $init },
- os: ::std::thread::__local::__impl::OsStaticKey {
- inner: ::std::thread::__local::__impl::OS_INIT_INNER,
+ os: ::std::thread::__local::OsStaticKey {
+ inner: ::std::thread::__local::OS_INIT_INNER,
dtor: ::std::option::Option::Some(
- ::std::thread::__local::__impl::destroy_value::<$t>
+ ::std::thread::__local::destroy_value::<$t>
),
},
}
//! `println!` and `panic!` for the child thread:
//!
//! ```rust
+//! # #![allow(unused_must_use)]
//! use std::thread;
//!
//! thread::Builder::new().name("child1".to_string()).spawn(move || {
#![stable(feature = "rust1", since = "1.0.0")]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::__local::{LocalKey, LocalKeyState};
-
-#[unstable(feature = "scoped_tls",
- reason = "scoped TLS has yet to have wide enough use to fully consider \
- stabilizing its interface")]
-pub use self::__scoped::ScopedKey;
-
use prelude::v1::*;
use any::Any;
// Thread-local storage
////////////////////////////////////////////////////////////////////////////////
-#[macro_use]
-#[doc(hidden)]
-#[path = "local.rs"] pub mod __local;
+#[macro_use] mod local;
+#[macro_use] mod scoped;
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::local::{LocalKey, LocalKeyState};
+
+#[unstable(feature = "scoped_tls",
+ reason = "scoped TLS has yet to have wide enough use to fully \
+ consider stabilizing its interface")]
+pub use self::scoped::ScopedKey;
-#[macro_use]
-#[doc(hidden)]
-#[path = "scoped.rs"] pub mod __scoped;
+#[doc(hidden)] pub use self::local::__impl as __local;
+#[doc(hidden)] pub use self::scoped::__impl as __scoped;
////////////////////////////////////////////////////////////////////////////////
// Builder
target_os = "openbsd",
target_arch = "aarch64")))]
const _INIT: __Key<$t> = __Key {
- inner: ::std::thread::__scoped::__impl::KeyInner {
+ inner: ::std::thread::__scoped::KeyInner {
inner: ::std::cell::UnsafeCell { value: 0 as *mut _ },
}
};
target_os = "openbsd",
target_arch = "aarch64"))]
const _INIT: __Key<$t> = __Key {
- inner: ::std::thread::__scoped::__impl::KeyInner {
- inner: ::std::thread::__scoped::__impl::OS_INIT,
+ inner: ::std::thread::__scoped::KeyInner {
+ inner: ::std::thread::__scoped::OS_INIT,
marker: ::std::marker::PhantomData::<::std::cell::Cell<$t>>,
}
};
}
// Use a macro because forwarding to a simple function has type system issues
-macro_rules! make_stmt_default {
+macro_rules! make_stmts_default {
($me:expr) => {
$me.make_expr().map(|e| {
- P(codemap::respan(e.span, ast::StmtExpr(e, ast::DUMMY_NODE_ID)))
+ SmallVector::one(P(codemap::respan(
+ e.span, ast::StmtExpr(e, ast::DUMMY_NODE_ID))))
})
}
}
None
}
- /// Create a statement.
+ /// Create zero or more statements.
///
/// By default this attempts to create an expression statement,
/// returning None if that fails.
- fn make_stmt(self: Box<Self>) -> Option<P<ast::Stmt>> {
- make_stmt_default!(self)
+ fn make_stmts(self: Box<Self>) -> Option<SmallVector<P<ast::Stmt>>> {
+ make_stmts_default!(self)
}
}
pat: P<ast::Pat>,
items: SmallVector<P<ast::Item>>,
impl_items: SmallVector<P<ast::ImplItem>>,
- stmt: P<ast::Stmt>,
+ stmts: SmallVector<P<ast::Stmt>>,
}
impl MacResult for MacEager {
self.impl_items
}
- fn make_stmt(self: Box<Self>) -> Option<P<ast::Stmt>> {
- match self.stmt {
- None => make_stmt_default!(self),
- s => s,
+ fn make_stmts(self: Box<Self>) -> Option<SmallVector<P<ast::Stmt>>> {
+ match self.stmts.as_ref().map_or(0, |s| s.len()) {
+ 0 => make_stmts_default!(self),
+ _ => self.stmts,
}
}
Some(SmallVector::zero())
}
}
- fn make_stmt(self: Box<DummyResult>) -> Option<P<ast::Stmt>> {
- Some(P(codemap::respan(self.span,
- ast::StmtExpr(DummyResult::raw_expr(self.span),
- ast::DUMMY_NODE_ID))))
+ fn make_stmts(self: Box<DummyResult>) -> Option<SmallVector<P<ast::Stmt>>> {
+ Some(SmallVector::one(P(
+ codemap::respan(self.span,
+ ast::StmtExpr(DummyResult::raw_expr(self.span),
+ ast::DUMMY_NODE_ID)))))
}
}
use ext::build::AstBuilder;
use codemap::{self, DUMMY_SP};
use codemap::Span;
+use diagnostic::SpanHandler;
use fold::MoveMap;
use owned_slice::OwnedSlice;
use parse::token::InternedString;
ast::ItemEnum(ref enum_def, ref generics) => {
self.expand_enum_def(cx,
enum_def,
+ &item.attrs[..],
item.ident,
generics)
}
fn expand_enum_def(&self,
cx: &mut ExtCtxt,
enum_def: &EnumDef,
+ type_attrs: &[ast::Attribute],
type_ident: Ident,
generics: &Generics) -> P<ast::Item> {
let mut field_tys = Vec::new();
method_def.expand_enum_method_body(cx,
self,
enum_def,
+ type_attrs,
type_ident,
self_args,
&nonself_args[..])
}
}
-fn variant_to_pat(cx: &mut ExtCtxt, sp: Span, enum_ident: ast::Ident, variant: &ast::Variant)
- -> P<ast::Pat> {
- let path = cx.path(sp, vec![enum_ident, variant.node.name]);
- cx.pat(sp, match variant.node.kind {
- ast::TupleVariantKind(..) => ast::PatEnum(path, None),
- ast::StructVariantKind(..) => ast::PatStruct(path, Vec::new(), true),
- })
+fn find_repr_type_name(diagnostic: &SpanHandler,
+ type_attrs: &[ast::Attribute]) -> &'static str {
+ let mut repr_type_name = "i32";
+ for a in type_attrs {
+ for r in &attr::find_repr_attrs(diagnostic, a) {
+ repr_type_name = match *r {
+ attr::ReprAny | attr::ReprPacked => continue,
+ attr::ReprExtern => "i32",
+
+ attr::ReprInt(_, attr::SignedInt(ast::TyIs)) => "isize",
+ attr::ReprInt(_, attr::SignedInt(ast::TyI8)) => "i8",
+ attr::ReprInt(_, attr::SignedInt(ast::TyI16)) => "i16",
+ attr::ReprInt(_, attr::SignedInt(ast::TyI32)) => "i32",
+ attr::ReprInt(_, attr::SignedInt(ast::TyI64)) => "i64",
+
+ attr::ReprInt(_, attr::UnsignedInt(ast::TyUs)) => "usize",
+ attr::ReprInt(_, attr::UnsignedInt(ast::TyU8)) => "u8",
+ attr::ReprInt(_, attr::UnsignedInt(ast::TyU16)) => "u16",
+ attr::ReprInt(_, attr::UnsignedInt(ast::TyU32)) => "u32",
+ attr::ReprInt(_, attr::UnsignedInt(ast::TyU64)) => "u64",
+ }
+ }
+ }
+ repr_type_name
}
impl<'a> MethodDef<'a> {
cx: &mut ExtCtxt,
trait_: &TraitDef,
enum_def: &EnumDef,
+ type_attrs: &[ast::Attribute],
type_ident: Ident,
self_args: Vec<P<Expr>>,
nonself_args: &[P<Expr>])
-> P<Expr> {
self.build_enum_match_tuple(
- cx, trait_, enum_def, type_ident, self_args, nonself_args)
+ cx, trait_, enum_def, type_attrs, type_ident, self_args, nonself_args)
}
cx: &mut ExtCtxt,
trait_: &TraitDef,
enum_def: &EnumDef,
+ type_attrs: &[ast::Attribute],
type_ident: Ident,
self_args: Vec<P<Expr>>,
nonself_args: &[P<Expr>]) -> P<Expr> {
.collect::<Vec<ast::Ident>>();
// The `vi_idents` will be bound, solely in the catch-all, to
- // a series of let statements mapping each self_arg to a usize
- // corresponding to its variant index.
+ // a series of let statements mapping each self_arg to an int
+ // value corresponding to its discriminant.
let vi_idents: Vec<ast::Ident> = self_arg_names.iter()
.map(|name| { let vi_suffix = format!("{}_vi", &name[..]);
cx.ident_of(&vi_suffix[..]) })
// unreachable-pattern error.
//
if variants.len() > 1 && self_args.len() > 1 {
- let arms: Vec<ast::Arm> = variants.iter().enumerate()
- .map(|(index, variant)| {
- let pat = variant_to_pat(cx, sp, type_ident, &**variant);
- let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyUs));
- cx.arm(sp, vec![pat], cx.expr_lit(sp, lit))
- }).collect();
-
// Build a series of let statements mapping each self_arg
- // to a usize corresponding to its variant index.
+ // to its discriminant value. If this is a C-style enum
+ // with a specific repr type, then casts the values to
+ // that type. Otherwise casts to `i32` (the default repr
+ // type).
+ //
// i.e. for `enum E<T> { A, B(1), C(T, T) }`, and a deriving
// with three Self args, builds three statements:
//
// ```
- // let __self0_vi = match self {
- // A => 0, B(..) => 1, C(..) => 2
- // };
- // let __self1_vi = match __arg1 {
- // A => 0, B(..) => 1, C(..) => 2
- // };
- // let __self2_vi = match __arg2 {
- // A => 0, B(..) => 1, C(..) => 2
- // };
+ // let __self0_vi = unsafe {
+ // std::intrinsics::discriminant_value(&self) } as i32;
+ // let __self1_vi = unsafe {
+ // std::intrinsics::discriminant_value(&__arg1) } as i32;
+ // let __self2_vi = unsafe {
+ // std::intrinsics::discriminant_value(&__arg2) } as i32;
// ```
let mut index_let_stmts: Vec<P<ast::Stmt>> = Vec::new();
+
+ let target_type_name =
+ find_repr_type_name(&cx.parse_sess.span_diagnostic, type_attrs);
+
for (&ident, self_arg) in vi_idents.iter().zip(self_args.iter()) {
- let variant_idx = cx.expr_match(sp, self_arg.clone(), arms.clone());
- let let_stmt = cx.stmt_let(sp, false, ident, variant_idx);
+ let path = vec![cx.ident_of_std("core"),
+ cx.ident_of("intrinsics"),
+ cx.ident_of("discriminant_value")];
+ let call = cx.expr_call_global(
+ sp, path, vec![cx.expr_addr_of(sp, self_arg.clone())]);
+ let variant_value = cx.expr_block(P(ast::Block {
+ stmts: vec![],
+ expr: Some(call),
+ id: ast::DUMMY_NODE_ID,
+ rules: ast::UnsafeBlock(ast::CompilerGenerated),
+ span: sp }));
+
+ let target_ty = cx.ty_ident(sp, cx.ident_of(target_type_name));
+ let variant_disr = cx.expr_cast(sp, variant_value, target_ty);
+ let let_stmt = cx.stmt_let(sp, false, ident, variant_disr);
index_let_stmts.push(let_stmt);
}
}
/// Expand a stmt
-fn expand_stmt(s: Stmt, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
- let (mac, style) = match s.node {
+fn expand_stmt(stmt: P<Stmt>, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
+ let stmt = stmt.and_then(|stmt| stmt);
+ let (mac, style) = match stmt.node {
StmtMac(mac, style) => (mac, style),
- _ => return expand_non_macro_stmt(s, fld)
+ _ => return expand_non_macro_stmt(stmt, fld)
};
- let expanded_stmt = match expand_mac_invoc(mac.and_then(|m| m), s.span,
- |r| r.make_stmt(),
- mark_stmt, fld) {
- Some(stmt) => stmt,
- None => {
- return SmallVector::zero();
+
+ let maybe_new_items =
+ expand_mac_invoc(mac.and_then(|m| m), stmt.span,
+ |r| r.make_stmts(),
+ |stmts, mark| stmts.move_map(|m| mark_stmt(m, mark)),
+ fld);
+
+ let mut fully_expanded = match maybe_new_items {
+ Some(stmts) => {
+ // Keep going, outside-in.
+ let new_items = stmts.into_iter().flat_map(|s| {
+ fld.fold_stmt(s).into_iter()
+ }).collect();
+ fld.cx.bt_pop();
+ new_items
}
+ None => SmallVector::zero()
};
- // Keep going, outside-in.
- let fully_expanded = fld.fold_stmt(expanded_stmt);
- fld.cx.bt_pop();
-
+ // If this is a macro invocation with a semicolon, then apply that
+ // semicolon to the final statement produced by expansion.
if style == MacStmtWithSemicolon {
- fully_expanded.into_iter().map(|s| s.map(|Spanned {node, span}| {
- Spanned {
- node: match node {
- StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
- _ => node /* might already have a semi */
- },
- span: span
- }
- })).collect()
- } else {
- fully_expanded
+ if let Some(stmt) = fully_expanded.pop() {
+ let new_stmt = stmt.map(|Spanned {node, span}| {
+ Spanned {
+ node: match node {
+ StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
+ _ => node /* might already have a semi */
+ },
+ span: span
+ }
+ });
+ fully_expanded.push(new_stmt);
+ }
}
+
+ fully_expanded
}
// expand a non-macro stmt. this is essentially the fallthrough for
}
fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {
- stmt.and_then(|stmt| expand_stmt(stmt, self))
+ expand_stmt(stmt, self)
}
fn fold_block(&mut self, block: P<Block>) -> P<Block> {
}
// apply a given mark to the given stmt. Used following the expansion of a macro.
-fn mark_stmt(expr: P<ast::Stmt>, m: Mrk) -> P<ast::Stmt> {
- Marker{mark:m}.fold_stmt(expr)
+fn mark_stmt(stmt: P<ast::Stmt>, m: Mrk) -> P<ast::Stmt> {
+ Marker{mark:m}.fold_stmt(stmt)
.expect_one("marking a stmt didn't return exactly one stmt")
}
Some(ret)
}
- fn make_stmt(self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Stmt>> {
- let ret = self.parser.borrow_mut().parse_stmt();
- self.ensure_complete_parse(true);
- ret
+ fn make_stmts(self: Box<ParserAnyMacro<'a>>)
+ -> Option<SmallVector<P<ast::Stmt>>> {
+ let mut ret = SmallVector::zero();
+ loop {
+ let mut parser = self.parser.borrow_mut();
+ match parser.token {
+ token::Eof => break,
+ _ => match parser.parse_stmt_nopanic() {
+ Ok(maybe_stmt) => match maybe_stmt {
+ Some(stmt) => ret.push(stmt),
+ None => (),
+ },
+ Err(_) => break,
+ }
+ }
+ }
+ self.ensure_complete_parse(false);
+ Some(ret)
}
}
}
}
+ pub fn pop(&mut self) -> Option<T> {
+ match self.repr {
+ Zero => None,
+ One(..) => {
+ let one = mem::replace(&mut self.repr, Zero);
+ match one {
+ One(v1) => Some(v1),
+ _ => unreachable!()
+ }
+ }
+ Many(ref mut vs) => vs.pop(),
+ }
+ }
+
pub fn push(&mut self, v: T) {
match self.repr {
Zero => self.repr = One(v),
} else {
src = PathBuf::from(&env::args().nth(2).unwrap());
}
- // preprocess the markdown, rerouting markdown references to html references
+ // preprocess the markdown, rerouting markdown references to html
+ // references
let mut markdown_data = String::new();
try!(File::open(&src.join(&item.path)).and_then(|mut f| {
f.read_to_string(&mut markdown_data)
format!("-o{}", out_path.display()),
format!("--html-before-content={}", prelude.display()),
format!("--html-after-content={}", postlude.display()),
+ format!("--markdown-playground-url=http://play.rust-lang.org"),
format!("--markdown-css={}", item.path_to_root.join("rust-book.css").display()),
"--markdown-no-toc".to_string(),
];
// create index.html from the root README
try!(fs::copy(&tgt.join("README.html"), &tgt.join("index.html")));
+
+ // Copy some js for playpen
+ let mut jquery = try!(File::create(tgt.join("jquery.js")));
+ let js = include_bytes!("../librustdoc/html/static/jquery-2.1.0.min.js");
+ try!(jquery.write_all(js));
+ let mut playpen = try!(File::create(tgt.join("playpen.js")));
+ let js = include_bytes!("../librustdoc/html/static/playpen.js");
+ try!(playpen.write_all(js));
Ok(())
}
});
</script>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="playpen.js"></script>
"#;
--- /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.
+
+pub trait Foo {
+ fn bar(&self);
+ fn foo(&mut self) {}
+}
--- /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.
+
+pub trait Foo {
+ #[doc(hidden)]
+ fn foo(&self) {}
+}
+
+impl Foo for i32 {}
--- /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.
+
+#![doc(html_root_url = "http://example.com/")]
+
+/// dox
+#[doc(primitive = "pointer")]
+pub mod ptr {}
--- /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.
+
+
+#![doc(html_root_url = "http://example.com")]
+
+pub trait Foo {
+ fn foo(&self) {}
+}
--- /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.
+
+pub trait Trait {
+ type Output;
+}
+
+pub fn fun<T>(_: T) where T: Trait<Output=i32> {}
--- /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.
+
+pub trait Deref {
+ type Target: ?Sized;
+
+ fn deref<'a>(&'a self) -> &'a Self::Target;
+}
+
+pub trait Add<RHS = Self> {
+ type Output;
+
+ fn add(self, rhs: RHS) -> Self::Output;
+}
+
+
+pub trait Bar {}
+pub trait Deref2 {
+ type Target: Bar;
+
+ fn deref(&self) -> Self::Target;
+}
+
+pub trait Index<Idx: ?Sized> {
+ type Output: ?Sized;
+ fn index(&self, index: Idx) -> &Self::Output;
+}
+
+pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
+ fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
+}
--- /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.
+
+pub trait Foo {
+ type Bar;
+ fn foo(&self) {}
+}
+
+pub struct Bar;
+
+impl Foo for Bar {
+ type Bar = i32;
+}
--- /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.
+
+pub struct Foo;
+
+impl Foo {
+ pub fn new<F>(f: F) -> Foo where F: FnMut() -> i32 {
+ loop {}
+ }
+}
--- /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.
+
+pub mod foo {
+
+ pub trait Foo {}
+ pub struct Bar;
+
+ impl Foo for Bar {}
+
+}
--- /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.
+
+pub mod fmt {
+ pub struct Error;
+}
--- /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 issue_23207_1;
+
+pub mod fmt {
+ pub use issue_23207_1::fmt::Error;
+}
+
--- /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.
+
+#![feature(optin_builtin_traits)]
+#![feature(core)]
+
+pub mod bar {
+ use std::marker;
+
+ pub trait Bar: marker::MarkerTrait + 'static {}
+
+ impl Bar for .. {}
+
+ pub trait Foo {
+ fn foo(&self) {}
+ }
+
+ impl Foo {
+ pub fn test<T: Bar>(&self) {}
+ }
+
+ pub struct TypeId;
+
+ impl TypeId {
+ pub fn of<T: Bar + ?Sized>() -> TypeId {
+ panic!()
+ }
+ }
+}
--- /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.
+
+#![crate_type="lib"]
+
+pub trait Trait {
+ fn provided(&self) {}
+}
+
+pub struct Struct;
+
+impl Trait for Struct {
+ fn provided(&self) {}
+}
--- /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.
+
+#![crate_type="lib"]
+#![feature(unboxed_closures)]
+
+pub trait Foo {
+ extern "rust-call" fn foo(&self, _: ()) -> i32;
+ extern "rust-call" fn foo_(&self, _: ()) -> i32 { 0 }
+}
--- /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.
+
+#![crate_type="lib"]
+
+extern "C" {
+ // @has lib/fn.foreigner.html //pre 'pub unsafe fn foreigner(cold_as_ice: u32)'
+ pub fn foreigner(cold_as_ice: u32);
+}
}
macro_rules! ignored_expr {
- () => ( 1, 2 ) //~ ERROR macro expansion ignores token `,`
+ () => ( 1, //~ ERROR unexpected token: `,`
+ 2 ) //~ ERROR macro expansion ignores token `2`
}
macro_rules! ignored_pat {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![crate_name="foo"]
-
/// ```rust
/// assert_eq!(foo::foo(), 1);
/// ```
+++ /dev/null
--include ../tools.mk
-
-all: lib.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc lib.rs
- $(HTMLDOCCK) $(TMPDIR)/doc lib.rs
+++ /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.
-
-#![crate_type="lib"]
-
-// @has lib/trait.Index.html
-pub trait Index<I: ?Sized> {
- // @has - '//*[@id="associatedtype.Output"]//code' 'type Output: ?Sized'
- type Output: ?Sized;
- // @has - '//*[@id="tymethod.index"]//code' \
- // "fn index<'a>(&'a self, index: I) -> &'a Self::Output"
- fn index<'a>(&'a self, index: I) -> &'a Self::Output;
-}
+++ /dev/null
--include ../tools.mk
-
-all: foo.rs bar.rs
- $(RUSTC) foo.rs --crate-type lib
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc bar.rs -L $(TMPDIR)
+++ /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 foo;
-
-pub use foo::bar;
-
-pub fn wut<T: bar::Bar>() {
-}
+++ /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.
-
-#![feature(optin_builtin_traits)]
-#![feature(core)]
-
-pub mod bar {
- use std::marker;
-
- pub trait Bar: marker::MarkerTrait + 'static {}
-
- impl Bar for .. {}
-
- pub trait Foo {
- fn foo(&self) {}
- }
-
- impl Foo {
- pub fn test<T: Bar>(&self) {}
- }
-
- pub struct TypeId;
-
- impl TypeId {
- pub fn of<T: Bar + ?Sized>() -> TypeId {
- panic!()
- }
- }
-}
+++ /dev/null
--include ../tools.mk
-
-all: lib.rs ext.rs
- $(HOST_RPATH_ENV) $(RUSTC) ext.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -L $(TMPDIR) -w html -o $(TMPDIR)/doc lib.rs
- $(HTMLDOCCK) $(TMPDIR)/doc lib.rs
+++ /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.
-
-#![crate_type="lib"]
-
-pub trait Trait {
- fn provided(&self) {}
-}
-
-pub struct Struct;
-
-impl Trait for Struct {
- fn provided(&self) {}
-}
+++ /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 ext;
-
-// @count lib/struct.Struct.html '//*[@id="method.provided"]' 1
-pub use ext::Struct;
+++ /dev/null
--include ../tools.mk
-
-all: foo.rs bar.rs
- $(HOST_RPATH_ENV) $(RUSTC) foo.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -L $(TMPDIR) -w html -o $(TMPDIR)/doc bar.rs
- $(HTMLDOCCK) $(TMPDIR)/doc bar.rs
+++ /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.
-
-#![feature(unboxed_closures)]
-
-extern crate foo;
-
-// @has bar/trait.Foo.html //pre "pub trait Foo"
-// @has - '//*[@id="tymethod.foo"]//code' 'extern "rust-call" fn foo'
-// @has - '//*[@id="tymethod.foo_"]//code' 'extern "rust-call" fn foo_'
-pub use foo::Foo;
-
-// @has bar/trait.Bar.html //pre "pub trait Bar"
-pub trait Bar {
- // @has - '//*[@id="tymethod.bar"]//code' 'extern "rust-call" fn bar'
- extern "rust-call" fn bar(&self, _: ());
- // @has - '//*[@id="method.bar_"]//code' 'extern "rust-call" fn bar_'
- extern "rust-call" fn bar_(&self, _: ()) { }
-}
+++ /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.
-
-#![crate_type="lib"]
-#![feature(unboxed_closures)]
-
-pub trait Foo {
- extern "rust-call" fn foo(&self, _: ()) -> i32;
- extern "rust-call" fn foo_(&self, _: ()) -> i32 { 0 }
-}
+++ /dev/null
--include ../tools.mk
-
-all: lib.rs
- $(HOST_RPATH_ENV) $(RUSTC) lib.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc lib.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -L $(TMPDIR) -w html -o $(TMPDIR)/doc user.rs
- $(HTMLDOCCK) $(TMPDIR)/doc lib.rs
- $(HTMLDOCCK) $(TMPDIR)/doc user.rs
+++ /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.
-
-#![crate_type="lib"]
-
-extern "C" {
- // @has lib/fn.foreigner.html //pre 'pub unsafe fn foreigner(cold_as_ice: u32)'
- pub fn foreigner(cold_as_ice: u32);
-}
+++ /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.
-
-#![crate_type="lib"]
-
-extern crate lib;
-
-// @has user/fn.foreigner.html //pre 'pub unsafe fn foreigner(cold_as_ice: u32)'
-pub use lib::foreigner;
+++ /dev/null
--include ../tools.mk
-
-# FIXME ignore windows
-ifndef IS_WINDOWS
-
-all:
- @echo $(RUSTDOC)
- $(HOST_RPATH_ENV) $(RUSTDOC) --test foo.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HTMLDOCCK) $(TMPDIR)/doc foo.rs
-
-else
-all:
-
-endif
+++ /dev/null
-// Copyright 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.
-
-#![crate_name="foo"]
-
-/// The '# ' lines should be removed from the output, but the #[derive] should be
-/// retained.
-///
-/// ```rust
-/// mod to_make_deriving_work { // FIXME #4913
-///
-/// # #[derive(PartialEq)] // invisible
-/// # struct Foo; // invisible
-///
-/// #[derive(PartialEq)] // Bar
-/// struct Bar(Foo);
-///
-/// fn test() {
-/// let x = Bar(Foo);
-/// assert!(x == x); // check that the derivings worked
-/// }
-///
-/// }
-/// ```
-pub fn foo() {}
-
-// @!has foo/fn.foo.html invisible
-// @matches - //pre "#\[derive\(PartialEq\)\] // Bar"
+++ /dev/null
--include ../tools.mk
-
-all: lib.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc lib.rs
- $(HTMLDOCCK) $(TMPDIR)/doc lib.rs
+++ /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.
-
-#![crate_type="lib"]
-
-// @has lib/struct.Struct.html //pre '#[must_use]'
-#[must_use]
-pub struct Struct {
- field: i32,
-}
-
-// @has lib/enum.Enum.html //pre '#[must_use = "message"]'
-#[must_use = "message"]
-pub enum Enum {
- Variant(i32),
-}
+++ /dev/null
--include ../tools.mk
-
-all: foo.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HTMLDOCCK) $(TMPDIR)/doc foo.rs
+++ /dev/null
-// Copyright 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(optin_builtin_traits)]
-
-// @matches foo/struct.Alpha.html '//pre' "pub struct Alpha"
-pub struct Alpha;
-// @matches foo/struct.Bravo.html '//pre' "pub struct Bravo<B>"
-pub struct Bravo<B>(B);
-
-// @matches foo/struct.Alpha.html '//*[@class="impl"]//code' "impl !Send for Alpha"
-impl !Send for Alpha {}
-
-// @matches foo/struct.Bravo.html '//*[@class="impl"]//code' "impl<B> !Send for Bravo<B>"
-impl<B> !Send for Bravo<B> {}
+++ /dev/null
--include ../tools.mk
-
-# FIXME ignore windows
-ifndef IS_WINDOWS
-all:
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo2.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo3.rs
-else
-all:
-endif
+++ /dev/null
-// Copyright 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.
-
-#![crate_type = "lib"]
-#![feature(globs)]
-
-mod m {
- pub use self::a::Foo;
-
- mod a {
- pub struct Foo;
- }
-
- mod b {
- pub use super::*;
- }
-}
+++ /dev/null
-// Copyright 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.
-
-#![crate_type = "lib"]
-#![feature(globs)]
-
-mod m {
- pub use self::a::Foo;
-
- mod a {
- pub struct Foo;
- }
-
- mod b {
- pub use super::*;
- }
-}
+++ /dev/null
-// Copyright 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(globs)]
-
-pub mod longhands {
- pub use super::*;
-
- pub use super::common_types::computed::compute_CSSColor as to_computed_value;
-
- pub fn computed_as_specified() {}
-}
-
-pub mod common_types {
- pub mod computed {
- pub use super::super::longhands::computed_as_specified as compute_CSSColor;
- }
-}
+++ /dev/null
--include ../tools.mk
-
-# FIXME ignore windows
-ifndef IS_WINDOWS
-
-source=index.rs
-
-all:
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc $(source)
- $(HTMLDOCCK) $(TMPDIR)/doc $(source)
-
-else
-all:
-
-endif
+++ /dev/null
-// Copyright 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.
-
-#![crate_name = "rustdoc_test"]
-
-// @has search-index.js Foo
-pub use private::Foo;
-
-mod private {
- pub struct Foo;
- impl Foo {
- pub fn test_method() {} // @has - test_method
- fn priv_method() {} // @!has - priv_method
- }
-
- pub trait PrivateTrait {
- fn trait_method(&self) {} // @!has - priv_method
- }
-}
+++ /dev/null
--include ../tools.mk
-all:
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HTMLDOCCK) $(TMPDIR)/doc foo.rs
+++ /dev/null
-// Copyright 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.
-
-// @has foo/index.html
-#![crate_name = "foo"]
-
-//! Very docs
-
-// @has foo/bar/index.html
-pub mod bar {
-
- /// So correct
- // @has foo/bar/baz/index.html
- pub mod baz {
- /// Much detail
- // @has foo/bar/baz/fn.baz.html
- pub fn baz() { }
- }
-
- /// *wow*
- // @has foo/bar/trait.Doge.html
- pub trait Doge { fn dummy(&self) { } }
-
- // @has foo/bar/struct.Foo.html
- pub struct Foo { x: isize, y: usize }
-
- // @has foo/bar/fn.prawns.html
- pub fn prawns((a, b): (isize, usize), Foo { x, y }: Foo) { }
-}
+++ /dev/null
--include ../tools.mk
-all:
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HTMLDOCCK) $(TMPDIR)/doc foo.rs
- $(HTMLDOCCK) $(TMPDIR)/doc qux/mod.rs
+++ /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.
-
-#![crate_name = "foo"]
-
-//! Dox
-// @has src/foo/foo.rs.html
-// @has foo/index.html '//a/@href' '../src/foo/foo.rs.html'
-
-pub mod qux;
-
-// @has foo/bar/index.html '//a/@href' '../../src/foo/foo.rs.html'
-pub mod bar {
-
- /// Dox
- // @has foo/bar/baz/index.html '//a/@href' '../../../src/foo/foo.rs.html'
- pub mod baz {
- /// Dox
- // @has foo/bar/baz/fn.baz.html '//a/@href' '../../../src/foo/foo.rs.html'
- pub fn baz() { }
- }
-
- /// Dox
- // @has foo/bar/trait.Foobar.html '//a/@href' '../../src/foo/foo.rs.html'
- pub trait Foobar { fn dummy(&self) { } }
-
- // @has foo/bar/struct.Foo.html '//a/@href' '../../src/foo/foo.rs.html'
- pub struct Foo { x: i32, y: u32 }
-
- // @has foo/bar/fn.prawns.html '//a/@href' '../../src/foo/foo.rs.html'
- pub fn prawns((a, b): (i32, u32), Foo { x, y }: Foo) { }
-}
-
-/// Dox
-// @has foo/fn.modfn.html '//a/@href' '../src/foo/foo.rs.html'
-pub fn modfn() { }
+++ /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.
-
-//! Dox
-// @has src/foo/qux/mod.rs.html
-// @has foo/qux/index.html '//a/@href' '../../src/foo/qux/mod.rs.html'
-
-// @has foo/qux/bar/index.html '//a/@href' '../../../src/foo/qux/mod.rs.html'
-pub mod bar {
-
- /// Dox
- // @has foo/qux/bar/baz/index.html '//a/@href' '../../../../src/foo/qux/mod.rs.html'
- pub mod baz {
- /// Dox
- // @has foo/qux/bar/baz/fn.baz.html '//a/@href' '../../../../src/foo/qux/mod.rs.html'
- pub fn baz() { }
- }
-
- /// Dox
- // @has foo/qux/bar/trait.Foobar.html '//a/@href' '../../../src/foo/qux/mod.rs.html'
- pub trait Foobar { fn dummy(&self) { } }
-
- // @has foo/qux/bar/struct.Foo.html '//a/@href' '../../../src/foo/qux/mod.rs.html'
- pub struct Foo { x: i32, y: u32 }
-
- // @has foo/qux/bar/fn.prawns.html '//a/@href' '../../../src/foo/qux/mod.rs.html'
- pub fn prawns((a, b): (i32, u32), Foo { x, y }: Foo) { }
-}
-
-/// Dox
-// @has foo/qux/fn.modfn.html '//a/@href' '../../src/foo/qux/mod.rs.html'
-pub fn modfn() { }
+++ /dev/null
--include ../tools.mk
-
-all: foo.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HTMLDOCCK) $(TMPDIR)/doc foo.rs
+++ /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.
-
-pub mod io {
- pub trait Reader { fn dummy(&self) { } }
-}
-
-pub enum Maybe<A> {
- Just(A),
- Nothing
-}
-
-// @has foo/prelude/index.html
-pub mod prelude {
- // @has foo/prelude/index.html '//code' 'pub use io::{self, Reader}'
- #[doc(no_inline)] pub use io::{self, Reader};
- // @has foo/prelude/index.html '//code' 'pub use Maybe::{self, Just, Nothing}'
- #[doc(no_inline)] pub use Maybe::{self, Just, Nothing};
-}
+++ /dev/null
--include ../tools.mk
-
-all: foo.rs
- $(HOST_RPATH_ENV) $(RUSTDOC) -w html -o $(TMPDIR)/doc foo.rs
- $(HTMLDOCCK) $(TMPDIR)/doc foo.rs
+++ /dev/null
-// Copyright 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.
-
-pub trait MyTrait { fn dummy(&self) { } }
-
-// @has foo/struct.Alpha.html '//pre' "pub struct Alpha<A> where A: MyTrait"
-pub struct Alpha<A>(A) where A: MyTrait;
-// @has foo/trait.Bravo.html '//pre' "pub trait Bravo<B> where B: MyTrait"
-pub trait Bravo<B> where B: MyTrait { fn get(&self, B: B); }
-// @has foo/fn.charlie.html '//pre' "pub fn charlie<C>() where C: MyTrait"
-pub fn charlie<C>() where C: MyTrait {}
-
-pub struct Delta<D>(D);
-
-// @has foo/struct.Delta.html '//*[@class="impl"]//code' \
-// "impl<D> Delta<D> where D: MyTrait"
-impl<D> Delta<D> where D: MyTrait {
- pub fn delta() {}
-}
-
-pub struct Echo<E>(E);
-
-// @has foo/struct.Echo.html '//*[@class="impl"]//code' \
-// "impl<E> MyTrait for Echo<E> where E: MyTrait"
-// @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
-// "impl<E> MyTrait for Echo<E> where E: MyTrait"
-impl<E> MyTrait for Echo<E> where E: MyTrait {}
-
-pub enum Foxtrot<F> { Foxtrot1(F) }
-
-// @has foo/enum.Foxtrot.html '//*[@class="impl"]//code' \
-// "impl<F> MyTrait for Foxtrot<F> where F: MyTrait"
-// @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
-// "impl<F> MyTrait for Foxtrot<F> where F: MyTrait"
-impl<F> MyTrait for Foxtrot<F> where F: MyTrait {}
--- /dev/null
+// Copyright 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(core)]
+
+extern crate core;
+use core::intrinsics::discriminant_value;
+
+enum CLike1 {
+ A,
+ B,
+ C,
+ D
+}
+
+enum CLike2 {
+ A = 5,
+ B = 2,
+ C = 19,
+ D
+}
+
+#[repr(i8)]
+enum CLike3 {
+ A = 5,
+ B,
+ C = -1,
+ D
+}
+
+enum ADT {
+ First(u32, u32),
+ Second(u64)
+}
+
+enum NullablePointer {
+ Something(&'static u32),
+ Nothing
+}
+
+static CONST : u32 = 0xBEEF;
+
+pub fn main() {
+ unsafe {
+
+ assert_eq!(discriminant_value(&CLike1::A), 0);
+ assert_eq!(discriminant_value(&CLike1::B), 1);
+ assert_eq!(discriminant_value(&CLike1::C), 2);
+ assert_eq!(discriminant_value(&CLike1::D), 3);
+
+ assert_eq!(discriminant_value(&CLike2::A), 5);
+ assert_eq!(discriminant_value(&CLike2::B), 2);
+ assert_eq!(discriminant_value(&CLike2::C), 19);
+ assert_eq!(discriminant_value(&CLike2::D), 20);
+
+ assert_eq!(discriminant_value(&CLike3::A), 5);
+ assert_eq!(discriminant_value(&CLike3::B), 6);
+ assert_eq!(discriminant_value(&CLike3::C), -1_i8 as u64);
+ assert_eq!(discriminant_value(&CLike3::D), 0);
+
+ assert_eq!(discriminant_value(&ADT::First(0,0)), 0);
+ assert_eq!(discriminant_value(&ADT::Second(5)), 1);
+
+ assert_eq!(discriminant_value(&NullablePointer::Nothing), 1);
+ assert_eq!(discriminant_value(&NullablePointer::Something(&CONST)), 0);
+
+ assert_eq!(discriminant_value(&10), 0);
+ assert_eq!(discriminant_value(&"test"), 0);
+ }
+}
--- /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.
+
+// ignore-windows
+// ignore-android
+
+#![feature(libc)]
+
+extern crate libc;
+
+use std::env;
+use std::fs::{self, File};
+use std::io;
+use std::net::{TcpListener, TcpStream, UdpSocket};
+use std::os::unix::prelude::*;
+use std::process::Command;
+use std::thread;
+
+fn main() {
+ let args = env::args().collect::<Vec<_>>();
+ if args.len() == 1 {
+ parent()
+ } else {
+ child(&args)
+ }
+}
+
+fn parent() {
+ let file = File::open("Makefile").unwrap();
+ let _dir = fs::read_dir("/").unwrap();
+ let tcp1 = TcpListener::bind("127.0.0.1:0").unwrap();
+ assert_eq!(tcp1.as_raw_fd(), file.as_raw_fd() + 2);
+ let tcp2 = tcp1.try_clone().unwrap();
+ let addr = tcp1.local_addr().unwrap();
+ let t = thread::scoped(|| TcpStream::connect(addr).unwrap());
+ let tcp3 = tcp1.accept().unwrap().0;
+ let tcp4 = t.join();
+ let tcp5 = tcp3.try_clone().unwrap();
+ let tcp6 = tcp4.try_clone().unwrap();
+ let udp1 = UdpSocket::bind("127.0.0.1:0").unwrap();
+ let udp2 = udp1.try_clone().unwrap();
+
+ let status = Command::new(env::args().next().unwrap())
+ .arg(file.as_raw_fd().to_string())
+ .arg((file.as_raw_fd() + 1).to_string())
+ .arg(tcp1.as_raw_fd().to_string())
+ .arg(tcp2.as_raw_fd().to_string())
+ .arg(tcp3.as_raw_fd().to_string())
+ .arg(tcp4.as_raw_fd().to_string())
+ .arg(tcp5.as_raw_fd().to_string())
+ .arg(tcp6.as_raw_fd().to_string())
+ .arg(udp1.as_raw_fd().to_string())
+ .arg(udp2.as_raw_fd().to_string())
+ .status()
+ .unwrap();
+ assert!(status.success());
+}
+
+fn child(args: &[String]) {
+ let mut b = [0u8; 2];
+ for arg in &args[1..] {
+ let fd: libc::c_int = arg.parse().unwrap();
+ unsafe {
+ assert_eq!(libc::read(fd, b.as_mut_ptr() as *mut _, 2), -1);
+ assert_eq!(io::Error::last_os_error().raw_os_error(),
+ Some(libc::EBADF));
+ }
+ }
+}
let _ = format!("{:p}{:p}{:p}",
rc, arc, b);
+ if cfg!(target_pointer_width = "32") {
+ assert_eq!(format!("{:#p}", p),
+ "0x00000000");
+ } else {
+ assert_eq!(format!("{:#p}", p),
+ "0x0000000000000000");
+ }
assert_eq!(format!("{:p}", p),
"0x0");
}
t!(format!("{:X}", 10_usize), "A");
t!(format!("{}", "foo"), "foo");
t!(format!("{}", "foo".to_string()), "foo");
+ if cfg!(target_pointer_width = "32") {
+ t!(format!("{:#p}", 0x1234 as *const isize), "0x00001234");
+ t!(format!("{:#p}", 0x1234 as *mut isize), "0x00001234");
+ } else {
+ t!(format!("{:#p}", 0x1234 as *const isize), "0x0000000000001234");
+ t!(format!("{:#p}", 0x1234 as *mut isize), "0x0000000000001234");
+ }
t!(format!("{:p}", 0x1234 as *const isize), "0x1234");
t!(format!("{:p}", 0x1234 as *mut isize), "0x1234");
t!(format!("{:x}", A), "aloha");
t!(format!("{}", 5 + 5), "10");
t!(format!("{:#4}", C), "☃123");
- // FIXME(#20676)
- // let a: &fmt::Debug = &1;
- // t!(format!("{:?}", a), "1");
+ let a: &fmt::Debug = &1;
+ t!(format!("{:?}", a), "1");
// Formatting strings and their arguments
--- /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.
+
+// Issue 15523: derive(PartialOrd) should use the provided
+// discriminant values for the derived ordering.
+//
+// This test is checking corner cases that arise when you have
+// 64-bit values in the variants.
+
+#[derive(PartialEq, PartialOrd)]
+#[repr(u64)]
+enum Eu64 {
+ Pos2 = 2,
+ PosMax = !0,
+ Pos1 = 1,
+}
+
+#[derive(PartialEq, PartialOrd)]
+#[repr(i64)]
+enum Ei64 {
+ Pos2 = 2,
+ Neg1 = -1,
+ NegMin = 1 << 63,
+ PosMax = !(1 << 63),
+ Pos1 = 1,
+}
+
+fn main() {
+ assert!(Eu64::Pos2 > Eu64::Pos1);
+ assert!(Eu64::Pos2 < Eu64::PosMax);
+ assert!(Eu64::Pos1 < Eu64::PosMax);
+
+
+ assert!(Ei64::Pos2 > Ei64::Pos1);
+ assert!(Ei64::Pos2 > Ei64::Neg1);
+ assert!(Ei64::Pos1 > Ei64::Neg1);
+ assert!(Ei64::Pos2 > Ei64::NegMin);
+ assert!(Ei64::Pos1 > Ei64::NegMin);
+ assert!(Ei64::Pos2 < Ei64::PosMax);
+ assert!(Ei64::Pos1 < Ei64::PosMax);
+}
--- /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.
+
+// Issue 15523: derive(PartialOrd) should use the provided
+// discriminant values for the derived ordering.
+//
+// This is checking the basic functionality.
+
+#[derive(PartialEq, PartialOrd)]
+enum E1 {
+ Pos2 = 2,
+ Neg1 = -1,
+ Pos1 = 1,
+}
+
+#[derive(PartialEq, PartialOrd)]
+#[repr(u8)]
+enum E2 {
+ Pos2 = 2,
+ PosMax = !0 as u8,
+ Pos1 = 1,
+}
+
+#[derive(PartialEq, PartialOrd)]
+#[repr(i8)]
+enum E3 {
+ Pos2 = 2,
+ Neg1 = -1_i8,
+ Pos1 = 1,
+}
+
+fn main() {
+ assert!(E1::Pos2 > E1::Pos1);
+ assert!(E1::Pos1 > E1::Neg1);
+ assert!(E1::Pos2 > E1::Neg1);
+
+ assert!(E2::Pos2 > E2::Pos1);
+ assert!(E2::Pos1 < E2::PosMax);
+ assert!(E2::Pos2 < E2::PosMax);
+
+ assert!(E3::Pos2 > E3::Pos1);
+ assert!(E3::Pos1 > E3::Neg1);
+ assert!(E3::Pos2 > E3::Neg1);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// pretty-expanded FIXME #23616
-
#[derive(Eq, PartialEq, PartialOrd, Ord)]
enum Test<'a> {
Int(&'a isize),
--- /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.
+
+// Regression test for unwrapping the result of `join`, issue #21291
+
+use std::thread;
+
+fn main() {
+ thread::spawn(|| {}).join().unwrap()
+}
--- /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.
+
+macro_rules! foo {
+ () => {
+ struct Bar;
+ struct Baz;
+ }
+}
+
+macro_rules! grault {
+ () => {
+ foo!();
+ struct Xyzzy;
+ }
+}
+
+fn static_assert_exists<T>() { }
+
+fn main() {
+ grault!();
+ static_assert_exists::<Bar>();
+ static_assert_exists::<Baz>();
+ static_assert_exists::<Xyzzy>();
+}
--- /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.
+
+macro_rules! foo {
+ () => {
+ struct Bar;
+ struct Baz;
+ }
+}
+
+macro_rules! grault {
+ () => {{
+ foo!();
+ struct Xyzzy;
+ 0
+ }}
+}
+
+fn main() {
+ let x = grault!();
+ assert_eq!(x, 0);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// pretty-expanded FIXME #23616
-
#![feature(collections)]
use std::string::String;
--- /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.
+
+#![crate_type="lib"]
+
+// @has assoc_types/trait.Index.html
+pub trait Index<I: ?Sized> {
+ // @has - '//*[@id="associatedtype.Output"]//code' 'type Output: ?Sized'
+ type Output: ?Sized;
+ // @has - '//*[@id="tymethod.index"]//code' \
+ // "fn index<'a>(&'a self, index: I) -> &'a Self::Output"
+ fn index<'a>(&'a self, index: I) -> &'a Self::Output;
+}
--- /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.
+
+// aux-build:rustdoc-default-impl.rs
+// ignore-android
+
+extern crate rustdoc_default_impl as foo;
+
+pub use foo::bar;
+
+pub fn wut<T: bar::Bar>() {
+}
--- /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.
+
+// aux-build:rustdoc-extern-default-method.rs
+// ignore-android
+
+extern crate rustdoc_extern_default_method as ext;
+
+// @count extern_default_method/struct.Struct.html '//*[@id="method.provided"]' 1
+pub use ext::Struct;
--- /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.
+
+// aux-build:rustdoc-extern-method.rs
+// ignore-android
+
+#![feature(unboxed_closures)]
+
+extern crate rustdoc_extern_method as foo;
+
+// @has extern_method/trait.Foo.html //pre "pub trait Foo"
+// @has - '//*[@id="tymethod.foo"]//code' 'extern "rust-call" fn foo'
+// @has - '//*[@id="method.foo_"]//code' 'extern "rust-call" fn foo_'
+pub use foo::Foo;
+
+// @has extern_method/trait.Bar.html //pre "pub trait Bar"
+pub trait Bar {
+ // @has - '//*[@id="tymethod.bar"]//code' 'extern "rust-call" fn bar'
+ extern "rust-call" fn bar(&self, _: ());
+ // @has - '//*[@id="method.bar_"]//code' 'extern "rust-call" fn bar_'
+ extern "rust-call" fn bar_(&self, _: ()) { }
+}
--- /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.
+
+// aux-build:rustdoc-ffi.rs
+// ignore-android
+
+extern crate rustdoc_ffi as lib;
+
+// @has ffi/fn.foreigner.html //pre 'pub unsafe extern fn foreigner(cold_as_ice: u32)'
+pub use lib::foreigner;
+
+extern "C" {
+ // @has ffi/fn.another.html //pre 'pub unsafe extern fn another(cold_as_ice: u32)'
+ pub fn another(cold_as_ice: u32);
+}
--- /dev/null
+// Copyright 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.
+
+/// The '# ' lines should be removed from the output, but the #[derive] should be
+/// retained.
+///
+/// ```rust
+/// mod to_make_deriving_work { // FIXME #4913
+///
+/// # #[derive(PartialEq)] // invisible
+/// # struct Foo; // invisible
+///
+/// #[derive(PartialEq)] // Bar
+/// struct Bar(Foo);
+///
+/// fn test() {
+/// let x = Bar(Foo);
+/// assert!(x == x); // check that the derivings worked
+/// }
+///
+/// }
+/// ```
+pub fn foo() {}
+
+// @!has hidden_line/fn.foo.html invisible
+// @matches - //pre "#\[derive\(PartialEq\)\] // Bar"
--- /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.
+
+// aux-build:inline-default-methods.rs
+// ignore-android
+
+extern crate inline_default_methods;
+
+// @has inline_default_methods/trait.Foo.html
+// @has - '//*[@class="rust trait"]' 'fn bar(&self);'
+// @has - '//*[@class="rust trait"]' 'fn foo(&mut self) { ... }'
+pub use inline_default_methods::Foo;
--- /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.
+
+// aux-build:issue-13698.rs
+// ignore-android
+
+extern crate issue_13698;
+
+pub struct Foo;
+// @!has issue_13698/struct.Foo.html '//*[@id="method.foo"]' 'fn foo'
+impl issue_13698::Foo for Foo {}
+
+pub trait Bar {
+ #[doc(hidden)]
+ fn bar(&self) {}
+}
+
+// @!has issue_13698/struct.Foo.html '//*[@id="method.foo"]' 'fn bar'
+impl Bar for Foo {}
--- /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.
+
+// @has issue_15169/struct.Foo.html '//*[@id="method.eq"]' 'fn eq'
+#[derive(PartialEq)]
+pub struct Foo;
--- /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.
+
+// aux-build:issue-15318.rs
+// ignore-android
+
+extern crate issue_15318;
+
+pub use issue_15318::ptr;
+
+// @has issue_15318_2/fn.bar.html \
+// '//*[@href="primitive.pointer.html"]' \
+// '*mut T'
+pub fn bar<T>(ptr: *mut T) {}
+
--- /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.
+
+// @has issue_15318_3/primitive.pointer.html
+
+/// dox
+#[doc(primitive = "pointer")]
+pub mod ptr {}
--- /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.
+
+// aux-build:issue-15318.rs
+// ignore-android
+
+#![feature(no_std)]
+#![no_std]
+
+extern crate issue_15318;
+
+// @has issue_15318/fn.bar.html \
+// '//*[@href="http://example.com/issue_15318/primitive.pointer.html"]' \
+// '*mut T'
+pub fn bar<T>(ptr: *mut T) {}
--- /dev/null
+// Copyright 2105 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.
+
+// compile-flags:--no-defaults --passes "collapse-docs" --passes "unindent-comments"
+
+// @has issue_15347/fn.foo.html
+#[doc(hidden)]
+pub fn foo() {}
--- /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.
+
+macro_rules! define_struct {
+ ($rounds:expr) => (
+ struct Struct {
+ sk: [u32; $rounds + 1]
+ }
+ )
+}
+
+define_struct!(2);
--- /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.
+
+pub struct Foo;
+
+// @has issue_16265_1/traits/index.html '[src]'
+pub mod traits {
+ impl PartialEq for super::Foo {
+ fn eq(&self, _: &super::Foo) -> bool { true }
+ }
+}
--- /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.
+
+
+// @has issue_16265_2/index.html '[src]'
+
+trait Y {}
+impl Y for Option<u32>{}
--- /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.
+
+// aux-build:issue-17476.rs
+// ignore-android
+
+extern crate issue_17476;
+
+pub struct Foo;
+
+// @has issue_17476/struct.Foo.html \
+// '//*[@href="http://example.com/issue_17476/trait.Foo.html#method.foo"]' \
+// 'foo'
+impl issue_17476::Foo for Foo {}
--- /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.
+
+// compile-flags:--test
+
+#![doc(test(attr(feature(staged_api))))]
+
+/// ```
+/// #![staged_api]
+/// fn main() {}
+/// ```
+pub fn foo() {}
--- /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.
+
+// @has issue_19055/trait.Any.html
+pub trait Any {}
+
+impl<'any> Any + 'any {
+ // @has - '//*[@id="method.is"]' 'fn is'
+ pub fn is<T: 'static>(&self) -> bool { loop {} }
+
+ // @has - '//*[@id="method.downcast_ref"]' 'fn downcast_ref'
+ pub fn downcast_ref<T: 'static>(&self) -> Option<&T> { loop {} }
+
+ // @has - '//*[@id="method.downcast_mut"]' 'fn downcast_mut'
+ pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> { loop {} }
+}
+
+pub trait Foo {
+ fn foo(&self) {}
+}
+
+// @has - '//*[@id="method.foo"]' 'fn foo'
+impl Foo for Any {}
--- /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.
+
+pub trait Foo {
+ fn foo(&self) {}
+}
+
+pub struct Bar;
+
+// @has issue_20175/struct.Bar.html \
+// '//*[@id="method.foo"]' \
+// 'fn foo'
+impl<'a> Foo for &'a Bar {}
--- /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.
+
+// aux-build:issue-20646.rs
+// ignore-android
+
+#![feature(associated_types)]
+
+extern crate issue_20646;
+
+// @has issue_20646/trait.Trait.html \
+// '//*[@id="associatedtype.Output"]' \
+// 'type Output'
+pub trait Trait {
+ type Output;
+}
+
+// @has issue_20646/fn.fun.html \
+// '//*[@class="rust fn"]' 'where T: Trait<Output=i32>'
+pub fn fun<T>(_: T) where T: Trait<Output=i32> {}
+
+pub mod reexport {
+ // @has issue_20646/reexport/trait.Trait.html \
+ // '//*[@id="associatedtype.Output"]' \
+ // 'type Output'
+ // @has issue_20646/reexport/fn.fun.html \
+ // '//*[@class="rust fn"]' 'where T: Trait<Output=i32>'
+ pub use issue_20646::{Trait, fun};
+}
--- /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.
+
+// aux-build:issue-20727.rs
+// ignore-android
+
+extern crate issue_20727;
+
+// @has issue_20727_2/trait.Add.html
+pub trait Add<RHS = Self> {
+ // @has - '//*[@class="rust trait"]' 'trait Add<RHS = Self> {'
+ // @has - '//*[@class="rust trait"]' 'type Output;'
+ type Output;
+
+ // @has - '//*[@class="rust trait"]' 'fn add(self, rhs: RHS) -> Self::Output;'
+ fn add(self, rhs: RHS) -> Self::Output;
+}
+
+// @has issue_20727_2/reexport/trait.Add.html
+pub mod reexport {
+ // @has - '//*[@class="rust trait"]' 'trait Add<RHS = Self> {'
+ // @has - '//*[@class="rust trait"]' 'type Output;'
+ // @has - '//*[@class="rust trait"]' 'fn add(self, rhs: RHS) -> Self::Output;'
+ pub use issue_20727::Add;
+}
+
--- /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.
+
+// aux-build:issue-20727.rs
+// ignore-android
+
+extern crate issue_20727;
+
+pub trait Bar {}
+
+// @has issue_20727_3/trait.Deref2.html
+pub trait Deref2 {
+ // @has - '//*[@class="rust trait"]' 'trait Deref2 {'
+ // @has - '//*[@class="rust trait"]' 'type Target: Bar;'
+ type Target: Bar;
+
+ // @has - '//*[@class="rust trait"]' 'fn deref(&self) -> Self::Target;'
+ fn deref(&self) -> Self::Target;
+}
+
+// @has issue_20727_3/reexport/trait.Deref2.html
+pub mod reexport {
+ // @has - '//*[@class="rust trait"]' 'trait Deref2 {'
+ // @has - '//*[@class="rust trait"]' 'type Target: Bar;'
+ // @has - '//*[@class="rust trait"]' 'fn deref(&self) -> Self::Target;'
+ pub use issue_20727::Deref2;
+}
--- /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.
+
+// aux-build:issue-20727.rs
+// ignore-android
+
+extern crate issue_20727;
+
+// @has issue_20727_4/trait.Index.html
+pub trait Index<Idx: ?Sized> {
+ // @has - '//*[@class="rust trait"]' 'trait Index<Idx: ?Sized> {'
+ // @has - '//*[@class="rust trait"]' 'type Output: ?Sized'
+ type Output: ?Sized;
+
+ // @has - '//*[@class="rust trait"]' \
+ // 'fn index(&self, index: Idx) -> &Self::Output'
+ fn index(&self, index: Idx) -> &Self::Output;
+}
+
+// @has issue_20727_4/trait.IndexMut.html
+pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
+ // @has - '//*[@class="rust trait"]' \
+ // 'trait IndexMut<Idx: ?Sized>: Index<Idx> {'
+ // @has - '//*[@class="rust trait"]' \
+ // 'fn index_mut(&mut self, index: Idx) -> &mut Self::Output;'
+ fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
+}
+
+pub mod reexport {
+ // @has issue_20727_4/reexport/trait.Index.html
+ // @has - '//*[@class="rust trait"]' 'trait Index<Idx> where Idx: ?Sized {'
+ // @has - '//*[@class="rust trait"]' 'type Output: ?Sized'
+ // @has - '//*[@class="rust trait"]' \
+ // 'fn index(&self, index: Idx) -> &Self::Output'
+ pub use issue_20727::Index;
+
+ // @has issue_20727_4/reexport/trait.IndexMut.html
+ // @has - '//*[@class="rust trait"]' \
+ // 'trait IndexMut<Idx>: Index<Idx> where Idx: ?Sized {'
+ // @has - '//*[@class="rust trait"]' \
+ // 'fn index_mut(&mut self, index: Idx) -> &mut Self::Output;'
+ pub use issue_20727::IndexMut;
+}
--- /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.
+
+// aux-build:issue-20727.rs
+// ignore-android
+
+extern crate issue_20727;
+
+// @has issue_20727/trait.Deref.html
+pub trait Deref {
+ // @has - '//*[@class="rust trait"]' 'trait Deref {'
+ // @has - '//*[@class="rust trait"]' 'type Target: ?Sized;'
+ type Target: ?Sized;
+
+ // @has - '//*[@class="rust trait"]' \
+ // "fn deref<'a>(&'a self) -> &'a Self::Target;"
+ fn deref<'a>(&'a self) -> &'a Self::Target;
+}
+
+// @has issue_20727/reexport/trait.Deref.html
+pub mod reexport {
+ // @has - '//*[@class="rust trait"]' 'trait Deref {'
+ // @has - '//*[@class="rust trait"]' 'type Target: ?Sized;'
+ // @has - '//*[@class="rust trait"]' \
+ // "fn deref(&'a self) -> &'a Self::Target;"
+ pub use issue_20727::Deref;
+}
--- /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.
+
+// aux-build:issue-21092.rs
+// ignore-android
+
+extern crate issue_21092;
+
+// @has issue_21092/struct.Bar.html
+// @has - '//*[@id="assoc_type.Bar"]' 'type Bar = i32'
+pub use issue_21092::{Foo, Bar};
--- /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.
+
+pub use inner::*;
+
+mod inner {
+ impl super::Blah for super::What { }
+}
+
+pub trait Blah { }
+
+// @count issue_21474/struct.What.html \
+// '//*[@class="impl"]' 1
+pub struct What;
--- /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.
+
+// aux-build:issue-21801.rs
+// ignore-android
+
+extern crate issue_21801;
+
+// @has issue_21801/struct.Foo.html
+// @has - '//*[@id="method.new"]' \
+// 'fn new<F>(f: F) -> Foo where F: FnMut() -> i32'
+pub use issue_21801::Foo;
--- /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.
+
+// aux-build:issue-22025.rs
+// ignore-android
+
+extern crate issue_22025;
+
+pub use issue_22025::foo::{Foo, Bar};
--- /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 {
+ // @has issue_22038/fn.foo1.html \
+ // '//*[@class="rust fn"]' 'pub unsafe extern fn foo1()'
+ pub fn foo1();
+}
+
+extern "system" {
+ // @has issue_22038/fn.foo2.html \
+ // '//*[@class="rust fn"]' 'pub unsafe extern "system" fn foo2()'
+ pub fn foo2();
+}
+
+// @has issue_22038/fn.bar.html \
+// '//*[@class="rust fn"]' 'pub extern fn bar()'
+pub extern fn bar() {}
+
+// @has issue_22038/fn.baz.html \
+// '//*[@class="rust fn"]' 'pub extern "system" fn baz()'
+pub extern "system" fn baz() {}
--- /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.
+
+// compile-flags:--test
+
+/// ```
+/// #
+/// ```
+pub fn main() {
+}
--- /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.
+
+// aux-build:issue-23207-1.rs
+// aux-build:issue-23207-2.rs
+// ignore-android
+
+extern crate issue_23207_2;
+
+// @has issue_23207/fmt/index.html
+// @count - '//*[@class="struct"]' 1
+pub use issue_23207_2::fmt;
+
--- /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.
+
+#![feature(no_std, lang_items, core)]
+#![no_std]
+
+extern crate core;
+
+pub mod str {
+ #![doc(primitive = "str")]
+
+ #[lang = "str"]
+ impl str {
+ // @has search-index.js foo
+ pub fn foo(&self) {}
+ }
+}
--- /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.
+
+// compile-flags:--test
+
+/// Example of rustdoc incorrectly parsing <code>```rust,should_panic</code>.
+///
+/// ```should_panic
+/// fn main() { panic!("fee"); }
+/// ```
+///
+/// ```rust,should_panic
+/// fn main() { panic!("fum"); }
+/// ```
+pub fn foo() {}
--- /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.
+
+// @has must_use/struct.Struct.html //pre '#[must_use]'
+#[must_use]
+pub struct Struct {
+ field: i32,
+}
+
+// @has must_use/enum.Enum.html //pre '#[must_use = "message"]'
+#[must_use = "message"]
+pub enum Enum {
+ Variant(i32),
+}
--- /dev/null
+// Copyright 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(optin_builtin_traits)]
+
+// @matches negative_impl/struct.Alpha.html '//pre' "pub struct Alpha"
+pub struct Alpha;
+// @matches negative_impl/struct.Bravo.html '//pre' "pub struct Bravo<B>"
+pub struct Bravo<B>(B);
+
+// @matches negative_impl/struct.Alpha.html '//*[@class="impl"]//code' "impl !Send for Alpha"
+impl !Send for Alpha {}
+
+// @matches negative_impl/struct.Bravo.html '//*[@class="impl"]//code' "impl<B> !Send for Bravo<B>"
+impl<B> !Send for Bravo<B> {}
--- /dev/null
+// Copyright 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.
+
+#![crate_type = "lib"]
+#![feature(globs)]
+
+mod m {
+ pub use self::a::Foo;
+
+ mod a {
+ pub struct Foo;
+ }
+
+ mod b {
+ pub use super::*;
+ }
+}
--- /dev/null
+// Copyright 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.
+
+#![crate_type = "lib"]
+#![feature(globs)]
+
+mod m {
+ pub use self::a::Foo;
+
+ mod a {
+ pub struct Foo;
+ }
+
+ mod b {
+ pub use super::*;
+ }
+}
--- /dev/null
+// Copyright 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(globs)]
+
+pub mod longhands {
+ pub use super::*;
+
+ pub use super::common_types::computed::compute_CSSColor as to_computed_value;
+
+ pub fn computed_as_specified() {}
+}
+
+pub mod common_types {
+ pub mod computed {
+ pub use super::super::longhands::computed_as_specified as compute_CSSColor;
+ }
+}
--- /dev/null
+// Copyright 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.
+
+#![crate_name = "rustdoc_test"]
+
+// @has search-index.js Foo
+pub use private::Foo;
+
+mod private {
+ pub struct Foo;
+ impl Foo {
+ pub fn test_method() {} // @has - test_method
+ fn priv_method() {} // @!has - priv_method
+ }
+
+ pub trait PrivateTrait {
+ fn trait_method(&self) {} // @!has - priv_method
+ }
+}
--- /dev/null
+// Copyright 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.
+
+// @has smoke/index.html
+
+//! Very docs
+
+// @has smoke/bar/index.html
+pub mod bar {
+
+ /// So correct
+ // @has smoke/bar/baz/index.html
+ pub mod baz {
+ /// Much detail
+ // @has smoke/bar/baz/fn.baz.html
+ pub fn baz() { }
+ }
+
+ /// *wow*
+ // @has smoke/bar/trait.Doge.html
+ pub trait Doge { fn dummy(&self) { } }
+
+ // @has smoke/bar/struct.Foo.html
+ pub struct Foo { x: isize, y: usize }
+
+ // @has smoke/bar/fn.prawns.html
+ pub fn prawns((a, b): (isize, usize), Foo { x, y }: Foo) { }
+}
--- /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.
+
+#![crate_name = "foo"]
+
+//! Dox
+// @has src/foo/src-links.rs.html
+// @has foo/index.html '//a/@href' '../src/foo/src-links.rs.html'
+
+#[path = "src-links/mod.rs"]
+pub mod qux;
+
+// @has foo/bar/index.html '//a/@href' '../../src/foo/src-links.rs.html'
+pub mod bar {
+
+ /// Dox
+ // @has foo/bar/baz/index.html '//a/@href' '../../../src/foo/src-links.rs.html'
+ pub mod baz {
+ /// Dox
+ // @has foo/bar/baz/fn.baz.html '//a/@href' '../../../src/foo/src-links.rs.html'
+ pub fn baz() { }
+ }
+
+ /// Dox
+ // @has foo/bar/trait.Foobar.html '//a/@href' '../../src/foo/src-links.rs.html'
+ pub trait Foobar { fn dummy(&self) { } }
+
+ // @has foo/bar/struct.Foo.html '//a/@href' '../../src/foo/src-links.rs.html'
+ pub struct Foo { x: i32, y: u32 }
+
+ // @has foo/bar/fn.prawns.html '//a/@href' '../../src/foo/src-links.rs.html'
+ pub fn prawns((a, b): (i32, u32), Foo { x, y }: Foo) { }
+}
+
+/// Dox
+// @has foo/fn.modfn.html '//a/@href' '../src/foo/src-links.rs.html'
+pub fn modfn() { }
+
+// same hierarchy as above, but just for the submodule
+
+// @has src/foo/src-links/mod.rs.html
+// @has foo/qux/index.html '//a/@href' '../../src/foo/src-links/mod.rs.html'
+// @has foo/qux/bar/index.html '//a/@href' '../../../src/foo/src-links/mod.rs.html'
+// @has foo/qux/bar/baz/index.html '//a/@href' '../../../../src/foo/src-links/mod.rs.html'
+// @has foo/qux/bar/baz/fn.baz.html '//a/@href' '../../../../src/foo/src-links/mod.rs.html'
+// @has foo/qux/bar/trait.Foobar.html '//a/@href' '../../../src/foo/src-links/mod.rs.html'
+// @has foo/qux/bar/struct.Foo.html '//a/@href' '../../../src/foo/src-links/mod.rs.html'
+// @has foo/qux/bar/fn.prawns.html '//a/@href' '../../../src/foo/src-links/mod.rs.html'
+// @has foo/qux/fn.modfn.html '//a/@href' '../../src/foo/src-links/mod.rs.html'
--- /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.
+
+//! Dox
+pub mod bar {
+
+ /// Dox
+ pub mod baz {
+ /// Dox
+ pub fn baz() { }
+ }
+
+ /// Dox
+ pub trait Foobar { fn dummy(&self) { } }
+
+ pub struct Foo { x: i32, y: u32 }
+
+ pub fn prawns((a, b): (i32, u32), Foo { x, y }: Foo) { }
+}
+
+/// Dox
+pub fn modfn() { }
--- /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.
+
+#![crate_name = "foo"]
+
+pub mod io {
+ pub trait Reader { fn dummy(&self) { } }
+}
+
+pub enum Maybe<A> {
+ Just(A),
+ Nothing
+}
+
+// @has foo/prelude/index.html
+pub mod prelude {
+ // @has foo/prelude/index.html '//code' 'pub use io::{self, Reader}'
+ #[doc(no_inline)] pub use io::{self, Reader};
+ // @has foo/prelude/index.html '//code' 'pub use Maybe::{self, Just, Nothing}'
+ #[doc(no_inline)] pub use Maybe::{self, Just, Nothing};
+}
--- /dev/null
+// Copyright 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.
+
+#![crate_name = "foo"]
+
+pub trait MyTrait { fn dummy(&self) { } }
+
+// @has foo/struct.Alpha.html '//pre' "pub struct Alpha<A> where A: MyTrait"
+pub struct Alpha<A>(A) where A: MyTrait;
+// @has foo/trait.Bravo.html '//pre' "pub trait Bravo<B> where B: MyTrait"
+pub trait Bravo<B> where B: MyTrait { fn get(&self, B: B); }
+// @has foo/fn.charlie.html '//pre' "pub fn charlie<C>() where C: MyTrait"
+pub fn charlie<C>() where C: MyTrait {}
+
+pub struct Delta<D>(D);
+
+// @has foo/struct.Delta.html '//*[@class="impl"]//code' \
+// "impl<D> Delta<D> where D: MyTrait"
+impl<D> Delta<D> where D: MyTrait {
+ pub fn delta() {}
+}
+
+pub struct Echo<E>(E);
+
+// @has foo/struct.Echo.html '//*[@class="impl"]//code' \
+// "impl<E> MyTrait for Echo<E> where E: MyTrait"
+// @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
+// "impl<E> MyTrait for Echo<E> where E: MyTrait"
+impl<E> MyTrait for Echo<E> where E: MyTrait {}
+
+pub enum Foxtrot<F> { Foxtrot1(F) }
+
+// @has foo/enum.Foxtrot.html '//*[@class="impl"]//code' \
+// "impl<F> MyTrait for Foxtrot<F> where F: MyTrait"
+// @has foo/trait.MyTrait.html '//*[@id="implementors-list"]//code' \
+// "impl<F> MyTrait for Foxtrot<F> where F: MyTrait"
+impl<F> MyTrait for Foxtrot<F> where F: MyTrait {}