src/test/run-pass/reflect-visit-type.rs

   1 // Copyright 2012 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.
   4 //
   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.
  10
  11 #[feature(managed_boxes)];
  12
  13 use std::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Disr, Opaque};
  14 use std::vec_ng::Vec;
  15
  16 struct MyVisitor {
  17     types: Vec<~str> ,
  18 }
  19
  20 impl TyVisitor for MyVisitor {
  21     fn visit_bot(&mut self) -> bool {
  22         self.types.push(~"bot");
  23         println!("visited bot type");
  24         true
  25     }
  26     fn visit_nil(&mut self) -> bool {
  27         self.types.push(~"nil");
  28         println!("visited nil type");
  29         true
  30     }
  31     fn visit_bool(&mut self) -> bool {
  32         self.types.push(~"bool");
  33         println!("visited bool type");
  34         true
  35     }
  36     fn visit_int(&mut self) -> bool {
  37         self.types.push(~"int");
  38         println!("visited int type");
  39         true
  40     }
  41     fn visit_i8(&mut self) -> bool {
  42         self.types.push(~"i8");
  43         println!("visited i8 type");
  44         true
  45     }
  46     fn visit_i16(&mut self) -> bool {
  47         self.types.push(~"i16");
  48         println!("visited i16 type");
  49         true
  50     }
  51     fn visit_i32(&mut self) -> bool { true }
  52     fn visit_i64(&mut self) -> bool { true }
  53
  54     fn visit_uint(&mut self) -> bool { true }
  55     fn visit_u8(&mut self) -> bool { true }
  56     fn visit_u16(&mut self) -> bool { true }
  57     fn visit_u32(&mut self) -> bool { true }
  58     fn visit_u64(&mut self) -> bool { true }
  59
  60     fn visit_f32(&mut self) -> bool { true }
  61     fn visit_f64(&mut self) -> bool { true }
  62
  63     fn visit_char(&mut self) -> bool { true }
  64
  65     fn visit_estr_box(&mut self) -> bool { true }
  66     fn visit_estr_uniq(&mut self) -> bool { true }
  67     fn visit_estr_slice(&mut self) -> bool { true }
  68     fn visit_estr_fixed(&mut self,
  69                         _sz: uint, _sz2: uint,
  70                         _align: uint) -> bool { true }
  71
  72     fn visit_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  73     fn visit_uniq(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  74     fn visit_ptr(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  75     fn visit_rptr(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  76
  77     fn visit_vec(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  78     fn visit_unboxed_vec(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  79     fn visit_evec_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  80     fn visit_evec_uniq(&mut self, _mtbl: uint, inner: *TyDesc) -> bool {
  81         self.types.push(~"[");
  82         unsafe { visit_tydesc(inner, &mut *self as &mut TyVisitor); }
  83         self.types.push(~"]");
  84         true
  85     }
  86     fn visit_evec_slice(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
  87     fn visit_evec_fixed(&mut self, _n: uint, _sz: uint, _align: uint,
  88                         _mtbl: uint, _inner: *TyDesc) -> bool { true }
  89
  90     fn visit_enter_rec(&mut self, _n_fields: uint,
  91                        _sz: uint, _align: uint) -> bool { true }
  92     fn visit_rec_field(&mut self, _i: uint, _name: &str,
  93                        _mtbl: uint, _inner: *TyDesc) -> bool { true }
  94     fn visit_leave_rec(&mut self, _n_fields: uint,
  95                        _sz: uint, _align: uint) -> bool { true }
  96
  97     fn visit_enter_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
  98                          _sz: uint, _align: uint) -> bool { true }
  99     fn visit_class_field(&mut self, _i: uint, _name: &str, _named: bool,
 100                          _mtbl: uint, _inner: *TyDesc) -> bool { true }
 101     fn visit_leave_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
 102                          _sz: uint, _align: uint) -> bool { true }
 103
 104     fn visit_enter_tup(&mut self, _n_fields: uint,
 105                        _sz: uint, _align: uint) -> bool { true }
 106     fn visit_tup_field(&mut self, _i: uint, _inner: *TyDesc) -> bool { true }
 107     fn visit_leave_tup(&mut self, _n_fields: uint,
 108                        _sz: uint, _align: uint) -> bool { true }
 109
 110     fn visit_enter_enum(&mut self, _n_variants: uint,
 111                         _get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
 112                         _sz: uint, _align: uint) -> bool { true }
 113     fn visit_enter_enum_variant(&mut self,
 114                                 _variant: uint,
 115                                 _disr_val: Disr,
 116                                 _n_fields: uint,
 117                                 _name: &str) -> bool { true }
 118     fn visit_enum_variant_field(&mut self, _i: uint, _offset: uint, _inner: *TyDesc)
 119         -> bool { true }
 120     fn visit_leave_enum_variant(&mut self,
 121                                 _variant: uint,
 122                                 _disr_val: Disr,
 123                                 _n_fields: uint,
 124                                 _name: &str) -> bool { true }
 125     fn visit_leave_enum(&mut self,
 126                         _n_variants: uint,
 127                         _get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
 128                         _sz: uint, _align: uint) -> bool { true }
 129
 130     fn visit_enter_fn(&mut self, _purity: uint, _proto: uint,
 131                       _n_inputs: uint, _retstyle: uint) -> bool { true }
 132     fn visit_fn_input(&mut self, _i: uint, _mode: uint, _inner: *TyDesc) -> bool { true }
 133     fn visit_fn_output(&mut self, _retstyle: uint, _variadic: bool, _inner: *TyDesc)
 134         -> bool { true }
 135     fn visit_leave_fn(&mut self, _purity: uint, _proto: uint,
 136                       _n_inputs: uint, _retstyle: uint) -> bool { true }
 137
 138
 139     fn visit_trait(&mut self, _name: &str) -> bool { true }
 140     fn visit_param(&mut self, _i: uint) -> bool { true }
 141     fn visit_self(&mut self) -> bool { true }
 142 }
 143
 144 fn visit_ty<T>(v: &mut MyVisitor) {
 145     unsafe { visit_tydesc(get_tydesc::<T>(), v as &mut TyVisitor) }
 146 }
 147
 148 pub fn main() {
 149     let mut v = MyVisitor {types: Vec::new()};
 150
 151     visit_ty::<bool>(&mut v);
 152     visit_ty::<int>(&mut v);
 153     visit_ty::<i8>(&mut v);
 154     visit_ty::<i16>(&mut v);
 155
 156     for s in v.types.iter() {
 157         println!("type: {}", (*s).clone());
 158     }
 159
 160     let vec_types: Vec<~str> = v.types.clone().move_iter().collect();
 161     assert_eq!(vec_types, vec!(~"bool", ~"int", ~"i8", ~"i16"));
 162 }