Enum full_moon::ast::types::TypeInfo

#[non_exhaustive]pub enum TypeInfo<'a> {
    Array {
        braces: ContainedSpan<'a>,
        type_info: Box<TypeInfo<'a>>,
    },
    Basic(TokenReference<'a>),
    Callback {
        parentheses: ContainedSpan<'a>,
        arguments: Punctuated<'a, TypeInfo<'a>>,
        arrow: TokenReference<'a>,
        return_type: Box<TypeInfo<'a>>,
    },
    Generic {
        base: TokenReference<'a>,
        arrows: ContainedSpan<'a>,
        generics: Punctuated<'a, TypeInfo<'a>>,
    },
    Intersection {
        left: Box<TypeInfo<'a>>,
        ampersand: TokenReference<'a>,
        right: Box<TypeInfo<'a>>,
    },
    Module {
        module: TokenReference<'a>,
        punctuation: TokenReference<'a>,
        type_info: Box<IndexedTypeInfo<'a>>,
    },
    Optional {
        base: Box<TypeInfo<'a>>,
        question_mark: TokenReference<'a>,
    },
    Table {
        braces: ContainedSpan<'a>,
        fields: Punctuated<'a, TypeField<'a>>,
    },
    Typeof {
        typeof_token: TokenReference<'a>,
        parentheses: ContainedSpan<'a>,
        inner: Box<Expression<'a>>,
    },
    Tuple {
        parentheses: ContainedSpan<'a>,
        types: Punctuated<'a, TypeInfo<'a>>,
    },
    Union {
        left: Box<TypeInfo<'a>>,
        pipe: TokenReference<'a>,
        right: Box<TypeInfo<'a>>,
    },
}

Any type, such as string, boolean?, number | boolean, etc.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Array

A shorthand type annotating the structure of an array: { number }

Fields of Array

braces: ContainedSpan<'a>

The braces ({}) containing the type info.

type_info: Box<TypeInfo<'a>>

The type info for the values in the Array

Basic(TokenReference<'a>)

A standalone type, such as string or Foo.

Callback

A callback type, such as (string, number) => boolean.

Fields of Callback

parentheses: ContainedSpan<'a>

The parentheses for the arguments.

arguments: Punctuated<'a, TypeInfo<'a>>

The argument types: (string, number).

arrow: TokenReference<'a>

The “thin arrow” (->) in between the arguments and the return type.

return_type: Box<TypeInfo<'a>>

The return type: boolean.

Generic

A type using generics, such as map<number, string>.

Fields of Generic

base: TokenReference<'a>

The type that has generics: map.

arrows: ContainedSpan<'a>

The arrows (<>) containing the type parameters.

generics: Punctuated<'a, TypeInfo<'a>>

The type parameters: number, string.

Intersection

An intersection type: string & number, denoting both types.

Fields of Intersection

left: Box<TypeInfo<'a>>

The left hand side: string.

ampersand: TokenReference<'a>

The ampersand (&) to separate the types.

right: Box<TypeInfo<'a>>

The right hand side: number.

Module

A type coming from a module, such as module.Foo

Fields of Module

module: TokenReference<'a>

The module the type is coming from: module.

punctuation: TokenReference<'a>

The punctuation (.) to index the module.

type_info: Box<IndexedTypeInfo<'a>>

The indexed type info: Foo.

Optional

An optional type, such as string?.

Fields of Optional

base: Box<TypeInfo<'a>>

The type that is optional: string.

question_mark: TokenReference<'a>

The question mark: ?.

Table

A type annotating the structure of a table: { foo: number, bar: string }

Fields of Table

braces: ContainedSpan<'a>

The braces ({}) containing the fields.

fields: Punctuated<'a, TypeField<'a>>

The fields: foo: number, bar: string.

Typeof

A type in the form of typeof(foo).

Fields of Typeof

typeof_token: TokenReference<'a>

The token typeof.

parentheses: ContainedSpan<'a>

The parentheses used to contain the expression.

inner: Box<Expression<'a>>

The inner expression: foo.

Tuple

A tuple expression: (string, number).

Fields of Tuple

parentheses: ContainedSpan<'a>

The parentheses used to contain the types

types: Punctuated<'a, TypeInfo<'a>>

The types: (string, number).

Union

A union type: string | number, denoting one or the other.

Fields of Union

left: Box<TypeInfo<'a>>

The left hand side: string.

pipe: TokenReference<'a>

The pipe (|) to separate the types.

right: Box<TypeInfo<'a>>

The right hand side: number.

Trait Implementations

impl<'a> Clone for TypeInfo<'a>

fn clone(&self) -> TypeInfo<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TypeInfo<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for TypeInfo<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a> Display for TypeInfo<'a>

fn fmt(&self, _derive_more_display_formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Node<'a> for TypeInfo<'a>

fn start_position(&self) -> Option<Position>

The start position of a node. None if can’t be determined

fn end_position(&self) -> Option<Position>

The end position of a node. None if it can’t be determined

fn similar(&self, other: &Self) -> bool

Whether another node of the same type is the same as this one semantically, ignoring position

fn tokens<'b>(&'b self) -> Tokens<'a, 'b>

The token references that comprise a node

fn range(&self) -> Option<(Position, Position)>

The full range of a node, if it has both start and end positions

fn surrounding_trivia<'b>(
    &'b self
) -> (Vec<&'b Token<'ast>>, Vec<&'b Token<'ast>>)

The tokens surrounding a node that are ignored and not accessible through the node’s own accessors. Use this if you want to get surrounding comments or whitespace. Returns a tuple of the leading and trailing trivia.

impl<'a> Owned for TypeInfo<'a>

type Owned = TypeInfo<'static>

What an owned version of the object looks like. Usually contains a 'static lifetime.

fn owned(&self) -> Self::Owned

Returns an owned version of the object.

impl<'a> PartialEq<TypeInfo<'a>> for TypeInfo<'a>

fn eq(&self, other: &TypeInfo<'a>) -> bool

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

fn ne(&self, other: &TypeInfo<'a>) -> bool

This method tests for !=.

impl<'a> Serialize for TypeInfo<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for TypeInfo<'a>