Chapter 1
Language Foundations

Dart's expressive power is rooted in its thoughtfully designed foundations. This chapter unveils the building blocks of Dart-helping you unlock the nuances of its syntax, the flexibility of its type system, and the practical conventions that shape robust, modern code. Whether you're decoding Dart's grammar or mastering its approach to null safety, you'll find the insights needed to write clear, correct, and future-proof applications.

1.1 Lexical Structure and Syntax

Dart's lexical structure and syntax establish the foundational rules that govern the formulation and interpretation of source code. Mastery of these rules is critical for precise code composition, effective parsing, and syntactical correctness. The design of Dart's lexical grammar ensures both expressive power and syntactic clarity, facilitating readability and minimizing ambiguities during compilation or interpretation.

Dart source code conforms to the Unicode character set, supporting a comprehensive range of characters beyond the ASCII subset. This universality allows Dart to accommodate identifiers and literals containing international characters. The source files are expected to be UTF-8 encoded, which is compatible with Unicode and widely adopted.

The core character subsets used in Dart lexical elements include:

• Letters: Characters from a to z, A to Z, which are foundational for identifiers and keywords.
• Digits: Characters 0 to 9, utilized in numeric literals and identifiers when not at the start.
• Special characters: Including symbols such as underscores (_), dollar signs ($), and punctuation marks that delimit expressions.
• Whitespace: White space characters (spaces, tabs, line terminators) which separate meaningful tokens.

Dart source code consists of a sequence of tokens, which are the smallest elements meaningful to the compiler. The major classes of tokens are:

• Keywords: Reserved words with fixed syntactic significance.
• Identifiers: Names chosen by programmers for variables, functions, classes, etc.
• Literals: Fixed values such as numbers, strings, booleans, and null.
• Operators and Punctuation: Symbols denoting operations, delimiters, and separators.

As detailed below, understanding how these tokens are constructed and recognized is vital for reading and generating correct Dart code.

Dart defines a set of reserved keywords that possess specific meanings and cannot be repurposed as identifiers. These keywords frame the syntactic structure by indicating data types, control flow constructs, modifiers, and other language features. The complete set includes:

abstract, as, assert, async, await, break, case, catch, class, const, continu
e,
covariant, default, deferred, do, dynamic, else, enum, export, extends, exten
sion,
external, factory, false, final, finally, for, function, get, hide, if, imple
ments,
import, in, inferface, is, late, library, mixin, new, null, on, operator, par
t,
patch, required, rethrow, return, set, show, static, super, switch, sync, thi
s,
throw, true, try, typedef, var, void, while, with, yield, and others introduc
ed
in later Dart versions.
 

These keywords anchor the grammar and are distinct from identifiers by lexical analysis. Any attempt to use a reserved keyword as an identifier results in a syntax error.

Identifiers in Dart represent names given to variables, functions, classes, parameters, and other user-defined entities. They must adhere to strict lexical rules:

• The first character must be a letter (Unicode letter) or an underscore (_).
• Subsequent characters may be letters, digits, or underscores.
• Identifiers are case-sensitive; for example, Data and data are different.
• Identifiers may not be a reserved keyword.
• Dart supports Unicode in identifiers, enabling usage of non-ASCII characters so long as they conform to Unicode letter classes.

Examples of valid identifiers:

name
_totalCount
variable1
Value

Invalid identifiers include those starting with digits, containing spaces or hyphens, or coinciding with reserved keywords.

Whitespace characters separate tokens without producing semantic effects but play a vital role in enhancing readability and separating lexical units. Dart treats the following as whitespace:

• Space (U+0020), horizontal tab (U+0009).
• Newline characters: line feed (U+000A), carriage return (U+000D), form feed (U+000C), line separator (U+2028), paragraph separator (U+2029).

Multiple whitespace characters are treated equivalently to a single separator in token parsing. Crucially, whitespace cannot appear within tokens such as identifiers or keywords.

Comments provide annotation and are ignored by the compiler:

• Single-line comments start with // and extend to the end of the line.
• Multi-line comments are enclosed between /* and */, supporting nested occurrences.
• Documentation comments utilize /// for single-line or /** ... */ for multi-line, which tools may parse for API generation.

Punctuation characters break code into logical segments and influence parsing. These include:

• ; (semicolon): Terminates statements.
• , (comma): Separates items in lists, function parameters, expressions.
• . (period): Member access and decimal point in numeric literals.
• () (parentheses): Grouping expressions, calling functions.
• {} (braces): Encapsulate blocks of code or map literals.
• [] (brackets): Array (List) indexing, type arguments.
• => (fat arrow): Shorthand for single-expression functions.

Accurate use of punctuation is critical for unambiguous code structure, distinguishing syntactic constructs such as statement boundaries, argument lists, and block scopes.

Consider defining a simple function:

int sum(int a, int b) {
return a + b;
}

Lexically, this breaks down as:

• int: keyword token indicating return type.
• sum: identifier naming the function.
• (: punctuation starting a parameter list.
• int: keyword indicating parameter type.
• a: identifier parameter name.
• ,: separator between parameters.
• int: keyword for second parameter type.
• b: identifier.
• ): end of parameter list.
• {: start of function body (block).
• return: keyword.
• a: identifier.
• +: operator symbol.
• b: identifier.
• ;: statement terminator.
• }: end of block.

Whitespace separates identifiers and keywords but is otherwise insignificant between tokens.

The combination of Unicode support, stringent token definitions, and the reserved keyword list allows Dart source code to be both flexible and precisely definable. The lexer's role is pivotal, converting raw characters into tokens based on the defined character sets and delimiter rules. Syntax analysis then assembles these tokens into valid parse trees.

The careful delineation of whitespace and punctuation aids clear token boundaries. Identifiers' lexical constraints guarantee well-formed...