ECMAScript 4 Netscape Proposal

Monday, June 30, 2003

A one-page version of this document is also available.

This document is Netscape’s proposal to the ECMA TC39TG1 working group for the ECMAScript Edition 4 language. This proposal is being updated continuously to match issues resolved in the committee discussions. The TC39TG1 working group’s current schedule calls for a release of a ECMAScript Edition 4 standard sometime in 2002.

See also a draft of the specification under construction in PDF format.

JavaScript 2.0 is a slight superset of ECMAScript Edition 4. JavaScript 2.0 contains features that were considered for ECMAScript Edition 4 but for which more experience is desirable before standardization occurs.



The following are recent major changes in this document:

Date Revisions
Jun 30, 2003
Jun 4, 2003
  • Split the super semantic field into super for classes and archetype for prototype-based objects.
  • Implemented simple prototypes on most objects, including class objects themselves, for compatibility with JavaScript 1.5.
  • Changed semantics so that the enumerable attribute now inherits when overriding an instance property. This was the original intent, although it was ambiguous in the written description of the attribute.
  • Put back a very simple package definition/import mechanism. Moved the extended import directive with the include/exclude selection mechanism to the rationale.
  • Added semantics for the library classes Object, Void, Null, Boolean, GeneralNumber (except for number formatting), Number, float, sbyte, byte, short, ushort, int, uint, long, ulong, Character, String (except for regular expressions), and Namespace.
  • Added numerous semantic utility functions to support the above classes.
  • Added \U escapes to the lexical grammar (but not yet the semantics).
  • Removed include and exclude keywords.
  • Removed some obsolete text from the description of Types; however, that page still needs a little work as it’s not as up-to-date as the semantics.
May 22, 2003
  • Renamed uses of the word “member” to “property” in the semantics. Cleaned up many other names without changing the meaning of the semantics.
  • Renamed Character to Char16, as well as related semantic names. Updated the description of Char16.
  • Implemented conversions of strings to numbers in the semantics. Appended an extra start symbol to the lexical grammar and semantics to assist with these conversions.
  • Eliminated the class Prototype, merging it with the class Object. This required modifying the rules on which objects can be used as prototypes — only direct instances of Object or other prototype-based classes can now be used as prototypes.
  • Made Object be dynamic, which required a slight change to the rules of inheritance of the dynamic attribute — it is now inherited from any superclass except Object.
  • Fixed instanceof when the second operand is a class such as RegExp and Array.
  • Implemented simple prototypes on primitive classes for compatibility with ECMAScript Edition 3.
  • Removed SystemFrame, which wasn’t needed any more.
  • Fixed errors in grammar rules for private.
  • Implemented final and static as attributes instead of syntax.
  • Removed obsolete semantic utilities and added a few helpers for constructing the standard classes.
  • Defined the global object, namespaces, attributes, and classes.
  • Changed the syntax of semantic record constructors to use single angular braces instead of double angular braces.
May 2, 2003
  • Updated the semantics. Simplified some of the object data structures. Merged uninitialised with none. Defined class initialization. Defined getters and setters. Implemented instanceof.
  • Defined error classes and replaced error tags with these classes. Revised which error gets reported in many cases.
  • Renamed class semantic variables from names such as objectClass to Object.
  • Removed package, import, and export directives. The description of packages and imports remains in the packages page, but is non-normative and there are no detailed semantics for these constructs.
  • The return statement cannot return a value from a constructor or a setter.
  • A getter must return a value; it cannot fall off the end of the function.
Apr 2, 2003
  • Removed multiple constructors from the body of the proposal and moved them to the rationale for future consideration.
  • Removed the constructor attribute.
  • Replaced the invoke superconstructor case with the ... function call syntax for passing an array of arguments (similar to what apply does) to any function or constructor.
Mar 24, 2003
  • Updated the semantics. Implemented is, catch, for, and for-in. Implemented instance methods on classes.
  • Disallowed initializers on for-in target variables. These are allowed by the grammar for convenience but prohibited by the semantics’ validation.
  • Fixed a major const definition design flaw in the semantics that led to race conditions and the possibility of definitions not being set up properly or initialized several times. Replaced the design, which relied on error catching to detect non-constant expressions at compile time, with one that lazily evaluates forward-referenced const expressions.
  • The prototype attribute now applies only to functions to make them into prototype-based functions/constructors. Removed its usage to make extractable class members.
  • Removed the old usage of the word “generic”.
  • Changed the enumerability defaults to match ECMAScript Edition 3.
  • Removed the static path analysis from the calling a superconstructor section.
  • Added invoke case to calling a superconstructor to allow passing a variable number of arguments to a superconstructor. (invoke is the same as apply except that it doesn’t take a this parameter.)
  • Required initializers for instance members to be compile-time constant expressions to simplify the semantics and avoid issues about how many times they are evaluated.
  • Minor editorial fixes.
Feb 17, 2003
  • Updated the semantics. Reorganized the property read, write, and delete code and indirected it through six customizable internal methods.
  • Merged packages with global objects in the semantics.
  • Introduced ilong and iulong notation in the semantics.
  • Introduced ns::id notation in the semantics.
  • Merged the concepts of inaccessible and uninitialized variables in the semantics.
  • Fixed the handling of const variable initializers in the semantics.
  • Implemented with statements and array initializers and updated object initializers in the semantics. These resulted in slight grammar changes.
Jan 29, 2003
  • Removed named function parameters from the body of the proposal and moved them to the rationale for future consideration.
  • Significantly simplified the semantics by removing named function parameters.
  • Class constructors no longer take named parameters to initialize instance members.
  • Allowed dynamic properties with namespaces to better integrate with E4X.
  • Removed typed arrays from the body of the proposal and moved them to the rationale for future consideration.
Jan 24, 2003
  • Updated the semantics.
  • Simplified the override logic by introducing the restriction that an instance variable cannot override a getter or a setter. The reverse is still allowed — a getter may override either a getter or a virtual instance variable, and a setter may override either a setter or a virtual instance variable. Also, the overriding definition may no longer override two different base members or add namespaces not mentioned in the base member.
  • An overriding method definition may no longer change the signature.
  • Allowed run-time namespace expressions in qualified identifiers to harmonize this proposal with E4X.
  • Fixed typos and anachronisms.
Jan 13, 2003
Nov 19, 2002
  • Updated the semantics.
  • Reorganized the grammar productions for function definitions and try statements without materially changing the language. This helped better factor the semantics for these constructs.
Oct 29, 2002
  • Changed numeric arithmetic contagion rules to try to return a long or ulong value when at least one operand is a long or ulong; if that’s not possible, the result overflows to a Number. Division will return a Number if that result would be more precise than a long or ulong.
  • Removed floating-point float arithmetic operations other than unary negation; these operations will always return a Number (or possibly a long or ulong if the other operand is a long or ulong).
  • Made === ignore differences in numeric types, so 5.0 === 5L will now be true.
  • Reduced repetitive semantics: when all actions A on a nonterminal N merely call A on the nonterminals in N’s grammar expansions, the actions are now abbreviated.
  • Simplified the lexer and stages descriptions.
  • Fixed several typos.
Sep 25, 2002
  • Fixed Number and float functionality.
  • Added conversions from numbers to strings.
  • Fixed broken links.
Sep 20, 2002
  • Operator overriding has been deferred until a future version of the language. Removed it from the proposal and moved it to the rationale section.
  • Removed the .() operator again.
  • Unit support has been deferred until a future version of the language. Removed it from the proposal and moved it to the rationale section.
  • Added semantics for float support.
  • Added long, ulong, and float literals.
  • Removed the concept of indexable members. All public members are now accessible via [].
  • Revised the lexical and syntactic grammar and semantics.
Jun 18, 2002
  • Attributes are now idempotent.
  • Removed the abstract attribute.
  • The enumerable attribute implies public.
  • Namespaces and classes defined as members of another class must specify the static attribute.
  • Added requirement that each variable referenced in a const initializer be resolvable to a scope.
  • Restricted class and namespace definitions to only global, package, or class scopes or blocks nested inside these scopes.
  • Corrected wording discrepancy: the superclass of a class must be a compile-time constant expression without forward references.
May 17, 2002
  • Removed class extensions from the proposal and added them to the rationale.
  • Since class extensions are now gone, made unit lookup look in the unit namespace instead of the Unit class.
  • Simplified the discussion of definition scopes, since no scope attributes remain in the proposal.
  • Deleted wrap pragma for wraparound machine integer arithmetic.
  • Deleted the compile attribute. Constants defined using const automatically become compile-time constants when used in compile-time constant expressions.
  • Defined explicit coercions for integral machine integers.
  • Removed restriction that top-level definitions in a package can only be placed in the namespace public or in namespaces defined within that package.
  • Added interfaces to the rationale.
Apr 22, 2002
  • Corrected and clarified the rules for when a variable or a constant may be accessed. Except for type- and attribute-less definitions, constants and variables are accessible only after being defined. Constants may be written at most once. Type expressions must be compile-time constant expressions.
  • A constant and a setter with the same qualified name may not be defined in the same scope.
  • Hoisting does not occur into class scope (this possibility is now excluded by the definition of a regional scope).
  • explicit is now an attribute instead of a specialized namespace.
  • Corrected the interaction of overriding and namespace defaulting in a definition. Defined the namespace defaulting and overriding rules.
  • Replaced mayOverride by override(undefined). Added regular rules for the behavior of overriding and the override attribute.
  • Allowed uninitialized semantic record fields.
  • Continuing to write the formal semantics. Added semantics for constant and variable declarations.
Mar 4, 2002
  • Restricted pragma arguments to be literal booleans, numbers, or strings. Also, strict mode changes now affect the semicolon after the pragma.
  • Removed class declarations without a body.
  • Removed include/exclude clauses from use directives. These now apply only to import directives and now indicate which top-level properties are shared. Simplified the name lookup algorithms to not account for includes/excludes on individual use directives.
  • Made other minor grammar changes to share productions and their semantics without affecting the language.
  • Added for each to the list of computation steps.
  • Added abbreviated notation for copying most of the fields from an existing tuple or record into a newly constructed one.
  • Continuing to write the formal semantics. Made major changes and additions to the formal semantics for evaluation of expressions and statements. Reorganized object layout and unified frames with container objects. Defined package objects. Added a phase parameter to distinguish compile-time constant expressions from runtime expressions.
Jan 4, 2002
  • Removed attributes from pragmas. Although somewhat useful, this made parsing dependent on attribute evaluation, and I'd rather not have such a dependency in the language.
Dec 20, 2001
  • Regularized the grammar of statements and directives. Separated annotated blocks into groups of either directives or substatements, which eliminated the troublesome situation of a definition being located in a substatement that happens to be a group. The attributes on a group of substatements are now restricted to only true and false.
Dec 19, 2001
  • Removed the local attribute, which was no longer necessary for anything.
  • Added the compile attribute to explicitly mark which const definitions must be compile-time constants. This became necessary because the semantics of compile-time const definitions are subtly different from those of regular const definitions, and it became unwieldy to try to guess which one a const definition is, based on how it is used.
  • Revamped the description of compile-time constant expressions. Removed the references to dominators. There are now two kinds of compile-time constant expressions: ones that allow forward references and ones that don’t.
Dec 17, 2001
  • Disallowed nested labels with the same name in the same function in the semantics.
  • Renamed GoContinue to Continue, GoBreak to Break, GoThrow to ThrownValue, and GoReturn to ReturnedValue in the semantics.
  • Pragmas may now take attributes (true and false only).
  • Fixed outdated text in the description of function parameters.
Dec 6, 2001
  • Reverted to the old definition of the Integer type; it’s back to being the set of integral IEEE doubles.
  • Deleted the double type and made Number act as double once again.
  • Renamed Character to char.
  • Rewrote the machine types section once again. Renamed int8, uint8, int16, uint16, int32, uint32, int64, and uint64 to sbyte, byte, short, ushort, int, uint, long, and ulong respectively. The first six of these are now subtypes of Integer; long and ulong are now disjoint from Number.
  • Renamed “coercion” to “implicit coercion” and “cast” to “explicit coercion”.
  • Added special case to the is operator to treat –0.0 as though it were +0.0.
  • Made the as operator support implicit coercions.
  • Added implicit coercions to the concept of a type.
Nov 26, 2001
  • Added support for comments inside functions in the semantics. Removed invariant and steps and turned them into comments.
  • Temporary variables in the semantics can now be declared without assigning a value to them.
  • Added more syntactic semantics.
  • Removed the #, ->, .., and @ tokens.
  • Made the Character type distinct from the set of single-character Strings.
  • Made double be a subtype of Number, which is now the union of numeric types. Made Integer distinct from double and accept unlimited-precision integers. Unified the integral machine types with Integer.
  • Made integral conversions that can result in loss of range error-checked by default. Added the wrap pragma to convert the behavior to wraparound.
Oct 26, 2001
Oct 18, 2001
Oct 16, 2001
Oct 3, 2001
  • Updated semantic notation to combine action procedures for multiple expansions of a nonterminal into one action procedure. Also deleted the notation for simple procedures to reduce confusion.
  • Reformatted the formal semantics and incorporated the above notation changes.
  • Added indexes to the rtf files.
Sep 26, 2001
  • Added more semantics.
  • delete now takes a PostfixExpression instead of a PostfixExpressionOrSuper.
Sep 24, 2001
Aug 22, 2001
Aug 17, 2001
Aug 15, 2001
Aug 10, 2001
Jul 24, 2001
  • null is now a valid String value, distinct from the empty string.
  • Removed the const Array and const t types. Added the StaticArray[t], DynamicArray[t], ConstArray, and ConstArray[t] types.
  • Removed the t[] notation. This is now reserved for fixed-size machine array types.
  • Removed the const operator.
  • Instance member initializers are re-evaluated each time a new instance is created.
  • Toughened the rules for argument type matching in overrides.
  • Changed the variable lookup rules to make a class’s instance members visible but inaccessible in static methods.
  • Removed the empty argument list case from the PragmaExpr and UseDirective grammars.
  • Removed the * wildcard case from IncludesExcludes.
  • Regularized the ImportDirective grammar.
  • Enabled true and false attributes on use namespace directives. Restricted import directive attributes to only true and false.
  • Simplified various grammar productions and renamed grammar nonterminals without affecting the language. Folded the Definition production into the Directive productions.
  • Specified extent of pragmas.
Jun 29, 2001
  • Renamed instanceof to is to allow it to have the new, more sensible semantics without breaking ECMAScript Edition 3 programs. instanceof is not part of ECMAScript Edition 4 but can be supported for legacy programs. is is a new reserved word.
  • Removed the [no line break] constraints after use.
  • Updated the compatibility section.
Jun 15, 2001
  • Renamed the machine types byte, ubyte, short, ushort, int, uint, long, ulong to int8, uint8, int16, uint16, int32, uint32, int64, and uint64 respectively.
  • Renamed Tuple to const Array.
  • Removed the nonindexable and nonenumerable visibility modifier attributes. Updated the definitions of the indexable and enumerable attributes.
  • Removed the indexable attribute keyword, but the indexable concept still exists because it is needed for compatibility with ECMAScript Edition 3.
  • Changed the default for public definitions to nonindexable and non-enumerable.
  • Forbade conflicting or repeated attributes.
  • The default member modifier attribute for const definitions is now final instead of static.
  • Removed the requirement to use this. to initialize instance constants from a constructor.
  • Setters can no longer return a value; the result of an assignment expression is now always the value of its right side.
  • Only classes with at least one member with the prototype attribute will themselves have a predefined prototype global member.
  • Renamed language directives to pragmas and removed the list of JavaScript versions.
  • Simplified the syntax of pragmas and changed the syntax of pragmas, namespace uses, and imports to make them consistent. Eliminated noninsertable semicolons.
  • Removed the parenthesized expression format of FieldName.
  • Noted that an implementation does not have to support package circularities but may do so as an extension.
  • Interchanged the names of the Definition and AnnotatedDefinition nonterminals.
  • Renamed the parser grammar to the syntactic grammar and the lexer grammar to the lexical grammar for consistency with ECMAScript Edition 3.
Apr 11, 2001
  • Reincarnated the @ operator as the as operator, which is now a new reserved word and has a lower precedence to match instanceof. The as operator now returns null if the type doesn’t match but the destination type contains null. as does not do any coercions.
  • Removed the | syntax for indicating named parameters. All optional parameters are now also named.
  • The arguments local variable is now supported only for unchecked functions.
  • Modified the syntax of the semantics to better match the ECMAScript Edition 3 style. Partially updated the notation page.
  • Fixed a bug in the unit semantics.
  • Note: Not all of the decisions reached in the last two ECMA TC39TG1 meetings have been integrated into this document yet.
Mar 9, 2001
  • Added links to the preliminary draft of the specification in PDF format.
  • Minor editorial changes.
Mar 2, 2001
Feb 28, 2001
  • Created the syntactic semantics. It’s still a work in progress.
  • Updated the execution stages page.
  • Added mutable cells and the associated operators to the semantic notation.
  • Renamed the Double semantic type to Float64 (this affects the semantics only, not the ECMAScript language).
  • Added many Float64 manipulation functions.
  • Made minor stylistic changes throughout the document.
Feb 22, 2001
  • Renamed type None to Never.
  • Renamed the empty escape from \Q to \_.
Feb 8, 2001
  • Added generic class members.
  • Extended the prototype attribute to allow any value for the this parameter and cause an instance member to appear in the class’s prototype global property. This makes prototype methods appear to be "intentionally generic" as per ECMAScript Edition 3.
Feb 6, 2001
  • Updated the definition extent model as discussed at the January TC39TG1 meeting. Now definitions are local by default but hoist if necessary. Removed the regional and global attributes.
  • Updated the definition conflict rules: added the rule about non-interfering local definitions and removed the rule about permitting re-execution of a const definition, since that is now impossible.
  • Removed the paragraph about ECMAScript Edition 4 being firmly in the dynamic camp from the introduction, since the examples given — dynamically defining classes and functions by placing them inside an if statement — no longer apply. Some of this can still be done using boolean attributes, but these attributes must be compile-time expressions.
  • Changed the data structures returned by methods of the for-in iteration protocol to be objects with named properties value and state rather than arrays or tuples with numbered properties 0 and 1. This allows the two properties to be declared using different types.
  • Specified a default superconstructor call if a constructor contains no other superconstructor calls.
  • Specified that object construction follows the Java model rather than the C++ model — when a constructor calls a virtual method on an object o under construction, it sees the most derived method even if the class in which that method is located has not yet run its constructor on o.
  • Added vector comprehensions [g(a| a  u] and [g(a| a  u and c(a)] to the semantic notation.
Jan 31, 2001
  • Eliminated namespace inheritance to simplify the proposal. This is unnecessary given the ability to use const to combine several namespace attributes.
  • Removed property lookups using a class before the :: (x.C::n and super x.C::n where C is a class). This feature did not add much useful functionality.
Jan 25, 2001
  • Minor wording changes.
  • Brought back the .() operator.
  • Updated semantic notation — revised description and usage of and added unique id’s.
Jan 11, 2001
  • In strict mode the default scope is local everywhere.
  • Like in C++, for statements now form their own scopes. This affects local definitions only.
  • catch clauses now form their own scopes.
  • try statements no longer allow annotations on any of their constituent blocks.
  • Split the notion of statements into statements and directives. Directives (including most definitions) can only be at the top level of a block, while statements can be anywhere. This avoids the problem of conditional definitions as substatements of a compound statement.
  • Reorganized the statement grammar around the distinction between statements and directives. Added the Substatement nonterminal.
  • Revised the discussion of annotated blocks.
  • Revised the description of scopes.
  • Added an optional const attribute to function parameters, which makes them read-only.
Jan 9, 2001
  • Removed the attribute weak.
  • Made minor clarifications without affecting the content.
  • Added rationale for the types Object and None.
  • Added attribute-style alternative to the type syntax rationale. Feedback on this style would be appreciated.
  • Revamped variable lookup to search for instance members inside instance methods without the need for the this. prefix. Also moved the description of the lookup of static members inside a class’s scope from the class section to the variable lookup section.
  • Simplified the package referencing rules. Also fixed the examples there to not use a package as a :: qualifier, since one is not allowed there by the name lookup rules.
  • Changed explicit from a specialized attribute into a namespace similar to internal. Removed implicit. This simplified the name lookup rules.
  • Greatly simplified use’s included and excluded name possibilities to be either * or a list of identifiers.
  • Generalized the iteration protocol to allow its methods to return objects of any type as long as they have the properties 0 and 1. Stated that the values returned by the iteration protocol expire when the next iteration occurs.
  • Added rationale for not overriding !, ||, ^^, &&, and ?:.
Dec 21, 2000
Dec 20, 2000
  • Made minor wording fixes in the packages section.
  • Simplified the grammar by making the const operator have the same precedence as the other unary operators. When used as a type constructor, the const operator now applies to the array type instead of the element type. The const operator can no longer be used to emulate the const statement.
  • Simplified the IncludesExcludes grammar without changing its behavior in any significant way by merging it with the expression grammar.
Dec 18, 2000
  • Changed the syntax for defining an operator override from function operator "op" to operator function "op". operator is now an attribute instead of a keyword.
  • Renamed operator overloading to operator overriding. Moved the operators page from the libraries to the core section.
  • Removed the Boolean return type restriction from the <, <=, ==, ===, and in operators.
  • Restricted the === operator to take operands of the same class.
  • Modified single and double operator dispatch rules so that null is considered to be a member of only the types Null and Object. Without this restriction dispatch becomes ambiguous. Note that ordinary method dispatch already has this restriction built-in.
  • Specified the built-in operator definitions.
Dec 2, 2000
  • Revamped the syntax for operator overriding based on feedback from the last ECMA meeting. There is now a special syntax to do this.
  • Modified the syntax for accessing a superclass’s method to conform to the new operator overriding scheme. The super::id syntax is no longer supported. super is now an operator modifier that alters the behavior of another operator such as . (property lookup) or any of the overridable operators such as +.
  • Updated the property lookup section to accommodate the new super syntax.
Nov 29, 2000
  • Revamped property lookup. For an unqualified reference x.n, instance name lookup previously found the most derived property. Now it first looks for the least derived property and picks the most derived overload of that property. The new definition handles private property access correctly and allows property access to be optimized to a simple offset lookup when the static type of the instance is known.
  • For simplicity removed the C::n (where C is a class) case of variable lookup. Use C.n instead.
  • Added descriptions of instances, properties, and property names.
  • Stated that the activation frame of a class contains aliases to the superclass’s global members.
  • Cleaned up nomenclature: the names defined by a class are members, while the bindings inside an object are properties. Members cause properties to be constructed when a class instance is created.
Nov 20, 2000
  • Renamed the s regular expression flag from simple to span.
  • Removed the /UnitProduct production from the unit grammar.
  • Allowed white space in the unit grammar. White space can now also be used to indicate implicit multiplication there.
  • Fixed the product rule in the unit grammar.
  • Renamed expt to pow in unit expressions.
Nov 4, 2000
  • Added attributes true and false.
  • Replaced the qualified attribute by the include and exclude syntax in import and use namespace statements. Added nonreserved words include and exclude.
  • Imported definitions appear in the global scope instead of the scope of the import statement; however, the implicit use still applies to scope of the import statement.
  • Predefined type names are constants in the global scope instead of a scope enclosing the global scope.
  • Defined activation frames and qualified names.
  • Blocks with attributes are not scopes.
  • Eliminated the notion of the static and dynamic extent of a definition. Rewrote and corrected the definition extent and name lookup rules in terms of scopes and activation frames only.
  • Simplified name lookup rules, making them independent of the order in which namespaces are used.
  • Relaxed the compile-time constant rules to permit expressions that either return a known value or signal an error. Without this change packages and namespaces cannot work.
  • A class can be used instead of a namespace before the :: during name lookup. This limits the search to members of that class or its superclasses.
  • Eliminated the a::b::c syntactic sugar. In the rare cases where it’s still needed, use (a.b)::c.
  • Defining b::n when there is already a definition a::n in the same scope causes an error if both namespaces a and b are used at the point of the definition of b::n.
  • Renamed scope to regional. scope blocks can now be either local or regional blocks. Defined the notion of a regional scope.
  • Changed unit lookup to look in the Unit class instead of prefixing unit_ to each unit name and looking for a global symbol. Added the unit attribute.
  • In strict mode the default scope is local only inside functions.
  • Strict mode is optional.
Oct 27, 2000
  • Expanded the qualified attribute to optionally take a list of symbols to exclude.
  • Definitions of top-level entities in a package can only be placed in the namespace public or in namespaces defined within that package.
  • Extensively modified and updated the description of units. Allowed multiple unit on the same expression in order to support combining number class units (such as "decimal") with units of measure. Defined the grammar and semantics of unit expressions.
Oct 10, 2000
  • Removed the primitive attribute.
  • Defined methods for overriding the for-in operator.
  • Added the s (simple) flag to regular expressions. This flag makes . match every character.
Oct 9, 2000
  • Made classof, eval, and include no longer be reserved words.
  • Combined the import statement with an automatic use namespace of selected namespaces.
  • Changed classof x to x.class.
  • Fixed minor editing errors.
Sep 23, 2000
  • Defined coercions of undefined to any type except None.
  • Renamed the none and void types to None and Void. Now all predefined type names start with upper case letters.
  • Resurrected the ECMAScript Edition 3 void operator and added the classof operator.
  • Made default constructors accept named arguments.
  • Modified the syntax of class extensions and moved their description to the definitions page.
  • Changed the meaning of a::b::c to be (a.b)::c rather than the intersection of the a::c and b::c sets. This means that an identifier may be qualified by only one namespace.
  • Updated the compatibility, namespace, operator overloading, and versioning pages.
Sep 22, 2000
Sep 21, 2000
  • Updated list of reserved words.
  • Updated concept page.
  • Renamed volatile to virtual, keeping volatile’s old semantics.
  • Revamped list and descriptions of attributes. Added a number of new attributes.
  • Disallowed qualifiers in names of literal object fields and names of arguments. Allowed parenthesized indirect expressions that evaluate to strings in those cases.
  • Added const operator, array types, and const array types.
  • Changed the handling of the rest parameter to only accept named arguments if it’s preceded by a |.
Sep 18, 2000 Integrated many changes based on recent discussions with Herman and others:
  • Renamed any to Object.
  • Added notion of live and dead statements.
  • Required attributes to be compile-time constants.
  • Reinstated parenthesized expressions before :: (except in attributes).
  • Changed package names in package definitions to be identifiers or dotted identifier lists. This required renaming the package attribute to internal in order to keep the grammar LR(1)-parsable.
  • Renamed import to qualified import and use import to import.
  • Allowed as an abbreviation for this.super::foo.
  • Removed obj.(expr) member access syntax.
  • Removed definitions that define qualified identifiers.
  • Required const declarations to have initializers.
  • Each block is its own scope in strict mode.
  • Specified the means of defining parameters that take named arguments. Rewrote description of argument passing.
  • Cleaned up significant portions of the grammar.
Aug 21, 2000
  • Significantly reworked syntax of attributes and expressions to allow attributes to take arguments. This required making constructor, namespace, and use into reserved words.
  • Required parentheses after eval.
  • Removed the syntaxes for placing a parenthesized expression before :: and for unquoted package names due to grammar conflicts.
  • Removed the attribute keyword; attributes are now defined using the const syntax.
  • Removed compile blocks.
  • Added the \Q escape, which turns into nothing and is useful for using identifiers that would otherwise be reserved words.
Aug 17, 2000 First version; split off from the JavaScript 2.0 proposal.

Waldemar Horwat
Last modified Monday, June 30, 2003