[−][src]Enum loa::syntax::NodeKind

pub enum NodeKind {
    Module {
        namespace_directive: Id,
        import_directives: Vec<Id>,
        module_declarations: Vec<Id>,
    },
    REPLLine {
        statements: Vec<Id>,
    },
    REPLDirective {
        colon: Token,
        symbol: Id,
        expression: Id,
        period: Option<Token>,
    },
    REPLExpression {
        expression: Id,
        period: Option<Token>,
    },
    Exported(Id, Token, Id),
    NamespaceDirective {
        namespace_keyword: Option<Token>,
        qualified_symbol: Id,
        period: Option<Token>,
    },
    ImportDirective {
        import_keyword: Option<Token>,
        qualified_symbol: Id,
        as_keyword: Option<Token>,
        symbol: Id,
        period: Option<Token>,
    },
    QualifiedSymbol {
        symbols: Vec<Id>,
    },
    Symbol(Token),
    Class {
        doc: Id,
        partial_keyword: Option<Token>,
        class_keyword: Option<Token>,
        symbol: Id,
        type_parameter_list: Id,
        class_body: Id,
        period: Option<Token>,
    },
    TypeParameterList {
        open_angle: Option<Token>,
        type_parameters: Vec<Id>,
        close_angle: Option<Token>,
    },
    TypeParameter {
        symbol: Id,
        variance_keyword: Option<Token>,
    },
    ClassBody {
        open_curly: Option<Token>,
        class_members: Vec<Id>,
        close_curly: Option<Token>,
    },
    Method {
        doc: Id,
        visibility: Option<Token>,
        native_keyword: Option<Token>,
        signature: Id,
        method_body: Id,
        period: Option<Token>,
    },
    IsDirective {
        is_keyword: Token,
        type_expression: Id,
        period: Option<Token>,
    },
    Variable {
        doc: Id,
        visibility: Option<Token>,
        var_keyword: Option<Token>,
        type_expression: Id,
        symbol: Id,
        equal_sign: Option<Token>,
        expression: Id,
        period: Option<Token>,
    },
    Initializer {
        doc: Id,
        visibility: Option<Token>,
        init_keyword: Option<Token>,
        message_pattern: Id,
        fat_arrow: Option<Token>,
        keyword_pairs: Vec<Id>,
        period: Option<Token>,
    },
    Signature {
        type_parameter_list: Id,
        message_pattern: Id,
        return_type: Id,
    },
    UnaryMessagePattern {
        symbol: Id,
    },
    BinaryMessagePattern {
        operator: Id,
        parameter_pattern: Id,
    },
    Operator(Vec<Token>),
    KeywordMessagePattern {
        keyword_pairs: Vec<Id>,
    },
    KeywordPair {
        keyword: Id,
        colon: Option<Token>,
        value: Id,
    },
    ReturnType {
        arrow: Option<Token>,
        type_expression: Id,
    },
    ParameterPattern {
        type_expression: Id,
        symbol: Id,
    },
    ReferenceTypeExpression {
        symbol: Id,
        type_argument_list: Id,
    },
    SelfTypeExpression(Token),
    SymbolTypeExpression(Token, String),
    Nothing(Token),
    TypeArgumentList {
        open_angle: Option<Token>,
        type_expressions: Vec<Id>,
        close_angle: Option<Token>,
    },
    MethodBody {
        fat_arrow: Option<Token>,
        expression: Id,
    },
    ReferenceExpression {
        symbol: Id,
    },
    CascadeExpression {
        expression: Id,
        semi_colon: Option<Token>,
    },
    TupleExpression {
        open_paren: Option<Token>,
        expression: Id,
        close_paren: Option<Token>,
    },
    SelfExpression(Token),
    StringExpression(Token, String),
    CharacterExpression(Token, Option<u16>),
    IntegerExpression(Token, BigInt),
    FloatExpression(Token, BigFraction),
    SymbolExpression(Token, String),
    MessageSendExpression {
        expression: Id,
        message: Id,
    },
    PanicExpression {
        panic_keyword: Token,
        expression: Id,
    },
    UnaryMessage {
        symbol: Id,
    },
    BinaryMessage {
        operator: Id,
        expression: Id,
    },
    KeywordMessage {
        keyword_pairs: Vec<Id>,
    },
    LetExpression {
        let_binding: Id,
        expression: Id,
    },
    LetBinding {
        let_keyword: Option<Token>,
        type_expression: Id,
        symbol: Id,
        equal_sign: Option<Token>,
        expression: Id,
        period: Option<Token>,
    },
    Doc {
        doc_line_marker: Token,
        blocks: Vec<Id>,
    },
    DocParagraphBlock {
        elements: Vec<Id>,
    },
    DocTextElement(Vec<Token>),
    DocItalicElement(Token, Vec<Token>, Token),
    DocBoldElement(Token, Vec<Token>, Token),
    DocLinkElement(Id, Id),
    DocLinkText(Token, Vec<Token>, Token),
    DocLinkRef(Token, Vec<Token>, Token),
}

Variants

Module
Module ::=
  NamespaceDirective
  ImportDirective*
  ModuleDeclaration*

Fields of Module

namespace_directive: Idimport_directives: Vec<Id>module_declarations: Vec<Id>
REPLLine
REPLLine ::=
  REPLStatement+

Fields of REPLLine

statements: Vec<Id>
REPLDirective
REPLStatement ::=
  REPLDirective |
  LetBinding |
  REPLExpression |
  ImportDirective |
  Declaration

REPLDirective ::=
  COLON
  Symbol
  Expression
  PERIOD?

Fields of REPLDirective

colon: Tokensymbol: Idexpression: Idperiod: Option<Token>
REPLExpression
REPLExpression ::=
  Expression
  PERIOD?

Fields of REPLExpression

expression: Idperiod: Option<Token>
Exported(Id, Token, Id)
ModuleDeclaration ::=
  Doc?
  (Declaration | EXPORT_KEYWORD Declaration)
NamespaceDirective
NamespaceDirective ::=
  NAMESPACE_KEYWORD
  QualifiedSymbol
  PERIOD

Fields of NamespaceDirective

namespace_keyword: Option<Token>qualified_symbol: Idperiod: Option<Token>
ImportDirective
ImportDirective ::=
  IMPORT_KEYWORD
  QualifiedSymbol
  (
    AS_KEYWORD
    Symbol
  )?
  PERIOD

Fields of ImportDirective

import_keyword: Option<Token>qualified_symbol: Idas_keyword: Option<Token>symbol: Idperiod: Option<Token>
QualifiedSymbol
QualifiedSymbol ::=
  Symbol
  (
    SLASH
    Symbol
  )*

Fields of QualifiedSymbol

symbols: Vec<Id>
Symbol(Token)
Symbol ::=
  SIMPLE_SYMBOL
Class
Declaration ::=
  Class

Class ::=
  PARTIAL_KEYWORD?
  CLASS_KEYWORD
  Symbol
  TypeParameterList?
  (ClassBody | PERIOD)

Fields of Class

doc: Idpartial_keyword: Option<Token>class_keyword: Option<Token>symbol: Idtype_parameter_list: Idclass_body: Idperiod: Option<Token>
TypeParameterList
TypeParameterList ::=
  OPEN_ANGLE
  TypeParameter
  (COMMA TypeParameter)*
  CLOSE_ANGLE

Fields of TypeParameterList

open_angle: Option<Token>type_parameters: Vec<Id>close_angle: Option<Token>
TypeParameter
TypeParameter ::=
  Symbol
  (IN_KEYWORD | OUT_KEYWORD | INOUT_KEYWORD)?

Fields of TypeParameter

symbol: Idvariance_keyword: Option<Token>
ClassBody
ClassBody ::=
  OPEN_CURLY
  ClassMember*
  CLOSE_CURLY

Fields of ClassBody

open_curly: Option<Token>class_members: Vec<Id>close_curly: Option<Token>
Method
ClassMember ::=
  Method |
  Initializer |
  Variable |
  IsDirective

Method ::=
  (PUBLIC_KEYWORD | PRIVATE_KEYWORD)?
  NATIVE_KEYWORD?
  Signature
  MethodBody?
  PERIOD

Fields of Method

doc: Idvisibility: Option<Token>native_keyword: Option<Token>signature: Idmethod_body: Idperiod: Option<Token>
IsDirective
IsDirective ::=
  IS_KEYWORD
  TypeExpression
  PERIOD

Fields of IsDirective

is_keyword: Tokentype_expression: Idperiod: Option<Token>
Variable
Variable ::=
  (PUBLIC_KEYWORD | PRIVATE_KEYWORD)?
  VAR_KEYWORD
  TypeExpression?
  Symbol
  (EQUAL_SIGN Expression)?
  PERIOD

Fields of Variable

doc: Idvisibility: Option<Token>var_keyword: Option<Token>type_expression: Idsymbol: Idequal_sign: Option<Token>expression: Idperiod: Option<Token>
Initializer
Initializer ::=
  (PUBLIC_KEYWORD | PRIVATE_KEYWORD)?
  INIT_KEYWORD
  MessagePattern
  (FAT_ARROW KeywordPair<Expression>*)
  PERIOD

Fields of Initializer

doc: Idvisibility: Option<Token>init_keyword: Option<Token>message_pattern: Idfat_arrow: Option<Token>keyword_pairs: Vec<Id>period: Option<Token>
Signature
Signature ::=
  TypeParameterList?
  MessagePattern
  ReturnType?

Fields of Signature

type_parameter_list: Idmessage_pattern: Idreturn_type: Id
UnaryMessagePattern
MessagePattern ::=
  UnaryMessagePattern |
  BinaryMessagePattern |
  KeywordMessagePattern

UnaryMessagePattern ::=
  Symbol

Fields of UnaryMessagePattern

symbol: Id
BinaryMessagePattern
BinaryMessagePattern ::=
  Operator
  ParameterPattern

Fields of BinaryMessagePattern

operator: Idparameter_pattern: Id
Operator(Vec<Token>)
Operator ::=
  (ASTERISK | PLUS | SLASH | EQUAL_SIGN | OPEN_ANGLE | CLOSE_ANGLE)+
KeywordMessagePattern
KeywordMessagePattern ::=
  KeywordPair<ParameterPattern>+

Fields of KeywordMessagePattern

keyword_pairs: Vec<Id>
KeywordPair
KeywordPair<N> ::=
  Symbol
  COLON
  N

Fields of KeywordPair

keyword: Idcolon: Option<Token>value: Id
ReturnType
ReturnType ::=
  ARROW
  TypeExpression

Fields of ReturnType

arrow: Option<Token>type_expression: Id
ParameterPattern
ParameterPattern ::=
  TypeExpression |
  Symbol |
  (
    TypeExpression
    Symbol
  )

Fields of ParameterPattern

type_expression: Idsymbol: Id
ReferenceTypeExpression
TypeExpression ::=
  ReferenceTypeExpression |
  SelfTypeExpression |
  Nothing |
  SymbolTypeExpression

ReferenceTypeExpression ::=
  Symbol
  TypeArgumentList?

Fields of ReferenceTypeExpression

symbol: Idtype_argument_list: Id
SelfTypeExpression(Token)
SelfTypeExpression ::=
  SELF_KEYWORD
SymbolTypeExpression(Token, String)
SymbolTypeExpression ::=
  SYMBOL_LITERAL
Nothing(Token)
Nothing ::=
  UNDERSCORE
TypeArgumentList
TypeArgumentList ::=
  OPEN_ANGLE
  TypeExpression
  (COMMA TypeExpression)*
  CLOSE_ANGLE

Fields of TypeArgumentList

open_angle: Option<Token>type_expressions: Vec<Id>close_angle: Option<Token>
MethodBody
MethodBody ::=
  FAT_ARROW
  Expression

Fields of MethodBody

fat_arrow: Option<Token>expression: Id
ReferenceExpression
Expression ::=
  ReferenceExpression |
  MessageSendExpression |
  SelfExpression |
  StringExpression |
  CharacterExpression |
  IntegerExpression |
  FloatExpression |
  SymbolExpression |
  CascadeExpression |
  TupleExpression |
  PanicExpression

ReferenceExpression ::=
  Symbol

Fields of ReferenceExpression

symbol: Id
CascadeExpression
CascadeExpression ::=
  Expression
  SEMI_COLON

Fields of CascadeExpression

expression: Idsemi_colon: Option<Token>
TupleExpression
TupleExpression ::=
  OPEN_PAREN
  Expression
  CLOSE_PAREN

Fields of TupleExpression

open_paren: Option<Token>expression: Idclose_paren: Option<Token>
SelfExpression(Token)
SelfExpression ::=
  SELF_KEYWORD
StringExpression(Token, String)
StringExpression ::=
  SIMPLE_STRING
CharacterExpression(Token, Option<u16>)
CharacterExpression ::=
  SIMPLE_CHARACTER
IntegerExpression(Token, BigInt)
IntegerExpression ::=
  SIMPLE_INTEGER
FloatExpression(Token, BigFraction)
FloatExpression ::=
  SIMPLE_FLOAT
SymbolExpression(Token, String)
SymbolExpression ::=
  SYMBOL_LITERAL
MessageSendExpression
MessageSendExpression ::=
  Expression
  Message

Fields of MessageSendExpression

expression: Idmessage: Id
PanicExpression
PanicExpression ::=
  PANIC_KEYWORD
  Expression

Fields of PanicExpression

panic_keyword: Tokenexpression: Id
UnaryMessage
Message ::=
  UnaryMessage |
  BinaryMessage |
  KeywordMessage

UnaryMessage ::=
  Symbol

Fields of UnaryMessage

symbol: Id
BinaryMessage
BinaryMessage ::=
  Operator
  Expression

Fields of BinaryMessage

operator: Idexpression: Id
KeywordMessage
KeywordMessage ::=
  KeywordPair<Expression>+

Fields of KeywordMessage

keyword_pairs: Vec<Id>
LetExpression
LetExpression ::=
  LetBinding
  Expression

Fields of LetExpression

let_binding: Idexpression: Id
LetBinding
LetBinding ::=
  LET_KEYWORD
  TypeExpression?
  Symbol
  EQUAL_SIGN
  Expression
  Period

Fields of LetBinding

let_keyword: Option<Token>type_expression: Idsymbol: Idequal_sign: Option<Token>expression: Idperiod: Option<Token>
Doc
Doc ::=
  DOC_LINE_MARKER
  DocBlock*

Fields of Doc

doc_line_marker: Tokenblocks: Vec<Id>
DocParagraphBlock
DocBlock ::=
  DocParagraphBlock

DocParagraphBlock ::=
  DocElement+

Fields of DocParagraphBlock

elements: Vec<Id>
DocTextElement(Vec<Token>)
DocElement ::=
  DocTextElement |
  DocItalicElement |
  DocBoldElement |
  DocLinkElement

DocTextElement ::=
  DOC_TEXT+
DocItalicElement(Token, Vec<Token>, Token)
DocItalicElement ::=
  UNDERSCORE
  DOC_TEXT+
  UNDERSCORE
DocBoldElement(Token, Vec<Token>, Token)
DocBoldElement ::=
  ASTERISK
  DOC_TEXT+
  ASTERISK
DocLinkElement(Id, Id)
DocLinkElement ::=
  DocLinkText
  DocLinkRef?
DocLinkText(Token, Vec<Token>, Token)
DocLinkText ::=
  OPEN_BRACKET
  DOC_TEXT+
  CLOSE_BRACKET
DocLinkRef(Token, Vec<Token>, Token)
DocLinkRef ::=
  OPEN_PAREN
  DOC_TEXT+
  CLOSE_PAREN

Methods

impl NodeKind[src]

pub fn leaves(&self) -> Vec<&Token>[src]

pub fn children(&self) -> Vec<Id>[src]

Trait Implementations

impl Clone for NodeKind[src]

impl Debug for NodeKind[src]

Auto Trait Implementations

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.