Squirrel.bnf

{
  parserClass="com.sqide.SquirrelParser"
  parserUtilClass="com.sqide.parser.SquirrelParserUtil"

  extends="com.intellij.extapi.psi.ASTWrapperPsiElement"

  psiClassPrefix="Squirrel"
  psiImplClassSuffix="Impl"
  psiPackage="com.sqide.psi"
  psiImplPackage="com.sqide.psi.impl"
  psiImplUtilClass="com.sqide.psi.impl.SquirrelPsiImplUtil"

  elementTypeHolderClass="com.sqide.SquirrelTokenTypes"
  elementTypeClass="com.sqide.psi.SquirrelElementType"
  tokenTypeClass="com.sqide.psi.SquirrelTokenType"

  tokens = [
    INCLUDE_DIRECTIVE    =  '@include'
    SEMICOLON_SYNTHETIC  =  '<NL>'

    RBRACE               =  '}'
    RBRACKET             =  ']'
    RPAREN               =  ')'
    PLUS_PLUS            =  '++'
    MINUS_MINUS          =  '--'

    LBRACE               =  '{'
    LBRACKET             =  '['
    LPAREN               =  '('
    DOUBLE_COLON         =  '::'
    COLON                =  ':'
    SEMICOLON            =  ';'
    COMMA                =  ','
    MULTI_ARGS           =  '...'
    CLASS_ATTR_START     =  '</'
    CLASS_ATTR_END       =  '/>'
    SHIFT_LEFT           =  '<<'
    SHIFT_RIGHT          =  '>>'
    UNSIGNED_SHIFT_RIGHT =  '>>>'
    CMP                  =  '<=>'
    EQ_EQ                =  '=='
    NOT_EQ               =  '!='
    LESS_OR_EQ           =  '<='
    GREATER_OR_EQ        =  '>='
    SEND_CHANNEL         =  '<-'
    PLUS_EQ              =  '+='
    MINUS_EQ             =  '-='
    MUL_EQ               =  '*='
    DIV_EQ               =  '/='
    REMAINDER_EQ         =  '%='
    OR_OR                =  '||'
    AND_AND              =  '&&'
    EQ                   =  '='
    NOT                  =  '!'
    BIT_NOT              =  '~'
    BIT_OR               =  '|'
    BIT_XOR              =  '^'
    BIT_AND              =  '&'
    LESS                 =  '<'
    GREATER              =  '>'
    PLUS                 =  '+'
    MINUS                =  '-'
    MUL                  =  '*'
    DIV                  =  '/'
    REMAINDER            =  '%'
    QUESTION             =  '?'
    AT                   =  '@'
    DOT                  =  '.'

    SINGLE_LINE_COMMENT = "regexp:(//|#)[^\r\n]*"
    MULTI_LINE_COMMENT = "regexp:/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*(\*+/)"

    IDENTIFIER = "regexp:[a-zA-Z_]+[a-zA-Z_0-9]*"
    INT = "regexp:((0[1-9][0-7]*)|(0x[0-9a-fA-F]*)|('\p{Alpha}')|(0|([1-9][0-9]*)))"
    FLOAT = "regexp:((([0-9]+\.[0-9]*)|([0-9]*\.[0-9]+))([eE][+-]?[0-9]+)?)|([0-9]+([eE][+-]?[0-9]+))"
    STRING = "regexp:(@\"([^\"]|\"\")*\"|\"(\\.|[^\"\n\r])*\")"

    NL="NL"
    WS="WS"
    NL="regexp:[\r\n]|\r\n"
    WS="regexp:[ \t\f]"
  ]
  implements("(ClassDeclaration|ClassExpression)")="com.sqide.psi.SquirrelClass"
  implements("(FunctionDeclaration|ConstructorDeclaration|MethodDeclaration|FunctionExpression)")="com.sqide.psi.SquirrelFunction"
  extends(".*Expression")=Expression
  extends(".*(Statement|Declaration|Block)")=Statement
  name(".*Expression")="expression"
}

// ---------
// PREVIEW MODE GOTCHAS
// ---------
// The optional semicolon logic is placed inside lexer. Therefore in order to test stuff in preview mode, you should
// keep in mind that:
//
// 1. In the preview mode, you should use <NL> instead of new lines in cases where you want the new line to work as
// semicolon. This is a fix for a live preview feature where it can't distinguish between whitespace line breaks and the
// useful ones.
//
// 2. Also, you should put semicolons after } in places where you expect the virtual semicolon to be placed.

//// TEST DATA:
//
//i = 2;
//i = 02;
//i = 0x222;
//i = 'c';
//f = 0.52;
//f = 1.e2;
//f = 1.e-2;
//s = "I'm a string"<NL>
//s = @"I'm a string verbatim string"<NL>
//s = @"I'm a multiline
//string verbatim string"<NL>
//b = true;
//b = false;
//n = null;
//exp = a ? i + 2 : b > -3 + +23 * i++ / 34 % ~ 3
//nc = i++ + ++i - --i - i-- + +i - -i - -(-i) + -i-- + errors_on_right + ---i + --(-i) + --i--i
//
//const a=-2;
//const b=2;
//enum c {};
//enum c {a,b,c=4, h="23", h=23, h=-2};
//local o, a=2, b=23, c = (1,2), d = function(a,b=2,c=2){}, e = @(a,b,...) a + (b, f = 2), g=[123, function(){}, @()(1+2)], c = class {};
//function a(a, b, a=2, a=2) {};
//a(a, 2, g[1]);
//class Test.B extends Test {
//    constructor (a) {
//    }
//    a = function (asd){
//    }
//    function sds() {
//    }
//    g = "234"
//}

SquirrelFile ::= !<<eof>> Statements

private semi ::= SEMICOLON_SYNTHETIC | ';' {name="semicolon"}
private multisemi ::= semi + {name="semicolon"}
private delimiter ::= multisemi | &'}' | <<eof>> | <<prevIsBrace>>

private Statements ::= multisemi? StatementWithSemi*

private StatementWithSemi ::= Statement delimiter { pin=1 recoverWhile=statement_recover }

private statement_recover ::= !(<<eof>> | delimiter | '{' | '}' | const | enum | local | function | class | return | break | continue | yield | throw | for | foreach | while | do | if | else | switch | case | default | try | catch | '@include')

Statement ::=
    IncludeDeclaration
    | Block
    | ExpressionStatement
    | ConstDeclaration
    | EnumDeclaration
    | LocalDeclaration
    | FunctionDeclaration
    | ClassDeclaration

    | ForStatement
    | ForeachStatement
    | WhileStatement
    | DoWhileStatement
    | IfStatement
    | SwitchStatement
    | TryStatement

    | ReturnStatement
    | BreakStatement
    | ContinueStatement
    | YieldStatement
    | ThrowStatement


private StatementOrEmpty ::= Statement | ';'

Block ::= '{' Statements? '}' {pin=1}

private OnceDirective ::= once
private IncludeDirective ::= INCLUDE_DIRECTIVE [OnceDirective]
IncludeDeclaration ::= IncludeDirective STRING {pin=1 name="include" methods=[getReference]}
ConstDeclaration ::= const Id '=' Literal {pin=1}

EnumDeclaration ::= enum Id '{' EnumItemDeclarations? '}' {pin=1}
private EnumItemDeclarations ::= EnumItem (',' EnumItem)* ','?
EnumItem ::= Id [ '=' Literal ]

LocalDeclaration ::= local VariableOrFunctionDeclarations {pin=1}
private VariableOrFunctionDeclarations ::= VarDeclarationList | FunctionDeclaration { name="variable or function declarations" }
VarDeclarationList ::= VarItem (',' VarItem)*
VarItem ::= Id VarInit?
VarInit ::= '=' ExpressionWithNoComma

FunctionDeclaration ::= function FunctionName Parameters FunctionBody  {pin=1}
FunctionName ::= Id ('::' (Id | constructor))*
FunctionBody ::= StatementOrEmpty
Parameters ::= '(' ParameterList? ')'
ParameterList ::=
Parameter (',' Parameter)* ((',' DefaultParameter)+ | (',' VariableLengthParameter))?
| DefaultParameter (',' DefaultParameter)*
| VariableLengthParameter?

Parameter ::= Id (!'=')
DefaultParameter ::= Id '=' ExpressionWithNoComma
VariableLengthParameter ::= '...'

ClassDeclaration ::= class ClassName [extends ClassName] ClassBody {pin=1}
ClassName ::= Id ('.' Id)*
ClassBody ::= '{' ClassMembers? '}'

private ClassMembers ::= ClassMember (semi* ClassMember)* semi?
ClassMember ::= ClassAttribute? static? (ConstructorDeclaration | RegularClassMember)
private RegularClassMember ::= KeyValuePair | MethodDeclaration
ConstructorDeclaration ::= constructor Parameters FunctionBody
MethodDeclaration ::= function FunctionName Parameters FunctionBody
ClassAttribute ::= '</' KeyValuePairs? '/>'

ReturnStatement ::= return Expression? {pin=1}
BreakStatement ::= break
ContinueStatement ::= continue
YieldStatement ::= yield Expression {pin=1}
ThrowStatement ::= throw Expression {pin=1}

ForStatement ::= for '(' ForLoopParts ')' StatementOrEmpty {pin=1}
ForLoopParts::= [LocalDeclaration | Expression] ';' Expression? ';' Expression?

ForeachStatement ::= foreach '(' [Id ','] Id in Expression ')' StatementOrEmpty {pin=1}
WhileStatement ::= while '(' ExpressionWithRecoverUntilParen ')' StatementOrEmpty {pin=1}
DoWhileStatement ::= do StatementOrEmpty while '(' ExpressionWithRecoverUntilParen ')' {pin=1}
IfStatement ::= if '(' ExpressionWithRecoverUntilParen ')' StatementOrEmpty [semi? else StatementOrEmpty] {pin=1}

SwitchStatement ::= switch '(' ExpressionWithRecoverUntilParen ')' '{' SwitchCase* DefaultCase? '}' {pin=1}
SwitchCase ::= case Expression ':' Statements? {pin=1}
DefaultCase::= default ':' Statements? {pin=2}

TryStatement ::= try StatementOrEmpty CatchPart {pin=1}
CatchPart ::= catch '(' Id ')' StatementOrEmpty {pin=1}

private ExpressionWithRecoverUntilParen ::= Expression {recoverWhile=parenthesesRecovery}
private parenthesesRecovery ::= !')'

ExpressionStatement ::= Expression;

Expression ::=
  CommaExpression
  | AssignExpression
  | TernaryExpression
  | LogicOrExpression
  | second_expr_group
  | BitwiseOrExpression
  | BitwiseXorExpression
  | BitwiseAndExpression
  | CompareExpression
  | RelationalExpression
  | ShiftExpression
  | AdditiveExpression
  | MultiplicativeExpression
  | first_expr_group
  | c_expr_group
  | b_expr_group
  | a_expr_group

private ExpressionWithNoComma ::=
  AssignExpression
  | TernaryExpression
  | LogicOrExpression
  | second_expr_group
  | BitwiseOrExpression
  | BitwiseXorExpression
  | BitwiseAndExpression
  | CompareExpression
  | RelationalExpression
  | ShiftExpression
  | AdditiveExpression
  | MultiplicativeExpression
  | first_expr_group
  | c_expr_group
  | b_expr_group
  | a_expr_group {name="expression"}

private a_expr_group ::= (SimpleRefExpression | LiteralExpression | JsonExpression | ParenthesizedExpression)
private b_expr_group ::= (ArrayItemExpression | ReferenceExpression | CallExpression)
private c_expr_group ::= (ClassExpression | TableExpression | ArrayExpression | FunctionExpression | LambdaFunctionExpression )
private first_expr_group ::= (UnaryExpression | PrefixExpression | InstanceOfExpression )
private second_expr_group ::= (LogicAndExpression | InExpression)

MultiplicativeOperator ::= '*' | '/' | '%'
AdditiveOperator ::= '+' | '-'
ShiftOperator ::= '<<' | '>>>' | '>>'
RelationalOperator ::= '<' | '<=' | '>' | '>='
EqualityOperator ::= '==' | '!=' | '<=>'
AssignmentOperator ::= '=' | '<-' | '*=' | '/=' | '%=' | '+=' | '-='
UnaryOperator ::= '-' | '!' | '~'
UnaryAction ::= typeof | clone | delete | resume
PrefixOperator ::= '++' | '--'

CommaExpression ::= Expression ',' Expression
AssignExpression ::= Expression AssignmentOperator Expression { rightAssociative=true }
TernaryExpression ::= Expression '?' Expression ':' Expression
LogicOrExpression ::= Expression '||' Expression
LogicAndExpression ::= Expression '&&' Expression
InExpression ::= Expression in Expression
BitwiseOrExpression ::= Expression '|' Expression
BitwiseXorExpression ::= Expression '^' Expression
BitwiseAndExpression ::= Expression '&' Expression
CompareExpression ::= Expression EqualityOperator Expression
RelationalExpression ::= Expression RelationalOperator Expression
ShiftExpression ::= Expression ShiftOperator Expression
AdditiveExpression ::= Expression AdditiveOperator Expression
MultiplicativeExpression ::= Expression MultiplicativeOperator Expression
UnaryExpression ::= (UnaryOperator | UnaryAction) Expression
PrefixExpression ::= PrefixOperator NamedElementExpression
InstanceOfExpression ::= Expression instanceof Expression
ParenthesizedExpression ::= '(' Expression ')'
ClassExpression ::= class [extends ClassName] ClassBody
FunctionExpression ::= function Parameters FunctionBody
LambdaFunctionExpression ::= '@' Parameters ExpressionWithNoComma
CallExpression ::= Expression Arguments
Arguments ::= '(' ArgumentList? ')'
ArgumentList ::= ArgumentListPart (',' ArgumentListPart)* {recoverWhile="argument_list_recover"}
private argument_list_recover ::= !(')')
private ArgumentListPart ::= ExpressionWithNoComma {recoverWhile="argument_list_part_recover"}
private argument_list_part_recover ::= !(')' | ',')

ArrayExpression ::= '[' ArrayElementsList?  ']'
private ArrayElementsList ::= ArrayListPart (',' ArrayListPart)* ','? {recoverWhile="array_list_recover"}
private array_list_recover ::= !(']')
private ArrayListPart ::= ExpressionWithNoComma {recoverWhile="array_list_part_recover"}
private array_list_part_recover ::= !(']' | ',')

ArrayItemExpression ::= Expression '[' ExpressionWithNoComma ']' PrefixOperator?

TableExpression ::= '{' KeyValuePairs? '}'
private TableItemSeparator ::= ',' | '<NL>'
private KeyValuePairs ::= TableItem (TableItemSeparator* TableItem)* TableItemSeparator?
TableItem ::= KeyValuePair | FunctionDeclaration
private KeyValuePair ::= Key '=' ExpressionWithNoComma
Key ::= Id | '[' Expression ']'

private NamedElementExpression ::= SimpleRefExpression | ReferenceExpression | ArrayItemExpression
ReferenceExpression ::= Expression '.' (Id | constructor)

SimpleRefExpression ::= Id PrefixOperator? {elementType=ReferenceExpression}
LiteralExpression ::= Literal
JsonExpression ::= Json

Literal ::=
    '-'? INT
  | '-'? FLOAT
  | StringLiteral
  | true | false
  | null

StringLiteral ::= STRING {methods =[getReference]}

Json ::= JsonObject | JsonArray
JsonArray ::= '[' [!']' JsonValue (!']' ',' JsonValue) *] ']' {pin(".*")=1}
JsonObject ::= '{' [!'}' JsonProp (!'}' ',' JsonProp) *] '}' {pin(".*")=1}
JsonProp ::= STRING ':' JsonValue {pin=1 recoverWhile=JsonRecover}
JsonValue ::= Literal | Expression | Json
private JsonRecover ::= !(',' | ']' | '}' | '[' | '{')

Id ::= '::'? IDENTIFIER { name="identifier" methods=[getReference]}