grammar.ungram

// Our BNF syntax used in the specification below works as follows:
// 
// foo ::= bar baz
// Foo derives bar followed by baz.
// 
// foo ::= bar | baz
// Foo derives either bar or baz.
// 
// bar ::= baz*
// Bar derives a sequence of zero or more baz.
// 
// bar ::= baz+
// Bar derives a sequence of one or more baz.
// 
// bar ::= foo? baz?
// Bar derives optional foo followed by optional baz.
// 
// bar ::= baz%","+
// Bar derives a sequence of one or more baz where consecutive baz"s are separated by a comma
// without a trailing comma.
//
// baz ::= ()
// Baz has a nulling rule (derives an epsilon string).
// 
// foo ::= &(bar baz)
// Foo makes a zero-width assertion that bar and baz are present ahead.
// 
// foo ::= !(bar baz)
// Foo makes a zero-width assertion that bar and baz are NOT present ahead.
//
// #start foo
// Declare start symbol.
//
// /\w+/ -> ident
// Declare regexp token calle.
SourceFile = Program
Program =
  Module

Module =
  TopLevelStatement*

TopLevelStatement =
  FunctionDefinitionForbidSelf
                      | StructDefinition
                      | Implementation
                      | Submodule
                      | ModuleDeclaration
                      | UseStatement
                      | GlobalDeclaration

GlobalDeclaration =
  'global' Ident GlobalTypeAnnotation '=' Literal ';'

Submodule =
  'mod' Ident '{' Module '}'

Contract =
  'contract' Ident '{' Module '}'

FunctionDefinitionAllowSelf =
  Attribute? FunctionModifiers 'fn' Ident Generics '(' FunctionParametersAllowSelf ')' FunctionReturnType Block
FunctionDefinitionForbidSelf =
  Attribute? FunctionModifiers 'fn' Ident Generics '(' FunctionParametersForbidSelf ')' FunctionReturnType Block

FunctionModifiers =
  'unconstrained'? 'open'?

Generics =
  ('<' (Ident ',')* Ident '>')?

StructDefinition =
  'struct' Ident Generics '{' StructFields '}'

LambdaReturnType =
  ('->' Type)?

FunctionReturnType =
  ('->' OptionalVisibility Type)?

Attribute =
  '#[' ('foreign(' AsciiAlpha AsciiAlpha* ')' | 'builtin(' AsciiAlpha AsciiAlpha* ')' | 'oracle(' AsciiAlpha AsciiAlpha* ')' | 'test') ']'

StructFields =
  ((Ident ':' Type) ',')* ((Ident ':' Type) ','?)?

LambdaParameters =
  ((Pattern ',')* Pattern)?

FunctionParametersForbidSelf =
  ((Pattern ':' OptionalVisibility Type) ',')* ((Pattern ':' OptionalVisibility Type) ','?)?
FunctionParametersAllowSelf =
  ((SelfParameter | Pattern ':' OptionalVisibility Type) ',')* ((SelfParameter | Pattern ':' OptionalVisibility Type) ','?)?

SelfParameter =
  'self'

Implementation =
  'impl' Generics Type '{' FunctionDefinitionAllowSelf* '}'

Block =
  '{' StatementNotLast* Expression? '}'

GlobalTypeAnnotation =
  (':' Type)?

OptionalTypeAnnotation =
  (':' Type)?

ModuleDeclaration =
  ModKeyword Ident ';'
ModKeyword =
  'mod' Whitespace

UseStatement =
  'use' Whitespace Path (Whitespace 'as' Ident)? ';'

Path =
  'crate' '::' Idents | 'dep' '::' Idents | Idents
Idents =
  (Ident '::')* Ident

Ident =
  (AsciiAlpha | '_') (AsciiAlphanumeric | '_')*

StatementNotLast =
  Declaration ';' | Assignment ';' | Expression ';' | ExpressionNotSemi

// "constrain" is deprecated
// constrain ::= "constrain" expression

Declaration =
  LetKeyword Pattern OptionalTypeAnnotation '=' Expression

LetKeyword =
  'let' Whitespace

Pattern =
  'mut' Pattern
          | '(' ((Pattern ',')* Pattern)? ')'
          | Path '{' (((Ident | Ident ':' Pattern) ',')* (Ident | Ident ':' Pattern))? '}'
          | Ident

Assignment =
  Lvalue AssignOperator Expression

AssignOperator =
  ('+' | '-' | '*' | '/' | '%' | '&' | '^' | '<<' | '>>' | '|' | '') '='

Lvalue =
  Ident ('.' (Ident | LvalueInteger) | '[' Expression ']')*
LvalueInteger =
  (Nonzero AsciiDigit* | '0')

Type =
  TypeInner
TypeInner =
  IntType | FunctionType | VecType | FieldType | BoolType
               | StringType | NamedType | ArrayType
               | TupleType

OptionalVisibility =
  'pub'?

// DEPRECATED
// maybe_comp_time ::= "comptime"?

FieldType =
  'Field'

BoolType =
  'bool'

StringType =
  'str' ('<' (Variable | Integer) '>')?

IntType =
  IntTypeToken

IntTypeToken =
  'u' AsciiDigit AsciiDigit?

NamedType =
  Path GenericTypeArgs

VecType =
  'Vec' GenericTypeArgs

GenericTypeArgs =
  ('<' ((Type | TypeExpression) ',')* (Type | TypeExpression) ','? '>')?

ArrayType =
  '[' Type (';' (Variable | Integer))? ']'

TupleType =
  '(' ((Type ',')* Type ','?)? ')'

FunctionType =
  'fn' '(' ((Type ',')* Type ','?)? ')' '->' Type

////////////////////////////////////////////////////////////////////////////////

/// type_expression ::= expression_with_precedence(lowest_type_precedence, type_expression, true)

/// expression ::= expression_with_precedence(Lowest, expression, false)

/// expression_with_precedence(Highest, ExprParser, true) ::= type_expression_term
/// expression_with_precedence(Highest, ExprParser, false) ::= term
/// expression_with_precedence(precedence, ExprParser, true) ::= expression_with_precedence(precedence.next_type_precedence(), ExprParser, true)
///                                                              (
///                                                                 operator_with_precedence(precedence)
///                                                                 expression_with_precedence(precedence.next_type_precedence(), ExprParser, true)
///                                                              )*
/// expression_with_precedence(precedence, ExprParser, false) ::= expression_with_precedence(precedence.next(), ExprParser, false)
///                                                              (
///                                                                 operator_with_precedence(precedence)
///                                                                 expression_with_precedence(precedence.next(), ExprParser, false)
///                                                              )*

/// EQUIVALENT TO:

Expression =
  Term (Operator Term)*
ExpressionNoConstructors =
  TermNoConstructors (Operator TermNoConstructors)*
ExpressionNotSemi =
  IfExpr | Block
Operator =
  '==' | '!=' | '|' | '^' | '&' | '<<' | '>>' | '<=' | '>=' | '<' | '>' | ' ' | '*' | '-' | '/' | '*' | '%'

TypeExpression =
  TypeExpressionTerm (TypeOperator TypeExpressionTerm)*
TypeOperator =
  '+' | '-' | '/' | '*' | '%'

TypeExpressionTerm =
  NegationInTypeExpression | TypeExpressionAtom

////////////////////////////////////////////////////////////////////////////////

Term =
  Not | Negation | AtomOrRightUnary
TermNoConstructors =
  NotNoConstructors | NegationNoConstructors | AtomOrRightUnaryNoConstructors

AtomOrRightUnary =
  Atom (CallRhs | ArrayRhs | CastRhs | MemberRhs)*
AtomOrRightUnaryNoConstructors =
  AtomNoConstructors (CallRhs | ArrayRhs | CastRhs | MemberRhs)*
CallRhs =
  '(' ExpressionList ')'
ArrayRhs =
  '[' Expression ']'
CastRhs =
  Whitespace 'as' Whitespace Type
MemberRhs =
  '.' FieldName ('(' ExpressionList ')')?

IfExpr =
  'if' Whitespace ExpressionNoConstructors Block ('else' (Block | IfExpr))? 

Lambda =
  '|' LambdaParameters '|' LambdaReturnType Expression

ForExpr =
  ForKeyword Ident InKeyword ForRange Block
ForKeyword =
  'for' Whitespace
InKeyword =
  'in' Whitespace

ForRange =
  ExpressionNoConstructors '..' ExpressionNoConstructors | ExpressionNoConstructors

ArrayExpr =
  StandardArray | ArraySugar

StandardArray =
  '[' (Expression ',')* (Expression ','?)? ']'

ArraySugar =
  '[' Expression ';' Expression ']' 

ExpressionList =
  ((Expression ',')* Expression ','?)?

Not =
  '!' Term
NotNoConstructors =
  '!' TermNoConstructors

Negation =
  '-' Term
NegationNoConstructors =
  '-' TermNoConstructors
NegationInTypeExpression =
  '-' TypeExpressionTerm

Atom =
  Tuple | IfExpr | ArrayExpr | Constructor | Lambda | Block | Variable | Literal
AtomNoConstructors =
  Tuple | IfExpr | ArrayExpr | Lambda | Block | Variable | Literal

TypeExpressionAtom =
  Variable | TypeLiteral | '(' TypeExpression ')'

Tuple =
  '(' ExpressionList ')'

FieldName =
  Ident | Integer

// lexer allows only even number of digits for hex
Integer =
  '0x' '00'* (Hex Hex)* | Nonzero AsciiDigit* | '0'

Nonzero =
  '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'

Hex =
  AsciiDigit | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'

Constructor =
  Path '{' (ConstructorField ',')* (ConstructorField ','?)? '}'

ConstructorField =
  Ident (':' Expression)?

Variable =
  Path

Literal =
  Integer | Bool | Str

TypeLiteral =
  Integer

LiteralOrCollection =
  Literal | Constructor | ArrayExpr

Bool =
  'true' | 'false'

Str = 'string'
AsciiDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
AsciiAlpha = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'w' | 'x' | 'y' | 'z' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'W' | 'X' | 'Y' | 'Z'
AsciiAlphanumeric = AsciiDigit | AsciiAlpha

Whitespace =
  ' '