nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-10 08:57:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

rustc: avoid use-ing syntax::ast::*.

Browse Source
This commit is contained in:
Eduard Burtescu 2014-09-13 20:10:34 +03:00
parent e09d98603e
commit 21da750663
8 changed files with 458 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
src/librustc/metadata/encoder.rs
View File

@ -32,8 +32,7 @@ use std::cell::RefCell;
use std::hash::Hash; use std::hash::Hash;
use std::hash; use std::hash;
use syntax::abi; use syntax::abi;
use syntax::ast::*; use syntax::ast::{mod, DefId, NodeId};
use syntax::ast;
use syntax::ast_map::{PathElem, PathElems}; use syntax::ast_map::{PathElem, PathElems};
use syntax::ast_map; use syntax::ast_map;
use syntax::ast_util::*; use syntax::ast_util::*;
@ -53,8 +52,8 @@ use rbml::io::SeekableMemWriter;
/// A borrowed version of `ast::InlinedItem`. /// A borrowed version of `ast::InlinedItem`.
pub enum InlinedItemRef<'a> { pub enum InlinedItemRef<'a> {
IIItemRef(&'a ast::Item), IIItemRef(&'a ast::Item),
IITraitItemRef(ast::DefId, &'a ast::TraitItem), IITraitItemRef(DefId, &'a ast::TraitItem),
IIImplItemRef(ast::DefId, &'a ast::ImplItem), IIImplItemRef(DefId, &'a ast::ImplItem),
IIForeignRef(&'a ast::ForeignItem) IIForeignRef(&'a ast::ForeignItem)
} }
@ -87,11 +86,11 @@ pub struct EncodeContext<'a, 'tcx: 'a> {
pub reachable: &'a NodeSet, pub reachable: &'a NodeSet,
} }
fn encode_name(rbml_w: &mut Encoder, name: Name) { fn encode_name(rbml_w: &mut Encoder, name: ast::Name) {
rbml_w.wr_tagged_str(tag_paths_data_name, token::get_name(name).get()); rbml_w.wr_tagged_str(tag_paths_data_name, token::get_name(name).get());
} }
fn encode_impl_type_basename(rbml_w: &mut Encoder, name: Ident) { fn encode_impl_type_basename(rbml_w: &mut Encoder, name: ast::Ident) {
rbml_w.wr_tagged_str(tag_item_impl_type_basename, token::get_ident(name).get()); rbml_w.wr_tagged_str(tag_item_impl_type_basename, token::get_ident(name).get());
} }
@ -134,7 +133,7 @@ pub fn def_to_string(did: DefId) -> String {
fn encode_item_variances(rbml_w: &mut Encoder, fn encode_item_variances(rbml_w: &mut Encoder,
ecx: &EncodeContext, ecx: &EncodeContext,
id: ast::NodeId) { id: NodeId) {
let v = ty::item_variances(ecx.tcx, ast_util::local_def(id)); let v = ty::item_variances(ecx.tcx, ast_util::local_def(id));
rbml_w.start_tag(tag_item_variances); rbml_w.start_tag(tag_item_variances);
v.encode(rbml_w); v.encode(rbml_w);
@ -310,14 +309,14 @@ fn encode_struct_fields(rbml_w: &mut Encoder,
fn encode_enum_variant_info(ecx: &EncodeContext, fn encode_enum_variant_info(ecx: &EncodeContext,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
id: NodeId, id: NodeId,
variants: &[P<Variant>], variants: &[P<ast::Variant>],
index: &mut Vec<entry<i64>>) { index: &mut Vec<entry<i64>>) {
debug!("encode_enum_variant_info(id={})", id); debug!("encode_enum_variant_info(id={})", id);
let mut disr_val = 0; let mut disr_val = 0;
let mut i = 0; let mut i = 0;
let vi = ty::enum_variants(ecx.tcx, let vi = ty::enum_variants(ecx.tcx,
ast::DefId { krate: LOCAL_CRATE, node: id }); DefId { krate: ast::LOCAL_CRATE, node: id });
for variant in variants.iter() { for variant in variants.iter() {
let def_id = local_def(variant.node.id); let def_id = local_def(variant.node.id);
index.push(entry { index.push(entry {
@ -382,7 +381,7 @@ fn encode_path<PI: Iterator<PathElem> + Clone>(rbml_w: &mut Encoder,
fn encode_reexported_static_method(rbml_w: &mut Encoder, fn encode_reexported_static_method(rbml_w: &mut Encoder,
exp: &middle::resolve::Export2, exp: &middle::resolve::Export2,
method_def_id: DefId, method_def_id: DefId,
method_name: Name) { method_name: ast::Name) {
debug!("(encode reexported static method) {}::{}", debug!("(encode reexported static method) {}::{}",
exp.name, token::get_name(method_name)); exp.name, token::get_name(method_name));
rbml_w.start_tag(tag_items_data_item_reexport); rbml_w.start_tag(tag_items_data_item_reexport);
@ -504,10 +503,10 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
/// * For enums, iterates through the node IDs of the variants. /// * For enums, iterates through the node IDs of the variants.
/// ///
/// * For newtype structs, iterates through the node ID of the constructor. /// * For newtype structs, iterates through the node ID of the constructor.
fn each_auxiliary_node_id(item: &Item, callback: |NodeId| -> bool) -> bool { fn each_auxiliary_node_id(item: &ast::Item, callback: |NodeId| -> bool) -> bool {
let mut continue_ = true; let mut continue_ = true;
match item.node { match item.node {
ItemEnum(ref enum_def, _) => { ast::ItemEnum(ref enum_def, _) => {
for variant in enum_def.variants.iter() { for variant in enum_def.variants.iter() {
continue_ = callback(variant.node.id); continue_ = callback(variant.node.id);
if !continue_ { if !continue_ {
@ -515,7 +514,7 @@ fn each_auxiliary_node_id(item: &Item, callback: |NodeId| -> bool) -> bool {
} }
} }
} }
ItemStruct(ref struct_def, _) => { ast::ItemStruct(ref struct_def, _) => {
// If this is a newtype struct, return the constructor. // If this is a newtype struct, return the constructor.
match struct_def.ctor_id { match struct_def.ctor_id {
Some(ctor_id) if struct_def.fields.len() > 0 && Some(ctor_id) if struct_def.fields.len() > 0 &&
@ -566,12 +565,12 @@ fn encode_reexports(ecx: &EncodeContext,
fn encode_info_for_mod(ecx: &EncodeContext, fn encode_info_for_mod(ecx: &EncodeContext,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
md: &Mod, md: &ast::Mod,
attrs: &[Attribute], attrs: &[ast::Attribute],
id: NodeId, id: NodeId,
path: PathElems, path: PathElems,
name: Ident, name: ast::Ident,
vis: Visibility) { vis: ast::Visibility) {
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
encode_def_id(rbml_w, local_def(id)); encode_def_id(rbml_w, local_def(id));
encode_family(rbml_w, 'm'); encode_family(rbml_w, 'm');
@ -593,7 +592,7 @@ fn encode_info_for_mod(ecx: &EncodeContext,
}); });
match item.node { match item.node {
ItemImpl(..) => { ast::ItemImpl(..) => {
let (ident, did) = (item.ident, item.id); let (ident, did) = (item.ident, item.id);
debug!("(encoding info for module) ... encoding impl {} \ debug!("(encoding info for module) ... encoding impl {} \
({}/{})", ({}/{})",
@ -615,7 +614,7 @@ fn encode_info_for_mod(ecx: &EncodeContext,
encode_stability(rbml_w, stab); encode_stability(rbml_w, stab);
// Encode the reexports of this module, if this module is public. // Encode the reexports of this module, if this module is public.
if vis == Public { if vis == ast::Public {
debug!("(encoding info for module) encoding reexports for {}", id); debug!("(encoding info for module) encoding reexports for {}", id);
encode_reexports(ecx, rbml_w, id, path); encode_reexports(ecx, rbml_w, id, path);
} }
@ -625,18 +624,18 @@ fn encode_info_for_mod(ecx: &EncodeContext,
} }
fn encode_struct_field_family(rbml_w: &mut Encoder, fn encode_struct_field_family(rbml_w: &mut Encoder,
visibility: Visibility) { visibility: ast::Visibility) {
encode_family(rbml_w, match visibility { encode_family(rbml_w, match visibility {
Public => 'g', ast::Public => 'g',
Inherited => 'N' ast::Inherited => 'N'
}); });
} }
fn encode_visibility(rbml_w: &mut Encoder, visibility: Visibility) { fn encode_visibility(rbml_w: &mut Encoder, visibility: ast::Visibility) {
rbml_w.start_tag(tag_items_data_item_visibility); rbml_w.start_tag(tag_items_data_item_visibility);
let ch = match visibility { let ch = match visibility {
Public => 'y', ast::Public => 'y',
Inherited => 'i', ast::Inherited => 'i',
}; };
rbml_w.wr_str(ch.to_string().as_slice()); rbml_w.wr_str(ch.to_string().as_slice());
rbml_w.end_tag(); rbml_w.end_tag();
@ -681,8 +680,8 @@ fn encode_explicit_self(rbml_w: &mut Encoder,
fn encode_mutability(rbml_w: &mut Encoder, fn encode_mutability(rbml_w: &mut Encoder,
m: ast::Mutability) { m: ast::Mutability) {
match m { match m {
MutImmutable => { rbml_w.writer.write(&[ 'i' as u8 ]); } ast::MutImmutable => { rbml_w.writer.write(&[ 'i' as u8 ]); }
MutMutable => { rbml_w.writer.write(&[ 'm' as u8 ]); } ast::MutMutable => { rbml_w.writer.write(&[ 'm' as u8 ]); }
} }
} }
} }
@ -854,7 +853,7 @@ fn encode_info_for_method(ecx: &EncodeContext,
impl_path: PathElems, impl_path: PathElems,
is_default_impl: bool, is_default_impl: bool,
parent_id: NodeId, parent_id: NodeId,
ast_item_opt: Option<&ImplItem>) { ast_item_opt: Option<&ast::ImplItem>) {
debug!("encode_info_for_method: {} {}", m.def_id, debug!("encode_info_for_method: {} {}", m.def_id,
token::get_name(m.name)); token::get_name(m.name));
@ -948,7 +947,7 @@ fn encode_method_argument_names(rbml_w: &mut Encoder,
fn encode_repr_attrs(rbml_w: &mut Encoder, fn encode_repr_attrs(rbml_w: &mut Encoder,
ecx: &EncodeContext, ecx: &EncodeContext,
attrs: &[Attribute]) { attrs: &[ast::Attribute]) {
let mut repr_attrs = Vec::new(); let mut repr_attrs = Vec::new();
for attr in attrs.iter() { for attr in attrs.iter() {
repr_attrs.extend(attr::find_repr_attrs(ecx.tcx.sess.diagnostic(), repr_attrs.extend(attr::find_repr_attrs(ecx.tcx.sess.diagnostic(),
@ -971,7 +970,7 @@ const FN_FAMILY: char = 'f';
const STATIC_METHOD_FAMILY: char = 'F'; const STATIC_METHOD_FAMILY: char = 'F';
const METHOD_FAMILY: char = 'h'; const METHOD_FAMILY: char = 'h';
fn should_inline(attrs: &[Attribute]) -> bool { fn should_inline(attrs: &[ast::Attribute]) -> bool {
use syntax::attr::*; use syntax::attr::*;
match find_inline_attr(attrs) { match find_inline_attr(attrs) {
InlineNone | InlineNever => false, InlineNone | InlineNever => false,
@ -1021,13 +1020,13 @@ fn encode_stability(rbml_w: &mut Encoder, stab_opt: Option<attr::Stability>) {
fn encode_info_for_item(ecx: &EncodeContext, fn encode_info_for_item(ecx: &EncodeContext,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
item: &Item, item: &ast::Item,
index: &mut Vec<entry<i64>>, index: &mut Vec<entry<i64>>,
path: PathElems, path: PathElems,
vis: ast::Visibility) { vis: ast::Visibility) {
let tcx = ecx.tcx; let tcx = ecx.tcx;
fn add_to_index(item: &Item, rbml_w: &Encoder, fn add_to_index(item: &ast::Item, rbml_w: &Encoder,
index: &mut Vec<entry<i64>>) { index: &mut Vec<entry<i64>>) {
index.push(entry { index.push(entry {
val: item.id as i64, val: item.id as i64,
@ -1042,7 +1041,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
let stab = stability::lookup(tcx, ast_util::local_def(item.id)); let stab = stability::lookup(tcx, ast_util::local_def(item.id));
match item.node { match item.node {
ItemStatic(_, m, _) => { ast::ItemStatic(_, m, _) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
encode_def_id(rbml_w, def_id); encode_def_id(rbml_w, def_id);
@ -1060,7 +1059,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_attributes(rbml_w, item.attrs.as_slice()); encode_attributes(rbml_w, item.attrs.as_slice());
rbml_w.end_tag(); rbml_w.end_tag();
} }
ItemConst(_, _) => { ast::ItemConst(_, _) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
encode_def_id(rbml_w, def_id); encode_def_id(rbml_w, def_id);
@ -1073,7 +1072,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_stability(rbml_w, stab); encode_stability(rbml_w, stab);
rbml_w.end_tag(); rbml_w.end_tag();
} }
ItemFn(ref decl, _, _, ref generics, _) => { ast::ItemFn(ref decl, _, _, ref generics, _) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
encode_def_id(rbml_w, def_id); encode_def_id(rbml_w, def_id);
@ -1094,7 +1093,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_method_argument_names(rbml_w, &**decl); encode_method_argument_names(rbml_w, &**decl);
rbml_w.end_tag(); rbml_w.end_tag();
} }
ItemMod(ref m) => { ast::ItemMod(ref m) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
encode_info_for_mod(ecx, encode_info_for_mod(ecx,
rbml_w, rbml_w,
@ -1105,7 +1104,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
item.ident, item.ident,
item.vis); item.vis);
} }
ItemForeignMod(ref fm) => { ast::ItemForeignMod(ref fm) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
encode_def_id(rbml_w, def_id); encode_def_id(rbml_w, def_id);
@ -1123,7 +1122,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_stability(rbml_w, stab); encode_stability(rbml_w, stab);
rbml_w.end_tag(); rbml_w.end_tag();
} }
ItemTy(..) => { ast::ItemTy(..) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
encode_def_id(rbml_w, def_id); encode_def_id(rbml_w, def_id);
@ -1135,7 +1134,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_stability(rbml_w, stab); encode_stability(rbml_w, stab);
rbml_w.end_tag(); rbml_w.end_tag();
} }
ItemEnum(ref enum_definition, _) => { ast::ItemEnum(ref enum_definition, _) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
@ -1165,7 +1164,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
(*enum_definition).variants.as_slice(), (*enum_definition).variants.as_slice(),
index); index);
} }
ItemStruct(ref struct_def, _) => { ast::ItemStruct(ref struct_def, _) => {
let fields = ty::lookup_struct_fields(tcx, def_id); let fields = ty::lookup_struct_fields(tcx, def_id);
/* First, encode the fields /* First, encode the fields
@ -1217,7 +1216,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
None => {} None => {}
} }
} }
ItemImpl(_, ref opt_trait, ref ty, ref ast_items) => { ast::ItemImpl(_, ref opt_trait, ref ty, ref ast_items) => {
// We need to encode information about the default methods we // We need to encode information about the default methods we
// have inherited, so we drive this based on the impl structure. // have inherited, so we drive this based on the impl structure.
let impl_items = tcx.impl_items.borrow(); let impl_items = tcx.impl_items.borrow();
@ -1321,7 +1320,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
} }
} }
} }
ItemTrait(_, _, _, ref ms) => { ast::ItemTrait(_, _, _, ref ms) => {
add_to_index(item, rbml_w, index); add_to_index(item, rbml_w, index);
rbml_w.start_tag(tag_items_data_item); rbml_w.start_tag(tag_items_data_item);
encode_def_id(rbml_w, def_id); encode_def_id(rbml_w, def_id);
@ -1433,14 +1432,14 @@ fn encode_info_for_item(ecx: &EncodeContext,
} }
}; };
match trait_item { match trait_item {
&RequiredMethod(ref m) => { &ast::RequiredMethod(ref m) => {
encode_attributes(rbml_w, m.attrs.as_slice()); encode_attributes(rbml_w, m.attrs.as_slice());
encode_trait_item(rbml_w); encode_trait_item(rbml_w);
encode_item_sort(rbml_w, 'r'); encode_item_sort(rbml_w, 'r');
encode_method_argument_names(rbml_w, &*m.decl); encode_method_argument_names(rbml_w, &*m.decl);
} }
&ProvidedMethod(ref m) => { &ast::ProvidedMethod(ref m) => {
encode_attributes(rbml_w, m.attrs.as_slice()); encode_attributes(rbml_w, m.attrs.as_slice());
encode_trait_item(rbml_w); encode_trait_item(rbml_w);
encode_item_sort(rbml_w, 'p'); encode_item_sort(rbml_w, 'p');
@ -1448,7 +1447,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_method_argument_names(rbml_w, &*m.pe_fn_decl()); encode_method_argument_names(rbml_w, &*m.pe_fn_decl());
} }
&TypeTraitItem(ref associated_type) => { &ast::TypeTraitItem(ref associated_type) => {
encode_attributes(rbml_w, encode_attributes(rbml_w,
associated_type.attrs.as_slice()); associated_type.attrs.as_slice());
encode_item_sort(rbml_w, 't'); encode_item_sort(rbml_w, 't');
@ -1461,7 +1460,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
// Encode inherent implementations for this trait. // Encode inherent implementations for this trait.
encode_inherent_implementations(ecx, rbml_w, def_id); encode_inherent_implementations(ecx, rbml_w, def_id);
} }
ItemMac(..) => { ast::ItemMac(..) => {
// macros are encoded separately // macros are encoded separately
} }
} }
@ -1469,7 +1468,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
fn encode_info_for_foreign_item(ecx: &EncodeContext, fn encode_info_for_foreign_item(ecx: &EncodeContext,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
nitem: &ForeignItem, nitem: &ast::ForeignItem,
index: &mut Vec<entry<i64>>, index: &mut Vec<entry<i64>>,
path: PathElems, path: PathElems,
abi: abi::Abi) { abi: abi::Abi) {
@ -1482,7 +1481,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
encode_def_id(rbml_w, local_def(nitem.id)); encode_def_id(rbml_w, local_def(nitem.id));
encode_visibility(rbml_w, nitem.vis); encode_visibility(rbml_w, nitem.vis);
match nitem.node { match nitem.node {
ForeignItemFn(..) => { ast::ForeignItemFn(..) => {
encode_family(rbml_w, FN_FAMILY); encode_family(rbml_w, FN_FAMILY);
encode_bounds_and_type(rbml_w, ecx, encode_bounds_and_type(rbml_w, ecx,
&lookup_item_type(ecx.tcx,local_def(nitem.id))); &lookup_item_type(ecx.tcx,local_def(nitem.id)));
@ -1492,7 +1491,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
} }
encode_symbol(ecx, rbml_w, nitem.id); encode_symbol(ecx, rbml_w, nitem.id);
} }
ForeignItemStatic(_, mutbl) => { ast::ForeignItemStatic(_, mutbl) => {
if mutbl { if mutbl {
encode_family(rbml_w, 'b'); encode_family(rbml_w, 'b');
} else { } else {
@ -1508,9 +1507,9 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
rbml_w.end_tag(); rbml_w.end_tag();
} }
fn my_visit_expr(_e: &Expr) { } fn my_visit_expr(_e: &ast::Expr) { }
fn my_visit_item(i: &Item, fn my_visit_item(i: &ast::Item,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
ecx: &EncodeContext, ecx: &EncodeContext,
index: &mut Vec<entry<i64>>) { index: &mut Vec<entry<i64>>) {
@ -1519,7 +1518,7 @@ fn my_visit_item(i: &Item,
}); });
} }
fn my_visit_foreign_item(ni: &ForeignItem, fn my_visit_foreign_item(ni: &ast::ForeignItem,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
ecx: &EncodeContext, ecx: &EncodeContext,
index: &mut Vec<entry<i64>>) { index: &mut Vec<entry<i64>>) {
@ -1542,18 +1541,18 @@ struct EncodeVisitor<'a, 'b:'a, 'c:'a, 'tcx:'c> {
} }
impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for EncodeVisitor<'a, 'b, 'c, 'tcx> { impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for EncodeVisitor<'a, 'b, 'c, 'tcx> {
fn visit_expr(&mut self, ex: &Expr) { fn visit_expr(&mut self, ex: &ast::Expr) {
visit::walk_expr(self, ex); visit::walk_expr(self, ex);
my_visit_expr(ex); my_visit_expr(ex);
} }
fn visit_item(&mut self, i: &Item) { fn visit_item(&mut self, i: &ast::Item) {
visit::walk_item(self, i); visit::walk_item(self, i);
my_visit_item(i, my_visit_item(i,
self.rbml_w_for_visit_item, self.rbml_w_for_visit_item,
self.ecx, self.ecx,
self.index); self.index);
} }
fn visit_foreign_item(&mut self, ni: &ForeignItem) { fn visit_foreign_item(&mut self, ni: &ast::ForeignItem) {
visit::walk_foreign_item(self, ni); visit::walk_foreign_item(self, ni);
my_visit_foreign_item(ni, my_visit_foreign_item(ni,
self.rbml_w_for_visit_item, self.rbml_w_for_visit_item,
@ -1564,22 +1563,22 @@ impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for EncodeVisitor<'a, 'b, 'c, 'tcx> {
fn encode_info_for_items(ecx: &EncodeContext, fn encode_info_for_items(ecx: &EncodeContext,
rbml_w: &mut Encoder, rbml_w: &mut Encoder,
krate: &Crate) krate: &ast::Crate)
-> Vec<entry<i64>> { -> Vec<entry<i64>> {
let mut index = Vec::new(); let mut index = Vec::new();
rbml_w.start_tag(tag_items_data); rbml_w.start_tag(tag_items_data);
index.push(entry { index.push(entry {
val: CRATE_NODE_ID as i64, val: ast::CRATE_NODE_ID as i64,
pos: rbml_w.writer.tell().unwrap(), pos: rbml_w.writer.tell().unwrap(),
}); });
encode_info_for_mod(ecx, encode_info_for_mod(ecx,
rbml_w, rbml_w,
&krate.module, &krate.module,
&[], &[],
CRATE_NODE_ID, ast::CRATE_NODE_ID,
ast_map::Values([].iter()).chain(None), ast_map::Values([].iter()).chain(None),
syntax::parse::token::special_idents::invalid, syntax::parse::token::special_idents::invalid,
Public); ast::Public);
visit::walk_crate(&mut EncodeVisitor { visit::walk_crate(&mut EncodeVisitor {
index: &mut index, index: &mut index,
@ -1637,18 +1636,18 @@ fn write_i64(writer: &mut SeekableMemWriter, &n: &i64) {
wr.write_be_u32(n as u32); wr.write_be_u32(n as u32);
} }
fn encode_meta_item(rbml_w: &mut Encoder, mi: &MetaItem) { fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) {
match mi.node { match mi.node {
MetaWord(ref name) => { ast::MetaWord(ref name) => {
rbml_w.start_tag(tag_meta_item_word); rbml_w.start_tag(tag_meta_item_word);
rbml_w.start_tag(tag_meta_item_name); rbml_w.start_tag(tag_meta_item_name);
rbml_w.writer.write(name.get().as_bytes()); rbml_w.writer.write(name.get().as_bytes());
rbml_w.end_tag(); rbml_w.end_tag();
rbml_w.end_tag(); rbml_w.end_tag();
} }
MetaNameValue(ref name, ref value) => { ast::MetaNameValue(ref name, ref value) => {
match value.node { match value.node {
LitStr(ref value, _) => { ast::LitStr(ref value, _) => {
rbml_w.start_tag(tag_meta_item_name_value); rbml_w.start_tag(tag_meta_item_name_value);
rbml_w.start_tag(tag_meta_item_name); rbml_w.start_tag(tag_meta_item_name);
rbml_w.writer.write(name.get().as_bytes()); rbml_w.writer.write(name.get().as_bytes());
@ -1661,7 +1660,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &MetaItem) {
_ => {/* FIXME (#623): encode other variants */ } _ => {/* FIXME (#623): encode other variants */ }
} }
} }
MetaList(ref name, ref items) => { ast::MetaList(ref name, ref items) => {
rbml_w.start_tag(tag_meta_item_list); rbml_w.start_tag(tag_meta_item_list);
rbml_w.start_tag(tag_meta_item_name); rbml_w.start_tag(tag_meta_item_name);
rbml_w.writer.write(name.get().as_bytes()); rbml_w.writer.write(name.get().as_bytes());
@ -1674,7 +1673,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &MetaItem) {
} }
} }
fn encode_attributes(rbml_w: &mut Encoder, attrs: &[Attribute]) { fn encode_attributes(rbml_w: &mut Encoder, attrs: &[ast::Attribute]) {
rbml_w.start_tag(tag_attributes); rbml_w.start_tag(tag_attributes);
for attr in attrs.iter() { for attr in attrs.iter() {
rbml_w.start_tag(tag_attribute); rbml_w.start_tag(tag_attribute);
@ -1728,7 +1727,7 @@ fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) {
for (i, def_id) in ecx.tcx.lang_items.items() { for (i, def_id) in ecx.tcx.lang_items.items() {
for id in def_id.iter() { for id in def_id.iter() {
if id.krate == LOCAL_CRATE { if id.krate == ast::LOCAL_CRATE {
rbml_w.start_tag(tag_lang_items_item); rbml_w.start_tag(tag_lang_items_item);
rbml_w.start_tag(tag_lang_items_item_id); rbml_w.start_tag(tag_lang_items_item_id);
@ -1804,7 +1803,7 @@ fn encode_macro_def(ecx: &EncodeContext,
/// Serialize the text of the exported macros /// Serialize the text of the exported macros
fn encode_macro_defs(ecx: &EncodeContext, fn encode_macro_defs(ecx: &EncodeContext,
krate: &Crate, krate: &ast::Crate,
rbml_w: &mut Encoder) { rbml_w: &mut Encoder) {
rbml_w.start_tag(tag_exported_macros); rbml_w.start_tag(tag_exported_macros);
for item in krate.exported_macros.iter() { for item in krate.exported_macros.iter() {
@ -1821,7 +1820,7 @@ fn encode_unboxed_closures<'a>(
.unboxed_closures .unboxed_closures
.borrow() .borrow()
.iter() { .iter() {
if unboxed_closure_id.krate != LOCAL_CRATE { if unboxed_closure_id.krate != ast::LOCAL_CRATE {
continue continue
} }
@ -1836,7 +1835,7 @@ fn encode_unboxed_closures<'a>(
rbml_w.end_tag(); rbml_w.end_tag();
} }
fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &Crate) { fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &ast::Crate) {
struct StructFieldVisitor<'a, 'b:'a> { struct StructFieldVisitor<'a, 'b:'a> {
rbml_w: &'a mut Encoder<'b>, rbml_w: &'a mut Encoder<'b>,
} }
@ -1865,9 +1864,9 @@ struct ImplVisitor<'a, 'b:'a, 'c:'a, 'tcx:'b> {
} }
impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> { impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> {
fn visit_item(&mut self, item: &Item) { fn visit_item(&mut self, item: &ast::Item) {
match item.node { match item.node {
ItemImpl(_, Some(ref trait_ref), _, _) => { ast::ItemImpl(_, Some(ref trait_ref), _, _) => {
let def_map = &self.ecx.tcx.def_map; let def_map = &self.ecx.tcx.def_map;
let trait_def = def_map.borrow()[trait_ref.ref_id].clone(); let trait_def = def_map.borrow()[trait_ref.ref_id].clone();
let def_id = trait_def.def_id(); let def_id = trait_def.def_id();
@ -1875,7 +1874,7 @@ impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> {
// Load eagerly if this is an implementation of the Drop trait // Load eagerly if this is an implementation of the Drop trait
// or if the trait is not defined in this crate. // or if the trait is not defined in this crate.
if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() || if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() ||
def_id.krate != LOCAL_CRATE { def_id.krate != ast::LOCAL_CRATE {
self.rbml_w.start_tag(tag_impls_impl); self.rbml_w.start_tag(tag_impls_impl);
encode_def_id(self.rbml_w, local_def(item.id)); encode_def_id(self.rbml_w, local_def(item.id));
self.rbml_w.end_tag(); self.rbml_w.end_tag();
@ -1898,7 +1897,7 @@ impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> {
/// ///
/// * Implementations of traits not defined in this crate. /// * Implementations of traits not defined in this crate.
fn encode_impls<'a>(ecx: &'a EncodeContext, fn encode_impls<'a>(ecx: &'a EncodeContext,
krate: &Crate, krate: &ast::Crate,
rbml_w: &'a mut Encoder) { rbml_w: &'a mut Encoder) {
rbml_w.start_tag(tag_impls); rbml_w.start_tag(tag_impls);
@ -1914,7 +1913,7 @@ fn encode_impls<'a>(ecx: &'a EncodeContext,
} }
fn encode_misc_info(ecx: &EncodeContext, fn encode_misc_info(ecx: &EncodeContext,
krate: &Crate, krate: &ast::Crate,
rbml_w: &mut Encoder) { rbml_w: &mut Encoder) {
rbml_w.start_tag(tag_misc_info); rbml_w.start_tag(tag_misc_info);
rbml_w.start_tag(tag_misc_info_crate_items); rbml_w.start_tag(tag_misc_info_crate_items);
@ -2011,13 +2010,15 @@ fn encode_dylib_dependency_formats(rbml_w: &mut Encoder, ecx: &EncodeContext) {
#[allow(non_upper_case_globals)] #[allow(non_upper_case_globals)]
pub const metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 1 ]; pub const metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 1 ];
pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec<u8> { pub fn encode_metadata(parms: EncodeParams, krate: &ast::Crate) -> Vec<u8> {
let mut wr = SeekableMemWriter::new(); let mut wr = SeekableMemWriter::new();
encode_metadata_inner(&mut wr, parms, krate); encode_metadata_inner(&mut wr, parms, krate);
wr.unwrap().into_iter().collect() wr.unwrap().into_iter().collect()
} }
fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate: &Crate) { fn encode_metadata_inner(wr: &mut SeekableMemWriter,
parms: EncodeParams,
krate: &ast::Crate) {
struct Stats { struct Stats {
attr_bytes: u64, attr_bytes: u64,
dep_bytes: u64, dep_bytes: u64,

7
src/librustc/metadata/tydecode.rs
View File

@ -27,7 +27,6 @@ use std::str;
use std::string::String; use std::string::String;
use syntax::abi; use syntax::abi;
use syntax::ast; use syntax::ast;
use syntax::ast::*;
use syntax::parse::token; use syntax::parse::token;
// Compact string representation for ty::t values. API ty_str & // Compact string representation for ty::t values. API ty_str &
@ -525,10 +524,10 @@ fn parse_hex(st: &mut PState) -> uint {
}; };
} }
fn parse_fn_style(c: char) -> FnStyle { fn parse_fn_style(c: char) -> ast::FnStyle {
match c { match c {
'u' => UnsafeFn, 'u' => ast::UnsafeFn,
'n' => NormalFn, 'n' => ast::NormalFn,
_ => panic!("parse_fn_style: bad fn_style {}", c) _ => panic!("parse_fn_style: bad fn_style {}", c)
} }
} }

43
src/librustc/metadata/tyencode.rs
View File

@ -23,7 +23,6 @@ use util::nodemap::FnvHashMap;
use syntax::abi::Abi; use syntax::abi::Abi;
use syntax::ast; use syntax::ast;
use syntax::ast::*;
use syntax::diagnostic::SpanHandler; use syntax::diagnostic::SpanHandler;
use syntax::parse::token; use syntax::parse::token;
@ -34,7 +33,7 @@ macro_rules! mywrite( ($($arg:tt)*) => ({ write!($($arg)*); }) )
pub struct ctxt<'a, 'tcx: 'a> { pub struct ctxt<'a, 'tcx: 'a> {
pub diag: &'a SpanHandler, pub diag: &'a SpanHandler,
// Def -> str Callback: // Def -> str Callback:
pub ds: fn(DefId) -> String, pub ds: fn(ast::DefId) -> String,
// The type context. // The type context.
pub tcx: &'a ty::ctxt<'tcx>, pub tcx: &'a ty::ctxt<'tcx>,
pub abbrevs: &'a abbrev_map pub abbrevs: &'a abbrev_map
@ -75,8 +74,8 @@ pub fn enc_ty(w: &mut SeekableMemWriter, cx: &ctxt, t: ty::t) {
fn enc_mutability(w: &mut SeekableMemWriter, mt: ast::Mutability) { fn enc_mutability(w: &mut SeekableMemWriter, mt: ast::Mutability) {
match mt { match mt {
MutImmutable => (), ast::MutImmutable => (),
MutMutable => mywrite!(w, "m"), ast::MutMutable => mywrite!(w, "m"),
} }
} }
@ -203,26 +202,26 @@ fn enc_sty(w: &mut SeekableMemWriter, cx: &ctxt, st: &ty::sty) {
ty::ty_char => mywrite!(w, "c"), ty::ty_char => mywrite!(w, "c"),
ty::ty_int(t) => { ty::ty_int(t) => {
match t { match t {
TyI => mywrite!(w, "i"), ast::TyI => mywrite!(w, "i"),
TyI8 => mywrite!(w, "MB"), ast::TyI8 => mywrite!(w, "MB"),
TyI16 => mywrite!(w, "MW"), ast::TyI16 => mywrite!(w, "MW"),
TyI32 => mywrite!(w, "ML"), ast::TyI32 => mywrite!(w, "ML"),
TyI64 => mywrite!(w, "MD") ast::TyI64 => mywrite!(w, "MD")
} }
} }
ty::ty_uint(t) => { ty::ty_uint(t) => {
match t { match t {
TyU => mywrite!(w, "u"), ast::TyU => mywrite!(w, "u"),
TyU8 => mywrite!(w, "Mb"), ast::TyU8 => mywrite!(w, "Mb"),
TyU16 => mywrite!(w, "Mw"), ast::TyU16 => mywrite!(w, "Mw"),
TyU32 => mywrite!(w, "Ml"), ast::TyU32 => mywrite!(w, "Ml"),
TyU64 => mywrite!(w, "Md") ast::TyU64 => mywrite!(w, "Md")
} }
} }
ty::ty_float(t) => { ty::ty_float(t) => {
match t { match t {
TyF32 => mywrite!(w, "Mf"), ast::TyF32 => mywrite!(w, "Mf"),
TyF64 => mywrite!(w, "MF"), ast::TyF64 => mywrite!(w, "MF"),
} }
} }
ty::ty_enum(def, ref substs) => { ty::ty_enum(def, ref substs) => {
@ -295,10 +294,10 @@ fn enc_sty(w: &mut SeekableMemWriter, cx: &ctxt, st: &ty::sty) {
} }
} }
fn enc_fn_style(w: &mut SeekableMemWriter, p: FnStyle) { fn enc_fn_style(w: &mut SeekableMemWriter, p: ast::FnStyle) {
match p { match p {
NormalFn => mywrite!(w, "n"), ast::NormalFn => mywrite!(w, "n"),
UnsafeFn => mywrite!(w, "u"), ast::UnsafeFn => mywrite!(w, "u"),
} }
} }
@ -308,10 +307,10 @@ fn enc_abi(w: &mut SeekableMemWriter, abi: Abi) {
mywrite!(w, "]") mywrite!(w, "]")
} }
fn enc_onceness(w: &mut SeekableMemWriter, o: Onceness) { fn enc_onceness(w: &mut SeekableMemWriter, o: ast::Onceness) {
match o { match o {
Once => mywrite!(w, "o"), ast::Once => mywrite!(w, "o"),
Many => mywrite!(w, "m") ast::Many => mywrite!(w, "m")
} }
} }

82
src/librustc/middle/check_const.rs
View File

@ -14,7 +14,7 @@ use middle::ty;
use middle::typeck; use middle::typeck;
use util::ppaux; use util::ppaux;
use syntax::ast::*; use syntax::ast;
use syntax::ast_util; use syntax::ast_util;
use syntax::visit::Visitor; use syntax::visit::Visitor;
use syntax::visit; use syntax::visit;
@ -40,13 +40,13 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
} }
impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &Item) { fn visit_item(&mut self, i: &ast::Item) {
check_item(self, i); check_item(self, i);
} }
fn visit_pat(&mut self, p: &Pat) { fn visit_pat(&mut self, p: &ast::Pat) {
check_pat(self, p); check_pat(self, p);
} }
fn visit_expr(&mut self, ex: &Expr) { fn visit_expr(&mut self, ex: &ast::Expr) {
if check_expr(self, ex) { if check_expr(self, ex) {
visit::walk_expr(self, ex); visit::walk_expr(self, ex);
} }
@ -59,13 +59,13 @@ pub fn check_crate(tcx: &ty::ctxt) {
tcx.sess.abort_if_errors(); tcx.sess.abort_if_errors();
} }
fn check_item(v: &mut CheckCrateVisitor, it: &Item) { fn check_item(v: &mut CheckCrateVisitor, it: &ast::Item) {
match it.node { match it.node {
ItemStatic(_, _, ref ex) | ast::ItemStatic(_, _, ref ex) |
ItemConst(_, ref ex) => { ast::ItemConst(_, ref ex) => {
v.inside_const(|v| v.visit_expr(&**ex)); v.inside_const(|v| v.visit_expr(&**ex));
} }
ItemEnum(ref enum_definition, _) => { ast::ItemEnum(ref enum_definition, _) => {
for var in (*enum_definition).variants.iter() { for var in (*enum_definition).variants.iter() {
for ex in var.node.disr_expr.iter() { for ex in var.node.disr_expr.iter() {
v.inside_const(|v| v.visit_expr(&**ex)); v.inside_const(|v| v.visit_expr(&**ex));
@ -76,12 +76,12 @@ fn check_item(v: &mut CheckCrateVisitor, it: &Item) {
} }
} }
fn check_pat(v: &mut CheckCrateVisitor, p: &Pat) { fn check_pat(v: &mut CheckCrateVisitor, p: &ast::Pat) {
fn is_str(e: &Expr) -> bool { fn is_str(e: &ast::Expr) -> bool {
match e.node { match e.node {
ExprBox(_, ref expr) => { ast::ExprBox(_, ref expr) => {
match expr.node { match expr.node {
ExprLit(ref lit) => ast_util::lit_is_str(&**lit), ast::ExprLit(ref lit) => ast_util::lit_is_str(&**lit),
_ => false, _ => false,
} }
} }
@ -90,8 +90,8 @@ fn check_pat(v: &mut CheckCrateVisitor, p: &Pat) {
} }
match p.node { match p.node {
// Let through plain ~-string literals here // Let through plain ~-string literals here
PatLit(ref a) => if !is_str(&**a) { v.inside_const(|v| v.visit_expr(&**a)); }, ast::PatLit(ref a) => if !is_str(&**a) { v.inside_const(|v| v.visit_expr(&**a)); },
PatRange(ref a, ref b) => { ast::PatRange(ref a, ref b) => {
if !is_str(&**a) { v.inside_const(|v| v.visit_expr(&**a)); } if !is_str(&**a) { v.inside_const(|v| v.visit_expr(&**a)); }
if !is_str(&**b) { v.inside_const(|v| v.visit_expr(&**b)); } if !is_str(&**b) { v.inside_const(|v| v.visit_expr(&**b)); }
} }
@ -99,18 +99,18 @@ fn check_pat(v: &mut CheckCrateVisitor, p: &Pat) {
} }
} }
fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool { fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
if !v.in_const { return true } if !v.in_const { return true }
match e.node { match e.node {
ExprUnary(UnDeref, _) => {} ast::ExprUnary(ast::UnDeref, _) => {}
ExprUnary(UnUniq, _) => { ast::ExprUnary(ast::UnUniq, _) => {
span_err!(v.tcx.sess, e.span, E0010, span_err!(v.tcx.sess, e.span, E0010,
"cannot do allocations in constant expressions"); "cannot do allocations in constant expressions");
return false; return false;
} }
ExprLit(ref lit) if ast_util::lit_is_str(&**lit) => {} ast::ExprLit(ref lit) if ast_util::lit_is_str(&**lit) => {}
ExprBinary(..) | ExprUnary(..) => { ast::ExprBinary(..) | ast::ExprUnary(..) => {
let method_call = typeck::MethodCall::expr(e.id); let method_call = typeck::MethodCall::expr(e.id);
if v.tcx.method_map.borrow().contains_key(&method_call) { if v.tcx.method_map.borrow().contains_key(&method_call) {
span_err!(v.tcx.sess, e.span, E0011, span_err!(v.tcx.sess, e.span, E0011,
@ -118,8 +118,8 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
expressions"); expressions");
} }
} }
ExprLit(_) => (), ast::ExprLit(_) => (),
ExprCast(ref from, _) => { ast::ExprCast(ref from, _) => {
let toty = ty::expr_ty(v.tcx, e); let toty = ty::expr_ty(v.tcx, e);
let fromty = ty::expr_ty(v.tcx, &**from); let fromty = ty::expr_ty(v.tcx, &**from);
if !ty::type_is_numeric(toty) && !ty::type_is_unsafe_ptr(toty) { if !ty::type_is_numeric(toty) && !ty::type_is_unsafe_ptr(toty) {
@ -133,7 +133,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
expression"); expression");
} }
} }
ExprPath(ref pth) => { ast::ExprPath(ref pth) => {
// NB: In the future you might wish to relax this slightly // NB: In the future you might wish to relax this slightly
// to handle on-demand instantiation of functions via // to handle on-demand instantiation of functions via
// foo::<bar> in a const. Currently that is only done on // foo::<bar> in a const. Currently that is only done on
@ -161,7 +161,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
} }
} }
} }
ExprCall(ref callee, _) => { ast::ExprCall(ref callee, _) => {
match v.tcx.def_map.borrow().get(&callee.id) { match v.tcx.def_map.borrow().get(&callee.id) {
Some(&DefStruct(..)) | Some(&DefStruct(..)) |
Some(&DefVariant(..)) => {} // OK. Some(&DefVariant(..)) => {} // OK.
@ -173,7 +173,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
} }
} }
} }
ExprBlock(ref block) => { ast::ExprBlock(ref block) => {
// Check all statements in the block // Check all statements in the block
for stmt in block.stmts.iter() { for stmt in block.stmts.iter() {
let block_span_err = |span| let block_span_err = |span|
@ -181,17 +181,17 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
"blocks in constants are limited to items and \ "blocks in constants are limited to items and \
tail expressions"); tail expressions");
match stmt.node { match stmt.node {
StmtDecl(ref span, _) => { ast::StmtDecl(ref span, _) => {
match span.node { match span.node {
DeclLocal(_) => block_span_err(span.span), ast::DeclLocal(_) => block_span_err(span.span),
// Item statements are allowed // Item statements are allowed
DeclItem(_) => {} ast::DeclItem(_) => {}
} }
} }
StmtExpr(ref expr, _) => block_span_err(expr.span), ast::StmtExpr(ref expr, _) => block_span_err(expr.span),
StmtSemi(ref semi, _) => block_span_err(semi.span), ast::StmtSemi(ref semi, _) => block_span_err(semi.span),
StmtMac(..) => { ast::StmtMac(..) => {
v.tcx.sess.span_bug(e.span, "unexpanded statement \ v.tcx.sess.span_bug(e.span, "unexpanded statement \
macro in const?!") macro in const?!")
} }
@ -202,20 +202,20 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr) -> bool {
None => {} None => {}
} }
} }
ExprVec(_) | ast::ExprVec(_) |
ExprAddrOf(MutImmutable, _) | ast::ExprAddrOf(ast::MutImmutable, _) |
ExprParen(..) | ast::ExprParen(..) |
ExprField(..) | ast::ExprField(..) |
ExprTupField(..) | ast::ExprTupField(..) |
ExprIndex(..) | ast::ExprIndex(..) |
ExprTup(..) | ast::ExprTup(..) |
ExprRepeat(..) | ast::ExprRepeat(..) |
ExprStruct(..) => {} ast::ExprStruct(..) => {}
ExprAddrOf(_, ref inner) => { ast::ExprAddrOf(_, ref inner) => {
match inner.node { match inner.node {
// Mutable slices are allowed. // Mutable slices are allowed.
ExprVec(_) => {} ast::ExprVec(_) => {}
_ => span_err!(v.tcx.sess, e.span, E0017, _ => span_err!(v.tcx.sess, e.span, E0017,
"references in constants may only refer \ "references in constants may only refer \
to immutable values") to immutable values")

144
src/librustc/middle/check_match.rs
View File

@ -27,7 +27,7 @@ use std::iter::AdditiveIterator;
use std::iter::range_inclusive; use std::iter::range_inclusive;
use std::num::Float; use std::num::Float;
use std::slice; use std::slice;
use syntax::ast::*; use syntax::ast::{mod, DUMMY_NODE_ID, NodeId, Pat};
use syntax::ast_util::walk_pat; use syntax::ast_util::walk_pat;
use syntax::codemap::{Span, Spanned, DUMMY_SP}; use syntax::codemap::{Span, Spanned, DUMMY_SP};
use syntax::fold::{Folder, noop_fold_pat}; use syntax::fold::{Folder, noop_fold_pat};
@ -39,7 +39,7 @@ use util::ppaux::ty_to_string;
pub const DUMMY_WILD_PAT: &'static Pat = &Pat { pub const DUMMY_WILD_PAT: &'static Pat = &Pat {
id: DUMMY_NODE_ID, id: DUMMY_NODE_ID,
node: PatWild(PatWildSingle), node: ast::PatWild(ast::PatWildSingle),
span: DUMMY_SP span: DUMMY_SP
}; };
@ -108,7 +108,7 @@ pub enum Constructor {
/// e.g. struct patterns and fixed-length arrays. /// e.g. struct patterns and fixed-length arrays.
Single, Single,
/// Enum variants. /// Enum variants.
Variant(DefId), Variant(ast::DefId),
/// Literal values. /// Literal values.
ConstantValue(const_val), ConstantValue(const_val),
/// Ranges of literal values (2..5). /// Ranges of literal values (2..5).
@ -132,14 +132,14 @@ enum WitnessPreference {
} }
impl<'a, 'tcx, 'v> Visitor<'v> for MatchCheckCtxt<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for MatchCheckCtxt<'a, 'tcx> {
fn visit_expr(&mut self, ex: &Expr) { fn visit_expr(&mut self, ex: &ast::Expr) {
check_expr(self, ex); check_expr(self, ex);
} }
fn visit_local(&mut self, l: &Local) { fn visit_local(&mut self, l: &ast::Local) {
check_local(self, l); check_local(self, l);
} }
fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v ast::FnDecl,
b: &'v Block, s: Span, n: NodeId) { b: &'v ast::Block, s: Span, n: NodeId) {
check_fn(self, fk, fd, b, s, n); check_fn(self, fk, fd, b, s, n);
} }
} }
@ -149,10 +149,10 @@ pub fn check_crate(tcx: &ty::ctxt) {
tcx.sess.abort_if_errors(); tcx.sess.abort_if_errors();
} }
fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) { fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) {
visit::walk_expr(cx, ex); visit::walk_expr(cx, ex);
match ex.node { match ex.node {
ExprMatch(ref scrut, ref arms, source) => { ast::ExprMatch(ref scrut, ref arms, source) => {
// First, check legality of move bindings. // First, check legality of move bindings.
for arm in arms.iter() { for arm in arms.iter() {
check_legality_of_move_bindings(cx, check_legality_of_move_bindings(cx,
@ -177,7 +177,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
(arm.pats.iter().map(|pat| { (arm.pats.iter().map(|pat| {
static_inliner.fold_pat((*pat).clone()) static_inliner.fold_pat((*pat).clone())
}).collect(), arm.guard.as_ref().map(|e| &**e)) }).collect(), arm.guard.as_ref().map(|e| &**e))
}).collect::<Vec<(Vec<P<Pat>>, Option<&Expr>)>>(); }).collect::<Vec<(Vec<P<Pat>>, Option<&ast::Expr>)>>();
if static_inliner.failed { if static_inliner.failed {
return; return;
@ -214,7 +214,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
.collect(); .collect();
check_exhaustive(cx, ex.span, &matrix); check_exhaustive(cx, ex.span, &matrix);
}, },
ExprForLoop(ref pat, _, _, _) => { ast::ExprForLoop(ref pat, _, _, _) => {
let mut static_inliner = StaticInliner::new(cx.tcx); let mut static_inliner = StaticInliner::new(cx.tcx);
is_refutable(cx, &*static_inliner.fold_pat((*pat).clone()), |uncovered_pat| { is_refutable(cx, &*static_inliner.fold_pat((*pat).clone()), |uncovered_pat| {
cx.tcx.sess.span_err( cx.tcx.sess.span_err(
@ -232,7 +232,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
} }
} }
fn is_expr_const_nan(tcx: &ty::ctxt, expr: &Expr) -> bool { fn is_expr_const_nan(tcx: &ty::ctxt, expr: &ast::Expr) -> bool {
match eval_const_expr(tcx, expr) { match eval_const_expr(tcx, expr) {
const_float(f) => f.is_nan(), const_float(f) => f.is_nan(),
_ => false _ => false
@ -244,7 +244,7 @@ fn check_for_static_nan(cx: &MatchCheckCtxt, pats: &[P<Pat>]) {
for pat in pats.iter() { for pat in pats.iter() {
walk_pat(&**pat, |p| { walk_pat(&**pat, |p| {
match p.node { match p.node {
PatLit(ref expr) if is_expr_const_nan(cx.tcx, &**expr) => { ast::PatLit(ref expr) if is_expr_const_nan(cx.tcx, &**expr) => {
span_warn!(cx.tcx.sess, p.span, E0003, span_warn!(cx.tcx.sess, p.span, E0003,
"unmatchable NaN in pattern, \ "unmatchable NaN in pattern, \
use the is_nan method in a guard instead"); use the is_nan method in a guard instead");
@ -257,7 +257,9 @@ fn check_for_static_nan(cx: &MatchCheckCtxt, pats: &[P<Pat>]) {
} }
// Check for unreachable patterns // Check for unreachable patterns
fn check_arms(cx: &MatchCheckCtxt, arms: &[(Vec<P<Pat>>, Option<&Expr>)], source: MatchSource) { fn check_arms(cx: &MatchCheckCtxt,
arms: &[(Vec<P<Pat>>, Option<&ast::Expr>)],
source: ast::MatchSource) {
let mut seen = Matrix(vec![]); let mut seen = Matrix(vec![]);
let mut printed_if_let_err = false; let mut printed_if_let_err = false;
for &(ref pats, guard) in arms.iter() { for &(ref pats, guard) in arms.iter() {
@ -267,7 +269,7 @@ fn check_arms(cx: &MatchCheckCtxt, arms: &[(Vec<P<Pat>>, Option<&Expr>)], source
match is_useful(cx, &seen, v.as_slice(), LeaveOutWitness) { match is_useful(cx, &seen, v.as_slice(), LeaveOutWitness) {
NotUseful => { NotUseful => {
match source { match source {
MatchIfLetDesugar => { ast::MatchIfLetDesugar => {
if printed_if_let_err { if printed_if_let_err {
// we already printed an irrefutable if-let pattern error. // we already printed an irrefutable if-let pattern error.
// We don't want two, that's just confusing. // We don't want two, that's just confusing.
@ -281,7 +283,7 @@ fn check_arms(cx: &MatchCheckCtxt, arms: &[(Vec<P<Pat>>, Option<&Expr>)], source
} }
}, },
MatchWhileLetDesugar => { ast::MatchWhileLetDesugar => {
// find the first arm pattern so we can use its span // find the first arm pattern so we can use its span
let &(ref first_arm_pats, _) = &arms[0]; let &(ref first_arm_pats, _) = &arms[0];
let first_pat = &first_arm_pats[0]; let first_pat = &first_arm_pats[0];
@ -289,7 +291,7 @@ fn check_arms(cx: &MatchCheckCtxt, arms: &[(Vec<P<Pat>>, Option<&Expr>)], source
span_err!(cx.tcx.sess, span, E0165, "irrefutable while-let pattern"); span_err!(cx.tcx.sess, span, E0165, "irrefutable while-let pattern");
}, },
MatchNormal => { ast::MatchNormal => {
span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern") span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern")
}, },
} }
@ -308,7 +310,7 @@ fn check_arms(cx: &MatchCheckCtxt, arms: &[(Vec<P<Pat>>, Option<&Expr>)], source
fn raw_pat<'a>(p: &'a Pat) -> &'a Pat { fn raw_pat<'a>(p: &'a Pat) -> &'a Pat {
match p.node { match p.node {
PatIdent(_, _, Some(ref s)) => raw_pat(&**s), ast::PatIdent(_, _, Some(ref s)) => raw_pat(&**s),
_ => p _ => p
} }
} }
@ -333,14 +335,14 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) {
} }
} }
fn const_val_to_expr(value: &const_val) -> P<Expr> { fn const_val_to_expr(value: &const_val) -> P<ast::Expr> {
let node = match value { let node = match value {
&const_bool(b) => LitBool(b), &const_bool(b) => ast::LitBool(b),
_ => unreachable!() _ => unreachable!()
}; };
P(Expr { P(ast::Expr {
id: 0, id: 0,
node: ExprLit(P(Spanned { node: node, span: DUMMY_SP })), node: ast::ExprLit(P(Spanned { node: node, span: DUMMY_SP })),
span: DUMMY_SP span: DUMMY_SP
}) })
} }
@ -362,7 +364,7 @@ impl<'a, 'tcx> StaticInliner<'a, 'tcx> {
impl<'a, 'tcx> Folder for StaticInliner<'a, 'tcx> { impl<'a, 'tcx> Folder for StaticInliner<'a, 'tcx> {
fn fold_pat(&mut self, pat: P<Pat>) -> P<Pat> { fn fold_pat(&mut self, pat: P<Pat>) -> P<Pat> {
match pat.node { match pat.node {
PatIdent(..) | PatEnum(..) => { ast::PatIdent(..) | ast::PatEnum(..) => {
let def = self.tcx.def_map.borrow().get(&pat.id).cloned(); let def = self.tcx.def_map.borrow().get(&pat.id).cloned();
match def { match def {
Some(DefConst(did)) => match lookup_const_by_id(self.tcx, did) { Some(DefConst(did)) => match lookup_const_by_id(self.tcx, did) {
@ -405,7 +407,7 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
let pats_len = pats.len(); let pats_len = pats.len();
let mut pats = pats.into_iter().map(|p| P((*p).clone())); let mut pats = pats.into_iter().map(|p| P((*p).clone()));
let pat = match ty::get(left_ty).sty { let pat = match ty::get(left_ty).sty {
ty::ty_tup(_) => PatTup(pats.collect()), ty::ty_tup(_) => ast::PatTup(pats.collect()),
ty::ty_enum(cid, _) | ty::ty_struct(cid, _) => { ty::ty_enum(cid, _) | ty::ty_struct(cid, _) => {
let (vid, is_structure) = match ctor { let (vid, is_structure) = match ctor {
@ -417,21 +419,21 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
}; };
if is_structure { if is_structure {
let fields = ty::lookup_struct_fields(cx.tcx, vid); let fields = ty::lookup_struct_fields(cx.tcx, vid);
let field_pats: Vec<Spanned<FieldPat>> = fields.into_iter() let field_pats: Vec<_> = fields.into_iter()
.zip(pats) .zip(pats)
.filter(|&(_, ref pat)| pat.node != PatWild(PatWildSingle)) .filter(|&(_, ref pat)| pat.node != ast::PatWild(ast::PatWildSingle))
.map(|(field, pat)| Spanned { .map(|(field, pat)| Spanned {
span: DUMMY_SP, span: DUMMY_SP,
node: FieldPat { node: ast::FieldPat {
ident: Ident::new(field.name), ident: ast::Ident::new(field.name),
pat: pat, pat: pat,
is_shorthand: false, is_shorthand: false,
} }
}).collect(); }).collect();
let has_more_fields = field_pats.len() < pats_len; let has_more_fields = field_pats.len() < pats_len;
PatStruct(def_to_path(cx.tcx, vid), field_pats, has_more_fields) ast::PatStruct(def_to_path(cx.tcx, vid), field_pats, has_more_fields)
} else { } else {
PatEnum(def_to_path(cx.tcx, vid), Some(pats.collect())) ast::PatEnum(def_to_path(cx.tcx, vid), Some(pats.collect()))
} }
} }
@ -440,40 +442,40 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
ty::ty_vec(_, Some(n)) => match ctor { ty::ty_vec(_, Some(n)) => match ctor {
&Single => { &Single => {
assert_eq!(pats_len, n); assert_eq!(pats_len, n);
PatVec(pats.collect(), None, vec!()) ast::PatVec(pats.collect(), None, vec!())
}, },
_ => unreachable!() _ => unreachable!()
}, },
ty::ty_vec(_, None) => match ctor { ty::ty_vec(_, None) => match ctor {
&Slice(n) => { &Slice(n) => {
assert_eq!(pats_len, n); assert_eq!(pats_len, n);
PatVec(pats.collect(), None, vec!()) ast::PatVec(pats.collect(), None, vec!())
}, },
_ => unreachable!() _ => unreachable!()
}, },
ty::ty_str => PatWild(PatWildSingle), ty::ty_str => ast::PatWild(ast::PatWildSingle),
_ => { _ => {
assert_eq!(pats_len, 1); assert_eq!(pats_len, 1);
PatRegion(pats.nth(0).unwrap()) ast::PatRegion(pats.nth(0).unwrap())
} }
} }
} }
ty::ty_vec(_, Some(len)) => { ty::ty_vec(_, Some(len)) => {
assert_eq!(pats_len, len); assert_eq!(pats_len, len);
PatVec(pats.collect(), None, vec![]) ast::PatVec(pats.collect(), None, vec![])
} }
_ => { _ => {
match *ctor { match *ctor {
ConstantValue(ref v) => PatLit(const_val_to_expr(v)), ConstantValue(ref v) => ast::PatLit(const_val_to_expr(v)),
_ => PatWild(PatWildSingle), _ => ast::PatWild(ast::PatWildSingle),
} }
} }
}; };
P(Pat { P(ast::Pat {
id: 0, id: 0,
node: pat, node: pat,
span: DUMMY_SP span: DUMMY_SP
@ -558,7 +560,7 @@ fn is_useful(cx: &MatchCheckCtxt,
}; };
let max_slice_length = rows.iter().filter_map(|row| match row[0].node { let max_slice_length = rows.iter().filter_map(|row| match row[0].node {
PatVec(ref before, _, ref after) => Some(before.len() + after.len()), ast::PatVec(ref before, _, ref after) => Some(before.len() + after.len()),
_ => None _ => None
}).max().map_or(0, |v| v + 1); }).max().map_or(0, |v| v + 1);
@ -639,7 +641,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
left_ty: ty::t, max_slice_length: uint) -> Vec<Constructor> { left_ty: ty::t, max_slice_length: uint) -> Vec<Constructor> {
let pat = raw_pat(p); let pat = raw_pat(p);
match pat.node { match pat.node {
PatIdent(..) => ast::PatIdent(..) =>
match cx.tcx.def_map.borrow().get(&pat.id) { match cx.tcx.def_map.borrow().get(&pat.id) {
Some(&DefConst(..)) => Some(&DefConst(..)) =>
cx.tcx.sess.span_bug(pat.span, "const pattern should've \ cx.tcx.sess.span_bug(pat.span, "const pattern should've \
@ -648,7 +650,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
Some(&DefVariant(_, id, _)) => vec!(Variant(id)), Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
_ => vec!() _ => vec!()
}, },
PatEnum(..) => ast::PatEnum(..) =>
match cx.tcx.def_map.borrow().get(&pat.id) { match cx.tcx.def_map.borrow().get(&pat.id) {
Some(&DefConst(..)) => Some(&DefConst(..)) =>
cx.tcx.sess.span_bug(pat.span, "const pattern should've \ cx.tcx.sess.span_bug(pat.span, "const pattern should've \
@ -656,7 +658,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
Some(&DefVariant(_, id, _)) => vec!(Variant(id)), Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
_ => vec!(Single) _ => vec!(Single)
}, },
PatStruct(..) => ast::PatStruct(..) =>
match cx.tcx.def_map.borrow().get(&pat.id) { match cx.tcx.def_map.borrow().get(&pat.id) {
Some(&DefConst(..)) => Some(&DefConst(..)) =>
cx.tcx.sess.span_bug(pat.span, "const pattern should've \ cx.tcx.sess.span_bug(pat.span, "const pattern should've \
@ -664,11 +666,11 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
Some(&DefVariant(_, id, _)) => vec!(Variant(id)), Some(&DefVariant(_, id, _)) => vec!(Variant(id)),
_ => vec!(Single) _ => vec!(Single)
}, },
PatLit(ref expr) => ast::PatLit(ref expr) =>
vec!(ConstantValue(eval_const_expr(cx.tcx, &**expr))), vec!(ConstantValue(eval_const_expr(cx.tcx, &**expr))),
PatRange(ref lo, ref hi) => ast::PatRange(ref lo, ref hi) =>
vec!(ConstantRange(eval_const_expr(cx.tcx, &**lo), eval_const_expr(cx.tcx, &**hi))), vec!(ConstantRange(eval_const_expr(cx.tcx, &**lo), eval_const_expr(cx.tcx, &**hi))),
PatVec(ref before, ref slice, ref after) => ast::PatVec(ref before, ref slice, ref after) =>
match ty::get(left_ty).sty { match ty::get(left_ty).sty {
ty::ty_vec(_, Some(_)) => vec!(Single), ty::ty_vec(_, Some(_)) => vec!(Single),
_ => if slice.is_some() { _ => if slice.is_some() {
@ -679,11 +681,11 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
vec!(Slice(before.len() + after.len())) vec!(Slice(before.len() + after.len()))
} }
}, },
PatBox(_) | PatTup(_) | PatRegion(..) => ast::PatBox(_) | ast::PatTup(_) | ast::PatRegion(..) =>
vec!(Single), vec!(Single),
PatWild(_) => ast::PatWild(_) =>
vec!(), vec!(),
PatMac(_) => ast::PatMac(_) =>
cx.tcx.sess.bug("unexpanded macro") cx.tcx.sess.bug("unexpanded macro")
} }
} }
@ -747,12 +749,11 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
let &Pat { let &Pat {
id: pat_id, ref node, span: pat_span id: pat_id, ref node, span: pat_span
} = raw_pat(r[col]); } = raw_pat(r[col]);
let head: Option<Vec<&Pat>> = match node { let head: Option<Vec<&Pat>> = match *node {
ast::PatWild(_) =>
&PatWild(_) =>
Some(Vec::from_elem(arity, DUMMY_WILD_PAT)), Some(Vec::from_elem(arity, DUMMY_WILD_PAT)),
&PatIdent(_, _, _) => { ast::PatIdent(_, _, _) => {
let opt_def = cx.tcx.def_map.borrow().get(&pat_id).cloned(); let opt_def = cx.tcx.def_map.borrow().get(&pat_id).cloned();
match opt_def { match opt_def {
Some(DefConst(..)) => Some(DefConst(..)) =>
@ -767,7 +768,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
} }
} }
&PatEnum(_, ref args) => { ast::PatEnum(_, ref args) => {
let def = cx.tcx.def_map.borrow()[pat_id].clone(); let def = cx.tcx.def_map.borrow()[pat_id].clone();
match def { match def {
DefConst(..) => DefConst(..) =>
@ -784,7 +785,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
} }
} }
&PatStruct(_, ref pattern_fields, _) => { ast::PatStruct(_, ref pattern_fields, _) => {
// Is this a struct or an enum variant? // Is this a struct or an enum variant?
let def = cx.tcx.def_map.borrow()[pat_id].clone(); let def = cx.tcx.def_map.borrow()[pat_id].clone();
let class_id = match def { let class_id = match def {
@ -820,13 +821,13 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
}) })
} }
&PatTup(ref args) => ast::PatTup(ref args) =>
Some(args.iter().map(|p| &**p).collect()), Some(args.iter().map(|p| &**p).collect()),
&PatBox(ref inner) | &PatRegion(ref inner) => ast::PatBox(ref inner) | ast::PatRegion(ref inner) =>
Some(vec![&**inner]), Some(vec![&**inner]),
&PatLit(ref expr) => { ast::PatLit(ref expr) => {
let expr_value = eval_const_expr(cx.tcx, &**expr); let expr_value = eval_const_expr(cx.tcx, &**expr);
match range_covered_by_constructor(constructor, &expr_value, &expr_value) { match range_covered_by_constructor(constructor, &expr_value, &expr_value) {
Some(true) => Some(vec![]), Some(true) => Some(vec![]),
@ -838,7 +839,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
} }
} }
&PatRange(ref from, ref to) => { ast::PatRange(ref from, ref to) => {
let from_value = eval_const_expr(cx.tcx, &**from); let from_value = eval_const_expr(cx.tcx, &**from);
let to_value = eval_const_expr(cx.tcx, &**to); let to_value = eval_const_expr(cx.tcx, &**to);
match range_covered_by_constructor(constructor, &from_value, &to_value) { match range_covered_by_constructor(constructor, &from_value, &to_value) {
@ -851,7 +852,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
} }
} }
&PatVec(ref before, ref slice, ref after) => { ast::PatVec(ref before, ref slice, ref after) => {
match *constructor { match *constructor {
// Fixed-length vectors. // Fixed-length vectors.
Single => { Single => {
@ -883,7 +884,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
} }
} }
&PatMac(_) => { ast::PatMac(_) => {
cx.tcx.sess.span_err(pat_span, "unexpanded macro"); cx.tcx.sess.span_err(pat_span, "unexpanded macro");
None None
} }
@ -895,12 +896,12 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
}) })
} }
fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) { fn check_local(cx: &mut MatchCheckCtxt, loc: &ast::Local) {
visit::walk_local(cx, loc); visit::walk_local(cx, loc);
let name = match loc.source { let name = match loc.source {
LocalLet => "local", ast::LocalLet => "local",
LocalFor => "`for` loop" ast::LocalFor => "`for` loop"
}; };
let mut static_inliner = StaticInliner::new(cx.tcx); let mut static_inliner = StaticInliner::new(cx.tcx);
@ -918,8 +919,8 @@ fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) {
fn check_fn(cx: &mut MatchCheckCtxt, fn check_fn(cx: &mut MatchCheckCtxt,
kind: FnKind, kind: FnKind,
decl: &FnDecl, decl: &ast::FnDecl,
body: &Block, body: &ast::Block,
sp: Span, sp: Span,
_: NodeId) { _: NodeId) {
visit::walk_fn(cx, kind, decl, body, sp); visit::walk_fn(cx, kind, decl, body, sp);
@ -957,10 +958,10 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
for pat in pats.iter() { for pat in pats.iter() {
pat_bindings(def_map, &**pat, |bm, _, span, _path| { pat_bindings(def_map, &**pat, |bm, _, span, _path| {
match bm { match bm {
BindByRef(_) => { ast::BindByRef(_) => {
by_ref_span = Some(span); by_ref_span = Some(span);
} }
BindByValue(_) => { ast::BindByValue(_) => {
} }
} }
}) })
@ -985,13 +986,13 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
walk_pat(&**pat, |p| { walk_pat(&**pat, |p| {
if pat_is_binding(def_map, &*p) { if pat_is_binding(def_map, &*p) {
match p.node { match p.node {
PatIdent(BindByValue(_), _, ref sub) => { ast::PatIdent(ast::BindByValue(_), _, ref sub) => {
let pat_ty = ty::node_id_to_type(tcx, p.id); let pat_ty = ty::node_id_to_type(tcx, p.id);
if ty::type_moves_by_default(tcx, pat_ty) { if ty::type_moves_by_default(tcx, pat_ty) {
check_move(p, sub.as_ref().map(|p| &**p)); check_move(p, sub.as_ref().map(|p| &**p));
} }
} }
PatIdent(BindByRef(_), _, _) => { ast::PatIdent(ast::BindByRef(_), _, _) => {
} }
_ => { _ => {
cx.tcx.sess.span_bug( cx.tcx.sess.span_bug(
@ -1010,7 +1011,8 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
/// Ensures that a pattern guard doesn't borrow by mutable reference or /// Ensures that a pattern guard doesn't borrow by mutable reference or
/// assign. /// assign.
fn check_for_mutation_in_guard<'a, 'tcx>(cx: &'a MatchCheckCtxt<'a, 'tcx>, guard: &Expr) { fn check_for_mutation_in_guard<'a, 'tcx>(cx: &'a MatchCheckCtxt<'a, 'tcx>,
guard: &ast::Expr) {
let mut checker = MutationChecker { let mut checker = MutationChecker {
cx: cx, cx: cx,
}; };
@ -1078,7 +1080,7 @@ impl<'a, 'b, 'tcx, 'v> Visitor<'v> for AtBindingPatternVisitor<'a, 'b, 'tcx> {
} }
match pat.node { match pat.node {
PatIdent(_, _, Some(_)) => { ast::PatIdent(_, _, Some(_)) => {
let bindings_were_allowed = self.bindings_allowed; let bindings_were_allowed = self.bindings_allowed;
self.bindings_allowed = false; self.bindings_allowed = false;
visit::walk_pat(self, pat); visit::walk_pat(self, pat);

204
src/librustc/middle/const_eval.rs
View File

@ -23,12 +23,12 @@ use middle::typeck::astconv;
use middle::typeck::check; use middle::typeck::check;
use util::nodemap::{DefIdMap}; use util::nodemap::{DefIdMap};
use syntax::ast::*; use syntax::ast::{mod, Expr};
use syntax::parse::token::InternedString; use syntax::parse::token::InternedString;
use syntax::ptr::P; use syntax::ptr::P;
use syntax::visit::Visitor; use syntax::visit::Visitor;
use syntax::visit; use syntax::visit;
use syntax::{ast, ast_map, ast_util, codemap}; use syntax::{ast_map, ast_util, codemap};
use std::rc::Rc; use std::rc::Rc;
use std::collections::hash_map::Vacant; use std::collections::hash_map::Vacant;
@ -118,7 +118,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt,
match tcx.map.find(enum_def.node) { match tcx.map.find(enum_def.node) {
None => None, None => None,
Some(ast_map::NodeItem(it)) => match it.node { Some(ast_map::NodeItem(it)) => match it.node {
ItemEnum(ast::EnumDef { ref variants }, _) => { ast::ItemEnum(ast::EnumDef { ref variants }, _) => {
variant_expr(variants.as_slice(), variant_def.node) variant_expr(variants.as_slice(), variant_def.node)
} }
_ => None _ => None
@ -136,7 +136,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt,
let expr_id = match csearch::maybe_get_item_ast(tcx, enum_def, let expr_id = match csearch::maybe_get_item_ast(tcx, enum_def,
|a, b, c, d| astencode::decode_inlined_item(a, b, c, d)) { |a, b, c, d| astencode::decode_inlined_item(a, b, c, d)) {
csearch::found(&ast::IIItem(ref item)) => match item.node { csearch::found(&ast::IIItem(ref item)) => match item.node {
ItemEnum(ast::EnumDef { ref variants }, _) => { ast::ItemEnum(ast::EnumDef { ref variants }, _) => {
// NOTE this doesn't do the right thing, it compares inlined // NOTE this doesn't do the right thing, it compares inlined
// NodeId's to the original variant_def's NodeId, but they // NodeId's to the original variant_def's NodeId, but they
// come from different crates, so they will likely never match. // come from different crates, so they will likely never match.
@ -158,7 +158,7 @@ pub fn lookup_const_by_id<'a>(tcx: &'a ty::ctxt, def_id: ast::DefId)
match tcx.map.find(def_id.node) { match tcx.map.find(def_id.node) {
None => None, None => None,
Some(ast_map::NodeItem(it)) => match it.node { Some(ast_map::NodeItem(it)) => match it.node {
ItemConst(_, ref const_expr) => { ast::ItemConst(_, ref const_expr) => {
Some(&**const_expr) Some(&**const_expr)
} }
_ => None _ => None
@ -176,7 +176,7 @@ pub fn lookup_const_by_id<'a>(tcx: &'a ty::ctxt, def_id: ast::DefId)
let expr_id = match csearch::maybe_get_item_ast(tcx, def_id, let expr_id = match csearch::maybe_get_item_ast(tcx, def_id,
|a, b, c, d| astencode::decode_inlined_item(a, b, c, d)) { |a, b, c, d| astencode::decode_inlined_item(a, b, c, d)) {
csearch::found(&ast::IIItem(ref item)) => match item.node { csearch::found(&ast::IIItem(ref item)) => match item.node {
ItemConst(_, ref const_expr) => Some(const_expr.id), ast::ItemConst(_, ref const_expr) => Some(const_expr.id),
_ => None _ => None
}, },
_ => None _ => None
@ -280,9 +280,9 @@ impl<'a, 'tcx> ConstEvalVisitor<'a, 'tcx> {
} }
impl<'a, 'tcx, 'v> Visitor<'v> for ConstEvalVisitor<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for ConstEvalVisitor<'a, 'tcx> {
fn visit_ty(&mut self, t: &Ty) { fn visit_ty(&mut self, t: &ast::Ty) {
match t.node { match t.node {
TyFixedLengthVec(_, ref expr) => { ast::TyFixedLengthVec(_, ref expr) => {
check::check_const_in_type(self.tcx, &**expr, ty::mk_uint()); check::check_const_in_type(self.tcx, &**expr, ty::mk_uint());
} }
_ => {} _ => {}
@ -317,12 +317,12 @@ pub enum const_val {
const_bool(bool) const_bool(bool)
} }
pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P<Pat> { pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P<ast::Pat> {
let pat = match expr.node { let pat = match expr.node {
ExprTup(ref exprs) => ast::ExprTup(ref exprs) =>
PatTup(exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect()), ast::PatTup(exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect()),
ExprCall(ref callee, ref args) => { ast::ExprCall(ref callee, ref args) => {
let def = tcx.def_map.borrow()[callee.id].clone(); let def = tcx.def_map.borrow()[callee.id].clone();
match tcx.def_map.borrow_mut().entry(expr.id) { match tcx.def_map.borrow_mut().entry(expr.id) {
Vacant(entry) => { entry.set(def); } Vacant(entry) => { entry.set(def); }
@ -334,33 +334,33 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P<Pat> {
_ => unreachable!() _ => unreachable!()
}; };
let pats = args.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect(); let pats = args.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect();
PatEnum(path, Some(pats)) ast::PatEnum(path, Some(pats))
} }
ExprStruct(ref path, ref fields, None) => { ast::ExprStruct(ref path, ref fields, None) => {
let field_pats = fields.iter().map(|field| codemap::Spanned { let field_pats = fields.iter().map(|field| codemap::Spanned {
span: codemap::DUMMY_SP, span: codemap::DUMMY_SP,
node: FieldPat { node: ast::FieldPat {
ident: field.ident.node, ident: field.ident.node,
pat: const_expr_to_pat(tcx, &*field.expr), pat: const_expr_to_pat(tcx, &*field.expr),
is_shorthand: false, is_shorthand: false,
}, },
}).collect(); }).collect();
PatStruct(path.clone(), field_pats, false) ast::PatStruct(path.clone(), field_pats, false)
} }
ExprVec(ref exprs) => { ast::ExprVec(ref exprs) => {
let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect(); let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr)).collect();
PatVec(pats, None, vec![]) ast::PatVec(pats, None, vec![])
} }
ExprPath(ref path) => { ast::ExprPath(ref path) => {
let opt_def = tcx.def_map.borrow().get(&expr.id).cloned(); let opt_def = tcx.def_map.borrow().get(&expr.id).cloned();
match opt_def { match opt_def {
Some(def::DefStruct(..)) => Some(def::DefStruct(..)) =>
PatStruct(path.clone(), vec![], false), ast::PatStruct(path.clone(), vec![], false),
Some(def::DefVariant(..)) => Some(def::DefVariant(..)) =>
PatEnum(path.clone(), None), ast::PatEnum(path.clone(), None),
_ => { _ => {
match lookup_const(tcx, expr) { match lookup_const(tcx, expr) {
Some(actual) => return const_expr_to_pat(tcx, actual), Some(actual) => return const_expr_to_pat(tcx, actual),
@ -370,9 +370,9 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P<Pat> {
} }
} }
_ => PatLit(P(expr.clone())) _ => ast::PatLit(P(expr.clone()))
}; };
P(Pat { id: expr.id, node: pat, span: expr.span }) P(ast::Pat { id: expr.id, node: pat, span: expr.span })
} }
pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val { pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val {
@ -385,7 +385,7 @@ pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val {
pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, String> { pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, String> {
fn fromb(b: bool) -> Result<const_val, String> { Ok(const_int(b as i64)) } fn fromb(b: bool) -> Result<const_val, String> { Ok(const_int(b as i64)) }
match e.node { match e.node {
ExprUnary(UnNeg, ref inner) => { ast::ExprUnary(ast::UnNeg, ref inner) => {
match eval_const_expr_partial(tcx, &**inner) { match eval_const_expr_partial(tcx, &**inner) {
Ok(const_float(f)) => Ok(const_float(-f)), Ok(const_float(f)) => Ok(const_float(-f)),
Ok(const_int(i)) => Ok(const_int(-i)), Ok(const_int(i)) => Ok(const_int(-i)),
@ -395,7 +395,7 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
ref err => ((*err).clone()) ref err => ((*err).clone())
} }
} }
ExprUnary(UnNot, ref inner) => { ast::ExprUnary(ast::UnNot, ref inner) => {
match eval_const_expr_partial(tcx, &**inner) { match eval_const_expr_partial(tcx, &**inner) {
Ok(const_int(i)) => Ok(const_int(!i)), Ok(const_int(i)) => Ok(const_int(!i)),
Ok(const_uint(i)) => Ok(const_uint(!i)), Ok(const_uint(i)) => Ok(const_uint(!i)),
@ -403,110 +403,110 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
_ => Err("not on float or string".to_string()) _ => Err("not on float or string".to_string())
} }
} }
ExprBinary(op, ref a, ref b) => { ast::ExprBinary(op, ref a, ref b) => {
match (eval_const_expr_partial(tcx, &**a), match (eval_const_expr_partial(tcx, &**a),
eval_const_expr_partial(tcx, &**b)) { eval_const_expr_partial(tcx, &**b)) {
(Ok(const_float(a)), Ok(const_float(b))) => { (Ok(const_float(a)), Ok(const_float(b))) => {
match op { match op {
BiAdd => Ok(const_float(a + b)), ast::BiAdd => Ok(const_float(a + b)),
BiSub => Ok(const_float(a - b)), ast::BiSub => Ok(const_float(a - b)),
BiMul => Ok(const_float(a * b)), ast::BiMul => Ok(const_float(a * b)),
BiDiv => Ok(const_float(a / b)), ast::BiDiv => Ok(const_float(a / b)),
BiRem => Ok(const_float(a % b)), ast::BiRem => Ok(const_float(a % b)),
BiEq => fromb(a == b), ast::BiEq => fromb(a == b),
BiLt => fromb(a < b), ast::BiLt => fromb(a < b),
BiLe => fromb(a <= b), ast::BiLe => fromb(a <= b),
BiNe => fromb(a != b), ast::BiNe => fromb(a != b),
BiGe => fromb(a >= b), ast::BiGe => fromb(a >= b),
BiGt => fromb(a > b), ast::BiGt => fromb(a > b),
_ => Err("can't do this op on floats".to_string()) _ => Err("can't do this op on floats".to_string())
} }
} }
(Ok(const_int(a)), Ok(const_int(b))) => { (Ok(const_int(a)), Ok(const_int(b))) => {
match op { match op {
BiAdd => Ok(const_int(a + b)), ast::BiAdd => Ok(const_int(a + b)),
BiSub => Ok(const_int(a - b)), ast::BiSub => Ok(const_int(a - b)),
BiMul => Ok(const_int(a * b)), ast::BiMul => Ok(const_int(a * b)),
BiDiv if b == 0 => { ast::BiDiv if b == 0 => {
Err("attempted to divide by zero".to_string()) Err("attempted to divide by zero".to_string())
} }
BiDiv => Ok(const_int(a / b)), ast::BiDiv => Ok(const_int(a / b)),
BiRem if b == 0 => { ast::BiRem if b == 0 => {
Err("attempted remainder with a divisor of \ Err("attempted remainder with a divisor of \
zero".to_string()) zero".to_string())
} }
BiRem => Ok(const_int(a % b)), ast::BiRem => Ok(const_int(a % b)),
BiAnd | BiBitAnd => Ok(const_int(a & b)), ast::BiAnd | ast::BiBitAnd => Ok(const_int(a & b)),
BiOr | BiBitOr => Ok(const_int(a | b)), ast::BiOr | ast::BiBitOr => Ok(const_int(a | b)),
BiBitXor => Ok(const_int(a ^ b)), ast::BiBitXor => Ok(const_int(a ^ b)),
BiShl => Ok(const_int(a << b as uint)), ast::BiShl => Ok(const_int(a << b as uint)),
BiShr => Ok(const_int(a >> b as uint)), ast::BiShr => Ok(const_int(a >> b as uint)),
BiEq => fromb(a == b), ast::BiEq => fromb(a == b),
BiLt => fromb(a < b), ast::BiLt => fromb(a < b),
BiLe => fromb(a <= b), ast::BiLe => fromb(a <= b),
BiNe => fromb(a != b), ast::BiNe => fromb(a != b),
BiGe => fromb(a >= b), ast::BiGe => fromb(a >= b),
BiGt => fromb(a > b) ast::BiGt => fromb(a > b)
} }
} }
(Ok(const_uint(a)), Ok(const_uint(b))) => { (Ok(const_uint(a)), Ok(const_uint(b))) => {
match op { match op {
BiAdd => Ok(const_uint(a + b)), ast::BiAdd => Ok(const_uint(a + b)),
BiSub => Ok(const_uint(a - b)), ast::BiSub => Ok(const_uint(a - b)),
BiMul => Ok(const_uint(a * b)), ast::BiMul => Ok(const_uint(a * b)),
BiDiv if b == 0 => { ast::BiDiv if b == 0 => {
Err("attempted to divide by zero".to_string()) Err("attempted to divide by zero".to_string())
} }
BiDiv => Ok(const_uint(a / b)), ast::BiDiv => Ok(const_uint(a / b)),
BiRem if b == 0 => { ast::BiRem if b == 0 => {
Err("attempted remainder with a divisor of \ Err("attempted remainder with a divisor of \
zero".to_string()) zero".to_string())
} }
BiRem => Ok(const_uint(a % b)), ast::BiRem => Ok(const_uint(a % b)),
BiAnd | BiBitAnd => Ok(const_uint(a & b)), ast::BiAnd | ast::BiBitAnd => Ok(const_uint(a & b)),
BiOr | BiBitOr => Ok(const_uint(a | b)), ast::BiOr | ast::BiBitOr => Ok(const_uint(a | b)),
BiBitXor => Ok(const_uint(a ^ b)), ast::BiBitXor => Ok(const_uint(a ^ b)),
BiShl => Ok(const_uint(a << b as uint)), ast::BiShl => Ok(const_uint(a << b as uint)),
BiShr => Ok(const_uint(a >> b as uint)), ast::BiShr => Ok(const_uint(a >> b as uint)),
BiEq => fromb(a == b), ast::BiEq => fromb(a == b),
BiLt => fromb(a < b), ast::BiLt => fromb(a < b),
BiLe => fromb(a <= b), ast::BiLe => fromb(a <= b),
BiNe => fromb(a != b), ast::BiNe => fromb(a != b),
BiGe => fromb(a >= b), ast::BiGe => fromb(a >= b),
BiGt => fromb(a > b), ast::BiGt => fromb(a > b),
} }
} }
// shifts can have any integral type as their rhs // shifts can have any integral type as their rhs
(Ok(const_int(a)), Ok(const_uint(b))) => { (Ok(const_int(a)), Ok(const_uint(b))) => {
match op { match op {
BiShl => Ok(const_int(a << b as uint)), ast::BiShl => Ok(const_int(a << b as uint)),
BiShr => Ok(const_int(a >> b as uint)), ast::BiShr => Ok(const_int(a >> b as uint)),
_ => Err("can't do this op on an int and uint".to_string()) _ => Err("can't do this op on an int and uint".to_string())
} }
} }
(Ok(const_uint(a)), Ok(const_int(b))) => { (Ok(const_uint(a)), Ok(const_int(b))) => {
match op { match op {
BiShl => Ok(const_uint(a << b as uint)), ast::BiShl => Ok(const_uint(a << b as uint)),
BiShr => Ok(const_uint(a >> b as uint)), ast::BiShr => Ok(const_uint(a >> b as uint)),
_ => Err("can't do this op on a uint and int".to_string()) _ => Err("can't do this op on a uint and int".to_string())
} }
} }
(Ok(const_bool(a)), Ok(const_bool(b))) => { (Ok(const_bool(a)), Ok(const_bool(b))) => {
Ok(const_bool(match op { Ok(const_bool(match op {
BiAnd => a && b, ast::BiAnd => a && b,
BiOr => a || b, ast::BiOr => a || b,
BiBitXor => a ^ b, ast::BiBitXor => a ^ b,
BiBitAnd => a & b, ast::BiBitAnd => a & b,
BiBitOr => a | b, ast::BiBitOr => a | b,
BiEq => a == b, ast::BiEq => a == b,
BiNe => a != b, ast::BiNe => a != b,
_ => return Err("can't do this op on bools".to_string()) _ => return Err("can't do this op on bools".to_string())
})) }))
} }
_ => Err("bad operands for binary".to_string()) _ => Err("bad operands for binary".to_string())
} }
} }
ExprCast(ref base, ref target_ty) => { ast::ExprCast(ref base, ref target_ty) => {
// This tends to get called w/o the type actually having been // This tends to get called w/o the type actually having been
// populated in the ctxt, which was causing things to blow up // populated in the ctxt, which was causing things to blow up
// (#5900). Fall back to doing a limited lookup to get past it. // (#5900). Fall back to doing a limited lookup to get past it.
@ -556,15 +556,15 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
ty::ty_float(ast::TyF64) => (f64, const_float, f64) ty::ty_float(ast::TyF64) => (f64, const_float, f64)
})) }))
} }
ExprPath(_) => { ast::ExprPath(_) => {
match lookup_const(tcx, e) { match lookup_const(tcx, e) {
Some(actual_e) => eval_const_expr_partial(tcx, &*actual_e), Some(actual_e) => eval_const_expr_partial(tcx, &*actual_e),
None => Err("non-constant path in constant expr".to_string()) None => Err("non-constant path in constant expr".to_string())
} }
} }
ExprLit(ref lit) => Ok(lit_to_const(&**lit)), ast::ExprLit(ref lit) => Ok(lit_to_const(&**lit)),
ExprParen(ref e) => eval_const_expr_partial(tcx, &**e), ast::ExprParen(ref e) => eval_const_expr_partial(tcx, &**e),
ExprBlock(ref block) => { ast::ExprBlock(ref block) => {
match block.expr { match block.expr {
Some(ref expr) => eval_const_expr_partial(tcx, &**expr), Some(ref expr) => eval_const_expr_partial(tcx, &**expr),
None => Ok(const_int(0i64)) None => Ok(const_int(0i64))
@ -574,24 +574,24 @@ pub fn eval_const_expr_partial(tcx: &ty::ctxt, e: &Expr) -> Result<const_val, St
} }
} }
pub fn lit_to_const(lit: &Lit) -> const_val { pub fn lit_to_const(lit: &ast::Lit) -> const_val {
match lit.node { match lit.node {
LitStr(ref s, _) => const_str((*s).clone()), ast::LitStr(ref s, _) => const_str((*s).clone()),
LitBinary(ref data) => { ast::LitBinary(ref data) => {
const_binary(Rc::new(data.iter().map(|x| *x).collect())) const_binary(Rc::new(data.iter().map(|x| *x).collect()))
} }
LitByte(n) => const_uint(n as u64), ast::LitByte(n) => const_uint(n as u64),
LitChar(n) => const_uint(n as u64), ast::LitChar(n) => const_uint(n as u64),
LitInt(n, ast::SignedIntLit(_, ast::Plus)) | ast::LitInt(n, ast::SignedIntLit(_, ast::Plus)) |
LitInt(n, ast::UnsuffixedIntLit(ast::Plus)) => const_int(n as i64), ast::LitInt(n, ast::UnsuffixedIntLit(ast::Plus)) => const_int(n as i64),
LitInt(n, ast::SignedIntLit(_, ast::Minus)) | ast::LitInt(n, ast::SignedIntLit(_, ast::Minus)) |
LitInt(n, ast::UnsuffixedIntLit(ast::Minus)) => const_int(-(n as i64)), ast::LitInt(n, ast::UnsuffixedIntLit(ast::Minus)) => const_int(-(n as i64)),
LitInt(n, ast::UnsignedIntLit(_)) => const_uint(n), ast::LitInt(n, ast::UnsignedIntLit(_)) => const_uint(n),
LitFloat(ref n, _) | ast::LitFloat(ref n, _) |
LitFloatUnsuffixed(ref n) => { ast::LitFloatUnsuffixed(ref n) => {
const_float(from_str::<f64>(n.get()).unwrap() as f64) const_float(from_str::<f64>(n.get()).unwrap() as f64)
} }
LitBool(b) => const_bool(b) ast::LitBool(b) => const_bool(b)
} }
} }

216
src/librustc/middle/liveness.rs
View File

@ -123,8 +123,7 @@ use std::fmt;
use std::io; use std::io;
use std::rc::Rc; use std::rc::Rc;
use std::uint; use std::uint;
use syntax::ast; use syntax::ast::{mod, NodeId, Expr};
use syntax::ast::*;
use syntax::codemap::{BytePos, original_sp, Span}; use syntax::codemap::{BytePos, original_sp, Span};
use syntax::parse::token::special_idents; use syntax::parse::token::special_idents;
use syntax::parse::token; use syntax::parse::token;
@ -140,7 +139,7 @@ enum LoopKind<'a> {
/// A `while` loop, with the given expression as condition. /// A `while` loop, with the given expression as condition.
WhileLoop(&'a Expr), WhileLoop(&'a Expr),
/// A `for` loop, with the given pattern to bind. /// A `for` loop, with the given pattern to bind.
ForLoop(&'a Pat), ForLoop(&'a ast::Pat),
} }
#[deriving(PartialEq)] #[deriving(PartialEq)]
@ -187,12 +186,13 @@ fn live_node_kind_to_string(lnk: LiveNodeKind, cx: &ty::ctxt) -> String {
} }
impl<'a, 'tcx, 'v> Visitor<'v> for IrMaps<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for IrMaps<'a, 'tcx> {
fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, id: ast::NodeId) { fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v ast::FnDecl,
b: &'v ast::Block, s: Span, id: NodeId) {
visit_fn(self, fk, fd, b, s, id); visit_fn(self, fk, fd, b, s, id);
} }
fn visit_local(&mut self, l: &ast::Local) { visit_local(self, l); } fn visit_local(&mut self, l: &ast::Local) { visit_local(self, l); }
fn visit_expr(&mut self, ex: &Expr) { visit_expr(self, ex); } fn visit_expr(&mut self, ex: &Expr) { visit_expr(self, ex); }
fn visit_arm(&mut self, a: &Arm) { visit_arm(self, a); } fn visit_arm(&mut self, a: &ast::Arm) { visit_arm(self, a); }
} }
pub fn check_crate(tcx: &ty::ctxt) { pub fn check_crate(tcx: &ty::ctxt) {
@ -250,12 +250,12 @@ struct CaptureInfo {
#[deriving(Show)] #[deriving(Show)]
struct LocalInfo { struct LocalInfo {
id: NodeId, id: NodeId,
ident: Ident ident: ast::Ident
} }
#[deriving(Show)] #[deriving(Show)]
enum VarKind { enum VarKind {
Arg(NodeId, Ident), Arg(NodeId, ast::Ident),
Local(LocalInfo), Local(LocalInfo),
ImplicitRet, ImplicitRet,
CleanExit CleanExit
@ -354,7 +354,8 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> {
} }
impl<'a, 'tcx, 'v> Visitor<'v> for Liveness<'a, 'tcx> { impl<'a, 'tcx, 'v> Visitor<'v> for Liveness<'a, 'tcx> {
fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, n: NodeId) { fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v ast::FnDecl,
b: &'v ast::Block, s: Span, n: NodeId) {
check_fn(self, fk, fd, b, s, n); check_fn(self, fk, fd, b, s, n);
} }
fn visit_local(&mut self, l: &ast::Local) { fn visit_local(&mut self, l: &ast::Local) {
@ -363,15 +364,15 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Liveness<'a, 'tcx> {
fn visit_expr(&mut self, ex: &Expr) { fn visit_expr(&mut self, ex: &Expr) {
check_expr(self, ex); check_expr(self, ex);
} }
fn visit_arm(&mut self, a: &Arm) { fn visit_arm(&mut self, a: &ast::Arm) {
check_arm(self, a); check_arm(self, a);
} }
} }
fn visit_fn(ir: &mut IrMaps, fn visit_fn(ir: &mut IrMaps,
fk: FnKind, fk: FnKind,
decl: &FnDecl, decl: &ast::FnDecl,
body: &Block, body: &ast::Block,
sp: Span, sp: Span,
id: ast::NodeId) { id: ast::NodeId) {
debug!("visit_fn"); debug!("visit_fn");
@ -429,7 +430,7 @@ fn visit_local(ir: &mut IrMaps, local: &ast::Local) {
visit::walk_local(ir, local); visit::walk_local(ir, local);
} }
fn visit_arm(ir: &mut IrMaps, arm: &Arm) { fn visit_arm(ir: &mut IrMaps, arm: &ast::Arm) {
for pat in arm.pats.iter() { for pat in arm.pats.iter() {
pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| { pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| {
debug!("adding local variable {} from match with bm {}", debug!("adding local variable {} from match with bm {}",
@ -448,7 +449,7 @@ fn visit_arm(ir: &mut IrMaps, arm: &Arm) {
fn visit_expr(ir: &mut IrMaps, expr: &Expr) { fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
match expr.node { match expr.node {
// live nodes required for uses or definitions of variables: // live nodes required for uses or definitions of variables:
ExprPath(_) => { ast::ExprPath(_) => {
let def = ir.tcx.def_map.borrow()[expr.id].clone(); let def = ir.tcx.def_map.borrow()[expr.id].clone();
debug!("expr {}: path that leads to {}", expr.id, def); debug!("expr {}: path that leads to {}", expr.id, def);
match def { match def {
@ -457,7 +458,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
} }
visit::walk_expr(ir, expr); visit::walk_expr(ir, expr);
} }
ExprFnBlock(..) | ExprProc(..) | ExprUnboxedFn(..) => { ast::ExprFnBlock(..) | ast::ExprProc(..) | ast::ExprUnboxedFn(..) => {
// Interesting control flow (for loops can contain labeled // Interesting control flow (for loops can contain labeled
// breaks or continues) // breaks or continues)
ir.add_live_node_for_node(expr.id, ExprNode(expr.span)); ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
@ -485,17 +486,17 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
} }
// live nodes required for interesting control flow: // live nodes required for interesting control flow:
ExprIf(..) | ExprMatch(..) | ExprWhile(..) | ExprLoop(..) => { ast::ExprIf(..) | ast::ExprMatch(..) | ast::ExprWhile(..) | ast::ExprLoop(..) => {
ir.add_live_node_for_node(expr.id, ExprNode(expr.span)); ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
visit::walk_expr(ir, expr); visit::walk_expr(ir, expr);
} }
ExprIfLet(..) => { ast::ExprIfLet(..) => {
ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet"); ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
} }
ExprWhileLet(..) => { ast::ExprWhileLet(..) => {
ir.tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet"); ir.tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet");
} }
ExprForLoop(ref pat, _, _, _) => { ast::ExprForLoop(ref pat, _, _, _) => {
pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| { pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| {
debug!("adding local variable {} from for loop with bm {}", debug!("adding local variable {} from for loop with bm {}",
p_id, bm); p_id, bm);
@ -509,20 +510,21 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
ir.add_live_node_for_node(expr.id, ExprNode(expr.span)); ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
visit::walk_expr(ir, expr); visit::walk_expr(ir, expr);
} }
ExprBinary(op, _, _) if ast_util::lazy_binop(op) => { ast::ExprBinary(op, _, _) if ast_util::lazy_binop(op) => {
ir.add_live_node_for_node(expr.id, ExprNode(expr.span)); ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
visit::walk_expr(ir, expr); visit::walk_expr(ir, expr);
} }
// otherwise, live nodes are not required: // otherwise, live nodes are not required:
ExprIndex(..) | ExprField(..) | ExprTupField(..) | ExprVec(..) | ast::ExprIndex(..) | ast::ExprField(..) | ast::ExprTupField(..) |
ExprCall(..) | ExprMethodCall(..) | ExprTup(..) | ExprSlice(..) | ast::ExprVec(..) | ast::ExprCall(..) | ast::ExprMethodCall(..) |
ExprBinary(..) | ExprAddrOf(..) | ast::ExprTup(..) | ast::ExprBinary(..) | ast::ExprAddrOf(..) |
ExprCast(..) | ExprUnary(..) | ExprBreak(_) | ast::ExprCast(..) | ast::ExprUnary(..) | ast::ExprBreak(_) |
ExprAgain(_) | ExprLit(_) | ExprRet(..) | ExprBlock(..) | ast::ExprAgain(_) | ast::ExprLit(_) | ast::ExprRet(..) |
ExprAssign(..) | ExprAssignOp(..) | ExprMac(..) | ast::ExprBlock(..) | ast::ExprAssign(..) | ast::ExprAssignOp(..) |
ExprStruct(..) | ExprRepeat(..) | ExprParen(..) | ast::ExprMac(..) | ast::ExprStruct(..) | ast::ExprRepeat(..) |
ExprInlineAsm(..) | ExprBox(..) => { ast::ExprParen(..) | ast::ExprInlineAsm(..) | ast::ExprBox(..) |
ast::ExprSlice(..) => {
visit::walk_expr(ir, expr); visit::walk_expr(ir, expr);
} }
} }
@ -611,7 +613,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
fn pat_bindings(&mut self, fn pat_bindings(&mut self,
pat: &Pat, pat: &ast::Pat,
f: |&mut Liveness<'a, 'tcx>, LiveNode, Variable, Span, NodeId|) { f: |&mut Liveness<'a, 'tcx>, LiveNode, Variable, Span, NodeId|) {
pat_util::pat_bindings(&self.ir.tcx.def_map, pat, |_bm, p_id, sp, _n| { pat_util::pat_bindings(&self.ir.tcx.def_map, pat, |_bm, p_id, sp, _n| {
let ln = self.live_node(p_id, sp); let ln = self.live_node(p_id, sp);
@ -621,7 +623,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
fn arm_pats_bindings(&mut self, fn arm_pats_bindings(&mut self,
pat: Option<&Pat>, pat: Option<&ast::Pat>,
f: |&mut Liveness<'a, 'tcx>, LiveNode, Variable, Span, NodeId|) { f: |&mut Liveness<'a, 'tcx>, LiveNode, Variable, Span, NodeId|) {
match pat { match pat {
Some(pat) => { Some(pat) => {
@ -631,12 +633,12 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
} }
fn define_bindings_in_pat(&mut self, pat: &Pat, succ: LiveNode) fn define_bindings_in_pat(&mut self, pat: &ast::Pat, succ: LiveNode)
-> LiveNode { -> LiveNode {
self.define_bindings_in_arm_pats(Some(pat), succ) self.define_bindings_in_arm_pats(Some(pat), succ)
} }
fn define_bindings_in_arm_pats(&mut self, pat: Option<&Pat>, succ: LiveNode) fn define_bindings_in_arm_pats(&mut self, pat: Option<&ast::Pat>, succ: LiveNode)
-> LiveNode { -> LiveNode {
let mut succ = succ; let mut succ = succ;
self.arm_pats_bindings(pat, |this, ln, var, _sp, _id| { self.arm_pats_bindings(pat, |this, ln, var, _sp, _id| {
@ -711,7 +713,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
fn find_loop_scope(&self, fn find_loop_scope(&self,
opt_label: Option<Ident>, opt_label: Option<ast::Ident>,
id: NodeId, id: NodeId,
sp: Span) sp: Span)
-> NodeId { -> NodeId {
@ -846,7 +848,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
// _______________________________________________________________________ // _______________________________________________________________________
fn compute(&mut self, decl: &FnDecl, body: &Block) -> LiveNode { fn compute(&mut self, decl: &ast::FnDecl, body: &ast::Block) -> LiveNode {
// if there is a `break` or `again` at the top level, then it's // if there is a `break` or `again` at the top level, then it's
// effectively a return---this only occurs in `for` loops, // effectively a return---this only occurs in `for` loops,
// where the body is really a closure. // where the body is really a closure.
@ -871,7 +873,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
entry_ln entry_ln
} }
fn propagate_through_fn_block(&mut self, _: &FnDecl, blk: &Block) fn propagate_through_fn_block(&mut self, _: &ast::FnDecl, blk: &ast::Block)
-> LiveNode { -> LiveNode {
// the fallthrough exit is only for those cases where we do not // the fallthrough exit is only for those cases where we do not
// explicitly return: // explicitly return:
@ -885,7 +887,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.propagate_through_block(blk, s.fallthrough_ln) self.propagate_through_block(blk, s.fallthrough_ln)
} }
fn propagate_through_block(&mut self, blk: &Block, succ: LiveNode) fn propagate_through_block(&mut self, blk: &ast::Block, succ: LiveNode)
-> LiveNode { -> LiveNode {
let succ = self.propagate_through_opt_expr(blk.expr.as_ref().map(|e| &**e), succ); let succ = self.propagate_through_opt_expr(blk.expr.as_ref().map(|e| &**e), succ);
blk.stmts.iter().rev().fold(succ, |succ, stmt| { blk.stmts.iter().rev().fold(succ, |succ, stmt| {
@ -893,30 +895,30 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
}) })
} }
fn propagate_through_stmt(&mut self, stmt: &Stmt, succ: LiveNode) fn propagate_through_stmt(&mut self, stmt: &ast::Stmt, succ: LiveNode)
-> LiveNode { -> LiveNode {
match stmt.node { match stmt.node {
StmtDecl(ref decl, _) => { ast::StmtDecl(ref decl, _) => {
self.propagate_through_decl(&**decl, succ) self.propagate_through_decl(&**decl, succ)
} }
StmtExpr(ref expr, _) | StmtSemi(ref expr, _) => { ast::StmtExpr(ref expr, _) | ast::StmtSemi(ref expr, _) => {
self.propagate_through_expr(&**expr, succ) self.propagate_through_expr(&**expr, succ)
} }
StmtMac(..) => { ast::StmtMac(..) => {
self.ir.tcx.sess.span_bug(stmt.span, "unexpanded macro"); self.ir.tcx.sess.span_bug(stmt.span, "unexpanded macro");
} }
} }
} }
fn propagate_through_decl(&mut self, decl: &Decl, succ: LiveNode) fn propagate_through_decl(&mut self, decl: &ast::Decl, succ: LiveNode)
-> LiveNode { -> LiveNode {
match decl.node { match decl.node {
DeclLocal(ref local) => { ast::DeclLocal(ref local) => {
self.propagate_through_local(&**local, succ) self.propagate_through_local(&**local, succ)
} }
DeclItem(_) => succ, ast::DeclItem(_) => succ,
} }
} }
@ -961,21 +963,21 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
match expr.node { match expr.node {
// Interesting cases with control flow or which gen/kill // Interesting cases with control flow or which gen/kill
ExprPath(_) => { ast::ExprPath(_) => {
self.access_path(expr, succ, ACC_READ | ACC_USE) self.access_path(expr, succ, ACC_READ | ACC_USE)
} }
ExprField(ref e, _, _) => { ast::ExprField(ref e, _, _) => {
self.propagate_through_expr(&**e, succ) self.propagate_through_expr(&**e, succ)
} }
ExprTupField(ref e, _, _) => { ast::ExprTupField(ref e, _, _) => {
self.propagate_through_expr(&**e, succ) self.propagate_through_expr(&**e, succ)
} }
ExprFnBlock(_, _, ref blk) | ast::ExprFnBlock(_, _, ref blk) |
ExprProc(_, ref blk) | ast::ExprProc(_, ref blk) |
ExprUnboxedFn(_, _, _, ref blk) => { ast::ExprUnboxedFn(_, _, _, ref blk) => {
debug!("{} is an ExprFnBlock, ExprProc, or ExprUnboxedFn", debug!("{} is an ExprFnBlock, ExprProc, or ExprUnboxedFn",
expr_to_string(expr)); expr_to_string(expr));
@ -1003,7 +1005,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
}) })
} }
ExprIf(ref cond, ref then, ref els) => { ast::ExprIf(ref cond, ref then, ref els) => {
// //
// (cond) // (cond)
// | // |
@ -1025,30 +1027,30 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.propagate_through_expr(&**cond, ln) self.propagate_through_expr(&**cond, ln)
} }
ExprIfLet(..) => { ast::ExprIfLet(..) => {
self.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet"); self.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
} }
ExprWhile(ref cond, ref blk, _) => { ast::ExprWhile(ref cond, ref blk, _) => {
self.propagate_through_loop(expr, WhileLoop(&**cond), &**blk, succ) self.propagate_through_loop(expr, WhileLoop(&**cond), &**blk, succ)
} }
ExprWhileLet(..) => { ast::ExprWhileLet(..) => {
self.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet"); self.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet");
} }
ExprForLoop(ref pat, ref head, ref blk, _) => { ast::ExprForLoop(ref pat, ref head, ref blk, _) => {
let ln = self.propagate_through_loop(expr, ForLoop(&**pat), &**blk, succ); let ln = self.propagate_through_loop(expr, ForLoop(&**pat), &**blk, succ);
self.propagate_through_expr(&**head, ln) self.propagate_through_expr(&**head, ln)
} }
// Note that labels have been resolved, so we don't need to look // Note that labels have been resolved, so we don't need to look
// at the label ident // at the label ident
ExprLoop(ref blk, _) => { ast::ExprLoop(ref blk, _) => {
self.propagate_through_loop(expr, LoopLoop, &**blk, succ) self.propagate_through_loop(expr, LoopLoop, &**blk, succ)
} }
ExprMatch(ref e, ref arms, _) => { ast::ExprMatch(ref e, ref arms, _) => {
// //
// (e) // (e)
// | // |
@ -1083,13 +1085,13 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.propagate_through_expr(&**e, ln) self.propagate_through_expr(&**e, ln)
} }
ExprRet(ref o_e) => { ast::ExprRet(ref o_e) => {
// ignore succ and subst exit_ln: // ignore succ and subst exit_ln:
let exit_ln = self.s.exit_ln; let exit_ln = self.s.exit_ln;
self.propagate_through_opt_expr(o_e.as_ref().map(|e| &**e), exit_ln) self.propagate_through_opt_expr(o_e.as_ref().map(|e| &**e), exit_ln)
} }
ExprBreak(opt_label) => { ast::ExprBreak(opt_label) => {
// Find which label this break jumps to // Find which label this break jumps to
let sc = self.find_loop_scope(opt_label, expr.id, expr.span); let sc = self.find_loop_scope(opt_label, expr.id, expr.span);
@ -1103,7 +1105,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
} }
ExprAgain(opt_label) => { ast::ExprAgain(opt_label) => {
// Find which label this expr continues to // Find which label this expr continues to
let sc = self.find_loop_scope(opt_label, expr.id, expr.span); let sc = self.find_loop_scope(opt_label, expr.id, expr.span);
@ -1117,7 +1119,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
} }
ExprAssign(ref l, ref r) => { ast::ExprAssign(ref l, ref r) => {
// see comment on lvalues in // see comment on lvalues in
// propagate_through_lvalue_components() // propagate_through_lvalue_components()
let succ = self.write_lvalue(&**l, succ, ACC_WRITE); let succ = self.write_lvalue(&**l, succ, ACC_WRITE);
@ -1125,7 +1127,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.propagate_through_expr(&**r, succ) self.propagate_through_expr(&**r, succ)
} }
ExprAssignOp(_, ref l, ref r) => { ast::ExprAssignOp(_, ref l, ref r) => {
// see comment on lvalues in // see comment on lvalues in
// propagate_through_lvalue_components() // propagate_through_lvalue_components()
let succ = self.write_lvalue(&**l, succ, ACC_WRITE|ACC_READ); let succ = self.write_lvalue(&**l, succ, ACC_WRITE|ACC_READ);
@ -1135,23 +1137,23 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
// Uninteresting cases: just propagate in rev exec order // Uninteresting cases: just propagate in rev exec order
ExprVec(ref exprs) => { ast::ExprVec(ref exprs) => {
self.propagate_through_exprs(exprs.as_slice(), succ) self.propagate_through_exprs(exprs.as_slice(), succ)
} }
ExprRepeat(ref element, ref count) => { ast::ExprRepeat(ref element, ref count) => {
let succ = self.propagate_through_expr(&**count, succ); let succ = self.propagate_through_expr(&**count, succ);
self.propagate_through_expr(&**element, succ) self.propagate_through_expr(&**element, succ)
} }
ExprStruct(_, ref fields, ref with_expr) => { ast::ExprStruct(_, ref fields, ref with_expr) => {
let succ = self.propagate_through_opt_expr(with_expr.as_ref().map(|e| &**e), succ); let succ = self.propagate_through_opt_expr(with_expr.as_ref().map(|e| &**e), succ);
fields.iter().rev().fold(succ, |succ, field| { fields.iter().rev().fold(succ, |succ, field| {
self.propagate_through_expr(&*field.expr, succ) self.propagate_through_expr(&*field.expr, succ)
}) })
} }
ExprCall(ref f, ref args) => { ast::ExprCall(ref f, ref args) => {
let diverges = !self.ir.tcx.is_method_call(expr.id) && { let diverges = !self.ir.tcx.is_method_call(expr.id) && {
let t_ret = ty::ty_fn_ret(ty::expr_ty(self.ir.tcx, &**f)); let t_ret = ty::ty_fn_ret(ty::expr_ty(self.ir.tcx, &**f));
t_ret == ty::FnDiverging t_ret == ty::FnDiverging
@ -1165,7 +1167,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.propagate_through_expr(&**f, succ) self.propagate_through_expr(&**f, succ)
} }
ExprMethodCall(_, _, ref args) => { ast::ExprMethodCall(_, _, ref args) => {
let method_call = typeck::MethodCall::expr(expr.id); let method_call = typeck::MethodCall::expr(expr.id);
let method_ty = self.ir.tcx.method_map.borrow().get(&method_call).unwrap().ty; let method_ty = self.ir.tcx.method_map.borrow().get(&method_call).unwrap().ty;
let diverges = ty::ty_fn_ret(method_ty) == ty::FnDiverging; let diverges = ty::ty_fn_ret(method_ty) == ty::FnDiverging;
@ -1177,11 +1179,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.propagate_through_exprs(args.as_slice(), succ) self.propagate_through_exprs(args.as_slice(), succ)
} }
ExprTup(ref exprs) => { ast::ExprTup(ref exprs) => {
self.propagate_through_exprs(exprs.as_slice(), succ) self.propagate_through_exprs(exprs.as_slice(), succ)
} }
ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => { ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => {
let r_succ = self.propagate_through_expr(&**r, succ); let r_succ = self.propagate_through_expr(&**r, succ);
let ln = self.live_node(expr.id, expr.span); let ln = self.live_node(expr.id, expr.span);
@ -1191,27 +1193,27 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
self.propagate_through_expr(&**l, ln) self.propagate_through_expr(&**l, ln)
} }
ExprIndex(ref l, ref r) | ast::ExprIndex(ref l, ref r) |
ExprBinary(_, ref l, ref r) | ast::ExprBinary(_, ref l, ref r) |
ExprBox(ref l, ref r) => { ast::ExprBox(ref l, ref r) => {
let r_succ = self.propagate_through_expr(&**r, succ); let r_succ = self.propagate_through_expr(&**r, succ);
self.propagate_through_expr(&**l, r_succ) self.propagate_through_expr(&**l, r_succ)
} }
ExprSlice(ref e1, ref e2, ref e3, _) => { ast::ExprSlice(ref e1, ref e2, ref e3, _) => {
let succ = e3.as_ref().map_or(succ, |e| self.propagate_through_expr(&**e, succ)); let succ = e3.as_ref().map_or(succ, |e| self.propagate_through_expr(&**e, succ));
let succ = e2.as_ref().map_or(succ, |e| self.propagate_through_expr(&**e, succ)); let succ = e2.as_ref().map_or(succ, |e| self.propagate_through_expr(&**e, succ));
self.propagate_through_expr(&**e1, succ) self.propagate_through_expr(&**e1, succ)
} }
ExprAddrOf(_, ref e) | ast::ExprAddrOf(_, ref e) |
ExprCast(ref e, _) | ast::ExprCast(ref e, _) |
ExprUnary(_, ref e) | ast::ExprUnary(_, ref e) |
ExprParen(ref e) => { ast::ExprParen(ref e) => {
self.propagate_through_expr(&**e, succ) self.propagate_through_expr(&**e, succ)
} }
ExprInlineAsm(ref ia) => { ast::ExprInlineAsm(ref ia) => {
let succ = ia.outputs.iter().rev().fold(succ, |succ, &(_, ref expr, _)| { let succ = ia.outputs.iter().rev().fold(succ, |succ, &(_, ref expr, _)| {
// see comment on lvalues // see comment on lvalues
@ -1225,15 +1227,15 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
}) })
} }
ExprLit(..) => { ast::ExprLit(..) => {
succ succ
} }
ExprBlock(ref blk) => { ast::ExprBlock(ref blk) => {
self.propagate_through_block(&**blk, succ) self.propagate_through_block(&**blk, succ)
} }
ExprMac(..) => { ast::ExprMac(..) => {
self.ir.tcx.sess.span_bug(expr.span, "unexpanded macro"); self.ir.tcx.sess.span_bug(expr.span, "unexpanded macro");
} }
} }
@ -1293,9 +1295,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
// just ignore such cases and treat them as reads. // just ignore such cases and treat them as reads.
match expr.node { match expr.node {
ExprPath(_) => succ, ast::ExprPath(_) => succ,
ExprField(ref e, _, _) => self.propagate_through_expr(&**e, succ), ast::ExprField(ref e, _, _) => self.propagate_through_expr(&**e, succ),
ExprTupField(ref e, _, _) => self.propagate_through_expr(&**e, succ), ast::ExprTupField(ref e, _, _) => self.propagate_through_expr(&**e, succ),
_ => self.propagate_through_expr(expr, succ) _ => self.propagate_through_expr(expr, succ)
} }
} }
@ -1304,7 +1306,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
fn write_lvalue(&mut self, expr: &Expr, succ: LiveNode, acc: uint) fn write_lvalue(&mut self, expr: &Expr, succ: LiveNode, acc: uint)
-> LiveNode { -> LiveNode {
match expr.node { match expr.node {
ExprPath(_) => self.access_path(expr, succ, acc), ast::ExprPath(_) => self.access_path(expr, succ, acc),
// We do not track other lvalues, so just propagate through // We do not track other lvalues, so just propagate through
// to their subcomponents. Also, it may happen that // to their subcomponents. Also, it may happen that
@ -1333,7 +1335,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
fn propagate_through_loop(&mut self, fn propagate_through_loop(&mut self,
expr: &Expr, expr: &Expr,
kind: LoopKind, kind: LoopKind,
body: &Block, body: &ast::Block,
succ: LiveNode) succ: LiveNode)
-> LiveNode { -> LiveNode {
@ -1437,7 +1439,7 @@ fn check_local(this: &mut Liveness, local: &ast::Local) {
visit::walk_local(this, local); visit::walk_local(this, local);
} }
fn check_arm(this: &mut Liveness, arm: &Arm) { fn check_arm(this: &mut Liveness, arm: &ast::Arm) {
// only consider the first pattern; any later patterns must have // only consider the first pattern; any later patterns must have
// the same bindings, and we also consider the first pattern to be // the same bindings, and we also consider the first pattern to be
// the "authoritative" set of ids // the "authoritative" set of ids
@ -1449,20 +1451,20 @@ fn check_arm(this: &mut Liveness, arm: &Arm) {
fn check_expr(this: &mut Liveness, expr: &Expr) { fn check_expr(this: &mut Liveness, expr: &Expr) {
match expr.node { match expr.node {
ExprAssign(ref l, ref r) => { ast::ExprAssign(ref l, ref r) => {
this.check_lvalue(&**l); this.check_lvalue(&**l);
this.visit_expr(&**r); this.visit_expr(&**r);
visit::walk_expr(this, expr); visit::walk_expr(this, expr);
} }
ExprAssignOp(_, ref l, _) => { ast::ExprAssignOp(_, ref l, _) => {
this.check_lvalue(&**l); this.check_lvalue(&**l);
visit::walk_expr(this, expr); visit::walk_expr(this, expr);
} }
ExprInlineAsm(ref ia) => { ast::ExprInlineAsm(ref ia) => {
for &(_, ref input) in ia.inputs.iter() { for &(_, ref input) in ia.inputs.iter() {
this.visit_expr(&**input); this.visit_expr(&**input);
} }
@ -1476,7 +1478,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
visit::walk_expr(this, expr); visit::walk_expr(this, expr);
} }
ExprForLoop(ref pat, _, _, _) => { ast::ExprForLoop(ref pat, _, _, _) => {
this.pat_bindings(&**pat, |this, ln, var, sp, id| { this.pat_bindings(&**pat, |this, ln, var, sp, id| {
this.warn_about_unused(sp, id, ln, var); this.warn_about_unused(sp, id, ln, var);
}); });
@ -1485,20 +1487,22 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
} }
// no correctness conditions related to liveness // no correctness conditions related to liveness
ExprCall(..) | ExprMethodCall(..) | ExprIf(..) | ExprMatch(..) | ast::ExprCall(..) | ast::ExprMethodCall(..) | ast::ExprIf(..) |
ExprWhile(..) | ExprLoop(..) | ExprIndex(..) | ExprField(..) | ast::ExprMatch(..) | ast::ExprWhile(..) | ast::ExprLoop(..) |
ExprTupField(..) | ExprVec(..) | ExprTup(..) | ExprBinary(..) | ast::ExprIndex(..) | ast::ExprField(..) | ast::ExprTupField(..) |
ExprCast(..) | ExprUnary(..) | ExprRet(..) | ExprBreak(..) | ast::ExprVec(..) | ast::ExprTup(..) | ast::ExprBinary(..) |
ExprAgain(..) | ExprLit(_) | ExprBlock(..) | ExprSlice(..) | ast::ExprCast(..) | ast::ExprUnary(..) | ast::ExprRet(..) |
ExprMac(..) | ExprAddrOf(..) | ExprStruct(..) | ExprRepeat(..) | ast::ExprBreak(..) | ast::ExprAgain(..) | ast::ExprLit(_) |
ExprParen(..) | ExprFnBlock(..) | ExprProc(..) | ExprUnboxedFn(..) | ast::ExprBlock(..) | ast::ExprMac(..) | ast::ExprAddrOf(..) |
ExprPath(..) | ExprBox(..) => { ast::ExprStruct(..) | ast::ExprRepeat(..) | ast::ExprParen(..) |
ast::ExprFnBlock(..) | ast::ExprProc(..) | ast::ExprUnboxedFn(..) |
ast::ExprPath(..) | ast::ExprBox(..) | ast::ExprSlice(..) => {
visit::walk_expr(this, expr); visit::walk_expr(this, expr);
} }
ExprIfLet(..) => { ast::ExprIfLet(..) => {
this.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet"); this.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
} }
ExprWhileLet(..) => { ast::ExprWhileLet(..) => {
this.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet"); this.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet");
} }
} }
@ -1506,8 +1510,8 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
fn check_fn(_v: &Liveness, fn check_fn(_v: &Liveness,
_fk: FnKind, _fk: FnKind,
_decl: &FnDecl, _decl: &ast::FnDecl,
_body: &Block, _body: &ast::Block,
_sp: Span, _sp: Span,
_id: NodeId) { _id: NodeId) {
// do not check contents of nested fns // do not check contents of nested fns
@ -1534,7 +1538,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
sp: Span, sp: Span,
_fk: FnKind, _fk: FnKind,
entry_ln: LiveNode, entry_ln: LiveNode,
body: &Block) { body: &ast::Block) {
match self.fn_ret(id) { match self.fn_ret(id) {
ty::FnConverging(t_ret) ty::FnConverging(t_ret)
if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => { if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => {
@ -1545,7 +1549,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
let ends_with_stmt = match body.expr { let ends_with_stmt = match body.expr {
None if body.stmts.len() > 0 => None if body.stmts.len() > 0 =>
match body.stmts.last().unwrap().node { match body.stmts.last().unwrap().node {
StmtSemi(ref e, _) => { ast::StmtSemi(ref e, _) => {
let t_stmt = ty::expr_ty(self.ir.tcx, &**e); let t_stmt = ty::expr_ty(self.ir.tcx, &**e);
ty::get(t_stmt).sty == ty::get(t_ret).sty ty::get(t_stmt).sty == ty::get(t_ret).sty
}, },
@ -1581,7 +1585,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
fn check_lvalue(&mut self, expr: &Expr) { fn check_lvalue(&mut self, expr: &Expr) {
match expr.node { match expr.node {
ExprPath(_) => { ast::ExprPath(_) => {
match self.ir.tcx.def_map.borrow()[expr.id].clone() { match self.ir.tcx.def_map.borrow()[expr.id].clone() {
DefLocal(nid) => { DefLocal(nid) => {
// Assignment to an immutable variable or argument: only legal // Assignment to an immutable variable or argument: only legal
@ -1613,7 +1617,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
} }
fn warn_about_unused_args(&self, decl: &FnDecl, entry_ln: LiveNode) { fn warn_about_unused_args(&self, decl: &ast::FnDecl, entry_ln: LiveNode) {
for arg in decl.inputs.iter() { for arg in decl.inputs.iter() {
pat_util::pat_bindings(&self.ir.tcx.def_map, pat_util::pat_bindings(&self.ir.tcx.def_map,
&*arg.pat, &*arg.pat,
@ -1628,7 +1632,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
} }
fn warn_about_unused_or_dead_vars_in_pat(&mut self, pat: &Pat) { fn warn_about_unused_or_dead_vars_in_pat(&mut self, pat: &ast::Pat) {
self.pat_bindings(pat, |this, ln, var, sp, id| { self.pat_bindings(pat, |this, ln, var, sp, id| {
if !this.warn_about_unused(sp, id, ln, var) { if !this.warn_about_unused(sp, id, ln, var) {
this.warn_about_dead_assign(sp, id, ln, var); this.warn_about_dead_assign(sp, id, ln, var);

58
src/librustc/middle/pat_util.rs
View File

@ -13,15 +13,15 @@ use middle::resolve;
use middle::ty; use middle::ty;
use util::nodemap::FnvHashMap; use util::nodemap::FnvHashMap;
use syntax::ast::*; use syntax::ast;
use syntax::ast_util::{walk_pat}; use syntax::ast_util::{walk_pat};
use syntax::codemap::{Span, DUMMY_SP}; use syntax::codemap::{Span, DUMMY_SP};
pub type PatIdMap = FnvHashMap<Ident, NodeId>; pub type PatIdMap = FnvHashMap<ast::Ident, ast::NodeId>;
// This is used because same-named variables in alternative patterns need to // This is used because same-named variables in alternative patterns need to
// use the NodeId of their namesake in the first pattern. // use the NodeId of their namesake in the first pattern.
pub fn pat_id_map(dm: &resolve::DefMap, pat: &Pat) -> PatIdMap { pub fn pat_id_map(dm: &resolve::DefMap, pat: &ast::Pat) -> PatIdMap {
let mut map = FnvHashMap::new(); let mut map = FnvHashMap::new();
pat_bindings(dm, pat, |_bm, p_id, _s, path1| { pat_bindings(dm, pat, |_bm, p_id, _s, path1| {
map.insert(path1.node, p_id); map.insert(path1.node, p_id);
@ -29,23 +29,27 @@ pub fn pat_id_map(dm: &resolve::DefMap, pat: &Pat) -> PatIdMap {
map map
} }
pub fn pat_is_refutable(dm: &resolve::DefMap, pat: &Pat) -> bool { pub fn pat_is_refutable(dm: &resolve::DefMap, pat: &ast::Pat) -> bool {
match pat.node { match pat.node {
PatLit(_) | PatRange(_, _) => true, ast::PatLit(_) | ast::PatRange(_, _) => true,
PatEnum(_, _) | PatIdent(_, _, None) | PatStruct(..) => { ast::PatEnum(_, _) |
ast::PatIdent(_, _, None) |
ast::PatStruct(..) => {
match dm.borrow().get(&pat.id) { match dm.borrow().get(&pat.id) {
Some(&DefVariant(..)) => true, Some(&DefVariant(..)) => true,
_ => false _ => false
} }
} }
PatVec(_, _, _) => true, ast::PatVec(_, _, _) => true,
_ => false _ => false
} }
} }
pub fn pat_is_variant_or_struct(dm: &resolve::DefMap, pat: &Pat) -> bool { pub fn pat_is_variant_or_struct(dm: &resolve::DefMap, pat: &ast::Pat) -> bool {
match pat.node { match pat.node {
PatEnum(_, _) | PatIdent(_, _, None) | PatStruct(..) => { ast::PatEnum(_, _) |
ast::PatIdent(_, _, None) |
ast::PatStruct(..) => {
match dm.borrow().get(&pat.id) { match dm.borrow().get(&pat.id) {
Some(&DefVariant(..)) | Some(&DefStruct(..)) => true, Some(&DefVariant(..)) | Some(&DefStruct(..)) => true,
_ => false _ => false
@ -55,9 +59,9 @@ pub fn pat_is_variant_or_struct(dm: &resolve::DefMap, pat: &Pat) -> bool {
} }
} }
pub fn pat_is_const(dm: &resolve::DefMap, pat: &Pat) -> bool { pub fn pat_is_const(dm: &resolve::DefMap, pat: &ast::Pat) -> bool {
match pat.node { match pat.node {
PatIdent(_, _, None) | PatEnum(..) => { ast::PatIdent(_, _, None) | ast::PatEnum(..) => {
match dm.borrow().get(&pat.id) { match dm.borrow().get(&pat.id) {
Some(&DefConst(..)) => true, Some(&DefConst(..)) => true,
_ => false _ => false
@ -67,9 +71,9 @@ pub fn pat_is_const(dm: &resolve::DefMap, pat: &Pat) -> bool {
} }
} }
pub fn pat_is_binding(dm: &resolve::DefMap, pat: &Pat) -> bool { pub fn pat_is_binding(dm: &resolve::DefMap, pat: &ast::Pat) -> bool {
match pat.node { match pat.node {
PatIdent(..) => { ast::PatIdent(..) => {
!pat_is_variant_or_struct(dm, pat) && !pat_is_variant_or_struct(dm, pat) &&
!pat_is_const(dm, pat) !pat_is_const(dm, pat)
} }
@ -77,10 +81,10 @@ pub fn pat_is_binding(dm: &resolve::DefMap, pat: &Pat) -> bool {
} }
} }
pub fn pat_is_binding_or_wild(dm: &resolve::DefMap, pat: &Pat) -> bool { pub fn pat_is_binding_or_wild(dm: &resolve::DefMap, pat: &ast::Pat) -> bool {
match pat.node { match pat.node {
PatIdent(..) => pat_is_binding(dm, pat), ast::PatIdent(..) => pat_is_binding(dm, pat),
PatWild(_) => true, ast::PatWild(_) => true,
_ => false _ => false
} }
} }
@ -88,11 +92,11 @@ pub fn pat_is_binding_or_wild(dm: &resolve::DefMap, pat: &Pat) -> bool {
/// Call `it` on every "binding" in a pattern, e.g., on `a` in /// Call `it` on every "binding" in a pattern, e.g., on `a` in
/// `match foo() { Some(a) => (), None => () }` /// `match foo() { Some(a) => (), None => () }`
pub fn pat_bindings(dm: &resolve::DefMap, pub fn pat_bindings(dm: &resolve::DefMap,
pat: &Pat, pat: &ast::Pat,
it: |BindingMode, NodeId, Span, &SpannedIdent|) { it: |ast::BindingMode, ast::NodeId, Span, &ast::SpannedIdent|) {
walk_pat(pat, |p| { walk_pat(pat, |p| {
match p.node { match p.node {
PatIdent(binding_mode, ref pth, _) if pat_is_binding(dm, p) => { ast::PatIdent(binding_mode, ref pth, _) if pat_is_binding(dm, p) => {
it(binding_mode, p.id, p.span, pth); it(binding_mode, p.id, p.span, pth);
} }
_ => {} _ => {}
@ -103,7 +107,7 @@ pub fn pat_bindings(dm: &resolve::DefMap,
/// Checks if the pattern contains any patterns that bind something to /// Checks if the pattern contains any patterns that bind something to
/// an ident, e.g. `foo`, or `Foo(foo)` or `foo @ Bar(..)`. /// an ident, e.g. `foo`, or `Foo(foo)` or `foo @ Bar(..)`.
pub fn pat_contains_bindings(dm: &resolve::DefMap, pat: &Pat) -> bool { pub fn pat_contains_bindings(dm: &resolve::DefMap, pat: &ast::Pat) -> bool {
let mut contains_bindings = false; let mut contains_bindings = false;
walk_pat(pat, |p| { walk_pat(pat, |p| {
if pat_is_binding(dm, p) { if pat_is_binding(dm, p) {
@ -116,9 +120,9 @@ pub fn pat_contains_bindings(dm: &resolve::DefMap, pat: &Pat) -> bool {
contains_bindings contains_bindings
} }
pub fn simple_identifier<'a>(pat: &'a Pat) -> Option<&'a Ident> { pub fn simple_identifier<'a>(pat: &'a ast::Pat) -> Option<&'a ast::Ident> {
match pat.node { match pat.node {
PatIdent(BindByValue(_), ref path1, None) => { ast::PatIdent(ast::BindByValue(_), ref path1, None) => {
Some(&path1.node) Some(&path1.node)
} }
_ => { _ => {
@ -127,12 +131,12 @@ pub fn simple_identifier<'a>(pat: &'a Pat) -> Option<&'a Ident> {
} }
} }
pub fn def_to_path(tcx: &ty::ctxt, id: DefId) -> Path { pub fn def_to_path(tcx: &ty::ctxt, id: ast::DefId) -> ast::Path {
ty::with_path(tcx, id, |mut path| Path { ty::with_path(tcx, id, |mut path| ast::Path {
global: false, global: false,
segments: path.last().map(|elem| PathSegment { segments: path.last().map(|elem| ast::PathSegment {
identifier: Ident::new(elem.name()), identifier: ast::Ident::new(elem.name()),
parameters: PathParameters::none(), parameters: ast::PathParameters::none(),
}).into_iter().collect(), }).into_iter().collect(),
span: DUMMY_SP, span: DUMMY_SP,
}) })