Notation

This section informally explains the grammar notation used below.

Symbols and naming

Terminal symbol names start with an uppercase letter, e.g. SimpleName.
Nonterminal symbol names start with lowercase letter, e.g. kotlinFile.
Each production starts with a colon (:).
Symbol definitions may have many productions and are terminated by a semicolon (;).
Symbol definitions may be prepended with attributes, e.g. start attribute denotes a start symbol.

EBNF expressions

Operator | denotes alternative.
Operator * denotes iteration (zero or more).
Operator + denotes iteration (one or more).
Operator ? denotes option (zero or one).
alpha{beta} denotes a nonempty beta-separated list of alpha's.
Operator ++ means that no space or comment allowed between operands.

Semicolons

Kotlin provides "semicolon inference": syntactically, subsentences (e.g., statements, declarations etc) are separated by the pseudo-token SEMI, which stands for "semicolon or newline". In most cases, there's no need for semicolons in Kotlin code.

Syntax

Relevant pages: Packages

start
kotlinFile: preamble topLevelObject*
;
start
script: preamble expression*
;

packageHeader

(used by preamble): modifiers "package" SimpleName{ "."} SEMI?
;

See Packages

import

(used by preamble): "import" SimpleName{ "."} ("." "*" | "as" SimpleName)? SEMI?
;

See Imports

topLevelObject

(used by kotlinFile): class; object; function; property; typeAlias
;

typeAlias

(used by memberDeclaration, declaration, topLevelObject): modifiers "typealias" SimpleName typeParameters? "=" type
;

Classes

See Classes and Inheritance

class

(used by memberDeclaration, declaration, topLevelObject): modifiers ("class" | "interface") SimpleName
typeParameters?
primaryConstructor?
(":" annotations delegationSpecifier{ ","})?
typeConstraints
(classBody? | enumClassBody)
;

primaryConstructor

(used by class, object): (modifiers "constructor")? ("(" functionParameter{ ","} ")")
;

classBody

(used by objectLiteral, enumEntry, class, companionObject, object): ("{" members "}")?
;

members

(used by enumClassBody, classBody): memberDeclaration*
;

delegationSpecifier

(used by objectLiteral, class, companionObject, object): constructorInvocation; userType; explicitDelegation
;

explicitDelegation

(used by delegationSpecifier): userType "by" expression
;

typeParameters

(used by typeAlias, class, property, function): "<" typeParameter{ ","} ">"
;

typeParameter

(used by typeParameters): modifiers SimpleName (":" userType)?
;

See Generic classes

typeConstraints

(used by class, property, function): ("where" typeConstraint{ ","})?
;

typeConstraint

(used by typeConstraints): annotations SimpleName ":" type
;

See Generic constraints

Class members

memberDeclaration

(used by members): companionObject; object; function; property; class; typeAlias; anonymousInitializer; secondaryConstructor
;

anonymousInitializer

(used by memberDeclaration): "init" block
;

companionObject

(used by memberDeclaration): modifiers "companion" "object" SimpleName? (":" delegationSpecifier{ ","})? classBody?
;

valueParameters

(used by secondaryConstructor, function): "(" functionParameter{ ","}? ")"
;

functionParameter

(used by valueParameters, primaryConstructor): modifiers ("val" | "var")? parameter ("=" expression)?
;

block

(used by catchBlock, anonymousInitializer, secondaryConstructor, functionBody, controlStructureBody, try, finallyBlock): "{" statements "}"
;

function

(used by memberDeclaration, declaration, topLevelObject): modifiers "fun"
typeParameters?
(type ".")?
SimpleName
typeParameters? valueParameters (":" type)?
typeConstraints
functionBody?
;

functionBody

(used by getter, setter, function): block; "=" expression
;

variableDeclarationEntry

(used by for, lambdaParameter, property, multipleVariableDeclarations): SimpleName (":" type)?
;

multipleVariableDeclarations

(used by for, lambdaParameter, property): "(" variableDeclarationEntry{ ","} ")"
;

property

(used by memberDeclaration, declaration, topLevelObject): modifiers ("val" | "var")
typeParameters?
(type ".")?
(multipleVariableDeclarations | variableDeclarationEntry)
typeConstraints
("by" | "=" expression SEMI?)?
(getter? setter? | setter? getter?) SEMI?
;

See Properties and Fields

getter

(used by property): modifiers "get"; modifiers "get" "(" ")" (":" type)? functionBody
;

setter

(used by property): modifiers "set"; modifiers "set" "(" modifiers (SimpleName | parameter) ")" functionBody
;

parameter

(used by functionType, setter, functionParameter): SimpleName ":" type
;

object

(used by memberDeclaration, declaration, topLevelObject): "object" SimpleName primaryConstructor? (":" delegationSpecifier{ ","})? classBody?

secondaryConstructor

(used by memberDeclaration): modifiers "constructor" valueParameters (":" constructorDelegationCall)? block
;

constructorDelegationCall

(used by secondaryConstructor): "this" valueArguments; "super" valueArguments
;

See Object expressions and Declarations

Enum classes

See Enum classes

enumClassBody

(used by class): "{" enumEntries (";" members)? "}"
;

enumEntries

(used by enumClassBody): (enumEntry{ ","} ","? ";"?)?
;

enumEntry

(used by enumEntries): modifiers SimpleName ("(" arguments ")")? classBody?
;

Types

See Types

type

(used by namedInfix, simpleUserType, getter, atomicExpression, whenCondition, property, typeArguments, function, typeAlias, parameter, functionType, variableDeclarationEntry, lambdaParameter, typeConstraint): typeModifiers typeReference
;

typeReference

(used by typeReference, nullableType, type): "(" typeReference ")"; functionType; userType; nullableType; "dynamic"
;

nullableType

(used by typeReference): typeReference "?"
;

userType

(used by typeParameter, catchBlock, callableReference, typeReference, delegationSpecifier, constructorInvocation, explicitDelegation): simpleUserType{ "."}
;

simpleUserType

(used by userType): SimpleName ("<" (optionalProjection type | "*"){ ","} ">")?
;

optionalProjection

(used by simpleUserType): varianceAnnotation
;

functionType

(used by typeReference): (type ".")? "(" parameter{ ","}? ")" "->" type?
;

Control structures

See Control structures

controlStructureBody

(used by whenEntry, for, if, doWhile, while): block; blockLevelExpression
;

if

(used by atomicExpression): "if" "(" expression ")" controlStructureBody SEMI? ("else" controlStructureBody)?
;

try

(used by atomicExpression): "try" block catchBlock* finallyBlock?
;

catchBlock

(used by try): "catch" "(" annotations SimpleName ":" userType ")" block
;

finallyBlock

(used by try): "finally" block
;

loop

(used by atomicExpression): for; while; doWhile
;

for

(used by loop): "for" "(" annotations (multipleVariableDeclarations | variableDeclarationEntry) "in" expression ")" controlStructureBody
;

while

(used by loop): "while" "(" expression ")" controlStructureBody
;

doWhile

(used by loop): "do" controlStructureBody "while" "(" expression ")"
;

Expressions

Precedence

Precedence	Title	Symbols
Highest	Postfix	`++`, `--`, `.`, `?.`, `?`
Prefix	`-`, `+`, `++`, `--`, `!`, `labelDefinition@`
Type RHS	`:`, `as`, `as?`
Multiplicative	`*`, `/`, `%`
Additive	`+`, `-`
Range	`..`
Infix function	`SimpleName`
Elvis	`?:`
Named checks	`in`, `!in`, `is`, `!is`
Comparison	`<`, `>`, `<=`, `>=`
Equality	`==`, `\!==`
Conjunction	`&&`
Disjunction	`\|\|`
Lowest	Assignment	`=`, `+=`, `-=`, `*=`, `/=`, `%=`