Safe Haskell	None
Language	Haskell2010

Language.ECMAScript3.Syntax

Description

ECMAScript 3 syntax. Spec refers to the ECMA-262 specification, 3rd edition.

Synopsis

Documentation

data JavaScript a Source

Constructors

Script a [Statement a]

A script in <script> ... </script> tags.

Instances

Functor JavaScript
Foldable JavaScript
Traversable JavaScript
Eq a => Eq (JavaScript a)
Data a => Data (JavaScript a)
Ord a => Ord (JavaScript a)
Show a => Show (JavaScript a)
(Data a, Arbitrary a, Enumerable a) => Arbitrary (JavaScript a)
Default a => Default (JavaScript a)
Enumerable a0 => Enumerable (JavaScript a)
Pretty (JavaScript a)
Data a => Fixable (JavaScript a)
Typeable (* -> *) JavaScript

unJavaScript :: JavaScript a -> [Statement a] Source

extracts statements from a JavaScript type

data Statement a Source

Statements, spec 12.

Constructors

BlockStmt a [Statement a]	`{stmts}`, spec 12.1
EmptyStmt a	`;`, spec 12.3
ExprStmt a (Expression a)	`expr;`, spec 12.4
IfStmt a (Expression a) (Statement a) (Statement a)	`if (e) stmt`, spec 12.5
IfSingleStmt a (Expression a) (Statement a)	`if (e) stmt1 else stmt2`, spec 12.5
SwitchStmt a (Expression a) [CaseClause a]	`switch (e) clauses`, spec 12.11
WhileStmt a (Expression a) (Statement a)	`while (e) do stmt`, spec 12.6
DoWhileStmt a (Statement a) (Expression a)	`do stmt while (e);`, spec 12.6
BreakStmt a (Maybe (Id a))	`break lab;`, spec 12.8
ContinueStmt a (Maybe (Id a))	`continue lab;`, spec 12.7
LabelledStmt a (Id a) (Statement a)	`lab: stmt`, spec 12.12
ForInStmt a (ForInInit a) (Expression a) (Statement a)	`for (x in o) stmt`, spec 12.6
ForStmt a (ForInit a) (Maybe (Expression a)) (Maybe (Expression a)) (Statement a)	`ForStmt a init test increment body`, `for (init; test, increment) body`, spec 12.6
TryStmt a (Statement a) (Maybe (CatchClause a)) (Maybe (Statement a))	`try stmt catch(x) stmt finally stmt`, spec 12.14
ThrowStmt a (Expression a)	`throw expr;`, spec 12.13
ReturnStmt a (Maybe (Expression a))	`return expr;`, spec 12.9
WithStmt a (Expression a) (Statement a)	`with (o) stmt`, spec 12.10
VarDeclStmt a [VarDecl a]	`var x, y=42;`, spec 12.2
FunctionStmt a (Id a) [Id a] [Statement a]	`function f(x, y, z) {...}`, spec 13

Instances

Functor Statement
Foldable Statement
Traversable Statement
HasAnnotation Statement
Eq a => Eq (Statement a)
Data a => Data (Statement a)
Ord a => Ord (Statement a)
Show a => Show (Statement a)
(Enumerable a, Arbitrary a, Data a) => Arbitrary (Statement a)
Enumerable a0 => Enumerable (Statement a)
Pretty [Statement a]
Pretty (Statement a)
Data a => Fixable (Statement a)
Typeable (* -> *) Statement

isIterationStmt :: Statement a -> Bool Source

Returns True if the statement is an IterationStatement according to spec 12.6.

data CaseClause a Source

Case clauses, spec 12.11

Constructors

CaseClause a (Expression a) [Statement a]	case e: stmts;
CaseDefault a [Statement a]	default: stmts;

Instances

Functor CaseClause
Foldable CaseClause
Traversable CaseClause
HasAnnotation CaseClause
Eq a => Eq (CaseClause a)
Data a => Data (CaseClause a)
Ord a => Ord (CaseClause a)
Show a => Show (CaseClause a)
(Enumerable a, Arbitrary a, Data a) => Arbitrary (CaseClause a)
Enumerable a0 => Enumerable (CaseClause a)
Pretty (CaseClause a)
Data a => Fixable (CaseClause a)
Typeable (* -> *) CaseClause

data CatchClause a Source

Catch clause, spec 12.14

Constructors

CatchClause a (Id a) (Statement a)

catch (x) {...}

Instances

Functor CatchClause
Foldable CatchClause
Traversable CatchClause
HasAnnotation CatchClause
Eq a => Eq (CatchClause a)
Data a => Data (CatchClause a)
Ord a => Ord (CatchClause a)
Show a => Show (CatchClause a)
(Enumerable a, Arbitrary a, Data a) => Arbitrary (CatchClause a)
Enumerable a0 => Enumerable (CatchClause a)
Pretty (CatchClause a)
Data a => Fixable (CatchClause a)
Typeable (* -> *) CatchClause

data ForInit a Source

for initializer, spec 12.6

Constructors

NoInit	empty
VarInit [VarDecl a]	var x, y=42
ExprInit (Expression a)	expr

Instances

Functor ForInit
Foldable ForInit
Traversable ForInit
Eq a => Eq (ForInit a)
Data a => Data (ForInit a)
Ord a => Ord (ForInit a)
Show a => Show (ForInit a)
(Enumerable a, Arbitrary a, Data a) => Arbitrary (ForInit a)
Enumerable a0 => Enumerable (ForInit a)
Pretty (ForInit a)
Data a => Fixable (ForInit a)
Typeable (* -> *) ForInit

data ForInInit a Source

for..in initializer, spec 12.6

Constructors

ForInVar (Id a)	var x
ForInLVal (LValue a)	`foo.baz`, `foo[bar]`, `z`

Instances

Functor ForInInit
Foldable ForInInit
Traversable ForInInit
Eq a => Eq (ForInInit a)
Data a => Data (ForInInit a)
Ord a => Ord (ForInInit a)
Show a => Show (ForInInit a)
(Enumerable a, Arbitrary a, Data a) => Arbitrary (ForInInit a)
Enumerable a0 => Enumerable (ForInInit a)
Pretty (ForInInit a)
Data a => Fixable (ForInInit a)
Typeable (* -> *) ForInInit

data VarDecl a Source

A variable declaration, spec 12.2

Constructors

VarDecl a (Id a) (Maybe (Expression a))

var x = e;

Instances

Functor VarDecl
Foldable VarDecl
Traversable VarDecl
HasAnnotation VarDecl
Eq a => Eq (VarDecl a)
Data a => Data (VarDecl a)
Ord a => Ord (VarDecl a)
Show a => Show (VarDecl a)
(Enumerable a, Arbitrary a, Data a) => Arbitrary (VarDecl a)
Enumerable a0 => Enumerable (VarDecl a)
Pretty (VarDecl a)
Data a => Fixable (VarDecl a)
Typeable (* -> *) VarDecl

data Expression a Source

Expressions, see spec 11

Constructors

StringLit a String	`"foo"`, spec 11.1.3, 7.8
RegexpLit a String Bool Bool	`RegexpLit a regexp global? case_insensitive?` -- regular expression, see spec 11.1.3, 7.8
NumLit a Double	`41.99999`, spec 11.1.3, 7.8
IntLit a Int	`42`, spec 11.1.3, 7.8
BoolLit a Bool	`true`, spec 11.1.3, 7.8
NullLit a	`null`, spec 11.1.3, 7.8
ArrayLit a [Expression a]	`[1,2,3]`, spec 11.1.4
ObjectLit a [(Prop a, Expression a)]	`{foo:"bar", baz: 42}`, spec 11.1.5
ThisRef a	`this`, spec 11.1.1
VarRef a (Id a)	`foo`, spec 11.1.2
DotRef a (Expression a) (Id a)	`foo.bar`, spec 11.2.1
BracketRef a (Expression a) (Expression a)	`foo[bar`, spec 11.2.1
NewExpr a (Expression a) [Expression a]	`new foo(bar)`, spec 11.2.2
PrefixExpr a PrefixOp (Expression a)	`@e`, spec 11.4 (excluding 11.4.4, 111.4.5)
UnaryAssignExpr a UnaryAssignOp (LValue a)	`++x`, `x--` etc., spec 11.3, 11.4.4, 11.4.5
InfixExpr a InfixOp (Expression a) (Expression a)	`e1@e2`, spec 11.5, 11.6, 11.7, 11.8, 11.9, 11.10, 11.11
CondExpr a (Expression a) (Expression a) (Expression a)	`e1 ? e2 : e3`, spec 11.12
AssignExpr a AssignOp (LValue a) (Expression a)	`e1 @=e2`, spec 11.13
ListExpr a [Expression a]	`e1, e2`, spec 11.14
CallExpr a (Expression a) [Expression a]	`f(x,y,z)`, spec 11.2.3 funcexprs are optionally named
FuncExpr a (Maybe (Id a)) [Id a] [Statement a]	`function f (x,y,z) {...}`, spec 11.2.5, 13

Instances

Functor Expression
Foldable Expression
Traversable Expression
HasAnnotation Expression
Eq a => Eq (Expression a)
Data a => Data (Expression a)
Ord a => Ord (Expression a)
Show a => Show (Expression a)
Default a => IsString (Expression a)
(Enumerable a, Arbitrary a, Data a) => Arbitrary (Expression a)
Enumerable a0 => Enumerable (Expression a)
Pretty (Expression a)
Data a => Fixable (Expression a)
Typeable (* -> *) Expression

data InfixOp Source

Infix operators: see spec 11.5-11.11

Constructors

OpLT	<
OpLEq	<=
OpGT	>
OpGEq	>=
OpIn	in
OpInstanceof	instanceof
OpEq	==
OpNEq	!=
OpStrictEq	===
OpStrictNEq	!===
OpLAnd	&&
OpLOr	\|\|
OpMul	*
OpDiv	/
OpMod	%
OpSub	-
OpLShift	<<
OpSpRShift	>>
OpZfRShift	>>>
OpBAnd	&
OpBXor	^
OpBOr	\|
OpAdd	+

Instances

Enum InfixOp
Eq InfixOp
Data InfixOp
Ord InfixOp
Show InfixOp
Arbitrary InfixOp
Enumerable InfixOp
Pretty InfixOp
Typeable * InfixOp

data AssignOp Source

Assignment operators: see spec 11.13

Constructors

OpAssign	simple assignment, `=`
OpAssignAdd	+=
OpAssignSub	-=
OpAssignMul	*=
OpAssignDiv	/=
OpAssignMod	%=
OpAssignLShift	<<=
OpAssignSpRShift	>>=
OpAssignZfRShift	>>>=
OpAssignBAnd	&=
OpAssignBXor	^=
OpAssignBOr	\|=

Instances

Eq AssignOp
Data AssignOp
Ord AssignOp
Show AssignOp
Arbitrary AssignOp
Enumerable AssignOp
Pretty AssignOp
Typeable * AssignOp

data Id a Source

Constructors

Id a String

Instances

Functor Id
Foldable Id
Traversable Id
HasAnnotation Id
Eq a => Eq (Id a)
Data a => Data (Id a)
Ord a => Ord (Id a)
Show a => Show (Id a)
Default a => IsString (Id a)
(Enumerable a, Arbitrary a) => Arbitrary (Id a)
Enumerable a0 => Enumerable (Id a)
Pretty (Id a)
Fixable (Id a)
Typeable (* -> *) Id

unId :: Id a -> String Source

data PrefixOp Source

Prefix operators: see spec 11.4 (excluding 11.4.4, 11.4.5)

Constructors

PrefixLNot	!
PrefixBNot	~
PrefixPlus	+
PrefixMinus	-
PrefixTypeof	typeof
PrefixVoid	void
PrefixDelete	delete

Instances

Eq PrefixOp
Data PrefixOp
Ord PrefixOp
Show PrefixOp
Arbitrary PrefixOp
Enumerable PrefixOp
Pretty PrefixOp
Typeable * PrefixOp

data Prop a Source

Property names in an object initializer: see spec 11.1.5

Constructors

PropId a (Id a)	property name is an identifier, `foo`
PropString a String	property name is a string, `"foo"`
PropNum a Integer	property name is an integer, `42`

Instances

Functor Prop
Foldable Prop
Traversable Prop
HasAnnotation Prop
Eq a => Eq (Prop a)
Data a => Data (Prop a)
Ord a => Ord (Prop a)
Show a => Show (Prop a)
Default a => IsString (Prop a)
(Enumerable a, Arbitrary a) => Arbitrary (Prop a)
Enumerable a0 => Enumerable (Prop a)
Pretty (Prop a)
Data a => Fixable (Prop a)
Typeable (* -> *) Prop

data UnaryAssignOp Source

Unary assignment operators: see spec 11.3, 11.4.4, 11.4.5

Constructors

PrefixInc	++x
PrefixDec	--x
PostfixInc	x++
PostfixDec	x--

Instances

Eq UnaryAssignOp
Data UnaryAssignOp
Ord UnaryAssignOp
Show UnaryAssignOp
Arbitrary UnaryAssignOp
Enumerable UnaryAssignOp
Typeable * UnaryAssignOp

data LValue a Source

Left-hand side expressions: see spec 11.2

Constructors

LVar a String	variable reference, `foo`
LDot a (Expression a) String	foo.bar
LBracket a (Expression a) (Expression a)	foo[bar]

Instances

Functor LValue
Foldable LValue
Traversable LValue
HasAnnotation LValue
Eq a => Eq (LValue a)
Data a => Data (LValue a)
Ord a => Ord (LValue a)
Show a => Show (LValue a)
Default a => IsString (LValue a)
(Data a, Enumerable a, Arbitrary a) => Arbitrary (LValue a)
Enumerable a0 => Enumerable (LValue a)
Pretty (LValue a)
Data a => Fixable (LValue a)
Typeable (* -> *) LValue

data SourcePos :: *

The abstract data type SourcePos represents source positions. It contains the name of the source (i.e. file name), a line number and a column number. SourcePos is an instance of the Show, Eq and Ord class.

Instances

Eq SourcePos
Data SourcePos
Ord SourcePos
Show SourcePos
Default SourcePos
Typeable * SourcePos

isValid :: forall a. (Data a, Typeable a) => JavaScript a -> Bool Source

The ECMAScript standard defines certain syntactic restrictions on programs (or, more precisely, statements) that aren't easily enforced in the AST datatype. These restrictions have to do with labeled statements and break/continue statement, as well as identifier names. Thus, it is possible to manually generate AST's that correspond to syntactically incorrect programs. Use this predicate to check if an JavaScript AST corresponds to a syntactically correct ECMAScript program.

isValidIdentifier :: Id a -> Bool Source

Checks if an identifier name is valid according to the spec

isValidIdentifierName :: String -> Bool Source

Checks if the String represents a valid identifier name

isReservedWord :: String -> Bool Source

Checks if a string is in the list of reserved ECMAScript words

isValidIdStart :: Char -> Bool Source

Checks if a character is valid at the start of an identifier

isValidIdPart :: Char -> Bool Source

Checks if a character is valid in an identifier part

data EnclosingStatement Source

Constructors

EnclosingIter [Label]	The enclosing statement is an iteration statement
EnclosingSwitch [Label]	The enclosing statement is a switch statement
EnclosingOther [Label]	The enclosing statement is some other statement. Note, `EnclosingOther` is never pushed if the current `labelSet` is empty, so the list of labels in this constructor should always be non-empty

Instances

Show EnclosingStatement
HasLabelSet EnclosingStatement

pushLabel :: Monad m => Id b -> StateT ([Label], [EnclosingStatement]) m a -> StateT ([Label], [EnclosingStatement]) m a Source

pushEnclosing :: Monad m => ([Label] -> EnclosingStatement) -> StateT ([Label], [EnclosingStatement]) m a -> StateT ([Label], [EnclosingStatement]) m a Source

class HasLabelSet a where Source

Methods

getLabelSet :: a -> [Label] Source

setLabelSet :: [Label] -> a -> a Source

Instances

HasLabelSet EnclosingStatement

isIter :: EnclosingStatement -> Bool Source

isIterSwitch :: EnclosingStatement -> Bool Source