1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
17 use owned_slice::OwnedSlice;
28 pub fn path_name_i(idents: &[Ident]) -> String {
29 // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
30 idents.iter().map(|i| {
31 token::get_ident(*i).get().to_string()
32 }).collect::<Vec<String>>().connect("::")
35 pub fn local_def(id: NodeId) -> DefId {
36 ast::DefId { krate: LOCAL_CRATE, node: id }
39 pub fn is_local(did: ast::DefId) -> bool { did.krate == LOCAL_CRATE }
41 pub fn stmt_id(s: &Stmt) -> NodeId {
43 StmtDecl(_, id) => id,
44 StmtExpr(_, id) => id,
45 StmtSemi(_, id) => id,
46 StmtMac(..) => fail!("attempted to analyze unexpanded stmt")
50 pub fn binop_to_string(op: BinOp) -> &'static str {
73 pub fn lazy_binop(b: BinOp) -> bool {
81 pub fn is_shift_binop(b: BinOp) -> bool {
89 pub fn unop_to_string(op: UnOp) -> &'static str {
98 pub fn is_path(e: P<Expr>) -> bool {
99 return match e.node { ExprPath(_) => true, _ => false };
102 /// Get a string representation of a signed int type, with its value.
103 /// We want to avoid "45int" and "-3int" in favor of "45" and "-3"
104 pub fn int_ty_to_string(t: IntTy, val: Option<i64>) -> String {
106 TyI if val.is_some() => "i",
115 // cast to a u64 so we can correctly print INT64_MIN. All integral types
116 // are parsed as u64, so we wouldn't want to print an extra negative
118 Some(n) => format!("{}{}", n as u64, s),
119 None => s.to_string()
123 pub fn int_ty_max(t: IntTy) -> u64 {
127 TyI | TyI32 => 0x80000000u64, // actually ni about TyI
128 TyI64 => 0x8000000000000000u64
132 /// Get a string representation of an unsigned int type, with its value.
133 /// We want to avoid "42uint" in favor of "42u"
134 pub fn uint_ty_to_string(t: UintTy, val: Option<u64>) -> String {
136 TyU if val.is_some() => "u",
145 Some(n) => format!("{}{}", n, s),
146 None => s.to_string()
150 pub fn uint_ty_max(t: UintTy) -> u64 {
154 TyU | TyU32 => 0xffffffffu64, // actually ni about TyU
155 TyU64 => 0xffffffffffffffffu64
159 pub fn float_ty_to_string(t: FloatTy) -> String {
161 TyF32 => "f32".to_string(),
162 TyF64 => "f64".to_string(),
166 // convert a span and an identifier to the corresponding
168 pub fn ident_to_path(s: Span, identifier: Ident) -> Path {
174 identifier: identifier,
175 lifetimes: Vec::new(),
176 types: OwnedSlice::empty(),
182 pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> P<Pat> {
185 node: PatIdent(BindByValue(MutImmutable), codemap::Spanned{span:s, node:i}, None),
190 pub fn name_to_dummy_lifetime(name: Name) -> Lifetime {
191 Lifetime { id: DUMMY_NODE_ID,
192 span: codemap::DUMMY_SP,
196 /// Generate a "pretty" name for an `impl` from its type and trait.
197 /// This is designed so that symbols of `impl`'d methods give some
198 /// hint of where they came from, (previously they would all just be
199 /// listed as `__extensions__::method_name::hash`, with no indication
201 pub fn impl_pretty_name(trait_ref: &Option<TraitRef>, ty: &Ty) -> Ident {
202 let mut pretty = pprust::ty_to_string(ty);
204 Some(ref trait_ref) => {
206 pretty.push_str(pprust::path_to_string(&trait_ref.path).as_slice());
210 token::gensym_ident(pretty.as_slice())
213 pub fn trait_method_to_ty_method(method: &Method) -> TypeMethod {
225 attrs: method.attrs.clone(),
227 decl: (*decl).clone(),
228 generics: generics.clone(),
229 explicit_self: (*explicit_self).clone(),
236 MethMac(_) => fail!("expected non-macro method declaration")
240 /// extract a TypeMethod from a TraitItem. if the TraitItem is
241 /// a default, pull out the useful fields to make a TypeMethod
243 // NB: to be used only after expansion is complete, and macros are gone.
244 pub fn trait_item_to_ty_method(method: &TraitItem) -> TypeMethod {
246 RequiredMethod(ref m) => (*m).clone(),
247 ProvidedMethod(ref m) => trait_method_to_ty_method(&**m),
248 TypeTraitItem(_) => {
249 fail!("trait_method_to_ty_method(): expected method but found \
255 pub fn split_trait_methods(trait_methods: &[TraitItem])
256 -> (Vec<TypeMethod>, Vec<P<Method>> ) {
257 let mut reqd = Vec::new();
258 let mut provd = Vec::new();
259 for trt_method in trait_methods.iter() {
261 RequiredMethod(ref tm) => reqd.push((*tm).clone()),
262 ProvidedMethod(ref m) => provd.push((*m).clone()),
263 TypeTraitItem(_) => {}
269 pub fn struct_field_visibility(field: ast::StructField) -> Visibility {
270 match field.node.kind {
271 ast::NamedField(_, v) | ast::UnnamedField(v) => v
275 /// Maps a binary operator to its precedence
276 pub fn operator_prec(op: ast::BinOp) -> uint {
278 // 'as' sits here with 12
279 BiMul | BiDiv | BiRem => 11u,
280 BiAdd | BiSub => 10u,
285 BiLt | BiLe | BiGe | BiGt => 4u,
292 /// Precedence of the `as` operator, which is a binary operator
293 /// not appearing in the prior table.
294 #[allow(non_uppercase_statics)]
295 pub static as_prec: uint = 12u;
297 pub fn empty_generics() -> Generics {
299 lifetimes: Vec::new(),
300 ty_params: OwnedSlice::empty(),
301 where_clause: WhereClause {
303 predicates: Vec::new(),
308 // ______________________________________________________________________
309 // Enumerating the IDs which appear in an AST
311 #[deriving(Encodable, Decodable, Show)]
318 pub fn max() -> IdRange {
325 pub fn empty(&self) -> bool {
329 pub fn add(&mut self, id: NodeId) {
330 self.min = cmp::min(self.min, id);
331 self.max = cmp::max(self.max, id + 1);
335 pub trait IdVisitingOperation {
336 fn visit_id(&self, node_id: NodeId);
339 /// A visitor that applies its operation to all of the node IDs
340 /// in a visitable thing.
342 pub struct IdVisitor<'a, O:'a> {
343 pub operation: &'a O,
344 pub pass_through_items: bool,
345 pub visited_outermost: bool,
348 impl<'a, O: IdVisitingOperation> IdVisitor<'a, O> {
349 fn visit_generics_helper(&self, generics: &Generics) {
350 for type_parameter in generics.ty_params.iter() {
351 self.operation.visit_id(type_parameter.id)
353 for lifetime in generics.lifetimes.iter() {
354 self.operation.visit_id(lifetime.lifetime.id)
359 impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
360 fn visit_mod(&mut self,
364 self.operation.visit_id(node_id);
365 visit::walk_mod(self, module)
368 fn visit_view_item(&mut self, view_item: &ViewItem) {
369 if !self.pass_through_items {
370 if self.visited_outermost {
373 self.visited_outermost = true;
376 match view_item.node {
377 ViewItemExternCrate(_, _, node_id) => {
378 self.operation.visit_id(node_id)
380 ViewItemUse(ref view_path) => {
381 match view_path.node {
382 ViewPathSimple(_, _, node_id) |
383 ViewPathGlob(_, node_id) => {
384 self.operation.visit_id(node_id)
386 ViewPathList(_, ref paths, node_id) => {
387 self.operation.visit_id(node_id);
388 for path in paths.iter() {
389 self.operation.visit_id(path.node.id())
395 visit::walk_view_item(self, view_item);
396 self.visited_outermost = false;
399 fn visit_foreign_item(&mut self, foreign_item: &ForeignItem) {
400 self.operation.visit_id(foreign_item.id);
401 visit::walk_foreign_item(self, foreign_item)
404 fn visit_item(&mut self, item: &Item) {
405 if !self.pass_through_items {
406 if self.visited_outermost {
409 self.visited_outermost = true
413 self.operation.visit_id(item.id);
415 ItemEnum(ref enum_definition, _) => {
416 for variant in enum_definition.variants.iter() {
417 self.operation.visit_id(variant.node.id)
423 visit::walk_item(self, item);
425 self.visited_outermost = false
428 fn visit_local(&mut self, local: &Local) {
429 self.operation.visit_id(local.id);
430 visit::walk_local(self, local)
433 fn visit_block(&mut self, block: &Block) {
434 self.operation.visit_id(block.id);
435 visit::walk_block(self, block)
438 fn visit_stmt(&mut self, statement: &Stmt) {
439 self.operation.visit_id(ast_util::stmt_id(statement));
440 visit::walk_stmt(self, statement)
443 fn visit_pat(&mut self, pattern: &Pat) {
444 self.operation.visit_id(pattern.id);
445 visit::walk_pat(self, pattern)
448 fn visit_expr(&mut self, expression: &Expr) {
449 self.operation.visit_id(expression.id);
450 visit::walk_expr(self, expression)
453 fn visit_ty(&mut self, typ: &Ty) {
454 self.operation.visit_id(typ.id);
456 TyPath(_, _, id) => self.operation.visit_id(id),
459 visit::walk_ty(self, typ)
462 fn visit_generics(&mut self, generics: &Generics) {
463 self.visit_generics_helper(generics);
464 visit::walk_generics(self, generics)
467 fn visit_fn(&mut self,
468 function_kind: visit::FnKind<'v>,
469 function_declaration: &'v FnDecl,
473 if !self.pass_through_items {
474 match function_kind {
475 visit::FkMethod(..) if self.visited_outermost => return,
476 visit::FkMethod(..) => self.visited_outermost = true,
481 self.operation.visit_id(node_id);
483 match function_kind {
484 visit::FkItemFn(_, generics, _, _) |
485 visit::FkMethod(_, generics, _) => {
486 self.visit_generics_helper(generics)
488 visit::FkFnBlock => {}
491 for argument in function_declaration.inputs.iter() {
492 self.operation.visit_id(argument.id)
497 function_declaration,
501 if !self.pass_through_items {
502 match function_kind {
503 visit::FkMethod(..) => self.visited_outermost = false,
509 fn visit_struct_field(&mut self, struct_field: &StructField) {
510 self.operation.visit_id(struct_field.node.id);
511 visit::walk_struct_field(self, struct_field)
514 fn visit_struct_def(&mut self,
515 struct_def: &StructDef,
519 self.operation.visit_id(id);
520 struct_def.ctor_id.map(|ctor_id| self.operation.visit_id(ctor_id));
521 visit::walk_struct_def(self, struct_def);
524 fn visit_trait_item(&mut self, tm: &ast::TraitItem) {
526 ast::RequiredMethod(ref m) => self.operation.visit_id(m.id),
527 ast::ProvidedMethod(ref m) => self.operation.visit_id(m.id),
528 ast::TypeTraitItem(ref typ) => self.operation.visit_id(typ.id),
530 visit::walk_trait_item(self, tm);
533 fn visit_lifetime_ref(&mut self, lifetime: &'v Lifetime) {
534 self.operation.visit_id(lifetime.id);
537 fn visit_lifetime_decl(&mut self, def: &'v LifetimeDef) {
538 self.visit_lifetime_ref(&def.lifetime);
542 pub fn visit_ids_for_inlined_item<O: IdVisitingOperation>(item: &InlinedItem,
544 let mut id_visitor = IdVisitor {
545 operation: operation,
546 pass_through_items: true,
547 visited_outermost: false,
550 visit::walk_inlined_item(&mut id_visitor, item);
553 struct IdRangeComputingVisitor {
554 result: Cell<IdRange>,
557 impl IdVisitingOperation for IdRangeComputingVisitor {
558 fn visit_id(&self, id: NodeId) {
559 let mut id_range = self.result.get();
561 self.result.set(id_range)
565 pub fn compute_id_range_for_inlined_item(item: &InlinedItem) -> IdRange {
566 let visitor = IdRangeComputingVisitor {
567 result: Cell::new(IdRange::max())
569 visit_ids_for_inlined_item(item, &visitor);
573 pub fn compute_id_range_for_fn_body(fk: visit::FnKind,
581 * Computes the id range for a single fn body,
582 * ignoring nested items.
585 let visitor = IdRangeComputingVisitor {
586 result: Cell::new(IdRange::max())
588 let mut id_visitor = IdVisitor {
590 pass_through_items: false,
591 visited_outermost: false,
593 id_visitor.visit_fn(fk, decl, body, sp, id);
597 pub fn walk_pat(pat: &Pat, it: |&Pat| -> bool) -> bool {
603 PatIdent(_, _, Some(ref p)) => walk_pat(&**p, it),
604 PatStruct(_, ref fields, _) => {
605 fields.iter().all(|field| walk_pat(&*field.node.pat, |p| it(p)))
607 PatEnum(_, Some(ref s)) | PatTup(ref s) => {
608 s.iter().all(|p| walk_pat(&**p, |p| it(p)))
610 PatBox(ref s) | PatRegion(ref s) => {
613 PatVec(ref before, ref slice, ref after) => {
614 before.iter().all(|p| walk_pat(&**p, |p| it(p))) &&
615 slice.iter().all(|p| walk_pat(&**p, |p| it(p))) &&
616 after.iter().all(|p| walk_pat(&**p, |p| it(p)))
618 PatMac(_) => fail!("attempted to analyze unexpanded pattern"),
619 PatWild(_) | PatLit(_) | PatRange(_, _) | PatIdent(_, _, _) |
626 pub trait EachViewItem {
627 fn each_view_item(&self, f: |&ast::ViewItem| -> bool) -> bool;
630 struct EachViewItemData<'a> {
631 callback: |&ast::ViewItem|: 'a -> bool,
634 impl<'a, 'v> Visitor<'v> for EachViewItemData<'a> {
635 fn visit_view_item(&mut self, view_item: &ast::ViewItem) {
636 let _ = (self.callback)(view_item);
640 impl EachViewItem for ast::Crate {
641 fn each_view_item(&self, f: |&ast::ViewItem| -> bool) -> bool {
642 let mut visit = EachViewItemData {
645 visit::walk_crate(&mut visit, self);
650 pub fn view_path_id(p: &ViewPath) -> NodeId {
652 ViewPathSimple(_, _, id) | ViewPathGlob(_, id)
653 | ViewPathList(_, _, id) => id
657 /// Returns true if the given struct def is tuple-like; i.e. that its fields
659 pub fn struct_def_is_tuple_like(struct_def: &ast::StructDef) -> bool {
660 struct_def.ctor_id.is_some()
663 /// Returns true if the given pattern consists solely of an identifier
664 /// and false otherwise.
665 pub fn pat_is_ident(pat: P<ast::Pat>) -> bool {
667 ast::PatIdent(..) => true,
672 // are two paths equal when compared unhygienically?
673 // since I'm using this to replace ==, it seems appropriate
674 // to compare the span, global, etc. fields as well.
675 pub fn path_name_eq(a : &ast::Path, b : &ast::Path) -> bool {
677 && (a.global == b.global)
678 && (segments_name_eq(a.segments.as_slice(), b.segments.as_slice()))
681 // are two arrays of segments equal when compared unhygienically?
682 pub fn segments_name_eq(a : &[ast::PathSegment], b : &[ast::PathSegment]) -> bool {
683 if a.len() != b.len() {
686 for (idx,seg) in a.iter().enumerate() {
687 if (seg.identifier.name != b[idx].identifier.name)
688 // FIXME #7743: ident -> name problems in lifetime comparison?
689 || (seg.lifetimes != b[idx].lifetimes)
690 // can types contain idents?
691 || (seg.types != b[idx].types) {
699 /// Returns true if this literal is a string and false otherwise.
700 pub fn lit_is_str(lit: &Lit) -> bool {
707 /// Macro invocations are guaranteed not to occur after expansion is complete.
708 /// Extracting fields of a method requires a dynamic check to make sure that it's
709 /// not a macro invocation. This check is guaranteed to succeed, assuming
710 /// that the invocations are indeed gone.
711 pub trait PostExpansionMethod {
712 fn pe_ident(&self) -> ast::Ident;
713 fn pe_generics<'a>(&'a self) -> &'a ast::Generics;
714 fn pe_abi(&self) -> Abi;
715 fn pe_explicit_self<'a>(&'a self) -> &'a ast::ExplicitSelf;
716 fn pe_fn_style(&self) -> ast::FnStyle;
717 fn pe_fn_decl<'a>(&'a self) -> &'a ast::FnDecl;
718 fn pe_body<'a>(&'a self) -> &'a ast::Block;
719 fn pe_vis(&self) -> ast::Visibility;
722 macro_rules! mf_method{
723 ($meth_name:ident, $field_ty:ty, $field_pat:pat, $result:expr) => {
724 fn $meth_name<'a>(&'a self) -> $field_ty {
726 $field_pat => $result,
728 fail!("expected an AST without macro invocations");
736 impl PostExpansionMethod for Method {
737 mf_method!(pe_ident,ast::Ident,MethDecl(ident,_,_,_,_,_,_,_),ident)
738 mf_method!(pe_generics,&'a ast::Generics,
739 MethDecl(_,ref generics,_,_,_,_,_,_),generics)
740 mf_method!(pe_abi,Abi,MethDecl(_,_,abi,_,_,_,_,_),abi)
741 mf_method!(pe_explicit_self,&'a ast::ExplicitSelf,
742 MethDecl(_,_,_,ref explicit_self,_,_,_,_),explicit_self)
743 mf_method!(pe_fn_style,ast::FnStyle,MethDecl(_,_,_,_,fn_style,_,_,_),fn_style)
744 mf_method!(pe_fn_decl,&'a ast::FnDecl,MethDecl(_,_,_,_,_,ref decl,_,_),&**decl)
745 mf_method!(pe_body,&'a ast::Block,MethDecl(_,_,_,_,_,_,ref body,_),&**body)
746 mf_method!(pe_vis,ast::Visibility,MethDecl(_,_,_,_,_,_,_,vis),vis)
753 use owned_slice::OwnedSlice;
755 fn ident_to_segment(id : &Ident) -> PathSegment {
756 PathSegment {identifier:id.clone(),
757 lifetimes: Vec::new(),
758 types: OwnedSlice::empty()}
761 #[test] fn idents_name_eq_test() {
762 assert!(segments_name_eq(
763 [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
764 .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().as_slice(),
765 [Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}]
766 .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().as_slice()));
767 assert!(!segments_name_eq(
768 [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
769 .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().as_slice(),
770 [Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}]
771 .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().as_slice()));