spec.idl

/**
 * Copyright 2014 Shape Security, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
  INFO: This specification is currently divided into the following sections:
  * supporting types
  * node classes
  * bindings
  * classes
  * modules
  * functions
  * object expressions
  * literals
  * other expressions
  * other statements
  * directives
  * other nodes
*/


// supporting types

typedef (SpreadElement or Expression)[] Arguments;
typedef DOMString string;
typedef string Identifier;
typedef string IdentifierName;
typedef string Label;

enum VariableDeclarationKind { "var", "let", "const" };

enum CompoundAssignmentOperator {
  "+=", "-=", "*=", "/=", "%=", "**=", "<<=", ">>=", ">>>=", "|=", "^=", "&="
};
enum BinaryOperator {
  "==", "!=", "===", "!==", "<", "<=", ">", ">=", "in", "instanceof", "<<",
  ">>", ">>>", "+", "-", "*", "/", "%", "**", ",", "||", "&&", "|", "^", "&"
};
enum UnaryOperator { "+", "-", "!", "~", "typeof", "void", "delete" };
enum UpdateOperator { "++", "--" };

interface Function {
  attribute boolean isGenerator;
  attribute FormalParameters params;
  attribute FunctionBody body;
};

// node classes

interface Node {
  [TypeIndicator] readonly attribute Type type;
};

interface Program : Node { };

interface Statement : Node { };
interface IterationStatement : Statement {
  attribute Statement body;
};

interface Expression : Node { };
interface MemberExpression : Expression {
  attribute (Expression or Super) _object;
};

interface PropertyName : Node { };

interface ObjectProperty : Node { };
interface NamedObjectProperty : ObjectProperty {
  attribute PropertyName name;
};
interface MethodDefinition : NamedObjectProperty {
  attribute FunctionBody body;
};

interface ImportDeclaration : Node {
  attribute string moduleSpecifier;
};
interface ExportDeclaration : Node { };

interface VariableReference : Node {
  attribute Identifier name;
};

// bindings

typedef (ObjectBinding or ArrayBinding) BindingPattern;
typedef (BindingPattern or BindingIdentifier) Binding;

typedef (AssignmentTargetIdentifier or MemberAssignmentTarget) SimpleAssignmentTarget;
typedef (ObjectAssignmentTarget or ArrayAssignmentTarget) AssignmentTargetPattern;
typedef (AssignmentTargetPattern or SimpleAssignmentTarget) AssignmentTarget;

typedef (Binding or BindingWithDefault) Parameter;

interface BindingWithDefault : Node {
  attribute Binding binding;
  attribute Expression init;
};

interface BindingIdentifier : VariableReference { };

interface AssignmentTargetIdentifier : VariableReference { };

interface MemberAssignmentTarget : Node {
  attribute (Expression or Super) _object;
};

interface ComputedMemberAssignmentTarget : MemberAssignmentTarget {
  attribute Expression expression;
};

interface StaticMemberAssignmentTarget : MemberAssignmentTarget {
  attribute IdentifierName property;
};

interface ArrayBinding : Node {
  attribute (Binding or BindingWithDefault)?[] elements;
  attribute Binding? rest;
};

interface ObjectBinding : Node {
  attribute BindingProperty[] properties;
};

interface BindingProperty : Node { };

interface BindingPropertyIdentifier : BindingProperty {
  attribute BindingIdentifier binding;
  attribute Expression? init;
};

interface BindingPropertyProperty : BindingProperty {
  attribute PropertyName name;
  attribute (Binding or BindingWithDefault) binding;
};

interface AssignmentTargetWithDefault : Node {
  attribute AssignmentTarget binding;
  attribute Expression init;
};

interface ArrayAssignmentTarget : Node {
  attribute (AssignmentTarget or AssignmentTargetWithDefault)?[] elements;
  attribute AssignmentTarget? rest;
};

interface ObjectAssignmentTarget : Node {
  attribute AssignmentTargetProperty[] properties;
};

interface AssignmentTargetProperty : Node { };

interface AssignmentTargetPropertyIdentifier : AssignmentTargetProperty {
  attribute AssignmentTargetIdentifier binding;
  attribute Expression? init;
};

interface AssignmentTargetPropertyProperty : AssignmentTargetProperty {
  attribute PropertyName name;
  attribute (AssignmentTarget or AssignmentTargetWithDefault) binding;
};


// classes

interface Class {
  attribute Expression? super;
  attribute ClassElement[] elements;
};

interface ClassExpression : Expression {
  attribute BindingIdentifier? name;
};
ClassExpression implements Class;

interface ClassDeclaration : Statement {
  attribute BindingIdentifier name;
};
ClassDeclaration implements Class;

interface ClassElement : Node {
  attribute boolean isStatic;
  attribute MethodDefinition method;
};


// modules

interface Module : Program {
  attribute Directive[] directives;
  attribute (ImportDeclaration or ExportDeclaration or Statement)[] items;
};

interface Import : ImportDeclaration {
  attribute BindingIdentifier? defaultBinding;
  attribute ImportSpecifier[] namedImports;
};

interface ImportNamespace : ImportDeclaration {
  attribute BindingIdentifier? defaultBinding;
  attribute BindingIdentifier namespaceBinding;
};

interface ImportSpecifier : Node {
  attribute IdentifierName? name;
  attribute BindingIdentifier binding;
};

interface ExportAllFrom : ExportDeclaration {
  attribute string moduleSpecifier;
};

interface ExportFrom : ExportDeclaration {
  attribute ExportFromSpecifier[] namedExports;
  attribute string moduleSpecifier;
};

interface ExportLocals : ExportDeclaration {
  attribute ExportLocalSpecifier[] namedExports;
};

interface Export : ExportDeclaration {
  attribute (FunctionDeclaration or ClassDeclaration or VariableDeclaration) declaration;
};

interface ExportDefault : ExportDeclaration {
  attribute (FunctionDeclaration or ClassDeclaration or Expression) body;
};

interface ExportFromSpecifier : Node {
  attribute IdentifierName name;
  attribute IdentifierName? exportedName;
};

interface ExportLocalSpecifier : Node {
  attribute IdentifierExpression name;
  attribute IdentifierName? exportedName;
};


// property definition

interface Method : MethodDefinition {
  attribute boolean isGenerator;
  attribute FormalParameters params;
};

interface Getter : MethodDefinition { };

interface Setter : MethodDefinition {
  attribute Parameter param;
};

interface DataProperty : NamedObjectProperty {
  attribute Expression expression;
};

interface ShorthandProperty : ObjectProperty {
  attribute IdentifierExpression name;
};

interface ComputedPropertyName : PropertyName {
  attribute Expression expression;
};

interface StaticPropertyName : PropertyName {
  attribute string value;
};


// literals

interface LiteralBooleanExpression : Expression {
  attribute boolean value;
};

interface LiteralInfinityExpression : Expression { };

interface LiteralNullExpression : Expression { };

interface LiteralNumericExpression : Expression {
  attribute double value;
};

interface LiteralRegExpExpression : Expression {
  attribute string pattern;
  attribute boolean global;
  attribute boolean ignoreCase;
  attribute boolean multiLine;
  attribute boolean sticky;
  attribute boolean unicode;
};

interface LiteralStringExpression : Expression {
  attribute string value;
};


// other expressions

interface ArrayExpression : Expression {
  attribute (SpreadElement or Expression)?[] elements;
};

interface ArrowExpression : Expression {
  attribute FormalParameters params;
  attribute (FunctionBody or Expression) body;
};

interface AssignmentExpression : Expression {
  attribute AssignmentTarget binding;
  attribute Expression expression;
};

interface BinaryExpression : Expression {
  attribute BinaryOperator operator;
  attribute Expression left;
  attribute Expression right;
};

interface CallExpression : Expression {
  attribute (Expression or Super) callee;
  attribute Arguments arguments;
};

interface CompoundAssignmentExpression : Expression {
  attribute CompoundAssignmentOperator operator;
  attribute SimpleAssignmentTarget binding;
  attribute Expression expression;
};

interface ComputedMemberExpression : MemberExpression {
  attribute Expression expression;
};

interface ConditionalExpression : Expression {
  attribute Expression test;
  attribute Expression consequent;
  attribute Expression alternate;
};

interface FunctionExpression : Expression {
  attribute BindingIdentifier? name;
};
FunctionExpression implements Function;

interface IdentifierExpression : Expression { };
IdentifierExpression implements VariableReference;

interface NewExpression : Expression {
  attribute Expression callee;
  attribute Arguments arguments;
};

interface NewTargetExpression : Expression { };

interface ObjectExpression : Expression {
  attribute ObjectProperty[] properties;
};

interface UnaryExpression : Expression {
  attribute UnaryOperator operator;
  attribute Expression operand;
};

interface StaticMemberExpression : MemberExpression {
  attribute IdentifierName property;
};

interface TemplateExpression : Expression {
  attribute Expression? tag;
  attribute (Expression or TemplateElement)[] elements;
};

interface ThisExpression : Expression { };

interface UpdateExpression : Expression {
  attribute boolean isPrefix;
  attribute UpdateOperator operator;
  attribute SimpleAssignmentTarget operand;
};

interface YieldExpression : Expression {
  attribute Expression? expression;
};

interface YieldGeneratorExpression : Expression {
  attribute Expression expression;
};


// other statements

interface BlockStatement : Statement {
  attribute Block block;
};

interface BreakStatement : Statement {
  attribute Label? label;
};

interface ContinueStatement : Statement {
  attribute Label? label;
};

interface DebuggerStatement : Statement { };

interface DoWhileStatement : IterationStatement {
  attribute Expression test;
};

interface EmptyStatement : Statement { };

interface ExpressionStatement : Statement {
  attribute Expression expression;
};

interface ForInStatement : IterationStatement {
  attribute (VariableDeclaration or AssignmentTarget) left;
  attribute Expression right;
};

interface ForOfStatement : IterationStatement {
  attribute (VariableDeclaration or AssignmentTarget) left;
  attribute Expression right;
};

interface ForStatement : IterationStatement {
  attribute (VariableDeclaration or Expression)? init;
  attribute Expression? test;
  attribute Expression? update;
};

interface IfStatement : Statement {
  attribute Expression test;
  attribute Statement consequent;
  attribute Statement? alternate;
};

interface LabeledStatement : Statement {
  attribute Label label;
  attribute Statement body;
};

interface ReturnStatement : Statement {
  attribute Expression? expression;
};

interface SwitchStatement : Statement {
  attribute Expression discriminant;
  attribute SwitchCase[] cases;
};

interface SwitchStatementWithDefault : Statement {
  attribute Expression discriminant;
  attribute SwitchCase[] preDefaultCases;
  attribute SwitchDefault defaultCase;
  attribute SwitchCase[] postDefaultCases;
};

interface ThrowStatement : Statement {
  attribute Expression expression;
};

interface TryCatchStatement : Statement {
  attribute Block body;
  attribute CatchClause catchClause;
};

interface TryFinallyStatement : Statement {
  attribute Block body;
  attribute CatchClause? catchClause;
  attribute Block finalizer;
};

interface VariableDeclarationStatement : Statement {
  attribute VariableDeclaration declaration;
};

interface WhileStatement : IterationStatement {
  attribute Expression test;
};

interface WithStatement : Statement {
  attribute Expression _object;
  attribute Statement body;
};


// other nodes

interface Block : Node {
  attribute Statement[] statements;
};

interface CatchClause : Node {
  attribute Binding binding;
  attribute Block body;
};

interface Directive : Node {
  attribute string rawValue;
};

interface FormalParameters : Node {
  attribute Parameter[] items;
  attribute Binding? rest;
};

interface FunctionBody : Node {
  attribute Directive[] directives;
  attribute Statement[] statements;
};

interface FunctionDeclaration : Statement {
  attribute BindingIdentifier name;
};
FunctionDeclaration implements Function;

interface Script : Program {
  attribute Directive[] directives;
  attribute Statement[] statements;
};

interface SpreadElement : Node {
  attribute Expression expression;
};

interface Super : Node { };

interface SwitchCase : Node {
  attribute Expression test;
  attribute Statement[] consequent;
};

interface SwitchDefault : Node {
  attribute Statement[] consequent;
};

interface TemplateElement : Node {
  attribute string rawValue;
};

interface VariableDeclaration : Node {
  attribute VariableDeclarationKind kind;
  [NonEmpty] attribute VariableDeclarator[] declarators;
};

interface VariableDeclarator : Node {
  attribute Binding binding;
  attribute Expression? init;
};