define DEF_LLVM_RULES
+ifeq ($(1),$$(CFG_BUILD))
+LLVM_DEPS_TARGET_$(1) := $$(LLVM_DEPS)
+else
+LLVM_DEPS_TARGET_$(1) := $$(LLVM_DEPS) $$(LLVM_CONFIG_$$(CFG_BUILD))
+endif
+
# If CFG_LLVM_ROOT is defined then we don't build LLVM ourselves
ifeq ($(CFG_LLVM_ROOT),)
LLVM_STAMP_$(1) = $$(CFG_LLVM_BUILD_DIR_$(1))/llvm-auto-clean-stamp
-$$(LLVM_CONFIG_$(1)): $$(LLVM_DEPS) $$(LLVM_STAMP_$(1))
+$$(LLVM_CONFIG_$(1)): $$(LLVM_DEPS_TARGET_$(1)) $$(LLVM_STAMP_$(1))
@$$(call E, cmake: llvm)
ifeq ($$(findstring msvc,$(1)),msvc)
$$(Q)$$(CFG_CMAKE) --build $$(CFG_LLVM_BUILD_DIR_$(1)) \
endif
$$(Q)touch $$(LLVM_CONFIG_$(1))
+ifeq ($$(findstring msvc,$(1)),msvc)
clean-llvm$(1):
+else
+clean-llvm$(1):
+ @$$(call E, clean: llvm)
+ $$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) clean
+endif
else
clean-llvm$(1):
let dst = build.compiler_rt_out(target);
let arch = target.split('-').next().unwrap();
let mode = if build.config.rust_optimize {"Release"} else {"Debug"};
+
+ let build_llvm_config = build.llvm_config(&build.config.build);
+ let mut cfg = cmake::Config::new(build.src.join("src/compiler-rt"));
+ cfg.target(target)
+ .host(&build.config.build)
+ .out_dir(&dst)
+ .profile(mode)
+ .define("LLVM_CONFIG_PATH", build_llvm_config)
+ .define("COMPILER_RT_DEFAULT_TARGET_TRIPLE", target)
+ .define("COMPILER_RT_BUILD_SANITIZERS", "OFF")
+ .define("COMPILER_RT_BUILD_EMUTLS", "OFF")
+ // inform about c/c++ compilers, the c++ compiler isn't actually used but
+ // it's needed to get the initial configure to work on all platforms.
+ .define("CMAKE_C_COMPILER", build.cc(target))
+ .define("CMAKE_CXX_COMPILER", build.cc(target));
+
let (dir, build_target, libname) = if target.contains("linux") ||
target.contains("freebsd") ||
target.contains("netbsd") {
- let os = if target.contains("android") {"-android"} else {""};
- let arch = if arch.starts_with("arm") && target.contains("eabihf") {
- "armhf"
+ let os_extra = if target.contains("android") && target.contains("arm") {
+ "-android"
} else {
- arch
+ ""
};
- let target = format!("clang_rt.builtins-{}{}", arch, os);
+ let builtins_arch = match arch {
+ "i586" => "i386",
+ "arm" | "armv7" if target.contains("android") => "armhf",
+ "arm" if target.contains("eabihf") => "armhf",
+ _ => arch,
+ };
+ let target = format!("clang_rt.builtins-{}{}", builtins_arch, os_extra);
("linux".to_string(), target.clone(), target)
- } else if target.contains("darwin") {
- let target = format!("clang_rt.builtins_{}_osx", arch);
+ } else if target.contains("apple-darwin") {
+ let builtins_arch = match arch {
+ "i686" => "i386",
+ _ => arch,
+ };
+ let target = format!("clang_rt.builtins_{}_osx", builtins_arch);
+ ("builtins".to_string(), target.clone(), target)
+ } else if target.contains("apple-ios") {
+ cfg.define("COMPILER_RT_ENABLE_IOS", "ON");
+ let target = match arch {
+ "armv7s" => "hard_pic_armv7em_macho_embedded".to_string(),
+ "aarch64" => "builtins_arm64_ios".to_string(),
+ _ => format!("hard_pic_{}_macho_embedded", arch),
+ };
("builtins".to_string(), target.clone(), target)
} else if target.contains("windows-gnu") {
let target = format!("clang_rt.builtins-{}", arch);
("windows".to_string(), target.clone(), target)
} else if target.contains("windows-msvc") {
+ let builtins_arch = match arch {
+ "i586" | "i686" => "i386",
+ _ => arch,
+ };
(format!("windows/{}", mode),
"lib/builtins/builtins".to_string(),
- format!("clang_rt.builtins-{}", arch.replace("i686", "i386")))
+ format!("clang_rt.builtins-{}", builtins_arch))
} else {
panic!("can't get os from target: {}", target)
};
}
let _ = fs::remove_dir_all(&dst);
t!(fs::create_dir_all(&dst));
- let build_llvm_config = build.llvm_config(&build.config.build);
- let mut cfg = cmake::Config::new(build.src.join("src/compiler-rt"));
- cfg.target(target)
- .host(&build.config.build)
- .out_dir(&dst)
- .profile(mode)
- .define("LLVM_CONFIG_PATH", build_llvm_config)
- .define("COMPILER_RT_DEFAULT_TARGET_TRIPLE", target)
- .define("COMPILER_RT_BUILD_SANITIZERS", "OFF")
- .define("COMPILER_RT_BUILD_EMUTLS", "OFF")
- // inform about c/c++ compilers, the c++ compiler isn't actually used but
- // it's needed to get the initial configure to work on all platforms.
- .define("CMAKE_C_COMPILER", build.cc(target))
- .define("CMAKE_CXX_COMPILER", build.cc(target))
- .build_target(&build_target);
+ cfg.build_target(&build_target);
cfg.build();
}
A quick note about closures that use explicit lifetimes. Sometimes you might have a closure
that takes a reference like so:
-```
+```rust
fn call_with_ref<F>(some_closure:F) -> i32
where F: Fn(&i32) -> i32 {
Normally you can specify the lifetime of the parameter to our closure. We
could annotate it on the function declaration:
-```ignore
-fn call_with_ref<'a, F>(some_closure:F) -> i32
+```rust,ignore
+fn call_with_ref<'a, F>(some_closure:F) -> i32
where F: Fn(&'a 32) -> i32 {
```
where F: for<'a> Fn(&'a 32) -> i32 {
```
-This lets the Rust compiler find the minimum lifetime to invoke our closure and
+This lets the Rust compiler find the minimum lifetime to invoke our closure and
satisfy the borrow checker's rules. Our function then compiles and excutes as we
expect.
-```
+```rust
fn call_with_ref<F>(some_closure:F) -> i32
where F: for<'a> Fn(&'a i32) -> i32 {
in different languages. To keep things simple, we’ll stick to ‘greetings’ and
‘farewells’ as two kinds of phrases, and use English and Japanese (日本語) as
two languages for those phrases to be in. We’ll use this module layout:
-
```text
+-----------+
+---| greetings |
- | +-----------+
- +---------+ |
+ +---------+ | +-----------+
+---| english |---+
| +---------+ | +-----------+
| +---| farewells |
| +---| greetings |
| +----------+ | +-----------+
+---| japanese |--+
- +----------+ |
- | +-----------+
+ +----------+ | +-----------+
+---| farewells |
+-----------+
```
[arrays]: primitive-types.html#arrays
[vectors]: vectors.html
-[heap]: the-stack-and-the-heap.html
+[heap]: the-stack-and-the-heap.html#the-heap
[stack]: the-stack-and-the-heap.html#the-stack
[bindings]: variable-bindings.html
[generics]: generics.html
pattern representing the value of 10 to the allocated memory and binds the
variable name x to this memory region for future reference.
+[i32]: primitive-types.html#numeric-types
+
Now consider the following code fragment:
```rust
}
// can be called with T == i64
-fn inverse<T>() -> T
+fn inverse<T>(x: i32) -> T
// this is using ConvertTo as if it were "ConvertTo<i64>"
where i32: ConvertTo<T> {
- 42.convert()
+ x.convert()
}
```
## Whitespace
-Whitespace is any non-empty string containing only the following characters:
-
+Whitespace is any non-empty string containing only characters that have the
+`Pattern_White_Space` Unicode property, namely:
+
+- `U+0009` (horizontal tab, `'\t'`)
+- `U+000A` (line feed, `'\n'`)
+- `U+000B` (vertical tab)
+- `U+000C` (form feed)
+- `U+000D` (carriage return, `'\r'`)
- `U+0020` (space, `' '`)
-- `U+0009` (tab, `'\t'`)
-- `U+000A` (LF, `'\n'`)
-- `U+000D` (CR, `'\r'`)
+- `U+0085` (next line)
+- `U+200E` (left-to-right mark)
+- `U+200F` (right-to-left mark)
+- `U+2028` (line separator)
+- `U+2029` (paragraph separator)
Rust is a "free-form" language, meaning that all forms of whitespace serve only
to separate _tokens_ in the grammar, and have no semantic significance.
//! format!("{:?}", (3, 4)); // => "(3, 4)"
//! format!("{value}", value=4); // => "4"
//! format!("{} {}", 1, 2); // => "1 2"
+//! format!("{:04}", 42); // => "0042" with leading zeros
//! ```
//!
//! From these, you can see that the first argument is a format string. It is
"##,
E0269: r##"
-Functions must eventually return a value of their return type. For example, in
-the following function:
+A returned value was expected but not all control paths return one.
+
+Erroneous code example:
```compile_fail,E0269
fn abracada_FAIL() -> String {
"this won't work".to_string();
+ // error: not all control paths return a value
}
```
-If the condition is true, the value `x` is returned, but if the condition is
-false, control exits the `if` block and reaches a place where nothing is being
-returned. All possible control paths must eventually return a `u8`, which is not
-happening here.
-
-An easy fix for this in a complicated function is to specify a default return
-value, if possible:
+In the previous code, the function is supposed to return a `String`, however,
+the code returns nothing (because of the ';'). Another erroneous code would be:
-```ignore
-fn foo(x: u8) -> u8 {
- if x > 0 {
- x // alternatively, `return x`
+```compile_fail
+fn abracada_FAIL(b: bool) -> u32 {
+ if b {
+ 0
+ } else {
+ "a" // It fails because an `u32` was expected and something else is
+ // returned.
}
- // lots of other if branches
- 0 // return 0 if all else fails
}
```
It is advisable to find out what the unhandled cases are and check for them,
returning an appropriate value or panicking if necessary. Check if you need
-to remove a semicolon from the last expression, like in this case:
-
-```ignore
-fn foo(x: u8) -> u8 {
- inner(2*x + 1);
-}
-```
-
-The semicolon discards the return value of `inner`, instead of returning
-it from `foo`.
+to remove a semicolon from the last expression, like in the first erroneous
+code example.
"##,
E0270: r##"
use std::collections::BTreeMap;
use std::iter;
use syntax::ast::*;
+use syntax::errors;
use syntax::ptr::P;
use syntax::codemap::{respan, Spanned};
use syntax::parse::token;
pub struct LoweringContext<'a> {
crate_root: Option<&'static str>,
// Use to assign ids to hir nodes that do not directly correspond to an ast node
- id_assigner: &'a NodeIdAssigner,
+ sess: Option<&'a Session>,
// As we walk the AST we must keep track of the current 'parent' def id (in
// the form of a DefIndex) so that if we create a new node which introduces
// a definition, then we can properly create the def id.
pub fn lower_crate(sess: &Session,
krate: &Crate,
- id_assigner: &NodeIdAssigner,
resolver: &mut Resolver)
-> hir::Crate {
// We're constructing the HIR here; we don't care what we will
} else {
Some("std")
},
- id_assigner: id_assigner,
+ sess: Some(sess),
parent_def: None,
resolver: resolver,
}.lower_crate(krate)
}
impl<'a> LoweringContext<'a> {
- pub fn testing_context(id_assigner: &'a NodeIdAssigner, resolver: &'a mut Resolver) -> Self {
+ pub fn testing_context(resolver: &'a mut Resolver) -> Self {
LoweringContext {
crate_root: None,
- id_assigner: id_assigner,
+ sess: None,
parent_def: None,
resolver: resolver,
}
}
fn next_id(&self) -> NodeId {
- self.id_assigner.next_node_id()
+ self.sess.map(Session::next_node_id).unwrap_or(0)
+ }
+
+ fn diagnostic(&self) -> &errors::Handler {
+ self.sess.map(Session::diagnostic)
+ .unwrap_or_else(|| panic!("this lowerer cannot emit diagnostics"))
}
fn str_to_ident(&self, s: &'static str) -> Name {
if let Some(SelfKind::Explicit(..)) = sig.decl.get_self().map(|eself| eself.node) {
match hir_sig.decl.get_self().map(|eself| eself.node) {
Some(hir::SelfKind::Value(..)) | Some(hir::SelfKind::Region(..)) => {
- self.id_assigner.diagnostic().span_err(sig.decl.inputs[0].ty.span,
+ self.diagnostic().span_err(sig.decl.inputs[0].ty.span,
"the type placeholder `_` is not allowed within types on item signatures");
}
_ => {}
make_struct(self, e, &["RangeInclusive", "NonEmpty"],
&[("start", e1), ("end", e2)]),
- _ => panic!(self.id_assigner.diagnostic()
+ _ => panic!(self.diagnostic()
.span_fatal(e.span, "inclusive range with no end")),
};
}
// If we are walking HIR (c.f., AST), we need to keep a reference to the
// crate.
hir_crate: Option<&'ast hir::Crate>,
- pub definitions: Definitions,
+ definitions: &'ast mut Definitions,
parent_def: Option<DefIndex>,
}
impl<'ast> DefCollector<'ast> {
- pub fn root() -> DefCollector<'ast> {
+ pub fn root(definitions: &'ast mut Definitions) -> DefCollector<'ast> {
let mut collector = DefCollector {
hir_crate: None,
- definitions: Definitions::new(),
+ definitions: definitions,
parent_def: None,
};
let root = collector.create_def_with_parent(None, CRATE_NODE_ID, DefPathData::CrateRoot);
pub fn extend(parent_node: NodeId,
parent_def_path: DefPath,
parent_def_id: DefId,
- definitions: Definitions)
+ definitions: &'ast mut Definitions)
-> DefCollector<'ast> {
let mut collector = DefCollector {
hir_crate: None,
use middle::cstore::LOCAL_CRATE;
use hir::def_id::{DefId, DefIndex};
+use hir::map::def_collector::DefCollector;
use rustc_data_structures::fnv::FnvHashMap;
-use syntax::ast;
+use syntax::{ast, visit};
use syntax::parse::token::InternedString;
use util::nodemap::NodeMap;
}
}
+ pub fn collect(&mut self, krate: &ast::Crate) {
+ let mut def_collector = DefCollector::root(self);
+ visit::walk_crate(&mut def_collector, krate);
+ }
+
/// Get the number of definitions.
pub fn len(&self) -> usize {
self.data.len()
use syntax::abi::Abi;
use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID, };
use syntax::codemap::Spanned;
-use syntax::visit;
use syntax_pos::Span;
use hir::*;
}
}
-pub fn collect_definitions<'ast>(krate: &'ast ast::Crate) -> Definitions {
- let mut def_collector = DefCollector::root();
- visit::walk_crate(&mut def_collector, krate);
- def_collector.definitions
-}
-
pub fn map_crate<'ast>(forest: &'ast mut Forest,
definitions: Definitions)
-> Map<'ast> {
let ii = map.forest.inlined_items.alloc(ii);
let ii_parent_id = fld.new_id(DUMMY_NODE_ID);
- let defs = mem::replace(&mut *map.definitions.borrow_mut(), Definitions::new());
+ let defs = &mut *map.definitions.borrow_mut();
let mut def_collector = DefCollector::extend(ii_parent_id,
parent_def_path.clone(),
parent_def_id,
defs);
def_collector.walk_item(ii, map.krate());
- *map.definitions.borrow_mut() = def_collector.definitions;
let mut collector = NodeCollector::extend(map.krate(),
ii,
use util::nodemap::{NodeMap, FnvHashMap};
use mir::transform as mir_pass;
-use syntax::ast::{NodeId, NodeIdAssigner, Name};
+use syntax::ast::{NodeId, Name};
use errors::{self, DiagnosticBuilder};
use errors::emitter::{Emitter, BasicEmitter, EmitterWriter};
use syntax::json::JsonEmitter;
id
}
+ pub fn next_node_id(&self) -> NodeId {
+ self.reserve_node_ids(1)
+ }
pub fn diagnostic<'a>(&'a self) -> &'a errors::Handler {
&self.parse_sess.span_diagnostic
}
}
}
-impl NodeIdAssigner for Session {
- fn next_node_id(&self) -> NodeId {
- self.reserve_node_ids(1)
- }
-
- fn peek_node_id(&self) -> NodeId {
- self.next_node_id.get().checked_add(1).unwrap()
- }
-
- fn diagnostic(&self) -> &errors::Handler {
- self.diagnostic()
- }
-}
-
fn split_msg_into_multilines(msg: &str) -> Option<String> {
// Conditions for enabling multi-line errors:
if !msg.contains("mismatched types") &&
let result = match e.node {
hir::ExprUnary(hir::UnNeg, ref inner) => {
// unary neg literals already got their sign during creation
- match inner.node {
- hir::ExprLit(ref lit) => {
- use syntax::ast::*;
- use syntax::ast::LitIntType::*;
- const I8_OVERFLOW: u64 = ::std::i8::MAX as u64 + 1;
- const I16_OVERFLOW: u64 = ::std::i16::MAX as u64 + 1;
- const I32_OVERFLOW: u64 = ::std::i32::MAX as u64 + 1;
- const I64_OVERFLOW: u64 = ::std::i64::MAX as u64 + 1;
- match (&lit.node, ety.map(|t| &t.sty)) {
- (&LitKind::Int(I8_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I8))) |
- (&LitKind::Int(I8_OVERFLOW, Signed(IntTy::I8)), _) => {
- return Ok(Integral(I8(::std::i8::MIN)))
- },
- (&LitKind::Int(I16_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I16))) |
- (&LitKind::Int(I16_OVERFLOW, Signed(IntTy::I16)), _) => {
- return Ok(Integral(I16(::std::i16::MIN)))
- },
- (&LitKind::Int(I32_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I32))) |
- (&LitKind::Int(I32_OVERFLOW, Signed(IntTy::I32)), _) => {
- return Ok(Integral(I32(::std::i32::MIN)))
- },
- (&LitKind::Int(I64_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I64))) |
- (&LitKind::Int(I64_OVERFLOW, Signed(IntTy::I64)), _) => {
- return Ok(Integral(I64(::std::i64::MIN)))
- },
- (&LitKind::Int(n, Unsuffixed), Some(&ty::TyInt(IntTy::Is))) |
- (&LitKind::Int(n, Signed(IntTy::Is)), _) => {
- match tcx.sess.target.int_type {
- IntTy::I16 => if n == I16_OVERFLOW {
- return Ok(Integral(Isize(Is16(::std::i16::MIN))));
- },
- IntTy::I32 => if n == I32_OVERFLOW {
- return Ok(Integral(Isize(Is32(::std::i32::MIN))));
- },
- IntTy::I64 => if n == I64_OVERFLOW {
- return Ok(Integral(Isize(Is64(::std::i64::MIN))));
- },
- _ => bug!(),
- }
- },
- _ => {},
- }
- },
- hir::ExprUnary(hir::UnNeg, ref inner) => {
- // skip `--$expr`
- return eval_const_expr_partial(tcx, inner, ty_hint, fn_args);
- },
- _ => {},
+ if let hir::ExprLit(ref lit) = inner.node {
+ use syntax::ast::*;
+ use syntax::ast::LitIntType::*;
+ const I8_OVERFLOW: u64 = ::std::i8::MAX as u64 + 1;
+ const I16_OVERFLOW: u64 = ::std::i16::MAX as u64 + 1;
+ const I32_OVERFLOW: u64 = ::std::i32::MAX as u64 + 1;
+ const I64_OVERFLOW: u64 = ::std::i64::MAX as u64 + 1;
+ match (&lit.node, ety.map(|t| &t.sty)) {
+ (&LitKind::Int(I8_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I8))) |
+ (&LitKind::Int(I8_OVERFLOW, Signed(IntTy::I8)), _) => {
+ return Ok(Integral(I8(::std::i8::MIN)))
+ },
+ (&LitKind::Int(I16_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I16))) |
+ (&LitKind::Int(I16_OVERFLOW, Signed(IntTy::I16)), _) => {
+ return Ok(Integral(I16(::std::i16::MIN)))
+ },
+ (&LitKind::Int(I32_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I32))) |
+ (&LitKind::Int(I32_OVERFLOW, Signed(IntTy::I32)), _) => {
+ return Ok(Integral(I32(::std::i32::MIN)))
+ },
+ (&LitKind::Int(I64_OVERFLOW, Unsuffixed), Some(&ty::TyInt(IntTy::I64))) |
+ (&LitKind::Int(I64_OVERFLOW, Signed(IntTy::I64)), _) => {
+ return Ok(Integral(I64(::std::i64::MIN)))
+ },
+ (&LitKind::Int(n, Unsuffixed), Some(&ty::TyInt(IntTy::Is))) |
+ (&LitKind::Int(n, Signed(IntTy::Is)), _) => {
+ match tcx.sess.target.int_type {
+ IntTy::I16 => if n == I16_OVERFLOW {
+ return Ok(Integral(Isize(Is16(::std::i16::MIN))));
+ },
+ IntTy::I32 => if n == I32_OVERFLOW {
+ return Ok(Integral(Isize(Is32(::std::i32::MIN))));
+ },
+ IntTy::I64 => if n == I64_OVERFLOW {
+ return Ok(Integral(Isize(Is64(::std::i64::MIN))));
+ },
+ _ => bug!(),
+ }
+ },
+ _ => {},
+ }
}
match eval_const_expr_partial(tcx, &inner, ty_hint, fn_args)? {
Float(f) => Float(-f),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rustc::dep_graph::DepGraph;
use rustc::hir;
use rustc::hir::{map as hir_map, FreevarMap, TraitMap};
use rustc::hir::def::DefMap;
use rustc_back::sha2::{Sha256, Digest};
use rustc_borrowck as borrowck;
use rustc_incremental;
-use rustc_resolve as resolve;
+use rustc_resolve::{MakeGlobMap, Resolver};
use rustc_metadata::macro_import;
use rustc_metadata::creader::read_local_crates;
use rustc_metadata::cstore::CStore;
use std::fs;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
-use syntax::ast::{self, NodeIdAssigner};
+use syntax::{ast, diagnostics, visit};
use syntax::attr::{self, AttrMetaMethods};
-use syntax::diagnostics;
use syntax::fold::Folder;
use syntax::parse::{self, PResult, token};
use syntax::util::node_count::NodeCounter;
-use syntax::visit;
use syntax;
use syntax_ext;
pub after_analysis: PhaseController<'a>,
pub after_llvm: PhaseController<'a>,
- pub make_glob_map: resolve::MakeGlobMap,
+ pub make_glob_map: MakeGlobMap,
}
impl<'a> CompileController<'a> {
after_hir_lowering: PhaseController::basic(),
after_analysis: PhaseController::basic(),
after_llvm: PhaseController::basic(),
- make_glob_map: resolve::MakeGlobMap::No,
+ make_glob_map: MakeGlobMap::No,
}
}
}
mut krate: ast::Crate,
crate_name: &'a str,
addl_plugins: Option<Vec<String>>,
- make_glob_map: resolve::MakeGlobMap)
+ make_glob_map: MakeGlobMap)
-> Result<ExpansionResult<'a>, usize> {
let time_passes = sess.time_passes();
krate = assign_node_ids(sess, krate);
+ let resolver_arenas = Resolver::arenas();
+ let mut resolver = Resolver::new(sess, make_glob_map, &resolver_arenas);
+
// Collect defintions for def ids.
- let mut defs =
- time(sess.time_passes(), "collecting defs", || hir_map::collect_definitions(&krate));
+ time(sess.time_passes(), "collecting defs", || resolver.definitions.collect(&krate));
- time(sess.time_passes(),
- "external crate/lib resolution",
- || read_local_crates(sess, &cstore, &defs, &krate, crate_name, &sess.dep_graph));
+ time(sess.time_passes(), "external crate/lib resolution", || {
+ let defs = &resolver.definitions;
+ read_local_crates(sess, &cstore, defs, &krate, crate_name, &sess.dep_graph)
+ });
time(sess.time_passes(),
"early lint checks",
"AST validation",
|| ast_validation::check_crate(sess, &krate));
- let (analysis, resolutions, hir_forest) =
- lower_and_resolve(sess, crate_name, &mut defs, &krate, &sess.dep_graph, make_glob_map);
+ time(sess.time_passes(), "name resolution", || {
+ resolver.resolve_crate(&krate);
+ });
+
+ // Lower ast -> hir.
+ let hir_forest = time(sess.time_passes(), "lowering ast -> hir", || {
+ hir_map::Forest::new(lower_crate(sess, &krate, &mut resolver), &sess.dep_graph)
+ });
// Discard MTWT tables that aren't required past lowering to HIR.
if !keep_mtwt_tables(sess) {
Ok(ExpansionResult {
expanded_crate: krate,
- defs: defs,
- analysis: analysis,
- resolutions: resolutions,
+ defs: resolver.definitions,
+ analysis: ty::CrateAnalysis {
+ export_map: resolver.export_map,
+ access_levels: AccessLevels::default(),
+ reachable: NodeSet(),
+ name: crate_name,
+ glob_map: if resolver.make_glob_map { Some(resolver.glob_map) } else { None },
+ },
+ resolutions: Resolutions {
+ def_map: resolver.def_map,
+ freevars: resolver.freevars,
+ trait_map: resolver.trait_map,
+ maybe_unused_trait_imports: resolver.maybe_unused_trait_imports,
+ },
hir_forest: hir_forest
})
}
krate
}
-pub fn lower_and_resolve<'a>(sess: &Session,
- id: &'a str,
- defs: &mut hir_map::Definitions,
- krate: &ast::Crate,
- dep_graph: &DepGraph,
- make_glob_map: resolve::MakeGlobMap)
- -> (ty::CrateAnalysis<'a>, Resolutions, hir_map::Forest) {
- resolve::with_resolver(sess, defs, make_glob_map, |mut resolver| {
- time(sess.time_passes(), "name resolution", || {
- resolve::resolve_crate(&mut resolver, krate);
- });
-
- // Lower ast -> hir.
- let hir_forest = time(sess.time_passes(), "lowering ast -> hir", || {
- hir_map::Forest::new(lower_crate(sess, krate, sess, &mut resolver), dep_graph)
- });
-
- (ty::CrateAnalysis {
- export_map: resolver.export_map,
- access_levels: AccessLevels::default(),
- reachable: NodeSet(),
- name: &id,
- glob_map: if resolver.make_glob_map { Some(resolver.glob_map) } else { None },
- }, Resolutions {
- def_map: resolver.def_map,
- freevars: resolver.freevars,
- trait_map: resolver.trait_map,
- maybe_unused_trait_imports: resolver.maybe_unused_trait_imports,
- }, hir_forest)
- })
-}
-
/// Run the resolution, typechecking, region checking and other
/// miscellaneous analysis passes on the crate. Return various
/// structures carrying the results of the analysis.
use rustc::ty::{self, Ty, TyCtxt};
use syntax::ast;
-use syntax::ast::NodeIdAssigner;
use syntax::ptr::P;
use syntax_pos;
#[cfg(test)] use std::io::Cursor;
#[cfg(test)] use syntax::parse;
-#[cfg(test)] use syntax::ast::NodeId;
#[cfg(test)] use rustc::hir::print as pprust;
#[cfg(test)] use rustc::hir::lowering::{LoweringContext, DummyResolver};
fn parse_sess(&self) -> &parse::ParseSess { self }
}
-#[cfg(test)]
-struct FakeNodeIdAssigner;
-
-#[cfg(test)]
-// It should go without saying that this may give unexpected results. Avoid
-// lowering anything which needs new nodes.
-impl NodeIdAssigner for FakeNodeIdAssigner {
- fn next_node_id(&self) -> NodeId {
- 0
- }
-
- fn peek_node_id(&self) -> NodeId {
- 0
- }
-}
-
#[cfg(test)]
fn mk_ctxt() -> parse::ParseSess {
parse::ParseSess::new()
#[cfg(test)]
fn with_testing_context<T, F: FnOnce(&mut LoweringContext) -> T>(f: F) -> T {
- let assigner = FakeNodeIdAssigner;
let mut resolver = DummyResolver;
- let mut lcx = LoweringContext::testing_context(&assigner, &mut resolver);
+ let mut lcx = LoweringContext::testing_context(&mut resolver);
f(&mut lcx)
}
register_long_diagnostics! {
E0154: r##"
+## Note: this error code is no longer emitted by the compiler.
+
Imports (`use` statements) are not allowed after non-item statements, such as
variable declarations and expression statements.
"##,
E0251: r##"
+## Note: this error code is no longer emitted by the compiler.
+
Two items of the same name cannot be imported without rebinding one of the
items under a new local name.
Two items of the same name cannot be imported without rebinding one of the
items under a new local name.
-An example of this error:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0252
use foo::baz;
use bar::baz; // error, do `use bar::baz as quux` instead
pub struct baz;
}
+mod bar {
+ pub mod baz {}
+}
+```
+
+You can use aliases in order to fix this error. Example:
+
+```
+use foo::baz as foo_baz;
+use bar::baz; // ok!
+
+fn main() {}
+
+mod foo {
+ pub struct baz;
+}
+
+mod bar {
+ pub mod baz {}
+}
+```
+
+Or you can reference the item with its parent:
+
+```
+use bar::baz;
+
+fn main() {
+ let x = foo::baz; // ok!
+}
+
+mod foo {
+ pub struct baz;
+}
+
mod bar {
pub mod baz {}
}
E0253: r##"
Attempt was made to import an unimportable value. This can happen when trying
-to import a method from a trait. An example of this error:
+to import a method from a trait.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0253
mod foo {
pub trait MyTrait {
fn do_something();
}
use foo::MyTrait::do_something;
+
+fn main() {}
```
It's invalid to directly import methods belonging to a trait or concrete type.
You can't import a value whose name is the same as another value defined in the
module.
-An example of this error:
+Erroneous code example:
-```compile_fail
-use bar::foo; // error, do `use bar::foo as baz` instead
+```compile_fail,E0255
+use bar::foo; // error: an item named `foo` is already in scope
fn foo() {}
fn main() {}
```
+
+You can use aliases in order to fix this error. Example:
+
+```
+use bar::foo as bar_foo; // ok!
+
+fn foo() {}
+
+mod bar {
+ pub fn foo() {}
+}
+
+fn main() {}
+```
+
+Or you can reference the item with its parent:
+
+```
+fn foo() {}
+
+mod bar {
+ pub fn foo() {}
+}
+
+fn main() {
+ bar::foo(); // we get the item by referring to its parent
+}
+```
"##,
E0256: r##"
+## Note: this error code is no longer emitted by the compiler.
+
You can't import a type or module when the name of the item being imported is
the same as another type or submodule defined in the module.
Erroneous code example:
-```compile_fail
-extern crate a;
-extern crate crate_a as a;
+```compile_fail,E0259
+extern crate std;
+extern crate libc as std;
+
+fn main() {}
```
The solution is to choose a different name that doesn't conflict with any
Correct example:
```ignore
-extern crate a;
-extern crate crate_a as other_name;
+extern crate std;
+extern crate libc as other_name;
```
"##,
E0260: r##"
The name for an item declaration conflicts with an external crate's name.
-For instance:
+Erroneous code example:
-```ignore
+```ignore,E0260
extern crate abc;
struct abc;
"##,
E0364: r##"
-Private items cannot be publicly re-exported. This error indicates that you
+Private items cannot be publicly re-exported. This error indicates that you
attempted to `pub use` a type or value that was not itself public.
-Here is an example that demonstrates the error:
+Erroneous code example:
```compile_fail
mod foo {
}
pub use foo::X;
+
+fn main() {}
```
The solution to this problem is to ensure that the items that you are
re-exporting are themselves marked with `pub`:
-```ignore
+```
mod foo {
pub const X: u32 = 1;
}
pub use foo::X;
+
+fn main() {}
```
See the 'Use Declarations' section of the reference for more information on
Private modules cannot be publicly re-exported. This error indicates that you
attempted to `pub use` a module that was not itself public.
-Here is an example that demonstrates the error:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0365
mod foo {
pub const X: u32 = 1;
}
pub use foo as foo2;
+
+fn main() {}
```
The solution to this problem is to ensure that the module that you are
re-exporting is itself marked with `pub`:
-```ignore
+```
pub mod foo {
pub const X: u32 = 1;
}
pub use foo as foo2;
+
+fn main() {}
```
See the 'Use Declarations' section of the reference for more information
E0401: r##"
Inner items do not inherit type parameters from the functions they are embedded
-in. For example, this will not compile:
+in.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0401
fn foo<T>(x: T) {
fn bar(y: T) { // T is defined in the "outer" function
// ..
Nor will this:
-```compile_fail
+```compile_fail,E0401
fn foo<T>(x: T) {
type MaybeT = Option<T>;
// ...
Or this:
-```compile_fail
+```compile_fail,E0401
fn foo<T>(x: T) {
struct Foo {
x: T,
"##,
E0403: r##"
-Some type parameters have the same name. Example of erroneous code:
+Some type parameters have the same name.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0403
fn foo<T, T>(s: T, u: T) {} // error: the name `T` is already used for a type
// parameter in this type parameter list
```
"##,
E0404: r##"
-You tried to implement something which was not a trait on an object. Example of
-erroneous code:
+You tried to implement something which was not a trait on an object.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0404
struct Foo;
struct Bar;
"##,
E0405: r##"
-The code refers to a trait that is not in scope. Example of erroneous code:
+The code refers to a trait that is not in scope.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0405
struct Foo;
impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope
E0407: r##"
A definition of a method not in the implemented trait was given in a trait
-implementation. Example of erroneous code:
+implementation.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0407
trait Foo {
fn a();
}
An "or" pattern was used where the variable bindings are not consistently bound
across patterns.
-Example of erroneous code:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0408
match x {
Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is
// not bound in pattern #2
An "or" pattern was used where the variable bindings are not consistently bound
across patterns.
-Example of erroneous code:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0409
let x = (0, 2);
match x {
(0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with
"##,
E0411: r##"
-The `Self` keyword was used outside an impl or a trait. Erroneous code example:
+The `Self` keyword was used outside an impl or a trait.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0411
<Self>::foo; // error: use of `Self` outside of an impl or trait
```
"##,
E0412: r##"
-The type name used is not in scope. Example of erroneous codes:
+The type name used is not in scope.
-```compile_fail
+Erroneous code examples:
+
+```compile_fail,E0412
impl Something {} // error: type name `Something` is not in scope
// or:
"##,
E0415: r##"
-More than one function parameter have the same name. Example of erroneous code:
+More than one function parameter have the same name.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0415
fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than
// once in this parameter list
```
"##,
E0416: r##"
-An identifier is bound more than once in a pattern. Example of erroneous code:
+An identifier is bound more than once in a pattern.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0416
match (1, 2) {
(x, x) => {} // error: identifier `x` is bound more than once in the
// same pattern
E0422: r##"
You are trying to use an identifier that is either undefined or not a struct.
-For instance:
-``` compile_fail
+Erroneous code example:
+
+``` compile_fail,E0422
fn main () {
let x = Foo { x: 1, y: 2 };
}
In this case, `Foo` is undefined, so it inherently isn't anything, and
definitely not a struct.
-```compile_fail
+```compile_fail,E0422
fn main () {
let foo = 1;
let x = foo { x: 1, y: 2 };
"##,
E0423: r##"
-A `struct` variant name was used like a function name. Example of erroneous
-code:
+A `struct` variant name was used like a function name.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0423
struct Foo { a: bool};
let f = Foo();
"##,
E0424: r##"
-The `self` keyword was used in a static method. Example of erroneous code:
+The `self` keyword was used in a static method.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0424
struct Foo;
impl Foo {
"##,
E0425: r##"
-An unresolved name was used. Example of erroneous codes:
+An unresolved name was used.
-```compile_fail
+Erroneous code examples:
+
+```compile_fail,E0425
something_that_doesnt_exist::foo;
// error: unresolved name `something_that_doesnt_exist::foo`
"##,
E0426: r##"
-An undeclared label was used. Example of erroneous code:
+An undeclared label was used.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0426
loop {
break 'a; // error: use of undeclared label `'a`
}
"##,
E0428: r##"
-A type or module has been defined more than once. Example of erroneous
-code:
+A type or module has been defined more than once.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0428
struct Bar;
struct Bar; // error: duplicate definition of value `Bar`
```
The `self` keyword cannot appear alone as the last segment in a `use`
declaration.
-Example of erroneous code:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0429
use std::fmt::self; // error: `self` imports are only allowed within a { } list
```
"##,
E0430: r##"
-The `self` import appears more than once in the list. Erroneous code example:
+The `self` import appears more than once in the list.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0430
use something::{self, self}; // error: `self` import can only appear once in
// the list
```
"##,
E0431: r##"
-An invalid `self` import was made. Erroneous code example:
+An invalid `self` import was made.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0431
use {self}; // error: `self` import can only appear in an import list with a
// non-empty prefix
```
"##,
E0432: r##"
-An import was unresolved. Erroneous code example:
+An import was unresolved.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0432
use something::Foo; // error: unresolved import `something::Foo`.
```
"##,
E0433: r##"
-Invalid import. Example of erroneous code:
+An undeclared type or module was used.
-```compile_fail
-use something_which_doesnt_exist;
-// error: unresolved import `something_which_doesnt_exist`
+Erroneous code example:
+
+```compile_fail,E0433
+let map = HashMap::new();
+// error: failed to resolve. Use of undeclared type or module `HashMap`
```
-Please verify you didn't misspell the import's name.
+Please verify you didn't misspell the type/module's name or that you didn't
+forgot to import it:
+
+
+```
+use std::collections::HashMap; // HashMap has been imported.
+let map: HashMap<u32, u32> = HashMap::new(); // So it can be used!
+```
"##,
E0434: r##"
because the variable comes from a dynamic environment. Inner functions do not
have access to their containing environment.
-Example of erroneous code:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0434
fn foo() {
let y = 5;
fn bar() -> u32 {
"##,
E0435: r##"
-A non-constant value was used to initialise a constant. Example of erroneous
-code:
+A non-constant value was used to initialise a constant.
-```compile_fail
+Erroneous code example:
+
+```compile_fail,E0435
let foo = 42u32;
const FOO : u32 = foo; // error: attempt to use a non-constant value in a
// constant
an associated type whose name does not match the name of any associated type
in the trait.
-Here is an example that demonstrates the error:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0437
trait Foo {}
impl Foo for i32 {
attempted to implement an associated constant whose name does not
match the name of any associated constant in the trait.
-Here is an example that demonstrates the error:
+Erroneous code example:
-```compile_fail
+```compile_fail,E0438
#![feature(associated_consts)]
trait Foo {}
use rustc::session::Session;
use rustc::lint;
use rustc::hir::def::*;
-use rustc::hir::def_id::DefId;
+use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
use rustc::ty;
use rustc::ty::subst::{ParamSpace, FnSpace, TypeSpace};
use rustc::hir::{Freevar, FreevarMap, TraitCandidate, TraitMap, GlobMap};
pub struct Resolver<'a> {
session: &'a Session,
- definitions: &'a mut Definitions,
+ pub definitions: Definitions,
graph_root: Module<'a>,
arenas: &'a ResolverArenas<'a>,
}
-struct ResolverArenas<'a> {
+pub struct ResolverArenas<'a> {
modules: arena::TypedArena<ModuleS<'a>>,
local_modules: RefCell<Vec<Module<'a>>>,
name_bindings: arena::TypedArena<NameBinding<'a>>,
}
fn definitions(&mut self) -> Option<&mut Definitions> {
- Some(self.definitions)
+ Some(&mut self.definitions)
}
}
}
impl<'a> Resolver<'a> {
- fn new(session: &'a Session,
- definitions: &'a mut Definitions,
- make_glob_map: MakeGlobMap,
- arenas: &'a ResolverArenas<'a>)
- -> Resolver<'a> {
- let root_def_id = definitions.local_def_id(CRATE_NODE_ID);
+ pub fn new(session: &'a Session, make_glob_map: MakeGlobMap, arenas: &'a ResolverArenas<'a>)
+ -> Resolver<'a> {
+ let root_def_id = DefId::local(CRATE_DEF_INDEX);
let graph_root =
ModuleS::new(NoParentLink, Some(Def::Mod(root_def_id)), false, arenas);
let graph_root = arenas.alloc_module(graph_root);
Resolver {
session: session,
- definitions: definitions,
+ definitions: Definitions::new(),
// The outermost module has def ID 0; this is not reflected in the
// AST.
}
}
- fn arenas() -> ResolverArenas<'a> {
+ pub fn arenas() -> ResolverArenas<'a> {
ResolverArenas {
modules: arena::TypedArena::new(),
local_modules: RefCell::new(Vec::new()),
}
}
+ /// Entry point to crate resolution.
+ pub fn resolve_crate(&mut self, krate: &Crate) {
+ // Currently, we ignore the name resolution data structures for
+ // the purposes of dependency tracking. Instead we will run name
+ // resolution and include its output in the hash of each item,
+ // much like we do for macro expansion. In other words, the hash
+ // reflects not just its contents but the results of name
+ // resolution on those contents. Hopefully we'll push this back at
+ // some point.
+ let _ignore = self.session.dep_graph.in_ignore();
+
+ self.build_reduced_graph(krate);
+ resolve_imports::resolve_imports(self);
+
+ self.current_module = self.graph_root;
+ visit::walk_crate(self, krate);
+
+ check_unused::check_crate(self, krate);
+ self.report_privacy_errors();
+ }
+
fn new_module(&self, parent_link: ParentLink<'a>, def: Option<Def>, external: bool)
-> Module<'a> {
self.arenas.alloc_module(ModuleS::new(parent_link, def, external, self.arenas))
None
}
- fn resolve_crate(&mut self, krate: &Crate) {
- debug!("(resolving crate) starting");
- self.current_module = self.graph_root;
- visit::walk_crate(self, krate);
- }
-
fn resolve_item(&mut self, item: &Item) {
let name = item.ident.name;
PatKind::Ident(bmode, ref ident, ref opt_pat) => {
// First try to resolve the identifier as some existing
// entity, then fall back to a fresh binding.
- let resolution = if let Ok(resolution) = self.resolve_path(pat.id,
- &Path::from_ident(ident.span, ident.node), 0, ValueNS) {
+ let local_def = self.resolve_identifier(ident.node, ValueNS, true);
+ let resolution = if let Some(LocalDef { def, .. }) = local_def {
let always_binding = !pat_src.is_refutable() || opt_pat.is_some() ||
bmode != BindingMode::ByValue(Mutability::Immutable);
- match resolution.base_def {
+ match def {
Def::Struct(..) | Def::Variant(..) |
Def::Const(..) | Def::AssociatedConst(..) if !always_binding => {
// A constant, unit variant, etc pattern.
- resolution
+ PathResolution::new(def)
}
Def::Struct(..) | Def::Variant(..) |
Def::Const(..) | Def::AssociatedConst(..) | Def::Static(..) => {
// A fresh binding that shadows something unacceptable.
+ let kind_name = PathResolution::new(def).kind_name();
resolve_error(
self,
ident.span,
ResolutionError::BindingShadowsSomethingUnacceptable(
- pat_src.descr(), resolution.kind_name(), ident.node.name)
+ pat_src.descr(), kind_name, ident.node.name)
);
err_path_resolution()
}
No,
}
-/// Entry point to crate resolution.
-pub fn resolve_crate<'a, 'b>(resolver: &'b mut Resolver<'a>, krate: &'b Crate) {
- // Currently, we ignore the name resolution data structures for
- // the purposes of dependency tracking. Instead we will run name
- // resolution and include its output in the hash of each item,
- // much like we do for macro expansion. In other words, the hash
- // reflects not just its contents but the results of name
- // resolution on those contents. Hopefully we'll push this back at
- // some point.
- let _ignore = resolver.session.dep_graph.in_ignore();
-
- resolver.build_reduced_graph(krate);
- resolve_imports::resolve_imports(resolver);
- resolver.resolve_crate(krate);
-
- check_unused::check_crate(resolver, krate);
- resolver.report_privacy_errors();
-}
-
-pub fn with_resolver<'a, T, F>(session: &'a Session,
- definitions: &'a mut Definitions,
- make_glob_map: MakeGlobMap,
- f: F) -> T
- where F: for<'b> FnOnce(Resolver<'b>) -> T,
-{
- let arenas = Resolver::arenas();
- let resolver = Resolver::new(session, definitions, make_glob_map, &arenas);
- f(resolver)
-}
-
__build_diagnostic_array! { librustc_resolve, DIAGNOSTICS }
document(w, cx, item)?;
let mut indices = (0..items.len()).filter(|i| {
+ if let clean::DefaultImplItem(..) = items[*i].inner {
+ return false;
+ }
!cx.maybe_ignore_item(&items[*i])
}).collect::<Vec<usize>>();
use rustc::middle::privacy::AccessLevels;
use rustc::util::nodemap::DefIdSet;
use std::cmp;
+use std::mem;
use std::string::String;
use std::usize;
// strip all #[doc(hidden)] items
let krate = {
struct Stripper<'a> {
- retained: &'a mut DefIdSet
+ retained: &'a mut DefIdSet,
+ update_retained: bool,
}
impl<'a> fold::DocFolder for Stripper<'a> {
fn fold_item(&mut self, i: Item) -> Option<Item> {
// use a dedicated hidden item for given item type if any
match i.inner {
clean::StructFieldItem(..) | clean::ModuleItem(..) => {
- return Strip(i).fold()
+ // We need to recurse into stripped modules to
+ // strip things like impl methods but when doing so
+ // we must not add any items to the `retained` set.
+ let old = mem::replace(&mut self.update_retained, false);
+ let ret = Strip(self.fold_item_recur(i).unwrap()).fold();
+ self.update_retained = old;
+ return ret;
}
_ => return None,
}
} else {
- self.retained.insert(i.def_id);
+ if self.update_retained {
+ self.retained.insert(i.def_id);
+ }
}
self.fold_item_recur(i)
}
}
- let mut stripper = Stripper{ retained: &mut retained };
+ let mut stripper = Stripper{ retained: &mut retained, update_retained: true };
stripper.fold_crate(krate)
};
let mut stripper = Stripper {
retained: &mut retained,
access_levels: &access_levels,
+ update_retained: true,
};
krate = ImportStripper.fold_crate(stripper.fold_crate(krate));
}
struct Stripper<'a> {
retained: &'a mut DefIdSet,
access_levels: &'a AccessLevels<DefId>,
+ update_retained: bool,
}
impl<'a> fold::DocFolder for Stripper<'a> {
fn fold_item(&mut self, i: Item) -> Option<Item> {
match i.inner {
- clean::StrippedItem(..) => return Some(i),
+ clean::StrippedItem(..) => {
+ // We need to recurse into stripped modules to strip things
+ // like impl methods but when doing so we must not add any
+ // items to the `retained` set.
+ let old = mem::replace(&mut self.update_retained, false);
+ let ret = self.fold_item_recur(i);
+ self.update_retained = old;
+ return ret;
+ }
// These items can all get re-exported
clean::TypedefItem(..) | clean::StaticItem(..) |
clean::StructItem(..) | clean::EnumItem(..) |
clean::ModuleItem(..) => {
if i.def_id.is_local() && i.visibility != Some(clean::Public) {
- return Strip(self.fold_item_recur(i).unwrap()).fold()
+ let old = mem::replace(&mut self.update_retained, false);
+ let ret = Strip(self.fold_item_recur(i).unwrap()).fold();
+ self.update_retained = old;
+ return ret;
}
}
- // trait impls for private items should be stripped
- clean::ImplItem(clean::Impl{
- for_: clean::ResolvedPath{ did, is_generic, .. }, ..
- }) => {
- if did.is_local() && !is_generic && !self.access_levels.is_exported(did) {
- return None;
- }
- }
// handled in the `strip-priv-imports` pass
clean::ExternCrateItem(..) | clean::ImportItem(..) => {}
};
let i = if fastreturn {
- self.retained.insert(i.def_id);
+ if self.update_retained {
+ self.retained.insert(i.def_id);
+ }
return Some(i);
} else {
self.fold_item_recur(i)
i.and_then(|i| {
match i.inner {
- // emptied modules/impls have no need to exist
+ // emptied modules have no need to exist
clean::ModuleItem(ref m)
if m.items.is_empty() &&
i.doc_value().is_none() => None,
- clean::ImplItem(ref i) if i.items.is_empty() => None,
_ => {
- self.retained.insert(i.def_id);
+ if self.update_retained {
+ self.retained.insert(i.def_id);
+ }
Some(i)
}
}
impl<'a> fold::DocFolder for ImplStripper<'a> {
fn fold_item(&mut self, i: Item) -> Option<Item> {
if let clean::ImplItem(ref imp) = i.inner {
+ // emptied none trait impls can be stripped
+ if imp.trait_.is_none() && imp.items.is_empty() {
+ return None;
+ }
if let Some(did) = imp.for_.def_id() {
if did.is_local() && !imp.for_.is_generic() &&
!self.retained.contains(&did)
}
hir::ViewPathList(p, paths) => {
let mine = paths.into_iter().filter(|path| {
- !self.maybe_inline_local(path.node.id(), None, false, om,
- please_inline)
+ !self.maybe_inline_local(path.node.id(), path.node.rename(),
+ false, om, please_inline)
}).collect::<hir::HirVec<hir::PathListItem>>();
if mine.is_empty() {
/// A slightly sad example of not reading anything into a buffer:
///
/// ```
-/// use std::io;
-/// use std::io::Read;
+/// use std::io::{self, Read};
///
-/// # fn foo() -> io::Result<String> {
/// let mut buffer = String::new();
-/// try!(io::empty().read_to_string(&mut buffer));
-/// # Ok(buffer)
-/// # }
+/// io::empty().read_to_string(&mut buffer).unwrap();
+/// assert!(buffer.is_empty());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn empty() -> Empty { Empty { _priv: () } }
///
/// All reads from this reader will succeed by filling the specified buffer with
/// the given byte.
+///
+/// # Examples
+///
+/// ```
+/// use std::io::{self, Read};
+///
+/// let mut buffer = [0; 3];
+/// io::repeat(0b101).read_exact(&mut buffer).unwrap();
+/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
+/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn repeat(byte: u8) -> Repeat { Repeat { byte: byte } }
///
/// All calls to `write` on the returned instance will return `Ok(buf.len())`
/// and the contents of the buffer will not be inspected.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::io::{self, Write};
+///
+/// let mut buffer = vec![1, 2, 3, 5, 8];
+/// let num_bytes = io::sink().write(&mut buffer).unwrap();
+/// assert_eq!(num_bytes, 5);
+/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn sink() -> Sink { Sink { _priv: () } }
/// // Values between `0` and `min` are Subnormal.
/// assert!(!lower_than_min.is_normal());
/// ```
- /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number
+ /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_normal(self) -> bool { num::Float::is_normal(self) }
/// Computes the tangent of a number (in radians).
///
/// ```
- /// use std::f64;
+ /// use std::f32;
///
- /// let x = f64::consts::PI/4.0;
+ /// let x = f32::consts::PI / 4.0;
/// let abs_difference = (x.tan() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// number is close to zero.
///
/// ```
- /// let x = 7.0f64;
+ /// use std::f32;
///
- /// // e^(ln(7)) - 1
- /// let abs_difference = (x.ln().exp_m1() - 6.0).abs();
+ /// let x = 6.0f32;
///
- /// assert!(abs_difference < 1e-10);
+ /// // e^(ln(6)) - 1
+ /// let abs_difference = (x.ln().exp_m1() - 5.0).abs();
+ ///
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// [subnormal][subnormal], or `NaN`.
///
/// ```
- /// use std::f32;
+ /// use std::f64;
///
- /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f64
- /// let max = f32::MAX;
- /// let lower_than_min = 1.0e-40_f32;
- /// let zero = 0.0f32;
+ /// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64
+ /// let max = f64::MAX;
+ /// let lower_than_min = 1.0e-308_f64;
+ /// let zero = 0.0f64;
///
/// assert!(min.is_normal());
/// assert!(max.is_normal());
///
/// assert!(!zero.is_normal());
- /// assert!(!f32::NAN.is_normal());
- /// assert!(!f32::INFINITY.is_normal());
+ /// assert!(!f64::NAN.is_normal());
+ /// assert!(!f64::INFINITY.is_normal());
/// // Values between `0` and `min` are Subnormal.
/// assert!(!lower_than_min.is_normal());
/// ```
- /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number
+ /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_normal(self) -> bool { num::Float::is_normal(self) }
/// ```
/// #![feature(float_extras)]
///
- /// let x = 1.0f32;
+ /// let x = 1.0f64;
///
- /// let abs_diff = (x.next_after(2.0) - 1.00000011920928955078125_f32).abs();
+ /// let abs_diff = (x.next_after(2.0) - 1.0000000000000002220446049250313_f64).abs();
///
/// assert!(abs_diff < 1e-10);
/// ```
///
/// See the module documentation for an in-depth explanation of components and
/// their role in the API.
+///
+/// This `enum` is created from iterating over the [`path::Components`]
+/// `struct`.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::path::{Component, Path};
+///
+/// let path = Path::new("/tmp/foo/bar.txt");
+/// let components = path.components().collect::<Vec<_>>();
+/// assert_eq!(&components, &[
+/// Component::RootDir,
+/// Component::Normal("tmp".as_ref()),
+/// Component::Normal("foo".as_ref()),
+/// Component::Normal("bar.txt".as_ref()),
+/// ]);
+/// ```
+///
+/// [`path::Components`]: struct.Components.html
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum Component<'a> {
///
/// *[See also the `std::f32` module](f32/index.html).*
///
-/// However, please note that examples are shared between the `f64` and `f32`
-/// primitive types. So it's normal if you see usage of `f64` in there.
-///
mod prim_f32 { }
#[doc(primitive = "f64")]
///
/// *[See also the `std::f64` module](f64/index.html).*
///
-/// However, please note that examples are shared between the `f64` and `f32`
-/// primitive types. So it's normal if you see usage of `f32` in there.
-///
mod prim_f64 { }
#[doc(primitive = "i8")]
/// signal being received or a spurious wakeup. Platforms which do not support
/// nanosecond precision for sleeping will have `dur` rounded up to the nearest
/// granularity of time they can sleep for.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use std::{thread, time};
+///
+/// let ten_millis = time::Duration::from_millis(10);
+/// let now = time::Instant::now();
+///
+/// thread::sleep(ten_millis);
+///
+/// assert!(now.elapsed() >= ten_millis);
+/// ```
#[stable(feature = "thread_sleep", since = "1.4.0")]
pub fn sleep(dur: Duration) {
imp::Thread::sleep(dur)
use syntax_pos::{mk_sp, Span, DUMMY_SP, ExpnId};
use codemap::{respan, Spanned};
use abi::Abi;
-use errors;
use parse::token::{self, keywords, InternedString};
use print::pprust;
use ptr::P;
/// small, positive ids.
pub const DUMMY_NODE_ID: NodeId = !0;
-pub trait NodeIdAssigner {
- fn next_node_id(&self) -> NodeId;
- fn peek_node_id(&self) -> NodeId;
-
- fn diagnostic(&self) -> &errors::Handler {
- panic!("this ID assigner cannot emit diagnostics")
- }
-}
-
/// The AST represents all type param bounds as types.
/// typeck::collect::compute_bounds matches these against
/// the "special" built-in traits (see middle::lang_items) and
fn attrs(&self) -> &[Attribute] {
match *self {
StmtKind::Local(ref local) => local.attrs(),
- StmtKind::Item(ref item) => item.attrs(),
+ StmtKind::Item(..) => &[],
StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => expr.attrs(),
StmtKind::Mac(ref mac) => {
let (_, _, ref attrs) = **mac;
fn map_attrs<F: FnOnce(Vec<Attribute>) -> Vec<Attribute>>(self, f: F) -> Self {
match self {
StmtKind::Local(local) => StmtKind::Local(local.map_attrs(f)),
- StmtKind::Item(item) => StmtKind::Item(item.map_attrs(f)),
+ StmtKind::Item(..) => self,
StmtKind::Expr(expr) => StmtKind::Expr(expr.map_attrs(f)),
StmtKind::Semi(expr) => StmtKind::Semi(expr.map_attrs(f)),
StmtKind::Mac(mac) => StmtKind::Mac(mac.map(|(mac, style, attrs)| {
}
fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVector<ast::Stmt> {
- // avoid calling `visit_stmt_or_expr_attrs` on items
- match stmt.node {
- ast::StmtKind::Item(_) => {}
- _ => self.visit_stmt_or_expr_attrs(stmt.attrs()),
- }
-
+ self.visit_stmt_or_expr_attrs(stmt.attrs());
self.configure(stmt).map(|stmt| fold::noop_fold_stmt(stmt, self))
.unwrap_or(SmallVector::zero())
}
span: self.span,
}))
}
+
+ fn make_ty(self: Box<DummyResult>) -> Option<P<ast::Ty>> {
+ Some(DummyResult::raw_ty(self.span))
+ }
}
/// An enum representing the different kinds of syntax extensions.
fn fold_with<F: Folder>(self, folder: &mut F) -> Self;
fn visit_with<V: Visitor>(&self, visitor: &mut V);
- // Return a placeholder expansion to allow compilation to continue after an erroring expansion.
- fn dummy(span: Span) -> Self;
-
// The user-friendly name of the node type (e.g. "expression", "item", etc.) for diagnostics.
fn kind_name() -> &'static str;
+
+ // Return a placeholder expansion to allow compilation to continue after an erroring expansion.
+ fn dummy(span: Span) -> Self {
+ Self::make_with(DummyResult::any(span)).unwrap()
+ }
}
macro_rules! impl_macro_generable {
($($ty:ty: $kind_name:expr, .$make:ident,
$(.$fold:ident)* $(lift .$fold_elt:ident)*,
- $(.$visit:ident)* $(lift .$visit_elt:ident)*,
- |$span:ident| $dummy:expr;)*) => { $(
+ $(.$visit:ident)* $(lift .$visit_elt:ident)*;)*) => { $(
impl MacroGenerable for $ty {
fn kind_name() -> &'static str { $kind_name }
fn make_with<'a>(result: Box<MacResult + 'a>) -> Option<Self> { result.$make() }
$( visitor.$visit(self) )*
$( for item in self.as_slice() { visitor. $visit_elt (item) } )*
}
- fn dummy($span: Span) -> Self { $dummy }
}
)* }
}
impl_macro_generable! {
- P<ast::Pat>: "pattern", .make_pat, .fold_pat, .visit_pat, |span| P(DummyResult::raw_pat(span));
- P<ast::Ty>: "type", .make_ty, .fold_ty, .visit_ty, |span| DummyResult::raw_ty(span);
- P<ast::Expr>:
- "expression", .make_expr, .fold_expr, .visit_expr, |span| DummyResult::raw_expr(span);
- SmallVector<ast::Stmt>:
- "statement", .make_stmts, lift .fold_stmt, lift .visit_stmt, |_span| SmallVector::zero();
- SmallVector<P<ast::Item>>:
- "item", .make_items, lift .fold_item, lift .visit_item, |_span| SmallVector::zero();
+ P<ast::Expr>: "expression", .make_expr, .fold_expr, .visit_expr;
+ P<ast::Pat>: "pattern", .make_pat, .fold_pat, .visit_pat;
+ P<ast::Ty>: "type", .make_ty, .fold_ty, .visit_ty;
+ SmallVector<ast::Stmt>: "statement", .make_stmts, lift .fold_stmt, lift .visit_stmt;
+ SmallVector<P<ast::Item>>: "item", .make_items, lift .fold_item, lift .visit_item;
SmallVector<ast::TraitItem>:
- "trait item", .make_trait_items, lift .fold_trait_item, lift .visit_trait_item,
- |_span| SmallVector::zero();
+ "trait item", .make_trait_items, lift .fold_trait_item, lift .visit_trait_item;
SmallVector<ast::ImplItem>:
- "impl item", .make_impl_items, lift .fold_impl_item, lift .visit_impl_item,
- |_span| SmallVector::zero();
+ "impl item", .make_impl_items, lift .fold_impl_item, lift .visit_impl_item;
}
impl MacroGenerable for Option<P<ast::Expr>> {
fn kind_name() -> &'static str { "expression" }
- fn dummy(_span: Span) -> Self { None }
fn make_with<'a>(result: Box<MacResult + 'a>) -> Option<Self> {
result.make_expr().map(Some)
}
&fld.cx.ecfg.features.unwrap());
}
- if path.segments.len() > 1 {
+ if path.segments.len() > 1 || path.global || !path.segments[0].parameters.is_empty() {
fld.cx.span_err(path.span, "expected macro name without module separators");
return None;
}
}
fn expand_multi_modified(a: Annotatable, fld: &mut MacroExpander) -> SmallVector<Annotatable> {
- let new_items: SmallVector<Annotatable> = match a {
+ match a {
Annotatable::Item(it) => match it.node {
ast::ItemKind::Mac(..) => {
it.and_then(|it| match it.node {
expand_impl_item(ii.unwrap(), fld).into_iter().
map(|ii| Annotatable::ImplItem(P(ii))).collect()
}
- };
-
- new_items.into_iter().flat_map(|a| decorate(a, fld)).collect()
-}
-
-fn decorate(a: Annotatable, fld: &mut MacroExpander) -> SmallVector<Annotatable> {
- let mut decorator_items = SmallVector::zero();
- let mut new_attrs = Vec::new();
- expand_decorators(a.clone(), fld, &mut decorator_items, &mut new_attrs);
-
- let mut new_items = SmallVector::one(a.fold_attrs(new_attrs));
- new_items.push_all(decorator_items);
- new_items
-}
-
-fn expand_decorators(a: Annotatable,
- fld: &mut MacroExpander,
- decorator_items: &mut SmallVector<Annotatable>,
- new_attrs: &mut Vec<ast::Attribute>)
-{
- for attr in a.attrs() {
- let mname = intern(&attr.name());
- match fld.cx.syntax_env.find(mname) {
- Some(rc) => match *rc {
- MultiDecorator(ref dec) => {
- attr::mark_used(&attr);
-
- fld.cx.bt_push(ExpnInfo {
- call_site: attr.span,
- callee: NameAndSpan {
- format: MacroAttribute(mname),
- span: Some(attr.span),
- // attributes can do whatever they like,
- // for now.
- allow_internal_unstable: true,
- }
- });
-
- let mut items: SmallVector<Annotatable> = SmallVector::zero();
- dec.expand(fld.cx,
- attr.span,
- &attr.node.value,
- &a,
- &mut |ann| items.push(ann));
-
- for item in items {
- for configured_item in item.fold_with(&mut fld.strip_unconfigured()) {
- decorator_items.extend(expand_annotatable(configured_item, fld));
- }
- }
-
- fld.cx.bt_pop();
- }
- _ => new_attrs.push((*attr).clone()),
- },
- _ => new_attrs.push((*attr).clone()),
- }
}
}
item = item.map_attrs(|mut attrs| {
for i in 0..attrs.len() {
if let Some(extension) = fld.cx.syntax_env.find(intern(&attrs[i].name())) {
- if let MultiModifier(..) = *extension {
- multi_modifier = Some((attrs.remove(i), extension));
- break;
+ match *extension {
+ MultiModifier(..) | MultiDecorator(..) => {
+ multi_modifier = Some((attrs.remove(i), extension));
+ break;
+ }
+ _ => {}
}
}
}
match multi_modifier {
None => expand_multi_modified(item, fld),
- Some((attr, extension)) => match *extension {
- MultiModifier(ref mac) => {
- attr::mark_used(&attr);
- fld.cx.bt_push(ExpnInfo {
- call_site: attr.span,
- callee: NameAndSpan {
- format: MacroAttribute(intern(&attr.name())),
- span: Some(attr.span),
- // attributes can do whatever they like, for now
- allow_internal_unstable: true,
- }
- });
- let modified = mac.expand(fld.cx, attr.span, &attr.node.value, item);
- fld.cx.bt_pop();
- modified.into_iter().flat_map(|it| expand_annotatable(it, fld)).collect()
- }
- _ => unreachable!(),
+ Some((attr, extension)) => {
+ attr::mark_used(&attr);
+ fld.cx.bt_push(ExpnInfo {
+ call_site: attr.span,
+ callee: NameAndSpan {
+ format: MacroAttribute(intern(&attr.name())),
+ span: Some(attr.span),
+ // attributes can do whatever they like, for now
+ allow_internal_unstable: true,
+ }
+ });
+
+ let modified = match *extension {
+ MultiModifier(ref mac) => mac.expand(fld.cx, attr.span, &attr.node.value, item),
+ MultiDecorator(ref mac) => {
+ let mut items = Vec::new();
+ mac.expand(fld.cx, attr.span, &attr.node.value, &item,
+ &mut |item| items.push(item));
+ items.push(item);
+ items
+ }
+ _ => unreachable!(),
+ };
+
+ fld.cx.bt_pop();
+ modified.into_iter().flat_map(|it| expand_annotatable(it, fld)).collect()
}
}
}
pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mut T) -> Expr {
Expr {
- id: folder.new_id(id),
node: match node {
ExprKind::Box(e) => {
ExprKind::Box(folder.fold_expr(e))
fields.move_map(|x| folder.fold_field(x)),
maybe_expr.map(|x| folder.fold_expr(x)))
},
- ExprKind::Paren(ex) => ExprKind::Paren(folder.fold_expr(ex)),
+ ExprKind::Paren(ex) => {
+ let sub_expr = folder.fold_expr(ex);
+ return Expr {
+ // Nodes that are equal modulo `Paren` sugar no-ops should have the same ids.
+ id: sub_expr.id,
+ node: ExprKind::Paren(sub_expr),
+ span: folder.new_span(span),
+ attrs: fold_attrs(attrs.into(), folder).into(),
+ };
+ }
ExprKind::Try(ex) => ExprKind::Try(folder.fold_expr(ex)),
},
+ id: folder.new_id(id),
span: folder.new_span(span),
attrs: fold_attrs(attrs.into(), folder).into(),
}
self.expect_one_of(edible, inedible)
}
- pub fn commit_stmt_expecting(&mut self, edible: token::Token) -> PResult<'a, ()> {
- self.commit_stmt(&[edible], &[])
- }
-
/// returns the span of expr, if it was not interpolated or the span of the interpolated token
fn interpolated_or_expr_span(&self,
expr: PResult<'a, P<Expr>>)
_ => { // all other kinds of statements:
let mut hi = span.hi;
if classify::stmt_ends_with_semi(&node) {
- self.commit_stmt_expecting(token::Semi)?;
+ self.commit_stmt(&[token::Semi], &[])?;
hi = self.last_span.hi;
}
/// This method helps to extract all the type parameters referenced from a
/// type. For a type parameter `<T>`, it looks for either a `TyPath` that
/// is not global and starts with `T`, or a `TyQPath`.
-fn find_type_parameters(ty: &ast::Ty, ty_param_names: &[ast::Name]) -> Vec<P<ast::Ty>> {
+fn find_type_parameters(ty: &ast::Ty, ty_param_names: &[ast::Name], span: Span, cx: &ExtCtxt)
+ -> Vec<P<ast::Ty>> {
use syntax::visit;
- struct Visitor<'a> {
+ struct Visitor<'a, 'b: 'a> {
+ cx: &'a ExtCtxt<'b>,
+ span: Span,
ty_param_names: &'a [ast::Name],
types: Vec<P<ast::Ty>>,
}
- impl<'a> visit::Visitor for Visitor<'a> {
+ impl<'a, 'b> visit::Visitor for Visitor<'a, 'b> {
fn visit_ty(&mut self, ty: &ast::Ty) {
match ty.node {
ast::TyKind::Path(_, ref path) if !path.global => {
visit::walk_ty(self, ty)
}
+
+ fn visit_mac(&mut self, mac: &ast::Mac) {
+ let span = Span { expn_id: self.span.expn_id, ..mac.span };
+ self.cx.span_err(span, "`derive` cannot be used on items with type macros");
+ }
}
let mut visitor = Visitor {
ty_param_names: ty_param_names,
types: Vec::new(),
+ span: span,
+ cx: cx,
};
visit::Visitor::visit_ty(&mut visitor, ty);
let mut processed_field_types = HashSet::new();
for field_ty in field_tys {
- let tys = find_type_parameters(&field_ty, &ty_param_names);
+ let tys = find_type_parameters(&field_ty, &ty_param_names, self.span, cx);
for ty in tys {
// if we have already handled this type, skip it
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(type_macros, concat_idents, rustc_attrs)]
-#![allow(unused)]
+#![feature(type_macros, concat_idents)]
-#[derive(Debug)] struct FooBar;
-#[derive(Debug)] struct Baz<T>(T, concat_idents!(Foo, Bar));
+#[derive(Debug)] //~ NOTE in this expansion
+struct Baz<T>(
+ concat_idents!(Foo, Bar) //~ ERROR `derive` cannot be used on items with type macros
+);
-#[rustc_error]
-fn main() {} //~ ERROR compilation successful
+fn main() {}
#[allow(unused_variables)]
fn main() {
let x2: i8 = --128; //~ error: literal out of range for i8
+ //~^ error: attempted to negate with overflow
let x = -3.40282348e+38_f32; //~ error: literal out of range for f32
let x = 3.40282348e+38_f32; //~ error: literal out of range for f32
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:expected macro name without module separators
-
fn main() {
- globnar::brotz!();
+ globnar::brotz!(); //~ ERROR expected macro name without module separators
+ ::foo!(); //~ ERROR expected macro name without module separators
+ foo::<T>!(); //~ ERROR expected macro name without module separators
}
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use foo.bar; //~ ERROR expected one of `::`, `;`, or `as`, found `.`
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "foo"]
+
+mod hidden {
+ #[derive(Clone)]
+ pub struct Foo;
+}
+
+#[doc(hidden)]
+pub mod __hidden {
+ pub use hidden::Foo;
+}
+
+// @has foo/trait.Clone.html
+// @!has - 'Foo'
+// @has implementors/foo/trait.Clone.js
+// @!has - 'Foo'
+pub use std::clone::Clone;
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "foo"]
+
+#[doc(hidden)]
+pub mod hidden {
+ pub struct Foo;
+
+ impl Foo {
+ #[doc(hidden)]
+ pub fn this_should_be_hidden() {}
+ }
+
+ pub struct Bar;
+
+ impl Bar {
+ fn this_should_be_hidden() {}
+ }
+}
+
+// @has foo/struct.Foo.html
+// @!has - 'Methods'
+// @!has - 'impl Foo'
+// @!has - 'this_should_be_hidden'
+pub use hidden::Foo;
+
+// @has foo/struct.Bar.html
+// @!has - 'Methods'
+// @!has - 'impl Bar'
+// @!has - 'this_should_be_hidden'
+pub use hidden::Bar;
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "foo"]
+
+mod second {
+ pub struct SomeTypeWithLongName;
+}
+
+// @has foo/index.html
+// @!has - SomeTypeWithLongName
+// @has foo/struct.SomeType.html
+// @!has - SomeTypeWithLongName
+// @!has foo/struct.SomeTypeWithLongName.html
+pub use second::{SomeTypeWithLongName as SomeType};
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "foo"]
+
+pub use std::marker::Send;
+
+// @!has foo/index.html 'Implementations'
match config.mode {
DebugInfoLldb => {
+ if let Some(lldb_version) = config.lldb_version.as_ref() {
+ if is_blacklisted_lldb_version(&lldb_version[..]) {
+ println!("WARNING: The used version of LLDB ({}) has a \
+ known issue that breaks debuginfo tests. See \
+ issue #32520 for more information. Skipping all \
+ LLDB-based tests!",
+ lldb_version);
+ return
+ }
+ }
+
// Some older versions of LLDB seem to have problems with multiple
// instances running in parallel, so only run one test thread at a
// time.
}
None
}
+
+fn is_blacklisted_lldb_version(version: &str) -> bool {
+ version == "350"
+}
projects / rust.git / commitdiff