JavascriptGeneration.ns

Newspeak3
'Root'
class JavascriptGeneration usingPlatform: platform = (
(* Building blocks of Javascript syntax trees and a tree writer. The nodes are intended to represent Javascript code to be generated rather than the result of parsing an arbitrary Javascript program, so there is no provision for some ungood things such as the with statement.

Copyright 2012 SAP AG.
Copyright 2013 Ryan Macnak

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
*)
|
	private List = platform collections List.
	private Map = platform collections Map.

	syntax = Syntax new.
	public factory = Factory new.
|) (
class Factory = (
(* Provides a set of methods to build Javascript ASTs by writing expressions more readable than those that instantiate AST classes directly. An instance is held onto by the containing module as the slot named 'factory'. It's convenient to bind that instance in a user module to a slot with a short name such as 'js', to create Javascript ASTs with expressions like

js block: {js return: (js ident: 'self')} *)
) (
public array: elements <List[Node]> ^<ArrayExpression> = (
	elements do: [:each | assert: [each isKindOfJsNode] message: 'JS node expected'].
	^syntax ArrayExpression elements: elements
)
public assign: lhs <Node> toBe: rhs <Node> ^<Node> = (
	assert: [lhs isKindOfJsNode] message: 'JS node expected on left'.
	assert: [rhs isKindOfJsNode] message: 'JS node expected on right'.
	^syntax AssignmentExpression leftHandSide: lhs rightHandSide: rhs
)
public block: statements <List[Node]> ^<Node> = (
	statements do: [:each | assert: [each isKindOfJsNode] message: 'Malformed statement tree'].
	^syntax Block statements: statements
)
public call: expression <Node> with: arguments <List[Node]> = (
	^syntax CallExpression function: expression arguments: arguments
)
public for: varName <String> in: expr <Node> do: bodyStmt <Node> = (
	| canonicalVarName |
	canonicalVarName:: varName isNil
		ifTrue: [varName]
		ifFalse: [varName isKindOfString ifTrue: [ident: varName] ifFalse: [varName]].
	^syntax ForInStatement
		varName: canonicalVarName
		expression: expr
		body: bodyStmt
)
public for: initExpr while: testExpr step: incExpr do: bodyStmt = (
	^syntax ForStatement
		initExpression: initExpr
		test: testExpr
		increment: incExpr
		body: bodyStmt
)
public function: name <String> of: params body: body <Block> = (
	| canonicalName canonicalParams |
	canonicalName:: name isNil
		ifTrue: [name]
		ifFalse: [name isKindOfString ifTrue: [ident: name] ifFalse: [name]].
	canonicalParams:: params collect: [:each | each isKindOfString ifTrue: [ident: each]  ifFalse: [each]].
	^syntax FunctionStatement name: canonicalName parameters: canonicalParams body: body
)
public functionOf: params body: body <Block> = (
	| paramIds |
	paramIds:: params collect: [:each | each isKindOfString ifTrue: [ident: each]  ifFalse: [each]].
	^syntax FunctionExpression name: nil parameters: paramIds body: body
)
public ident: name <String> ^<Node> = (
	assert: [name isKindOfString] message: 'name must be a string'.
	^syntax IdentifierExpression name: name
)
public if: expression <Node> then: then <Node> ^<Node> = (
	^syntax IfStatement expression: expression then: then else: nil
)
public if: expression <Node> then: then <Node> else: else <Node> ^<Node> = (
	^syntax IfStatement expression: expression then: then else: else
)
public literal: value <Boolean | Integer | String> ^<Node> = (
	value isKindOfString ifTrue: [^syntax StringLiteral value: value].
	value isKindOfNumber ifTrue: [^syntax NumberLiteral value: value].
	(true = value or: [false = value]) ifTrue: [^syntax BooleanLiteral value: value].
	error: 'this value cannot be a Javascript literal'
)
public new: expression <Node> with: args <List[Node]> ^<Node> = (
	^syntax NewExpression expression: expression arguments: args
)
public objectLiteral = (
	^syntax ObjectLiteral new
)
public objectLiteral: slots <List> = (
	slots keysAndValuesDo:
		[:index : element |
		assert: (index odd
			ifTrue: [[element isKindOfString]]
			ifFalse: [[element isKindOfJsNode]]) message: 'JS node or string expected'].
	^syntax ObjectLiteral slots: slots
)
public objectLiteralSlotNames: names <List[String]> values: values <List[Node]> = (
	^syntax ObjectLiteral slotNames: names values: values
)
public operator: name <String> with: left <Node> and: right <Node> = (
	| canonicalName |
	canonicalName:: name isNil
		ifTrue: [name]
		ifFalse: [name isKindOfString ifTrue: [ident: name] ifFalse: [name]].
	assert: [left isKindOfJsNode] message: 'JS node expected on left'.
	assert: [right isKindOfJsNode] message: 'JS node expected on right'.
	^syntax OperatorExpression operator: canonicalName with: left and: right
)
public postfixOperator: name <String> on: operand <Node> = (
	| canonicalName |
	canonicalName:: name isNil
		ifTrue: [name]
		ifFalse: [name isKindOfString ifTrue: [ident: name] ifFalse: [name]].
	^syntax UnaryOperatorExpression operator: canonicalName postfix: true on: operand
)
public prefixOperator: name <String> on: operand <Node> = (
	| canonicalName |
	canonicalName:: name isNil
		ifTrue: [name]
		ifFalse: [name isKindOfString ifTrue: [ident: name] ifFalse: [name]].
	^syntax UnaryOperatorExpression operator: canonicalName postfix: false on: operand
)
public propertyOf: expression <Node> at: indexExpr <Node> = (
	assert: [expression isKindOfJsNode] message: 'JS node expected'.
	assert: [indexExpr isKindOfJsNode] message: 'JS node expected for index expression'.
	^syntax MemberExpression primary: expression property: indexExpr
)
public propertyOf: expression <Node> atPath: path <List[Node]> = (
	assert: [expression isKindOfJsNode] message: 'JS node expected'.
	^path isEmpty
		ifTrue: [expression]
		ifFalse:
			[propertyOf: (propertyOf: expression at: path first)
				atPath: (path copyFrom: 2 to: path size)]
)
public return = (
	^syntax ReturnStatement expression: nil
)
public return: expression <Node | nil> = (
	^syntax ReturnStatement expression: expression
)
public script: statements <List[Node]> = (
	^syntax Script statements: statements
)
public ternaryIf: condition then: then else: else = (
	^syntax TernaryOperatorExpression
		if: condition
		then: then
		else: else
)
public throw: expression <Node> ^<Node> = (
	^syntax ThrowStatement expression: expression
)
public try: block <Block> catch: varName <String> with: catchBlock <Block> = (
	| canonicalVarName |
	canonicalVarName:: varName isNil
		ifTrue: [varName]
		ifFalse: [varName isKindOfString ifTrue: [ident: varName] ifFalse: [varName]].
	^syntax TryStatement block: block catch: canonicalVarName with: catchBlock finally: nil
)
public try: block <Block> catch: varName <String> with: catchBlock <Block> finally: finallyBlock <Block> = (
	| canonicalVarName |
	canonicalVarName:: varName isNil
		ifTrue: [varName]
		ifFalse: [varName isKindOfString ifTrue: [ident: varName] ifFalse: [varName]].
	^syntax TryStatement block: block catch: canonicalVarName with: catchBlock finally: finallyBlock
)
public try: block <Block> finally: finallyBlock <Block> = (
	^syntax TryStatement block: block catch: nil with: nil finally: finallyBlock
)
public var: name <String> ^<VariableStatement> = (
	| canonicalName |
	canonicalName:: name isNil
		ifTrue: [name]
		ifFalse: [name isKindOfString ifTrue: [ident: name] ifFalse: [name]].
	^syntax VariableStatement name: canonicalName initializer: nil
)
public var: name <String> value: expr <Node> ^<VariableStatement> = (
	| canonicalName |
	canonicalName:: name isNil
		ifTrue: [name]
		ifFalse: [name isKindOfString ifTrue: [ident: name] ifFalse: [name]].
	^syntax VariableStatement name: canonicalName initializer: expr
)
public verbatim: text <String> = (
	 assert: [text isKindOfString] message: 'String expected'.
	^syntax VerbatimNode text: text
)
) : (
)
class Syntax = (
(* The AST nodes. The preferred way to construct instances is to use the factory object (an instance of Factory, a sibling of this class) held onto by the module. *)
) (
public class ArrayExpression elements: elements = Node (
(* An array constructor expression. *)
|
	protected elements_ = elements.
|) (
public = anotherNode = (
	^super = anotherNode and: [elements = anotherNode elements]
)
public elements = (
	^elements_
)
public visitBy: visitor = (
	^visitor visitArrayExpression: self
)
) : (
)
public class AssignmentExpression leftHandSide: lhs rightHandSide: rhs = Node (|
	public leftHandSide <Expression> = lhs.
	public rightHandSide <Expression> = rhs.
|) (
public = anotherNode = (
	^super = anotherNode
		and: [leftHandSide = anotherNode leftHandSide
			and: [rightHandSide = anotherNode rightHandSide]]
)
public isKindOfOperatorExpression = (
	^true
)
public printOn: stream = (
	super printOn: stream.
	stream nextPutAll: ' ('.
	leftHandSide printOn: stream.
	stream nextPutAll: ', '.
	rightHandSide printOn: stream.
	stream nextPutAll: ')'
)
public visitBy: visitor = (
	^visitor visitAssignmentExpression: self
)
) : (
)
public class Block statements: s = Node (
(* Block; ECMA-262 p. 220. *)
|
	statementsS <List[Statement | Expression]> = s.
|) (
public = anotherNode = (
	^super = anotherNode and: [statements = anotherNode statements]
)
public asBlock = (
	^self
)
public statements = (
	^statementsS
)
public visitBy: visitor = (
	^visitor visitBlock: self
)
) : (
public empty = (
	^Block statements: {}
)
)
public class BooleanLiteral value: b <Boolean> = Node (|
	valueS = b.
|) (
public = anotherNode = (
	^super = anotherNode and: [value = anotherNode value]
)
public printOn: stream = (
	super printOn: stream.
	stream nextPutAll: ' ('.
	value printOn: stream.
	stream nextPutAll: ')'
)
public value = (
	^valueS
)
public visitBy: visitor = (
	^visitor visitBooleanLiteral: self
)
) : (
)
public class CallExpression function: f arguments: args = Node (
(* expression ( arguments ) *)
|
	public function <Expression> = f.
	public arguments <List[Expression]> = args.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[function = anotherNode function and: [arguments = anotherNode arguments]]
)
public visitBy: visitor = (
	^visitor visitCallExpression: self
)
) : (
)
public class DeleteExpression memberExpression: m = Node (
(* AST node for the delete operator. *)
|
	public memberExpression <MemberExpression> = m.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[memberExpression = anotherNode memberExpression]
)
public visitBy: visitor = (
	^visitor visitDeleteExpression: self
)
) : (
)
public class ForInStatement varName: name <IdentifierExpression> expression: expr body: body = Node (|
	public varName = name.
	public expression = expr.
	public body = body.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[varName = anotherNode varName and:
		[expression = anotherNode expression and:
		[body = anotherNode body]]]
)
public visitBy: visitor = (
	^visitor visitForInStatement: self
)
) : (
)
public class ForStatement initExpression: initExpr test: testExpr increment: incExpr body: body = Node (|
	public initExpression = initExpr.
	public testExpression = testExpr.
	public incrementExpression = incExpr.
	public body = body.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[initExpression = anotherNode initExpression and:
		[testExpression = anotherNode testExpression and:
		[incrementExpression = anotherNode incrementExpression and:
		[body = anotherNode body]]]]
)
public visitBy: visitor = (
	^visitor visitForStatement: self
)
) : (
)
public class FunctionExpression name: s <IdentifierExpression | nil> parameters: names <List[IdentifierExpression]> body: b = Node (
(* FunctionExpression. ECMA-262, p. 262. *)
|
	public name <IdentifierExpression | nil> = s.
	public parameters <List[IdentifierExpression]> = names.
	public body <Block> = b asBlock.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[name = anotherNode name and:
		[parameters = anotherNode parameters and:
		[body = anotherNode body]]]
)
public isKindOfFunctionExpression = (
	^true
)
public visitBy: visitor = (
	^visitor visitFunctionExpression: self
)
) : (
public parameters: names <List[IdentifierExpression]> body: b <Node> = (
	^FunctionExpression name: nil parameters: names body: b
)
)
public class FunctionStatement name: s parameters: names body: b = FunctionExpression name: s parameters: names body: b (
(* A function statement. Essentially the same thing as a function expression, but needs to be written out differently. Note that unlike in a function expression, the name argument is not optional. TODO: should we move name up to this class and make function expressions anonymous? What does the standard say? *)
) (
public visitBy: visitor = (
	^visitor visitFunctionStatement: self
)
) : (
)
public class IdentifierExpression name: s <String> = Node (
(* a case of PrimaryExpression *)
|
	nameS = s.
|) (
public = anotherNode = (
	^super = anotherNode and: [name = anotherNode name]
)
public name = (
	^nameS
)
public printOn: stream = (
	super printOn: stream.
	stream nextPutAll: ' ('.
	stream nextPutAll: name.
	stream nextPutAll: ')'
)
public visitBy: visitor = (
	^visitor visitIdentifierExpression: self
)
) : (
)
public class IfStatement expression: expr then: then else: else = Node (
(* if ( expression ) thenStatement else elseStatement *)
|
	public expression = expr.
	public thenStatement = then.
	public elseStatement = else.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[expression = anotherNode expression and:
		[thenStatement = anotherNode thenStatement and:
		[elseStatement = anotherNode elseStatement]]]
)
public visitBy: visitor = (
	^visitor visitIfStatement: self
)
) : (
public expression: expr then: then = (
	^IfStatement expression: expr then: then else: nil
)
)
public class MemberExpression primary: expr <Expression> property: p <Node> = Node (
(* primary[property] *)
|
	public primary = expr.
	public property = p.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[primary = anotherNode primary and:
		[property = anotherNode property]]
)
public visitBy: visitor = (
	^visitor visitMemberExpression: self
)
) : (
)
public class NewExpression expression: expr arguments: args = Node (
(* new expr ( arg, .... ) *)
|
	public expression = expr.
	public arguments = args.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[expression = anotherNode expression and:
		[arguments = anotherNode arguments]]
)
public visitBy: visitor = (
	^visitor visitNewExpression: self
)
) : (
)
class Node = (
(* The superclass of all other nodes, both statements and expressions. *)
|
	public comment <String>
|) (
public = anotherNode = (
	^class = anotherNode class
)
public asBlock = (
	^Block statements: {self}
)
public isKindOfFunctionExpression = (
	^false
)
public isKindOfJsNode = (
	^true
)
public isKindOfNumberLiteral ^<Boolean> = (
	^false
)
public isKindOfOperatorExpression = (
	^false
)
public isKindOfStringLiteral = (
	^false
)
) : (
)
public class NumberLiteral value: v <Number> = Node (|
	valueS = v.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[value = anotherNode value]
)
public isKindOfNumberLiteral ^<Boolean> = (
	^true
)
public printOn: stream = (
	super printOn: stream.
	stream nextPutAll: ' ('.
	value printOn: stream.
	stream nextPutAll: ')'
)
public value = (
	^valueS
)
public visitBy: visitor = (
	^visitor visitNumberLiteral: self
)
) : (
)
public class ObjectLiteral = Node (
(* Object literal. ECMA-262, p. 216. *)
|
	public slotNames = List new.
	public slotValues = List new.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[slotNames = anotherNode slotNames and:
		[slotValues = anotherNode slotValues]]
)
public addSlot: name <String> value: object = (
	slotNames addLast: name.
	slotValues addLast: object
)
public slotCount = (
	^slotNames size
)
public slotsDo: aBlock = (
	(* Invoke a two-argument aBlock with the name and the value of each slot in this literal. *)
	^slotNames with: slotValues do: aBlock
)
public slotsDo: aBlock betweenDo: betweenBlock = (
	(* Invoke a two-argument aBlock with the name and the value of each slot in this literal. Between the invocations (but not after the last one), invoke the betweenBlock. *)
	| lastIndex |
	lastIndex:: slotNames size.
	1 to: lastIndex do:
		[:index |
		aBlock value: (slotNames at: index) value: (slotValues at: index).
		index = lastIndex ifFalse: [betweenBlock value]]
)
public visitBy: visitor = (
	^visitor visitObjectLiteral: self
)
) : (
public slotNames: names values: values = (
	| instance |
	instance:: ObjectLiteral new.	
	1 to: names size do: 
		[:index | instance addSlot: (names at: index) value: (values at: index)].
	^instance
)
public slots: namesAndValues = (
	| instance |
	namesAndValues size odd ifTrue: [error: 'invalid slot initialization data'].
	instance:: ObjectLiteral new.
	1 to: namesAndValues size by: 2 do:
		[:i |
		instance addSlot: (namesAndValues at: i) value: (namesAndValues at: i + 1)].
	^instance
)
)
public class OperatorExpression operator: name <String> with: left <Node> and: right <Node> = Node (|
	public operatorName = name.
	public left = left.
	public right = right.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[operatorName = anotherNode operatorName and:
		[left = anotherNode left and:
		[right = anotherNode right]]]
)
public isKindOfOperatorExpression = (
	^true
)
public visitBy: visitor = (
	^visitor visitOperatorExpression: self
)
) : (
)
public class ReturnStatement expression: expr = Node (
(* return expression/opt. *)
|
	expressionS = expr.
|) (
public = anotherNode = (
	^super = anotherNode and: [expression = anotherNode expression]
)
public expression = (
	^expressionS
)
public printOn: stream = (
	super printOn: stream.
	stream nextPutAll: ' ('.
	expression printOn: stream.
	stream nextPutAll: ')'
)
public visitBy: visitor = (
	^visitor visitReturnStatement: self
)
) : (
)
public class Script statements: statements <List[Node]> = Node (
(* A series of statements, a top-level node to hold them together. *)
|
	statements_ = statements.
|) (
public = anotherNode = (
	^super = anotherNode and: [statements = anotherNode statements]
)
public statements ^<List[Node]> = (
	^statements_
)
public visitBy: visitor = (
	^visitor visitScript: self
)
) : (
)
public class StringLiteral value: string <String> = Node (|
	valueS = string.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[value = anotherNode value]
)
public isKindOfStringLiteral ^<Boolean> = (
	^true
)
public printOn: stream = (
	super printOn: stream.
	stream nextPutAll: ' ('.
	value printOn: stream.
	stream nextPutAll: ')'
)
public value = (
	^valueS
)
public visitBy: visitor = (
	^visitor visitStringLiteral: self
)
) : (
)
public class TernaryOperatorExpression if: condExpr then: thenExpr else: elseExpr = Node (|
	public condition = condExpr.
	public then = thenExpr.
	public else = elseExpr.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[condition = anotherNode condition and:
		[then = anotherNode then and:
		[else = anotherNode else]]]
)
public visitBy: visitor = (
	^visitor visitTernaryOperatorExpression: self
)
) : (
)
public class ThrowStatement expression: expr = Node (|
	expressionS = expr.
|) (
public = anotherNode = (
	^super = anotherNode and: [expression = anotherNode expression]
)
public expression = (
	^expressionS
)
public visitBy: visitor = (
	^visitor visitThrowStatement: self
)
) : (
)
public class TryStatement block: pb <Block> catch: cvar <IdentifierExpression | nil> with: cb <Block | nil> finally: fb <Block | nil> = Node (
(* ECMA-262 p. 222 *)
|
	public protectedBlock = pb.
	public catchVar = cvar.
	public catchBlock = cb.
	public finallyBlock = fb.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[protectedBlock = anotherNode protectedBlock and:
		[catchVar = anotherNode catchVar and:
		[catchBlock = anotherNode catchBlock and:
		[finallyBlock = anotherNode finallyBlock]]]]
)
public visitBy: visitor = (
	^visitor visitTryStatement: self
)
) : (
)
public class UnaryOperatorExpression operator: name <String> postfix: postfix <Boolean> on: node <Node> = Node (
(* A unary operator application, either prefix or postfix. *)
|
	public operatorName <String> = name.
	public isPostfix <Boolean> = postfix.
	public operand <Node> = node.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[operatorName = anotherNode operatorName and:
		[isPostfix = anotherNode isPostfix and:
		[operand = anotherNode operand]]]
)
public visitBy: visitor = (
	^visitor visitUnaryOperatorExpression: self
)
) : (
)
public class VariableStatement name: n <IdentifierExpression> initializer: expr <Expression> = Node (
(* var name [= expression] *)
|
	public name = n.
	public initializer = expr.
|) (
public = anotherNode = (
	^super = anotherNode and:
		[name = anotherNode name and:
		[initializer = anotherNode initializer]]
)
public printOn: stream = (
	super printOn: stream.
	stream nextPutAll: ' ('.
	name printOn: stream.
	stream nextPutAll: ', '.
	initializer printOn: stream.
	stream nextPutAll: ')'
)
public visitBy: visitor = (
	^visitor visitVariableStatement: self
)
) : (
public name: s = (
	^VariableStatement name: s initializer: nil
)
)
public class VerbatimNode text: s <String> = Node (
(* A node holding onto arbitrary text, to be emitted verbatim into the generated Javascript source. Nothing but the text is emitted, however the context may insert additional tokens before or after the text. For example if a verbatim node appears as a statement in a block, it will have a terminating semicolon. *)
|
	public text = s.
|) (
public = anotherNode = (
	^super = anotherNode and: [text = anotherNode text]
)
public visitBy: visitor = (
	^visitor visitVerbatimNode: self
)
) : (
)
) : (
)
public class Writer = (
(* Writes out a tree of Javascript syntax elements. *)
|
	private output <StringBuilder>
	private tabLevel <Integer>
	private stringTranslation = Map new.
|stringTranslation at: "\" put: '\\'.
	stringTranslation at: String cr put: '\r'.
	stringTranslation at: String lf put: '\n'.
	stringTranslation at: """ put: '\"') (
beginNewWriteCycleUsing: sb <StringBuilder> = (
	output:: sb.
	tabLevel:: 0.
)
contents ^<String> = (
	(* Answer the Javascript source generated last. *)
	^output asString
)
cr = (
	(* Write a newline and the next line's indentation. *)
	output add: String lf.
	tabLevel timesRepeat: [output add: ' ']
)
public generateSourceFor: node <Node> on: sb <StringBuilder> = (
	(* Generate Javascript source to represent the node, writing it out to the stream. *)
	beginNewWriteCycleUsing: sb.
	node visitBy: self.
)
inIndentedBlock: closure = (
	write: '{'.
	indentCr.
	^closure ensure:
		[unindentCr.
		write: '}']
)
indentCr = (
	tabLevel: tabLevel + 1.
	cr
)
unindentCr = (
	tabLevel:: 0 max: tabLevel - 1.
	cr
)
public visitArrayExpression: node <ArrayExpression> = (
	| elements |
	elements: node elements.
	elements isEmpty ifTrue:
		[^write: '[]'].
	elements size = 1 ifTrue:
		[write: '['.
		elements first visitBy: self.
		^write: ']'].
	write: '['.
	indentCr.
	elements
		do:
			[:each | each visitBy: self]
		separatedBy:
			[write: ','.
			cr].
	unindentCr.
	write: ']'
)
public visitAssignmentExpression: node <AssignmentExpression> = (
	node leftHandSide visitBy: self.
	write: ' = '.
	node rightHandSide visitBy: self.
)
public visitBlock: node <Block> = (
	| statements |
	statements: node statements.
	statements isEmpty ifTrue:
		[^write: '{}'].
	write: '{'.
	indentCr.
	statements
		do:
			[:each |
			each visitBy: self.
			write: ';']
		separatedBy:
			[cr].
	unindentCr.
	write: '}'
)
public visitBooleanLiteral: node <BooleanLiteral> = (
	write:: node value ifTrue: ['true'] ifFalse: ['false']
)
public visitCallExpression: node <CallExpression> = (
	| parenthesize |
	parenthesize:: node function isKindOfFunctionExpression.
	parenthesize ifTrue: [write: '('].
	node function visitBy: self.
	parenthesize ifTrue: [write: ')'].
	write: '('.
	node arguments
		do:
			[:arg |
			arg visitBy: self]
		separatedBy:
			[write: ', '].
	write: ')'
)
public visitDeleteExpression: node <DeleteExpression> = (
	write: 'delete '.
	node memberExpression visitBy: self.
)
public visitForInStatement: node = (
	write: 'for ('.
	node varName visitBy: self.
	write: ' in '.
	node expression visitBy: self.
	write: ') '.
	node body asBlock visitBy: self.
)
public visitForStatement: node = (
	write: 'for ('.
	node initExpression visitBy: self.
	write: '; '.
	node testExpression visitBy: self.
	write: '; '.
	node incrementExpression visitBy: self.
	write: ') '.
	node body asBlock visitBy: self.
)
public visitFunctionExpression: node <FunctionExpression> = (
	visitFunctionStatement: node.
)
public visitFunctionStatement: node <FunctionStatement> = (
	write: 'function '.
	node name ifNotNil:
		[:name |
		name visitBy: self.
		write: ' '].
	write: '('.
	node parameters
		do: [:each | each visitBy: self]
		separatedBy: [write: ', '].
	write: ') '.
	writeBlock: node body.
)
public visitIdentifierExpression: node <IdentifierExpression> = (
	write: node name
)
public visitIfStatement: node <IfStatement> = (
	write: 'if ('.
	node expression visitBy: self.
	write: ') '.
	writeBlock: node thenStatement asBlock.
	node elseStatement ifNotNil:
		[:else |
		write: ' else '.
		writeBlock: node elseStatement asBlock]
)
public visitMemberExpression: node <MemberExpression> = (
	| parenthesize |
	parenthesize:: (node primary isKindOfNumberLiteral
		or: [node primary isKindOfOperatorExpression])
		or: [node primary isKindOfFunctionExpression].
	parenthesize ifTrue: [write: '('].
	node primary visitBy: self.
	parenthesize ifTrue: [write: ')'].

	(node property isKindOfStringLiteral and: [isLegalIdentifier: node property value])
		ifTrue: 	[write: '.'.
				 write: node property value]
		ifFalse: [write: '['.
				 node property visitBy: self.
				 write: ']']
)
public visitNewExpression: node <NewExpression> = (
	write: 'new '.
	node expression visitBy: self.
	write: '('.
	node arguments
		do:
			[:arg |
			arg visitBy: self]
		separatedBy:
			[write: ', '].
	write: ')'
)
public visitNumberLiteral: node <NumberLiteral> = (
	write: node value printString
)
public visitObjectLiteral: node <ObjectLiteral> = (
	node slotCount = 0 ifTrue:
		[write: '{}'.
		^self].
	write: '{'.
	indentCr.
	node
		slotsDo:
			[:name :value |
			name visitBy: self.
			write: ': '.
			value visitBy: self]
		betweenDo:
			[write: ','.
			cr].
	unindentCr.
	write: '}'
)
public visitOperatorExpression: node <OperatorExpression> = (
	| parenthesizeLeft parenthesizeRight |
	parenthesizeLeft:: node left isKindOfOperatorExpression.
	parenthesizeRight:: node right isKindOfOperatorExpression.
	parenthesizeLeft ifTrue: [write: '('].
	node left visitBy: self.
	parenthesizeLeft ifTrue: [write: ') '] ifFalse: [write: ' '].
	node operatorName visitBy: self.
	parenthesizeRight ifTrue: [write: ' ('] ifFalse: [write: ' '].
	node right visitBy: self.
	parenthesizeRight ifTrue: [write: ')']
)
public visitReturnStatement: node <ReturnStatement> = (
	write: 'return'.
	node expression ifNotNil:
		[:expr |
		write: ' '.
		expr visitBy: self]
)
public visitScript: node <Script> = (
	node statements
		do:
			[:each |
			each visitBy: self.
			write: ';']
		separatedBy:
			[cr.
			cr].
)
public visitStringLiteral: node <StringLiteral> = (
	write: '"'.
	node value do:
		[:each | | s |
		s:: stringTranslation
			at: each
			ifAbsent: [{each}].
		write: s].
	write: '"'
)
public visitTernaryOperatorExpression: node = (
	write: '('.
	node condition visitBy: self.
	write: ' ? '.
	node then visitBy: self.
	write: ' : '.
	node else visitBy: self.
	write: ')'
)
public visitThrowStatement: node <ThrowStatement> = (
	write: 'throw '.
	node expression visitBy: self
)
public visitTryStatement: node <TryStatement> = (
	write: 'try '.
	writeBlock: node protectedBlock.
	node catchBlock ifNotNil:
		[:catch |
		write: ' catch ('.
		node catchVar visitBy: self.
		write: ') '.
		writeBlock: catch].
	node finallyBlock ifNotNil:
		[:finally |
		write: ' finally '.
		writeBlock: finally]
)
public visitUnaryOperatorExpression: node <UnaryOperatorExpression> = (
	| isPostfix isOnOperator |
	isPostfix:: node isPostfix.
	isOnOperator:: node operand isKindOfOperatorExpression.
	isPostfix ifFalse: [node operatorName visitBy: self].
	isOnOperator ifTrue: [write: '(']. (* not always necessary, but safer *)
	node operand visitBy: self.
	isOnOperator ifTrue: [write: ')'].
	isPostfix ifTrue: [node operatorName visitBy: self].
)
public visitVariableStatement: node <VariableStatement> = (
	write: 'let '.
	node name visitBy: self.
	node initializer ifNotNil:
		[:expr |
		write: ' = '.
		expr visitBy: self].
)
public visitVerbatimNode: node = (
	write: node text
)
write: text <String> = (
	output add: text
)
writeBlock: block = (
	| statements |
	statements: block statements.
	statements isEmpty
		ifTrue: [write: '{}']
		ifFalse:
			[inIndentedBlock:
				[statements
					do:
						[:each |
						each visitBy: self.
						write: ';']
					separatedBy:
						[cr]]]
)
) : (
)
isLegalIdentifier: id <String> ^<Boolean> = (
	(* This is more conservative than the actual rule. *)
	id size > 0 ifFalse: [^false].
	id do: [:char | ('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_' includes: char) ifFalse: [^false]].
	^id first isKindOfNumber not
)
) : (
)