Still needs values of F_DUPFD_CLOEXEC on other OSs.
For Bitrig, NetBSD and OpenBSD the constant was incorrectly in posix01, when
it's actually posix08. In order to maintain backwards-compatiblity, the
constant was only copied, not moved.
cc #24237
use syntax::ast::{Block, FnDecl, NodeId};
use syntax::ast;
use syntax::codemap::Span;
-use syntax::visit;
+use syntax::visit::FnKind;
/// An FnLikeNode is a Node that is like a fn, in that it has a decl
/// and a body (as well as a NodeId, a span, etc).
pub struct FnParts<'a> {
pub decl: &'a FnDecl,
pub body: &'a Block,
- pub kind: visit::FnKind<'a>,
+ pub kind: FnKind<'a>,
pub span: Span,
pub id: NodeId,
}
|c: ClosureParts| c.id)
}
- pub fn kind(self) -> visit::FnKind<'a> {
- let item = |p: ItemFnParts<'a>| -> visit::FnKind<'a> {
- visit::FkItemFn(p.ident, p.generics, p.unsafety, p.constness, p.abi, p.vis)
+ pub fn kind(self) -> FnKind<'a> {
+ let item = |p: ItemFnParts<'a>| -> FnKind<'a> {
+ FnKind::ItemFn(p.ident, p.generics, p.unsafety, p.constness, p.abi, p.vis)
};
let closure = |_: ClosureParts| {
- visit::FkClosure
+ FnKind::Closure
};
let method = |_, ident, sig: &'a ast::MethodSig, vis, _, _| {
- visit::FkMethod(ident, sig, vis)
+ FnKind::Method(ident, sig, vis)
};
self.handle(item, method, closure)
}
NodeImplItem(ii) => PathName(ii.ident.name),
NodeTraitItem(ti) => PathName(ti.ident.name),
NodeVariant(v) => PathName(v.node.name.name),
+ NodeLifetime(lt) => PathName(lt.name),
_ => panic!("no path elem for {:?}", node)
}
}
use syntax::visit::{Visitor, FnKind};
use syntax::parse::token::InternedString;
use syntax::{ast, ast_util, visit};
+use syntax::diagnostic;
/// Information about the registered lints.
///
match (sess, from_plugin) {
// We load builtin lints first, so a duplicate is a compiler bug.
// Use early_error when handling -W help with no crate.
- (None, _) => early_error(&msg[..]),
+ (None, _) => early_error(diagnostic::Auto, &msg[..]),
(Some(sess), false) => sess.bug(&msg[..]),
// A duplicate name from a plugin is a user error.
match (sess, from_plugin) {
// We load builtin lints first, so a duplicate is a compiler bug.
// Use early_error when handling -W help with no crate.
- (None, _) => early_error(&msg[..]),
+ (None, _) => early_error(diagnostic::Auto, &msg[..]),
(Some(sess), false) => sess.bug(&msg[..]),
// A duplicate name from a plugin is a user error.
use syntax::ast;
use syntax::codemap::Span;
-use syntax::visit::{self, Visitor};
+use syntax::visit::{self, FnKind, Visitor};
use std::collections::hash_map::Entry;
use std::cmp::Ordering;
}
fn fn_like(&mut self,
- fk: visit::FnKind,
+ fk: FnKind,
fd: &ast::FnDecl,
b: &ast::Block,
s: Span,
}
let mode = match fk {
- visit::FkItemFn(_, _, _, ast::Constness::Const, _, _) => {
+ FnKind::ItemFn(_, _, _, ast::Constness::Const, _, _) => {
Mode::ConstFn
}
- visit::FkMethod(_, m, _) => {
+ FnKind::Method(_, m, _) => {
if m.constness == ast::Constness::Const {
Mode::ConstFn
} else {
}
fn visit_fn(&mut self,
- fk: visit::FnKind<'v>,
+ fk: FnKind<'v>,
fd: &'v ast::FnDecl,
b: &'v ast::Block,
s: Span,
sp: Span,
fn_id: NodeId) {
match kind {
- visit::FkClosure => {}
+ FnKind::Closure => {}
_ => cx.param_env = ParameterEnvironment::for_item(cx.tcx, fn_id),
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![allow(non_camel_case_types)]
+//#![allow(non_camel_case_types)]
use self::ConstVal::*;
use self::ErrKind::*;
use util::num::ToPrimitive;
use syntax::ast::{self, Expr};
-use syntax::codemap::Span;
+use syntax::codemap::{self, Span};
use syntax::parse::token::InternedString;
use syntax::ptr::P;
-use syntax::{codemap, visit};
+use syntax::visit::FnKind;
use std::borrow::{Cow, IntoCow};
use std::num::wrapping::OverflowingOps;
};
match fn_like.kind() {
- visit::FkItemFn(_, _, _, ast::Constness::Const, _, _) => {
+ FnKind::ItemFn(_, _, _, ast::Constness::Const, _, _) => {
Some(fn_like)
}
- visit::FkMethod(_, m, _) => {
+ FnKind::Method(_, m, _) => {
if m.constness == ast::Constness::Const {
Some(fn_like)
} else {
use syntax::ast;
use syntax::codemap::Span;
use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
#[derive(Copy, Clone)]
struct UnsafeContext {
}
impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
- fn visit_fn(&mut self, fn_kind: visit::FnKind<'v>, fn_decl: &'v ast::FnDecl,
+ fn visit_fn(&mut self, fn_kind: FnKind<'v>, fn_decl: &'v ast::FnDecl,
block: &'v ast::Block, span: Span, _: ast::NodeId) {
let (is_item_fn, is_unsafe_fn) = match fn_kind {
- visit::FkItemFn(_, _, unsafety, _, _, _) =>
+ FnKind::ItemFn(_, _, unsafety, _, _, _) =>
(true, unsafety == ast::Unsafety::Unsafe),
- visit::FkMethod(_, sig, _) =>
+ FnKind::Method(_, sig, _) =>
(true, sig.unsafety == ast::Unsafety::Unsafe),
_ => (false, false),
};
use syntax::abi::RustIntrinsic;
use syntax::ast;
use syntax::codemap::Span;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
use syntax::visit;
pub fn check_crate(tcx: &ctxt) {
}
impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> {
- fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v ast::FnDecl,
b: &'v ast::Block, s: Span, id: ast::NodeId) {
match fk {
- visit::FkItemFn(..) | visit::FkMethod(..) => {
+ FnKind::ItemFn(..) | FnKind::Method(..) => {
let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
self.param_envs.push(param_env);
visit::walk_fn(self, fk, fd, b, s);
self.param_envs.pop();
}
- visit::FkClosure(..) => {
+ FnKind::Closure(..) => {
visit::walk_fn(self, fk, fd, b, s);
}
}
use syntax::parse::token::special_idents;
use syntax::print::pprust::lifetime_to_string;
use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
use util::nodemap::NodeMap;
#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)]
replace(&mut self.labels_in_fn, saved);
}
- fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+ fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v ast::FnDecl,
b: &'v ast::Block, s: Span, _: ast::NodeId) {
match fk {
- visit::FkItemFn(_, generics, _, _, _, _) => {
+ FnKind::ItemFn(_, generics, _, _, _, _) => {
self.visit_early_late(subst::FnSpace, generics, |this| {
this.walk_fn(fk, fd, b, s)
})
}
- visit::FkMethod(_, sig, _) => {
+ FnKind::Method(_, sig, _) => {
self.visit_early_late(subst::FnSpace, &sig.generics, |this| {
this.walk_fn(fk, fd, b, s)
})
}
- visit::FkClosure(..) => {
+ FnKind::Closure(..) => {
self.walk_fn(fk, fd, b, s)
}
}
// labels of the function body and swaps them in before visiting
// the function body itself.
fn walk_fn<'b>(&mut self,
- fk: visit::FnKind,
+ fk: FnKind,
fd: &ast::FnDecl,
fb: &'b ast::Block,
_span: Span) {
match fk {
- visit::FkItemFn(_, generics, _, _, _, _) => {
+ FnKind::ItemFn(_, generics, _, _, _, _) => {
visit::walk_fn_decl(self, fd);
self.visit_generics(generics);
}
- visit::FkMethod(_, sig, _) => {
+ FnKind::Method(_, sig, _) => {
visit::walk_fn_decl(self, fd);
self.visit_generics(&sig.generics);
self.visit_explicit_self(&sig.explicit_self);
}
- visit::FkClosure(..) => {
+ FnKind::Closure(..) => {
visit::walk_fn_decl(self, fd);
}
}
}
#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash,
- RustcEncodable, RustcDecodable, Copy, Debug)]
+ RustcEncodable, RustcDecodable, Copy)]
pub enum BoundRegion {
/// An anonymous region parameter for a given fn (&T)
BrAnon(u32),
pub object_lifetime_default: ObjectLifetimeDefault,
}
-#[derive(Clone, Debug)]
+#[derive(Clone)]
pub struct RegionParameterDef {
pub name: ast::Name,
pub def_id: DefId,
$struct_name { $($opt: $init),* }
}
- pub fn $buildfn(matches: &getopts::Matches) -> $struct_name
+ pub fn $buildfn(matches: &getopts::Matches, color: ColorConfig) -> $struct_name
{
let mut op = $defaultfn();
for option in matches.opt_strs($prefix) {
if !setter(&mut op, value) {
match (value, opt_type_desc) {
(Some(..), None) => {
- early_error(&format!("{} option `{}` takes no \
- value", $outputname, key))
+ early_error(color, &format!("{} option `{}` takes no \
+ value", $outputname, key))
}
(None, Some(type_desc)) => {
- early_error(&format!("{0} option `{1}` requires \
- {2} ({3} {1}=<value>)",
- $outputname, key,
- type_desc, $prefix))
+ early_error(color, &format!("{0} option `{1}` requires \
+ {2} ({3} {1}=<value>)",
+ $outputname, key,
+ type_desc, $prefix))
}
(Some(value), Some(type_desc)) => {
- early_error(&format!("incorrect value `{}` for {} \
- option `{}` - {} was expected",
- value, $outputname,
- key, type_desc))
+ early_error(color, &format!("incorrect value `{}` for {} \
+ option `{}` - {} was expected",
+ value, $outputname,
+ key, type_desc))
}
(None, None) => unreachable!()
}
break;
}
if !found {
- early_error(&format!("unknown {} option: `{}`",
- $outputname, key));
+ early_error(color, &format!("unknown {} option: `{}`",
+ $outputname, key));
}
}
return op;
}
pub fn build_session_options(matches: &getopts::Matches) -> Options {
+ let color = match matches.opt_str("color").as_ref().map(|s| &s[..]) {
+ Some("auto") => Auto,
+ Some("always") => Always,
+ Some("never") => Never,
+
+ None => Auto,
+
+ Some(arg) => {
+ early_error(Auto, &format!("argument for --color must be auto, always \
+ or never (instead was `{}`)",
+ arg))
+ }
+ };
+
let unparsed_crate_types = matches.opt_strs("crate-type");
let crate_types = parse_crate_types_from_list(unparsed_crate_types)
- .unwrap_or_else(|e| early_error(&e[..]));
+ .unwrap_or_else(|e| early_error(color, &e[..]));
let mut lint_opts = vec!();
let mut describe_lints = false;
let lint_cap = matches.opt_str("cap-lints").map(|cap| {
lint::Level::from_str(&cap).unwrap_or_else(|| {
- early_error(&format!("unknown lint level: `{}`", cap))
+ early_error(color, &format!("unknown lint level: `{}`", cap))
})
});
- let debugging_opts = build_debugging_options(matches);
+ let debugging_opts = build_debugging_options(matches, color);
let parse_only = debugging_opts.parse_only;
let no_trans = debugging_opts.no_trans;
"link" => OutputTypeExe,
"dep-info" => OutputTypeDepInfo,
_ => {
- early_error(&format!("unknown emission type: `{}`",
- part))
+ early_error(color, &format!("unknown emission type: `{}`",
+ part))
}
};
output_types.push(output_type)
output_types.push(OutputTypeExe);
}
- let cg = build_codegen_options(matches);
+ let cg = build_codegen_options(matches, color);
let sysroot_opt = matches.opt_str("sysroot").map(|m| PathBuf::from(&m));
let target = matches.opt_str("target").unwrap_or(
let opt_level = {
if matches.opt_present("O") {
if cg.opt_level.is_some() {
- early_error("-O and -C opt-level both provided");
+ early_error(color, "-O and -C opt-level both provided");
}
Default
} else {
Some(2) => Default,
Some(3) => Aggressive,
Some(arg) => {
- early_error(&format!("optimization level needs to be \
- between 0-3 (instead was `{}`)",
- arg));
+ early_error(color, &format!("optimization level needs to be \
+ between 0-3 (instead was `{}`)",
+ arg));
}
}
}
let gc = debugging_opts.gc;
let debuginfo = if matches.opt_present("g") {
if cg.debuginfo.is_some() {
- early_error("-g and -C debuginfo both provided");
+ early_error(color, "-g and -C debuginfo both provided");
}
FullDebugInfo
} else {
Some(1) => LimitedDebugInfo,
Some(2) => FullDebugInfo,
Some(arg) => {
- early_error(&format!("debug info level needs to be between \
- 0-2 (instead was `{}`)",
- arg));
+ early_error(color, &format!("debug info level needs to be between \
+ 0-2 (instead was `{}`)",
+ arg));
}
}
};
let mut search_paths = SearchPaths::new();
for s in &matches.opt_strs("L") {
- search_paths.add_path(&s[..]);
+ search_paths.add_path(&s[..], color);
}
let libs = matches.opt_strs("l").into_iter().map(|s| {
(Some(name), "framework") => (name, cstore::NativeFramework),
(Some(name), "static") => (name, cstore::NativeStatic),
(_, s) => {
- early_error(&format!("unknown library kind `{}`, expected \
- one of dylib, framework, or static",
- s));
+ early_error(color, &format!("unknown library kind `{}`, expected \
+ one of dylib, framework, or static",
+ s));
}
};
(name.to_string(), kind)
"file-names" => PrintRequest::FileNames,
"sysroot" => PrintRequest::Sysroot,
req => {
- early_error(&format!("unknown print request `{}`", req))
+ early_error(color, &format!("unknown print request `{}`", req))
}
}
}).collect::<Vec<_>>();
if !cg.remark.is_empty() && debuginfo == NoDebugInfo {
- early_warn("-C remark will not show source locations without \
- --debuginfo");
+ early_warn(color, "-C remark will not show source locations without \
+ --debuginfo");
}
- let color = match matches.opt_str("color").as_ref().map(|s| &s[..]) {
- Some("auto") => Auto,
- Some("always") => Always,
- Some("never") => Never,
-
- None => Auto,
-
- Some(arg) => {
- early_error(&format!("argument for --color must be auto, always \
- or never (instead was `{}`)",
- arg))
- }
- };
-
let mut externs = HashMap::new();
for arg in &matches.opt_strs("extern") {
let mut parts = arg.splitn(2, '=');
let name = match parts.next() {
Some(s) => s,
- None => early_error("--extern value must not be empty"),
+ None => early_error(color, "--extern value must not be empty"),
};
let location = match parts.next() {
Some(s) => s,
- None => early_error("--extern value must be of the format `foo=bar`"),
+ None => early_error(color, "--extern value must be of the format `foo=bar`"),
};
externs.entry(name.to_string()).or_insert(vec![]).push(location.to_string());
diagnostic::expect(sess.diagnostic(), opt, msg)
}
-pub fn early_error(msg: &str) -> ! {
- let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto, None);
+pub fn early_error(color: diagnostic::ColorConfig, msg: &str) -> ! {
+ let mut emitter = diagnostic::EmitterWriter::stderr(color, None);
emitter.emit(None, msg, None, diagnostic::Fatal);
panic!(diagnostic::FatalError);
}
-pub fn early_warn(msg: &str) {
- let mut emitter = diagnostic::EmitterWriter::stderr(diagnostic::Auto, None);
+pub fn early_warn(color: diagnostic::ColorConfig, msg: &str) {
+ let mut emitter = diagnostic::EmitterWriter::stderr(color, None);
emitter.emit(None, msg, None, diagnostic::Warning);
}
use std::slice;
use std::path::{Path, PathBuf};
use session::early_error;
+use syntax::diagnostic;
#[derive(Clone, Debug)]
pub struct SearchPaths {
SearchPaths { paths: Vec::new() }
}
- pub fn add_path(&mut self, path: &str) {
+ pub fn add_path(&mut self, path: &str, color: diagnostic::ColorConfig) {
let (kind, path) = if path.starts_with("native=") {
(PathKind::Native, &path["native=".len()..])
} else if path.starts_with("crate=") {
(PathKind::All, path)
};
if path.is_empty() {
- early_error("empty search path given via `-L`");
+ early_error(color, "empty search path given via `-L`");
}
self.paths.push((kind, PathBuf::from(path)));
}
impl<'tcx> fmt::Debug for ty::TypeParameterDef<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "TypeParameterDef({:?}, {:?}/{})",
- self.def_id, self.space, self.index)
+ write!(f, "TypeParameterDef({}, {}:{}, {:?}/{})",
+ self.name,
+ self.def_id.krate, self.def_id.node,
+ self.space, self.index)
+ }
+}
+
+impl fmt::Debug for ty::RegionParameterDef {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "RegionParameterDef({}, {}:{}, {:?}/{}, {:?})",
+ self.name,
+ self.def_id.krate, self.def_id.node,
+ self.space, self.index,
+ self.bounds)
}
}
}
}
+impl fmt::Debug for ty::BoundRegion {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ BrAnon(n) => write!(f, "BrAnon({:?})", n),
+ BrFresh(n) => write!(f, "BrFresh({:?})", n),
+ BrNamed(did, name) => {
+ write!(f, "BrNamed({}:{}, {:?})", did.krate, did.node, name)
+ }
+ BrEnv => "BrEnv".fmt(f),
+ }
+ }
+}
+
impl fmt::Debug for ty::Region {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl,
b: &'v Block, s: Span, id: ast::NodeId) {
match fk {
- visit::FkItemFn(..) |
- visit::FkMethod(..) => {
+ FnKind::ItemFn(..) |
+ FnKind::Method(..) => {
let new_free_region_map = self.tcx.free_region_map(id);
let old_free_region_map =
mem::replace(&mut self.free_region_map, new_free_region_map);
self.free_region_map = old_free_region_map;
}
- visit::FkClosure => {
+ FnKind::Closure => {
borrowck_fn(self, fk, fd, b, s, id);
}
}
None => return
};
- let descriptions = diagnostics_registry();
+ let sopts = config::build_session_options(&matches);
- do_or_return!(callbacks.early_callback(&matches, &descriptions));
+ let descriptions = diagnostics_registry();
- let sopts = config::build_session_options(&matches);
+ do_or_return!(callbacks.early_callback(&matches, &descriptions, sopts.color));
let (odir, ofile) = make_output(&matches);
let (input, input_file_path) = match make_input(&matches.free) {
// else (e.g., selecting input and output).
fn early_callback(&mut self,
_: &getopts::Matches,
- _: &diagnostics::registry::Registry)
+ _: &diagnostics::registry::Registry,
+ _: diagnostic::ColorConfig)
-> Compilation {
Compilation::Continue
}
impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
fn early_callback(&mut self,
matches: &getopts::Matches,
- descriptions: &diagnostics::registry::Registry)
+ descriptions: &diagnostics::registry::Registry,
+ color: diagnostic::ColorConfig)
-> Compilation {
match matches.opt_str("explain") {
Some(ref code) => {
print!("{}", &description[1..]);
}
None => {
- early_error(&format!("no extended information for {}", code));
+ early_error(color, &format!("no extended information for {}", code));
}
}
return Compilation::Stop;
if should_stop == Compilation::Stop {
return None;
}
- early_error("no input filename given");
+ early_error(sopts.color, "no input filename given");
}
1 => panic!("make_input should have provided valid inputs"),
- _ => early_error("multiple input filenames provided")
+ _ => early_error(sopts.color, "multiple input filenames provided")
}
None
println!("{}", String::from_utf8(v).unwrap());
}
&Input::Str(_) => {
- early_error("cannot list metadata for stdin");
+ early_error(sess.opts.color, "cannot list metadata for stdin");
}
}
return Compilation::Stop;
PrintRequest::CrateName => {
let input = match input {
Some(input) => input,
- None => early_error("no input file provided"),
+ None => early_error(sess.opts.color, "no input file provided"),
};
let attrs = attrs.as_ref().unwrap();
let t_outputs = driver::build_output_filenames(input,
&opt.opt_group.short_name
};
if m.opt_present(opt_name) {
- early_error(&format!("use of unstable option '{}' requires \
- -Z unstable-options", opt_name));
+ early_error(diagnostic::Auto, &format!("use of unstable option '{}' \
+ requires -Z unstable-options",
+ opt_name));
}
}
}
m
}
- Err(f) => early_error(&f.to_string())
+ Err(f) => early_error(diagnostic::Auto, &f.to_string())
}
}
use syntax::feature_gate::{KNOWN_ATTRIBUTES, AttributeType};
use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
use syntax::ptr::P;
-use syntax::visit::{self, Visitor};
+use syntax::visit::{self, FnKind, Visitor};
// hardwired lints from librustc
pub use lint::builtin::*;
}
fn check_fn(&mut self, cx: &Context,
- fk: visit::FnKind, _: &ast::FnDecl,
+ fk: FnKind, _: &ast::FnDecl,
_: &ast::Block, span: Span, id: ast::NodeId) {
match fk {
- visit::FkMethod(ident, _, _) => match method_context(cx, id, span) {
+ FnKind::Method(ident, _, _) => match method_context(cx, id, span) {
MethodContext::PlainImpl => {
self.check_snake_case(cx, "method", &ident.name.as_str(), Some(span))
},
},
_ => (),
},
- visit::FkItemFn(ident, _, _, _, _, _) => {
+ FnKind::ItemFn(ident, _, _, _, _, _) => {
self.check_snake_case(cx, "function", &ident.name.as_str(), Some(span))
},
_ => (),
}
}
- fn check_fn(&mut self, cx: &Context, fk: visit::FnKind, _: &ast::FnDecl,
+ fn check_fn(&mut self, cx: &Context, fk: FnKind, _: &ast::FnDecl,
_: &ast::Block, span: Span, _: ast::NodeId) {
match fk {
- visit::FkItemFn(_, _, ast::Unsafety::Unsafe, _, _, _) =>
+ FnKind::ItemFn(_, _, ast::Unsafety::Unsafe, _, _, _) =>
cx.span_lint(UNSAFE_CODE, span, "declaration of an `unsafe` function"),
- visit::FkMethod(_, sig, _) => {
+ FnKind::Method(_, sig, _) => {
if sig.unsafety == ast::Unsafety::Unsafe {
cx.span_lint(UNSAFE_CODE, span, "implementation of an `unsafe` method")
}
}
fn check_fn(&mut self, cx: &Context,
- _: visit::FnKind, decl: &ast::FnDecl,
+ _: FnKind, decl: &ast::FnDecl,
_: &ast::Block, _: Span, _: ast::NodeId) {
for a in &decl.inputs {
self.check_unused_mut_pat(cx, slice::ref_slice(&a.pat));
lint_array![UNCONDITIONAL_RECURSION]
}
- fn check_fn(&mut self, cx: &Context, fn_kind: visit::FnKind, _: &ast::FnDecl,
+ fn check_fn(&mut self, cx: &Context, fn_kind: FnKind, _: &ast::FnDecl,
blk: &ast::Block, sp: Span, id: ast::NodeId) {
type F = for<'tcx> fn(&ty::ctxt<'tcx>,
ast::NodeId, ast::NodeId, ast::Ident, ast::NodeId) -> bool;
let method = match fn_kind {
- visit::FkItemFn(..) => None,
- visit::FkMethod(..) => {
+ FnKind::ItemFn(..) => None,
+ FnKind::Method(..) => {
cx.tcx.impl_or_trait_item(DefId::local(id)).as_opt_method()
}
// closures can't recur, so they don't matter.
- visit::FkClosure => return
+ FnKind::Closure => return
};
// Walk through this function (say `f`) looking to see if
use syntax::parse::token::{self, special_names, special_idents};
use syntax::ptr::P;
use syntax::codemap::{self, Span, Pos};
-use syntax::visit::{self, Visitor};
+use syntax::visit::{self, FnKind, Visitor};
use std::collections::{HashMap, HashSet};
use std::collections::hash_map::Entry::{Occupied, Vacant};
});
}
fn visit_fn(&mut self,
- function_kind: visit::FnKind<'v>,
+ function_kind: FnKind<'v>,
declaration: &'v FnDecl,
block: &'v Block,
_: Span,
node_id: NodeId) {
let rib_kind = match function_kind {
- visit::FkItemFn(_, generics, _, _, _, _) => {
+ FnKind::ItemFn(_, generics, _, _, _, _) => {
self.visit_generics(generics);
ItemRibKind
}
- visit::FkMethod(_, sig, _) => {
+ FnKind::Method(_, sig, _) => {
self.visit_generics(&sig.generics);
self.visit_explicit_self(&sig.explicit_self);
MethodRibKind
}
- visit::FkClosure(..) => ClosureRibKind(node_id)
+ FnKind::Closure(..) => ClosureRibKind(node_id)
};
self.resolve_function(rib_kind, declaration, block);
}
repr
}
-macro_rules! repeat_u8_as_u32 {
- ($name:expr) => { (($name as u32) << 24 |
- ($name as u32) << 16 |
- ($name as u32) << 8 |
- ($name as u32)) }
+const fn repeat_u8_as_u32(val: u8) -> u32 {
+ (val as u32) << 24 | (val as u32) << 16 | (val as u32) << 8 | val as u32
}
-macro_rules! repeat_u8_as_u64 {
- ($name:expr) => { ((repeat_u8_as_u32!($name) as u64) << 32 |
- (repeat_u8_as_u32!($name) as u64)) }
+
+const fn repeat_u8_as_u64(val: u8) -> u64 {
+ (repeat_u8_as_u32(val) as u64) << 32 | repeat_u8_as_u32(val) as u64
}
/// `DTOR_NEEDED_HINT` is a stack-local hint that just means
pub const DTOR_MOVED_HINT: u8 = 0x2d;
pub const DTOR_NEEDED: u8 = 0xd4;
-pub const DTOR_NEEDED_U32: u32 = repeat_u8_as_u32!(DTOR_NEEDED);
-pub const DTOR_NEEDED_U64: u64 = repeat_u8_as_u64!(DTOR_NEEDED);
+pub const DTOR_NEEDED_U32: u32 = repeat_u8_as_u32(DTOR_NEEDED);
+pub const DTOR_NEEDED_U64: u64 = repeat_u8_as_u64(DTOR_NEEDED);
#[allow(dead_code)]
pub fn dtor_needed_usize(ccx: &CrateContext) -> usize {
match &ccx.tcx().sess.target.target.target_pointer_width[..] {
}
pub const DTOR_DONE: u8 = 0x1d;
-pub const DTOR_DONE_U32: u32 = repeat_u8_as_u32!(DTOR_DONE);
-pub const DTOR_DONE_U64: u64 = repeat_u8_as_u64!(DTOR_DONE);
+pub const DTOR_DONE_U32: u32 = repeat_u8_as_u32(DTOR_DONE);
+pub const DTOR_DONE_U64: u64 = repeat_u8_as_u64(DTOR_DONE);
#[allow(dead_code)]
pub fn dtor_done_usize(ccx: &CrateContext) -> usize {
match &ccx.tcx().sess.target.target.target_pointer_width[..] {
let mut structural_to_nomimal = HashMap::new();
let sig = tcx.no_late_bound_regions(i_ty.ty.fn_sig()).unwrap();
+ if intr.inputs.len() != sig.inputs.len() {
+ span_err!(tcx.sess, it.span, E0444,
+ "platform-specific intrinsic has invalid number of \
+ arguments: found {}, expected {}",
+ intr.inputs.len(), sig.inputs.len());
+ return
+ }
let input_pairs = intr.inputs.iter().zip(&sig.inputs);
for (i, (expected_arg, arg)) in input_pairs.enumerate() {
match_intrinsic_type_to_type(tcx, &format!("argument {}", i + 1), it.span,
use syntax::codemap::{DUMMY_SP, Span};
use syntax::parse::token::{special_idents};
use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::visit::{FnKind, Visitor};
pub struct CheckTypeWellFormedVisitor<'ccx, 'tcx:'ccx> {
ccx: &'ccx CrateCtxt<'ccx, 'tcx>,
}
fn visit_fn(&mut self,
- fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+ fk: FnKind<'v>, fd: &'v ast::FnDecl,
b: &'v ast::Block, span: Span, id: ast::NodeId) {
match fk {
- visit::FkClosure | visit::FkItemFn(..) => {}
- visit::FkMethod(..) => {
+ FnKind::Closure | FnKind::ItemFn(..) => {}
+ FnKind::Method(..) => {
match self.tcx().impl_or_trait_item(DefId::local(id)) {
ty::ImplOrTraitItem::MethodTraitItem(ty_method) => {
reject_shadowing_type_parameters(self.tcx(), span, &ty_method.generics)
parameters. You can read more about it in the API documentation:
https://doc.rust-lang.org/std/marker/struct.PhantomData.html
-"##
+"##,
+
+E0444: r##"
+A platform-specific intrinsic function has wrong number of arguments.
+Erroneous code example:
+
+```
+#[repr(simd)]
+struct f64x2(f64, f64);
+
+extern "platform-intrinsic" {
+ fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32;
+ // error: platform-specific intrinsic has invalid number of arguments
+}
+```
+
+Please refer to the function declaration to see if it corresponds
+with yours. Example:
+
+```
+#[repr(simd)]
+struct f64x2(f64, f64);
+
+extern "platform-intrinsic" {
+ fn x86_mm_movemask_pd(x: f64x2) -> i32; // ok!
+}
+```
+"##,
}
use serialize::Decodable;
use serialize::json::{self, Json};
use rustc::session::search_paths::SearchPaths;
+use syntax::diagnostic;
// reexported from `clean` so it can be easily updated with the mod itself
pub use clean::SCHEMA_VERSION;
let mut libs = SearchPaths::new();
for s in &matches.opt_strs("L") {
- libs.add_path(s);
+ libs.add_path(s, diagnostic::Auto);
}
let externs = match parse_externs(&matches) {
Ok(ex) => ex,
// First, parse the crate and extract all relevant information.
let mut paths = SearchPaths::new();
for s in &matches.opt_strs("L") {
- paths.add_path(s);
+ paths.add_path(s, diagnostic::Auto);
}
let cfgs = matches.opt_strs("cfg");
let triple = matches.opt_str("target");
pub span: Span,
}
-
-// NB PartialEq method appears below.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)]
pub struct Ty {
pub id: NodeId,
use parse::token;
use print::pprust;
use ptr::P;
-use visit::Visitor;
+use visit::{FnKind, Visitor};
use visit;
use std::cmp;
node_id: NodeId) {
if !self.pass_through_items {
match function_kind {
- visit::FkMethod(..) if self.visited_outermost => return,
- visit::FkMethod(..) => self.visited_outermost = true,
+ FnKind::Method(..) if self.visited_outermost => return,
+ FnKind::Method(..) => self.visited_outermost = true,
_ => {}
}
}
self.operation.visit_id(node_id);
match function_kind {
- visit::FkItemFn(_, generics, _, _, _, _) => {
+ FnKind::ItemFn(_, generics, _, _, _, _) => {
self.visit_generics_helper(generics)
}
- visit::FkMethod(_, sig, _) => {
+ FnKind::Method(_, sig, _) => {
self.visit_generics_helper(&sig.generics)
}
- visit::FkClosure => {}
+ FnKind::Closure => {}
}
for argument in &function_declaration.inputs {
span);
if !self.pass_through_items {
- if let visit::FkMethod(..) = function_kind {
+ if let FnKind::Method(..) = function_kind {
self.visited_outermost = false;
}
}
}
/// Computes the id range for a single fn body, ignoring nested items.
-pub fn compute_id_range_for_fn_body(fk: visit::FnKind,
+pub fn compute_id_range_for_fn_body(fk: FnKind,
decl: &FnDecl,
body: &Block,
sp: Span,
use codemap::{CodeMap, Span};
use diagnostic::SpanHandler;
use visit;
-use visit::Visitor;
+use visit::{FnKind, Visitor};
use parse::token::{self, InternedString};
use std::ascii::AsciiExt;
}
fn visit_fn(&mut self,
- fn_kind: visit::FnKind<'v>,
+ fn_kind: FnKind<'v>,
fn_decl: &'v ast::FnDecl,
block: &'v ast::Block,
span: Span,
_node_id: NodeId) {
// check for const fn declarations
match fn_kind {
- visit::FkItemFn(_, _, _, ast::Constness::Const, _, _) => {
+ FnKind::ItemFn(_, _, _, ast::Constness::Const, _, _) => {
self.gate_feature("const_fn", span, "const fn is unstable");
}
_ => {
}
match fn_kind {
- visit::FkItemFn(_, _, _, _, abi, _) if abi == Abi::RustIntrinsic => {
+ FnKind::ItemFn(_, _, _, _, abi, _) if abi == Abi::RustIntrinsic => {
self.gate_feature("intrinsics",
span,
"intrinsics are subject to change")
}
- visit::FkItemFn(_, _, _, _, abi, _) |
- visit::FkMethod(_, &ast::MethodSig { abi, .. }, _) if abi == Abi::RustCall => {
+ FnKind::ItemFn(_, _, _, _, abi, _) |
+ FnKind::Method(_, &ast::MethodSig { abi, .. }, _) if abi == Abi::RustCall => {
self.gate_feature("unboxed_closures",
span,
"rust-call ABI is subject to change")
return self.parse_loop_expr(None, lo);
}
if try!(self.eat_keyword(keywords::Continue) ){
- let lo = self.span.lo;
let ex = if self.token.is_lifetime() {
let lifetime = self.get_lifetime();
try!(self.bump());
//! instance, a walker looking for item names in a module will miss all of
//! those that are created by the expansion of a macro.
-pub use self::FnKind::*;
-
use abi::Abi;
use ast::*;
use ast;
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum FnKind<'a> {
/// fn foo() or extern "Abi" fn foo()
- FkItemFn(Ident, &'a Generics, Unsafety, Constness, Abi, Visibility),
+ ItemFn(Ident, &'a Generics, Unsafety, Constness, Abi, Visibility),
/// fn foo(&self)
- FkMethod(Ident, &'a MethodSig, Option<Visibility>),
+ Method(Ident, &'a MethodSig, Option<Visibility>),
/// |x, y| {}
- FkClosure,
+ Closure,
}
/// Each method of the Visitor trait is a hook to be potentially
visitor.visit_expr(&**expr);
}
ItemFn(ref declaration, unsafety, constness, abi, ref generics, ref body) => {
- visitor.visit_fn(FkItemFn(item.ident, generics, unsafety,
- constness, abi, item.vis),
+ visitor.visit_fn(FnKind::ItemFn(item.ident, generics, unsafety,
+ constness, abi, item.vis),
&**declaration,
&**body,
item.span,
walk_fn_decl(visitor, function_declaration);
match function_kind {
- FkItemFn(_, generics, _, _, _, _) => {
+ FnKind::ItemFn(_, generics, _, _, _, _) => {
visitor.visit_generics(generics);
}
- FkMethod(_, sig, _) => {
+ FnKind::Method(_, sig, _) => {
visitor.visit_generics(&sig.generics);
visitor.visit_explicit_self(&sig.explicit_self);
}
- FkClosure(..) => {}
+ FnKind::Closure(..) => {}
}
visitor.visit_block(function_body)
walk_fn_decl(visitor, &sig.decl);
}
MethodTraitItem(ref sig, Some(ref body)) => {
- visitor.visit_fn(FkMethod(trait_item.ident, sig, None), &sig.decl,
+ visitor.visit_fn(FnKind::Method(trait_item.ident, sig, None), &sig.decl,
body, trait_item.span, trait_item.id);
}
TypeTraitItem(ref bounds, ref default) => {
visitor.visit_expr(expr);
}
MethodImplItem(ref sig, ref body) => {
- visitor.visit_fn(FkMethod(impl_item.ident, sig, Some(impl_item.vis)), &sig.decl,
+ visitor.visit_fn(FnKind::Method(impl_item.ident, sig, Some(impl_item.vis)), &sig.decl,
body, impl_item.span, impl_item.id);
}
TypeImplItem(ref ty) => {
}
}
ExprClosure(_, ref function_declaration, ref body) => {
- visitor.visit_fn(FkClosure,
+ visitor.visit_fn(FnKind::Closure,
&**function_declaration,
&**body,
expression.span,
--- /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.
+
+// Test number of arguments in platform-specific intrinsic function
+// This is the error E0444
+
+#![feature(repr_simd, platform_intrinsics)]
+
+#[repr(simd)]
+struct f64x2(f64, f64);
+
+extern "platform-intrinsic" {
+ fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32; //~ platform-specific intrinsic
+}
+
+pub fn main() {
+}
--- /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.
+
+// Make sure that a continue span actually contains the keyword.
+
+fn main() {
+ 'a: loop {
+ if false {
+ continue //~ ERROR use of undeclared label
+ 'b;
+ } else {
+ break //~ ERROR use of undeclared label
+ 'c;
+ }
+ }
+}
use rustc::session::Session;
use rustc::session::config::{self, Input};
use rustc_driver::{driver, CompilerCalls, Compilation};
-use syntax::diagnostics;
+use syntax::{diagnostics, diagnostic};
use std::path::PathBuf;
impl<'a> CompilerCalls<'a> for TestCalls {
fn early_callback(&mut self,
_: &getopts::Matches,
- _: &diagnostics::registry::Registry)
+ _: &diagnostics::registry::Registry,
+ _: diagnostic::ColorConfig)
-> Compilation {
self.count *= 2;
Compilation::Continue
projects / rust.git / commitdiff