blob: 4055b6a60c1b45338f4ed98ac14ceb433c4d1d00 [file] [log] [blame]
use super::*;
/// The different kinds of types recognized by the compiler
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum Ty {
/// A variable-length array (`[T]`)
Slice(Box<Ty>),
/// A fixed length array (`[T; n]`)
Array(Box<Ty>, ConstExpr),
/// A raw pointer (`*const T` or `*mut T`)
Ptr(Box<MutTy>),
/// A reference (`&'a T` or `&'a mut T`)
Rptr(Option<Lifetime>, Box<MutTy>),
/// A bare function (e.g. `fn(usize) -> bool`)
BareFn(Box<BareFnTy>),
/// The never type (`!`)
Never,
/// A tuple (`(A, B, C, D, ...)`)
Tup(Vec<Ty>),
/// A path (`module::module::...::Type`), optionally
/// "qualified", e.g. `<Vec<T> as SomeTrait>::SomeType`.
///
/// Type parameters are stored in the Path itself
Path(Option<QSelf>, Path),
/// A trait object type `Bound1 + Bound2 + Bound3`
/// where `Bound` is a trait or a lifetime.
TraitObject(Vec<TyParamBound>),
/// An `impl Bound1 + Bound2 + Bound3` type
/// where `Bound` is a trait or a lifetime.
ImplTrait(Vec<TyParamBound>),
/// No-op; kept solely so that we can pretty-print faithfully
Paren(Box<Ty>),
/// TyKind::Infer means the type should be inferred instead of it having been
/// specified. This can appear anywhere in a type.
Infer,
/// A macro in the type position.
Mac(Mac),
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct MutTy {
pub ty: Ty,
pub mutability: Mutability,
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum Mutability {
Mutable,
Immutable,
}
/// A "Path" is essentially Rust's notion of a name.
///
/// It's represented as a sequence of identifiers,
/// along with a bunch of supporting information.
///
/// E.g. `std::cmp::PartialEq`
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct Path {
/// A `::foo` path, is relative to the crate root rather than current
/// module (like paths in an import).
pub global: bool,
/// The segments in the path: the things separated by `::`.
pub segments: Vec<PathSegment>,
}
impl<T> From<T> for Path
where T: Into<PathSegment>
{
fn from(segment: T) -> Self {
Path {
global: false,
segments: vec![segment.into()],
}
}
}
/// A segment of a path: an identifier, an optional lifetime, and a set of types.
///
/// E.g. `std`, `String` or `Box<T>`
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct PathSegment {
/// The identifier portion of this path segment.
pub ident: Ident,
/// Type/lifetime parameters attached to this path. They come in
/// two flavors: `Path<A,B,C>` and `Path(A,B) -> C`. Note that
/// this is more than just simple syntactic sugar; the use of
/// parens affects the region binding rules, so we preserve the
/// distinction.
pub parameters: PathParameters,
}
impl<T> From<T> for PathSegment
where T: Into<Ident>
{
fn from(ident: T) -> Self {
PathSegment {
ident: ident.into(),
parameters: PathParameters::none(),
}
}
}
/// Parameters of a path segment.
///
/// E.g. `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum PathParameters {
/// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`
AngleBracketed(AngleBracketedParameterData),
/// The `(A, B)` and `C` in `Foo(A, B) -> C`
Parenthesized(ParenthesizedParameterData),
}
impl PathParameters {
pub fn none() -> Self {
PathParameters::AngleBracketed(AngleBracketedParameterData::default())
}
pub fn is_empty(&self) -> bool {
match *self {
PathParameters::AngleBracketed(ref bracketed) => {
bracketed.lifetimes.is_empty() && bracketed.types.is_empty() &&
bracketed.bindings.is_empty()
}
PathParameters::Parenthesized(_) => false,
}
}
}
/// A path like `Foo<'a, T>`
#[derive(Debug, Clone, Eq, PartialEq, Default, Hash)]
pub struct AngleBracketedParameterData {
/// The lifetime parameters for this path segment.
pub lifetimes: Vec<Lifetime>,
/// The type parameters for this path segment, if present.
pub types: Vec<Ty>,
/// Bindings (equality constraints) on associated types, if present.
///
/// E.g., `Foo<A=Bar>`.
pub bindings: Vec<TypeBinding>,
}
/// Bind a type to an associated type: `A=Foo`.
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct TypeBinding {
pub ident: Ident,
pub ty: Ty,
}
/// A path like `Foo(A,B) -> C`
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct ParenthesizedParameterData {
/// `(A, B)`
pub inputs: Vec<Ty>,
/// `C`
pub output: Option<Ty>,
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct PolyTraitRef {
/// The `'a` in `<'a> Foo<&'a T>`
pub bound_lifetimes: Vec<LifetimeDef>,
/// The `Foo<&'a T>` in `<'a> Foo<&'a T>`
pub trait_ref: Path,
}
/// The explicit Self type in a "qualified path". The actual
/// path, including the trait and the associated item, is stored
/// separately. `position` represents the index of the associated
/// item qualified with this Self type.
///
/// ```rust,ignore
/// <Vec<T> as a::b::Trait>::AssociatedItem
/// ^~~~~ ~~~~~~~~~~~~~~^
/// ty position = 3
///
/// <Vec<T>>::AssociatedItem
/// ^~~~~ ^
/// ty position = 0
/// ```
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct QSelf {
pub ty: Box<Ty>,
pub position: usize,
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct BareFnTy {
pub unsafety: Unsafety,
pub abi: Option<Abi>,
pub lifetimes: Vec<LifetimeDef>,
pub inputs: Vec<BareFnArg>,
pub output: FunctionRetTy,
pub variadic: bool,
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum Unsafety {
Unsafe,
Normal,
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum Abi {
Named(String),
Rust,
}
/// An argument in a function type.
///
/// E.g. `bar: usize` as in `fn foo(bar: usize)`
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct BareFnArg {
pub name: Option<Ident>,
pub ty: Ty,
}
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum FunctionRetTy {
/// Return type is not specified.
///
/// Functions default to `()` and
/// closures default to inference. Span points to where return
/// type would be inserted.
Default,
/// Everything else
Ty(Ty),
}
#[cfg(feature = "parsing")]
pub mod parsing {
use super::*;
use {TyParamBound, TraitBoundModifier};
#[cfg(feature = "full")]
use ConstExpr;
#[cfg(feature = "full")]
use constant::parsing::const_expr;
#[cfg(feature = "full")]
use expr::parsing::expr;
use generics::parsing::{lifetime, lifetime_def, ty_param_bound, bound_lifetimes};
use ident::parsing::ident;
use lit::parsing::quoted_string;
use mac::parsing::mac;
use std::str;
named!(pub ty -> Ty, alt!(
ty_paren // must be before ty_tup
|
ty_mac // must be before ty_path
|
ty_path // must be before ty_poly_trait_ref
|
ty_vec
|
ty_array
|
ty_ptr
|
ty_rptr
|
ty_bare_fn
|
ty_never
|
ty_tup
|
ty_poly_trait_ref
|
ty_impl_trait
));
named!(ty_mac -> Ty, map!(mac, Ty::Mac));
named!(ty_vec -> Ty, do_parse!(
punct!("[") >>
elem: ty >>
punct!("]") >>
(Ty::Slice(Box::new(elem)))
));
named!(ty_array -> Ty, do_parse!(
punct!("[") >>
elem: ty >>
punct!(";") >>
len: array_len >>
punct!("]") >>
(Ty::Array(Box::new(elem), len))
));
#[cfg(not(feature = "full"))]
use constant::parsing::const_expr as array_len;
#[cfg(feature = "full")]
named!(array_len -> ConstExpr, alt!(
terminated!(const_expr, after_array_len)
|
terminated!(expr, after_array_len) => { ConstExpr::Other }
));
#[cfg(feature = "full")]
named!(after_array_len -> &str, peek!(punct!("]")));
named!(ty_ptr -> Ty, do_parse!(
punct!("*") >>
mutability: alt!(
keyword!("const") => { |_| Mutability::Immutable }
|
keyword!("mut") => { |_| Mutability::Mutable }
) >>
target: ty >>
(Ty::Ptr(Box::new(MutTy {
ty: target,
mutability: mutability,
})))
));
named!(ty_rptr -> Ty, do_parse!(
punct!("&") >>
life: option!(lifetime) >>
mutability: mutability >>
target: ty >>
(Ty::Rptr(life, Box::new(MutTy {
ty: target,
mutability: mutability,
})))
));
named!(ty_bare_fn -> Ty, do_parse!(
lifetimes: opt_vec!(do_parse!(
keyword!("for") >>
punct!("<") >>
lifetimes: terminated_list!(punct!(","), lifetime_def) >>
punct!(">") >>
(lifetimes)
)) >>
unsafety: unsafety >>
abi: option!(abi) >>
keyword!("fn") >>
punct!("(") >>
inputs: separated_list!(punct!(","), fn_arg) >>
trailing_comma: option!(punct!(",")) >>
variadic: option!(cond_reduce!(trailing_comma.is_some(), punct!("..."))) >>
punct!(")") >>
output: option!(preceded!(
punct!("->"),
ty
)) >>
(Ty::BareFn(Box::new(BareFnTy {
unsafety: unsafety,
abi: abi,
lifetimes: lifetimes,
inputs: inputs,
output: match output {
Some(ty) => FunctionRetTy::Ty(ty),
None => FunctionRetTy::Default,
},
variadic: variadic.is_some(),
})))
));
named!(ty_never -> Ty, map!(punct!("!"), |_| Ty::Never));
named!(ty_tup -> Ty, do_parse!(
punct!("(") >>
elems: terminated_list!(punct!(","), ty) >>
punct!(")") >>
(Ty::Tup(elems))
));
named!(ty_path -> Ty, do_parse!(
qpath: qpath >>
parenthesized: cond!(
qpath.1.segments.last().unwrap().parameters == PathParameters::none(),
option!(parenthesized_parameter_data)
) >>
bounds: many0!(preceded!(punct!("+"), ty_param_bound)) >>
({
let (qself, mut path) = qpath;
if let Some(Some(parenthesized)) = parenthesized {
path.segments.last_mut().unwrap().parameters = parenthesized;
}
if bounds.is_empty() {
Ty::Path(qself, path)
} else {
let path = TyParamBound::Trait(
PolyTraitRef {
bound_lifetimes: Vec::new(),
trait_ref: path,
},
TraitBoundModifier::None,
);
let bounds = Some(path).into_iter().chain(bounds).collect();
Ty::TraitObject(bounds)
}
})
));
named!(parenthesized_parameter_data -> PathParameters, do_parse!(
punct!("(") >>
inputs: terminated_list!(punct!(","), ty) >>
punct!(")") >>
output: option!(preceded!(
punct!("->"),
ty
)) >>
(PathParameters::Parenthesized(
ParenthesizedParameterData {
inputs: inputs,
output: output,
},
))
));
named!(pub qpath -> (Option<QSelf>, Path), alt!(
map!(path, |p| (None, p))
|
do_parse!(
punct!("<") >>
this: map!(ty, Box::new) >>
path: option!(preceded!(
keyword!("as"),
path
)) >>
punct!(">") >>
punct!("::") >>
rest: separated_nonempty_list!(punct!("::"), path_segment) >>
({
match path {
Some(mut path) => {
let pos = path.segments.len();
path.segments.extend(rest);
(Some(QSelf { ty: this, position: pos }), path)
}
None => {
(Some(QSelf { ty: this, position: 0 }), Path {
global: false,
segments: rest,
})
}
}
})
)
|
map!(keyword!("self"), |_| (None, "self".into()))
));
named!(ty_poly_trait_ref -> Ty, map!(
separated_nonempty_list!(punct!("+"), ty_param_bound),
Ty::TraitObject
));
named!(ty_impl_trait -> Ty, do_parse!(
keyword!("impl") >>
elem: separated_nonempty_list!(punct!("+"), ty_param_bound) >>
(Ty::ImplTrait(elem))
));
named!(ty_paren -> Ty, do_parse!(
punct!("(") >>
elem: ty >>
punct!(")") >>
(Ty::Paren(Box::new(elem)))
));
named!(pub mutability -> Mutability, alt!(
keyword!("mut") => { |_| Mutability::Mutable }
|
epsilon!() => { |_| Mutability::Immutable }
));
named!(pub path -> Path, do_parse!(
global: option!(punct!("::")) >>
segments: separated_nonempty_list!(punct!("::"), path_segment) >>
(Path {
global: global.is_some(),
segments: segments,
})
));
named!(path_segment -> PathSegment, alt!(
do_parse!(
id: option!(ident) >>
punct!("<") >>
lifetimes: separated_list!(punct!(","), lifetime) >>
types: opt_vec!(preceded!(
cond!(!lifetimes.is_empty(), punct!(",")),
separated_nonempty_list!(
punct!(","),
terminated!(ty, not!(punct!("=")))
)
)) >>
bindings: opt_vec!(preceded!(
cond!(!lifetimes.is_empty() || !types.is_empty(), punct!(",")),
separated_nonempty_list!(punct!(","), type_binding)
)) >>
cond!(!lifetimes.is_empty() || !types.is_empty() || !bindings.is_empty(), option!(punct!(","))) >>
punct!(">") >>
(PathSegment {
ident: id.unwrap_or_else(|| "".into()),
parameters: PathParameters::AngleBracketed(
AngleBracketedParameterData {
lifetimes: lifetimes,
types: types,
bindings: bindings,
}
),
})
)
|
map!(ident, Into::into)
|
map!(alt!(
keyword!("super")
|
keyword!("self")
|
keyword!("Self")
), Into::into)
));
named!(type_binding -> TypeBinding, do_parse!(
id: ident >>
punct!("=") >>
ty: ty >>
(TypeBinding {
ident: id,
ty: ty,
})
));
named!(pub poly_trait_ref -> PolyTraitRef, do_parse!(
bound_lifetimes: bound_lifetimes >>
trait_ref: path >>
parenthesized: option!(cond_reduce!(
trait_ref.segments.last().unwrap().parameters == PathParameters::none(),
parenthesized_parameter_data
)) >>
({
let mut trait_ref = trait_ref;
if let Some(parenthesized) = parenthesized {
trait_ref.segments.last_mut().unwrap().parameters = parenthesized;
}
PolyTraitRef {
bound_lifetimes: bound_lifetimes,
trait_ref: trait_ref,
}
})
));
named!(pub fn_arg -> BareFnArg, do_parse!(
name: option!(do_parse!(
name: ident >>
punct!(":") >>
not!(tag!(":")) >> // not ::
(name)
)) >>
ty: ty >>
(BareFnArg {
name: name,
ty: ty,
})
));
named!(pub unsafety -> Unsafety, alt!(
keyword!("unsafe") => { |_| Unsafety::Unsafe }
|
epsilon!() => { |_| Unsafety::Normal }
));
named!(pub abi -> Abi, do_parse!(
keyword!("extern") >>
name: option!(quoted_string) >>
(match name {
Some(name) => Abi::Named(name),
None => Abi::Rust,
})
));
}
#[cfg(feature = "printing")]
mod printing {
use super::*;
use quote::{Tokens, ToTokens};
impl ToTokens for Ty {
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
Ty::Slice(ref inner) => {
tokens.append("[");
inner.to_tokens(tokens);
tokens.append("]");
}
Ty::Array(ref inner, ref len) => {
tokens.append("[");
inner.to_tokens(tokens);
tokens.append(";");
len.to_tokens(tokens);
tokens.append("]");
}
Ty::Ptr(ref target) => {
tokens.append("*");
match target.mutability {
Mutability::Mutable => tokens.append("mut"),
Mutability::Immutable => tokens.append("const"),
}
target.ty.to_tokens(tokens);
}
Ty::Rptr(ref lifetime, ref target) => {
tokens.append("&");
lifetime.to_tokens(tokens);
target.mutability.to_tokens(tokens);
target.ty.to_tokens(tokens);
}
Ty::BareFn(ref func) => {
func.to_tokens(tokens);
}
Ty::Never => {
tokens.append("!");
}
Ty::Tup(ref elems) => {
tokens.append("(");
tokens.append_separated(elems, ",");
if elems.len() == 1 {
tokens.append(",");
}
tokens.append(")");
}
Ty::Path(None, ref path) => {
path.to_tokens(tokens);
}
Ty::Path(Some(ref qself), ref path) => {
tokens.append("<");
qself.ty.to_tokens(tokens);
if qself.position > 0 {
tokens.append("as");
for (i, segment) in path.segments
.iter()
.take(qself.position)
.enumerate() {
if i > 0 || path.global {
tokens.append("::");
}
segment.to_tokens(tokens);
}
}
tokens.append(">");
for segment in path.segments.iter().skip(qself.position) {
tokens.append("::");
segment.to_tokens(tokens);
}
}
Ty::TraitObject(ref bounds) => {
tokens.append_separated(bounds, "+");
}
Ty::ImplTrait(ref bounds) => {
tokens.append("impl");
tokens.append_separated(bounds, "+");
}
Ty::Paren(ref inner) => {
tokens.append("(");
inner.to_tokens(tokens);
tokens.append(")");
}
Ty::Infer => {
tokens.append("_");
}
Ty::Mac(ref mac) => mac.to_tokens(tokens),
}
}
}
impl ToTokens for Mutability {
fn to_tokens(&self, tokens: &mut Tokens) {
if let Mutability::Mutable = *self {
tokens.append("mut");
}
}
}
impl ToTokens for Path {
fn to_tokens(&self, tokens: &mut Tokens) {
for (i, segment) in self.segments.iter().enumerate() {
if i > 0 || self.global {
tokens.append("::");
}
segment.to_tokens(tokens);
}
}
}
impl ToTokens for PathSegment {
fn to_tokens(&self, tokens: &mut Tokens) {
self.ident.to_tokens(tokens);
if self.ident.as_ref().is_empty() && self.parameters.is_empty() {
tokens.append("<");
tokens.append(">");
} else {
self.parameters.to_tokens(tokens);
}
}
}
impl ToTokens for PathParameters {
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
PathParameters::AngleBracketed(ref parameters) => {
parameters.to_tokens(tokens);
}
PathParameters::Parenthesized(ref parameters) => {
parameters.to_tokens(tokens);
}
}
}
}
impl ToTokens for AngleBracketedParameterData {
fn to_tokens(&self, tokens: &mut Tokens) {
let has_lifetimes = !self.lifetimes.is_empty();
let has_types = !self.types.is_empty();
let has_bindings = !self.bindings.is_empty();
if !has_lifetimes && !has_types && !has_bindings {
return;
}
tokens.append("<");
let mut first = true;
for lifetime in &self.lifetimes {
if !first {
tokens.append(",");
}
lifetime.to_tokens(tokens);
first = false;
}
for ty in &self.types {
if !first {
tokens.append(",");
}
ty.to_tokens(tokens);
first = false;
}
for binding in &self.bindings {
if !first {
tokens.append(",");
}
binding.to_tokens(tokens);
first = false;
}
tokens.append(">");
}
}
impl ToTokens for TypeBinding {
fn to_tokens(&self, tokens: &mut Tokens) {
self.ident.to_tokens(tokens);
tokens.append("=");
self.ty.to_tokens(tokens);
}
}
impl ToTokens for ParenthesizedParameterData {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append("(");
tokens.append_separated(&self.inputs, ",");
tokens.append(")");
if let Some(ref output) = self.output {
tokens.append("->");
output.to_tokens(tokens);
}
}
}
impl ToTokens for PolyTraitRef {
fn to_tokens(&self, tokens: &mut Tokens) {
if !self.bound_lifetimes.is_empty() {
tokens.append("for");
tokens.append("<");
tokens.append_separated(&self.bound_lifetimes, ",");
tokens.append(">");
}
self.trait_ref.to_tokens(tokens);
}
}
impl ToTokens for BareFnTy {
fn to_tokens(&self, tokens: &mut Tokens) {
if !self.lifetimes.is_empty() {
tokens.append("for");
tokens.append("<");
tokens.append_separated(&self.lifetimes, ",");
tokens.append(">");
}
self.unsafety.to_tokens(tokens);
self.abi.to_tokens(tokens);
tokens.append("fn");
tokens.append("(");
tokens.append_separated(&self.inputs, ",");
if self.variadic {
if !self.inputs.is_empty() {
tokens.append(",");
}
tokens.append("...");
}
tokens.append(")");
if let FunctionRetTy::Ty(ref ty) = self.output {
tokens.append("->");
ty.to_tokens(tokens);
}
}
}
impl ToTokens for BareFnArg {
fn to_tokens(&self, tokens: &mut Tokens) {
if let Some(ref name) = self.name {
name.to_tokens(tokens);
tokens.append(":");
}
self.ty.to_tokens(tokens);
}
}
impl ToTokens for Unsafety {
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
Unsafety::Unsafe => tokens.append("unsafe"),
Unsafety::Normal => {
// nothing
}
}
}
}
impl ToTokens for Abi {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append("extern");
match *self {
Abi::Named(ref named) => named.to_tokens(tokens),
Abi::Rust => {}
}
}
}
}