Enum full_moon::ast::types::TypeInfo

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

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

The braces ({}) containing the type info.

type_info: Box<TypeInfo>

The type info for the values in the Array

Basic

A standalone type, such as string or Foo.

Tuple Fields of Basic

0: TokenReference

Callback

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

Fields of Callback

parentheses: ContainedSpan

The parentheses for the arguments.

arguments: Punctuated<TypeArgument>

The argument types: (string, number).

arrow: TokenReference

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

return_type: Box<TypeInfo>

The return type: boolean.

Generic

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

Fields of Generic

base: TokenReference

The type that has generics: map.

arrows: ContainedSpan

The arrows (<>) containing the type parameters.

generics: Punctuated<TypeInfo>

The type parameters: number, string.

Intersection

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

Fields of Intersection

left: Box<TypeInfo>

The left hand side: string.

ampersand: TokenReference

The ampersand (&) to separate the types.

right: Box<TypeInfo>

The right hand side: number.

Module

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

Fields of Module

module: TokenReference

The module the type is coming from: module.

punctuation: TokenReference

The punctuation (.) to index the module.

type_info: Box<IndexedTypeInfo>

The indexed type info: Foo.

Optional

An optional type, such as string?.

Fields of Optional

base: Box<TypeInfo>

The type that is optional: string.

question_mark: TokenReference

The question mark: ?.

Table

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

Fields of Table

braces: ContainedSpan

The braces ({}) containing the fields.

fields: Punctuated<TypeField>

The fields: foo: number, bar: string.

Typeof

A type in the form of typeof(foo).

Fields of Typeof

typeof_token: TokenReference

The token typeof.

parentheses: ContainedSpan

The parentheses used to contain the expression.

inner: Box<Expression>

The inner expression: foo.

Tuple

A tuple expression: (string, number).

Fields of Tuple

parentheses: ContainedSpan

The parentheses used to contain the types

types: Punctuated<TypeInfo>

The types: (string, number).

Union

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

Fields of Union

left: Box<TypeInfo>

The left hand side: string.

pipe: TokenReference

The pipe (|) to separate the types.

right: Box<TypeInfo>

The right hand side: number.

Variadic

A variadic type: ...number.

Fields of Variadic

ellipse: TokenReference

The ellipse: ....

type_info: Box<TypeInfo>

The type that is variadic: number.

Trait Implementations

impl Clone for TypeInfo

fn clone(&self) -> TypeInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeInfo

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

Deserialize this value from the given Serde deserializer.

impl Display for TypeInfo

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

Formats the value using the given formatter.

impl Node for TypeInfo

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<'a>(&'a self) -> Tokens<'a>

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(&self) -> (Vec<&Token>, Vec<&Token>)

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 PartialEq<TypeInfo> for TypeInfo

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

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

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

This method tests for !=.

impl Serialize for TypeInfo

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TypeInfo