# `nodes.coffee` contains all of the node classes for the syntax tree. Most

# nodes are created as the result of actions in the [grammar](grammar.html),

# but some are created by other nodes as a method of code generation. To convert

# the syntax tree into a string of JavaScript code, call `compile()` on the root.

{Scope} = require './scope'

# Import the helpers we plan to use.

{compact, flatten, extend, merge, del, starts, ends, last} = require './helpers'

exports.extend = extend # for parser

# Constant functions for nodes that don't need customization.

YES = -> yes

NO = -> no

THIS = -> this

NEGATE = -> @negated = not @negated; this

#### Base

# The **Base** is the abstract base class for all nodes in the syntax tree.

# Each subclass implements the `compileNode` method, which performs the

# code generation for that node. To compile a node to JavaScript,

# call `compile` on it, which wraps `compileNode` in some generic extra smarts,

# to know when the generated code needs to be wrapped up in a closure.

# An options hash is passed and cloned throughout, containing information about

# the environment from higher in the tree (such as if a returned value is

# being requested by the surrounding function), information about the current

# scope, and indentation level.

exports.Base = class Base

# Common logic for determining whether to wrap this node in a closure before

# compiling it, or to compile directly. We need to wrap if this node is a

# *statement*, and it's not a *pureStatement*, and we're not at

# the top level of a block (which would be unnecessary), and we haven't

# already been asked to return the result (because statements know how to

# return results).

compile: (o, lvl) ->

o = extend {}, o

o.level = lvl if lvl

node = @unfoldSoak(o) or this

node.tab = o.indent

if o.level is LEVEL_TOP or not node.isStatement(o)

node.compileNode o

else

node.compileClosure o

# Statements converted into expressions via closure-wrapping share a scope

# object with their parent closure, to preserve the expected lexical scope.

compileClosure: (o) ->

if @jumps() or this instanceof Throw

throw SyntaxError 'cannot use a pure statement in an expression.'

o.sharedScope = yes

Closure.wrap(this).compileNode o

# If the code generation wishes to use the result of a complex expression

# in multiple places, ensure that the expression is only ever evaluated once,

# by assigning it to a temporary variable. Pass a level to precompile.

cache: (o, level, reused) ->

unless @isComplex()

ref = if level then @compile o, level else this

[ref, ref]

else

ref = new Literal reused or o.scope.freeVariable 'ref'

sub = new Assign ref, this

if level then [sub.compile(o, level), ref.value] else [sub, ref]

# Compile to a source/variable pair suitable for looping.

compileLoopReference: (o, name) ->

src = tmp = @compile o, LEVEL_LIST

unless -Infinity < +src < Infinity or IDENTIFIER.test(src) and o.scope.check(src, yes)

src = "#{ tmp = o.scope.freeVariable name } = #{src}"

[src, tmp]

# Construct a node that returns the current node's result.

# Note that this is overridden for smarter behavior for

# many statement nodes (e.g. If, For)...

makeReturn: ->

new Return this

# Does this node, or any of its children, contain a node of a certain kind?

# Recursively traverses down the *children* of the nodes, yielding to a block

# and returning true when the block finds a match. `contains` does not cross

# scope boundaries.

contains: (pred) ->

contains = no

@traverseChildren no, (node) ->

if pred node

contains = yes

return no

contains

# Is this node of a certain type, or does it contain the type?

containsType: (type) ->

this instanceof type or @contains (node) -> node instanceof type

# Pull out the last non-comment node of a node list.

lastNonComment: (list) ->

i = list.length

return list[i] while i-- when list[i] not instanceof Comment

null

# `toString` representation of the node, for inspecting the parse tree.

# This is what `coffee --nodes` prints out.

toString: (idt = '', name = @constructor.name) ->

tree = '\n' + idt + name

tree += '?' if @soak

@eachChild (node) -> tree += node.toString idt + TAB

tree

# Passes each child to a function, breaking when the function returns `false`.

eachChild: (func) ->

return this unless @children

for attr in @children when @[attr]

for child in flatten [@[attr]]

return this if func(child) is false

this

traverseChildren: (crossScope, func) ->

@eachChild (child) ->

return false if func(child) is false

child.traverseChildren crossScope, func

invert: ->

new Op '!', this

unwrapAll: ->

node = this

continue until node is node = node.unwrap()

node

# Default implementations of the common node properties and methods. Nodes

# will override these with custom logic, if needed.

children: []

isStatement : NO

jumps : NO

isComplex : YES

isChainable : NO

isAssignable : NO

unwrap : THIS

unfoldSoak : NO

# Is this node used to assign a certain variable?

assigns: NO

#### Block

# The block is the list of expressions that forms the body of an

# indented block of code -- the implementation of a function, a clause in an

# `if`, `switch`, or `try`, and so on...

exports.Block = class Block extends Base

constructor: (nodes) ->

@expressions = compact flatten nodes or []

children: ['expressions']

# Tack an expression on to the end of this expression list.

push: (node) ->

@expressions.push node

this

# Remove and return the last expression of this expression list.

pop: ->

@expressions.pop()

# Add an expression at the beginning of this expression list.

unshift: (node) ->

@expressions.unshift node

this

# If this Block consists of just a single node, unwrap it by pulling

# it back out.

unwrap: ->

if @expressions.length is 1 then @expressions[0] else this

# Is this an empty block of code?

isEmpty: ->

not @expressions.length

isStatement: (o) ->

for exp in @expressions when exp.isStatement o

return yes

no

jumps: (o) ->

for exp in @expressions

return exp if exp.jumps o

# A Block node does not return its entire body, rather it

# ensures that the final expression is returned.

makeReturn: ->

len = @expressions.length

while len--

expr = @expressions[len]

if expr not instanceof Comment

@expressions[len] = expr.makeReturn()

@expressions.splice(len, 1) if expr instanceof Return and not expr.expression

break

this

# A **Block** is the only node that can serve as the root.

compile: (o = {}, level) ->

if o.scope then super o, level else @compileRoot o

# Compile all expressions within the **Block** body. If we need to

# return the result, and it's an expression, simply return it. If it's a

# statement, ask the statement to do so.

compileNode: (o) ->

@tab = o.indent

top = o.level is LEVEL_TOP

codes = []

for node in @expressions

node = node.unwrapAll()

node = (node.unfoldSoak(o) or node)

if node instanceof Block

# This is a nested block. We don't do anything special here like enclose

# it in a new scope; we just compile the statements in this block along with

# our own

codes.push node.compileNode o

else if top

node.front = true

code = node.compile o

codes.push if node.isStatement o then code else @tab + code + ';'

else

codes.push node.compile o, LEVEL_LIST

return codes.join '\n' if top

code = codes.join(', ') or 'void 0'

if codes.length > 1 and o.level >= LEVEL_LIST then "(#{code})" else code

# If we happen to be the top-level **Block**, wrap everything in

# a safety closure, unless requested not to.

# It would be better not to generate them in the first place, but for now,

# clean up obvious double-parentheses.

compileRoot: (o) ->

o.indent = @tab = if o.bare then '' else TAB

o.scope = new Scope null, this, null

o.level = LEVEL_TOP

code = @compileWithDeclarations o

if o.google

provides = o.google.provides

provides.sort()

providesJs = ("goog.provide('#{name}');" for name in provides)

providesJs = providesJs.join '\n'

includes = o.google.includes

comparator = (a, b) -> a.name.localeCompare(b.name)

includes.sort comparator

# Sometimes a file may try to both provide and require the same namespace,

# e.g., a class and its subclass are declared in the same file. When this

# happens, the goog.require() statement should not be included, though it

# may have an alias within the goog.scope() call.

includesJs = ("goog.require('#{inc.name}');" for inc in includes \

when provides.indexOf(inc.name) == -1)

includesJs = includesJs.join '\n'

aliases = (inc for inc in includes when inc.alias)

aliases.sort comparator

idt = @tab + TAB

aliases = ("#{idt}var #{inc.alias} = #{inc.name};" for inc in aliases)

aliases = aliases.join '\n'

code = """

#{providesJs}

#{includesJs}

goog.scope(function() {

#{aliases}

#{code}

}); // close goog.scope()

"""

if o.bare then code else "(function() {\n#{code}\n}).call(this);\n"

# Compile the expressions body for the contents of a function, with

# declarations of all inner variables pushed up to the top.

compileWithDeclarations: (o) ->

code = post = ''

for exp, i in @expressions

exp = exp.unwrap()

break unless exp instanceof Comment or exp instanceof Literal

o = merge(o, level: LEVEL_TOP)

if i

rest = @expressions.splice i, @expressions.length

code = @compileNode(o)

@expressions = rest

post = @compileNode o

{scope} = o

if scope.expressions is this

declars = o.scope.hasDeclarations()

assigns = scope.hasAssignments

if (declars or assigns) and i

code += '\n'

if declars

code += "#{@tab}var #{ scope.declaredVariables().join(', ') };\n"

if assigns

code += "#{@tab}var #{ multident scope.assignedVariables().join(', '), @tab };\n"

code + post

# Wrap up the given nodes as a **Block**, unless it already happens

# to be one.

@wrap: (nodes) ->

return nodes[0] if nodes.length is 1 and nodes[0] instanceof Block

new Block nodes

#### Literal

# Literals are static values that can be passed through directly into

# JavaScript without translation, such as: strings, numbers,

# `true`, `false`, `null`...

exports.Literal = class Literal extends Base

constructor: (@value) ->

makeReturn: ->

if @isStatement() then this else new Return this

isAssignable: ->

IDENTIFIER.test @value

isStatement: ->

@value in ['break', 'continue', 'debugger']

isComplex: NO

assigns: (name) ->

name is @value

jumps: (o) ->

return no unless @isStatement()

if not (o and (o.loop or o.block and (@value isnt 'continue'))) then this else no

compileNode: (o) ->

code = if @isUndefined

if o.level >= LEVEL_ACCESS then '(void 0)' else 'void 0'

else if @value.reserved

"\"#{@value}\""

else

@value

if @isStatement() then "#{@tab}#{code};" else code

toString: ->

' "' + @value + '"'

#### Return

# A `return` is a *pureStatement* -- wrapping it in a closure wouldn't

# make sense.

exports.Return = class Return extends Base

constructor: (expr) ->

@expression = expr if expr and not expr.unwrap().isUndefined

children: ['expression']

isStatement: YES

makeReturn: THIS

jumps: THIS

compile: (o, level) ->

expr = @expression?.makeReturn()

if expr and expr not instanceof Return then expr.compile o, level else super o, level

compileNode: (o) ->

@tab + "return#{ if @expression then ' ' + @expression.compile(o, LEVEL_PAREN) else '' };"

#### Value

# A value, variable or literal or parenthesized, indexed or dotted into,

# or vanilla.

exports.Value = class Value extends Base

constructor: (base, props, tag) ->

return base if not props and base instanceof Value

@base = base

@properties = props or []

@[tag] = true if tag

return this

children: ['base', 'properties']

# Add a property access to the list.

push: (prop) ->

@properties.push prop

this

hasProperties: ->

[email protected]

# Some boolean checks for the benefit of other nodes.

isArray : -> not @properties.length and @base instanceof Arr

isComplex : -> @hasProperties() or @base.isComplex()

isAssignable : -> @hasProperties() or @base.isAssignable()

isSimpleNumber : -> @base instanceof Literal and SIMPLENUM.test @base.value

isAtomic : ->

for node in @properties.concat @base

return no if node.soak or node instanceof Call

yes

isStatement : (o) -> not @properties.length and @base.isStatement o

assigns : (name) -> not @properties.length and @base.assigns name

jumps : (o) -> not @properties.length and @base.jumps o

isObject: (onlyGenerated) ->

return no if @properties.length

(@base instanceof Obj) and (not onlyGenerated or @base.generated)

isSplice: ->

last(@properties) instanceof Slice

makeReturn: ->

if @properties.length then super() else @base.makeReturn()

# The value can be unwrapped as its inner node, if there are no attached

# properties.

unwrap: ->

if @properties.length then this else @base

# A reference has base part (`this` value) and name part.

# We cache them separately for compiling complex expressions.

# `a()[b()] ?= c` -> `(_base = a())[_name = b()] ? _base[_name] = c`

cacheReference: (o) ->

name = last @properties

if @properties.length < 2 and not @base.isComplex() and not name?.isComplex()

return [this, this] # `a` `a.b`

base = new Value @base, @properties[...-1]

if base.isComplex() # `a().b`

bref = new Literal o.scope.freeVariable 'base'

base = new Value new Parens new Assign bref, base

return [base, bref] unless name # `a()`

if name.isComplex() # `a[b()]`

nref = new Literal o.scope.freeVariable 'name'

name = new Index new Assign nref, name.index

nref = new Index nref

[base.push(name), new Value(bref or base.base, [nref or name])]

# We compile a value to JavaScript by compiling and joining each property.

# Things get much more interesting if the chain of properties has *soak*

# operators `?.` interspersed. Then we have to take care not to accidentally

# evaluate anything twice when building the soak chain.

compileNode: (o) ->

@base.front = @front

props = @properties

code = @base.compile o, if props.length then LEVEL_ACCESS else null

code = "#{code}." if (@base instanceof Parens or props.length) and SIMPLENUM.test code

code += prop.compile o for prop in props

code

# Unfold a soak into an `If`: `a?.b` -> `a.b if a?`

unfoldSoak: (o) ->

return @unfoldedSoak if @unfoldedSoak?

result = do =>

if ifn = @base.unfoldSoak o

Array::push.apply ifn.body.properties, @properties

return ifn

for prop, i in @properties when prop.soak

prop.soak = off

fst = new Value @base, @properties[...i]

snd = new Value @base, @properties[i..]

if fst.isComplex()

ref = new Literal o.scope.freeVariable 'ref'

fst = new Parens new Assign ref, fst

snd.base = ref

return new If new Existence(fst), snd, soak: on

null

@unfoldedSoak = result or no

#### Comment

# CoffeeScript passes through block comments as JavaScript block comments

# at the same position.

exports.Comment = class Comment extends Base

constructor: (@comment) ->

isStatement: YES

makeReturn: THIS

compileNode: (o, level) ->

code = '/*' + multident(@comment, @tab) + '*/'

code = o.indent + code if (level or o.level) is LEVEL_TOP

code

#### Call

# Node for a function invocation. Takes care of converting `super()` calls into

# calls against the prototype's function of the same name.

exports.Call = class Call extends Base

constructor: (variable, @args = [], @soak) ->

@isNew = false

@isSuper = variable is 'super'

@variable = if @isSuper then null else variable

children: ['variable', 'args']

# Tag this invocation as creating a new instance.

newInstance: ->

base = @variable.base or @variable

if base instanceof Call and not base.isNew

base.newInstance()

else

@isNew = true

this

# Grab the reference to the superclass's implementation of the current

# method.

superReference: (o) ->

{method} = o.scope

throw SyntaxError 'cannot call super outside of a function.' unless method

{name} = method

throw SyntaxError 'cannot call super on an anonymous function.' unless name?

if o.google

if method.klass

(new Value (new Literal method.klass), [new Access(new Literal "superClass_"), new Access new Literal name]).compile o

else if method.ctorParent

# This is a call to the superclass constructor.

# Although the technique used by CoffeeScript (__super__.constructor)

# should also work for Closure, we use a slightly different style for

# consistency with existing Closure Library code.

method.ctorParent.compile o

else

throw SyntaxError "super() called without a parent class"

else

if method.klass

(new Value (new Literal method.klass), [new Access(new Literal "__super__"), new Access new Literal name]).compile o

else

"#{name}.__super__.constructor"

# Soaked chained invocations unfold into if/else ternary structures.

unfoldSoak: (o) ->

if @soak

if @variable

return ifn if ifn = unfoldSoak o, this, 'variable'

[left, rite] = new Value(@variable).cacheReference o

else

left = new Literal @superReference o

rite = new Value left

rite = new Call rite, @args

rite.isNew = @isNew

left = new Literal "typeof #{ left.compile o } === \"function\""

return new If left, new Value(rite), soak: yes

call = this

list = []

loop

if call.variable instanceof Call

list.push call

call = call.variable

continue

break unless call.variable instanceof Value

list.push call

break unless (call = call.variable.base) instanceof Call

for call in list.reverse()

if ifn

if call.variable instanceof Call

call.variable = ifn

else

call.variable.base = ifn

ifn = unfoldSoak o, call, 'variable'

ifn

# Walk through the objects in the arguments, moving over simple values.

# This allows syntax like `call a: b, c` into `call({a: b}, c);`

filterImplicitObjects: (list) ->

nodes = []

for node in list

unless node.isObject?() and node.base.generated

nodes.push node

continue

obj = null

for prop in node.base.properties

if prop instanceof Assign or prop instanceof Comment

nodes.push obj = new Obj properties = [], true if not obj

properties.push prop

else

nodes.push prop

obj = null

nodes

# Compile a vanilla function call.

compileNode: (o) ->

@variable?.front = @front

if code = Splat.compileSplattedArray o, @args, true

return @compileSplat o, code

args = @filterImplicitObjects @args

args = (arg.compile o, LEVEL_LIST for arg in args).join ', '

if @isSuper

@superReference(o) + ".call(this#{ args and ', ' + args })"

else

(if @isNew then 'new ' else '') + @variable.compile(o, LEVEL_ACCESS) + "(#{args})"

# `super()` is converted into a call against the superclass's implementation

# of the current function.

compileSuper: (args, o) ->

"#{@superReference(o)}.call(this#{ if args.length then ', ' else '' }#{args})"

# If you call a function with a splat, it's converted into a JavaScript

# `.apply()` call to allow an array of arguments to be passed.

# If it's a constructor, then things get real tricky. We have to inject an

# inner constructor in order to be able to pass the varargs.

compileSplat: (o, splatArgs) ->

return "#{ @superReference o }.apply(this, #{splatArgs})" if @isSuper

if @isNew

idt = @tab + TAB

return """

(function(func, args, ctor) {

#{idt}ctor.prototype = func.prototype;

#{idt}var child = new ctor, result = func.apply(child, args);

#{idt}return typeof result === "object" ? result : child;

#{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function() {})

"""

base = new Value @variable

if (name = base.properties.pop()) and base.isComplex()

ref = o.scope.freeVariable 'ref'

fun = "(#{ref} = #{ base.compile o, LEVEL_LIST })#{ name.compile o }"

else

fun = base.compile o, LEVEL_ACCESS

fun = "(#{fun})" if SIMPLENUM.test fun

if name

ref = fun

fun += name.compile o

else

ref = 'null'

"#{fun}.apply(#{ref}, #{splatArgs})"

#### Extends

# Node to extend an object's prototype with an ancestor object.

# After `goog.inherits` from the

# [Closure Library](http://closure-library.googlecode.com/svn/docs/closureGoogBase.js.html).

exports.Extends = class Extends extends Base

constructor: (@child, @parent) ->

children: ['child', 'parent']

# Hooks one constructor into another's prototype chain.

compile: (o) ->

unless o.google

utility 'hasProp', o

if o.google

inheritsFunction = new Value(new Literal 'goog.inherits')

else

inheritsFunction = new Value(new Literal utility 'extends', o)

new Call(inheritsFunction, [@child, @parent]).compile o

#### Access

# A `.` access into a property of a value, or the `::` shorthand for

# an access into the object's prototype.

exports.Access = class Access extends Base

constructor: (@name, tag) ->

@name.asKey = yes

@proto = if tag is 'proto' then '.prototype' else ''

@soak = tag is 'soak'

children: ['name']

compile: (o) ->

name = @name.compile o

@proto + if IDENTIFIER.test name then ".#{name}" else "[#{name}]"

isComplex: NO

#### Index

# A `[ ... ]` indexed access into an array or object.

exports.Index = class Index extends Base

constructor: (@index) ->

children: ['index']

compile: (o) ->

(if @proto then '.prototype' else '') + "[#{ @index.compile o, LEVEL_PAREN }]"

isComplex: ->

@index.isComplex()

#### Range

# A range literal. Ranges can be used to extract portions (slices) of arrays,

# to specify a range for comprehensions, or as a value, to be expanded into the

# corresponding array of integers at runtime.

exports.Range = class Range extends Base

children: ['from', 'to']

constructor: (@from, @to, tag) ->

@exclusive = tag is 'exclusive'

@equals = if @exclusive then '' else '='

# Compiles the range's source variables -- where it starts and where it ends.

# But only if they need to be cached to avoid double evaluation.

compileVariables: (o) ->

o = merge o, top: true

[@fromC, @fromVar] = @from.cache o, LEVEL_LIST

[@toC, @toVar] = @to.cache o, LEVEL_LIST

[@step, @stepVar] = step.cache o, LEVEL_LIST if step = del o, 'step'

[@fromNum, @toNum] = [@fromVar.match(SIMPLENUM), @toVar.match(SIMPLENUM)]

@stepNum = @stepVar.match(SIMPLENUM) if @stepVar

# When compiled normally, the range returns the contents of the *for loop*

# needed to iterate over the values in the range. Used by comprehensions.

compileNode: (o) ->

@compileVariables o unless @fromVar

return @compileArray(o) unless o.index

# Set up endpoints.

known = @fromNum and @toNum

idx = del o, 'index'

varPart = "#{idx} = #{@fromC}"

varPart += ", #{@toC}" if @toC isnt @toVar

varPart += ", #{@step}" if @step isnt @stepVar

[lt, gt] = ["#{idx} <#{@equals}", "#{idx} >#{@equals}"]

# Generate the condition.

condPart = if @stepNum

condPart = if +@stepNum > 0 then "#{lt} #{@toVar}" else "#{gt} #{@toVar}"

else if known

[from, to] = [+@fromNum, +@toNum]

condPart = if from <= to then "#{lt} #{to}" else "#{gt} #{to}"

else

cond = "#{@fromVar} <= #{@toVar}"

condPart = "#{cond} ? #{lt} #{@toVar} : #{gt} #{@toVar}"

# Generate the step.

stepPart = if @stepVar

"#{idx} += #{@stepVar}"

else if known

if from <= to then "#{idx}++" else "#{idx}--"

else

"#{cond} ? #{idx}++ : #{idx}--"

# The final loop body.

"#{varPart}; #{condPart}; #{stepPart}"

# When used as a value, expand the range into the equivalent array.

compileArray: (o) ->

if @fromNum and @toNum and Math.abs(@fromNum - @toNum) <= 20

range = [+@fromNum..+@toNum]

range.pop() if @exclusive

return "[#{ range.join(', ') }]"

idt = @tab + TAB

i = o.scope.freeVariable 'i'

result = o.scope.freeVariable 'results'

pre = "\n#{idt}#{result} = [];"

if @fromNum and @toNum

o.index = i

body = @compileNode o

else

vars = "#{i} = #{@fromC}" + if @toC isnt @toVar then ", #{@toC}" else ''

cond = "#{@fromVar} <= #{@toVar}"

body = "var #{vars}; #{cond} ? #{i} <#{@equals} #{@toVar} : #{i} >#{@equals} #{@toVar}; #{cond} ? #{i}++ : #{i}--"

post = "{ #{result}.push(#{i}); }\n#{idt}return #{result};\n#{o.indent}"

hasArgs = (node) -> node?.contains (n) -> n instanceof Literal and n.value is 'arguments' and not n.asKey

args = ', arguments' if hasArgs(@from) or hasArgs(@to)

"(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this#{args ? ''})"

#### Slice

# An array slice literal. Unlike JavaScript's `Array#slice`, the second parameter

# specifies the index of the end of the slice, just as the first parameter

# is the index of the beginning.

exports.Slice = class Slice extends Base

children: ['range']

constructor: (@range) ->

super()

# We have to be careful when trying to slice through the end of the array,

# `9e9` is used because not all implementations respect `undefined` or `1/0`.

# `9e9` should be safe because `9e9` > `2**32`, the max array length.

compileNode: (o) ->

{to, from} = @range

fromStr = from and from.compile(o, LEVEL_PAREN) or '0'

compiled = to and to.compile o, LEVEL_PAREN

if to and not (not @range.exclusive and +compiled is -1)

toStr = ', ' + if @range.exclusive

compiled

else if SIMPLENUM.test compiled

(+compiled + 1).toString()

else

"(#{compiled} + 1) || 9e9"

".slice(#{ fromStr }#{ toStr or '' })"

#### Obj

# An object literal, nothing fancy.

exports.Obj = class Obj extends Base

constructor: (props, @generated = false) ->

@objects = @properties = props or []

children: ['properties']

compileNode: (o) ->

props = @properties

return (if @front then '({})' else '{}') unless props.length

if @generated

for node in props when node instanceof Value

throw new Error 'cannot have an implicit value in an implicit object'

idt = o.indent += TAB

lastNoncom = @lastNonComment @properties

props = for prop, i in props

join = if i is props.length - 1

''

else if prop is lastNoncom or prop instanceof Comment

'\n'

else

',\n'

indent = if prop instanceof Comment then '' else idt

if prop instanceof Value and prop.this

prop = new Assign prop.properties[0].name, prop, 'object'

if prop not instanceof Comment

if prop not instanceof Assign

prop = new Assign prop, prop, 'object'

(prop.variable.base or prop.variable).asKey = yes

indent + prop.compile(o, LEVEL_TOP) + join

props = props.join ''

obj = "{#{ props and '\n' + props + '\n' + @tab }}"

if @front then "(#{obj})" else obj

assigns: (name) ->

for prop in @properties when prop.assigns name then return yes

no

#### Arr

# An array literal.

exports.Arr = class Arr extends Base

constructor: (objs) ->

@objects = objs or []

children: ['objects']

filterImplicitObjects: Call::filterImplicitObjects

compileNode: (o) ->

return '[]' unless @objects.length

o.indent += TAB

objs = @filterImplicitObjects @objects

return code if code = Splat.compileSplattedArray o, objs

code = (obj.compile o, LEVEL_LIST for obj in objs).join ', '

if code.indexOf('\n') >= 0

"[\n#{o.indent}#{code}\n#{@tab}]"

else

"[#{code}]"

assigns: (name) ->

for obj in @objects when obj.assigns name then return yes

no

#### Class

# The CoffeeScript class definition.

# Initialize a **Class** with its name, an optional superclass, and a

# list of prototype property assignments.

exports.Class = class Class extends Base

constructor: (@variable, @parent, @body = new Block) ->

@boundFuncs = []

@body.classBody = yes

children: ['variable', 'parent', 'body']

# Figure out the appropriate name for the constructor function of this class.

determineName: (o) ->

return null unless @variable

return @variable.compile o if o.google or o.closure

decl = if tail = last @variable.properties

tail instanceof Access and tail.name.value

else

@variable.base.value

decl and= IDENTIFIER.test(decl) and decl

# For all `this`-references and bound functions in the class definition,

# `this` is the Class being constructed.

setContext: (name) ->

@body.traverseChildren false, (node) ->

return false if node.classBody

if node instanceof Literal and node.value is 'this'

node.value = name

else if node instanceof Code

node.klass = name

node.context = name if node.bound

# Ensure that all functions bound to the instance are proxied in the

# constructor.

addBoundFunctions: (o) ->

if @boundFuncs.length

for bvar in @boundFuncs

lhs = (new Value (new Literal "this"), [new Access bvar]).compile o

@ctor.body.unshift new Literal "#{lhs} = #{utility 'bind', o}(#{lhs}, this)"

# Merge the properties from a top-level object as prototypal properties

# on the class.

addProperties: (node, name, o) ->

props = node.base.properties[0..]

exprs = while assign = props.shift()

if assign instanceof Assign

base = assign.variable.base

delete assign.context

func = assign.value

if base.value is 'constructor'

if @ctor

throw new Error 'cannot define more than one constructor in a class'

if func.bound

throw new Error 'cannot define a constructor as a bound function'

if func instanceof Code

assign = @ctor = func

else

@externalCtor = o.scope.freeVariable 'class'

assign = new Assign new Literal(@externalCtor), func

else

unless assign.variable.this

assign.variable = new Value(new Literal(name), [new Access(base, 'proto')])

if func instanceof Code and func.bound

@boundFuncs.push base

func.bound = no

assign

compact exprs

# Walk the body of the class, looking for prototype properties to be converted.

walkBody: (name, o) ->

@traverseChildren false, (child) =>

return false if child instanceof Class

if child instanceof Block

for node, i in exps = child.expressions

if node instanceof Value and node.isObject(true)

exps[i] = @addProperties node, name, o

child.expressions = exps = flatten exps

# Make sure that a constructor is defined for the class, and properly

# configured.

ensureConstructor: (name, o) ->

if not @ctor

@ctor = new Code

unless o.google

@ctor.body.push new Literal "#{name}.__super__.constructor.apply(this, arguments)" if @parent

@ctor.body.push new Literal "#{@externalCtor}.apply(this, arguments)" if @externalCtor

@body.expressions.unshift @ctor

@ctor.ctor = @ctor.name = name

@ctor.klass = null

@ctor.noReturn = yes

# This is added for the benefit of --google.

@ctor.ctorParent = @parent

# Instead of generating the JavaScript string directly, we build up the

# equivalent syntax tree and compile that, in pieces. You can see the

# constructor, property assignments, and inheritance getting built out below.

compileNode: (o) ->

decl = @determineName o

name = decl or @name or '_Class'

lname = new Literal name

@setContext name

@walkBody name, o

@ensureConstructor name, o

@body.expressions.unshift new Extends lname, @parent if @parent and not o.google and not o.closure

@body.expressions.unshift @ctor unless @ctor instanceof Code

@body.expressions.push lname unless (o.google or o.closure)

@addBoundFunctions o

if o.google or o.closure

@body.compile o

else

klass = new Parens Closure.wrap(@body), true

klass = new Assign @variable, klass if @variable

klass.compile o

#### Assign

# The **Assign** is used to assign a local variable to value, or to set the

# property of an object -- including within object literals.

exports.Assign = class Assign extends Base

constructor: (@variable, @value, @context, options) ->

@param = options and options.param

children: ['variable', 'value']

isStatement: (o) ->

o?.level is LEVEL_TOP and @context and "?" in @context

assigns: (name) ->

@[if @context is 'object' then 'value' else 'variable'].assigns name

unfoldSoak: (o) ->

unfoldSoak o, this, 'variable'

# Compile an assignment, delegating to `compilePatternMatch` or

# `compileSplice` if appropriate. Keep track of the name of the base object

# we've been assigned to, for correct internal references. If the variable

# has not been seen yet within the current scope, declare it.

compileNode: (o) ->

if isValue = @variable instanceof Value

return @compilePatternMatch o if @variable.isArray() or @variable.isObject()

return @compileSplice o if @variable.isSplice()

return @compileConditional o if @context in ['||=', '&&=', '?=']

name = @variable.compile o, LEVEL_LIST

unless @context or @variable.isAssignable()

throw SyntaxError "\"#{ @variable.compile o }\" cannot be assigned."

unless @context or isValue and (@variable.namespaced or @variable.hasProperties())

if @param

o.scope.add name, 'var'