// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
{
  psiImplUtilClass="com.jetbrains.lang.dart.util.DartPsiImplUtil"

  parserClass="com.jetbrains.lang.dart.DartParser"
  parserUtilClass="com.jetbrains.lang.dart.DartGeneratedParserUtilBase"

  implements="com.jetbrains.lang.dart.psi.DartPsiCompositeElement"
  extends="com.jetbrains.lang.dart.psi.impl.DartPsiCompositeElementImpl"

  psiClassPrefix="Dart"
  psiImplClassSuffix="Impl"
  psiPackage="com.jetbrains.lang.dart.psi"
  psiImplPackage="com.jetbrains.lang.dart.psi.impl"

  elementTypeHolderClass="com.jetbrains.lang.dart.DartTokenTypes"
  elementTypePrefix=""
  elementTypeClass="com.jetbrains.lang.dart.DartElementType"
  tokenTypeClass="com.jetbrains.lang.dart.DartElementType"

  tokenTypeClass="com.jetbrains.lang.dart.DartTokenTypes"

  generateFirstCheck=50

  tokens = [
// reserved words
  ASSERT="assert"
  BREAK="break"
  CASE="case"
  CATCH="catch"
  CLASS="class"
  CONST="const"
  CONTINUE="continue"
  DEFAULT="default"
  DO="do"
  ELSE="else"
  ENUM="enum"
  EXTENDS="extends"
  FALSE="false"
  FINAL="final"
  FINALLY="finally"
  FOR="for"
  IF="if"
  IN="in"
  IS="is"
  NEW="new"
  NULL="null"
  RETHROW="rethrow"
  RETURN="return"
  SUPER="super"
  SWITCH="switch"
  THIS="this"
  THROW="throw"
  TRUE="true"
  TRY="try"
  VAR="var"
  VOID="void"
  WHILE="while"
  WITH="with"

// BUILT_IN_IDENTIFIER
  ABSTRACT="abstract"
  AS="as"
  COVARIANT="covariant"
  DEFERRED="deferred"
  EXPORT="export"
  EXTERNAL="external"
  FACTORY="factory"
  GET="get"
  IMPLEMENTS="implements"
  IMPORT="import"
  LIBRARY="library"
  MIXIN="mixin"
  OPERATOR="operator"
  PART="part"
  SET="set"
  STATIC="static"
  TYPEDEF="typedef"

// other
  ON="on"
  OF="of"
  NATIVE="native"
  SHOW="show"
  HIDE="hide"
  SYNC="sync"
  ASYNC="async"
  AWAIT="await"
  YIELD="yield"
  LATE="late"
  REQUIRED="required"

  LBRACE="{"
  RBRACE="}"
  LBRACKET="["
  RBRACKET="]"
  LPAREN="("
  RPAREN=")"
  SEMICOLON=";"
  MINUS="-"
  MINUS_EQ="-="
  MINUS_MINUS="--"
  PLUS="+"
  PLUS_PLUS="++"
  PLUS_EQ="+="
  DIV="/"
  DIV_EQ="/="
  MUL="*"
  MUL_EQ="*="
  INT_DIV="~/"
  INT_DIV_EQ="~/="
  REM_EQ="%="
  REM="%"
  BIN_NOT="~"
  NOT="!"

  EXPRESSION_BODY_DEF="=>"
  EQ="="
  EQ_EQ="=="
  NEQ="!="
  DOT="."
  DOT_DOT=".."
  QUEST_DOT_DOT="?.."
  DOT_DOT_DOT="..."
  DOT_DOT_DOT_QUEST="...?"
  COMMA=","
  COLON=":"
  GT=">"
  GT_EQ=">="
  GT_GT=">>"
  GT_GT_EQ=">>="
  LT="<"
  LT_EQ="<="
  LT_LT="<<"
  LT_LT_EQ="<<="
  OR="|"
  OR_EQ="|="
  OR_OR="||"
  OR_OR_EQ="||="
  QUEST="?"
  QUEST_DOT="?."
  QUEST_QUEST="??"
  QUEST_QUEST_EQ="??="
  XOR="^"
  XOR_EQ="^="
  AND="&"
  AND_EQ="&="
  AND_AND="&&"
  AND_AND_EQ="&&="
  HASH="#"
  AT="@"
  ]

  extends(".*Expression")="expression"
}

dartUnit ::= topLevelDefinition*
private topLevelDefinition ::= libraryStatement
                             | partOfStatement
                             | importStatement
                             | exportStatement
                             | partStatement
                             | classDefinition
                             | mixinDeclaration
                             | enumDefinition
                             | functionTypeAlias
                             | getterOrSetterDeclaration
                             | functionDeclarationWithBodyOrNative
                             | varDeclarationListWithSemicolon
                             | incompleteDeclaration // not valid according to spec, but we'd like it to be parsed in order to have completion
                             {recoverWhile="top_level_recover"}
private top_level_recover ::= !(<<nonStrictID>> | '@' | 'abstract' | 'class' | 'const' | 'enum' | 'export' | 'external' | 'final' | 'get' | 'import' | 'library' | 'part' | 'set' | 'static' | 'typedef' | 'var' | 'void')

incompleteDeclaration ::= metadata* ('external' | 'static' | 'final' | 'const' | 'covariant')* type | metadata+;

partOfStatement ::= metadata* 'part' 'of' (libraryId | uriElement)';' {
  pin=4
  methods = [ getLibraryName ]
}

libraryId ::= <<nonStrictID>> ('.' <<nonStrictID>>)*
{mixin="com.jetbrains.lang.dart.psi.impl.DartLibraryIdBase" implements="com.jetbrains.lang.dart.psi.DartReference"}

libraryStatement ::= metadata* 'library' libraryNameElement ';' {pin=3}

libraryNameElement ::= <<nonStrictID>> ('.' <<nonStrictID>>)* {
  mixin="com.jetbrains.lang.dart.psi.impl.DartLibraryNameElementBase"
  implements="com.jetbrains.lang.dart.psi.DartPsiCompositeElement, com.intellij.psi.PsiNameIdentifierOwner"
  methods=[getName]
}

importStatement ::= metadata* 'import' uriElement importConfig* ('deferred'? 'as' componentName )? combinator* ';' {
  pin=3
  implements="com.jetbrains.lang.dart.psi.DartImportOrExportStatement"
  methods = [
    getUriString
    importPrefix = "componentName"
  ]
}

exportStatement ::= metadata* 'export' uriElement importConfig* combinator* ';' {
  pin=3
  implements="com.jetbrains.lang.dart.psi.DartImportOrExportStatement"
  methods = [ getUriString ]
}

private importConfig ::= 'if' '(' dottedName ('==' stringLiteralExpression)? ')' stringLiteralExpression
private dottedName ::= <<nonStrictID>> ('.' <<nonStrictID>>)*

private combinator ::= showCombinator | hideCombinator

showCombinator ::= 'show' libraryReferenceList {pin=1}
hideCombinator ::= 'hide' libraryReferenceList {pin=1}
libraryReferenceList ::= libraryComponentReferenceExpression (',' libraryComponentReferenceExpression)*

partStatement ::= metadata* 'part' uriElement ';' {
  pin=3
  implements="com.jetbrains.lang.dart.psi.DartUriBasedDirective"
  methods = [ getUriString ]
}

metadata ::= '@' simpleQualifiedReferenceExpression <<argumentsWrapper>>?

uriElement ::= stringLiteralExpression {mixin="com.jetbrains.lang.dart.psi.impl.DartUriElementBase"   methods = [ getUriStringAndItsRange ]}

varAccessDeclaration ::= metadata* 'static'? ('covariant'? 'late'? finalOrConst type               componentName |
                                              'covariant'? 'late'? finalOrConst                    componentName <<failIfItLooksLikeConstantObjectExpression>> |
                                              'covariant'? 'late'? 'var'                           componentName |
                                              'covariant'  'late'               type !asExpression componentName |
                                              'covariant'                       type !asExpression componentName |
                                                           'late'               type !asExpression componentName |
                                                                                type !asExpression componentName) !'.' !':'
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}
private finalOrConst ::= 'final' | 'const'
private varDeclarationListWithSemicolon ::= varDeclarationList ';'{pin=1}
varDeclarationList ::= varAccessDeclaration varInit? (',' varDeclarationListPart)* {pin = 3}
varDeclarationListPart ::= componentName varInit?
{
  mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl"
  implements="com.jetbrains.lang.dart.psi.DartComponent"
  methods= [getMetadataList]
}

classDefinition ::= metadata* 'abstract'? 'class' componentName typeParameters? (mixinApplication | standardClassDeclarationTail)
{pin=4 mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartPsiClass" implements="com.jetbrains.lang.dart.psi.DartClass"}

mixinDeclaration ::= metadata* 'mixin' componentName typeParameters? onMixins? interfaces? classBody
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartPsiClass" implements="com.jetbrains.lang.dart.psi.DartClass"}

enumDefinition ::= metadata* 'enum' componentName '{' enumConstantDeclaration (',' enumConstantDeclaration)* ','? '}'
{pin=3  mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartPsiClass" implements="com.jetbrains.lang.dart.psi.DartClass"}

enumConstantDeclaration ::= componentName
{
  mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl"
  implements="com.jetbrains.lang.dart.psi.DartComponent"
  methods = [getMetadataList]
}

mixinApplication ::= '=' type mixins? interfaces? ';' {pin = 1}
private standardClassDeclarationTail ::= superclass? mixins? interfaces? ('native' stringLiteralExpression?)? classBody?

classBody ::= '{' classMembers '}' {pin=1}
classMembers ::= classMemberDefinition*
{recoverWhile="simple_scope_recover" implements="com.jetbrains.lang.dart.psi.DartExecutionScope"}
private simple_scope_recover ::= !'}'

private getterOrSetterDeclaration ::= getterDeclaration | setterDeclaration

getterDeclaration ::= getterDeclarationWithReturnType | getterDeclarationWithoutReturnType // 'get' is a valid identifier, so can be a returnType
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}
private getterDeclarationWithReturnType    ::= metadata* ('external' | 'static')* returnType 'get' componentName formalParameterList? (';' | functionBodyOrNative) {pin=5}
private getterDeclarationWithoutReturnType ::= metadata* ('external' | 'static')*            'get' componentName formalParameterList? (';' | functionBodyOrNative) {pin=4}

setterDeclaration ::= setterDeclarationWithReturnType | setterDeclarationWithoutReturnType // 'set' is a valid identifier, so can be a returnType
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}
private setterDeclarationWithReturnType    ::= metadata* ('external' | 'static')* returnType 'set' componentName formalParameterList (';' | functionBodyOrNative) {pin=5}
private setterDeclarationWithoutReturnType ::= metadata* ('external' | 'static')*            'set' componentName formalParameterList (';' | functionBodyOrNative) {pin=4}

typeParameters ::= '<' typeParameter? (',' typeParameter)* '>' {pin=1}
typeParameter ::= metadata* componentName ('extends' type)?
{recoverWhile="type_parameter_recover" mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}

private type_parameter_recover ::= !(<<nonStrictID>> | '(' | ',' | '=' | '>' | '@' | 'abstract' | 'class' | 'const' | 'export' | 'extends' |
                                     'external' | 'final' | 'get' | 'implements' | 'import' | 'library' | 'native' | 'part' | 'set' |
                                     'static' | 'typedef' | 'var' | 'void' | '{')
superclass ::= 'extends' type {pin=1}
mixins ::= 'with' typeList {pin=1}
onMixins ::= 'on' typeList {pin=1}
interfaces ::= 'implements' typeList {pin=1}

private classMemberDefinition ::= factoryConstructorDeclaration
                                | namedConstructorDeclaration
                                | getterOrSetterDeclaration
                                | methodDeclaration
                                | varDeclarationListWithSemicolon
                                | incompleteDeclaration // not valid according to spec, but we'd like it to be parsed in order to have completion
                                {recoverWhile="class_member_recover"}
private class_member_recover ::= !(<<nonStrictID>> | '@' | 'abstract' | 'class' | 'const' | 'export' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'library' | 'operator' | 'part' | 'set' | 'static' | 'typedef' | 'var' | 'void' | '}' )

private functionBodyOrNative ::= 'native' functionBody
                               | functionNative
                               | functionBody

private functionNative ::= 'native' (stringLiteralExpression ';' | ';' | stringLiteralExpression functionBody)

methodDeclaration ::= metadata* ('external' | 'static' | 'const')* methodDeclarationPrivate initializers? (';' | functionBodyOrNative | redirection)?
{pin=3 mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartMethodDeclarationImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}
private methodDeclarationPrivate ::= returnType <<methodNameWrapper>> typeParameters? formalParameterList | !untypedFunctionType <<methodNameWrapper>> typeParameters? formalParameterList // todo remove, use functionSignature as in spec

namedConstructorDeclaration ::= metadata* ('external' | 'const')* componentName '.' componentName formalParameterList initializers? (';' | functionBodyOrNative | redirection)?
{pin=6 mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent" methods = [getComponentName]}

initializers ::= ':' superCallOrFieldInitializer (',' superCallOrFieldInitializer)*

// If it were possible to edit Object or Null then we'd have to allow for ?.
redirection ::= ':' 'this' ('.' referenceExpression)? <<argumentsWrapper>>  {pin=2}

fieldInitializer ::= ('this' '.')? referenceExpression '=' expression {pin=2}

superCallOrFieldInitializer ::= (superExpression | thisExpression) ('.' referenceExpression)? <<argumentsWrapper>>
                              | fieldInitializer
                              | assertStatement
                              {recoverWhile="super_call_or_field_initializer_recover"}
private super_call_or_field_initializer_recover ::= !(<<nonStrictID>> | ',' | ':' | ';' | '=>' | '@' | 'abstract' | 'async' | 'class' | 'const' |
                                                      'export' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'library' |
                                                      'native' | 'operator' | 'part' | 'set' | 'static' | 'sync' | 'typedef' | 'var' | 'void' | '{' |
                                                      '}' )

functionTypeAlias ::= metadata* 'typedef' functionPrefix typeParameters? formalParameterList ';'?
                    | metadata* 'typedef' componentName typeParameters? '=' functionTypeWrapper ';'?
{pin=5 mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}
private functionPrefix ::= returnType componentName | componentName

parameterTypeList ::= '(' ')'
                    | '(' normalParameterTypes ','? ')'
                    | '(' normalParameterTypes ',' optionalParameterTypes ')'
                    | '(' optionalParameterTypes ')'

private normalParameterTypes ::= normalParameterType (',' normalParameterType)*
normalParameterType ::= typedIdentifier | type
private typedIdentifier ::= type <<nonStrictID>>

optionalParameterTypes ::= optionalPositionalParameterTypes | namedParameterTypes
private optionalPositionalParameterTypes ::= '[' normalParameterTypes ','? ']'
private namedParameterTypes ::= '{' 'required'? typedIdentifier (',' 'required'? typedIdentifier)* ','? '}'

factoryConstructorDeclaration ::= metadata* ('external' | 'const')* 'factory' componentName ('.' componentName)? formalParameterList factoryTail?
{pin=3 mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent" methods = [getComponentName]}
private factoryTail ::= varFactoryDeclaration ';' | functionBodyOrNative | ';' {pin(".*")=1}
private varFactoryDeclaration ::= '=' type ['.' referenceExpression] {pin(".*")=1}

userDefinableOperator ::= binaryOperator |
                          '~' |
                          '[' ']' '='?
private binaryOperator ::= multiplicativeOperator |
                           additiveOperator |
                           shiftOperator|
                           relationalOperator|
                           '==' |
                           bitwiseOperator

multiplicativeOperator ::= '*' | '/' | '%' | '~/'
additiveOperator ::= '+' | '-'
shiftOperator ::= '<<' | <<gtGt>>
relationalOperator ::= <<gtEq>> | '>' | '<=' | '<'
bitwiseOperator ::= '&' | '^' | '|'

assignmentOperator ::= '=' | '*=' | '/=' | '~/=' | '%=' | '+=' | '-=' | '<<=' | <<gtGtEq>> | '&=' | '&&=' | '^=' | '|=' | '||=' | '??='
equalityOperator ::= '==' | '!='

formalParameterList ::= '(' ')' |
                        '(' normalFormalParameters (',' optionalFormalParameters)? ','? ')' |
                        '(' optionalFormalParameters ')'
private normalFormalParameters ::= normalFormalParameter (',' normalFormalParameter)*

fieldFormalParameter ::= metadata* finalConstVarVoidOrType? 'this' '.' referenceExpression typeParameters? formalParameterList?

optionalFormalParameters ::= optionalPositionalFormalParameters (',' namedFormalParameters)? | namedFormalParameters
private optionalPositionalFormalParameters ::= '[' defaultFormalNamedParameter (',' defaultFormalNamedParameter)* ','? ']'
private namedFormalParameters ::= '{' defaultFormalNamedParameter (',' defaultFormalNamedParameter)* ','? '}'

defaultFormalNamedParameter ::= 'required'? normalFormalParameter (('=' | ':') expression)? {recoverWhile="default_formal_parameter_recover"}
private default_formal_parameter_recover ::= !(')' | ',' | ']' | '}')

normalFormalParameter ::= functionFormalParameter
                        | fieldFormalParameter
                        | simpleFormalParameter
                        | incorrectNormalFormalParameter {
  methods = [findComponentName]
}
private incorrectNormalFormalParameter ::= '<' + <<nonStrictID>> + '>' <<nonStrictID>> // because Analysis Server gives syntactically incorrect quick fixes, e.g. "void foo(<bottom> arg0) {\n}"

functionFormalParameter ::= !functionTypeWrapper (metadata*                         componentName typeParameters? formalParameterList |
                                                  metadata* 'covariant'? returnType componentName typeParameters? formalParameterList |
                                                  metadata* 'covariant'             componentName typeParameters? formalParameterList)
                            '?'?
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}

simpleFormalParameter ::= declaredIdentifier | metadata* componentName | metadata* 'covariant' componentName
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}
private declaredIdentifier ::= metadata* finalConstVarOrTypeAndComponentName;

returnType ::= 'void' !untypedFunctionType | type // TODO returnType is now equivalent to type and removed from spec, we could remove it as well

private finalConstVarVoidOrType ::= 'late'? 'final' type? | 'const' type? | 'late'? 'var' | 'late'? 'void' | 'late' type | type // Be careful on using it! It may erroneously consume 'type?'. See finalConstVarOrTypeAndComponentName
private finalConstVarOrTypeAndComponentName ::= 'covariant'? 'late'? 'final' type componentName |
                                                'covariant'? 'late'? 'final'      componentName |
                                                'covariant'?         'const' type componentName |
                                                'covariant'?         'const'      componentName |
                                                'covariant'? 'late'? 'var'        componentName |
                                                'covariant'  'late'          type componentName |
                                                'covariant'                  type componentName |
                                                             'late'          type componentName |
                                                                             type componentName

componentName ::= << nonStrictID >>
{mixin="com.jetbrains.lang.dart.psi.impl.DartNamedElementImpl" implements="com.jetbrains.lang.dart.psi.DartNamedElement"}

// see nonStrictID
id ::= IDENTIFIER

type ::= 'void' !untypedFunctionType | functionTypeWrapper | simpleType  {
  methods=[
    resolveReference getReferenceExpression getTypeArguments
  ]
}

untypedFunctionType ::= <<functionId>> typeParameters? parameterTypeList '?'?
private functionTypeWrapper ::= (voidTypeFunctionType | untypedFunctionType | simpleType) typedFunctionType+ | untypedFunctionType
left typedFunctionType ::= <<functionId>> typeParameters? parameterTypeList '?'?

voidTypeFunctionType ::= 'void'
simpleType ::= simpleQualifiedReferenceExpression typeArguments? '?'?

typeArguments ::= '<' typeList '>'
typeList ::= type? (',' type)*

block ::= '{' statements '}' {extraRoot=true pin=1 implements="com.jetbrains.lang.dart.psi.IDartBlock"}

statements ::= statement* {implements="com.jetbrains.lang.dart.psi.DartExecutionScope"}
private statement ::= label* nonLabelledStatement

private nonLabelledStatement ::= block // Guard to break tie with map literal.
                               | functionDeclarationWithBody
                               | forStatement
                               | whileStatement
                               | doWhileStatement
                               | switchStatement
                               | ifStatement
                               | rethrowStatement
                               | tryStatement
                               | breakStatement
                               | continueStatement
                               | returnStatement
                               | assertStatementWithSemicolon
                               | statementFollowedBySemiColon
                               | yieldEachStatement
                               | yieldStatement
                               | ';'
                               | '=>' // for better recovery
private statementFollowedBySemiColon ::= (varDeclarationList | expression) ';' {pin=1}

label::= componentName ':'
{
  mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl"
  implements="com.jetbrains.lang.dart.psi.DartComponent"
  methods = [getMetadataList]
}

private expressionWithRecoverUntilParen ::= expression {recoverWhile="not_paren_recover"}
private expressionWithRecoverUntilParenOrComma ::= expression {recoverWhile="not_paren_or_comma_recover"}
private not_paren_recover ::= !')'
private not_paren_or_comma_recover ::= !(')' | ',')

whileStatement ::= 'while' '(' expressionWithRecoverUntilParen ')' statement {pin=1}
doWhileStatement ::= 'do' statement 'while' '(' expressionWithRecoverUntilParen ')' ';' {pin=1}
forStatement ::= 'await'? 'for' forLoopPartsInBraces statement {pin=2}
//todo component
private assertStatementWithSemicolon ::= assertStatement ';' {pin=1}
assertStatement ::= 'assert' '(' expressionWithRecoverUntilParenOrComma (',' expressionWithRecoverUntilParenOrComma)? ','? ')' {pin=1}
yieldEachStatement ::= 'yield' '*' expression ';' {pin=2}
yieldStatement ::= 'yield' expression ';' {pin=1}
breakStatement ::= 'break' referenceExpression? ';' {pin=1}
continueStatement ::= 'continue' referenceExpression? ';' {pin=1}
returnStatement ::= 'return' expression? ';' {pin=1}
rethrowStatement ::= 'rethrow' ';' {pin=1}

forLoopPartsInBraces::= '(' forLoopParts ')'
forLoopParts::= forInPart
              | varDeclarationList (';' expression? (';' expressionList?)?)?
              | expressionList? (';' expression? (';' expressionList?)?)?
              {recoverWhile="for_loops_parts_recover"}

forInPart ::= (varAccessDeclaration | componentName) 'in' expression

private for_loops_parts_recover ::= !')'

ifStatement ::= 'if' '(' expressionWithRecoverUntilParen ')' statement ('else' statement)?  {pin=1}
switchStatement ::= 'switch' '(' expressionWithRecoverUntilParen ')' '{' switchCase* defaultCase? '}' {pin=1}

switchCase ::= label* 'case' expression ':' statements {pin=2}
defaultCase::= label* 'default' ':' statements {pin = 2}

tryStatement ::= 'try' block (onPart+ finallyPart? | finallyPart) {pin=1}
onPart ::= catchPart block | 'on' type catchPart? block {pin=1}
catchPart ::= 'catch' '(' componentName (',' componentName)? ')' {pin=1}
finallyPart::= 'finally' block {pin=1}

varInit ::= '=' expression {pin=1}

expressionList ::= expression (','? expression)*
arguments ::= '(' argumentList? ')'

argumentList ::= argumentListPart (',' argumentListPart)* ','? {recoverWhile="argument_list_recover"}
private argument_list_recover ::= !(')')
private argumentListPart ::= namedArgument | expression {recoverWhile="argument_list_part_recover"}
private argument_list_part_recover ::= !(')' | ',')

namedArgument ::= parameterNameReferenceExpression ':' expression {
  methods = [
    getParameterReferenceExpression
    getExpression
  ]
}

parameterNameReferenceExpression ::= << nonStrictID >>
{mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

expression ::= assignExpressionWrapper {recoverWhile="expression_recover"}
private expression_recover ::= !(<<nonStrictID>> | <<parenthesizedExpressionWrapper>> | '!' | '!=' | '%' | '%=' |
                                 '&&' | '&&=' | '&' | '&=' | '(' | ')' | '*' | '*=' | '+' | '++' | '+=' | ',' | '-' | '--' | '-=' | '.' | '..' | '?..' | '...' | '...?' | '/' |
                                 '/=' | ':' | ';' | '<' | '<<' | '<<=' | '<=' | '=' | '==' | '=>' | '>' | <<gtGt>> | <<gtEq>> | <<gtGtEq>> |
                                 '@' | '[' | ']' | '^' | '^=' | '?.' | '??=' | '??' | '?' |
                                 'abstract' | 'as' | 'assert' | 'async' | 'break' | 'case' | 'catch' | 'class' | 'const' |
                                 'continue' | 'default' | 'deferred' | 'do' | 'else' | 'export' | 'external' | 'factory' | 'final' | 'finally' | 'for' |
                                 'get' | 'hide' | 'if' | 'import' | 'is' | 'library' | 'native' | 'new' | 'on' | 'operator' | 'part' |
                                 'rethrow' | 'return' | 'set' | 'show' | 'static' | 'super' | 'switch' | 'sync' | 'this' | 'throw' | 'try' |
                                 'typedef' | 'var' | 'void' | 'while' | '{' | '|' | '|=' | '||' | '||=' | '}' | '~' | '~/' | '~/=' | CLOSING_QUOTE |
                                  FALSE | HEX_NUMBER | LONG_TEMPLATE_ENTRY_END | LONG_TEMPLATE_ENTRY_START | NULL | NUMBER |
                                  OPEN_QUOTE | RAW_SINGLE_QUOTED_STRING | RAW_TRIPLE_QUOTED_STRING | REGULAR_STRING_PART |
                                  SHORT_TEMPLATE_ENTRY_START | TRUE)

private assignExpressionWrapper ::= ternaryExpressionWrapper assignExpression*
left assignExpression ::= assignmentOperator ternaryExpressionWrapper {pin=1} // todo right associate

private ternaryExpressionWrapper ::= ifNullExpressionWrapper ternaryExpression?
left ternaryExpression ::= '?' expression ':' ternaryExpressionWrapper {pin=1}

private ifNullExpressionWrapper ::= logicOrExpressionWrapper ifNullExpression*
left ifNullExpression ::= '??' logicOrExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private logicOrExpressionWrapper ::= logicAndExpressionWrapper logicOrExpression*
left logicOrExpression ::= '||' logicAndExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private logicAndExpressionWrapper ::= compareExpressionWrapper logicAndExpression*
left logicAndExpression ::= '&&' compareExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private compareExpressionWrapper ::= bitwiseExpressionWrapper compareExpression*
left compareExpression ::= (relationalOperator | equalityOperator) bitwiseExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private bitwiseExpressionWrapper ::= shiftExpressionWrapper bitwiseExpression*
left bitwiseExpression ::= bitwiseOperator shiftExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private shiftExpressionWrapper ::= additiveExpressionWrapper shiftExpression*
left shiftExpression ::= shiftOperator additiveExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private additiveExpressionWrapper ::= multiplicativeExpressionWrapper additiveExpression*
left additiveExpression ::= additiveOperator multiplicativeExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private multiplicativeExpressionWrapper ::= prefixExpression multiplicativeExpression*
left multiplicativeExpression ::= multiplicativeOperator prefixExpression
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

prefixExpression ::= (prefixOperator prefixExpression) | awaitExpression | suffixExpressionWrapper
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}
prefixOperator ::= '-' | '+' | '--' | '++' | '!' | '~'

awaitExpression ::= <<isInsideSyncOrAsyncFunction>> 'await' prefixExpression
{mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private suffixExpressionWrapper ::= valueExpression suffixExpression*
left suffixExpression ::= ('--' | '++')
{mixin="com.jetbrains.lang.dart.psi.impl.DartOperatorExpressionImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

valueExpression ::= primary callOrArrayAccessOrQualifiedRefExpression (isExpression | asExpression)? cascadeReferenceExpression*
left isExpression ::= 'is' '!'? type
left asExpression ::= 'as' type
{mixin="com.jetbrains.lang.dart.psi.impl.DartClassReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private primary ::=  literalExpression |
                     functionExpression |
                     newExpression | // constant object expression is also parsed as newExpression
                     refOrThisOrSuperOrParenExpression |
                     throwExpression

parenthesizedExpression ::= '(' expressionInParentheses ')'
{pin=1 mixin="com.jetbrains.lang.dart.psi.impl.DartClassReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}
private expressionInParentheses ::= expression | statement {recoverWhile=parenthesesRecovery}
private parenthesesRecovery ::= !')'

private callOrArrayAccessOrQualifiedRefExpression ::= (callExpression | arrayAccessExpression | qualifiedReferenceExpression | '!')*

private refOrThisOrSuperOrParenExpression ::= (referenceExpression | thisExpression | superExpression | << parenthesizedExpressionWrapper >>)

left callExpression ::= typeArguments? <<argumentsWrapper>>
{mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference" methods = [getArguments]}
left arrayAccessExpression ::= arrayAccess
{mixin="com.jetbrains.lang.dart.psi.impl.DartClassReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private arrayAccess ::= '?.'? '[' expression? ']' {pin=2}

libraryComponentReferenceExpression ::= << nonStrictID >>
{mixin="com.jetbrains.lang.dart.psi.impl.DartLibraryComponentReferenceExpressionBase" implements="com.jetbrains.lang.dart.psi.DartReference"}

referenceExpression ::= << nonStrictID >>
{mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

left qualifiedReferenceExpression ::= '.' referenceExpression | '?.' referenceExpression {elementType="referenceExpression"}
cascadeReferenceExpression ::= ('?..' | '..') << cascadeStopper >> (arrayAccess | refOrThisOrSuperOrParenExpression callOrArrayAccessOrQualifiedRefExpression) << varInitWrapper >>
{mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

simpleQualifiedReferenceExpression ::= referenceExpression qualifiedReferenceExpression* {elementType="referenceExpression"}

thisExpression ::= 'this'
{mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}
superExpression ::= 'super'
{mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

newExpression ::= newExpressionWithKeyword | simpleQualifiedReferenceExpression typeArguments '.' referenceExpression <<argumentsWrapper>> {
  mixin="com.jetbrains.lang.dart.psi.impl.DartReferenceImpl"
  implements="com.jetbrains.lang.dart.psi.DartReference"
  methods=[isConstantObjectExpression getArguments]
}

private newExpressionWithKeyword ::= ('new' | 'const') type ('.' referenceExpression)? <<argumentsWrapper>> { pin=1 }

throwExpression ::= 'throw' expression

// todo get rid of all Wrappers and WITHOUT_CASCADE user data, implement expression parsing according to the spec and Grammar-Kit docs
literalExpression ::= NULL | TRUE | FALSE | NUMBER | HEX_NUMBER | stringLiteralExpression | symbolLiteralExpression | <<setOrMapLiteralExpressionWrapper>> | <<listLiteralExpressionWrapper>>
{mixin="com.jetbrains.lang.dart.psi.impl.DartClassReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

symbolLiteralExpression ::= '#' ('void' | userDefinableOperator | simpleQualifiedReferenceExpression) {pin=1}

stringLiteralExpression ::= (RAW_SINGLE_QUOTED_STRING | RAW_TRIPLE_QUOTED_STRING | stringTemplate)+
{mixin="com.jetbrains.lang.dart.psi.impl.DartStringLiteralExpressionBase" implements="com.jetbrains.lang.dart.psi.DartReference, com.intellij.psi.PsiLanguageInjectionHost"}

private stringTemplate ::= OPEN_QUOTE (REGULAR_STRING_PART | shortTemplateEntry | longTemplateEntry)* CLOSING_QUOTE {pin=1}
shortTemplateEntry ::= SHORT_TEMPLATE_ENTRY_START (thisExpression | referenceExpression) {pin=1}
longTemplateEntry ::= LONG_TEMPLATE_ENTRY_START expression LONG_TEMPLATE_ENTRY_END {pin=1}

listLiteralExpression ::= 'const'? typeArguments? '[' elements? ']'
{mixin="com.jetbrains.lang.dart.psi.impl.DartClassReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}
setOrMapLiteralExpression ::= 'const'? typeArguments? '{' elements? '}'
{mixin="com.jetbrains.lang.dart.psi.impl.DartClassReferenceImpl" implements="com.jetbrains.lang.dart.psi.DartReference"}

private elements ::= element (','? element)* ','? ;
element ::= spreadElement | ifElement | forElement | mapEntry | expression

mapEntry ::= expression ':' expression {pin=2};
spreadElement ::= ('...' | '...?') expression {pin=1};
ifElement ::= 'if' '(' expressionWithRecoverUntilParen ')' element ('else' element)? {pin = 1};
forElement ::= 'await'? 'for' '(' forLoopParts ')' element {pin=2};

functionExpression ::= typeParameters? formalParameterList functionExpressionBody
{mixin="com.jetbrains.lang.dart.psi.impl.DartFunctionExpressionBase"}
functionDeclarationWithBodyOrNative ::= metadata* 'external'? (returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList) ( ';' | functionBodyOrNative)
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}
functionDeclarationWithBody ::= metadata*  (returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList) functionBody // todo merge with functionDeclarationWithBodyOrNative
{mixin="com.jetbrains.lang.dart.psi.impl.AbstractDartComponentImpl" implements="com.jetbrains.lang.dart.psi.DartComponent"}

functionBody ::= arrowBodyWithSemi | <<blockBodyWrapper>> {methods=[getBlock]}
private arrowBodyWithSemi ::= <<arrowBodyWrapper>> ';' {pin=1}
functionExpressionBody ::= <<arrowBodyWrapper>> | <<blockBodyWrapper>>

//functionBody ::= arrowBodyWithSemi | blockBody {methods=[getBlock]}
//private arrowBodyWithSemi ::= arrowBody ';' {pin=1}
//functionExpressionBody ::= arrowBody | blockBody

private arrowBody ::= ('async' '*'? | 'sync' '*'?)? '=>' expression {pin=2}
private blockBody ::= ('async' '*'? | 'sync' '*'?)? lazyParseableBlock
private lazyParseableBlock ::= <<lazyParseableBlockImpl>>