Vyper.bnf

{
    parserClass="org.vyperlang.plugin.parser.BaseVyperParser"
    extends="com.intellij.extapi.psi.ASTWrapperPsiElement"
    implements="org.vyperlang.plugin.psi.VyperElement"

    psiClassPrefix="Vyper"
    psiImplClassSuffix="Impl"
    psiPackage="org.vyperlang.plugin.psi"
    psiImplPackage="org.vyperlang.plugin.psi.impl"

    elementTypeHolderClass="org.vyperlang.plugin.psi.VyperTypes"
    elementTypeClass="org.vyperlang.plugin.psi.VyperElementType"
    tokenTypeClass="org.vyperlang.plugin.psi.VyperTokenType"

    parserUtilClass = "org.vyperlang.plugin.parser.ParserUtil"

    tokens = [
        DECORATOR = '@'
        comment='regexp:(#.*)'
        SEMICOLON=';'
        COMMA=','
        DOT='.'
        COLON=':'
        LBRACKET='['
        RBRACKET=']'
        LBRACE='{'
        RBRACE='}'
        LPAREN='('
        RPAREN=')'
        ELLIPSIS='...'

        PLUS='+'
        MINUS='-'
        MULT='*'
        DIV='/'
        EXPONENT='**'
        NOT='not'
        ASSIGN='='
        TO='=>'
        EQ='=='
        NEQ='!='
        PLUS_ASSIGN='+='
        MINUS_ASSIGN='-='
        MULT_ASSIGN='*='
        DIV_ASSIGN='/='
        PERCENT_ASSIGN='%='
        LESS='<'
        LESSEQ='<='
        MORE='>'
        MOREEQ='>='
        AND='and'
        OR='or'
        QUESTION='?'
        PERCENT='%'
        TILDE='~'
        LSHIFT='<<'
        RSHIFT='>>'
        AMPERSAND='&'
        PIPE='|'
        CARET='^'

        hexLiteral='regexp:hex"([0-9a-fA-F]+)"'
        stringLiteralDouble='regexp:("([^"\r\n\\]|\\.)*")'
        stringLiteralDoubleB='regexp:(b"([^"\r\n\\]|\\.)*")'
        stringLiteralSingle="regexp:('([^'\r\n\\]|\\.)*')"
        stringLiteralSingleB="regexp:(b'([^'\r\n\\]|\\.)*')"
        MultiLineStringToken = 'regexp:("""([^"]|"[^"]|""[^"])*""")'

        decimalNumber='regexp:([0-9][_0-9]*)'
        fixedNumber='regexp:(([0-9][_0-9]*)+\.[_0-9]*|([0-9][_0-9]*)*\.([0-9][_0-9]*))'
        booleanLiteral='regexp:True|False'
        scientificNumber='regexp:((([0-9][_0-9]*)+|([0-9][_0-9]*)+\.[_0-9]*|([0-9][_0-9]*|[0-9])*\.[_0-9]+)[Ee][+-]?[_0-9]+)'
        hexNumber='regexp:(0[xX][_0-9a-fA-F]+)'

        // keywords
//        def='def'
//        if='if'
//        elif='elif'
//        else='else'
//        for='for'
//        in='in'
//        return='return'
//        raise='raise'
//        pass='pass'
//        assert='assert'
//        log='log'
//        range='range'
//        enum='enum'
//        flag='flag'
//        struct='struct'
//        interface='interface'
//        event='event'
//        implements='implements'
//        external='external'
//        internal='internal'
//        deploy='deploy'
//        pure='pure'
//        view='view'
//        nonpayable='nonpayable'
//        payable='payable'
//        self='self'
//        indexed='indexed'
        BOUND='bound'

        intM = 'regexp:(int[0-9]+)'
        uintM = 'regexp:(uint[0-9]+)'
        bytesM = 'regexp:(bytes[0-9]+)'
        string = 'String'
        bytes = 'Bytes'
        DynArray = 'DynArray'
        HashMap = 'HashMap'

        newline = 'regexp:(\r?\n)'
        BREAK_LINE = 'regexp:(\s*\\\s*\n)'
        Identifier='regexp:([A-Za-z_]\w*)'
    ]
    //to handle left recursion
    extends(".*Expression") = Expression
}

VyperFile ::= ((!<<eof>> MultiLineString? SourceUnit) (&INDEQ SourceUnit)*)?

external INDEQ ::= indEq
external INDLT ::= indLt
external INDGT ::= indGt
external INDNONE ::= indNone

// Order is handled by `VyperDeclarationsOrderAnnotator`
private SourceUnit ::= ( ImportDirective
                        | ConstantDefinitionExpression
                        | ImmutableDefinitionExpression
                        | ImplementsDirective
                        | StructDeclaration
                        | InterfaceDeclaration
                        | EventDeclaration
                        | FlagDeclaration
                        | FunctionDefinition
                        | StateVariableDeclaration)
                        { recoverWhile = recoverIndent }

// constant type and immutable type are the same
private ConstantType ::= (&INDNONE constant &INDNONE '(' TYPE ')') | (public &INDNONE '(' &INDNONE ConstantType &INDNONE ')')
private ImmutableType ::= (&INDNONE immutable &INDNONE '(' TYPE ')') | (public &INDNONE '(' &INDNONE ImmutableType &INDNONE ')')
// constant type requires setting a value (semantic)
ConstantDefinitionExpression ::= Identifier &INDNONE ':' ConstantType &INDNONE '=' &INDNONE Expression  {
    pin=5
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}
// immutable type requires setting a value in constructor
ImmutableDefinitionExpression ::= Identifier &INDNONE ':' ImmutableType {
    pin=5
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

ImportDirective ::= ( import &INDNONE Identifier )
                   | ( import &INDNONE ImportPath &INDNONE as &INDNONE Identifier )
                   | ( from &INDNONE ImportPath &INDNONE import &INDNONE Identifier ) {
    pin(".*")=1
    mixin = "org.vyperlang.plugin.psi.VyperImportImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}
ImportPath ::= Identifier  (&INDNONE '.' &INDNONE Identifier)*

// implements statements
ImplementsDirective ::= implements &INDNONE ':' &INDNONE VarLiteral (&INDNONE ',' &INDNONE VarLiteral)* {
    pin=1
}

// external interfaces ok
InterfaceDeclaration ::= interface &INDNONE Identifier &INDNONE ':'
                        <<indented (InterfaceFunction+) >> {
    pin=1
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

InterfaceFunction ::= ( def &INDNONE Identifier FunctionArgs FunTypeAnnotation? &INDNONE ':' &INDNONE InterfaceFunctionModifier )  {
    pin=1
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

InterfaceFunctionModifier ::= pure | view | nonpayable | payable

// Trailing commas: https://github.com/JetBrains/Grammar-Kit/blob/master/HOWTO.md#41-trailing-commas
FunctionArgs ::= '(' (ParamDef (',' (ParamDef | &')'))*)? ')' {pin(".*")=1}

ParamDef ::= Identifier ':' TYPE ('=' Expression)? {
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

// could be default assignment
StructDeclaration ::= struct &INDNONE Identifier &INDNONE COLON  StructBody {
    pin = 1
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}
private StructBody ::= StructSingleDef | <<indented (StructMultipleDef) >>
private StructSingleDef ::= (&INDNONE StructLocalVariableDefinition)
private StructMultipleDef ::= StructLocalVariableDefinition ( &INDEQ StructLocalVariableDefinition )*
private StructLocalVariableDefinition ::= LocalVariableDefinition | Identifier | StringLiteral {recoverWhile=recoverIndent}
private recoverIndent ::= !(&INDEQ | &INDLT |<<eof>>)

FlagDeclaration ::= (enum|flag) &INDNONE Identifier &INDNONE COLON  (<<indented FlagOptions >>) {
    pin = 1
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}
private FlagOptions ::= FlagOption ( &INDEQ FlagOption )*
FlagOption ::= Identifier {
    recoverWhile=recoverIndent
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

//ok
//Events must all come before global declarations and function definitions
EventDeclaration ::= event &INDNONE Identifier &INDNONE ':' ((&INDGT EventProperty?) | (&INDNONE PassStatement))  {
    pin=5
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

EventProperty ::= Identifier ':' (IndexedData | TYPE) (Identifier ':' (IndexedData |TYPE))*
IndexedData ::= indexed '(' TYPE ')'

// VARIABLES

// state variables  May not assign value whilst defining type
StateVariableType ::= TYPE | public &INDNONE '(' &INDNONE StateVariableType &INDNONE ')'
StateVariableDeclaration ::= Identifier &INDNONE ':' StateVariableType (&INDNONE '=' &INDNONE Expression)?
{
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

// semantic : HashMap may only be state variable
LocalVariableDefinition ::=  Identifier &INDNONE ':' &INDNONE TYPE ((&INDNONE '=') (&INDNONE Expression))?
{
    mixin = "org.vyperlang.plugin.psi.VyperNamedElementImpl"
    implements = "org.vyperlang.plugin.psi.VyperNamedElement"
}

MultiLineString ::= MultiLineStringToken

// FUNCTIONS
private FunDef ::= def (&INDNONE Identifier) FunctionArgs FunTypeAnnotation? (&INDNONE ':')
{
    pin = 1
}

FunctionImplementation ::= (&INDNONE Statement) | <<indented ((MultiLineString)? &INDEQ Statement (&INDEQ Statement)*) >>
FunctionBody ::= (ELLIPSIS|FunctionImplementation)  // ELLIPSIS is used for vyi files
FunTypeAnnotation ::= &INDNONE '->' &INDNONE ( TYPE | '(' TYPE (',' TYPE)* ')' )
FunctionDefinition ::= FunctionModifier (&INDEQ FunctionModifier)* FunDef FunctionBody
{
    pin=1
    implements = "org.vyperlang.plugin.psi.VyperFunctionDefElement"
    mixin = "org.vyperlang.plugin.psi.VyperFunctionDefMixin"
}

private FunctionVisibility ::= external | internal | deploy
private FunctionMutability ::= pure | view | nonpayable | payable
FunctionDecorator ::= FunctionVisibility | FunctionMutability | (nonreentrant ((&INDNONE '(') FunctionEntrancyKey ')')?)
FunctionModifier ::=  (DECORATOR (&INDNONE FunctionDecorator)) { pin = 1 }
FunctionEntrancyKey ::=  stringLiteralSingle | stringLiteralDouble

// statements
Statement ::= PassStatement
              | IfStatement
              | ForStatement
              | Continue
              | Break
              | Return
              | Raise
              | SimpleStatement
              | MultiLineString // docstring
              {recoverWhile = recoverStatement}

private recoverStatement ::= !(&INDEQ|&INDLT)

private CondStmt ::= Expression &INDNONE ':' ((&INDNONE Statement)
                                     | <<indented (Statement (&INDEQ Statement)*)>>)
private ElifStmt ::= elif &INDNONE CondStmt
                     {pin = 1}
private ElseStmt ::= else &INDNONE ':' ((&INDNONE Statement)
                                       | <<indented (Statement (&INDEQ Statement)*)>>)
                     {pin = 1}

IfStatement ::= if &INDNONE CondStmt (&INDEQ ElifStmt)* (&INDEQ ElseStmt)? {pin=1}

private SimpleStatement ::= LocalVariableDefinition | ExpressionStatement
private ExpressionStatement ::= Expression

ForStatement ::= for &INDNONE Identifier (&INDNONE  ':' TYPE)? &INDNONE in &INDNONE Expression &INDNONE ':'
                    (&INDNONE Statement | <<indented (Statement (&INDEQ Statement)*)>>) {
    pin=1
}
private Continue ::= continue
private Break ::= break
private Return ::= return (&INDNONE Expression (',' Expression)*)? {
    pin=1
}
private Raise ::= raise StringLiteral?
private PassStatement ::= pass

Expression ::=
  TernaryExpression
  | AssignmentExpression
  | TupleAssignmentExpression
  | RangeExpression
  | IndexAccessExpression
  | UnaryExpression
  | CallExpression
  | StructExpression
  | AssertExpression
  | EqExpression
  | OrExpression
  | AndExpression
  | CompExpression
  | PlusMinExpression
  | MultDivExpression
  | ExponentExpression
  | BinExpression
  | MemberAccessExpression
  | InlineArrayExpression
  | EventLogExpression
  | ExtCallExpression
  | StaticCallExpression
  | InExpression
  | PrimaryExpression
  | ParenthesizedExpression


EventLogExpression ::= log (&INDNONE Identifier '.')? &INDNONE VarLiteral FunctionCallArguments
InExpression ::= Expression (&INDNONE not)? &INDNONE in &INDNONE Expression
TernaryExpression ::= Expression &INDNONE if &INDNONE Expression &INDNONE else &INDNONE Expression { pin = 1 }
ExtCallExpression ::= extcall Expression
StaticCallExpression ::= staticcall Expression

RangeExpression ::= range &INDNONE '(' Expression (',' Expression)? RangeBound? ')'
RangeBound ::= ',' BOUND '=' (VarLiteral | NumberLiteral)

StructExpressionMember ::= VarLiteral &INDNONE ':' &INDNONE Expression
private StructExpressionMembers ::= '{' StructExpressionMember (',' (StructExpressionMember | &'}'))* '}' {pin(".*")=1}
StructExpression ::= VarLiteral (&INDNONE'(') StructExpressionMembers ')'

AssignmentExpression ::=
    Expression (&INDNONE ('=' | '+=' | '-=' | '*=' | '/=' | '%='))
    Expression { rightAssociative=true  }

TupleAssignmentExpression ::= VarLiteral (',' VarLiteral)+ &INDNONE '=' Expression

CallExpression ::= Expression &INDNONE FunctionCallArguments

MemberAccessExpression ::= Expression &INDNONE '.' &INDNONE VarLiteral {
    name = "member access"
}
IndexAccessExpression ::= Expression &INDNONE '[' Expression ']'
ParenthesizedExpression ::= '(' Expression ')' {pin = 1}
UnaryExpression ::=  (not | '~' | '+' | '-') &INDNONE Expression {
    rightAssociative=true
    pin = 1
}
InlineArrayExpression ::= '[' Expression (',' (Expression | &']'))* ']' {pin(".*")=1}
AndExpression ::=  Expression AND Expression
OrExpression ::= Expression OR Expression
EqExpression ::= Expression ('==' | '!=') Expression
CompExpression ::= Expression ('<' | '>' | '<=' | '>=') Expression
PlusMinExpression ::= Expression ('+' | '-') Expression
MultDivExpression ::= Expression ('*' | '/' | '%') Expression
ExponentExpression ::= Expression '**' Expression
BinExpression ::= Expression (PIPE | AMPERSAND | RSHIFT | LSHIFT | CARET) Expression

AssertExpression ::= assert &INDNONE Expression (&INDNONE AssertMessage)? {
    pin = 1
    name = "assert expression"
}
private AssertMessage ::= ',' ( stringLiteralDouble | stringLiteralSingle | MultiLineString )

FunctionCallArgument ::= Expression | ( VarLiteral '=' Expression )
FunctionCallArguments ::= '(' (FunctionCallArgument (',' (FunctionCallArgument | &')'))*)? ')' {pin(".*")=1}

PrimaryExpression ::= VarLiteral | BooleanLiteral | NumberLiteral | HexLiteral | StringLiteral | self
    | TYPE // type is accepted as parameter in some built-in functions

VarLiteral ::= Identifier {
    implements = "org.vyperlang.plugin.psi.VyperReferenceElement"
    mixin = "org.vyperlang.plugin.psi.VyperVarLiteralMixin"
    name = "variable"
}

// TODO #29: BuiltIn ::= 'bitwise_and' | 'bitwise_not' | 'bitwise_or' | 'bitwise_xor' | 'shift' | 'create_minimal_proxy_to' | 'create_copy_of' | 'create_from_blueprint' | 'raw_call' | 'raw_log' | 'raw_revert' | 'selfdestruct' | 'send' | 'ecadd' | 'ecmul' | 'ecrecover' | 'keccak256' | 'sha256' | 'concat' | 'convert' | 'uint2str' | 'extract32' | 'slice' | 'abs' | 'ceil' | 'epsilon' | 'floor' | 'max' | 'max_value' | 'min' | 'min_value' | 'pow_mod256' | 'sqrt' | 'isqrt' | 'uint256_addmod' | 'uint256_mulmod' | 'unsafe_add' | 'unsafe_sub' | 'unsafe_mul' | 'unsafe_div' | 'as_wei_value' | 'blockhash' | 'empty' | 'len' | 'method_id' | '_abi_encode' | '_abi_decode' | 'abi_encode' | 'abi_decode' | 'print'

// TYPES seems okay
TYPE ::=  ListType | MapType | ValueType | StructType

ValueType ::= intM | uintM | bytesM | address | bool | ((string | bytes) &INDNONE '[' Expression ']')

ListType ::= ( ValueType | StructType ) &INDNONE '[' Expression ']' (&INDNONE '[' Expression ']')*

StructType ::= Identifier
{
    implements = "org.vyperlang.plugin.psi.VyperReferenceElement"
    mixin = "org.vyperlang.plugin.psi.VyperVarLiteralMixin"
}

private DynArrayType ::= DynArray &INDNONE '[' TYPE ',' Expression ']'
private HashMapType ::= HashMap &INDNONE '[' Expression ',' TYPE ']'
MapType ::= DynArrayType | HashMapType { pin=1 }

private BooleanLiteral ::= booleanLiteral
private NumberLiteral ::= HexNumber | DecimalNumber | FixedNumber
private StringLiteral ::= stringLiteralDouble | stringLiteralDoubleB | stringLiteralSingle | stringLiteralSingleB | MultiLineString
private DecimalNumber ::= decimalNumber
private HexNumber ::= hexNumber
private HexLiteral ::= hexLiteral
private FixedNumber ::=fixedNumber