This specification defines the syntax and semantics of Jet, a multi-purpose scripting language influenced by ActionScript 3.

A conforming implementation of Jet shall provide support for all the mandatory types, values, objects, properties, functions, and program syntax and semantics described in this specification.

A conforming implementation of this specification shall interpret characters in conformance with the Unicode Standard, Version 2.1 or later.

A conforming implementation of Jet may provide additional types, values, objects, properties, and functions beyond those described in this specification.

Document Object Model (DOM) Level 2 Specifications, W3C Recommendation, 13 November 2000.

ECMA-262, 1999, ECMAScript Language Specification – 3rd edition.

Extensible Markup Language 1.0 (Second Edition), W3C Recommendation 6 October 2000.

Namespaces in XML, W3C Recommendation, 14 January 1999.

ISO/IEC 10646:2003, Information Technology – Universal Multiple-Octet Coded Character Set (UCS).

Unicode Inc. (1996), The Unicode StandardTM, Version 2.0. ISBN: 0-201-48345-9, Addison-Wesley Publishing Co., Menlo Park, California.

Unicode Inc. (1998), Unicode Technical Report #8: The Unicode StandardTM, Version 2.1.

Unicode Inc. (1998), Unicode Technical Report #15: Unicode Normalization Forms.

XML Information Set, W3C Recommendation 24 October 2001.

XML Path Language (XPath) Version 1.0, W3C Recommendation 16 November 1999.

XML Schema Part 1: Structures, W3C Recommendation, 2 May 2001.

XML Schema Part 2: Datatypes, W3C Recommendation, 2 May 2001.

SemVer, Semantic Versioning 2.0.0 (https://semver.org).

JSON (JavaScript Object Notation) (https://json.org).

Language Server Protocol Specification 3.17 (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification).

CommonMark Specification (https://spec.commonmark.org).

XSL Transformations (XSLT), W3C Recommendation 16 November 1999.

This section contains a non-normative overview of the Jet language.

Jet is an object-oriented programming language for performing computations and manipulating computational objects within a host environment. Jet as defined here is not intended to be computationally self-sufficient; indeed, there are no provisions in this specification for input of external data or output of computed results. Instead, it is expected that the computational environment of a Jet program will provide not only the objects and other facilities described in this specification but also certain environment-specific host objects, whose description and behaviour are beyond the scope of this specification except to indicate that they may provide certain properties that can be accessed and certain functions that can be called from a Jet program.

Jet is designed after the ActionScript 3 language.

Jet incorporates two features that aim to accelerate large scale development: JetDependencies and JetDoc, described in respective subsections.

Jet for XML (J4X) is an incorporated Jet feature based on the ECMAScript for XML standard, ECMA-357 second edition. J4X provides types, values, objects, properties, and program syntax and semantics for processing and manipulating XML data.

const person = <Person>
    <name>Razen</name>
    <interest type="farming" rate="0.5"/>
    <interest type="quantumPhysics" rate="1"/>
</Person>

trace(person.name.toString())
trace(Number(person..interest.(@type == "quantumPhysics")[0].@rate) == 1)

Unlike with ActionScript 3, the Jet language does not include three-dimensional properties that belong to a namespace.

In ActionScript 3, where it is common to share internal properties throughout a codebase using namespaces, in Jet it is rather common to share internal properties throughout a codebase using public properties with the JetDoc @private tag.

package q1.n1 {
    public class C1 {
        /** @private */
        public var Q1Internals_x;
    }
}

Jet incorporates JetDependencies, a dependency manager that supports describing dependency packages and performing a series of commands to manage dependencies.

Dependencies in JetDependencies do not conflict in terms of the implementation.

Native extensions are libraries that extend a framework with functionality that is not natively available. Jet aids in developing native extensions through the combination of meta-data and conditional compilation, leaving the rest to the implementation of Jet. The programmer may attach files to meta-data, including those that are JetDependencies artifacts.

[N1(File(output + "data.bin"))]
class C1 {
    [N1(name = "f")]
    function f(): void;
}
configuration {
    if (k=a) {
        trace("k=a");
    } else {
        trace("Something else");
    }
}

JetDoc is a documentation feature incorporated in the Jet language. JetDoc and JetDependencies are related in that JetDependencies is able to auto publish JetDoc documentation once a package is published.

The following program demonstrates documenting a class that is allowed to be constructed through an object initializer.

package n1.p {
    /**
     * `C`
     *
     * @example
     *
     * ```
     * import n1.p.*;
     * const o: C1 = { q: true };
     * ```
     */
    [Literal]
    public class C1 {
        /**
         * Q
         */
        public var q: Boolean;
    }
}

The Jet compilation cycle can be resumed as in the following chart:

The compiler used throughout the above process is specified by the JetDependencies platform.

Note: the Jet bytecode is undocumented as the Jet compiler is a work in progress. The Jet bytecode shall be similiar to the ActionScript Virtual Machine 2 bytecode format by Adobe.

Note: the Jet bytecode shall support the following:

• Meta-data with source location attached to definitions
• Meta-data with source location attached to specific code regions of a function as result of annotatated block statements

The String data type uses an implementation-defined encoding to represent a sequence of characters. String indices identify a character in the encoding unit.

Snippets

Jet supports throwing errors as in Java, in the form of unchecked exceptions that may occur during program execution.

function f(): void {
    throw new RangeError()
}
try {
    f()
} catch (error: RangeError) {
    f1()
}

JetDoc comments use the @throws tag to describe thrown errors, as in:

package n1.n2 {
    /**
     * @throws n1.n2.N2Error
     */
    public function f(): void {}
}

There are two types of properties: fixed and dynamic properties. Fixed properties shadow dynamic properties by default.

Fixed properties are those defined at the class fixture. Dynamic properties are those resulting from property accessor proxies.

The Map class is one of those classes that commonly use dynamic properties using a textual name.

const o = { x: 10 }
o.x++

Disambiguation between accessing fixed and dynamic properties may be done explicitly through the reserved J4X qualifiers fixed and dynamic.

o.fixed::x
o.dynamic::x

Nullability in the Jet language takes the preference of using the null value to indicate absence of value, however the undefined value exists as part of the void type and as therefore as part of the * type.

The type T?, or ?T, consists of the values of T and null.

The type T! consists of the values of T but null.

Certain operators are supported for nullability, such as the nullish coalescing operator (x ?? y), the non-null operator (o!), and the optional chaining operator (?.). These operators consider solely the values undefined and null as absence of value.

The nullish coalescing operator (x ?? y) returns the right operand if the left operand is undefined or null.

x ?? y

The non-null operator (o!) ensures the operand is not null and not undefined.

o!

The optional chaining operator (?.) returns the absent value if the base object is undefined or null, or otherwise performs a chain of operations on the base object.

o?.f()
o?.[k]
o?.()

Operations of the Jet language may be customized through proxies. Proxies are special methods defined with the proxy attribute.

class C {
    const v;
    function C(a) { v = a }
    proxy function add(c: C): C (new C(this.v + c.v));
}
trace((new C(10) + new C(10)).v)

Frameworks that allow rapid interactive user interface development take the approach of processing customized file extensions as part of a JetDependencies platform. Maintainers of a JetDependencies platform import the compiler APIs, including the semantics, parser, and verifier, to process such file extensions.

Customized file formats supported by frameworks extend the XML language in general, describing an user interface component or a component library. XML formats may allow literal Jet code, either as a sequence of directives or as an expression.

The Jet language supports simple parameterized types.

class C.<T> {}

Implementations prefer performing polymorphism for parameterized types, but polymorphism may not be used for the Array class applied with a certain primitive type such as Number.

With polymorphism, type parameters are substituted by the * type during runtime and additional compile-time verification applies when using parameterized types.

The Jet language does not support constraints on type parameters in the present, such as those present in the Java language.

The Jet language does not support type parameters for methods in the present.

The Jet language includes bland type inference and there are cases where the programmer may need explicitness to take advantage of compile-time facilities. For example, the language does not support union types and there are places where the programmer is able to pass more than one data type.

The call operator (T()) where T is a type, is equivalent to a type conversion. Such call operator passes T as the context type to the first argument, opening room for type inference.

[Literal]
class Options {
    const x: String
}

function f(options) {
    switch type (options) {
        case (value: Number) {
            // Number
        }
        case (options: Options) {
            // Options
        }
    }
}

f(10)
f(Options( { x: "string" } ))

Jet includes a built-in mechanism for loading environment variables using the import.meta.env expression.

import.meta.env.EXAMPLE

The result of loading environment variables is implementation defined, however it is expected that an implementation loads an .env file from the directory of the main JetDependencies package, also referred to as a DotEnv file.

The ability of accessing the directory to which JetDependencies produces artifacts is valuable since such directory varies across JetDependencies compilations. The Jet language includes certain ways of accessing such directory, called the artifact output of JetDependencies.

The import.meta.output expression evaluates to a string identifying the JetDependencies artifact output directory.

import node.filesystem.*;

// Locate <output>/my/data.txt
const file = new File(import.meta.output).resolvePath("my/data.txt");

// Write to <output>/my/data.txt
file.write("Text");

As seen in an earlier section, meta-data support file entries resolving files from the JetDependencies artifact output through the output + “path/to/file” expression.

The embed expression supports embedding files from the JetDependencies artifact output.

const bytes = embed {
    source: output + "auto/generated.bin",
    type: ByteArray,
};

For the purpose of of this specification the following definitions apply:

A set of data values.

One of the types void, null, Boolean, Number, Single, Long, BigInt, String, or Char.

A member of one of the primitive types. A primitive value is a datum that is represented directly at the lowest level of the language implementation.

A set of zero or more properties.

A key-value pair belonging to an object. The key of a property may be alternatively referred to as a name.

A method is a property that may be invoked as a function.

The Extensible Markup Language (XML) is an information encoding standard endorsed by the World Wide Web Consortium (W3C) for sending, receiving, and processing data across the World Wide Web. XML comprises a series of characters that contains not only substantive information, called character data, but also meta-information about the structure and layout of the character data, called markup.

One of the two basic constituents of XML data (the other is character data). Markup is a series of characters that provides information about the structure or layout of character data. Common forms of markup are start-tags, end-tags, empty-element tags, comments, CDATA tag delimiters, and processing instructions.

One of the two basic constituents of XML data (the other is markup). Character data is a series of characters that represents substantive data encapsulated by XML markup. Character data is defined as any series of characters that are not markup.

A single markup entity that acts as a delimiter for character data. A tag can be a start-tag, an endtag, or an empty-element tag. Start-tags begin with a less than (<) character and end with a greater than (>) character. End-tags begin with a pairing of the less than and slash characters (</) and end with a greater than (>) character. Empty-element begin with a less than (<) character and end with a pairing of the slash and greater than (/>) characters.

A data construct comprising two tags (a start-tag and an end-tag) that delimit character data or nested elements. If neither character data nor nested elements exist for a given element, then the element can be defined by a single empty-element tag. Every well-formed XML document contains at least one element, called the root or document element.

An optional name-value pair, separated by an equal sign (=), that can appear inside a tag. Attributes can store information about an element or actual data that would otherwise be stored as character data.

A group of identifiers for elements and attributes that are collectively bound to a Uniform Resource Identifier (URI) such that their use will not cause naming conflicts when used with identically named identifiers that are in a different namespace.

A markup entity that contains instructions or information for the application that is processing the XML. Processing-instruction tags begin with a combination of the less than (<) character and a question mark (?) character (<?) and end with the same combination of characters but in reverse order (?>).

A list of zero or more files and zero or more subdirectories, created at a path in a file system similiar to how files are stored at a path in a file system.

Either textual or binary data stored at a path in a file system. Resolutions may be performed from a file path to another file path.

The name of a file.

A dependable unit as part of the JetDependencies dependency manager. A JetDependencies package must not be mistaken as a package.

A JetDependencies workspace consists of multiple JetDependencies packages.

An unique identifier that distinguishes dependencies of different implementations.

An invokable JetDependencies package as part of another JetDependencies package.

A key-value constant consisting of strings supplied to the JetDependencies build system.

Application for entering commands in the user device.

A plain text format for writing structured documents as specified by the CommonMark Specification.

A version control system.

This document uses the following notation to define one or more productions of a nonterminal of the syntactic grammar:

Symbol :
Production1 Symbol1
ProductionN

This document uses double colon (::) notation to define productions of a nonterminal of the lexical grammar:

Symbol ::
terminal

The _opt subscript is used to indicate that a nonterminal symbol is optional.

Symbol ::
Symbol1_opt

A bracketed clause or predicate may appear between the rules of a production, such as in:

Symbol ::
[lookahead ∈ { 0 }] Symbol1
[lookahead ∉ { default }] Symbol2
SourceCharacters [but no embedded <![CDATA[]

The «empty» clause is matched by the grammar where other rules do not match otherwise.

Symbol :
«empty»

Braces subscripts are used to quantify a rule:

• Symbol_{4} — Four of Symbol
• Symbol_{2,} — At least two of Symbol
• Symbol_{1,4} — One to four of Symbol

This section defines the lexical grammar of the Jet language.

The tokenizer scans one of the following input goal symbols depending on the syntactic context: * InputElementDiv, InputElementRegExp, InputElementXMLTag, or InputElementXMLContent.

The following program illustrates how the tokenizer decides which is the input goal symbol to scan:

/(?:)/       ;
a / b        ;
<a>Text</a>  ;

The following table indicates which is the input goal symbol that is scanned for each of the tokens comprising the previous program:

Syntax

InputElementDiv ::
WhiteSpace
LineTerminator
Comment
Identifier
ReservedWord
Punctuator
NumericLiteral
StringLiteral

InputElementRegExp ::
WhiteSpace
LineTerminator
Comment
Identifier
ReservedWord
Punctuator
/
/=
NumericLiteral
StringLiteral
RegularExpressionLiteral
XMLMarkup

InputElementXMLTag ::
XMLName
XMLTagPunctuator
XMLAttributeValue
XMLWhitespace
{

InputElementXMLContent ::
XMLMarkup
XMLText
{
< [lookahead ∉ { ?, !, / }]
</

Syntax

SourceCharacter ::
Unicode code point

SourceCharacters ::
SourceCharacter SourceCharacters_opt

The WhiteSpace token is filtered out by the lexical scanner.

Syntax

WhiteSpace ::
U+09 tab
U+0B vertical tab
U+0C form feed
U+20 space
U+A0 no-break space
Unicode “space separator”

The LineTerminator token is filtered out by the lexical scanner, however it may result in a VirtualSemicolon to be inserted.

Syntax

LineTerminator ::
U+0A line feed
U+0D carriage return
U+2028 line separator
U+2029 paragraph separator

The Comment token is filtered out by the lexical scanner, however it propagates any LineTerminator token from its characters.

The Comment symbol is similiar to that from the ECMA-262 third edition, adding support for nested multi-line comments.

/*
 * /*
 *  *
 *  */
 */

Syntax

Comment ::
// SingleLineCommentCharacters
MultiLineComment

SingleLineCommentCharacters ::
SingleLineCommentCharacter SingleLineCommentCharacters_opt

SingleLineCommentCharacter ::
[lookahead ∉ { LineTerminator }] SourceCharacter

MultiLineComment ::
/* MultiLineCommentCharacters_opt */

MultiLineCommentCharacters ::
SourceCharacters [but no embedded sequence /*]
MultiLineComment
MultiLineCommentCharacters SourceCharacters [but no embedded sequence /*]
MultiLineCommentCharacters MultiLineComment

The VirtualSemicolon nonterminal matches an automatically inserted semicolon, known as a virtual semicolon.

Virtual semicolons are inserted in the following occasions:

• After a right-curly character }
• Before a LineTerminator

The Identifier symbol is similiar to that from the ECMA-262 third edition, but with support for scalar Unicode escapes.

Syntax

Identifier ::
IdentifierName [but not ReservedWord or ContextKeyword]
ContextKeyword

IdentifierName ::
IdentifierStart
IdentifierName IdentifierPart

IdentifierStart ::
UnicodeLetter
underscore _
$
UnicodeEscapeSequence

IdentifierPart ::
UnicodeLetter
UnicodeCombiningMark
UnicodeConnectorPunctuation
UnicodeDigit
underscore _
$
UnicodeEscapeSequence

UnicodeLetter ::
Unicode letter (“L”)
Unicode letter number (“Nl”)

UnicodeDigit ::
Unicode decimal digit number (“Nd”)

UnicodeCombiningMark ::
Unicode nonspacing mark (“Mn”)
Unicode spacing combining mark (“Mc”)

UnicodeConnectorPunctuation ::
Unicode connector punctuation (“Pc”)

ReservedWord includes the following reserved words:

as
do
if
in
is

for
new
not
try
use
var

case
else
null
this
true
void
with

await
break
catch
class
const
false
super
throw
while
yield

delete
import
public
return
switch
typeof

default
extends
finally
package
private

continue
function
internal

interface
protected

implements

ContextKeyword is one of the following in certain syntactic contexts:

get
set
xml

each
enum
from
meta
type

embed
final
fixed
proxy

native
static

dynamic

abstract
override

namespace

configuration

Punctuator includes one of the following:

::  @
.  ..  ...
(  )  [  ]  {  }
:  ;  ,
?  !  =
?.
<  <=
>  >=
==  ===
!=  !==
+  -  *  %  **
++  --
<<  >>  >>>
&  ^  |  ~
&&  ^^  ||  ??

The @ punctuator must not be followed by a single quote ' or a double quote character ".

Punctuator includes CompoundAssignmentPunctuator. CompoundAssignmentPunctuator is one of the following:

+=  -=  *=  %=  **=
<<=  >>=  >>>=  &=  ^=  |=
&&=  ^^=  ||=
??=

NumericLiteral is similiar to NumericLiteral from the ECMA-262 third edition, with support for binary literals and underscore separators:

0b1011
1_000

Syntax

NumericLiteral ::
DecimalLiteral [lookahead ∉ { IdentifierStart, DecimalDigit }]
HexIntegerLiteral [lookahead ∉ { IdentifierStart, DecimalDigit }]
BinIntegerLiteral [lookahead ∉ { IdentifierStart, DecimalDigit }]

DecimalLiteral ::
DecimalIntegerLiteral . UnderscoreDecimalDigits_opt
ExponentPart_opt
. UnderscoreDecimalDigits ExponentPart_opt
DecimalIntegerLiteral ExponentPart_opt

DecimalIntegerLiteral ::
0
[lookahead = NonZeroDigit] UnderscoreDecimalDigits_opt

DecimalDigits ::
DecimalDigit_{1,}

UnderscoreDecimalDigits ::
DecimalDigits UnderscoreDecimalDigits _ DecimalDigits

DecimalDigit ::
0-9

NonZeroDigit ::
1-9

ExponentPart ::
ExponentIndicator SignedInteger

ExponentIndicator ::
e
E

SignedInteger ::
UnderscoreDecimalDigits
+ UnderscoreDecimalDigits
- UnderscoreDecimalDigits

HexIntegerLiteral ::
0x UnderscoreHexDigits
0X UnderscoreHexDigits

HexDigit ::
0-9
A-F
a-f

UnderscoreHexDigits ::
HexDigit_{1,}
UnderscoreDecimalDigits _ HexDigit_{1,}

BinIntegerLiteral ::
0b UnderscoreBinDigits
0B UnderscoreBinDigits

BinDigit ::
0
1

UnderscoreBinDigits ::
BinDigit_{1,}
UnderscoreDecimalDigits _ BinDigit_{1,}

RegularExpressionLiteral is similiar to RegularExpressionLiteral from the ECMA-262 third edition, with support for line breaks.

Syntax

RegularExpressionLiteral ::
/ RegularExpressionBody / RegularExpressionFlags

RegularExpressionBody ::
RegularExpressionFirstChar RegularExpressionChars

RegularExpressionChars ::
«empty»
RegularExpressionChars RegularExpressionChar

RegularExpressionFirstChar ::
SourceCharacter [but not * or \ or /]
BackslashSequence

RegularExpressionChar ::
SourceCharacter [but not \ or /]
BackslashSequence

BackslashSequence ::
\ SourceCharacter

RegularExpressionFlags ::
«empty»
RegularExpressionFlags IdentifierPart

StringLiteral is similiar to the StringLiteral symbol from the ECMA-262 third edition. The following additional features are included:

• Scalar UnicodeEscapeSequence using the \u{...} form
• Triple string literals
• Raw string literals using the @ prefix

Triple string literals use either """ or ''' as delimiter and may span multiple lines. The contents of triple string literals are indentation-based, as can be observed in the following program:

const text = """
    foo
    bar
    """
text == "foo\nbar"

Triple string literals are processed as follows:

• The first empty line is ignored.
• The base indentation of a triple string literal is that of the last string line.

Both regular and triple string literals accept the @ prefix, designating raw string literals. Raw string literals contain no escape sequences.

const text = @"""
    x\y
    """

Escape sequences are described by the following table:

Syntax

StringLiteral ::
[lookahead ≠ """] " DoubleStringCharacter_{0,} "
[lookahead ≠ '''] ' SingleStringCharacter_{0,} '
""" TripleDoubleStringCharacter_{0,} """
''' TripleSingleStringCharacter_{0,} '''
RawStringLiteral

RawStringLiteral ::
@ [lookahead ≠ """] " DoubleStringRawCharacter_{0,} "
@ [lookahead ≠ '''] ' SingleStringRawCharacter_{0,} '
@""" TripleDoubleStringRawCharacter_{0,} """
@''' TripleSingleStringRawCharacter_{0,} '''

DoubleStringCharacter ::
SourceCharacter [but not double-quote " or backslash \ or LineTerminator]
EscapeSequence

SingleStringCharacter ::
SourceCharacter [but not single-quote ' or backslash \ or LineTerminator]
EscapeSequence

DoubleStringRawCharacter ::
SourceCharacter [but not double-quote " or LineTerminator]

SingleStringRawCharacter ::
SourceCharacter [but not single-quote ' or LineTerminator]

TripleDoubleStringCharacter ::
[lookahead ≠ """] SourceCharacter [but not backslash \ or LineTerminator]
EscapeSequence
LineTerminator

TripleSingleStringCharacter ::
[lookahead ≠ '''] SourceCharacter [but not backslash \ or LineTerminator]
EscapeSequence
LineTerminator

TripleDoubleStringRawCharacter ::
[lookahead ≠ """] SourceCharacter [but not LineTerminator]
LineTerminator

TripleSingleStringRawCharacter ::
[lookahead ≠ '''] SourceCharacter [but not LineTerminator]
LineTerminator

Syntax

EscapeSequence ::
\ CharacterEscapeSequence
\0 [lookahead ∉ DecimalDigit]
\ LineTerminator
HexEscapeSequence
UnicodeEscapeSequence

CharacterEscapeSequence ::
SingleEscapeCharacter
NonEscapeCharacter

SingleEscapeCharacter ::
'
"
\
b
f
n
r
t
v

NonEscapeCharacter ::
SourceCharacter [but not EscapeCharacter or LineTerminator]

EscapeCharacter ::
SingleEscapeCharacter
DecimalDigit
x
u

HexEscapeSequence ::
\x HexDigit HexDigit

UnicodeEscapeSequence ::
\u HexDigit_{4}
\u { HexDigit_{1,} }

This section defines nonterminals used in the lexical grammar as part of J4X.

If a XMLMarkup, XMLAttributeValue or XMLText contains a LineTerminator after parsed, it contributes such LineTerminator to the lexical scanner.

Syntax

XMLMarkup ::
XMLComment
XMLCDATA
XMLPI

XMLWhitespaceCharacter ::
U+20 space
U+09 tab
U+0D carriage return
U+0A line feed

XMLWhitespace ::
XMLWhitespaceCharacter
XMLWhitespace XMLWhitespaceCharacter

XMLText ::
SourceCharacters [but no embedded left-curly { or less-than <]

XMLName ::
XMLNameStart
XMLName XMLNamePart

XMLNameStart ::
UnicodeLetter
underscore _
colon :

XMLNamePart ::
UnicodeLetter
UnicodeDigit
period .
hyphen -
underscore _
colon :

XMLComment ::
<!-- XMLCommentCharacters_opt -->

XMLCommentCharacters ::
SourceCharacters [but no embedded sequence -->]

XMLCDATA ::
<![CDATA[ XMLCDATACharacters ]]>

XMLCDATACharacters ::
SourceCharacters [but no embedded sequence ]]>]

XMLPI ::
<? XMLPICharacters_opt ?>

XMLPICharacters ::
SourceCharacters [but no embedded sequence ?>]

XMLAttributeValue ::
" XMLDoubleStringCharacters_opt "
' XMLSingleStringCharacters_opt '

XMLDoubleStringCharacters ::
SourceCharacters [but no embedded double-quote "]

XMLSingleStringCharacters ::
SourceCharacters [but no embedded single-quote ']

XMLTagPunctuator ::
=
>
/>

The default value of a type is determined according to the following table:

The language performs auto boxing of primitive types. Primitive types are represented in a memory efficient way wherever available, including within an Array.

Primitive types are boxed without duplicating identity:

var x: Object = 10
var y: Object = 10

// true
x == y

The any type * contains values from all other types. The * type is the most ascending type of all other types.

The void type consists of the undefined value.

The null type consists of the null value. Although the null type exists in the specification, no operation in the language can result in the null type.

The Boolean type consists of the values false and true.

The String type consists of a sequence of Unicode Scalar Values whose encoding is implementation-defined.

The Char type represents a character as an Unicode scalar value.

A function type consists of zero or more parameters and a result type.

type F = function(): T

Inheritance

A function type inherits from the Function class.

A function type is a final class.

Grammar

Each parameter is either a required, optional, or rest parameter.

The formal parameter list is a list of zero or more required parameters followed by zero or more optional parameters followed by an optional rest parameter.

The rest parameter must appear at most once.

Restrictions

The rest parameter, if any, must be of the Array type.

A tuple type represents a sequence of two or more element types.

type T1 = [E1, E2]

type T2 = [E1, E2, EN]

Inheritance

A tuple type inherits the Object class.

A tuple type is a final class.

Access

Tuple types consist of mutable elements and are compared by reference.

type T = [Number, Number]
const v: T = [10, 10]
v[0] += 1
v != [11, 10]

T? or ?T is an union between null and T.

The Array.<T> type is a dynamic collection of T values. Array may be denoted by either Array.<T> or [T].

type A1 = [T1]

type A2 = Array.<T2>

The Object type is the ascending type of all other classes and all enumerations.

The internal ExpectType(symbol) function takes the following steps:

• If symbol is PackageReferenceValue(base, prop)
  • Return ExpectType(prop)
• If symbol is ScopeReferenceValue(base, prop)
  • Return ExpectType(prop)
• If symbol is TypeAsReferenceValue(type)
  • Return type
• Throw type error if symbol is not a type.
• Return symbol.

Type conversions occur either implicitly or explicitly.

An explicit type conversion occurs through one of the following expressions:

v as T
T(v)

v as T is an optional type conversion which, if a failure, results in null.

The language performs implicit compile-time conversions from a constant to a constant of another type. These conversions are described by the following table:

An implicit conversion is followed by an attempt of an implicit constant conversion. Implicit conversions are described by the following table:

An explicit conversion is followed by an attempt of an implicit conversion. Explicit conversions are described by the following table:

The contravariant and covariant Array conversions do not take nullable types except for a conversion from [*] to [T?].

A visibility is either public, private, protected, or internal.

Runtime restrictions

• When a class static or instance property is not public and it is not an internal property belonging to a top-level class, it is not possible for such property to be found at runtime.
• When a class static or instance property is not public and it is not an internal property belonging to a top-level class, it is not contained in the runtime type description.

class C1 { var x }
const o = new C1
const k = "x"
o[k] = 10 // OK as C1 is a top-level class

The internal PropertyIsVisible(prop, scope) function takes the following steps:

1. If prop is a value
   1. If prop is StaticReferenceValue(base, prop1)
      1. Assign prop = prop1
   2. Else if prop is InstanceReferenceValue(base, prop1)
      1. Assign prop = prop1
   3. Else if prop is PackageReferenceValue(base, prop1)
      1. Assign prop = prop1
   4. Else return true.
2. Let v be prop.[[Visibility]]
3. If v is public, return true.
4. If v is internal
   1. Let p be undefined.
   2. Let p1 be prop.[[Parent]]
   3. While p1 is defined
      1. If p1 is a package
         1. Assign p = p1
         2. Exit while loop
      2. Assign p1 = p1.[[Parent]]
   4. If p is undefined
      1. Return true.
   5. While scope is defined
      1. If scope is a package scope and scope.[[Package]] equals p
         1. Return true.
      2. Assign scope = scope.[[Parent]]
   6. Return false.
5. If v is private
   1. Let t be undefined.
   2. Let p be prop.[[Parent]]
   3. While p is defined
      1. If p is a class or enum
         1. Assign t = p
         2. Exit while loop
      2. Assign p = p.[[Parent]]
   4. If t is undefined
      1. Return false
   5. While scope is defined
      1. If scope is a class scope or enum scope and scope.[[Class]] equals t
         1. Return true.
      2. Assign scope = scope.[[Parent]]
   6. Return false.
6. If v is protected
   1. Let t be undefined.
   2. Let p be prop.[[Parent]]
   3. While p is defined
      1. If p is a class or enum
         1. Assign t = p
         2. Exit while loop
      2. Assign p = p.[[Parent]]
   4. If t is undefined
      1. Return false
   5. While scope is defined
      1. If scope is a class scope or enum scope
         1. Let scopeClass be scope.[[Class]]
         2. If scopeClass equals t or scopeClass is a subtype of t
            1. Return true.
      2. Assign scope = scope.[[Parent]]
   6. Return false.
7. Return false.

Packages as denoted by the package keyword are used to organize properties and classes.

For an user to refer to a package’s property it must be imported beforehand through an import directive.

package { public const j = Infinity }
package x.y { public const w = 10 }

trace(j)

import x.y.*
trace(w)
trace(x.y.w)

The fully qualified name of an imported package’s property shadows any variable name in scope as described in the Fully Qualified Names section.

package x.y { public const w = 10 }
class X { const y = new XY }
class XY { const w = Infinity }

import x.y.*
const x = new X
trace(x)
trace(x.y.w == 10)

The top-level package is an unnamed package from which subsequent packages are defined.

package {}

Directives of the form use package q.*; contribute an use package to a package. Use packages are used in name resolution to resolve to names from another package.

package a1.n1 { use package o1.n1.* }

A package may have zero or more subpackages. The top-level package contains the topmost packages as subpackages.

package q1 {}
package q1.q2 {}
package q1.q2.qN {}

Package sets allow to resolve a property from a set of packages.

A variable represents a fixed slot storing a value.

var x: Number

const y: Number

A variable is designed read-only through using the const keyword instead of the var keyword when defining the variable.

Read-only variables are called constants.

Variables are lazily initialized except those whose static type defines a default value, such as one of the primitive types. Lazily initialized variables are initialized upon the first access.

A variable may consist of a constant initializer. A constant initializer consists of a constant expression.

var x = 0

Restrictions

During runtime it is a ReferenceError if the value of a variable is accessed before initialized and the static type of that variable includes no default value.

class C {
    const x: Number
    const y: RegExp
    function C() {
        x // 0
        y // ReferenceError
    }
}

During runtime it is a VerifyError if a constant is assigned more than once.

const x = 0
x++ // ERROR

At compile-time a non instance constant must contain an initializer.

const x // ERROR

class C1 { const x } // OK

At compile-time a non instance constant must not be assigned more than once.

const x = 0
x++ // ERROR

At compile-time an instance constant may be assigned in the constructor body.

class C1 {
    const x
    function C1() { x = 10 }
}

At compile-time an instance constant may not be assigned outside the constructor body.

const x // VerifyError

const x = 10
x++ // VerifyError

class C {
    const x
    function C(x) { this.x = x }
    function f() { x = 10 } // VerifyError
}

A variable may contain zero or more meta-data.

[N1(n2)]
const x

Optional variables do not need to be specified when using an object initializer to construct a class.

[Literal]
class C1 { const x: Number? }

const o: C1 = {}

A variable is optional when its static type includes null or when its static type includes undefined.

A virtual property is an accessor that may be used as a variable.

A virtual property is read-only if it has only a getter.

A virtual property is write-only if it has only a setter.

Getter and setter are methods that belong to the virtual property.

function get x(): T (v);
function set x(v: T): void {}

A method represents an invokable symbol that takes zero or more parameters and returns a value.

A method is a generator if it contains the yield operator.

• Non asynchronous generators return Iterator.<T>.
• Asynchronous generators return Iterator.<Promise.<T>>.

function f() {
    for (var i = 0; i < 10; ++i) {
        yield i
    }
}

A method is asynchronous if it contains the await operator.

• Non generator asynchronous methods return Promise.<T>.
• Asynchronous generators return Iterator.<Promise.<T>>.

function f() { await f1() }

A method is native if it contains the native attribute.

native function f(): void

A method may contain zero or more meta-data.

[N1(n2)]
function f() {}

An instance method is a non static method directly enclosed in a class, enum, or interface block.

class C1 {
    function f() {}
}

Instance methods are bound methods; that is, they always produce the same Function object when accessed from an instance with the this literal bound to the instance object.

class C1 {
    function f(): C1 (this)
}

const o = new C1
trace(o.f == o.f)

const { f } = o
trace(f() == o)

An abstract method contains the abstract attribute.

Restrictions

Abstract methods must not contain a body.

Abstract methods must be overriden by subclasses of the enclosing class.

A final method contains the final attribute.

Restrictions

Final methods must not be overriden by subclasses of the enclosing class.

An overriding method contains the override attribute.

class C1 {
    function f() {}
}
class C2 extends C1 {
    override function f() {}
}

The overriding method contains an overriding signature. The method of the base class being overriden contains a signature referred to as base signature.

It is a verify error if the overriding signature is not compatible with the base signature.

The overriding signature is compatible with the base signature if either:

• It is equals the base signature
• It introduces optional parameters and/or a rest parameter to the base signature and either the result type is equals to that of the base signature or the result type is a subtype of that of the base signature.

class C1 {
    function f(): * (10);
}
class C2 extends C1 {
    override function f(a: Number = 10): Number (a ** 2);
}

It is allowed for an overriding method to override either a method, a getter, or a setter. The kind of base class method being overriden must be looked up according to the kind of the overriding method.

An interface method is an instance method belonging to an interface.

interface I {
    function f();
}

Implementors of an interface must implement those interface methods that are not optional. The method visibility must match public if the implementor is at a package, otherwise the visibility must match internal.

interface I1 {
    function f() {}
}
class C1 implements I1 {
    function f() {}
}

An interface method is optional when its body is explicitly specified.

interface I1 {
    function f() {}
}

An interface method is allowed to be a method, a getter, or a setter.

A getter is a method that belongs to a virtual property, used as a way to retrieve the value of the property.

function get x(): T (v);

Restrictions

A getter must not be asynchronous; that is, it must not contain the await operator.

A getter must not be a generator; that is, it must not contain the yield operator.

A setter is a method that belongs to a virtual property, used as a way to assign the value of the property.

function set x(v: T): void {}

Restrictions

A setter must not be asynchronous; that is, it must not contain the await operator.

A setter must not be a generator; that is, it must not contain the yield operator.

A constructor is a method whose name matches that of the directly enclosing class.

class C1 {
    function C1() {}
}

Restrictions

A constructor must not be asynchronous; that is, it must not contain the await operator.

A constructor must not be a generator; that is, it must not contain the yield operator.

It is a verify error if the constructor contains no super(); statement and the constructor of the parent class contains a non-empty parameter list.

A constructor is allowed to perform assignments to instance constants.

A constructor is allowed to contain a single super(); statement.

A proxy is a method containing the proxy attribute, enclosed by a class or enum block. The name of a proxy must be one of the several proxy names listed in this section.

class C {
    proxy function positive(): T {}
}

class C {
    proxy function negate(): T {}
}

class C {
    proxy function bitwiseNot(): T {}
}

class C {
    proxy function add(right: C): T {}
}

class C {
    proxy function subtract(right: C): T {}
}

class C {
    proxy function multiply(right: C): T {}
}

class C {
    proxy function divide(right: C): T {}
}

class C {
    proxy function remainder(right: C): T {}
}

class C {
    proxy function power(right: C): T {}
}

class C {
    proxy function bitwiseAnd(right: C): T {}
}

class C {
    proxy function bitwiseXor(right: C): T {}
}

class C {
    proxy function bitwiseOr(right: C): T {}
}

class C {
    proxy function shiftLeft(right: C): T {}
}

class C {
    proxy function shiftRight(right: C): T {}
}

class C {
    proxy function shiftRightUnsigned(right: C): T {}
}

The to proxy contributes an explicit conversion from the enclosing class to the type it returns.

The to proxy may be defined multiple times.

The to proxy indicates conversion failure by throwing a TypeError error.

class C {
    proxy function to(): T {}
}

class C {
    proxy function getProperty(k: K): T {}
}

class C {
    proxy function setProperty(k: K, v: V): void {}
}

class C {
    proxy function deleteProperty(k: K): Boolean {}
}

The has proxy is used for the in operator.

class C {
    proxy function has(v: T): Boolean {}
}

The keys proxy is used for the for…in statement.

class C {
    proxy function keys(): Iterator.<K> {}
}

The values proxy is used for the for each statement.

class C {
    proxy function values(): Iterator.<V> {}
}

An alias is a symbol that translates to another symbol. Aliases are a result from type definitions and certain import directives.

type D = Number
import N1 = q.N
import q1 = q.*

An alias may contain zero or more meta-data:

[N1(n2)]
type T2 = T1

The internal ResolveAlias(type) function takes the following steps:

1. If type is an alias, return ResolveAlias(type.[[AliasOf]]).
2. Return type.

An enumeration is an user-defined type whose main composition is a set of possible variants called members. An enumeration is denoted by the enum keyword.

An enumeration represents a final class that inherits the Object type.

Unlike in general languages, members of an enumeration in Jet consist of a (string, number) group. Efficient implementations represent a variable of an enumeration data type as a number, if not in boxed form.

enum E1 {
    const M1, M2
}
const v: E1 = "m1"
const v: E1 = "m2"

Set enumerations contain the Set meta-data and have special behaviour in that a value of the enumeration data type may include zero or more mutual members.

[Set]
enum E1 {
    const M1, M2
}
const set: E1 = ["m1", "m2"]
trace("m1" in set)
trace("m2" in set)

The enum block supports defining properties other than enumeration members, including instance methods, static methods, static properties and proxies.

Unlike with a class block, the enum block does not support defining a constructor.

enum E1 {
    const M1, M2
    function math(): Number (
        valueOf() * 16
    )
}

An enumeration member consists of a (string, number) group.

Members within the enum block are defined using variable definitions that do not contain the static attribute.

The string and number values are corresponding to a String and a number.

Defining a member, in addition to contributing a member, shall also contribute a static constant to the enumeration whose name is that of the binding identifier and whose value identifies the enumeration member.

E.M

The value for string and number may be specified in different forms. If in any of the forms a component is omitted, the value is automatically assigned to that component. The values for the (string, number) group are given in the initializer of the const definition, as in the following block:

const M
const M = "string"
const M = number
const M = ["string", number]
const M = [number, "string"]

In the presented forms, number must be a constant expression that is a number constant whose data type is the numeric type of the enumeration.

Restrictions

It is a syntax error if any of the following conditions are true:

• A member definition is not denoted by the const keyword.
• A variable binding of a member definition includes destructuring.
• A variable binding of a member definition includes a type annotation.

It is a verify error if any of the following conditions are true:

• The member name already exists.
• The string already belongs to another member.
• The number already belongs to another member.
• If it is a set enumeration and number is not one or a power of two.

If the string component is omitted when defining a member, its value is a screaming snake case to camel case transformation of the member name, as illustrated in the following table:

If the number component is omitted when defining a member, its value is selected based on the previous member definition.

For non Set enumerations, the initial member number is zero (0) and the next member number is an increment of 1 of the previous member number:

const M1 // = 0
const M2 // = 1

For Set enumerations, the initial member number is one (1) and the next member number is the double of the previous member number:

const M1 // = 1
const M2 // = 2
const M4 // = 4

An enumeration uses the same numeric type for all of its members. Such numeric type may be specified by the as clause.

By default, an enumeration uses Number as its numeric type.

enum E1 as Long {
    const M1
}

Set enumerations are defined with the Set meta-data. Set enumerations are immutable data types represented by zero or more members, using bitwise capabilities.

[Set]
enum E1 { const M1, M2 }

The programmer is allowed to use a string literal to identify an enumeration member by its string value wherever the enumeration is expected at compile-time.

enum E1 {
    const M1, M2;
}
function f(a: E1) a == "m1";
trace(f("m1"));

Set enumerations can be initialized within an array literal or object initializer.

It is allowed to convert to an enumeration using the call operator (E(v)). The conversion accepts a String or a number of the numeric type.

It is a TypeError if such conversions fail due to unrecognized String or number.

For set enumerations, converting from a number always succeeds, as the members are identified by the corresponding bits and the unrecognized bits are ignored.

E(v)

The instance method valueOf() of an enumeration returns the number corresponding to the enumeration object.

For a common enumeration, the instance method toString() returns the string corresponding to the enumeration object.

For a set enumeration, the instance method toString() returns a string as a comma-separated list corresponding to the included members.

For set enumerations, the static constant all is a set containing all the members of the enumeration.

For set enumerations, the instance method with(other : E, value : Boolean) : E where E is the enumeration, produces the same result as the expression:

value ? include(other) : exclude(other)

For set enumerations, the instance method include(other : E) : E where E is the enumeration, produces the same result as the expression:

E(valueOf() | other.valueOf())

For set enumerations, the instance method exclude(other : E) : E where E is the enumeration, produces the same result as the expression:

E(other in this ? valueOf() ^ other.valueOf() : valueOf())

For set enumerations, the instance method toggle(other : E) : E where E is the enumeration, produces the same result as the expression:

E(valueOf() ^ other.valueOf())`

For set enumerations, the instance method filter(other : E) : E where E is the enumeration, produces the same result as the expression:

E(valueOf() & other.valueOf())`

For set enumerations, the proxy has(value : E) where E is the enumeration, produces the same result as the expression valueOf() & value.valueOf() != 0.

m in o

A class as denoted by the class keyword represents an object type. A class is accessed as a Class object during runtime.

Restrictions

Instance properties must not be duplicate in the class inheritance.

class C1 {
    var x
}
class C2 extends C1 {
    var x // VerifyError
}

Overriding methods are allowed to be duplicate in the class inheritance.

class C1 {
    function f() {}
    function get x() 10
}
class C2 extends C1 {
    override function f() {} // OK
    function get x() 10 // VerifyError (must override)
}

By default, all classes, excluding Object, have Object as their base class.

Restrictions

It is a verify error if a class attempts to extend itself.

It is a verify error if a class attempts to extend a subclass of itself.

Restrictions

Classes containing the [Literal] meta-data have the following restrictions:

• They are implicitly marked final.
• They must extend the Object class.

[Literal]
final class C1 {
    var x
}
const o: C1 = { x: 10 }

A class may contain zero or more meta-data.

[N1(n2)]
class C1 {}

An interface as denoted by the interface keyword represents an abstract object type. An interface is accessed as a Class object during runtime.

Methods must not be a duplicate in the interface inheritance.

interface I1 {
    function f() {}
}
interface I2 extends I1 {
    function f() {} // VerifyError
}

It is a verify error if an interface attempts to extend itself.

It is a verify error if an interface attempts to extend a subtype of itself.

An interface may contain zero or more meta-data.

[N1(n2)]
interface I1 {}

The internal ResolveProperty(base, qual, key, disambiguation = default) function takes a base object, a qual qualifier value and a key value, and resolves to a reference value. ResolveProperty takes the following steps:

1. If base is a value whose type is one of { XML, XMLList }, return XMLReferenceValue(base, qual, key, disambiguation).
2. If base is a scope, return ResolveScopeProperty(base, qual, key).
3. If base is a value whose type is * or if key is not a String or Number constant
   1. Return DynamicReferenceValue(base, qual, key, disambiguation)
4. Return undefined if qual is not undefined.
5. If base is a class or enum
   1. Return undefined if key is not a String constant.
   2. While base is not undefined
      1. Let r be the symbol in base.[[StaticProperties]] whose key is equals key.
      2. Return StaticReferenceValue(base, r) if r is not undefined.
      3. Assign base = base.[[BaseClass]]
   3. Return undefined.
6. If base is the import.meta value
   1. Return undefined if key is not a String constant.
   2. If key equals env, return the import.meta.env symbol.
   3. If key equals output, return the import.meta.output symbol.
   4. Return undefined.
7. If base is the import.meta.env value
   1. Return undefined if key is not a String constant.
   2. Let evDict be the result of loading environment variables.
   3. Let ev be evDict.[key]
   4. If ev is not undefined, return a String constant consisting of the ev string.
   5. Return undefined.
8. If base is a value
   1. Return undefined if the type of base is void or a nullable type.
   2. If key is a String constant and disambiguation is one of { default, fixed }
      1. For each descending type in the type hierarchy of base
         1. For each (propName, prop) in type.[[Prototype]]
            1. If propName is equals key, return InstanceReferenceValue(base, prop).
   3. If disambiguation is one of { default, dynamic }
      1. For each descending type in the type hierarchy of base
         1. Let proxy be FindPropertyProxy(type)
         2. If proxy is not undefined
            1. If the first parameter type of proxy is equals the type of key or if the type of key is a subtype of the first parameter type of proxy
               1. Return ProxyReferenceValue(base, proxy)
   4. If key is a Number constant value and base is of a tuple type
      1. Let key be ToUInt32(key)
      2. Assuming key to be a zero-based index, if the key index is not out of bounds of the element sequence of the tuple type of base
         1. Return TupleReferenceValue(base, key).
   5. Return undefined.
9. If base is a package
   1. Return undefined if key is not a String constant.
   2. Let r be a symbol in base.[[Properties]] whose key is equals key.
   3. Return WrapPropertyReference(ResolveAlias(r)) if r is not undefined.
   4. For each p in base.[[UsePackages]]
      1. Let r be ResolveProperty(p, undefined, key, disambiguation)
      2. Return r if it is not undefined.
   5. Return undefined.
10. If base is a package set
    1. Return undefined if key is not a String constant.
    2. For each p in base.[[Packages]]
       1. Let r be ResolveProperty(p, undefined, key, disambiguation)
       2. Return r if it is not undefined.
    3. Return undefined.
11. Return undefined.

The internal FindPropertyProxy(type) function takes the following steps:

1. Return undefined if type.[[Proxies]] is undefined.
2. Return a method of type.[[Proxies]] whose name equals getProperty.

The internal ResolveScopeProperty(base, qual, key, disambiguation) function takes the following steps:

1. If base is a with scope
   1. If the static type of base.[[Object]] is one of the types { *, XML, XMLList }
      1. Return DynamicScopeReferenceValue(base, qual, key, disambiguation)
   2. Let r be ResolveProperty(base.[[Object]], qual, key, disambiguation)
   3. Return r if it is not undefined.
2. If base is a filter operator scope
   1. Return DynamicScopeReferenceValue(base, qual, key, disambiguation).
3. Let r be undefined.
4. If qual is undefined and key is a String constant
   1. Assign r = a symbol of base.[[Properties]] whose key equals key.
5. If r is not undefined
   1. Assign r = WrapPropertyReference(ResolveAlias(r))
   2. Return r
6. If base is an activation scope and base.[[This]] is not undefined
   1. Assign r = ResolveProperty(base.[[This]], qual, key, disambiguation)
   2. Return r if it is not undefined.
7. If base is a class scope or enum scope
   1. Assign r = ResolveProperty(base.[[Class]], qual, key, disambiguation)
8. Let amb be undefined.
9. If base is a package scope
   1. Assign amb = ResolveProperty(base.[[Package]], qual, key, disambiguation)
   2. It is an ambiguous reference error if r is not undefined
   3. Assign r = amb
10. If qual is undefined and key is a String constant
    1. For each p in base.[[Imports]]
       1. If p.[[Name]] equals key
          1. Assign amb = WrapPropertyReference(ResolveAlias(p))
          2. It is an ambiguous reference error if r is not undefined
          3. Assign r = amb
11. For each op in base.[[OpenPackages]]
    1. Assign amb = ResolveProperty(op, qual, key, disambiguation)
    2. It is an ambiguous reference error if r is not undefined
    3. Assign r = amb
12. If r is undefined and base.[[Parent]] is not undefined
    1. Return ResolveScopeProperty(base.[[Parent]], qual, key)
13. Return r

The internal WrapPropertyReference(prop) function takes the following steps:

1. If prop is a type and prop is either the void type, the * type, a function type, a tuple type, or a T? type
   1. Return TypeAsReferenceValue(prop)
2. Let parent be prop.[[Parent]]
3. If parent is a class or enum, return StaticReferenceValue(parent, prop)
4. If parent is a package, return PackageReferenceValue(parent, prop)
5. Assert that parent is a scope.
6. Return ScopeReferenceValue(parent, prop)

The internal reference values described in this section are used at compile-time to represent references that may be read or overwritten.

In the subsections, disambiguation is one of { default, fixed, dynamic }.

The internal XMLReferenceValue(base, qual, key, disambiguation) reference value has the following characteristics:

• It is not read-only.
• It is not write-only.
• Its static type is *.

The internal DynamicReferenceValue(base, qual, key, disambiguation) reference value has the following characteristics:

• It is not read-only.
• It is not write-only.
• Its static type is *.

The internal StaticReferenceValue(base, prop) reference value has the following characteristics:

• It is read-only if prop is read-only.
• It is write-only if prop is write-only.
• Its static type is PropertyStaticType(prop).

The internal InstanceReferenceValue(base, prop) reference value has the following characteristics:

• It is read-only if prop is read-only.
• It is write-only if prop is write-only.
• Its static type is PropertyStaticType(prop).

The internal ProxyReferenceValue(base, proxy) reference value has the following characteristics:

• proxy is the getProperty() proxy.
• It is read-only if the type hierarchy of the base static type does not define the setProperty() proxy.
• It is not write-only.
• Its static type is the result type of signature of proxy.

The internal TupleReferenceValue(base, index) reference value has the following characteristics:

• index is a zero-based index into the base tuple.
• It is not read-only.
• It is not write-only.
• Its static type is the type of the ith element of the base tuple given where i is index.

The internal ScopeReferenceValue(base, prop) reference value has the following characteristics:

• It is read-only if prop is read-only.
• It is write-only if prop is write-only.
• Its static type is PropertyStaticType(prop).

The internal DynamicScopeReferenceValue(base, qual, key, disambiguation) reference value has the following characteristics:

• It is not read-only.
• It is not write-only.
• Its static type is *.

The internal PackageReferenceValue(base, prop) reference value has the following characteristics:

• It is read-only if prop is read-only.
• It is write-only if prop is write-only.
• Its static type is PropertyStaticType(prop).

The internal TypeAsReferenceValue(type) reference value has the following characteristics:

• It is used for types such as *, void, tuple types and function types.
• It is read-only.
• It is not write-only.
• Its static type is Class.

The static type of a property is determined by the internal PropertyStaticType(prop) function as follows:

• If it is a variable or virtual property, return prop.[[Type]].
• If it is a function, return prop.[[Signature]].
• Assert that it is a type.
• Return Class.

Properties have a fully qualified name which is a left-to-right combination of each p_i.[[Name]] where p is the list of ascending parent definitions and the descending definition and i goes from the ascending.

package q.f { public var x }
import q.f.x
q.f.x

Given a syntax construct e consisting of an Identifier token followed by one or more . IdentifierName productions, the internal ResolveFullyQualifiedName(e) function takes the following steps:

• Let S be a string sequence consisting of each name in E from left-to-right.
• If S matches the fully qualified name of a property P1 from (enclosing scope).[[Imports]], return WrapPropertyReference(P1).

import com.qux.bar.BarType
com.qux.bar.BarType.BETA

• If S minus the trailing name matches the fully qualified name of a package P1 from (enclosing scope).[[OpenPackages]]
  • Let r be ResolveProperty(P1, undefined, trailing name of S)
  • If r is not undefined and PropertyIsVisible(r, enclosing scope) is true
    • Return r.

import com.qux.bar.*
com.qux.bar.BarType.BETA

• If S minus the trailing name matches the name of a package alias P1 from (enclosing scope).[[PackageAliases]]
  • Let r be ResolveProperty(P1, undefined, trailing name of S)
  • If r is not undefined and PropertyIsVisible(r, enclosing scope) is true
    • Return r.

import b = com.qux.bar.*
b.BarType.BETA

• Return undefined.

If e is a different syntax construct, the ResolveFullyQualifiedName() function returns undefined.

Lexical scopes, called solely scopes, are used to represent available lexical names during lexical name lookup.

When creating the base scope of a program, let it be subsequent of the unique scope s.

• Contribute the top-level package to s.[[OpenPackages]].
• Contribute the jet.lang package to s.[[OpenPackages]].

The with scope extends the internal properties of a scope as described in the following table.

The filter operator scope extends the internal properties of a scope as described in the following table.

The activation scope extends the internal properties of a scope as described in the following table.

The class scope extends the internal properties of a scope as described in the following table.

The enum scope extends the internal properties of a scope as described in the following table.

The interface scope extends the internal properties of a scope as described in the following table.

The package scope extends the internal properties of a scope as described in the following table.

Jet programs execute in three phases: parsing, verification and evaluation. The verification and evaluation phases may overlap. The verification phase may occur during compile time wherever possible.

Directive attributes using brackets notation are called meta-data. Meta-data consist of a name and an optional list of key-value entries, including keyless entries.

[N1(x = 10)]
const x

[N2] { f() }

The interpretation of meta-data is implementation defined, except of that of the reserved meta-data listed in the following subsections.

Syntax

MetadataForm :
MetadataName
MetadataName ( MetadataEntryList_opt )

MetadataName :
Identifier
Identifier :: IdentifierName

MetadataEntryList :
MetadataEntry
MetadataEntryList , MetadataEntry

MetadataEntry :
MetadataValue
MetadataName = MetadataValue

MetadataValue :
MetadataName
StringLiteral
NumericLiteral
- NumericLiteral
BooleanLiteral
List ( MetadataEntryList_opt )
File ( FileMetadataPath )

FileMetadataPath :
StringLiteral
output + StringLiteral

Semantics

A MetadataName entry value is equivalent to a string.

NumericLiteral is interpreted as a IEEE 754 double-precision floating point possibly preceded by a minus sign -.

A File entry value is interpreted as resolving to a file. If the path starts with output +, then the file is resolved relative to the artifact output directory of JetDependencies; otherwise the file is resolved relative to the parent directory of the enclosing file.

This section enumerates meta-data that are reserved in certain contexts.

The Literal meta-data is reserved at the class definition. It is used for indicating that the class can be initialized through an object initializer.

The Set meta-data is reserved at the enum definition. It is used for indicating that the enum is a set enumeration.

Syntax

TypeParameters :
. < TypeParameterList ParameterGreaterThan

TypeParameterList :
TypeParameter
TypeParameterList , TypeParameter

TypeParameter :
Identifier

Syntax

TypeExpression :
TypeExpression^noPrefix
? TypeExpression^noPrefix

TypeExpression^noPrefix :
*
Identifier
void
[ TypeExpression ]
( TypeExpression )
TupleTypeExpression
FunctionTypeExpression
TypeExpression^noPrefix . IdentifierName
TypeExpression^noPrefix TypeArguments
TypeExpression^noPrefix ?
TypeExpression^noPrefix !

TypeExpressionList :
TypeExpression
TypeExpressionList , TypeExpression

TypeArguments :
. < TypeArgumentsList ParameterGreaterThan

ParameterGreaterThan :
>
first greater-than > from the offending token

TypeArgumentsList :
TypeExpression
TypeArgumentsList , TypeExpression

TupleTypeExpression :
[ TupleElementTypes ]

TupleElementTypes :
TypeExpression , TypeExpression
TupleElementTypes , TypeExpression

FunctionTypeExpression :
function ( FunctionTypeParameters ) : TypeExpression

FunctionTypeParameters :
«empty»
FunctionTypeParameter
FunctionTypeParameters , FunctionTypeParameter

FunctionTypeParameter :
TypedIdentifier
FunctionTypeOptionalParameter
... TypedIdentifier

TypedIdentifier :
IdentifierName
IdentifierName : TypeExpression

FunctionTypeOptionalParameter :
IdentifierName ?
IdentifierName ? : TypeExpression

Verification

TypeExpression : TypeExpression^noPrefix

• Return the verification result of TypeExpression^noPrefix.

TypeExpression : ? TypeExpression^noPrefix

• Return the verification result of TypeExpression^noPrefix if it is a nullable type.
• Return a nullable type consisting of the verification result of TypeExpression^noPrefix.

TypeExpression^noPrefix : *

• Return the any type.

TypeExpression^noPrefix : Identifier

• Let p be ResolveProperty(enclosing scope, undefined, string of Identifier)
• It is a verify error if p is undefined.
• It is a verify error if PropertyIsVisible(p, enclosing scope) is false.
• It is a verify error if p is not a type and the rule is not followed by a postfix operator.
• It is a verify error if p is a reference value that references a parameterized type and the expression is not followed by TypeArguments.
• Return p.

TypeExpression^noPrefix : void

• Return the void type.

TypeExpression^noPrefix : TupleTypeExpression

• Return the verification of TupleTypeExpression.

TypeExpression^noPrefix : FunctionTypeExpression

• Return the verification of FunctionTypeExpression.

TypeExpression^noPrefix : [ TypeExpression ]

• Return an array type consisting of the verification result of TypeExpression.

TypeExpression^noPrefix : ( TypeExpression )

• Return the verification result of TypeExpression.

TypeExpression^noPrefix : TypeExpression^noPrefix . IdentifierName

• Let p be ResolveFullyQualifiedName(type expression).
• If p is not undefined
  • Return p.
• Let base be the verification result of TypeExpression^noPrefix.
• Let p be ResolveProperty(base, undefined, string of IdentifierName)
• It is a verify error if p is undefined.
• It is a verify error if PropertyIsVisible(p, enclosing scope) is false.
• It is a verify error if p is a reference value that references a parameterized type and the expression is not followed by TypeArguments.
• Return p.

TypeExpression^noPrefix : TypeExpression^noPrefix TypeArguments

• Let base be the verification result of TypeExpression^noPrefix.
• It is a verify error if base is not a type with [[TypeParameters]].
• It is a verify error if base[[TypeParameters]] is empty.
• Let a be the verification sequence of TypeArguments.
• Return a type substitution in base with a as type arguments.

TypeExpression^noPrefix : TypeExpression^noPrefix ?

• Return the verification result of TypeExpression^noPrefix if it is a nullable type.
• Return a nullable type consisting of the verification result of TypeExpression^noPrefix.

TypeExpression^noPrefix : TypeExpression^noPrefix !

• Return a non nullable type from the verification result of TypeExpression^noPrefix.

TupleTypeExpression : [ TupleElementTypes ]

• Let e be an empty list.
• For each e₀ TypeExpression in TupleElementTypes
  • Append to e the verification result of e₀
• Return a tuple type consisting of the element types e.

FunctionTypeExpression : function ( FunctionTypeParameters ) : TypeExpression

• It is a verify error if FunctionTypeParameters is not a sequence of zero or more TypedIdentifier followed by zero or more FunctionTypeOptionalParameter followed by optional … TypedIdentifier.
• Let p₀ be an empty list.
• Let p₁ be an empty list.
• Let p₂ be undefined.
• For each TypedIdentifier as typedId in FunctionTypeParameters
  • Let (name, type) be the verification of typedId.
  • Contribute (name, type) to p₀.
• For each FunctionTypeOptionalParameter as optParam in FunctionTypeParameters
  • Let (name, type) be the verification of optParam.
  • Contribute (name, type) to p₁.
• If FunctionTypeParameters contains … TypedIdentifier as typeId
  • Let (name, type) be the verification of typedId.
  • It is a verify error if type is not the Array type.
  • Assign p₂ = (name, type)
• Let returnType be the verification of TypeExpression preceded by the : result type prefix.
• Return a function type consisting of required parameters p₀, optional parameters p₁, rest parameter p₂ and return type returnType.

TypedIdentifier : IdentifierName
FunctionTypeOptionalParameter : IdentifierName ?

• It is a verify error if no context type is given.
• Return (string of IdentifierName, context type)

TypedIdentifier : IdentifierName : TypeExpression
FunctionTypeOptionalParameter : IdentifierName ? : TypeExpression

• Return (string of IdentifierName, verification of TypeExpression)

TypeArguments : . < TypeArgumentsList ParameterGreaterThan

• Return the verification of each TypeExpression in TypeArgumentsList in a sequence.

The syntactic grammar for expressions declares the β superscript, which denotes a pair of definitions: allowIn and noIn.

Syntax

x
*
q::x
q::[k]     ;
(q)::x     ;
(q)::[k]   ;
@x
@[k]
@q::x
@q::[k]
@(q)::x
@(q)::[k]

The qualifier identifiers fixed and dynamic are context keywords used for indicating a property disambiguation.

o.fixed::x
o.dynamic::x

PropertyIdentifier :
Identifier [when keywords are enabled]
IdentifierName [when keywords are disabled]
*

Qualifier :
PropertyIdentifier

SimpleQualifiedIdentifier :
PropertyIdentifier
Qualifier :: PropertyIdentifier
Qualifier :: Brackets

ExpressionQualifiedIdentifier :
ParenExpression :: PropertyIdentifier
ParenExpression :: Brackets

NonAttributeQualifiedIdentifier :
SimpleQualifiedIdentifier
ExpressionQualifiedIdentifier

QualifiedIdentifier :
@ Brackets
@ NonAttributeQualifiedIdentifier
NonAttributeQualifiedIdentifier

Verification

The Identifier and IdentifierName productions of PropertyIdentifier result into a string consisting of the respective identifier characters. The production of PropertyIdentifier results into the string.

• Let disambiguation be default.

The qualifier PropertyIdentifier preceding the :: punctuator is treated as follows:

• If it is equals fixed or dynamic
  • Assign disambiguation = string of PropertyIdentifier
• Else
  • Let qid be the translation of it into a PrimaryExpression : QualifiedIdentifier.
  • Verify qid as such production limited to the Namespace type.
  • Let the qualifier be the value of qid.

The qualifier ParenExpression preceding the :: punctuator is treated as follows:

• Limit the ParenExpression symbol to the Namespace type.

Brackets must be of the String type.

Verifying QualifiedIdentifier results into a (qual, key, disambiguation) group consisting of an optional qualifier Namespace object, a key String value and disambiguation respectively.

Evaluation

The qualifier PropertyIdentifier preceding the :: punctuator translates to a PrimaryExpression : QualifiedIdentifier and is evaluated as such production.

Syntax

PrimaryExpression :
NullLiteral
BooleanLiteral
NumericLiteral
StringLiteral
ThisLiteral
RegularExpressionLiteral
QualifiedIdentifier
XMLInitializer
ParenListExpression
ArrayLiteral
ObjectInitializer
EmbedExpression

NullLiteral :
null

BooleanLiteral :
true
false

ThisLiteral :
this

Verification

PrimaryExpression : NullLiteral

• If the context type is T?
  • Return a null constant of the context type.
• Return a null constant of the * type.

PrimaryExpression : NumericLiteral

• If the context type is N or N? where N is a number type
  • Return a number constant consisting of the NumericLiteral mathematical value of the context type.
• Return a number constant consisting of the NumericLiteral mathematical value of the Number type.

PrimaryExpression : StringLiteral

• If the context type is Char or Char?
  • It is a verify error if the string of StringLiteral does not consist of a single Unicode Scalar Value.
  • Return a Char constant of the context type whose value is the first Unicode Scalar Value of the StringLiteral string.
• If the context type is E or E? where E is an enum
  • Let s be the string of StringLiteral.
  • It is a verify error if E contains no enum member with a string equals s.
  • Return an enum constant, of the context type, identifying the enum member of E with a string equals s.
• Return a string constant of the String type consisting of the string of StringLiteral.

PrimaryExpression : QualifiedIdentifier

• Let (qual, key, disambiguation) be the result of verifying the nonterminal symbol on right-hand side of the production.
• Let r be ResolveProperty(enclosing scope, qual, key, disambiguation).
• It is a verify error if r is undefined.
• It is a verify error if PropertyIsVisible(r, enclosing scope) is false.
• It is a verify error if r is a reference value that references a parameterized type and the expression is not followed by TypeArguments.
• If r is a reference value to a constant c where c.[[ConstantInitializer]] is not undefined
  • Return c.[[ConstantInitializer]]
• Return r.

PrimaryExpression : ThisLiteral

• Let act be the enclosing activation.
• It is a verify error if act is undefined or if act[[This]] is undefined.
• Return act[[This]].

PrimaryExpression : RegularExpressionLiteral

• Return a value of type RegExp.

PrimaryExpression : BooleanLiteral

• If BooleanLiteral is true, return a boolean constant of value true of the Boolean type.
• Return a boolean constant of value false of the Boolean type.

PrimaryExpression : ParenListExpression
PrimaryExpression : EmbedExpression
PrimaryExpression : XMLInitializer
PrimaryExpression : ArrayLiteral
PrimaryExpression : ObjectInitializer

• Return the result of verifying the nonterminal symbol on right-hand side of the production.

Syntax

ParenExpression :
( AssignmentExpression^allowIn )

ParenListExpression :
ParenExpression
( ListExpression^allowIn , AssignmentExpression^allowIn )

Syntax

ObjectInitializer :
{ FieldList }

FieldList :
«empty»
NonEmptyFieldList
NonEmptyFieldList ,

NonEmptyFieldList :
InitializerField
InitializerRest
NonEmptyFieldList , InitializerField
NonEmptyFieldList , InitializerRest

InitializerRest :
... AssignmentExpression^allowIn

InitializerField :
FieldName : AssignmentExpression^allowIn
IdentifierName

FieldName :
IdentifierName
Brackets
StringLiteral
NumericLiteral

Semantics

The object initializer may be used to initialize the following types:

• *
• Object
• Map.<K, V>
• Set enumerations
• Classes containing the [Literal] meta-data

Initializing a type that is one of { *, Object, Object? } results into a Map.<*, *> object.

The default context type is the Map.<*, *> type.

Verification

A field item is either an InitializerRest or an InitializerField, from left-to-right.

ObjectInitializer

• Let ctxType be the initially given context type or Map.<*, *> otherwise.
• Match the nonterminal symbol with AnyOrObject(ctxType).
• Otherwise match the nonterminal symbol with Map(ctxType).
• Otherwise match the nonterminal symbol with SetEnum(ctxType).
• Otherwise match the nonterminal symbol with LiteralClass(ctxType).
• Otherwise throw a verify error.

ResolveShorthand(IdentifierName) internal function

• Let r be ResolveProperty(enclosing scope, undefined, IdentifierName string).
• Throw a verify error if r is undefined.
• Throw a verify error if PropertyIsVisible(ref, enclosing scope) is false.
• Throw a verify error if r is a reference value that references a parameterized type.
• Return r

ResolveInstanceVariable(C, name) internal function

• Let variable be a non-inherited instance variable of C whose [[Name]] equals the name string.
• Throw a verify error if variable is undefined.
• Throw a verify error if PropertyIsVisible(variable, enclosing scope) is false.
• Return variable.

AnyOrObject(ctxType) internal verification

• If ctxType is not one of { *, Object, Object?, Map.<*, *>, Map.<*, *>? }, return match failure.
• For each field item field
  • If field is InitializerRest
    • Limit the type of the expression of field to Map.<*, *>.
  • Else if the field is a shorthand field IdentifierName
    • Call ResolveShorthand(IdentifierName).
  • Else
    • If the FieldName of field is a Brackets symbol
      • Verify the Brackets symbol.
    • Verify the AssignmentExpression^allowIn symbol of the InitializerField.
• Return a value of the ctxType type.

Map(ctxType) internal verification

• If ctxType is not M or M?, where M is Map.<K, V>, return match failure.
• For each field item field
  • If field is InitializerRest
    • Limit the type of the expression of field to Map.<K, V>.
  • Else if the field is a shorthand field IdentifierName
    • Let shortRef be ResolveShorthand(IdentifierName).
    • Limit the static type of shortRef to V.
    • Throw a verify error if K is not one of { *, Object, String }.
  • Else
    • If the FieldName of field is a Brackets symbol
      • Limit the type of the Brackets expression to K.
    • Else if the FieldName of field is an IdentifierName symbol
      • Throw a verify error if K is not one of { *, Object, String }.
    • Else if the FieldName of field is a StringLiteral symbol
      • Throw a verify error if K is not one of { *, Object, String }.
    • Else if the FieldName of field is a NumericLiteral symbol
      • Throw a verify error if K is not one of { *, Object, Number }.
    • Limit the type of the AssignmentExpression^allowIn symbol of the InitializerField to V.
• Return a value of the ctxType type.

SetEnum(ctxType) internal verification

• If ctxType is not E or E?, where E is a set enumeration, return match failure.
• Let c be zero.
• Let isConst be true.
• For each field item field
  • If field is InitializerRest
    • Let c1 be the result of limiting the type of the expression of field to E.
    • If c1 is an enum constant and isConst is true
      • Assign c = bitwise OR(c, number of c1)
    • Else assign isConst = false
  • Else if the field is a shorthand field IdentifierName
    • Let shortRef be ResolveShorthand(IdentifierName).
    • Limit the static type of shortRef to Boolean.
    • Let member be an enumeration member of E whose string equals the IdentifierName string
    • Throw a verify error if member is undefined.
    • If shortRef is a boolean constant and isConst is true
      • If shortRef boolean is true
        • Assign c = bitwise OR(c, number of member)
      • Else assign c = erase bits of (number of member) from c if all bits are included
    • Else assign isConst = false
  • Else
    • Let c1 be the result of limiting the type of the AssignmentExpression^allowIn symbol of the InitializerField to E.
    • If the FieldName of field is a Brackets symbol
      • Limit the type of the Brackets expression to String.
      • Assign isConst = false
    • Else if the FieldName of field is an IdentifierName symbol or a StringLiteral symbol
      • Let member be an enumeration member of E whose string equals the string of the IdentifierName symbol or StringLiteral symbol.
      • Throw a verify error if member is undefined.
      • If c1 is a boolean constant and isConst is true
        • If c1 boolean is true
          • Assign c = bitwise OR(c, number of member)
        • Else assign c = erase bits of (number of member) from c if all bits are included
      • Else assign isConst = false
    • Else if the FieldName of field is a NumericLiteral symbol
      • Throw a verify error.
• If isConst is true
  • Return an enum constant with number c and static type as ctxType.
• Return a value of the ctxType type.

LiteralClass(ctxType) internal verification

• If ctxType is not C or C?, where C is a class and C[[AllowLiteral]] is true, return match failure.
• Let missing be a set containing all non optional non-inherited instance variables of C.
• For each field item field
  • If field is InitializerRest
    • Limit the type of the expression of field to C.
    • Assign missing = empty set
  • Else if the field is a shorthand field IdentifierName
    • Let variable be ResolveInstanceVariable(C, IdentifierName string).
    • Remove variable from the missing set.
    • Let shortRef be ResolveShorthand(IdentifierName).
    • Limit the static type of shortRef to variable[[Type]].
  • Else
    • If the FieldName of field is a Brackets symbol
      • Limit the type of the Brackets expression to String.
      • Verify the AssignmentExpression^allowIn symbol of the InitializerField.
      • Assign missing = empty set
    • Else if the FieldName of field is an IdentifierName symbol or a StringLiteral symbol
      • Let variable be ResolveInstanceVariable(C, IdentifierName string or StringLiteral string).
      • Remove variable from the missing set.
      • Limit the type of the AssignmentExpression^allowIn symbol of the InitializerField to variable[[Type]].
    • Else if the FieldName of field is a NumericLiteral symbol
      • Verify the AssignmentExpression^allowIn symbol of the InitializerField.
      • Throw a verify error.
• Throw a verify error if missing is a non empty set.
• Return a value of the ctxType type.

Syntax

ArrayLiteral :
[ Elision_opt ]
[ ElementList ]
[ ElementList , Elision_opt ]

Elision :
,
Elision ,

ElementList :
Elision_opt AssignmentExpression^allowIn
Elision_opt InitializerRest
ElementList , Elision_opt AssignmentExpression^allowIn
ElementList , Elision_opt InitializerRest

Semantics

The array initializer may be used to initialize the following types:

• *
• Object
• Tuple types
• [T]
• Set enumerations

Initializing * or Object results in constructing a [*] object.

By default, the array initializer results in an object of the [*] type.

Elision commas result into undefined elements.

const list = [,,,]
list.length == 3
list[0] === undefined

Verification

ArrayLiteral

• Let ctxType be the initially given context type or the [*] type otherwise.
• Match the nonterminal symbol with AnyOrObject(ctxType).
• Otherwise match the nonterminal symbol with Tuple(ctxType).
• Otherwise match the nonterminal symbol with Array(ctxType).
• Otherwise match the nonterminal symbol with SetEnum(ctxType).
• Otherwise throw a verify error.

VerifyRest(r, T) internal function

• Verifying the expression of the InitializerRest nonterminal symbol r must return a value where either whose static type includes the values() proxy proxy or where whose static type is equals or a subtype of Iterator.<T>.
• If proxy is not undefined, its signature must return Iterator.<T> or a subtype of Iterator.<T>.

An element item corresponds to either an Elision, AssignmentExpression^allowIn or InitializerRest, from left-to-right.

AnyOrObject(ctxType) internal verification

• If ctxType is not one of { *, Object, Object?, [*], [*]? }, return match failure.
• For each element item elem
  • If elem is InitializerRest
    • VerifyRest(elem, *)
  • Else if elem is AssignmentExpression^allowIn
    • Verify elem
• Return a value of the ctxType type.

Tuple(ctxType) internal verification

• If ctxType type is not T or T? where T is a tuple type, return match failure.
• For each element index i element item elem
  • If elem is ,
    • Throw a verify error
  • Else if elem is InitializerRest
    • Throw a verify error
  • Else if elem is AssignmentExpression^allowIn
    • It is a verify error if i is equals or greater than the element length of T.
    • Limit elem to the ith element type of T.
• Return a value of the ctxType type.

When verifying ArrayLiteral, if the context type is [T] or [T]?:

Array(ctxType) internal verification

• If ctxType type is not [T] or [T]?, return match failure.
• For each element item elem
  • If elem is ,
    • Throw a verify error
  • Else if elem is InitializerRest
    • VerifyRest(elem, T)
  • Else if elem is AssignmentExpression^allowIn
    • Limit elem to T type.
• Return a value of the ctxType type.

SetEnum(ctxType) internal verification

• If ctxType type is not E or E? where E is a set enumeration, return match failure.
• Let c be zero.
• Let isConst be true.
• For each element item elem*
  • If elem is ,
    • Throw a verify error
  • Else if elem is InitializerRest
    • Throw a verify error
  • Else if elem is AssignmentExpression^allowIn
    • Let c1 be the result of limiting elem to the E type.
    • If c1 is an enum constant and isConst is true
      • Assign c = bitwise OR(c, number of c1)
    • Else
      • Assign isConst = false
• If isConst is true
  • Return an enum constant with number c and static type as ctxType.
• Return a value of the ctxType type.

Syntax

XMLInitializer :
XMLMarkup
XMLElement
< > XMLElementContent </ >

XMLElement :
< XMLTagContent XMLWhitespace_opt />
< XMLTagContent XMLWhitespace_opt > XMLElementContent </ XMLTagName XMLWhitespace_opt >

XMLTagContent :
XMLTagName XMLAttributes

XMLTagName :
{ AssignmentExpression^allowIn }
XMLName

XMLAttributes :
XMLWhitespace { AssignmentExpression^allowIn }
XMLAttribute XMLAttributes
«empty»

XMLAttribute :
XMLWhitespace XMLName XMLWhitespace_opt = XMLWhitespace_opt { AssignmentExpression^allowIn }
XMLWhitespace XMLName XMLWhitespace_opt = XMLWhitespace_opt XMLAttributeValue

XMLElementContent :
{ AssignmentExpression^allowIn } XMLElementContent
XMLMarkup XMLElementContent
XMLText XMLElementContent
XMLElement XMLElementContent
«empty»

Semantics

Interpolation expressions such as in <>{x}</> result in string concatenation.

Verification

XMLInitializer : XMLMarkup

• Return a value of the XML type.

XMLInitializer : XMLElement

• Verify the nonterminal symbol on right-hand side of the production.
• Return a value of the XML type.

XMLInitializer : < > XMLElementContent </ >

• Verify the XMLElementContent nonterminal.
• Return a value of the XMLList type.

XMLElement

• Verify every root AssignmentExpression^allowIn.

XMLElementContent

• Verify every root AssignmentExpression^allowIn.

The embed expression is used to embed static files in the program at compile time. It may be used to embed a file either as a ByteArray object or as an UTF-8 encoded String text.

const text = embed {
    source: "path/to/data.txt",
    type: String,
};
const bytes = embed {
    source: "path/to/data.bin",
    type: ByteArray,
};

The embed expression allows resolving files from the JetDependencies output directory:

const bytes = embed {
    source: output + "auto/generated.bin",
    type: ByteArray,
};

Syntax

EmbedExpression :
embed ObjectInitializer

Semantics

The ObjectInitializer symbol as part of the embed expression is read as a compile-time description pointing to a file as the source property and its result type as the type property. The result type must be either String or ByteArray.

• A result type of String indicates that the file is read as an UTF-8 encoded text.
• A result type of ByteArray indicates that the file is read as binary data.

The source property of ObjectInitializer may be specified in one of the following forms:

• A StringLiteral production resolving to a file path (value of the StringLiteral) relative to the file path of the program.
• An output + StringLiteral production resolving to a file path (value of the StringLiteral) relative to the JetDependencies output directory.

If the result type is unspecified, it is set to the context type.

Verification

• It is a verify error if fields other than source and type are present.
• It is a verify error if the source field is unspecified.
• Let filePath be a string
• If the source field consists of a StringLiteral production
  • Assign filePath = resolution from the file path of the source file to the file path specified by the StringLiteral string.
• Else if the source field consists of a output + StringLiteral production
  • Assign filePath = resolution from the JetDependencies output directory to the file path specified by the StringLiteral string.
• Else it is a verify error.
• Let resultType be undefined.
• Let typeExp be the refining of the value of the type field of ObjectInitializer into a TypeExpression.
• Assign resultType = ExpectType(verification of typeExp)
• If resultType is undefined, assign resultType = context type.
• resultType is converted to a non-nullable type if it is explicitly nullable.
• It is a verify error if resultType is undefined or resultType is not one of { ByteArray, String }.
• Let v be an embed value of type resultType.
• If resultType is ByteArray
  • Let content be the bytes from the file path filePath.
  • Contribute content to v.
• Else if resultType is String
  • Let content be an UTF-8 encoded text from the file path filePath.
  • Contribute content to v.
• Return v.

Syntax

SuperExpression :
super
super Arguments

Syntax

PostfixExpression :
FullPostfixExpression
ShortNewExpression

FullPostfixExpression :
PrimaryExpression
MetaProperty
FullNewExpression
FullPostfixExpression PropertyOperator
SuperExpression PropertyOperator
FullPostfixExpression NonNull
FullPostfixExpression Arguments
FullPostfixExpression TypeArguments
FullPostfixExpression QueryOperator
FullPostfixExpression [no line break] ++
FullPostfixExpression [no line break] --
FullPostfixExpression OptionalChaining

NonNull :
!

OptionalChaining :
?. QualifiedIdentifier
?. Brackets
?. Arguments
OptionalChaining PropertyOperator
OptionalChaining NonNull
OptionalChaining Arguments
OptionalChaining TypeArguments
OptionalChaining QueryOperator
OptionalChaining OptionalChaining

Semantics

Fully qualified names are preprocessed on postfix expressions by calling ResolveFullyQualifiedName(postfix expression).

Syntax

PropertyOperator :
. QualifiedIdentifier
Brackets

Brackets :
[ ListExpression^allowIn ]

Syntax

QueryOperator :
.. QualifiedIdentifier
. ( ListExpression^allowIn )

Syntax

Arguments :
( )
( ListExpression^allowIn )

ArgumentList^allowIn :
AssignmentExpression^β
ArgumentList^β , AssignmentExpression^β

Semantics

The call operator over a type base is equivalent to an explicit type conversion. In the following program, v is verified with the context type T and then explicitly converted to T.

T(v)

Syntax

MetaProperty :
ImportMeta

ImportMeta :
import . meta

Semantics

The import.meta expression returns the import.meta symbol. The import.meta symbol is a value is of the any type (*) and returns undefined wherever used unless a property accessor follows the expression.

Syntax

FullNewExpression :
new FullNewSubexpression Arguments

FullNewSubexpression :
PrimaryExpression
FullNewExpression
FullNewSubexpression PropertyOperator
SuperExpression PropertyOperator

ShortNewExpression :
new ShortNewSubexpression

ShortNewSubexpression :
FullNewSubexpression
ShortNewExpression

Semantics

The new expression is used to instantiate a class.

The new expression must not be used to instantiate static classes and enumerations.

Syntax

UnaryExpression :
PostfixExpression
delete PostfixExpression
void UnaryExpression
await UnaryExpression
typeof UnaryExpression
++ PostfixExpression
-- PostfixExpression
+ UnaryExpression
- UnaryExpression
~ UnaryExpression
! UnaryExpression

The binary operators are left-associative, excluding the following cases:

• The exponentiation operator is right-associative.

The short circuit operators (||, ^^) have the lowest precedence and the exponentiation operator (**) has the highest precedence.

Syntax

ExponentiationExpression :
UnaryExpression
UnaryExpression ** ExponentiationExpression

Syntax

MultiplicativeExpression :
ExponentiationExpression
MultiplicativeExpression * ExponentiationExpression
MultiplicativeExpression / ExponentiationExpression
MultiplicativeExpression % ExponentiationExpression

Syntax

AdditiveExpression :
MultiplicativeExpression
AdditiveExpression + MultiplicativeExpression
AdditiveExpression - MultiplicativeExpression

Syntax

ShiftExpression :
AdditiveExpression
ShiftExpression << AdditiveExpression
ShiftExpression >> AdditiveExpression
ShiftExpression >>> AdditiveExpression

Syntax

RelationalExpression^β :
ShiftExpression
RelationalExpression^β > ShiftExpression
RelationalExpression^β < ShiftExpression
RelationalExpression^β <= ShiftExpression
RelationalExpression^β >= ShiftExpression
RelationalExpression^β as ShiftExpression
RelationalExpression^β is ShiftExpression
RelationalExpression^β is not ShiftExpression
[β = allowIn] RelationalExpression^β in ShiftExpression
[β = allowIn] RelationalExpression^β not in ShiftExpression

Syntax

EqualityExpression^β :
RelationalExpression^β
EqualityExpression^β == RelationalExpression^β
EqualityExpression^β != RelationalExpression^β
EqualityExpression^β === RelationalExpression^β
EqualityExpression^β !== RelationalExpression^β

Syntax

BitwiseAndExpression^β :
EqualityExpression^β
BitwiseAndExpression^β & EqualityExpression^β

BitwiseXorExpression^allowIn :
BitwiseAndExpression^β
BitwiseXorExpression^β ^ BitwiseAndExpression^β

BitwiseOrExpression^allowIn :
BitwiseXorExpression^β
BitwiseOrExpression^β | BitwiseXorExpression^β

Syntax

LogicalAndExpression^β :
BitwiseOrExpression^β
LogicalAndExpression^β && BitwiseOrExpression^β

LogicalXorExpression^allowIn :
LogicalAndExpression^β
LogicalXorExpression^β ^^ LogicalAndExpression^β

LogicalOrExpression^allowIn :
LogicalXorExpression^β
LogicalOrExpression^β || LogicalXorExpression^β

Syntax

CoalesceExpression^β :
CoalesceExpressionHead^β ?? BitwiseOrExpression^β

CoalesceExpressionHead^allowIn :
CoalesceExpression^β
BitwiseOrExpression^β

Syntax

ShortCircuitExpression^β :
LogicalOrExpression^β
CoalesceExpression^β

Syntax

ConditionalExpression^β :
ShortCircuitExpression^β
ShortCircuitExpression^β ? AssignmentExpression^β : AssignmentExpression^β

Syntax

NonAssignmentExpression^β :
ShortCircuitExpression^β
yield [no line break] NonAssignmentExpression^β
FunctionExpression^β
ShortCircuitExpression^β ? NonAssignmentExpression^β : NonAssignmentExpression^β

Syntax

AssignmentExpression^β :
ConditionalExpression^β
yield [no line break] AssignmentExpression^β
FunctionExpression^β
AssignmentLeftHandSide = AssignmentExpression^β
PostfixExpression CompoundAssignmentPunctuator AssignmentExpression^β
PostfixExpression /= AssignmentExpression^β

AssignmentLeftHandSide :
ArrayDestructuring
ObjectDestructuring
PostfixExpression [but not ArrayDestructuring or ObjectDestructuring]

Verification

AssignmentExpression^β : ConditionalExpression^β

• Return the result of verifying the nonterminal symbol on right-hand side of the production.

AssignmentExpression^β : FunctionExpression^β

• Return the result of verifying the nonterminal symbol on right-hand side of the production.

Syntax

FunctionExpression^β :
function FunctionCommon^β
function IdentifierName FunctionCommon^β

Semantics

The function expression results in an object of a function type compliant to the function signature. The language does not perform type inference on function signatures.

// 30
trace([10, 20].reduce(function(acc: Number, v: Number): Number (acc + v), 0));

A call to a function resulting from a function expression has implementation-defined behavior: the number of formal parameters may or may not be restricted to the number of call arguments.

Verification

FunctionExpression^β : function FunctionCommon^β
FunctionExpression^β : function IdentifierName FunctionCommon^β

• Let act be an activation scope.
• Let signature be the result of verifying the FunctionSignature symbol within FunctionCommon by passing act as the activation scope act, therefore contributing properties to act.
• Let f be a function.
• If the IdentifierName symbol appears
  • Assign f.[[Name]] = IdentifierName string
• Assign f.[[IsGenerator]] = true if the yield operator appears within the function body or false otherwise
• Assign f.[[IsAsync]] = true if the await operator appears within the function body or false otherwise
• Assign f.[[Signature]] = signature
• Assign act.[[This]] = (enclosing activation).[[This]] or undefined.
• Assign act.[[Function]] = f
• Assign f.[[Activation]] = act
• If f.[[Name]] is a non empty string
  • It is a verify error if act.[[Properties]].[f.[[Name]]] is already defined.
  • Let thisFunc be a read-only variable of the signature type whose name is f.[[Name]].
  • Assign thisFunc.[[Parent]] = act.
  • Assign act.[[Properties]].[f.[[Name]]] = thisFunc.
• Call VerifyFunctionBody(the FunctionCommon symbol, act, f, signature)
• Return a function value of the signature type and act activation.

Syntax

ListExpression^β :
AssignmentExpression^β
ListExpression^β , AssignmentExpression^β

Syntax

Destructuring :
Identifier [if keywords are enabled]
IdentifierName [if keywords are disabled]
ArrayDestructuring
ObjectDestructuring
Destructuring NonNull [lookahead ∉ NonNull]

ArrayDestructuring :
[ Elision_opt ]
[ DestructuringElementList ]
[ DestructuringElementList , Elision_opt ]

ObjectDestructuring :
{ DestructuringFields_opt }
{ DestructuringFields , }

TypedDestructuring :
Destructuring
Destructuring : TypeExpression

DestructuringElementList :
Elision_opt Destructuring^allowIn
Elision_opt DestructuringRest
DestructuringElementList , Elision_opt Destructuring^allowIn
DestructuringElementList , Elision_opt DestructuringRest

DestructuringRest :
... Destructuring

DestructuringFields :
DestructuringField
DestructuringFields , DestructuringField

DestructuringField :
FieldName NonNull_opt : Destructuring^allowIn
IdentifierName NonNull_opt

Semantics

Array destructuring is allowed for the following context types:

• * type — Yields * typed elements.
• [T1, T2, …] type — Yields tuple reference values.
• Classes defining a getProperty() proxy that takes the Number type
  • Yields proxy reference values.
  • Destructuring assignments require a corresponding setProperty() proxy in the same class.

const [x, y, , ,] = a

Object destructuring is allowed for any context type, except void.

const {x, y} = o

Verification

The ω superscript used throughout the specification translates to one of { abbrev, noShortIf, full }.

Syntax

Statement^ω :
SuperStatement Semicolon^ω
BlockAttributes_opt Block
IfStatement^ω
SwitchStatement
DoStatement Semicolon^ω
WhileStatement^ω
ForStatement^ω
WithStatement^ω
ContinueStatement Semicolon^ω
BreakStatement Semicolon^ω
ReturnStatement Semicolon^ω
ThrowStatement Semicolon^ω
TryStatement
ExpressionStatement Semicolon^ω
LabeledStatement^ω
DefaultXMLNamespaceStatement

Substatement^ω :
EmptyStatement
Statement^ω

Substatements :
«empty»
SubstatementsPrefix Substatement^abbrev

SubstatementsPrefix :
«empty»
SubstatementsPrefix Substatement^full

Semicolon^abbrev :
;
VirtualSemicolon
«empty»

Semicolon^noShortIf :
Semicolon^abbrev

Semicolon^full :
;
VirtualSemicolon

Syntax

EmptyStatement :
;

Syntax

ExpressionStatement :
[lookahead ∉ { function, { }] ListExpression^allowIn

Syntax

SuperStatement :
super Arguments

Syntax

Block :
{ Directives }

Semantics

The block statement may contain meta-data.

[N1(n2 = 10)] {
    trace("Log")
}

Syntax

LabeledStatement^ω :
Identifier : Substatement^ω

Syntax

IfStatement^abbrev :
if ParenListExpression Substatement^abbrev
if ParenListExpression Substatement^noShortIf else Substatement^abbrev

IfStatement^full :
if ParenListExpression Substatement^full
if ParenListExpression Substatement^noShortIf else Substatement^full

IfStatement^noShortIf :
if ParenListExpression Substatement^noShortIf else Substatement^noShortIf

The switch statement is similiar to that of Java. Unlike in Java, the switch statement does not include fallthroughs.

A switch statement applied to a discriminant whose context type is an enum must be exhaustive and it must contain case elements matching all of the enum members.

switch (item.category) {
    case "fine":
    case "moderate":
        trace("Fine")
    default:
        trace("Something else")
}

The switch type statement is used to match the type of a discriminant value.

switch type (v) {
    case (d: Date) {
        // Date
    }
    default {
        // No matched case
    }
}

Syntax

SwitchStatement :
switch ParenListExpression { CaseElements^abbrev }
switch [no line break] type ParenListExpression { TypeCaseElements }

CaseElements^ω :
«empty»
CaseElement^ω
CaseElements^full CaseElement^ω

CaseElement^ω :
CaseLabel_{1,} CaseDirectives^ω

CaseLabel :
case ListExpression^allowIn :
default :

CaseDirectives^ω :
Directive^ω
CaseDirectives^full Directive^ω

TypeCaseElements :
«empty»
TypeCaseElement
TypeCaseElements TypeCaseElement

TypeCaseElement :
case ( TypedDestructuring ) Block
default Block

Syntax

DoStatement :
do Substatement^abbrev while ParenListExpression

Syntax

WhileStatement^ω :
while ParenListExpression Substatement^ω

The for…in statement is used to iterate the keys of an object through the keys() proxy.

for (const key in map) {
    trace(key)
}

The for each statement is used to either iterate the values of an Iterator implementor or iterate the values of an object through the values() proxy.

for each (const value in array) {
    trace(value)
}

Syntax

ForStatement^ω :
for ( ForInitializer ; ListExpression^allowIn_opt ; ListExpression^allowIn_opt ) Substatement^ω
for ( ForInBinding in ListExpression^allowIn ) Substatement^ω
for [no line break] each ( ForInBinding in ListExpression^allowIn ) Substatement^ω

ForInitializer :
«empty»
ListExpression^noIn
VariableDefinition^noIn

ForInBinding :
PostfixExpression
VariableDefinitionKind VariableBinding^noIn

Syntax

ContinueStatement :
continue
continue [no line break] Identifier

Syntax

BreakStatement :
break
break [no line break] Identifier

Syntax

WithStatement^ω :
with ParenListExpression Substatement^ω

Syntax

ReturnStatement :
return
return [no line break] ListExpression^allowIn

Syntax

ThrowStatement :
throw [no line break] ListExpression^allowIn

Syntax

TryStatement :
try Block CatchClauses
try Block CatchClauses_opt finally Block

CatchClauses :
CatchClause
CatchClauses CatchClause

CatchClause :
catch ( TypedDestructuring ) Block

Syntax

DefaultXMLNamespaceStatement :
default [no line break] xml [no line break] namespace = NonAssignmentExpression^allowIn

Syntax

Directive^ω :
EmptyStatement
Statement^ω
Attributes_opt AnnotatableDirective^ω
ImportDirective Semicolon^ω
UsePackageDirective Semicolon^ω
ConfigurationDirective

AnnotatableDirective^ω :
VariableDefinition^allowIn Semicolon^ω
FunctionDefinition
ClassDefinition
EnumDefinition
InterfaceDefinition
TypeDefinition Semicolon^ω

Directives :
«empty»
DirectivesPrefix Directive^abbrev

DirectivesPrefix :
«empty»
DirectivesPrefix Directive^full

Attributes are in the sequence of meta-data followed by modifier keywords.

Syntax

Attributes :
Attribute AttributeLineBreakRestriction
AttributeCombination AttributeLineBreakRestriction

AttributeCombination :
Attribute AttributeLineBreakRestriction Attributes

BlockAttributes :
Metadata
BlockAttributes Metadata

AttributeLineBreakRestriction :
no line break if the previous and offending tokens match an IdentifierName

Attribute :
Metadata
public
private
protected
internal
proxy
final
native
static
abstract
override

Metadata :
MetadataPreRestriction [ MetadataForm ]]
MetadataPreRestriction [ MetadataForm MetadataTrailingComma ]

MetadataPreRestriction :
if the Metadata is in the beginning of Attributes or if the Metadata appears before an IdentifierName in Attributes

MetadataTrailingComma :
comma , if the Metadata is the first occurrence in Attributes or BlockAttributes

The configuration directive expands blocks to the enclosing block or context if their compile time condition matches.

configuration {
    if (debug) {
        /* Debug */
    } else {
        /* Release */
    }
}

Syntax

ConfigurationDirective :
configuration { ConfigurationSubdirective }

ConfigurationSubdirective :
Block
if ( ConfigurationExpression ) Block
if ( ConfigurationExpression ) Block else ConfigurationSubdirective

ConfigurationExpression :
ConfigurationPrimaryExpression
ConfigurationPrimaryExpression && ConfigurationExpression
ConfigurationPrimaryExpression || ConfigurationExpression

ConfigurationPrimaryExpression :
ConfigurationConstant
ConfigurationConstant ConfigurationEquality Identifier
ConfigurationConstant ConfigurationEquality StringLiteral
( ConfigurationExpression )
! ConfigurationPrimaryExpression

ConfigurationConstant :
Identifier
Identifier :: IdentifierName

ConfigurationEquality :
=
!=

Semantics

A configuration expression of the form x is equivalent to checking whether a constant x is present in the JetDependencies compilation.

Syntax

ImportDirective :
import PackageName . *
import PackageName . IdentifierName
import Identifier = PackageName . *
import Identifier = PackageName . IdentifierName

Semantics

An import p.*; directive contributes the p package to (enclosing scope).[[OpenPackages]].

package p { public var x }
import p.*
p.x
x

An import p.x; directive contributes the x property of the p package to (enclosing scope).[[Imports]]. It is a verify error if PropertyIsVisible(p.x, enclosing scope) is false.

package p { public var x }
import p.x
p.x
x

An import p2 = p1.*; directive contributes an alias p2 of the package p1 to (enclosing scope).[[PackageAliases]].

package p1 { public var x }
import p2 = p1.*
var x
p2.x
x

An import y = p.x; directive assigns (enclosing scope).[[Properties]][y] an alias y of the x property of the p package.

• It is a verify error if (enclosing scope).[[Properties]][y] already exists before the assignment.
• It is a verify error if PropertyIsVisible(p.x, enclosing scope) is false.

package p { public var x }
import y = p.x
y

The use directive is used to export definitions from another package to the enclosing package.

package p1 {}
package p2 { use package p1.* }

Syntax

UsePackageDirective :
use package PackageName . *
use package PackageName . IdentifierName
use package Identifier = PackageName . IdentifierName

Semantics

An use directive must be directly enclosed by a package block.

A use package p.*; directive contributes the p package to (enclosing package).[[UsePackages]].

package p1 { public var x }
package p2 { use package p1.* }

A use package p.x; directive assigns (enclosing packages).[[Properties]].[x] an alias x of the x property of the p package.

• It is a verify error if (enclosing packages).[[Properties]].[x] is already defined before the assignment.
• It is a verify error if PropertyIsVisible(p.x, enclosing scope) is false.

package p1 { public var x }
package p2 { use package p1.x }

A use package y = p.x; directive assigns (enclosing package).[[Properties]].[y] an alias y of the x property of the p package.

• It is a verify error if (enclosing package).[[Properties]].[y] is already defined before the assignment.
• It is a verify error if PropertyIsVisible(p.x, enclosing scope) is false.

package p1 { public var x }
package p2 { use package y = p1.x }

Syntax

VariableDefinition^β :
VariableDefinitionKind VariableBindingList^β

VariableDefinitionKind :
var
const

VariableBindingList^β :
VariableBinding^β
VariableBindingList^β , VariableBinding^β

VariableBinding^β :
TypedDestructuring VariableInitialization^β

VariableInitialization^β :
«empty»
= AssignmentExpression^β

Local variables

Variables of an activation are block-scoped and shadow any previous definition.

const x: String = ""
const x: Number = 0

Type inference

If a variable has no type annotation and but has an initializer, its static type is that of the initializer. If a variable has no type annotation and no initializer, the variable is of the * type.

// x: *
var x
// x: Number
var x = 10
for each (var v in ["x", "y"]) {
    // v: *
}
function f(a) {
    // a: *
}

Semantics

A VariableDefinition may be modified by the following attributes: