[−][src]Enum cpp_demangle::ast::Type

pub enum Type {
    Function(FunctionType),
    ClassEnum(ClassEnumType),
    Array(ArrayType),
    Vector(VectorType),
    PointerToMember(PointerToMemberType),
    TemplateParam(TemplateParam),
    TemplateTemplate(TemplateTemplateParamHandle, TemplateArgs),
    Decltype(Decltype),
    Qualified(CvQualifiers, TypeHandle),
    PointerTo(TypeHandle),
    LvalueRef(TypeHandle),
    RvalueRef(TypeHandle),
    Complex(TypeHandle),
    Imaginary(TypeHandle),
    VendorExtension(SourceName, Option<TemplateArgs>, TypeHandle),
    PackExpansion(TypeHandle),
}

The <type> production.

<type> ::= <builtin-type>
       ::= <function-type>
       ::= <class-enum-type>
       ::= <array-type>
       ::= <vector-type>
       ::= <pointer-to-member-type>
       ::= <template-param>
       ::= <template-template-param> <template-args>
       ::= <decltype>
       ::= <CV-qualifiers> <type>
       ::= P <type>                                 # pointer-to
       ::= R <type>                                 # reference-to
       ::= O <type>                                 # rvalue reference-to (C++0x)
       ::= C <type>                                 # complex pair (C 2000)
       ::= G <type>                                 # imaginary (C 2000)
       ::= U <source-name> [<template-args>] <type> # vendor extended type qualifier
       ::= Dp <type>                                # pack expansion (C++0x)
       ::= <substitution>

Variants

Function(FunctionType)

A function type.

ClassEnum(ClassEnumType)

A class, union, or enum type.

Array(ArrayType)

An array type.

Vector(VectorType)

A vector type.

PointerToMember(PointerToMemberType)

A pointer-to-member type.

TemplateParam(TemplateParam)

A named template parameter type.

A template template type.

Decltype(Decltype)

A decltype.

A const-, restrict-, and/or volatile-qualified type.

PointerTo(TypeHandle)

A pointer to a type.

LvalueRef(TypeHandle)

An lvalue reference to a type.

RvalueRef(TypeHandle)

An rvalue reference to a type.

Complex(TypeHandle)

A complex pair of the given type.

Imaginary(TypeHandle)

An imaginary of the given type.

A vendor extended type qualifier.

PackExpansion(TypeHandle)

A pack expansion.

Trait Implementations

impl Clone for Type[src]

impl Debug for Type[src]

impl Eq for Type[src]

impl PartialEq<Type> for Type[src]

impl StructuralEq for Type[src]

impl StructuralPartialEq for Type[src]

Auto Trait Implementations

impl RefUnwindSafe for Type

impl Send for Type

impl Sync for Type

impl Unpin for Type

impl UnwindSafe for Type

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.