David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 1 | use super::*; |
| 2 | |
David Tolnay | 771ecf4 | 2016-09-23 19:26:37 -0700 | [diff] [blame] | 3 | /// The different kinds of types recognized by the compiler |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 4 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 5 | pub enum Ty { |
| 6 | /// A variable-length array (`[T]`) |
David Tolnay | 16709ba | 2016-10-05 23:11:32 -0700 | [diff] [blame] | 7 | Slice(Box<Ty>), |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 8 | /// A fixed length array (`[T; n]`) |
David Tolnay | 3cb23a9 | 2016-10-07 23:02:21 -0700 | [diff] [blame] | 9 | Array(Box<Ty>, ConstExpr), |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 10 | /// A raw pointer (`*const T` or `*mut T`) |
| 11 | Ptr(Box<MutTy>), |
| 12 | /// A reference (`&'a T` or `&'a mut T`) |
| 13 | Rptr(Option<Lifetime>, Box<MutTy>), |
| 14 | /// A bare function (e.g. `fn(usize) -> bool`) |
| 15 | BareFn(Box<BareFnTy>), |
| 16 | /// The never type (`!`) |
| 17 | Never, |
| 18 | /// A tuple (`(A, B, C, D, ...)`) |
| 19 | Tup(Vec<Ty>), |
| 20 | /// A path (`module::module::...::Type`), optionally |
| 21 | /// "qualified", e.g. `<Vec<T> as SomeTrait>::SomeType`. |
| 22 | /// |
| 23 | /// Type parameters are stored in the Path itself |
| 24 | Path(Option<QSelf>, Path), |
David Tolnay | 02c907f | 2017-01-23 00:06:37 -0800 | [diff] [blame] | 25 | /// A trait object type `Bound1 + Bound2 + Bound3` |
| 26 | /// where `Bound` is a trait or a lifetime. |
| 27 | TraitObject(Vec<TyParamBound>), |
| 28 | /// An `impl Bound1 + Bound2 + Bound3` type |
| 29 | /// where `Bound` is a trait or a lifetime. |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 30 | ImplTrait(Vec<TyParamBound>), |
| 31 | /// No-op; kept solely so that we can pretty-print faithfully |
| 32 | Paren(Box<Ty>), |
| 33 | /// TyKind::Infer means the type should be inferred instead of it having been |
| 34 | /// specified. This can appear anywhere in a type. |
| 35 | Infer, |
David Tolnay | 0047c71 | 2016-12-21 21:59:25 -0500 | [diff] [blame] | 36 | /// A macro in the type position. |
| 37 | Mac(Mac), |
| 38 | } |
| 39 | |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 40 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 41 | pub struct MutTy { |
| 42 | pub ty: Ty, |
| 43 | pub mutability: Mutability, |
| 44 | } |
| 45 | |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 46 | #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 47 | pub enum Mutability { |
| 48 | Mutable, |
| 49 | Immutable, |
| 50 | } |
| 51 | |
David Tolnay | 771ecf4 | 2016-09-23 19:26:37 -0700 | [diff] [blame] | 52 | /// A "Path" is essentially Rust's notion of a name. |
| 53 | /// |
| 54 | /// It's represented as a sequence of identifiers, |
| 55 | /// along with a bunch of supporting information. |
| 56 | /// |
| 57 | /// E.g. `std::cmp::PartialEq` |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 58 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 59 | pub struct Path { |
David Tolnay | f06fdde | 2016-12-22 17:07:59 -0500 | [diff] [blame] | 60 | /// A `::foo` path, is relative to the crate root rather than current |
| 61 | /// module (like paths in an import). |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 62 | pub global: bool, |
David Tolnay | f06fdde | 2016-12-22 17:07:59 -0500 | [diff] [blame] | 63 | /// The segments in the path: the things separated by `::`. |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 64 | pub segments: Vec<PathSegment>, |
| 65 | } |
| 66 | |
David Tolnay | daaf774 | 2016-10-03 11:11:43 -0700 | [diff] [blame] | 67 | impl<T> From<T> for Path |
| 68 | where T: Into<PathSegment> |
| 69 | { |
David Tolnay | 84aa075 | 2016-10-02 23:01:13 -0700 | [diff] [blame] | 70 | fn from(segment: T) -> Self { |
| 71 | Path { |
| 72 | global: false, |
| 73 | segments: vec![segment.into()], |
| 74 | } |
| 75 | } |
| 76 | } |
| 77 | |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 78 | /// A segment of a path: an identifier, an optional lifetime, and a set of types. |
| 79 | /// |
| 80 | /// E.g. `std`, `String` or `Box<T>` |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 81 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 82 | pub struct PathSegment { |
David Tolnay | f06fdde | 2016-12-22 17:07:59 -0500 | [diff] [blame] | 83 | /// The identifier portion of this path segment. |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 84 | pub ident: Ident, |
David Tolnay | f06fdde | 2016-12-22 17:07:59 -0500 | [diff] [blame] | 85 | /// Type/lifetime parameters attached to this path. They come in |
| 86 | /// two flavors: `Path<A,B,C>` and `Path(A,B) -> C`. Note that |
| 87 | /// this is more than just simple syntactic sugar; the use of |
| 88 | /// parens affects the region binding rules, so we preserve the |
| 89 | /// distinction. |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 90 | pub parameters: PathParameters, |
| 91 | } |
| 92 | |
David Tolnay | daaf774 | 2016-10-03 11:11:43 -0700 | [diff] [blame] | 93 | impl<T> From<T> for PathSegment |
| 94 | where T: Into<Ident> |
| 95 | { |
David Tolnay | 84aa075 | 2016-10-02 23:01:13 -0700 | [diff] [blame] | 96 | fn from(ident: T) -> Self { |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 97 | PathSegment { |
David Tolnay | 84aa075 | 2016-10-02 23:01:13 -0700 | [diff] [blame] | 98 | ident: ident.into(), |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 99 | parameters: PathParameters::none(), |
| 100 | } |
| 101 | } |
| 102 | } |
| 103 | |
| 104 | /// Parameters of a path segment. |
| 105 | /// |
| 106 | /// E.g. `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)` |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 107 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 108 | pub enum PathParameters { |
| 109 | /// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>` |
| 110 | AngleBracketed(AngleBracketedParameterData), |
| 111 | /// The `(A, B)` and `C` in `Foo(A, B) -> C` |
| 112 | Parenthesized(ParenthesizedParameterData), |
| 113 | } |
| 114 | |
| 115 | impl PathParameters { |
| 116 | pub fn none() -> Self { |
| 117 | PathParameters::AngleBracketed(AngleBracketedParameterData::default()) |
| 118 | } |
David Tolnay | 5332d4b | 2016-10-30 14:25:22 -0700 | [diff] [blame] | 119 | |
| 120 | pub fn is_empty(&self) -> bool { |
| 121 | match *self { |
| 122 | PathParameters::AngleBracketed(ref bracketed) => { |
David Tolnay | c1fea50 | 2016-10-30 17:54:02 -0700 | [diff] [blame] | 123 | bracketed.lifetimes.is_empty() && bracketed.types.is_empty() && |
| 124 | bracketed.bindings.is_empty() |
David Tolnay | 5332d4b | 2016-10-30 14:25:22 -0700 | [diff] [blame] | 125 | } |
| 126 | PathParameters::Parenthesized(_) => false, |
| 127 | } |
| 128 | } |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | /// A path like `Foo<'a, T>` |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 132 | #[derive(Debug, Clone, Eq, PartialEq, Default, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 133 | pub struct AngleBracketedParameterData { |
| 134 | /// The lifetime parameters for this path segment. |
| 135 | pub lifetimes: Vec<Lifetime>, |
| 136 | /// The type parameters for this path segment, if present. |
| 137 | pub types: Vec<Ty>, |
| 138 | /// Bindings (equality constraints) on associated types, if present. |
| 139 | /// |
| 140 | /// E.g., `Foo<A=Bar>`. |
| 141 | pub bindings: Vec<TypeBinding>, |
| 142 | } |
| 143 | |
| 144 | /// Bind a type to an associated type: `A=Foo`. |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 145 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 146 | pub struct TypeBinding { |
| 147 | pub ident: Ident, |
| 148 | pub ty: Ty, |
| 149 | } |
| 150 | |
| 151 | /// A path like `Foo(A,B) -> C` |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 152 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 153 | pub struct ParenthesizedParameterData { |
| 154 | /// `(A, B)` |
| 155 | pub inputs: Vec<Ty>, |
| 156 | /// `C` |
| 157 | pub output: Option<Ty>, |
| 158 | } |
| 159 | |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 160 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 161 | pub struct PolyTraitRef { |
| 162 | /// The `'a` in `<'a> Foo<&'a T>` |
| 163 | pub bound_lifetimes: Vec<LifetimeDef>, |
| 164 | /// The `Foo<&'a T>` in `<'a> Foo<&'a T>` |
| 165 | pub trait_ref: Path, |
| 166 | } |
| 167 | |
| 168 | /// The explicit Self type in a "qualified path". The actual |
| 169 | /// path, including the trait and the associated item, is stored |
| 170 | /// separately. `position` represents the index of the associated |
| 171 | /// item qualified with this Self type. |
| 172 | /// |
| 173 | /// ```rust,ignore |
| 174 | /// <Vec<T> as a::b::Trait>::AssociatedItem |
| 175 | /// ^~~~~ ~~~~~~~~~~~~~~^ |
| 176 | /// ty position = 3 |
| 177 | /// |
| 178 | /// <Vec<T>>::AssociatedItem |
| 179 | /// ^~~~~ ^ |
| 180 | /// ty position = 0 |
| 181 | /// ``` |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 182 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 183 | pub struct QSelf { |
| 184 | pub ty: Box<Ty>, |
David Tolnay | daaf774 | 2016-10-03 11:11:43 -0700 | [diff] [blame] | 185 | pub position: usize, |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 186 | } |
| 187 | |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 188 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 189 | pub struct BareFnTy { |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 190 | pub unsafety: Unsafety, |
| 191 | pub abi: Option<Abi>, |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 192 | pub lifetimes: Vec<LifetimeDef>, |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 193 | pub inputs: Vec<BareFnArg>, |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 194 | pub output: FunctionRetTy, |
David Tolnay | 292e600 | 2016-10-29 22:03:51 -0700 | [diff] [blame] | 195 | pub variadic: bool, |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 196 | } |
| 197 | |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 198 | #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 199 | pub enum Unsafety { |
| 200 | Unsafe, |
| 201 | Normal, |
| 202 | } |
| 203 | |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 204 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 205 | pub enum Abi { |
| 206 | Named(String), |
David Tolnay | 76195ce | 2016-10-30 16:53:48 -0700 | [diff] [blame] | 207 | Rust, |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 208 | } |
| 209 | |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 210 | /// An argument in a function type. |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 211 | /// |
| 212 | /// E.g. `bar: usize` as in `fn foo(bar: usize)` |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 213 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 214 | pub struct BareFnArg { |
| 215 | pub name: Option<Ident>, |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 216 | pub ty: Ty, |
| 217 | } |
| 218 | |
David Tolnay | 9bf4af8 | 2017-01-07 11:17:46 -0800 | [diff] [blame] | 219 | #[derive(Debug, Clone, Eq, PartialEq, Hash)] |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 220 | pub enum FunctionRetTy { |
| 221 | /// Return type is not specified. |
| 222 | /// |
| 223 | /// Functions default to `()` and |
| 224 | /// closures default to inference. Span points to where return |
| 225 | /// type would be inserted. |
| 226 | Default, |
| 227 | /// Everything else |
| 228 | Ty(Ty), |
| 229 | } |
| 230 | |
David Tolnay | 86eca75 | 2016-09-04 11:26:41 -0700 | [diff] [blame] | 231 | #[cfg(feature = "parsing")] |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 232 | pub mod parsing { |
| 233 | use super::*; |
David Tolnay | a6ac181 | 2017-01-23 00:29:11 -0800 | [diff] [blame] | 234 | use {TyParamBound, TraitBoundModifier}; |
David Tolnay | fe2cc9a | 2016-10-30 12:47:36 -0700 | [diff] [blame] | 235 | #[cfg(feature = "full")] |
| 236 | use ConstExpr; |
David Tolnay | f945fb5 | 2017-02-27 12:53:54 -0800 | [diff] [blame] | 237 | #[cfg(feature = "full")] |
David Tolnay | 3cb23a9 | 2016-10-07 23:02:21 -0700 | [diff] [blame] | 238 | use constant::parsing::const_expr; |
David Tolnay | fe2cc9a | 2016-10-30 12:47:36 -0700 | [diff] [blame] | 239 | #[cfg(feature = "full")] |
| 240 | use expr::parsing::expr; |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 241 | use generics::parsing::{lifetime, lifetime_def, ty_param_bound, bound_lifetimes}; |
David Tolnay | 5533772 | 2016-09-11 12:58:56 -0700 | [diff] [blame] | 242 | use ident::parsing::ident; |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 243 | use lit::parsing::quoted_string; |
David Tolnay | 0047c71 | 2016-12-21 21:59:25 -0500 | [diff] [blame] | 244 | use mac::parsing::mac; |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 245 | use std::str; |
David Tolnay | da4049b | 2016-09-04 10:59:23 -0700 | [diff] [blame] | 246 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 247 | named!(pub ty -> Ty, alt!( |
David Tolnay | d040d77 | 2016-10-25 21:33:51 -0700 | [diff] [blame] | 248 | ty_paren // must be before ty_tup |
| 249 | | |
David Tolnay | 0047c71 | 2016-12-21 21:59:25 -0500 | [diff] [blame] | 250 | ty_mac // must be before ty_path |
| 251 | | |
David Tolnay | 4f0f251 | 2016-10-30 09:28:14 -0700 | [diff] [blame] | 252 | ty_path // must be before ty_poly_trait_ref |
| 253 | | |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 254 | ty_vec |
David Tolnay | da4049b | 2016-09-04 10:59:23 -0700 | [diff] [blame] | 255 | | |
David Tolnay | fa94b6f | 2016-10-05 23:26:11 -0700 | [diff] [blame] | 256 | ty_array |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 257 | | |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 258 | ty_ptr |
| 259 | | |
| 260 | ty_rptr |
| 261 | | |
| 262 | ty_bare_fn |
| 263 | | |
| 264 | ty_never |
| 265 | | |
| 266 | ty_tup |
| 267 | | |
David Tolnay | 4f0f251 | 2016-10-30 09:28:14 -0700 | [diff] [blame] | 268 | ty_poly_trait_ref |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 269 | | |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 270 | ty_impl_trait |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 271 | )); |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 272 | |
David Tolnay | 0047c71 | 2016-12-21 21:59:25 -0500 | [diff] [blame] | 273 | named!(ty_mac -> Ty, map!(mac, Ty::Mac)); |
| 274 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 275 | named!(ty_vec -> Ty, do_parse!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 276 | punct!("[") >> |
| 277 | elem: ty >> |
| 278 | punct!("]") >> |
David Tolnay | 16709ba | 2016-10-05 23:11:32 -0700 | [diff] [blame] | 279 | (Ty::Slice(Box::new(elem))) |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 280 | )); |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 281 | |
David Tolnay | fa94b6f | 2016-10-05 23:26:11 -0700 | [diff] [blame] | 282 | named!(ty_array -> Ty, do_parse!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 283 | punct!("[") >> |
| 284 | elem: ty >> |
| 285 | punct!(";") >> |
David Tolnay | 514f129 | 2017-02-27 12:30:57 -0800 | [diff] [blame] | 286 | len: array_len >> |
David Tolnay | c94c38a | 2016-09-05 17:02:03 -0700 | [diff] [blame] | 287 | punct!("]") >> |
David Tolnay | fa94b6f | 2016-10-05 23:26:11 -0700 | [diff] [blame] | 288 | (Ty::Array(Box::new(elem), len)) |
| 289 | )); |
| 290 | |
David Tolnay | 514f129 | 2017-02-27 12:30:57 -0800 | [diff] [blame] | 291 | #[cfg(not(feature = "full"))] |
David Tolnay | f945fb5 | 2017-02-27 12:53:54 -0800 | [diff] [blame] | 292 | use constant::parsing::const_expr as array_len; |
David Tolnay | 514f129 | 2017-02-27 12:30:57 -0800 | [diff] [blame] | 293 | |
David Tolnay | fe2cc9a | 2016-10-30 12:47:36 -0700 | [diff] [blame] | 294 | #[cfg(feature = "full")] |
David Tolnay | 514f129 | 2017-02-27 12:30:57 -0800 | [diff] [blame] | 295 | named!(array_len -> ConstExpr, alt!( |
| 296 | terminated!(const_expr, after_array_len) |
| 297 | | |
| 298 | terminated!(expr, after_array_len) => { ConstExpr::Other } |
David Tolnay | fe2cc9a | 2016-10-30 12:47:36 -0700 | [diff] [blame] | 299 | )); |
| 300 | |
David Tolnay | 514f129 | 2017-02-27 12:30:57 -0800 | [diff] [blame] | 301 | #[cfg(feature = "full")] |
| 302 | named!(after_array_len -> &str, peek!(punct!("]"))); |
| 303 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 304 | named!(ty_ptr -> Ty, do_parse!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 305 | punct!("*") >> |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 306 | mutability: alt!( |
David Tolnay | 10413f0 | 2016-09-30 09:12:02 -0700 | [diff] [blame] | 307 | keyword!("const") => { |_| Mutability::Immutable } |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 308 | | |
David Tolnay | 10413f0 | 2016-09-30 09:12:02 -0700 | [diff] [blame] | 309 | keyword!("mut") => { |_| Mutability::Mutable } |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 310 | ) >> |
| 311 | target: ty >> |
| 312 | (Ty::Ptr(Box::new(MutTy { |
| 313 | ty: target, |
| 314 | mutability: mutability, |
| 315 | }))) |
| 316 | )); |
| 317 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 318 | named!(ty_rptr -> Ty, do_parse!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 319 | punct!("&") >> |
David Tolnay | f6ccb83 | 2016-09-04 15:00:56 -0700 | [diff] [blame] | 320 | life: option!(lifetime) >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 321 | mutability: mutability >> |
| 322 | target: ty >> |
| 323 | (Ty::Rptr(life, Box::new(MutTy { |
| 324 | ty: target, |
| 325 | mutability: mutability, |
| 326 | }))) |
| 327 | )); |
| 328 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 329 | named!(ty_bare_fn -> Ty, do_parse!( |
David Tolnay | 4f12183 | 2016-10-25 21:33:36 -0700 | [diff] [blame] | 330 | lifetimes: opt_vec!(do_parse!( |
| 331 | keyword!("for") >> |
| 332 | punct!("<") >> |
| 333 | lifetimes: terminated_list!(punct!(","), lifetime_def) >> |
| 334 | punct!(">") >> |
| 335 | (lifetimes) |
David Tolnay | 6b7aaf0 | 2016-09-04 10:39:25 -0700 | [diff] [blame] | 336 | )) >> |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 337 | unsafety: unsafety >> |
| 338 | abi: option!(abi) >> |
David Tolnay | 4f12183 | 2016-10-25 21:33:36 -0700 | [diff] [blame] | 339 | keyword!("fn") >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 340 | punct!("(") >> |
David Tolnay | 292e600 | 2016-10-29 22:03:51 -0700 | [diff] [blame] | 341 | inputs: separated_list!(punct!(","), fn_arg) >> |
| 342 | trailing_comma: option!(punct!(",")) >> |
| 343 | variadic: option!(cond_reduce!(trailing_comma.is_some(), punct!("..."))) >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 344 | punct!(")") >> |
David Tolnay | f6ccb83 | 2016-09-04 15:00:56 -0700 | [diff] [blame] | 345 | output: option!(preceded!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 346 | punct!("->"), |
| 347 | ty |
| 348 | )) >> |
| 349 | (Ty::BareFn(Box::new(BareFnTy { |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 350 | unsafety: unsafety, |
| 351 | abi: abi, |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 352 | lifetimes: lifetimes, |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 353 | inputs: inputs, |
| 354 | output: match output { |
| 355 | Some(ty) => FunctionRetTy::Ty(ty), |
| 356 | None => FunctionRetTy::Default, |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 357 | }, |
David Tolnay | 292e600 | 2016-10-29 22:03:51 -0700 | [diff] [blame] | 358 | variadic: variadic.is_some(), |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 359 | }))) |
| 360 | )); |
| 361 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 362 | named!(ty_never -> Ty, map!(punct!("!"), |_| Ty::Never)); |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 363 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 364 | named!(ty_tup -> Ty, do_parse!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 365 | punct!("(") >> |
David Tolnay | ff46fd2 | 2016-10-08 13:53:28 -0700 | [diff] [blame] | 366 | elems: terminated_list!(punct!(","), ty) >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 367 | punct!(")") >> |
| 368 | (Ty::Tup(elems)) |
| 369 | )); |
| 370 | |
David Tolnay | 6414da7 | 2016-10-08 00:55:17 -0700 | [diff] [blame] | 371 | named!(ty_path -> Ty, do_parse!( |
| 372 | qpath: qpath >> |
David Tolnay | f6c7440 | 2016-10-08 02:31:26 -0700 | [diff] [blame] | 373 | parenthesized: cond!( |
| 374 | qpath.1.segments.last().unwrap().parameters == PathParameters::none(), |
| 375 | option!(parenthesized_parameter_data) |
| 376 | ) >> |
David Tolnay | 6414da7 | 2016-10-08 00:55:17 -0700 | [diff] [blame] | 377 | bounds: many0!(preceded!(punct!("+"), ty_param_bound)) >> |
| 378 | ({ |
David Tolnay | f6c7440 | 2016-10-08 02:31:26 -0700 | [diff] [blame] | 379 | let (qself, mut path) = qpath; |
| 380 | if let Some(Some(parenthesized)) = parenthesized { |
| 381 | path.segments.last_mut().unwrap().parameters = parenthesized; |
| 382 | } |
David Tolnay | 6414da7 | 2016-10-08 00:55:17 -0700 | [diff] [blame] | 383 | if bounds.is_empty() { |
David Tolnay | 02c907f | 2017-01-23 00:06:37 -0800 | [diff] [blame] | 384 | Ty::Path(qself, path) |
David Tolnay | 6414da7 | 2016-10-08 00:55:17 -0700 | [diff] [blame] | 385 | } else { |
David Tolnay | 02c907f | 2017-01-23 00:06:37 -0800 | [diff] [blame] | 386 | let path = TyParamBound::Trait( |
| 387 | PolyTraitRef { |
| 388 | bound_lifetimes: Vec::new(), |
| 389 | trait_ref: path, |
| 390 | }, |
| 391 | TraitBoundModifier::None, |
| 392 | ); |
| 393 | let bounds = Some(path).into_iter().chain(bounds).collect(); |
| 394 | Ty::TraitObject(bounds) |
David Tolnay | 6414da7 | 2016-10-08 00:55:17 -0700 | [diff] [blame] | 395 | } |
| 396 | }) |
| 397 | )); |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 398 | |
David Tolnay | f6c7440 | 2016-10-08 02:31:26 -0700 | [diff] [blame] | 399 | named!(parenthesized_parameter_data -> PathParameters, do_parse!( |
| 400 | punct!("(") >> |
David Tolnay | ff46fd2 | 2016-10-08 13:53:28 -0700 | [diff] [blame] | 401 | inputs: terminated_list!(punct!(","), ty) >> |
David Tolnay | f6c7440 | 2016-10-08 02:31:26 -0700 | [diff] [blame] | 402 | punct!(")") >> |
| 403 | output: option!(preceded!( |
| 404 | punct!("->"), |
| 405 | ty |
| 406 | )) >> |
| 407 | (PathParameters::Parenthesized( |
| 408 | ParenthesizedParameterData { |
| 409 | inputs: inputs, |
| 410 | output: output, |
| 411 | }, |
| 412 | )) |
| 413 | )); |
| 414 | |
David Tolnay | 9636c05 | 2016-10-02 17:11:17 -0700 | [diff] [blame] | 415 | named!(pub qpath -> (Option<QSelf>, Path), alt!( |
| 416 | map!(path, |p| (None, p)) |
| 417 | | |
| 418 | do_parse!( |
| 419 | punct!("<") >> |
| 420 | this: map!(ty, Box::new) >> |
| 421 | path: option!(preceded!( |
| 422 | keyword!("as"), |
| 423 | path |
| 424 | )) >> |
| 425 | punct!(">") >> |
| 426 | punct!("::") >> |
| 427 | rest: separated_nonempty_list!(punct!("::"), path_segment) >> |
| 428 | ({ |
| 429 | match path { |
| 430 | Some(mut path) => { |
| 431 | let pos = path.segments.len(); |
| 432 | path.segments.extend(rest); |
| 433 | (Some(QSelf { ty: this, position: pos }), path) |
| 434 | } |
| 435 | None => { |
| 436 | (Some(QSelf { ty: this, position: 0 }), Path { |
| 437 | global: false, |
| 438 | segments: rest, |
| 439 | }) |
| 440 | } |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 441 | } |
David Tolnay | 9636c05 | 2016-10-02 17:11:17 -0700 | [diff] [blame] | 442 | }) |
| 443 | ) |
David Tolnay | 6cd2a23 | 2016-10-24 22:41:08 -0700 | [diff] [blame] | 444 | | |
| 445 | map!(keyword!("self"), |_| (None, "self".into())) |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 446 | )); |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 447 | |
David Tolnay | 4f0f251 | 2016-10-30 09:28:14 -0700 | [diff] [blame] | 448 | named!(ty_poly_trait_ref -> Ty, map!( |
David Tolnay | 8eb6c45 | 2016-10-30 13:19:15 -0700 | [diff] [blame] | 449 | separated_nonempty_list!(punct!("+"), ty_param_bound), |
David Tolnay | 02c907f | 2017-01-23 00:06:37 -0800 | [diff] [blame] | 450 | Ty::TraitObject |
David Tolnay | 6414da7 | 2016-10-08 00:55:17 -0700 | [diff] [blame] | 451 | )); |
| 452 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 453 | named!(ty_impl_trait -> Ty, do_parse!( |
David Tolnay | 10413f0 | 2016-09-30 09:12:02 -0700 | [diff] [blame] | 454 | keyword!("impl") >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 455 | elem: separated_nonempty_list!(punct!("+"), ty_param_bound) >> |
| 456 | (Ty::ImplTrait(elem)) |
| 457 | )); |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 458 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 459 | named!(ty_paren -> Ty, do_parse!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 460 | punct!("(") >> |
| 461 | elem: ty >> |
| 462 | punct!(")") >> |
| 463 | (Ty::Paren(Box::new(elem))) |
| 464 | )); |
David Tolnay | b79ee96 | 2016-09-04 09:39:20 -0700 | [diff] [blame] | 465 | |
David Tolnay | 47a877c | 2016-10-01 16:50:55 -0700 | [diff] [blame] | 466 | named!(pub mutability -> Mutability, alt!( |
David Tolnay | bd76e57 | 2016-10-02 13:43:16 -0700 | [diff] [blame] | 467 | keyword!("mut") => { |_| Mutability::Mutable } |
David Tolnay | f6ccb83 | 2016-09-04 15:00:56 -0700 | [diff] [blame] | 468 | | |
| 469 | epsilon!() => { |_| Mutability::Immutable } |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 470 | )); |
| 471 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 472 | named!(pub path -> Path, do_parse!( |
David Tolnay | f6ccb83 | 2016-09-04 15:00:56 -0700 | [diff] [blame] | 473 | global: option!(punct!("::")) >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 474 | segments: separated_nonempty_list!(punct!("::"), path_segment) >> |
| 475 | (Path { |
| 476 | global: global.is_some(), |
| 477 | segments: segments, |
| 478 | }) |
| 479 | )); |
| 480 | |
David Tolnay | 9636c05 | 2016-10-02 17:11:17 -0700 | [diff] [blame] | 481 | named!(path_segment -> PathSegment, alt!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 482 | do_parse!( |
David Tolnay | 9636c05 | 2016-10-02 17:11:17 -0700 | [diff] [blame] | 483 | id: option!(ident) >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 484 | punct!("<") >> |
| 485 | lifetimes: separated_list!(punct!(","), lifetime) >> |
| 486 | types: opt_vec!(preceded!( |
| 487 | cond!(!lifetimes.is_empty(), punct!(",")), |
| 488 | separated_nonempty_list!( |
| 489 | punct!(","), |
David Tolnay | 1f16b60 | 2017-02-07 20:06:55 -0500 | [diff] [blame] | 490 | terminated!(ty, not!(punct!("="))) |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 491 | ) |
| 492 | )) >> |
| 493 | bindings: opt_vec!(preceded!( |
| 494 | cond!(!lifetimes.is_empty() || !types.is_empty(), punct!(",")), |
| 495 | separated_nonempty_list!(punct!(","), type_binding) |
| 496 | )) >> |
David Tolnay | 82a47d5 | 2016-10-30 13:01:38 -0700 | [diff] [blame] | 497 | cond!(!lifetimes.is_empty() || !types.is_empty() || !bindings.is_empty(), option!(punct!(","))) >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 498 | punct!(">") >> |
| 499 | (PathSegment { |
David Tolnay | 9636c05 | 2016-10-02 17:11:17 -0700 | [diff] [blame] | 500 | ident: id.unwrap_or_else(|| "".into()), |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 501 | parameters: PathParameters::AngleBracketed( |
| 502 | AngleBracketedParameterData { |
| 503 | lifetimes: lifetimes, |
| 504 | types: types, |
| 505 | bindings: bindings, |
| 506 | } |
| 507 | ), |
| 508 | }) |
| 509 | ) |
| 510 | | |
David Tolnay | 84aa075 | 2016-10-02 23:01:13 -0700 | [diff] [blame] | 511 | map!(ident, Into::into) |
David Tolnay | 7780722 | 2016-10-24 22:30:15 -0700 | [diff] [blame] | 512 | | |
David Tolnay | e14e3be | 2016-10-24 22:53:07 -0700 | [diff] [blame] | 513 | map!(alt!( |
| 514 | keyword!("super") |
| 515 | | |
| 516 | keyword!("self") |
| 517 | | |
| 518 | keyword!("Self") |
| 519 | ), Into::into) |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 520 | )); |
| 521 | |
Arnavion | f2dada1 | 2017-04-20 23:55:20 -0700 | [diff] [blame^] | 522 | named!(pub mod_style_path -> Path, do_parse!( |
| 523 | global: option!(punct!("::")) >> |
| 524 | segments: separated_nonempty_list!(punct!("::"), mod_style_path_segment) >> |
| 525 | (Path { |
| 526 | global: global.is_some(), |
| 527 | segments: segments, |
| 528 | }) |
| 529 | )); |
| 530 | |
| 531 | named!(mod_style_path_segment -> PathSegment, alt!( |
| 532 | map!(ident, Into::into) |
| 533 | | |
| 534 | map!(alt!( |
| 535 | keyword!("super") |
| 536 | | |
| 537 | keyword!("self") |
| 538 | | |
| 539 | keyword!("Self") |
| 540 | ), Into::into) |
| 541 | )); |
| 542 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 543 | named!(type_binding -> TypeBinding, do_parse!( |
David Tolnay | 5533772 | 2016-09-11 12:58:56 -0700 | [diff] [blame] | 544 | id: ident >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 545 | punct!("=") >> |
| 546 | ty: ty >> |
| 547 | (TypeBinding { |
David Tolnay | 5533772 | 2016-09-11 12:58:56 -0700 | [diff] [blame] | 548 | ident: id, |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 549 | ty: ty, |
| 550 | }) |
| 551 | )); |
| 552 | |
David Tolnay | b5a7b14 | 2016-09-13 22:46:39 -0700 | [diff] [blame] | 553 | named!(pub poly_trait_ref -> PolyTraitRef, do_parse!( |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 554 | bound_lifetimes: bound_lifetimes >> |
| 555 | trait_ref: path >> |
David Tolnay | 4f0f251 | 2016-10-30 09:28:14 -0700 | [diff] [blame] | 556 | parenthesized: option!(cond_reduce!( |
David Tolnay | f6c7440 | 2016-10-08 02:31:26 -0700 | [diff] [blame] | 557 | trait_ref.segments.last().unwrap().parameters == PathParameters::none(), |
David Tolnay | 4f0f251 | 2016-10-30 09:28:14 -0700 | [diff] [blame] | 558 | parenthesized_parameter_data |
| 559 | )) >> |
David Tolnay | f6c7440 | 2016-10-08 02:31:26 -0700 | [diff] [blame] | 560 | ({ |
| 561 | let mut trait_ref = trait_ref; |
David Tolnay | 4f0f251 | 2016-10-30 09:28:14 -0700 | [diff] [blame] | 562 | if let Some(parenthesized) = parenthesized { |
David Tolnay | f6c7440 | 2016-10-08 02:31:26 -0700 | [diff] [blame] | 563 | trait_ref.segments.last_mut().unwrap().parameters = parenthesized; |
| 564 | } |
| 565 | PolyTraitRef { |
| 566 | bound_lifetimes: bound_lifetimes, |
| 567 | trait_ref: trait_ref, |
| 568 | } |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 569 | }) |
| 570 | )); |
| 571 | |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 572 | named!(pub fn_arg -> BareFnArg, do_parse!( |
David Tolnay | b0417d7 | 2016-10-25 21:46:35 -0700 | [diff] [blame] | 573 | name: option!(do_parse!( |
| 574 | name: ident >> |
| 575 | punct!(":") >> |
David Tolnay | 1f16b60 | 2017-02-07 20:06:55 -0500 | [diff] [blame] | 576 | not!(tag!(":")) >> // not :: |
David Tolnay | b0417d7 | 2016-10-25 21:46:35 -0700 | [diff] [blame] | 577 | (name) |
| 578 | )) >> |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 579 | ty: ty >> |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 580 | (BareFnArg { |
| 581 | name: name, |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 582 | ty: ty, |
| 583 | }) |
| 584 | )); |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 585 | |
| 586 | named!(pub unsafety -> Unsafety, alt!( |
| 587 | keyword!("unsafe") => { |_| Unsafety::Unsafe } |
| 588 | | |
| 589 | epsilon!() => { |_| Unsafety::Normal } |
| 590 | )); |
| 591 | |
| 592 | named!(pub abi -> Abi, do_parse!( |
| 593 | keyword!("extern") >> |
| 594 | name: option!(quoted_string) >> |
| 595 | (match name { |
| 596 | Some(name) => Abi::Named(name), |
David Tolnay | 76195ce | 2016-10-30 16:53:48 -0700 | [diff] [blame] | 597 | None => Abi::Rust, |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 598 | }) |
| 599 | )); |
David Tolnay | 9d8f197 | 2016-09-04 11:58:48 -0700 | [diff] [blame] | 600 | } |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 601 | |
| 602 | #[cfg(feature = "printing")] |
| 603 | mod printing { |
| 604 | use super::*; |
| 605 | use quote::{Tokens, ToTokens}; |
| 606 | |
| 607 | impl ToTokens for Ty { |
| 608 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 609 | match *self { |
David Tolnay | 16709ba | 2016-10-05 23:11:32 -0700 | [diff] [blame] | 610 | Ty::Slice(ref inner) => { |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 611 | tokens.append("["); |
| 612 | inner.to_tokens(tokens); |
| 613 | tokens.append("]"); |
| 614 | } |
David Tolnay | fa94b6f | 2016-10-05 23:26:11 -0700 | [diff] [blame] | 615 | Ty::Array(ref inner, ref len) => { |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 616 | tokens.append("["); |
| 617 | inner.to_tokens(tokens); |
| 618 | tokens.append(";"); |
David Tolnay | fa94b6f | 2016-10-05 23:26:11 -0700 | [diff] [blame] | 619 | len.to_tokens(tokens); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 620 | tokens.append("]"); |
| 621 | } |
| 622 | Ty::Ptr(ref target) => { |
| 623 | tokens.append("*"); |
| 624 | match target.mutability { |
| 625 | Mutability::Mutable => tokens.append("mut"), |
| 626 | Mutability::Immutable => tokens.append("const"), |
| 627 | } |
| 628 | target.ty.to_tokens(tokens); |
| 629 | } |
| 630 | Ty::Rptr(ref lifetime, ref target) => { |
| 631 | tokens.append("&"); |
| 632 | lifetime.to_tokens(tokens); |
David Tolnay | 47a877c | 2016-10-01 16:50:55 -0700 | [diff] [blame] | 633 | target.mutability.to_tokens(tokens); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 634 | target.ty.to_tokens(tokens); |
| 635 | } |
| 636 | Ty::BareFn(ref func) => { |
| 637 | func.to_tokens(tokens); |
| 638 | } |
| 639 | Ty::Never => { |
| 640 | tokens.append("!"); |
| 641 | } |
| 642 | Ty::Tup(ref elems) => { |
| 643 | tokens.append("("); |
David Tolnay | 94ebdf9 | 2016-09-04 13:33:16 -0700 | [diff] [blame] | 644 | tokens.append_separated(elems, ","); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 645 | if elems.len() == 1 { |
| 646 | tokens.append(","); |
| 647 | } |
| 648 | tokens.append(")"); |
| 649 | } |
David Tolnay | f69904a | 2016-09-04 14:46:07 -0700 | [diff] [blame] | 650 | Ty::Path(None, ref path) => { |
| 651 | path.to_tokens(tokens); |
| 652 | } |
| 653 | Ty::Path(Some(ref qself), ref path) => { |
| 654 | tokens.append("<"); |
| 655 | qself.ty.to_tokens(tokens); |
| 656 | if qself.position > 0 { |
| 657 | tokens.append("as"); |
David Tolnay | daaf774 | 2016-10-03 11:11:43 -0700 | [diff] [blame] | 658 | for (i, segment) in path.segments |
David Tolnay | 05120ef | 2017-03-12 18:29:26 -0700 | [diff] [blame] | 659 | .iter() |
| 660 | .take(qself.position) |
| 661 | .enumerate() { |
David Tolnay | f69904a | 2016-09-04 14:46:07 -0700 | [diff] [blame] | 662 | if i > 0 || path.global { |
| 663 | tokens.append("::"); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 664 | } |
David Tolnay | f69904a | 2016-09-04 14:46:07 -0700 | [diff] [blame] | 665 | segment.to_tokens(tokens); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 666 | } |
David Tolnay | f69904a | 2016-09-04 14:46:07 -0700 | [diff] [blame] | 667 | } |
| 668 | tokens.append(">"); |
| 669 | for segment in path.segments.iter().skip(qself.position) { |
| 670 | tokens.append("::"); |
| 671 | segment.to_tokens(tokens); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 672 | } |
| 673 | } |
David Tolnay | 02c907f | 2017-01-23 00:06:37 -0800 | [diff] [blame] | 674 | Ty::TraitObject(ref bounds) => { |
David Tolnay | 6414da7 | 2016-10-08 00:55:17 -0700 | [diff] [blame] | 675 | tokens.append_separated(bounds, "+"); |
| 676 | } |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 677 | Ty::ImplTrait(ref bounds) => { |
| 678 | tokens.append("impl"); |
David Tolnay | 94ebdf9 | 2016-09-04 13:33:16 -0700 | [diff] [blame] | 679 | tokens.append_separated(bounds, "+"); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 680 | } |
| 681 | Ty::Paren(ref inner) => { |
| 682 | tokens.append("("); |
| 683 | inner.to_tokens(tokens); |
| 684 | tokens.append(")"); |
| 685 | } |
| 686 | Ty::Infer => { |
| 687 | tokens.append("_"); |
| 688 | } |
David Tolnay | 0047c71 | 2016-12-21 21:59:25 -0500 | [diff] [blame] | 689 | Ty::Mac(ref mac) => mac.to_tokens(tokens), |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 690 | } |
| 691 | } |
| 692 | } |
| 693 | |
David Tolnay | 47a877c | 2016-10-01 16:50:55 -0700 | [diff] [blame] | 694 | impl ToTokens for Mutability { |
| 695 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 696 | if let Mutability::Mutable = *self { |
| 697 | tokens.append("mut"); |
| 698 | } |
| 699 | } |
| 700 | } |
| 701 | |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 702 | impl ToTokens for Path { |
| 703 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 704 | for (i, segment) in self.segments.iter().enumerate() { |
| 705 | if i > 0 || self.global { |
| 706 | tokens.append("::"); |
| 707 | } |
| 708 | segment.to_tokens(tokens); |
| 709 | } |
| 710 | } |
| 711 | } |
| 712 | |
| 713 | impl ToTokens for PathSegment { |
| 714 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 715 | self.ident.to_tokens(tokens); |
David Tolnay | 5332d4b | 2016-10-30 14:25:22 -0700 | [diff] [blame] | 716 | if self.ident.as_ref().is_empty() && self.parameters.is_empty() { |
| 717 | tokens.append("<"); |
| 718 | tokens.append(">"); |
| 719 | } else { |
| 720 | self.parameters.to_tokens(tokens); |
| 721 | } |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 722 | } |
| 723 | } |
| 724 | |
| 725 | impl ToTokens for PathParameters { |
| 726 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 727 | match *self { |
| 728 | PathParameters::AngleBracketed(ref parameters) => { |
| 729 | parameters.to_tokens(tokens); |
| 730 | } |
| 731 | PathParameters::Parenthesized(ref parameters) => { |
| 732 | parameters.to_tokens(tokens); |
| 733 | } |
| 734 | } |
| 735 | } |
| 736 | } |
| 737 | |
| 738 | impl ToTokens for AngleBracketedParameterData { |
| 739 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 740 | let has_lifetimes = !self.lifetimes.is_empty(); |
| 741 | let has_types = !self.types.is_empty(); |
| 742 | let has_bindings = !self.bindings.is_empty(); |
| 743 | if !has_lifetimes && !has_types && !has_bindings { |
| 744 | return; |
| 745 | } |
| 746 | |
| 747 | tokens.append("<"); |
| 748 | |
| 749 | let mut first = true; |
| 750 | for lifetime in &self.lifetimes { |
| 751 | if !first { |
| 752 | tokens.append(","); |
| 753 | } |
| 754 | lifetime.to_tokens(tokens); |
| 755 | first = false; |
| 756 | } |
| 757 | for ty in &self.types { |
| 758 | if !first { |
| 759 | tokens.append(","); |
| 760 | } |
| 761 | ty.to_tokens(tokens); |
| 762 | first = false; |
| 763 | } |
| 764 | for binding in &self.bindings { |
| 765 | if !first { |
| 766 | tokens.append(","); |
| 767 | } |
| 768 | binding.to_tokens(tokens); |
| 769 | first = false; |
| 770 | } |
| 771 | |
| 772 | tokens.append(">"); |
| 773 | } |
| 774 | } |
| 775 | |
| 776 | impl ToTokens for TypeBinding { |
| 777 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 778 | self.ident.to_tokens(tokens); |
| 779 | tokens.append("="); |
| 780 | self.ty.to_tokens(tokens); |
| 781 | } |
| 782 | } |
| 783 | |
| 784 | impl ToTokens for ParenthesizedParameterData { |
| 785 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 786 | tokens.append("("); |
David Tolnay | 94ebdf9 | 2016-09-04 13:33:16 -0700 | [diff] [blame] | 787 | tokens.append_separated(&self.inputs, ","); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 788 | tokens.append(")"); |
| 789 | if let Some(ref output) = self.output { |
| 790 | tokens.append("->"); |
| 791 | output.to_tokens(tokens); |
| 792 | } |
| 793 | } |
| 794 | } |
| 795 | |
| 796 | impl ToTokens for PolyTraitRef { |
| 797 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 798 | if !self.bound_lifetimes.is_empty() { |
David Tolnay | e8796aa | 2016-09-04 14:48:22 -0700 | [diff] [blame] | 799 | tokens.append("for"); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 800 | tokens.append("<"); |
David Tolnay | 94ebdf9 | 2016-09-04 13:33:16 -0700 | [diff] [blame] | 801 | tokens.append_separated(&self.bound_lifetimes, ","); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 802 | tokens.append(">"); |
| 803 | } |
| 804 | self.trait_ref.to_tokens(tokens); |
| 805 | } |
| 806 | } |
| 807 | |
| 808 | impl ToTokens for BareFnTy { |
| 809 | fn to_tokens(&self, tokens: &mut Tokens) { |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 810 | if !self.lifetimes.is_empty() { |
David Tolnay | 4f12183 | 2016-10-25 21:33:36 -0700 | [diff] [blame] | 811 | tokens.append("for"); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 812 | tokens.append("<"); |
David Tolnay | 4260229 | 2016-10-01 22:25:45 -0700 | [diff] [blame] | 813 | tokens.append_separated(&self.lifetimes, ","); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 814 | tokens.append(">"); |
| 815 | } |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 816 | self.unsafety.to_tokens(tokens); |
| 817 | self.abi.to_tokens(tokens); |
David Tolnay | 4f12183 | 2016-10-25 21:33:36 -0700 | [diff] [blame] | 818 | tokens.append("fn"); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 819 | tokens.append("("); |
David Tolnay | 4260229 | 2016-10-01 22:25:45 -0700 | [diff] [blame] | 820 | tokens.append_separated(&self.inputs, ","); |
David Tolnay | 292e600 | 2016-10-29 22:03:51 -0700 | [diff] [blame] | 821 | if self.variadic { |
| 822 | if !self.inputs.is_empty() { |
| 823 | tokens.append(","); |
| 824 | } |
| 825 | tokens.append("..."); |
| 826 | } |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 827 | tokens.append(")"); |
David Tolnay | 4260229 | 2016-10-01 22:25:45 -0700 | [diff] [blame] | 828 | if let FunctionRetTy::Ty(ref ty) = self.output { |
| 829 | tokens.append("->"); |
| 830 | ty.to_tokens(tokens); |
| 831 | } |
| 832 | } |
| 833 | } |
| 834 | |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 835 | impl ToTokens for BareFnArg { |
David Tolnay | 4260229 | 2016-10-01 22:25:45 -0700 | [diff] [blame] | 836 | fn to_tokens(&self, tokens: &mut Tokens) { |
David Tolnay | 62f374c | 2016-10-02 13:37:00 -0700 | [diff] [blame] | 837 | if let Some(ref name) = self.name { |
| 838 | name.to_tokens(tokens); |
David Tolnay | 4260229 | 2016-10-01 22:25:45 -0700 | [diff] [blame] | 839 | tokens.append(":"); |
| 840 | } |
| 841 | self.ty.to_tokens(tokens); |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 842 | } |
| 843 | } |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 844 | |
| 845 | impl ToTokens for Unsafety { |
| 846 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 847 | match *self { |
| 848 | Unsafety::Unsafe => tokens.append("unsafe"), |
| 849 | Unsafety::Normal => { |
| 850 | // nothing |
| 851 | } |
| 852 | } |
| 853 | } |
| 854 | } |
| 855 | |
| 856 | impl ToTokens for Abi { |
| 857 | fn to_tokens(&self, tokens: &mut Tokens) { |
| 858 | tokens.append("extern"); |
| 859 | match *self { |
| 860 | Abi::Named(ref named) => named.to_tokens(tokens), |
David Tolnay | 76195ce | 2016-10-30 16:53:48 -0700 | [diff] [blame] | 861 | Abi::Rust => {} |
David Tolnay | b8d8ef5 | 2016-10-29 14:30:08 -0700 | [diff] [blame] | 862 | } |
| 863 | } |
| 864 | } |
David Tolnay | 87d0b44 | 2016-09-04 11:52:12 -0700 | [diff] [blame] | 865 | } |