Enum cpp_demangle::ast::Type

pub enum Type {
    Function(FunctionType),
    ClassEnum(ClassEnumType),
    Array(ArrayType),
    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>
       ::= <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.

PointerToMember(PointerToMemberType)

A pointer-to-member type.

TemplateParam(TemplateParam)

A named template parameter type.

TemplateTemplate(TemplateTemplateParamHandle, TemplateArgs)

A template template type.

Decltype(Decltype)

A decltype.

Qualified(CvQualifiers, TypeHandle)

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.

VendorExtension(SourceName, Option<TemplateArgs>, TypeHandle)

A vendor extended type qualifier.

PackExpansion(TypeHandle)

A pack expansion.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Type

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl PartialEq for Type

fn eq(&self, __arg_0: &Type) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Type) -> bool

This method tests for !=.

impl Eq for Type