6139 lines
215 KiB
CoffeeScript
6139 lines
215 KiB
CoffeeScript
# `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.
|
||
|
||
Error.stackTraceLimit = Infinity
|
||
|
||
{Scope} = require './scope'
|
||
{isUnassignable, JS_FORBIDDEN} = require './lexer'
|
||
|
||
# Import the helpers we plan to use.
|
||
{compact, flatten, extend, merge, del, starts, ends, some,
|
||
addDataToNode, attachCommentsToNode, locationDataToString,
|
||
throwSyntaxError, replaceUnicodeCodePointEscapes,
|
||
isFunction, isPlainObject, isNumber, parseNumber} = require './helpers'
|
||
|
||
# Functions required by parser.
|
||
exports.extend = extend
|
||
exports.addDataToNode = addDataToNode
|
||
|
||
# Constant functions for nodes that don’t need customization.
|
||
YES = -> yes
|
||
NO = -> no
|
||
THIS = -> this
|
||
NEGATE = -> @negated = not @negated; this
|
||
|
||
#### CodeFragment
|
||
|
||
# The various nodes defined below all compile to a collection of **CodeFragment** objects.
|
||
# A CodeFragments is a block of generated code, and the location in the source file where the code
|
||
# came from. CodeFragments can be assembled together into working code just by catting together
|
||
# all the CodeFragments' `code` snippets, in order.
|
||
exports.CodeFragment = class CodeFragment
|
||
constructor: (parent, code) ->
|
||
@code = "#{code}"
|
||
@type = parent?.constructor?.name or 'unknown'
|
||
@locationData = parent?.locationData
|
||
@comments = parent?.comments
|
||
|
||
toString: ->
|
||
# This is only intended for debugging.
|
||
"#{@code}#{if @locationData then ": " + locationDataToString(@locationData) else ''}"
|
||
|
||
# Convert an array of CodeFragments into a string.
|
||
fragmentsToText = (fragments) ->
|
||
(fragment.code for fragment in fragments).join('')
|
||
|
||
#### 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
|
||
|
||
compile: (o, lvl) ->
|
||
fragmentsToText @compileToFragments o, lvl
|
||
|
||
# Occasionally a node is compiled multiple times, for example to get the name
|
||
# of a variable to add to scope tracking. When we know that a “premature”
|
||
# compilation won’t result in comments being output, set those comments aside
|
||
# so that they’re preserved for a later `compile` call that will result in
|
||
# the comments being included in the output.
|
||
compileWithoutComments: (o, lvl, method = 'compile') ->
|
||
if @comments
|
||
@ignoreTheseCommentsTemporarily = @comments
|
||
delete @comments
|
||
unwrapped = @unwrapAll()
|
||
if unwrapped.comments
|
||
unwrapped.ignoreTheseCommentsTemporarily = unwrapped.comments
|
||
delete unwrapped.comments
|
||
|
||
fragments = @[method] o, lvl
|
||
|
||
if @ignoreTheseCommentsTemporarily
|
||
@comments = @ignoreTheseCommentsTemporarily
|
||
delete @ignoreTheseCommentsTemporarily
|
||
if unwrapped.ignoreTheseCommentsTemporarily
|
||
unwrapped.comments = unwrapped.ignoreTheseCommentsTemporarily
|
||
delete unwrapped.ignoreTheseCommentsTemporarily
|
||
|
||
fragments
|
||
|
||
compileNodeWithoutComments: (o, lvl) ->
|
||
@compileWithoutComments o, lvl, 'compileNode'
|
||
|
||
# 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).
|
||
compileToFragments: (o, lvl) ->
|
||
o = extend {}, o
|
||
o.level = lvl if lvl
|
||
node = @unfoldSoak(o) or this
|
||
node.tab = o.indent
|
||
|
||
fragments = if o.level is LEVEL_TOP or not node.isStatement(o)
|
||
node.compileNode o
|
||
else
|
||
node.compileClosure o
|
||
@compileCommentFragments o, node, fragments
|
||
fragments
|
||
|
||
compileToFragmentsWithoutComments: (o, lvl) ->
|
||
@compileWithoutComments o, lvl, 'compileToFragments'
|
||
|
||
# Statements converted into expressions via closure-wrapping share a scope
|
||
# object with their parent closure, to preserve the expected lexical scope.
|
||
compileClosure: (o) ->
|
||
@checkForPureStatementInExpression()
|
||
o.sharedScope = yes
|
||
func = new Code [], Block.wrap [this]
|
||
args = []
|
||
if @contains ((node) -> node instanceof SuperCall)
|
||
func.bound = yes
|
||
else if (argumentsNode = @contains isLiteralArguments) or @contains isLiteralThis
|
||
args = [new ThisLiteral]
|
||
if argumentsNode
|
||
meth = 'apply'
|
||
args.push new IdentifierLiteral 'arguments'
|
||
else
|
||
meth = 'call'
|
||
func = new Value func, [new Access new PropertyName meth]
|
||
parts = (new Call func, args).compileNode o
|
||
|
||
switch
|
||
when func.isGenerator or func.base?.isGenerator
|
||
parts.unshift @makeCode "(yield* "
|
||
parts.push @makeCode ")"
|
||
when func.isAsync or func.base?.isAsync
|
||
parts.unshift @makeCode "(await "
|
||
parts.push @makeCode ")"
|
||
parts
|
||
|
||
compileCommentFragments: (o, node, fragments) ->
|
||
return fragments unless node.comments
|
||
# This is where comments, that are attached to nodes as a `comments`
|
||
# property, become `CodeFragment`s. “Inline block comments,” e.g.
|
||
# `/* */`-delimited comments that are interspersed within code on a line,
|
||
# are added to the current `fragments` stream. All other fragments are
|
||
# attached as properties to the nearest preceding or following fragment,
|
||
# to remain stowaways until they get properly output in `compileComments`
|
||
# later on.
|
||
unshiftCommentFragment = (commentFragment) ->
|
||
if commentFragment.unshift
|
||
# Find the first non-comment fragment and insert `commentFragment`
|
||
# before it.
|
||
unshiftAfterComments fragments, commentFragment
|
||
else
|
||
if fragments.length isnt 0
|
||
precedingFragment = fragments[fragments.length - 1]
|
||
if commentFragment.newLine and precedingFragment.code isnt '' and
|
||
not /\n\s*$/.test precedingFragment.code
|
||
commentFragment.code = "\n#{commentFragment.code}"
|
||
fragments.push commentFragment
|
||
|
||
for comment in node.comments when comment not in @compiledComments
|
||
@compiledComments.push comment # Don’t output this comment twice.
|
||
# For block/here comments, denoted by `###`, that are inline comments
|
||
# like `1 + ### comment ### 2`, create fragments and insert them into
|
||
# the fragments array.
|
||
# Otherwise attach comment fragments to their closest fragment for now,
|
||
# so they can be inserted into the output later after all the newlines
|
||
# have been added.
|
||
if comment.here # Block comment, delimited by `###`.
|
||
commentFragment = new HereComment(comment).compileNode o
|
||
else # Line comment, delimited by `#`.
|
||
commentFragment = new LineComment(comment).compileNode o
|
||
if (commentFragment.isHereComment and not commentFragment.newLine) or
|
||
node.includeCommentFragments()
|
||
# Inline block comments, like `1 + /* comment */ 2`, or a node whose
|
||
# `compileToFragments` method has logic for outputting comments.
|
||
unshiftCommentFragment commentFragment
|
||
else
|
||
fragments.push @makeCode '' if fragments.length is 0
|
||
if commentFragment.unshift
|
||
fragments[0].precedingComments ?= []
|
||
fragments[0].precedingComments.push commentFragment
|
||
else
|
||
fragments[fragments.length - 1].followingComments ?= []
|
||
fragments[fragments.length - 1].followingComments.push commentFragment
|
||
fragments
|
||
|
||
# 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.
|
||
#
|
||
# If `level` is passed, then returns `[val, ref]`, where `val` is the compiled value, and `ref`
|
||
# is the compiled reference. If `level` is not passed, this returns `[val, ref]` where
|
||
# the two values are raw nodes which have not been compiled.
|
||
cache: (o, level, shouldCache) ->
|
||
complex = if shouldCache? then shouldCache this else @shouldCache()
|
||
if complex
|
||
ref = new IdentifierLiteral o.scope.freeVariable 'ref'
|
||
sub = new Assign ref, this
|
||
if level then [sub.compileToFragments(o, level), [@makeCode(ref.value)]] else [sub, ref]
|
||
else
|
||
ref = if level then @compileToFragments o, level else this
|
||
[ref, ref]
|
||
|
||
# Occasionally it may be useful to make an expression behave as if it was 'hoisted', whereby the
|
||
# result of the expression is available before its location in the source, but the expression's
|
||
# variable scope corresponds to the source position. This is used extensively to deal with executable
|
||
# class bodies in classes.
|
||
#
|
||
# Calling this method mutates the node, proxying the `compileNode` and `compileToFragments`
|
||
# methods to store their result for later replacing the `target` node, which is returned by the
|
||
# call.
|
||
hoist: ->
|
||
@hoisted = yes
|
||
target = new HoistTarget @
|
||
|
||
compileNode = @compileNode
|
||
compileToFragments = @compileToFragments
|
||
|
||
@compileNode = (o) ->
|
||
target.update compileNode, o
|
||
|
||
@compileToFragments = (o) ->
|
||
target.update compileToFragments, o
|
||
|
||
target
|
||
|
||
cacheToCodeFragments: (cacheValues) ->
|
||
[fragmentsToText(cacheValues[0]), fragmentsToText(cacheValues[1])]
|
||
|
||
# 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: (results, mark) ->
|
||
if mark
|
||
# Mark this node as implicitly returned, so that it can be part of the
|
||
# node metadata returned in the AST.
|
||
@canBeReturned = yes
|
||
return
|
||
node = @unwrapAll()
|
||
if results
|
||
new Call new Literal("#{results}.push"), [node]
|
||
else
|
||
new Return node
|
||
|
||
# Does this node, or any of its children, contain a node of a certain kind?
|
||
# Recursively traverses down the *children* nodes and returns the first one
|
||
# that verifies `pred`. Otherwise return undefined. `contains` does not cross
|
||
# scope boundaries.
|
||
contains: (pred) ->
|
||
node = undefined
|
||
@traverseChildren no, (n) ->
|
||
if pred n
|
||
node = n
|
||
return no
|
||
node
|
||
|
||
# Pull out the last node of a node list.
|
||
lastNode: (list) ->
|
||
if list.length is 0 then null else list[list.length - 1]
|
||
|
||
# Debugging 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
|
||
|
||
checkForPureStatementInExpression: ->
|
||
if jumpNode = @jumps()
|
||
jumpNode.error 'cannot use a pure statement in an expression'
|
||
|
||
# Plain JavaScript object representation of the node, that can be serialized
|
||
# as JSON. This is what the `ast` option in the Node API returns.
|
||
# We try to follow the [Babel AST spec](https://github.com/babel/babel/blob/master/packages/babel-parser/ast/spec.md)
|
||
# as closely as possible, for improved interoperability with other tools.
|
||
# **WARNING: DO NOT OVERRIDE THIS METHOD IN CHILD CLASSES.**
|
||
# Only override the component `ast*` methods as needed.
|
||
ast: (o, level) ->
|
||
# Merge `level` into `o` and perform other universal checks.
|
||
o = @astInitialize o, level
|
||
# Create serializable representation of this node.
|
||
astNode = @astNode o
|
||
# Mark AST nodes that correspond to expressions that (implicitly) return.
|
||
# We can’t do this as part of `astNode` because we need to assemble child
|
||
# nodes first before marking the parent being returned.
|
||
if @astNode? and @canBeReturned
|
||
Object.assign astNode, {returns: yes}
|
||
astNode
|
||
|
||
astInitialize: (o, level) ->
|
||
o = Object.assign {}, o
|
||
o.level = level if level?
|
||
if o.level > LEVEL_TOP
|
||
@checkForPureStatementInExpression()
|
||
# `@makeReturn` must be called before `astProperties`, because the latter may call
|
||
# `.ast()` for child nodes and those nodes would need the return logic from `makeReturn`
|
||
# already executed by then.
|
||
@makeReturn null, yes if @isStatement(o) and o.level isnt LEVEL_TOP and o.scope?
|
||
o
|
||
|
||
astNode: (o) ->
|
||
# Every abstract syntax tree node object has four categories of properties:
|
||
# - type, stored in the `type` field and a string like `NumberLiteral`.
|
||
# - location data, stored in the `loc`, `start`, `end` and `range` fields.
|
||
# - properties specific to this node, like `parsedValue`.
|
||
# - properties that are themselves child nodes, like `body`.
|
||
# These fields are all intermixed in the Babel spec; `type` and `start` and
|
||
# `parsedValue` are all top level fields in the AST node object. We have
|
||
# separate methods for returning each category, that we merge together here.
|
||
Object.assign {}, {type: @astType(o)}, @astProperties(o), @astLocationData()
|
||
|
||
# By default, a node class has no specific properties.
|
||
astProperties: -> {}
|
||
|
||
# By default, a node class’s AST `type` is its class name.
|
||
astType: -> @constructor.name
|
||
|
||
# The AST location data is a rearranged version of our Jison location data,
|
||
# mutated into the structure that the Babel spec uses.
|
||
astLocationData: ->
|
||
jisonLocationDataToAstLocationData @locationData
|
||
|
||
# Determines whether an AST node needs an `ExpressionStatement` wrapper.
|
||
# Typically matches our `isStatement()` logic but this allows overriding.
|
||
isStatementAst: (o) ->
|
||
@isStatement o
|
||
|
||
# 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) ->
|
||
recur = func(child)
|
||
child.traverseChildren(crossScope, func) unless recur is no
|
||
|
||
# `replaceInContext` will traverse children looking for a node for which `match` returns
|
||
# true. Once found, the matching node will be replaced by the result of calling `replacement`.
|
||
replaceInContext: (match, replacement) ->
|
||
return false unless @children
|
||
for attr in @children when children = @[attr]
|
||
if Array.isArray children
|
||
for child, i in children
|
||
if match child
|
||
children[i..i] = replacement child, @
|
||
return true
|
||
else
|
||
return true if child.replaceInContext match, replacement
|
||
else if match children
|
||
@[attr] = replacement children, @
|
||
return true
|
||
else
|
||
return true if children.replaceInContext match, replacement
|
||
|
||
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` are the properties to recurse into when tree walking. The
|
||
# `children` list *is* the structure of the AST. The `parent` pointer, and
|
||
# the pointer to the `children` are how you can traverse the tree.
|
||
children: []
|
||
|
||
# `isStatement` has to do with “everything is an expression”. A few things
|
||
# can’t be expressions, such as `break`. Things that `isStatement` returns
|
||
# `true` for are things that can’t be used as expressions. There are some
|
||
# error messages that come from `nodes.coffee` due to statements ending up
|
||
# in expression position.
|
||
isStatement: NO
|
||
|
||
# Track comments that have been compiled into fragments, to avoid outputting
|
||
# them twice.
|
||
compiledComments: []
|
||
|
||
# `includeCommentFragments` lets `compileCommentFragments` know whether this node
|
||
# has special awareness of how to handle comments within its output.
|
||
includeCommentFragments: NO
|
||
|
||
# `jumps` tells you if an expression, or an internal part of an expression,
|
||
# has a flow control construct (like `break`, `continue`, or `return`)
|
||
# that jumps out of the normal flow of control and can’t be used as a value.
|
||
# (Note that `throw` is not considered a flow control construct.)
|
||
# This is important because flow control in the middle of an expression
|
||
# makes no sense; we have to disallow it.
|
||
jumps: NO
|
||
|
||
# If `node.shouldCache() is false`, it is safe to use `node` more than once.
|
||
# Otherwise you need to store the value of `node` in a variable and output
|
||
# that variable several times instead. Kind of like this: `5` need not be
|
||
# cached. `returnFive()`, however, could have side effects as a result of
|
||
# evaluating it more than once, and therefore we need to cache it. The
|
||
# parameter is named `shouldCache` rather than `mustCache` because there are
|
||
# also cases where we might not need to cache but where we want to, for
|
||
# example a long expression that may well be idempotent but we want to cache
|
||
# for brevity.
|
||
shouldCache: YES
|
||
|
||
isChainable: NO
|
||
isAssignable: NO
|
||
isNumber: NO
|
||
|
||
unwrap: THIS
|
||
unfoldSoak: NO
|
||
|
||
# Is this node used to assign a certain variable?
|
||
assigns: NO
|
||
|
||
# For this node and all descendents, set the location data to `locationData`
|
||
# if the location data is not already set.
|
||
updateLocationDataIfMissing: (locationData, force) ->
|
||
@forceUpdateLocation = yes if force
|
||
return this if @locationData and not @forceUpdateLocation
|
||
delete @forceUpdateLocation
|
||
@locationData = locationData
|
||
|
||
@eachChild (child) ->
|
||
child.updateLocationDataIfMissing locationData
|
||
|
||
# Add location data from another node
|
||
withLocationDataFrom: ({locationData}) ->
|
||
@updateLocationDataIfMissing locationData
|
||
|
||
# Add location data and comments from another node
|
||
withLocationDataAndCommentsFrom: (node) ->
|
||
@withLocationDataFrom node
|
||
{comments} = node
|
||
@comments = comments if comments?.length
|
||
this
|
||
|
||
# Throw a SyntaxError associated with this node’s location.
|
||
error: (message) ->
|
||
throwSyntaxError message, @locationData
|
||
|
||
makeCode: (code) ->
|
||
new CodeFragment this, code
|
||
|
||
wrapInParentheses: (fragments) ->
|
||
[@makeCode('('), fragments..., @makeCode(')')]
|
||
|
||
wrapInBraces: (fragments) ->
|
||
[@makeCode('{'), fragments..., @makeCode('}')]
|
||
|
||
# `fragmentsList` is an array of arrays of fragments. Each array in fragmentsList will be
|
||
# concatenated together, with `joinStr` added in between each, to produce a final flat array
|
||
# of fragments.
|
||
joinFragmentArrays: (fragmentsList, joinStr) ->
|
||
answer = []
|
||
for fragments, i in fragmentsList
|
||
if i then answer.push @makeCode joinStr
|
||
answer = answer.concat fragments
|
||
answer
|
||
|
||
#### HoistTarget
|
||
|
||
# A **HoistTargetNode** represents the output location in the node tree for a hoisted node.
|
||
# See Base#hoist.
|
||
exports.HoistTarget = class HoistTarget extends Base
|
||
# Expands hoisted fragments in the given array
|
||
@expand = (fragments) ->
|
||
for fragment, i in fragments by -1 when fragment.fragments
|
||
fragments[i..i] = @expand fragment.fragments
|
||
fragments
|
||
|
||
constructor: (@source) ->
|
||
super()
|
||
|
||
# Holds presentational options to apply when the source node is compiled.
|
||
@options = {}
|
||
|
||
# Placeholder fragments to be replaced by the source node’s compilation.
|
||
@targetFragments = { fragments: [] }
|
||
|
||
isStatement: (o) ->
|
||
@source.isStatement o
|
||
|
||
# Update the target fragments with the result of compiling the source.
|
||
# Calls the given compile function with the node and options (overriden with the target
|
||
# presentational options).
|
||
update: (compile, o) ->
|
||
@targetFragments.fragments = compile.call @source, merge o, @options
|
||
|
||
# Copies the target indent and level, and returns the placeholder fragments
|
||
compileToFragments: (o, level) ->
|
||
@options.indent = o.indent
|
||
@options.level = level ? o.level
|
||
[ @targetFragments ]
|
||
|
||
compileNode: (o) ->
|
||
@compileToFragments o
|
||
|
||
compileClosure: (o) ->
|
||
@compileToFragments o
|
||
|
||
#### Root
|
||
|
||
# The root node of the node tree
|
||
exports.Root = class Root extends Base
|
||
constructor: (@body) ->
|
||
super()
|
||
|
||
@isAsync = (new Code [], @body).isAsync
|
||
|
||
children: ['body']
|
||
|
||
# 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.
|
||
compileNode: (o) ->
|
||
o.indent = if o.bare then '' else TAB
|
||
o.level = LEVEL_TOP
|
||
o.compiling = yes
|
||
@initializeScope o
|
||
fragments = @body.compileRoot o
|
||
return fragments if o.bare
|
||
functionKeyword = "#{if @isAsync then 'async ' else ''}function"
|
||
[].concat @makeCode("(#{functionKeyword}() {\n"), fragments, @makeCode("\n}).call(this);\n")
|
||
|
||
initializeScope: (o) ->
|
||
o.scope = new Scope null, @body, null, o.referencedVars ? []
|
||
# Mark given local variables in the root scope as parameters so they don’t
|
||
# end up being declared on the root block.
|
||
o.scope.parameter name for name in o.locals or []
|
||
|
||
commentsAst: ->
|
||
@allComments ?=
|
||
for commentToken in (@allCommentTokens ? []) when not commentToken.heregex
|
||
if commentToken.here
|
||
new HereComment commentToken
|
||
else
|
||
new LineComment commentToken
|
||
comment.ast() for comment in @allComments
|
||
|
||
astNode: (o) ->
|
||
o.level = LEVEL_TOP
|
||
@initializeScope o
|
||
super o
|
||
|
||
astType: -> 'File'
|
||
|
||
astProperties: (o) ->
|
||
@body.isRootBlock = yes
|
||
return
|
||
program: Object.assign @body.ast(o), @astLocationData()
|
||
comments: @commentsAst()
|
||
|
||
#### 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) ->
|
||
super()
|
||
|
||
@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 jumpNode if jumpNode = exp.jumps o
|
||
|
||
# A Block node does not return its entire body, rather it
|
||
# ensures that the final expression is returned.
|
||
makeReturn: (results, mark) ->
|
||
len = @expressions.length
|
||
[..., lastExp] = @expressions
|
||
lastExp = lastExp?.unwrap() or no
|
||
# We also need to check that we’re not returning a JSX tag if there’s an
|
||
# adjacent one at the same level; JSX doesn’t allow that.
|
||
if lastExp and lastExp instanceof Parens and lastExp.body.expressions.length > 1
|
||
{body:{expressions}} = lastExp
|
||
[..., penult, last] = expressions
|
||
penult = penult.unwrap()
|
||
last = last.unwrap()
|
||
if penult instanceof JSXElement and last instanceof JSXElement
|
||
expressions[expressions.length - 1].error 'Adjacent JSX elements must be wrapped in an enclosing tag'
|
||
if mark
|
||
@expressions[len - 1]?.makeReturn results, mark
|
||
return
|
||
while len--
|
||
expr = @expressions[len]
|
||
@expressions[len] = expr.makeReturn results
|
||
@expressions.splice(len, 1) if expr instanceof Return and not expr.expression
|
||
break
|
||
this
|
||
|
||
compile: (o, lvl) ->
|
||
return new Root(this).withLocationDataFrom(this).compile o, lvl unless o.scope
|
||
|
||
super o, lvl
|
||
|
||
# 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
|
||
compiledNodes = []
|
||
|
||
for node, index in @expressions
|
||
if node.hoisted
|
||
# This is a hoisted expression.
|
||
# We want to compile this and ignore the result.
|
||
node.compileToFragments o
|
||
continue
|
||
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.
|
||
compiledNodes.push node.compileNode o
|
||
else if top
|
||
node.front = yes
|
||
fragments = node.compileToFragments o
|
||
unless node.isStatement o
|
||
fragments = indentInitial fragments, @
|
||
[..., lastFragment] = fragments
|
||
unless lastFragment.code is '' or lastFragment.isComment
|
||
fragments.push @makeCode ';'
|
||
compiledNodes.push fragments
|
||
else
|
||
compiledNodes.push node.compileToFragments o, LEVEL_LIST
|
||
if top
|
||
if @spaced
|
||
return [].concat @joinFragmentArrays(compiledNodes, '\n\n'), @makeCode('\n')
|
||
else
|
||
return @joinFragmentArrays(compiledNodes, '\n')
|
||
if compiledNodes.length
|
||
answer = @joinFragmentArrays(compiledNodes, ', ')
|
||
else
|
||
answer = [@makeCode 'void 0']
|
||
if compiledNodes.length > 1 and o.level >= LEVEL_LIST then @wrapInParentheses answer else answer
|
||
|
||
compileRoot: (o) ->
|
||
@spaced = yes
|
||
fragments = @compileWithDeclarations o
|
||
HoistTarget.expand fragments
|
||
@compileComments fragments
|
||
|
||
# Compile the expressions body for the contents of a function, with
|
||
# declarations of all inner variables pushed up to the top.
|
||
compileWithDeclarations: (o) ->
|
||
fragments = []
|
||
post = []
|
||
for exp, i in @expressions
|
||
exp = exp.unwrap()
|
||
break unless exp instanceof Literal
|
||
o = merge(o, level: LEVEL_TOP)
|
||
if i
|
||
rest = @expressions.splice i, 9e9
|
||
[spaced, @spaced] = [@spaced, no]
|
||
[fragments, @spaced] = [@compileNode(o), spaced]
|
||
@expressions = rest
|
||
post = @compileNode o
|
||
{scope} = o
|
||
if scope.expressions is this
|
||
declars = o.scope.hasDeclarations()
|
||
assigns = scope.hasAssignments
|
||
if declars or assigns
|
||
fragments.push @makeCode '\n' if i
|
||
fragments.push @makeCode "#{@tab}var "
|
||
if declars
|
||
declaredVariables = scope.declaredVariables()
|
||
for declaredVariable, declaredVariablesIndex in declaredVariables
|
||
fragments.push @makeCode declaredVariable
|
||
if Object::hasOwnProperty.call o.scope.comments, declaredVariable
|
||
fragments.push o.scope.comments[declaredVariable]...
|
||
if declaredVariablesIndex isnt declaredVariables.length - 1
|
||
fragments.push @makeCode ', '
|
||
if assigns
|
||
fragments.push @makeCode ",\n#{@tab + TAB}" if declars
|
||
fragments.push @makeCode scope.assignedVariables().join(",\n#{@tab + TAB}")
|
||
fragments.push @makeCode ";\n#{if @spaced then '\n' else ''}"
|
||
else if fragments.length and post.length
|
||
fragments.push @makeCode "\n"
|
||
fragments.concat post
|
||
|
||
compileComments: (fragments) ->
|
||
for fragment, fragmentIndex in fragments
|
||
# Insert comments into the output at the next or previous newline.
|
||
# If there are no newlines at which to place comments, create them.
|
||
if fragment.precedingComments
|
||
# Determine the indentation level of the fragment that we are about
|
||
# to insert comments before, and use that indentation level for our
|
||
# inserted comments. At this point, the fragments’ `code` property
|
||
# is the generated output JavaScript, and CoffeeScript always
|
||
# generates output indented by two spaces; so all we need to do is
|
||
# search for a `code` property that begins with at least two spaces.
|
||
fragmentIndent = ''
|
||
for pastFragment in fragments[0...(fragmentIndex + 1)] by -1
|
||
indent = /^ {2,}/m.exec pastFragment.code
|
||
if indent
|
||
fragmentIndent = indent[0]
|
||
break
|
||
else if '\n' in pastFragment.code
|
||
break
|
||
code = "\n#{fragmentIndent}" + (
|
||
for commentFragment in fragment.precedingComments
|
||
if commentFragment.isHereComment and commentFragment.multiline
|
||
multident commentFragment.code, fragmentIndent, no
|
||
else
|
||
commentFragment.code
|
||
).join("\n#{fragmentIndent}").replace /^(\s*)$/gm, ''
|
||
for pastFragment, pastFragmentIndex in fragments[0...(fragmentIndex + 1)] by -1
|
||
newLineIndex = pastFragment.code.lastIndexOf '\n'
|
||
if newLineIndex is -1
|
||
# Keep searching previous fragments until we can’t go back any
|
||
# further, either because there are no fragments left or we’ve
|
||
# discovered that we’re in a code block that is interpolated
|
||
# inside a string.
|
||
if pastFragmentIndex is 0
|
||
pastFragment.code = '\n' + pastFragment.code
|
||
newLineIndex = 0
|
||
else if pastFragment.isStringWithInterpolations and pastFragment.code is '{'
|
||
code = code[1..] + '\n' # Move newline to end.
|
||
newLineIndex = 1
|
||
else
|
||
continue
|
||
delete fragment.precedingComments
|
||
pastFragment.code = pastFragment.code[0...newLineIndex] +
|
||
code + pastFragment.code[newLineIndex..]
|
||
break
|
||
|
||
# Yes, this is awfully similar to the previous `if` block, but if you
|
||
# look closely you’ll find lots of tiny differences that make this
|
||
# confusing if it were abstracted into a function that both blocks share.
|
||
if fragment.followingComments
|
||
# Does the first trailing comment follow at the end of a line of code,
|
||
# like `; // Comment`, or does it start a new line after a line of code?
|
||
trail = fragment.followingComments[0].trail
|
||
fragmentIndent = ''
|
||
# Find the indent of the next line of code, if we have any non-trailing
|
||
# comments to output. We need to first find the next newline, as these
|
||
# comments will be output after that; and then the indent of the line
|
||
# that follows the next newline.
|
||
unless trail and fragment.followingComments.length is 1
|
||
onNextLine = no
|
||
for upcomingFragment in fragments[fragmentIndex...]
|
||
unless onNextLine
|
||
if '\n' in upcomingFragment.code
|
||
onNextLine = yes
|
||
else
|
||
continue
|
||
else
|
||
indent = /^ {2,}/m.exec upcomingFragment.code
|
||
if indent
|
||
fragmentIndent = indent[0]
|
||
break
|
||
else if '\n' in upcomingFragment.code
|
||
break
|
||
# Is this comment following the indent inserted by bare mode?
|
||
# If so, there’s no need to indent this further.
|
||
code = if fragmentIndex is 1 and /^\s+$/.test fragments[0].code
|
||
''
|
||
else if trail
|
||
' '
|
||
else
|
||
"\n#{fragmentIndent}"
|
||
# Assemble properly indented comments.
|
||
code += (
|
||
for commentFragment in fragment.followingComments
|
||
if commentFragment.isHereComment and commentFragment.multiline
|
||
multident commentFragment.code, fragmentIndent, no
|
||
else
|
||
commentFragment.code
|
||
).join("\n#{fragmentIndent}").replace /^(\s*)$/gm, ''
|
||
for upcomingFragment, upcomingFragmentIndex in fragments[fragmentIndex...]
|
||
newLineIndex = upcomingFragment.code.indexOf '\n'
|
||
if newLineIndex is -1
|
||
# Keep searching upcoming fragments until we can’t go any
|
||
# further, either because there are no fragments left or we’ve
|
||
# discovered that we’re in a code block that is interpolated
|
||
# inside a string.
|
||
if upcomingFragmentIndex is fragments.length - 1
|
||
upcomingFragment.code = upcomingFragment.code + '\n'
|
||
newLineIndex = upcomingFragment.code.length
|
||
else if upcomingFragment.isStringWithInterpolations and upcomingFragment.code is '}'
|
||
code = "#{code}\n"
|
||
newLineIndex = 0
|
||
else
|
||
continue
|
||
delete fragment.followingComments
|
||
# Avoid inserting extra blank lines.
|
||
code = code.replace /^\n/, '' if upcomingFragment.code is '\n'
|
||
upcomingFragment.code = upcomingFragment.code[0...newLineIndex] +
|
||
code + upcomingFragment.code[newLineIndex..]
|
||
break
|
||
|
||
fragments
|
||
|
||
# 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
|
||
|
||
astNode: (o) ->
|
||
if (o.level? and o.level isnt LEVEL_TOP) and @expressions.length
|
||
return (new Sequence(@expressions).withLocationDataFrom @).ast o
|
||
|
||
super o
|
||
|
||
astType: ->
|
||
if @isRootBlock
|
||
'Program'
|
||
else if @isClassBody
|
||
'ClassBody'
|
||
else
|
||
'BlockStatement'
|
||
|
||
astProperties: (o) ->
|
||
checkForDirectives = del o, 'checkForDirectives'
|
||
|
||
sniffDirectives @expressions, notFinalExpression: checkForDirectives if @isRootBlock or checkForDirectives
|
||
directives = []
|
||
body = []
|
||
for expression in @expressions
|
||
expressionAst = expression.ast o
|
||
# Ignore generated PassthroughLiteral
|
||
if not expressionAst?
|
||
continue
|
||
else if expression instanceof Directive
|
||
directives.push expressionAst
|
||
# If an expression is a statement, it can be added to the body as is.
|
||
else if expression.isStatementAst o
|
||
body.push expressionAst
|
||
# Otherwise, we need to wrap it in an `ExpressionStatement` AST node.
|
||
else
|
||
body.push Object.assign
|
||
type: 'ExpressionStatement'
|
||
expression: expressionAst
|
||
,
|
||
expression.astLocationData()
|
||
|
||
return {
|
||
# For now, we’re not including `sourceType` on the `Program` AST node.
|
||
# Its value could be either `'script'` or `'module'`, and there’s no way
|
||
# for CoffeeScript to always know which it should be. The presence of an
|
||
# `import` or `export` statement in source code would imply that it should
|
||
# be a `module`, but a project may consist of mostly such files and also
|
||
# an outlier file that lacks `import` or `export` but is still imported
|
||
# into the project and therefore expects to be treated as a `module`.
|
||
# Determining the value of `sourceType` is essentially the same challenge
|
||
# posed by determining the parse goal of a JavaScript file, also `module`
|
||
# or `script`, and so if Node figures out a way to do so for `.js` files
|
||
# then CoffeeScript can copy Node’s algorithm.
|
||
|
||
# sourceType: 'module'
|
||
body, directives
|
||
}
|
||
|
||
astLocationData: ->
|
||
return if @isRootBlock and not @locationData?
|
||
super()
|
||
|
||
# A directive e.g. 'use strict'.
|
||
# Currently only used during AST generation.
|
||
exports.Directive = class Directive extends Base
|
||
constructor: (@value) ->
|
||
super()
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
value: Object.assign {},
|
||
@value.ast o
|
||
type: 'DirectiveLiteral'
|
||
|
||
#### Literal
|
||
|
||
# `Literal` is a base class for 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) ->
|
||
super()
|
||
|
||
shouldCache: NO
|
||
|
||
assigns: (name) ->
|
||
name is @value
|
||
|
||
compileNode: (o) ->
|
||
[@makeCode @value]
|
||
|
||
astProperties: ->
|
||
return
|
||
value: @value
|
||
|
||
toString: ->
|
||
# This is only intended for debugging.
|
||
" #{if @isStatement() then super() else @constructor.name}: #{@value}"
|
||
|
||
exports.NumberLiteral = class NumberLiteral extends Literal
|
||
constructor: (@value, {@parsedValue} = {}) ->
|
||
super()
|
||
unless @parsedValue?
|
||
if isNumber @value
|
||
@parsedValue = @value
|
||
@value = "#{@value}"
|
||
else
|
||
@parsedValue = parseNumber @value
|
||
|
||
isBigInt: ->
|
||
/n$/.test @value
|
||
|
||
astType: ->
|
||
if @isBigInt()
|
||
'BigIntLiteral'
|
||
else
|
||
'NumericLiteral'
|
||
|
||
astProperties: ->
|
||
return
|
||
value:
|
||
if @isBigInt()
|
||
@parsedValue.toString()
|
||
else
|
||
@parsedValue
|
||
extra:
|
||
rawValue:
|
||
if @isBigInt()
|
||
@parsedValue.toString()
|
||
else
|
||
@parsedValue
|
||
raw: @value
|
||
|
||
exports.InfinityLiteral = class InfinityLiteral extends NumberLiteral
|
||
constructor: (@value, {@originalValue = 'Infinity'} = {}) ->
|
||
super()
|
||
|
||
compileNode: ->
|
||
[@makeCode '2e308']
|
||
|
||
astNode: (o) ->
|
||
unless @originalValue is 'Infinity'
|
||
return new NumberLiteral(@value).withLocationDataFrom(@).ast o
|
||
super o
|
||
|
||
astType: -> 'Identifier'
|
||
|
||
astProperties: ->
|
||
return
|
||
name: 'Infinity'
|
||
declaration: no
|
||
|
||
exports.NaNLiteral = class NaNLiteral extends NumberLiteral
|
||
constructor: ->
|
||
super 'NaN'
|
||
|
||
compileNode: (o) ->
|
||
code = [@makeCode '0/0']
|
||
if o.level >= LEVEL_OP then @wrapInParentheses code else code
|
||
|
||
astType: -> 'Identifier'
|
||
|
||
astProperties: ->
|
||
return
|
||
name: 'NaN'
|
||
declaration: no
|
||
|
||
exports.StringLiteral = class StringLiteral extends Literal
|
||
constructor: (@originalValue, {@quote, @initialChunk, @finalChunk, @indent, @double, @heregex} = {}) ->
|
||
super ''
|
||
@quote = null if @quote is '///'
|
||
@fromSourceString = @quote?
|
||
@quote ?= '"'
|
||
heredoc = @isFromHeredoc()
|
||
|
||
val = @originalValue
|
||
if @heregex
|
||
val = val.replace HEREGEX_OMIT, '$1$2'
|
||
val = replaceUnicodeCodePointEscapes val, flags: @heregex.flags
|
||
else
|
||
val = val.replace STRING_OMIT, '$1'
|
||
val =
|
||
unless @fromSourceString
|
||
val
|
||
else if heredoc
|
||
indentRegex = /// \n#{@indent} ///g if @indent
|
||
|
||
val = val.replace indentRegex, '\n' if indentRegex
|
||
val = val.replace LEADING_BLANK_LINE, '' if @initialChunk
|
||
val = val.replace TRAILING_BLANK_LINE, '' if @finalChunk
|
||
val
|
||
else
|
||
val.replace SIMPLE_STRING_OMIT, (match, offset) =>
|
||
if (@initialChunk and offset is 0) or
|
||
(@finalChunk and offset + match.length is val.length)
|
||
''
|
||
else
|
||
' '
|
||
@delimiter = @quote.charAt 0
|
||
@value = makeDelimitedLiteral val, {
|
||
@delimiter
|
||
@double
|
||
}
|
||
|
||
@unquotedValueForTemplateLiteral = makeDelimitedLiteral val, {
|
||
delimiter: '`'
|
||
@double
|
||
escapeNewlines: no
|
||
includeDelimiters: no
|
||
convertTrailingNullEscapes: yes
|
||
}
|
||
|
||
@unquotedValueForJSX = makeDelimitedLiteral val, {
|
||
@double
|
||
escapeNewlines: no
|
||
includeDelimiters: no
|
||
escapeDelimiter: no
|
||
}
|
||
|
||
compileNode: (o) ->
|
||
return StringWithInterpolations.fromStringLiteral(@).compileNode o if @shouldGenerateTemplateLiteral()
|
||
return [@makeCode @unquotedValueForJSX] if @jsx
|
||
super o
|
||
|
||
# `StringLiteral`s can represent either entire literal strings
|
||
# or pieces of text inside of e.g. an interpolated string.
|
||
# When parsed as the former but needing to be treated as the latter
|
||
# (e.g. the string part of a tagged template literal), this will return
|
||
# a copy of the `StringLiteral` with the quotes trimmed from its location
|
||
# data (like it would have if parsed as part of an interpolated string).
|
||
withoutQuotesInLocationData: ->
|
||
endsWithNewline = @originalValue[-1..] is '\n'
|
||
locationData = Object.assign {}, @locationData
|
||
locationData.first_column += @quote.length
|
||
if endsWithNewline
|
||
locationData.last_line -= 1
|
||
locationData.last_column =
|
||
if locationData.last_line is locationData.first_line
|
||
locationData.first_column + @originalValue.length - '\n'.length
|
||
else
|
||
@originalValue[...-1].length - '\n'.length - @originalValue[...-1].lastIndexOf('\n')
|
||
else
|
||
locationData.last_column -= @quote.length
|
||
locationData.last_column_exclusive -= @quote.length
|
||
locationData.range = [
|
||
locationData.range[0] + @quote.length
|
||
locationData.range[1] - @quote.length
|
||
]
|
||
copy = new StringLiteral @originalValue, {@quote, @initialChunk, @finalChunk, @indent, @double, @heregex}
|
||
copy.locationData = locationData
|
||
copy
|
||
|
||
isFromHeredoc: ->
|
||
@quote.length is 3
|
||
|
||
shouldGenerateTemplateLiteral: ->
|
||
@isFromHeredoc()
|
||
|
||
astNode: (o) ->
|
||
return StringWithInterpolations.fromStringLiteral(@).ast o if @shouldGenerateTemplateLiteral()
|
||
super o
|
||
|
||
astProperties: ->
|
||
return
|
||
value: @originalValue
|
||
extra:
|
||
raw: "#{@delimiter}#{@originalValue}#{@delimiter}"
|
||
|
||
exports.RegexLiteral = class RegexLiteral extends Literal
|
||
constructor: (value, {@delimiter = '/', @heregexCommentTokens = []} = {}) ->
|
||
super ''
|
||
heregex = @delimiter is '///'
|
||
endDelimiterIndex = value.lastIndexOf '/'
|
||
@flags = value[endDelimiterIndex + 1..]
|
||
val = @originalValue = value[1...endDelimiterIndex]
|
||
val = val.replace HEREGEX_OMIT, '$1$2' if heregex
|
||
val = replaceUnicodeCodePointEscapes val, {@flags}
|
||
@value = "#{makeDelimitedLiteral val, delimiter: '/'}#{@flags}"
|
||
|
||
REGEX_REGEX: /// ^ / (.*) / \w* $ ///
|
||
|
||
astType: -> 'RegExpLiteral'
|
||
|
||
astProperties: (o) ->
|
||
[, pattern] = @REGEX_REGEX.exec @value
|
||
return {
|
||
value: undefined
|
||
pattern, @flags, @delimiter
|
||
originalPattern: @originalValue
|
||
extra:
|
||
raw: @value
|
||
originalRaw: "#{@delimiter}#{@originalValue}#{@delimiter}#{@flags}"
|
||
rawValue: undefined
|
||
comments:
|
||
for heregexCommentToken in @heregexCommentTokens
|
||
if heregexCommentToken.here
|
||
new HereComment(heregexCommentToken).ast o
|
||
else
|
||
new LineComment(heregexCommentToken).ast o
|
||
}
|
||
|
||
exports.PassthroughLiteral = class PassthroughLiteral extends Literal
|
||
constructor: (@originalValue, {@here, @generated} = {}) ->
|
||
super ''
|
||
@value = @originalValue.replace /\\+(`|$)/g, (string) ->
|
||
# `string` is always a value like '\`', '\\\`', '\\\\\`', etc.
|
||
# By reducing it to its latter half, we turn '\`' to '`', '\\\`' to '\`', etc.
|
||
string[-Math.ceil(string.length / 2)..]
|
||
|
||
astNode: (o) ->
|
||
return null if @generated
|
||
super o
|
||
|
||
astProperties: ->
|
||
return {
|
||
value: @originalValue
|
||
here: !!@here
|
||
}
|
||
|
||
exports.IdentifierLiteral = class IdentifierLiteral extends Literal
|
||
isAssignable: YES
|
||
|
||
eachName: (iterator) ->
|
||
iterator @
|
||
|
||
astType: ->
|
||
if @jsx
|
||
'JSXIdentifier'
|
||
else
|
||
'Identifier'
|
||
|
||
astProperties: ->
|
||
return
|
||
name: @value
|
||
declaration: !!@isDeclaration
|
||
|
||
exports.PropertyName = class PropertyName extends Literal
|
||
isAssignable: YES
|
||
|
||
astType: ->
|
||
if @jsx
|
||
'JSXIdentifier'
|
||
else
|
||
'Identifier'
|
||
|
||
astProperties: ->
|
||
return
|
||
name: @value
|
||
declaration: no
|
||
|
||
exports.ComputedPropertyName = class ComputedPropertyName extends PropertyName
|
||
compileNode: (o) ->
|
||
[@makeCode('['), @value.compileToFragments(o, LEVEL_LIST)..., @makeCode(']')]
|
||
|
||
astNode: (o) ->
|
||
@value.ast o
|
||
|
||
exports.StatementLiteral = class StatementLiteral extends Literal
|
||
isStatement: YES
|
||
|
||
makeReturn: THIS
|
||
|
||
jumps: (o) ->
|
||
return this if @value is 'break' and not (o?.loop or o?.block)
|
||
return this if @value is 'continue' and not o?.loop
|
||
|
||
compileNode: (o) ->
|
||
[@makeCode "#{@tab}#{@value};"]
|
||
|
||
astType: ->
|
||
switch @value
|
||
when 'continue' then 'ContinueStatement'
|
||
when 'break' then 'BreakStatement'
|
||
when 'debugger' then 'DebuggerStatement'
|
||
|
||
exports.ThisLiteral = class ThisLiteral extends Literal
|
||
constructor: (value) ->
|
||
super 'this'
|
||
@shorthand = value is '@'
|
||
|
||
compileNode: (o) ->
|
||
code = if o.scope.method?.bound then o.scope.method.context else @value
|
||
[@makeCode code]
|
||
|
||
astType: -> 'ThisExpression'
|
||
|
||
astProperties: ->
|
||
return
|
||
shorthand: @shorthand
|
||
|
||
exports.UndefinedLiteral = class UndefinedLiteral extends Literal
|
||
constructor: ->
|
||
super 'undefined'
|
||
|
||
compileNode: (o) ->
|
||
[@makeCode if o.level >= LEVEL_ACCESS then '(void 0)' else 'void 0']
|
||
|
||
astType: -> 'Identifier'
|
||
|
||
astProperties: ->
|
||
return
|
||
name: @value
|
||
declaration: no
|
||
|
||
exports.NullLiteral = class NullLiteral extends Literal
|
||
constructor: ->
|
||
super 'null'
|
||
|
||
exports.BooleanLiteral = class BooleanLiteral extends Literal
|
||
constructor: (value, {@originalValue} = {}) ->
|
||
super value
|
||
@originalValue ?= @value
|
||
|
||
astProperties: ->
|
||
value: if @value is 'true' then yes else no
|
||
name: @originalValue
|
||
|
||
exports.DefaultLiteral = class DefaultLiteral extends Literal
|
||
astType: -> 'Identifier'
|
||
|
||
astProperties: ->
|
||
return
|
||
name: 'default'
|
||
declaration: no
|
||
|
||
#### Return
|
||
|
||
# A `return` is a *pureStatement*—wrapping it in a closure wouldn’t make sense.
|
||
exports.Return = class Return extends Base
|
||
constructor: (@expression, {@belongsToFuncDirectiveReturn} = {}) ->
|
||
super()
|
||
|
||
children: ['expression']
|
||
|
||
isStatement: YES
|
||
makeReturn: THIS
|
||
jumps: THIS
|
||
|
||
compileToFragments: (o, level) ->
|
||
expr = @expression?.makeReturn()
|
||
if expr and expr not instanceof Return then expr.compileToFragments o, level else super o, level
|
||
|
||
compileNode: (o) ->
|
||
answer = []
|
||
# TODO: If we call `expression.compile()` here twice, we’ll sometimes
|
||
# get back different results!
|
||
if @expression
|
||
answer = @expression.compileToFragments o, LEVEL_PAREN
|
||
unshiftAfterComments answer, @makeCode "#{@tab}return "
|
||
# Since the `return` got indented by `@tab`, preceding comments that are
|
||
# multiline need to be indented.
|
||
for fragment in answer
|
||
if fragment.isHereComment and '\n' in fragment.code
|
||
fragment.code = multident fragment.code, @tab
|
||
else if fragment.isLineComment
|
||
fragment.code = "#{@tab}#{fragment.code}"
|
||
else
|
||
break
|
||
else
|
||
answer.push @makeCode "#{@tab}return"
|
||
answer.push @makeCode ';'
|
||
answer
|
||
|
||
checkForPureStatementInExpression: ->
|
||
# don’t flag `return` from `await return`/`yield return` as invalid.
|
||
return if @belongsToFuncDirectiveReturn
|
||
super()
|
||
|
||
astType: -> 'ReturnStatement'
|
||
|
||
astProperties: (o) ->
|
||
argument: @expression?.ast(o, LEVEL_PAREN) ? null
|
||
|
||
# Parent class for `YieldReturn`/`AwaitReturn`.
|
||
exports.FuncDirectiveReturn = class FuncDirectiveReturn extends Return
|
||
constructor: (expression, {@returnKeyword}) ->
|
||
super expression
|
||
|
||
compileNode: (o) ->
|
||
@checkScope o
|
||
super o
|
||
|
||
checkScope: (o) ->
|
||
unless o.scope.parent?
|
||
@error "#{@keyword} can only occur inside functions"
|
||
|
||
isStatementAst: NO
|
||
|
||
astNode: (o) ->
|
||
@checkScope o
|
||
|
||
new Op @keyword,
|
||
new Return @expression, belongsToFuncDirectiveReturn: yes
|
||
.withLocationDataFrom(
|
||
if @expression?
|
||
locationData: mergeLocationData @returnKeyword.locationData, @expression.locationData
|
||
else
|
||
@returnKeyword
|
||
)
|
||
.withLocationDataFrom @
|
||
.ast o
|
||
|
||
# `yield return` works exactly like `return`, except that it turns the function
|
||
# into a generator.
|
||
exports.YieldReturn = class YieldReturn extends FuncDirectiveReturn
|
||
keyword: 'yield'
|
||
|
||
exports.AwaitReturn = class AwaitReturn extends FuncDirectiveReturn
|
||
keyword: 'await'
|
||
|
||
#### Value
|
||
|
||
# A value, variable or literal or parenthesized, indexed or dotted into,
|
||
# or vanilla.
|
||
exports.Value = class Value extends Base
|
||
constructor: (base, props, tag, isDefaultValue = no) ->
|
||
super()
|
||
return base if not props and base instanceof Value
|
||
@base = base
|
||
@properties = props or []
|
||
@tag = tag
|
||
@[tag] = yes if tag
|
||
@isDefaultValue = isDefaultValue
|
||
# If this is a `@foo =` assignment, if there are comments on `@` move them
|
||
# to be on `foo`.
|
||
if @base?.comments and @base instanceof ThisLiteral and @properties[0]?.name?
|
||
moveComments @base, @properties[0].name
|
||
|
||
children: ['base', 'properties']
|
||
|
||
# Add a property (or *properties* ) `Access` to the list.
|
||
add: (props) ->
|
||
@properties = @properties.concat props
|
||
@forceUpdateLocation = yes
|
||
this
|
||
|
||
hasProperties: ->
|
||
@properties.length isnt 0
|
||
|
||
bareLiteral: (type) ->
|
||
not @properties.length and @base instanceof type
|
||
|
||
# Some boolean checks for the benefit of other nodes.
|
||
isArray : -> @bareLiteral(Arr)
|
||
isRange : -> @bareLiteral(Range)
|
||
shouldCache : -> @hasProperties() or @base.shouldCache()
|
||
isAssignable : (opts) -> @hasProperties() or @base.isAssignable opts
|
||
isNumber : -> @bareLiteral(NumberLiteral)
|
||
isString : -> @bareLiteral(StringLiteral)
|
||
isRegex : -> @bareLiteral(RegexLiteral)
|
||
isUndefined : -> @bareLiteral(UndefinedLiteral)
|
||
isNull : -> @bareLiteral(NullLiteral)
|
||
isBoolean : -> @bareLiteral(BooleanLiteral)
|
||
isAtomic : ->
|
||
for node in @properties.concat @base
|
||
return no if node.soak or node instanceof Call or node instanceof Op and node.operator is 'do'
|
||
yes
|
||
|
||
isNotCallable : -> @isNumber() or @isString() or @isRegex() or
|
||
@isArray() or @isRange() or @isSplice() or @isObject() or
|
||
@isUndefined() or @isNull() or @isBoolean()
|
||
|
||
isStatement : (o) -> not @properties.length and @base.isStatement o
|
||
isJSXTag : -> @base instanceof JSXTag
|
||
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)
|
||
|
||
isElision: ->
|
||
return no unless @base instanceof Arr
|
||
@base.hasElision()
|
||
|
||
isSplice: ->
|
||
[..., lastProperty] = @properties
|
||
lastProperty instanceof Slice
|
||
|
||
looksStatic: (className) ->
|
||
return no unless ((thisLiteral = @base) instanceof ThisLiteral or (name = @base).value is className) and
|
||
@properties.length is 1 and @properties[0].name?.value isnt 'prototype'
|
||
return
|
||
staticClassName: thisLiteral ? name
|
||
|
||
# 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] = @properties
|
||
if @properties.length < 2 and not @base.shouldCache() and not name?.shouldCache()
|
||
return [this, this] # `a` `a.b`
|
||
base = new Value @base, @properties[...-1]
|
||
if base.shouldCache() # `a().b`
|
||
bref = new IdentifierLiteral o.scope.freeVariable 'base'
|
||
base = new Value new Parens new Assign bref, base
|
||
return [base, bref] unless name # `a()`
|
||
if name.shouldCache() # `a[b()]`
|
||
nref = new IdentifierLiteral o.scope.freeVariable 'name'
|
||
name = new Index new Assign nref, name.index
|
||
nref = new Index nref
|
||
[base.add(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
|
||
if props.length and @base.cached?
|
||
# Cached fragments enable correct order of the compilation,
|
||
# and reuse of variables in the scope.
|
||
# Example:
|
||
# `a(x = 5).b(-> x = 6)` should compile in the same order as
|
||
# `a(x = 5); b(-> x = 6)`
|
||
# (see issue #4437, https://github.com/jashkenas/coffeescript/issues/4437)
|
||
fragments = @base.cached
|
||
else
|
||
fragments = @base.compileToFragments o, (if props.length then LEVEL_ACCESS else null)
|
||
if props.length and SIMPLENUM.test fragmentsToText fragments
|
||
fragments.push @makeCode '.'
|
||
for prop in props
|
||
fragments.push (prop.compileToFragments o)...
|
||
|
||
fragments
|
||
|
||
# Unfold a soak into an `If`: `a?.b` -> `a.b if a?`
|
||
unfoldSoak: (o) ->
|
||
@unfoldedSoak ?= do =>
|
||
ifn = @base.unfoldSoak o
|
||
if ifn
|
||
ifn.body.properties.push @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.shouldCache()
|
||
ref = new IdentifierLiteral o.scope.freeVariable 'ref'
|
||
fst = new Parens new Assign ref, fst
|
||
snd.base = ref
|
||
return new If new Existence(fst), snd, soak: on
|
||
no
|
||
|
||
eachName: (iterator, {checkAssignability = yes} = {}) ->
|
||
if @hasProperties()
|
||
iterator @
|
||
else if not checkAssignability or @base.isAssignable()
|
||
@base.eachName iterator
|
||
else
|
||
@error 'tried to assign to unassignable value'
|
||
|
||
# For AST generation, we need an `object` that’s this `Value` minus its last
|
||
# property, if it has properties.
|
||
object: ->
|
||
return @ unless @hasProperties()
|
||
# Get all properties except the last one; for a `Value` with only one
|
||
# property, `initialProperties` is an empty array.
|
||
initialProperties = @properties[0...@properties.length - 1]
|
||
# Create the `object` that becomes the new “base” for the split-off final
|
||
# property.
|
||
object = new Value @base, initialProperties, @tag, @isDefaultValue
|
||
# Add location data to our new node, so that it has correct location data
|
||
# for source maps or later conversion into AST location data.
|
||
object.locationData =
|
||
if initialProperties.length is 0
|
||
# This new `Value` has only one property, so the location data is just
|
||
# that of the parent `Value`’s base.
|
||
@base.locationData
|
||
else
|
||
# This new `Value` has multiple properties, so the location data spans
|
||
# from the parent `Value`’s base to the last property that’s included
|
||
# in this new node (a.k.a. the second-to-last property of the parent).
|
||
mergeLocationData @base.locationData, initialProperties[initialProperties.length - 1].locationData
|
||
object
|
||
|
||
containsSoak: ->
|
||
return no unless @hasProperties()
|
||
|
||
for property in @properties when property.soak
|
||
return yes
|
||
|
||
return yes if @base instanceof Call and @base.soak
|
||
|
||
no
|
||
|
||
astNode: (o) ->
|
||
# If the `Value` has no properties, the AST node is just whatever this
|
||
# node’s `base` is.
|
||
return @base.ast o unless @hasProperties()
|
||
# Otherwise, call `Base::ast` which in turn calls the `astType` and
|
||
# `astProperties` methods below.
|
||
super o
|
||
|
||
astType: ->
|
||
if @isJSXTag()
|
||
'JSXMemberExpression'
|
||
else if @containsSoak()
|
||
'OptionalMemberExpression'
|
||
else
|
||
'MemberExpression'
|
||
|
||
# If this `Value` has properties, the *last* property (e.g. `c` in `a.b.c`)
|
||
# becomes the `property`, and the preceding properties (e.g. `a.b`) become
|
||
# a child `Value` node assigned to the `object` property.
|
||
astProperties: (o) ->
|
||
[..., property] = @properties
|
||
property.name.jsx = yes if @isJSXTag()
|
||
computed = property instanceof Index or property.name?.unwrap() not instanceof PropertyName
|
||
return {
|
||
object: @object().ast o, LEVEL_ACCESS
|
||
property: property.ast o, (LEVEL_PAREN if computed)
|
||
computed
|
||
optional: !!property.soak
|
||
shorthand: !!property.shorthand
|
||
}
|
||
|
||
astLocationData: ->
|
||
return super() unless @isJSXTag()
|
||
# don't include leading < of JSX tag in location data
|
||
mergeAstLocationData(
|
||
jisonLocationDataToAstLocationData(@base.tagNameLocationData),
|
||
jisonLocationDataToAstLocationData(@properties[@properties.length - 1].locationData)
|
||
)
|
||
|
||
exports.MetaProperty = class MetaProperty extends Base
|
||
constructor: (@meta, @property) ->
|
||
super()
|
||
|
||
children: ['meta', 'property']
|
||
|
||
checkValid: (o) ->
|
||
if @meta.value is 'new'
|
||
if @property instanceof Access and @property.name.value is 'target'
|
||
unless o.scope.parent?
|
||
@error "new.target can only occur inside functions"
|
||
else
|
||
@error "the only valid meta property for new is new.target"
|
||
else if @meta.value is 'import'
|
||
unless @property instanceof Access and @property.name.value is 'meta'
|
||
@error "the only valid meta property for import is import.meta"
|
||
|
||
compileNode: (o) ->
|
||
@checkValid o
|
||
fragments = []
|
||
fragments.push @meta.compileToFragments(o, LEVEL_ACCESS)...
|
||
fragments.push @property.compileToFragments(o)...
|
||
fragments
|
||
|
||
astProperties: (o) ->
|
||
@checkValid o
|
||
|
||
return
|
||
meta: @meta.ast o, LEVEL_ACCESS
|
||
property: @property.ast o
|
||
|
||
#### HereComment
|
||
|
||
# Comment delimited by `###` (becoming `/* */`).
|
||
exports.HereComment = class HereComment extends Base
|
||
constructor: ({ @content, @newLine, @unshift, @locationData }) ->
|
||
super()
|
||
|
||
compileNode: (o) ->
|
||
multiline = '\n' in @content
|
||
|
||
# Unindent multiline comments. They will be reindented later.
|
||
if multiline
|
||
indent = null
|
||
for line in @content.split '\n'
|
||
leadingWhitespace = /^\s*/.exec(line)[0]
|
||
if not indent or leadingWhitespace.length < indent.length
|
||
indent = leadingWhitespace
|
||
@content = @content.replace /// \n #{indent} ///g, '\n' if indent
|
||
|
||
hasLeadingMarks = /\n\s*[#|\*]/.test @content
|
||
@content = @content.replace /^([ \t]*)#(?=\s)/gm, ' *' if hasLeadingMarks
|
||
|
||
@content = "/*#{@content}#{if hasLeadingMarks then ' ' else ''}*/"
|
||
fragment = @makeCode @content
|
||
fragment.newLine = @newLine
|
||
fragment.unshift = @unshift
|
||
fragment.multiline = multiline
|
||
# Don’t rely on `fragment.type`, which can break when the compiler is minified.
|
||
fragment.isComment = fragment.isHereComment = yes
|
||
fragment
|
||
|
||
astType: -> 'CommentBlock'
|
||
|
||
astProperties: ->
|
||
return
|
||
value: @content
|
||
|
||
#### LineComment
|
||
|
||
# Comment running from `#` to the end of a line (becoming `//`).
|
||
exports.LineComment = class LineComment extends Base
|
||
constructor: ({ @content, @newLine, @unshift, @locationData, @precededByBlankLine }) ->
|
||
super()
|
||
|
||
compileNode: (o) ->
|
||
fragment = @makeCode(if /^\s*$/.test @content then '' else "#{if @precededByBlankLine then "\n#{o.indent}" else ''}//#{@content}")
|
||
fragment.newLine = @newLine
|
||
fragment.unshift = @unshift
|
||
fragment.trail = not @newLine and not @unshift
|
||
# Don’t rely on `fragment.type`, which can break when the compiler is minified.
|
||
fragment.isComment = fragment.isLineComment = yes
|
||
fragment
|
||
|
||
astType: -> 'CommentLine'
|
||
|
||
astProperties: ->
|
||
return
|
||
value: @content
|
||
|
||
#### JSX
|
||
|
||
exports.JSXIdentifier = class JSXIdentifier extends IdentifierLiteral
|
||
astType: -> 'JSXIdentifier'
|
||
|
||
exports.JSXTag = class JSXTag extends JSXIdentifier
|
||
constructor: (value, {
|
||
@tagNameLocationData
|
||
@closingTagOpeningBracketLocationData
|
||
@closingTagSlashLocationData
|
||
@closingTagNameLocationData
|
||
@closingTagClosingBracketLocationData
|
||
}) ->
|
||
super value
|
||
|
||
astProperties: ->
|
||
return
|
||
name: @value
|
||
|
||
exports.JSXExpressionContainer = class JSXExpressionContainer extends Base
|
||
constructor: (@expression, {locationData} = {}) ->
|
||
super()
|
||
@expression.jsxAttribute = yes
|
||
@locationData = locationData ? @expression.locationData
|
||
|
||
children: ['expression']
|
||
|
||
compileNode: (o) ->
|
||
@expression.compileNode(o)
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
expression: astAsBlockIfNeeded @expression, o
|
||
|
||
exports.JSXEmptyExpression = class JSXEmptyExpression extends Base
|
||
|
||
exports.JSXText = class JSXText extends Base
|
||
constructor: (stringLiteral) ->
|
||
super()
|
||
@value = stringLiteral.unquotedValueForJSX
|
||
@locationData = stringLiteral.locationData
|
||
|
||
astProperties: ->
|
||
return {
|
||
@value
|
||
extra:
|
||
raw: @value
|
||
}
|
||
|
||
exports.JSXAttribute = class JSXAttribute extends Base
|
||
constructor: ({@name, value}) ->
|
||
super()
|
||
@value =
|
||
if value?
|
||
value = value.base
|
||
if value instanceof StringLiteral and not value.shouldGenerateTemplateLiteral()
|
||
value
|
||
else
|
||
new JSXExpressionContainer value
|
||
else
|
||
null
|
||
@value?.comments = value.comments
|
||
|
||
children: ['name', 'value']
|
||
|
||
compileNode: (o) ->
|
||
compiledName = @name.compileToFragments o, LEVEL_LIST
|
||
return compiledName unless @value?
|
||
val = @value.compileToFragments o, LEVEL_LIST
|
||
compiledName.concat @makeCode('='), val
|
||
|
||
astProperties: (o) ->
|
||
name = @name
|
||
if ':' in name.value
|
||
name = new JSXNamespacedName name
|
||
return
|
||
name: name.ast o
|
||
value: @value?.ast(o) ? null
|
||
|
||
exports.JSXAttributes = class JSXAttributes extends Base
|
||
constructor: (arr) ->
|
||
super()
|
||
@attributes = []
|
||
for object in arr.objects
|
||
@checkValidAttribute object
|
||
{base} = object
|
||
if base instanceof IdentifierLiteral
|
||
# attribute with no value eg disabled
|
||
attribute = new JSXAttribute name: new JSXIdentifier(base.value).withLocationDataAndCommentsFrom base
|
||
attribute.locationData = base.locationData
|
||
@attributes.push attribute
|
||
else if not base.generated
|
||
# object spread attribute eg {...props}
|
||
attribute = base.properties[0]
|
||
attribute.jsx = yes
|
||
attribute.locationData = base.locationData
|
||
@attributes.push attribute
|
||
else
|
||
# Obj containing attributes with values eg a="b" c={d}
|
||
for property in base.properties
|
||
{variable, value} = property
|
||
attribute = new JSXAttribute {
|
||
name: new JSXIdentifier(variable.base.value).withLocationDataAndCommentsFrom variable.base
|
||
value
|
||
}
|
||
attribute.locationData = property.locationData
|
||
@attributes.push attribute
|
||
@locationData = arr.locationData
|
||
|
||
children: ['attributes']
|
||
|
||
# Catch invalid attributes: <div {a:"b", props} {props} "value" />
|
||
checkValidAttribute: (object) ->
|
||
{base: attribute} = object
|
||
properties = attribute?.properties or []
|
||
if not (attribute instanceof Obj or attribute instanceof IdentifierLiteral) or (attribute instanceof Obj and not attribute.generated and (properties.length > 1 or not (properties[0] instanceof Splat)))
|
||
object.error """
|
||
Unexpected token. Allowed JSX attributes are: id="val", src={source}, {props...} or attribute.
|
||
"""
|
||
|
||
compileNode: (o) ->
|
||
fragments = []
|
||
for attribute in @attributes
|
||
fragments.push @makeCode ' '
|
||
fragments.push attribute.compileToFragments(o, LEVEL_TOP)...
|
||
fragments
|
||
|
||
astNode: (o) ->
|
||
attribute.ast(o) for attribute in @attributes
|
||
|
||
exports.JSXNamespacedName = class JSXNamespacedName extends Base
|
||
constructor: (tag) ->
|
||
super()
|
||
[namespace, name] = tag.value.split ':'
|
||
@namespace = new JSXIdentifier(namespace).withLocationDataFrom locationData: extractSameLineLocationDataFirst(namespace.length) tag.locationData
|
||
@name = new JSXIdentifier(name ).withLocationDataFrom locationData: extractSameLineLocationDataLast(name.length ) tag.locationData
|
||
@locationData = tag.locationData
|
||
|
||
children: ['namespace', 'name']
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
namespace: @namespace.ast o
|
||
name: @name.ast o
|
||
|
||
# Node for a JSX element
|
||
exports.JSXElement = class JSXElement extends Base
|
||
constructor: ({@tagName, @attributes, @content}) ->
|
||
super()
|
||
|
||
children: ['tagName', 'attributes', 'content']
|
||
|
||
compileNode: (o) ->
|
||
@content?.base.jsx = yes
|
||
fragments = [@makeCode('<')]
|
||
fragments.push (tag = @tagName.compileToFragments(o, LEVEL_ACCESS))...
|
||
fragments.push @attributes.compileToFragments(o)...
|
||
if @content
|
||
fragments.push @makeCode('>')
|
||
fragments.push @content.compileNode(o, LEVEL_LIST)...
|
||
fragments.push [@makeCode('</'), tag..., @makeCode('>')]...
|
||
else
|
||
fragments.push @makeCode(' />')
|
||
fragments
|
||
|
||
isFragment: ->
|
||
!@tagName.base.value.length
|
||
|
||
astNode: (o) ->
|
||
# The location data spanning the opening element < ... > is captured by
|
||
# the generated Arr which contains the element's attributes
|
||
@openingElementLocationData = jisonLocationDataToAstLocationData @attributes.locationData
|
||
|
||
tagName = @tagName.base
|
||
tagName.locationData = tagName.tagNameLocationData
|
||
if @content?
|
||
@closingElementLocationData = mergeAstLocationData(
|
||
jisonLocationDataToAstLocationData tagName.closingTagOpeningBracketLocationData
|
||
jisonLocationDataToAstLocationData tagName.closingTagClosingBracketLocationData
|
||
)
|
||
|
||
super o
|
||
|
||
astType: ->
|
||
if @isFragment()
|
||
'JSXFragment'
|
||
else
|
||
'JSXElement'
|
||
|
||
elementAstProperties: (o) ->
|
||
tagNameAst = =>
|
||
tag = @tagName.unwrap()
|
||
if tag?.value and ':' in tag.value
|
||
tag = new JSXNamespacedName tag
|
||
tag.ast o
|
||
|
||
openingElement = Object.assign {
|
||
type: 'JSXOpeningElement'
|
||
name: tagNameAst()
|
||
selfClosing: not @closingElementLocationData?
|
||
attributes: @attributes.ast o
|
||
}, @openingElementLocationData
|
||
|
||
closingElement = null
|
||
if @closingElementLocationData?
|
||
closingElement = Object.assign {
|
||
type: 'JSXClosingElement'
|
||
name: Object.assign(
|
||
tagNameAst(),
|
||
jisonLocationDataToAstLocationData @tagName.base.closingTagNameLocationData
|
||
)
|
||
}, @closingElementLocationData
|
||
if closingElement.name.type in ['JSXMemberExpression', 'JSXNamespacedName']
|
||
rangeDiff = closingElement.range[0] - openingElement.range[0] + '/'.length
|
||
columnDiff = closingElement.loc.start.column - openingElement.loc.start.column + '/'.length
|
||
shiftAstLocationData = (node) =>
|
||
node.range = [
|
||
node.range[0] + rangeDiff
|
||
node.range[1] + rangeDiff
|
||
]
|
||
node.start += rangeDiff
|
||
node.end += rangeDiff
|
||
node.loc.start =
|
||
line: @closingElementLocationData.loc.start.line
|
||
column: node.loc.start.column + columnDiff
|
||
node.loc.end =
|
||
line: @closingElementLocationData.loc.start.line
|
||
column: node.loc.end.column + columnDiff
|
||
if closingElement.name.type is 'JSXMemberExpression'
|
||
currentExpr = closingElement.name
|
||
while currentExpr.type is 'JSXMemberExpression'
|
||
shiftAstLocationData currentExpr unless currentExpr is closingElement.name
|
||
shiftAstLocationData currentExpr.property
|
||
currentExpr = currentExpr.object
|
||
shiftAstLocationData currentExpr
|
||
else # JSXNamespacedName
|
||
shiftAstLocationData closingElement.name.namespace
|
||
shiftAstLocationData closingElement.name.name
|
||
|
||
{openingElement, closingElement}
|
||
|
||
fragmentAstProperties: (o) ->
|
||
openingFragment = Object.assign {
|
||
type: 'JSXOpeningFragment'
|
||
}, @openingElementLocationData
|
||
|
||
closingFragment = Object.assign {
|
||
type: 'JSXClosingFragment'
|
||
}, @closingElementLocationData
|
||
|
||
{openingFragment, closingFragment}
|
||
|
||
contentAst: (o) ->
|
||
return [] unless @content and not @content.base.isEmpty?()
|
||
|
||
content = @content.unwrapAll()
|
||
children =
|
||
if content instanceof StringLiteral
|
||
[new JSXText content]
|
||
else # StringWithInterpolations
|
||
for element in @content.unwrapAll().extractElements o, includeInterpolationWrappers: yes, isJsx: yes
|
||
if element instanceof StringLiteral
|
||
new JSXText element
|
||
else # Interpolation
|
||
{expression} = element
|
||
unless expression?
|
||
emptyExpression = new JSXEmptyExpression()
|
||
emptyExpression.locationData = emptyExpressionLocationData {
|
||
interpolationNode: element
|
||
openingBrace: '{'
|
||
closingBrace: '}'
|
||
}
|
||
|
||
new JSXExpressionContainer emptyExpression, locationData: element.locationData
|
||
else
|
||
unwrapped = expression.unwrapAll()
|
||
if unwrapped instanceof JSXElement and
|
||
# distinguish `<a><b /></a>` from `<a>{<b />}</a>`
|
||
unwrapped.locationData.range[0] is element.locationData.range[0]
|
||
unwrapped
|
||
else
|
||
new JSXExpressionContainer unwrapped, locationData: element.locationData
|
||
|
||
child.ast(o) for child in children when not (child instanceof JSXText and child.value.length is 0)
|
||
|
||
astProperties: (o) ->
|
||
Object.assign(
|
||
if @isFragment()
|
||
@fragmentAstProperties o
|
||
else
|
||
@elementAstProperties o
|
||
,
|
||
children: @contentAst o
|
||
)
|
||
|
||
astLocationData: ->
|
||
if @closingElementLocationData?
|
||
mergeAstLocationData @openingElementLocationData, @closingElementLocationData
|
||
else
|
||
@openingElementLocationData
|
||
|
||
#### Call
|
||
|
||
# Node for a function invocation.
|
||
exports.Call = class Call extends Base
|
||
constructor: (@variable, @args = [], @soak, @token) ->
|
||
super()
|
||
|
||
@implicit = @args.implicit
|
||
@isNew = no
|
||
if @variable instanceof Value and @variable.isNotCallable()
|
||
@variable.error "literal is not a function"
|
||
|
||
if @variable.base instanceof JSXTag
|
||
return new JSXElement(
|
||
tagName: @variable
|
||
attributes: new JSXAttributes @args[0].base
|
||
content: @args[1]
|
||
)
|
||
|
||
# `@variable` never gets output as a result of this node getting created as
|
||
# part of `RegexWithInterpolations`, so for that case move any comments to
|
||
# the `args` property that gets passed into `RegexWithInterpolations` via
|
||
# the grammar.
|
||
if @variable.base?.value is 'RegExp' and @args.length isnt 0
|
||
moveComments @variable, @args[0]
|
||
|
||
children: ['variable', 'args']
|
||
|
||
# When setting the location, we sometimes need to update the start location to
|
||
# account for a newly-discovered `new` operator to the left of us. This
|
||
# expands the range on the left, but not the right.
|
||
updateLocationDataIfMissing: (locationData) ->
|
||
if @locationData and @needsUpdatedStartLocation
|
||
@locationData = Object.assign {},
|
||
@locationData,
|
||
first_line: locationData.first_line
|
||
first_column: locationData.first_column
|
||
range: [
|
||
locationData.range[0]
|
||
@locationData.range[1]
|
||
]
|
||
base = @variable?.base or @variable
|
||
if base.needsUpdatedStartLocation
|
||
@variable.locationData = Object.assign {},
|
||
@variable.locationData,
|
||
first_line: locationData.first_line
|
||
first_column: locationData.first_column
|
||
range: [
|
||
locationData.range[0]
|
||
@variable.locationData.range[1]
|
||
]
|
||
base.updateLocationDataIfMissing locationData
|
||
delete @needsUpdatedStartLocation
|
||
super locationData
|
||
|
||
# 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
|
||
@needsUpdatedStartLocation = true
|
||
this
|
||
|
||
# Soaked chained invocations unfold into if/else ternary structures.
|
||
unfoldSoak: (o) ->
|
||
if @soak
|
||
if @variable instanceof Super
|
||
left = new Literal @variable.compile o
|
||
rite = new Value left
|
||
@variable.error "Unsupported reference to 'super'" unless @variable.accessor?
|
||
else
|
||
return ifn if ifn = unfoldSoak o, this, 'variable'
|
||
[left, rite] = new Value(@variable).cacheReference o
|
||
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
|
||
|
||
# Compile a vanilla function call.
|
||
compileNode: (o) ->
|
||
@checkForNewSuper()
|
||
@variable?.front = @front
|
||
compiledArgs = []
|
||
# If variable is `Accessor` fragments are cached and used later
|
||
# in `Value::compileNode` to ensure correct order of the compilation,
|
||
# and reuse of variables in the scope.
|
||
# Example:
|
||
# `a(x = 5).b(-> x = 6)` should compile in the same order as
|
||
# `a(x = 5); b(-> x = 6)`
|
||
# (see issue #4437, https://github.com/jashkenas/coffeescript/issues/4437)
|
||
varAccess = @variable?.properties?[0] instanceof Access
|
||
argCode = (arg for arg in (@args || []) when arg instanceof Code)
|
||
if argCode.length > 0 and varAccess and not @variable.base.cached
|
||
[cache] = @variable.base.cache o, LEVEL_ACCESS, -> no
|
||
@variable.base.cached = cache
|
||
|
||
for arg, argIndex in @args
|
||
if argIndex then compiledArgs.push @makeCode ", "
|
||
compiledArgs.push (arg.compileToFragments o, LEVEL_LIST)...
|
||
|
||
fragments = []
|
||
if @isNew
|
||
fragments.push @makeCode 'new '
|
||
fragments.push @variable.compileToFragments(o, LEVEL_ACCESS)...
|
||
fragments.push @makeCode('('), compiledArgs..., @makeCode(')')
|
||
fragments
|
||
|
||
checkForNewSuper: ->
|
||
if @isNew
|
||
@variable.error "Unsupported reference to 'super'" if @variable instanceof Super
|
||
|
||
containsSoak: ->
|
||
return yes if @soak
|
||
return yes if @variable?.containsSoak?()
|
||
no
|
||
|
||
astNode: (o) ->
|
||
if @soak and @variable instanceof Super and o.scope.namedMethod()?.ctor
|
||
@variable.error "Unsupported reference to 'super'"
|
||
@checkForNewSuper()
|
||
super o
|
||
|
||
astType: ->
|
||
if @isNew
|
||
'NewExpression'
|
||
else if @containsSoak()
|
||
'OptionalCallExpression'
|
||
else
|
||
'CallExpression'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
callee: @variable.ast o, LEVEL_ACCESS
|
||
arguments: arg.ast(o, LEVEL_LIST) for arg in @args
|
||
optional: !!@soak
|
||
implicit: !!@implicit
|
||
|
||
#### Super
|
||
|
||
# Takes care of converting `super()` calls into calls against the prototype's
|
||
# function of the same name.
|
||
# When `expressions` are set the call will be compiled in such a way that the
|
||
# expressions are evaluated without altering the return value of the `SuperCall`
|
||
# expression.
|
||
exports.SuperCall = class SuperCall extends Call
|
||
children: Call::children.concat ['expressions']
|
||
|
||
isStatement: (o) ->
|
||
@expressions?.length and o.level is LEVEL_TOP
|
||
|
||
compileNode: (o) ->
|
||
return super o unless @expressions?.length
|
||
|
||
superCall = new Literal fragmentsToText super o
|
||
replacement = new Block @expressions.slice()
|
||
|
||
if o.level > LEVEL_TOP
|
||
# If we might be in an expression we need to cache and return the result
|
||
[superCall, ref] = superCall.cache o, null, YES
|
||
replacement.push ref
|
||
|
||
replacement.unshift superCall
|
||
replacement.compileToFragments o, if o.level is LEVEL_TOP then o.level else LEVEL_LIST
|
||
|
||
exports.Super = class Super extends Base
|
||
constructor: (@accessor, @superLiteral) ->
|
||
super()
|
||
|
||
children: ['accessor']
|
||
|
||
compileNode: (o) ->
|
||
@checkInInstanceMethod o
|
||
|
||
method = o.scope.namedMethod()
|
||
unless method.ctor? or @accessor?
|
||
{name, variable} = method
|
||
if name.shouldCache() or (name instanceof Index and name.index.isAssignable())
|
||
nref = new IdentifierLiteral o.scope.parent.freeVariable 'name'
|
||
name.index = new Assign nref, name.index
|
||
@accessor = if nref? then new Index nref else name
|
||
|
||
if @accessor?.name?.comments
|
||
# A `super()` call gets compiled to e.g. `super.method()`, which means
|
||
# the `method` property name gets compiled for the first time here, and
|
||
# again when the `method:` property of the class gets compiled. Since
|
||
# this compilation happens first, comments attached to `method:` would
|
||
# get incorrectly output near `super.method()`, when we want them to
|
||
# get output on the second pass when `method:` is output. So set them
|
||
# aside during this compilation pass, and put them back on the object so
|
||
# that they’re there for the later compilation.
|
||
salvagedComments = @accessor.name.comments
|
||
delete @accessor.name.comments
|
||
fragments = (new Value (new Literal 'super'), if @accessor then [ @accessor ] else [])
|
||
.compileToFragments o
|
||
attachCommentsToNode salvagedComments, @accessor.name if salvagedComments
|
||
fragments
|
||
|
||
checkInInstanceMethod: (o) ->
|
||
method = o.scope.namedMethod()
|
||
@error 'cannot use super outside of an instance method' unless method?.isMethod
|
||
|
||
astNode: (o) ->
|
||
@checkInInstanceMethod o
|
||
|
||
if @accessor?
|
||
return (
|
||
new Value(
|
||
new Super().withLocationDataFrom (@superLiteral ? @)
|
||
[@accessor]
|
||
).withLocationDataFrom @
|
||
).ast o
|
||
|
||
super o
|
||
|
||
#### RegexWithInterpolations
|
||
|
||
# Regexes with interpolations are in fact just a variation of a `Call` (a
|
||
# `RegExp()` call to be precise) with a `StringWithInterpolations` inside.
|
||
exports.RegexWithInterpolations = class RegexWithInterpolations extends Base
|
||
constructor: (@call, {@heregexCommentTokens = []} = {}) ->
|
||
super()
|
||
|
||
children: ['call']
|
||
|
||
compileNode: (o) ->
|
||
@call.compileNode o
|
||
|
||
astType: -> 'InterpolatedRegExpLiteral'
|
||
|
||
astProperties: (o) ->
|
||
interpolatedPattern: @call.args[0].ast o
|
||
flags: @call.args[1]?.unwrap().originalValue ? ''
|
||
comments:
|
||
for heregexCommentToken in @heregexCommentTokens
|
||
if heregexCommentToken.here
|
||
new HereComment(heregexCommentToken).ast o
|
||
else
|
||
new LineComment(heregexCommentToken).ast o
|
||
|
||
#### TaggedTemplateCall
|
||
|
||
exports.TaggedTemplateCall = class TaggedTemplateCall extends Call
|
||
constructor: (variable, arg, soak) ->
|
||
arg = StringWithInterpolations.fromStringLiteral arg if arg instanceof StringLiteral
|
||
super variable, [ arg ], soak
|
||
|
||
compileNode: (o) ->
|
||
@variable.compileToFragments(o, LEVEL_ACCESS).concat @args[0].compileToFragments(o, LEVEL_LIST)
|
||
|
||
astType: -> 'TaggedTemplateExpression'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
tag: @variable.ast o, LEVEL_ACCESS
|
||
quasi: @args[0].ast o, LEVEL_LIST
|
||
|
||
#### Extends
|
||
|
||
# Node to extend an object's prototype with an ancestor object.
|
||
# After `goog.inherits` from the
|
||
# [Closure Library](https://github.com/google/closure-library/blob/master/closure/goog/base.js).
|
||
exports.Extends = class Extends extends Base
|
||
constructor: (@child, @parent) ->
|
||
super()
|
||
|
||
children: ['child', 'parent']
|
||
|
||
# Hooks one constructor into another's prototype chain.
|
||
compileToFragments: (o) ->
|
||
new Call(new Value(new Literal utility 'extend', o), [@child, @parent]).compileToFragments 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, {@soak, @shorthand} = {}) ->
|
||
super()
|
||
|
||
children: ['name']
|
||
|
||
compileToFragments: (o) ->
|
||
name = @name.compileToFragments o
|
||
node = @name.unwrap()
|
||
if node instanceof PropertyName
|
||
[@makeCode('.'), name...]
|
||
else
|
||
[@makeCode('['), name..., @makeCode(']')]
|
||
|
||
shouldCache: NO
|
||
|
||
astNode: (o) ->
|
||
# Babel doesn’t have an AST node for `Access`, but rather just includes
|
||
# this Access node’s child `name` Identifier node as the `property` of
|
||
# the `MemberExpression` node.
|
||
@name.ast o
|
||
|
||
#### Index
|
||
|
||
# A `[ ... ]` indexed access into an array or object.
|
||
exports.Index = class Index extends Base
|
||
constructor: (@index) ->
|
||
super()
|
||
|
||
children: ['index']
|
||
|
||
compileToFragments: (o) ->
|
||
[].concat @makeCode("["), @index.compileToFragments(o, LEVEL_PAREN), @makeCode("]")
|
||
|
||
shouldCache: ->
|
||
@index.shouldCache()
|
||
|
||
astNode: (o) ->
|
||
# Babel doesn’t have an AST node for `Index`, but rather just includes
|
||
# this Index node’s child `index` Identifier node as the `property` of
|
||
# the `MemberExpression` node. The fact that the `MemberExpression`’s
|
||
# `property` is an Index means that `computed` is `true` for the
|
||
# `MemberExpression`.
|
||
@index.ast o
|
||
|
||
#### 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) ->
|
||
super()
|
||
|
||
@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
|
||
shouldCache = del o, 'shouldCache'
|
||
[@fromC, @fromVar] = @cacheToCodeFragments @from.cache o, LEVEL_LIST, shouldCache
|
||
[@toC, @toVar] = @cacheToCodeFragments @to.cache o, LEVEL_LIST, shouldCache
|
||
[@step, @stepVar] = @cacheToCodeFragments step.cache o, LEVEL_LIST, shouldCache if step = del o, 'step'
|
||
@fromNum = if @from.isNumber() then parseNumber @fromVar else null
|
||
@toNum = if @to.isNumber() then parseNumber @toVar else null
|
||
@stepNum = if step?.isNumber() then parseNumber @stepVar else null
|
||
|
||
# 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'
|
||
idxName = del o, 'name'
|
||
namedIndex = idxName and idxName isnt idx
|
||
varPart =
|
||
if known and not namedIndex
|
||
"var #{idx} = #{@fromC}"
|
||
else
|
||
"#{idx} = #{@fromC}"
|
||
varPart += ", #{@toC}" if @toC isnt @toVar
|
||
varPart += ", #{@step}" if @step isnt @stepVar
|
||
[lt, gt] = ["#{idx} <#{@equals}", "#{idx} >#{@equals}"]
|
||
|
||
# Generate the condition.
|
||
[from, to] = [@fromNum, @toNum]
|
||
# Always check if the `step` isn't zero to avoid the infinite loop.
|
||
stepNotZero = "#{ @stepNum ? @stepVar } !== 0"
|
||
stepCond = "#{ @stepNum ? @stepVar } > 0"
|
||
lowerBound = "#{lt} #{ if known then to else @toVar }"
|
||
upperBound = "#{gt} #{ if known then to else @toVar }"
|
||
condPart =
|
||
if @step?
|
||
if @stepNum? and @stepNum isnt 0
|
||
if @stepNum > 0 then "#{lowerBound}" else "#{upperBound}"
|
||
else
|
||
"#{stepNotZero} && (#{stepCond} ? #{lowerBound} : #{upperBound})"
|
||
else
|
||
if known
|
||
"#{ if from <= to then lt else gt } #{to}"
|
||
else
|
||
"(#{@fromVar} <= #{@toVar} ? #{lowerBound} : #{upperBound})"
|
||
|
||
cond = if @stepVar then "#{@stepVar} > 0" else "#{@fromVar} <= #{@toVar}"
|
||
|
||
# Generate the step.
|
||
stepPart = if @stepVar
|
||
"#{idx} += #{@stepVar}"
|
||
else if known
|
||
if namedIndex
|
||
if from <= to then "++#{idx}" else "--#{idx}"
|
||
else
|
||
if from <= to then "#{idx}++" else "#{idx}--"
|
||
else
|
||
if namedIndex
|
||
"#{cond} ? ++#{idx} : --#{idx}"
|
||
else
|
||
"#{cond} ? #{idx}++ : #{idx}--"
|
||
|
||
varPart = "#{idxName} = #{varPart}" if namedIndex
|
||
stepPart = "#{idxName} = #{stepPart}" if namedIndex
|
||
|
||
# The final loop body.
|
||
[@makeCode "#{varPart}; #{condPart}; #{stepPart}"]
|
||
|
||
|
||
# When used as a value, expand the range into the equivalent array.
|
||
compileArray: (o) ->
|
||
known = @fromNum? and @toNum?
|
||
if known and Math.abs(@fromNum - @toNum) <= 20
|
||
range = [@fromNum..@toNum]
|
||
range.pop() if @exclusive
|
||
return [@makeCode "[#{ range.join(', ') }]"]
|
||
idt = @tab + TAB
|
||
i = o.scope.freeVariable 'i', single: true, reserve: no
|
||
result = o.scope.freeVariable 'results', reserve: no
|
||
pre = "\n#{idt}var #{result} = [];"
|
||
if known
|
||
o.index = i
|
||
body = fragmentsToText @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 isLiteralArguments
|
||
args = ', arguments' if hasArgs(@from) or hasArgs(@to)
|
||
[@makeCode "(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this#{args ? ''})"]
|
||
|
||
astProperties: (o) ->
|
||
return {
|
||
from: @from?.ast(o) ? null
|
||
to: @to?.ast(o) ? null
|
||
@exclusive
|
||
}
|
||
|
||
#### 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
|
||
# Handle an expression in the property access, e.g. `a[!b in c..]`.
|
||
if from?.shouldCache()
|
||
from = new Value new Parens from
|
||
if to?.shouldCache()
|
||
to = new Value new Parens to
|
||
fromCompiled = from?.compileToFragments(o, LEVEL_PAREN) or [@makeCode '0']
|
||
if to
|
||
compiled = to.compileToFragments o, LEVEL_PAREN
|
||
compiledText = fragmentsToText compiled
|
||
if not (not @range.exclusive and +compiledText is -1)
|
||
toStr = ', ' + if @range.exclusive
|
||
compiledText
|
||
else if to.isNumber()
|
||
"#{+compiledText + 1}"
|
||
else
|
||
compiled = to.compileToFragments o, LEVEL_ACCESS
|
||
"+#{fragmentsToText compiled} + 1 || 9e9"
|
||
[@makeCode ".slice(#{ fragmentsToText fromCompiled }#{ toStr or '' })"]
|
||
|
||
astNode: (o) ->
|
||
@range.ast o
|
||
|
||
#### Obj
|
||
|
||
# An object literal, nothing fancy.
|
||
exports.Obj = class Obj extends Base
|
||
constructor: (props, @generated = no) ->
|
||
super()
|
||
|
||
@objects = @properties = props or []
|
||
|
||
children: ['properties']
|
||
|
||
isAssignable: (opts) ->
|
||
for prop in @properties
|
||
# Check for reserved words.
|
||
message = isUnassignable prop.unwrapAll().value
|
||
prop.error message if message
|
||
|
||
prop = prop.value if prop instanceof Assign and
|
||
prop.context is 'object' and
|
||
prop.value?.base not instanceof Arr
|
||
return no unless prop.isAssignable opts
|
||
yes
|
||
|
||
shouldCache: ->
|
||
not @isAssignable()
|
||
|
||
# Check if object contains splat.
|
||
hasSplat: ->
|
||
return yes for prop in @properties when prop instanceof Splat
|
||
no
|
||
|
||
# Move rest property to the end of the list.
|
||
# `{a, rest..., b} = obj` -> `{a, b, rest...} = obj`
|
||
# `foo = ({a, rest..., b}) ->` -> `foo = {a, b, rest...}) ->`
|
||
reorderProperties: ->
|
||
props = @properties
|
||
splatProps = @getAndCheckSplatProps()
|
||
splatProp = props.splice splatProps[0], 1
|
||
@objects = @properties = [].concat props, splatProp
|
||
|
||
compileNode: (o) ->
|
||
@reorderProperties() if @hasSplat() and @lhs
|
||
props = @properties
|
||
if @generated
|
||
for node in props when node instanceof Value
|
||
node.error 'cannot have an implicit value in an implicit object'
|
||
|
||
idt = o.indent += TAB
|
||
lastNode = @lastNode @properties
|
||
|
||
# If this object is the left-hand side of an assignment, all its children
|
||
# are too.
|
||
@propagateLhs()
|
||
|
||
isCompact = yes
|
||
for prop in @properties
|
||
if prop instanceof Assign and prop.context is 'object'
|
||
isCompact = no
|
||
|
||
answer = []
|
||
answer.push @makeCode if isCompact then '' else '\n'
|
||
for prop, i in props
|
||
join = if i is props.length - 1
|
||
''
|
||
else if isCompact
|
||
', '
|
||
else if prop is lastNode
|
||
'\n'
|
||
else
|
||
',\n'
|
||
indent = if isCompact then '' else idt
|
||
|
||
key = if prop instanceof Assign and prop.context is 'object'
|
||
prop.variable
|
||
else if prop instanceof Assign
|
||
prop.operatorToken.error "unexpected #{prop.operatorToken.value}" unless @lhs
|
||
prop.variable
|
||
else
|
||
prop
|
||
if key instanceof Value and key.hasProperties()
|
||
key.error 'invalid object key' if prop.context is 'object' or not key.this
|
||
key = key.properties[0].name
|
||
prop = new Assign key, prop, 'object'
|
||
if key is prop
|
||
if prop.shouldCache()
|
||
[key, value] = prop.base.cache o
|
||
key = new PropertyName key.value if key instanceof IdentifierLiteral
|
||
prop = new Assign key, value, 'object'
|
||
else if key instanceof Value and key.base instanceof ComputedPropertyName
|
||
# `{ [foo()] }` output as `{ [ref = foo()]: ref }`.
|
||
if prop.base.value.shouldCache()
|
||
[key, value] = prop.base.value.cache o
|
||
key = new ComputedPropertyName key.value if key instanceof IdentifierLiteral
|
||
prop = new Assign key, value, 'object'
|
||
else
|
||
# `{ [expression] }` output as `{ [expression]: expression }`.
|
||
prop = new Assign key, prop.base.value, 'object'
|
||
else if not prop.bareLiteral?(IdentifierLiteral) and prop not instanceof Splat
|
||
prop = new Assign prop, prop, 'object'
|
||
if indent then answer.push @makeCode indent
|
||
answer.push prop.compileToFragments(o, LEVEL_TOP)...
|
||
if join then answer.push @makeCode join
|
||
answer.push @makeCode if isCompact then '' else "\n#{@tab}"
|
||
answer = @wrapInBraces answer
|
||
if @front then @wrapInParentheses answer else answer
|
||
|
||
getAndCheckSplatProps: ->
|
||
return unless @hasSplat() and @lhs
|
||
props = @properties
|
||
splatProps = (i for prop, i in props when prop instanceof Splat)
|
||
props[splatProps[1]].error "multiple spread elements are disallowed" if splatProps?.length > 1
|
||
splatProps
|
||
|
||
assigns: (name) ->
|
||
for prop in @properties when prop.assigns name then return yes
|
||
no
|
||
|
||
eachName: (iterator) ->
|
||
for prop in @properties
|
||
prop = prop.value if prop instanceof Assign and prop.context is 'object'
|
||
prop = prop.unwrapAll()
|
||
prop.eachName iterator if prop.eachName?
|
||
|
||
# Convert “bare” properties to `ObjectProperty`s (or `Splat`s).
|
||
expandProperty: (property) ->
|
||
{variable, context, operatorToken} = property
|
||
key = if property instanceof Assign and context is 'object'
|
||
variable
|
||
else if property instanceof Assign
|
||
operatorToken.error "unexpected #{operatorToken.value}" unless @lhs
|
||
variable
|
||
else
|
||
property
|
||
if key instanceof Value and key.hasProperties()
|
||
key.error 'invalid object key' unless context isnt 'object' and key.this
|
||
if property instanceof Assign
|
||
return new ObjectProperty fromAssign: property
|
||
else
|
||
return new ObjectProperty key: property
|
||
return new ObjectProperty(fromAssign: property) unless key is property
|
||
return property if property instanceof Splat
|
||
|
||
new ObjectProperty key: property
|
||
|
||
expandProperties: ->
|
||
@expandProperty(property) for property in @properties
|
||
|
||
propagateLhs: (setLhs) ->
|
||
@lhs = yes if setLhs
|
||
return unless @lhs
|
||
|
||
for property in @properties
|
||
if property instanceof Assign and property.context is 'object'
|
||
{value} = property
|
||
unwrappedValue = value.unwrapAll()
|
||
if unwrappedValue instanceof Arr or unwrappedValue instanceof Obj
|
||
unwrappedValue.propagateLhs yes
|
||
else if unwrappedValue instanceof Assign
|
||
unwrappedValue.nestedLhs = yes
|
||
else if property instanceof Assign
|
||
# Shorthand property with default, e.g. `{a = 1} = b`.
|
||
property.nestedLhs = yes
|
||
else if property instanceof Splat
|
||
property.propagateLhs yes
|
||
|
||
astNode: (o) ->
|
||
@getAndCheckSplatProps()
|
||
super o
|
||
|
||
astType: ->
|
||
if @lhs
|
||
'ObjectPattern'
|
||
else
|
||
'ObjectExpression'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
implicit: !!@generated
|
||
properties:
|
||
property.ast(o) for property in @expandProperties()
|
||
|
||
exports.ObjectProperty = class ObjectProperty extends Base
|
||
constructor: ({key, fromAssign}) ->
|
||
super()
|
||
if fromAssign
|
||
{variable: @key, value, context} = fromAssign
|
||
if context is 'object'
|
||
# All non-shorthand properties (i.e. includes `:`).
|
||
@value = value
|
||
else
|
||
# Left-hand-side shorthand with default e.g. `{a = 1} = b`.
|
||
@value = fromAssign
|
||
@shorthand = yes
|
||
@locationData = fromAssign.locationData
|
||
else
|
||
# Shorthand without default e.g. `{a}` or `{@a}` or `{[a]}`.
|
||
@key = key
|
||
@shorthand = yes
|
||
@locationData = key.locationData
|
||
|
||
astProperties: (o) ->
|
||
isComputedPropertyName = (@key instanceof Value and @key.base instanceof ComputedPropertyName) or @key.unwrap() instanceof StringWithInterpolations
|
||
keyAst = @key.ast o, LEVEL_LIST
|
||
|
||
return
|
||
key:
|
||
if keyAst?.declaration
|
||
Object.assign {}, keyAst, declaration: no
|
||
else
|
||
keyAst
|
||
value: @value?.ast(o, LEVEL_LIST) ? keyAst
|
||
shorthand: !!@shorthand
|
||
computed: !!isComputedPropertyName
|
||
method: no
|
||
|
||
#### Arr
|
||
|
||
# An array literal.
|
||
exports.Arr = class Arr extends Base
|
||
constructor: (objs, @lhs = no) ->
|
||
super()
|
||
@objects = objs or []
|
||
@propagateLhs()
|
||
|
||
children: ['objects']
|
||
|
||
hasElision: ->
|
||
return yes for obj in @objects when obj instanceof Elision
|
||
no
|
||
|
||
isAssignable: (opts) ->
|
||
{allowExpansion, allowNontrailingSplat, allowEmptyArray = no} = opts ? {}
|
||
return allowEmptyArray unless @objects.length
|
||
|
||
for obj, i in @objects
|
||
return no if not allowNontrailingSplat and obj instanceof Splat and i + 1 isnt @objects.length
|
||
return no unless (allowExpansion and obj instanceof Expansion) or (obj.isAssignable(opts) and (not obj.isAtomic or obj.isAtomic()))
|
||
yes
|
||
|
||
shouldCache: ->
|
||
not @isAssignable()
|
||
|
||
compileNode: (o) ->
|
||
return [@makeCode '[]'] unless @objects.length
|
||
o.indent += TAB
|
||
fragmentIsElision = ([ fragment ]) ->
|
||
fragment.type is 'Elision' and fragment.code.trim() is ','
|
||
# Detect if `Elision`s at the beginning of the array are processed (e.g. [, , , a]).
|
||
passedElision = no
|
||
|
||
answer = []
|
||
for obj, objIndex in @objects
|
||
unwrappedObj = obj.unwrapAll()
|
||
# Let `compileCommentFragments` know to intersperse block comments
|
||
# into the fragments created when compiling this array.
|
||
if unwrappedObj.comments and
|
||
unwrappedObj.comments.filter((comment) -> not comment.here).length is 0
|
||
unwrappedObj.includeCommentFragments = YES
|
||
|
||
compiledObjs = (obj.compileToFragments o, LEVEL_LIST for obj in @objects)
|
||
olen = compiledObjs.length
|
||
# If `compiledObjs` includes newlines, we will output this as a multiline
|
||
# array (i.e. with a newline and indentation after the `[`). If an element
|
||
# contains line comments, that should also trigger multiline output since
|
||
# by definition line comments will introduce newlines into our output.
|
||
# The exception is if only the first element has line comments; in that
|
||
# case, output as the compact form if we otherwise would have, so that the
|
||
# first element’s line comments get output before or after the array.
|
||
includesLineCommentsOnNonFirstElement = no
|
||
for fragments, index in compiledObjs
|
||
for fragment in fragments
|
||
if fragment.isHereComment
|
||
fragment.code = fragment.code.trim()
|
||
else if index isnt 0 and includesLineCommentsOnNonFirstElement is no and hasLineComments fragment
|
||
includesLineCommentsOnNonFirstElement = yes
|
||
# Add ', ' if all `Elisions` from the beginning of the array are processed (e.g. [, , , a]) and
|
||
# element isn't `Elision` or last element is `Elision` (e.g. [a,,b,,])
|
||
if index isnt 0 and passedElision and (not fragmentIsElision(fragments) or index is olen - 1)
|
||
answer.push @makeCode ', '
|
||
passedElision = passedElision or not fragmentIsElision fragments
|
||
answer.push fragments...
|
||
if includesLineCommentsOnNonFirstElement or '\n' in fragmentsToText(answer)
|
||
for fragment, fragmentIndex in answer
|
||
if fragment.isHereComment
|
||
fragment.code = "#{multident(fragment.code, o.indent, no)}\n#{o.indent}"
|
||
else if fragment.code is ', ' and not fragment?.isElision and fragment.type not in ['StringLiteral', 'StringWithInterpolations']
|
||
fragment.code = ",\n#{o.indent}"
|
||
answer.unshift @makeCode "[\n#{o.indent}"
|
||
answer.push @makeCode "\n#{@tab}]"
|
||
else
|
||
for fragment in answer when fragment.isHereComment
|
||
fragment.code = "#{fragment.code} "
|
||
answer.unshift @makeCode '['
|
||
answer.push @makeCode ']'
|
||
answer
|
||
|
||
assigns: (name) ->
|
||
for obj in @objects when obj.assigns name then return yes
|
||
no
|
||
|
||
eachName: (iterator) ->
|
||
for obj in @objects
|
||
obj = obj.unwrapAll()
|
||
obj.eachName iterator
|
||
|
||
# If this array is the left-hand side of an assignment, all its children
|
||
# are too.
|
||
propagateLhs: (setLhs) ->
|
||
@lhs = yes if setLhs
|
||
return unless @lhs
|
||
for object in @objects
|
||
object.lhs = yes if object instanceof Splat or object instanceof Expansion
|
||
unwrappedObject = object.unwrapAll()
|
||
if unwrappedObject instanceof Arr or unwrappedObject instanceof Obj
|
||
unwrappedObject.propagateLhs yes
|
||
else if unwrappedObject instanceof Assign
|
||
unwrappedObject.nestedLhs = yes
|
||
|
||
astType: ->
|
||
if @lhs
|
||
'ArrayPattern'
|
||
else
|
||
'ArrayExpression'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
elements:
|
||
object.ast(o, LEVEL_LIST) for object in @objects
|
||
|
||
#### Class
|
||
|
||
# The CoffeeScript class definition.
|
||
# Initialize a **Class** with its name, an optional superclass, and a body.
|
||
|
||
exports.Class = class Class extends Base
|
||
children: ['variable', 'parent', 'body']
|
||
|
||
constructor: (@variable, @parent, @body) ->
|
||
super()
|
||
unless @body?
|
||
@body = new Block
|
||
@hasGeneratedBody = yes
|
||
|
||
compileNode: (o) ->
|
||
@name = @determineName()
|
||
executableBody = @walkBody o
|
||
|
||
# Special handling to allow `class expr.A extends A` declarations
|
||
parentName = @parent.base.value if @parent instanceof Value and not @parent.hasProperties()
|
||
@hasNameClash = @name? and @name is parentName
|
||
|
||
node = @
|
||
|
||
if executableBody or @hasNameClash
|
||
node = new ExecutableClassBody node, executableBody
|
||
else if not @name? and o.level is LEVEL_TOP
|
||
# Anonymous classes are only valid in expressions
|
||
node = new Parens node
|
||
|
||
if @boundMethods.length and @parent
|
||
@variable ?= new IdentifierLiteral o.scope.freeVariable '_class'
|
||
[@variable, @variableRef] = @variable.cache o unless @variableRef?
|
||
|
||
if @variable
|
||
node = new Assign @variable, node, null, { @moduleDeclaration }
|
||
|
||
@compileNode = @compileClassDeclaration
|
||
try
|
||
return node.compileToFragments o
|
||
finally
|
||
delete @compileNode
|
||
|
||
compileClassDeclaration: (o) ->
|
||
@ctor ?= @makeDefaultConstructor() if @externalCtor or @boundMethods.length
|
||
@ctor?.noReturn = true
|
||
|
||
@proxyBoundMethods() if @boundMethods.length
|
||
|
||
o.indent += TAB
|
||
|
||
result = []
|
||
result.push @makeCode "class "
|
||
result.push @makeCode @name if @name
|
||
@compileCommentFragments o, @variable, result if @variable?.comments?
|
||
result.push @makeCode ' ' if @name
|
||
result.push @makeCode('extends '), @parent.compileToFragments(o)..., @makeCode ' ' if @parent
|
||
|
||
result.push @makeCode '{'
|
||
unless @body.isEmpty()
|
||
@body.spaced = true
|
||
result.push @makeCode '\n'
|
||
result.push @body.compileToFragments(o, LEVEL_TOP)...
|
||
result.push @makeCode "\n#{@tab}"
|
||
result.push @makeCode '}'
|
||
|
||
result
|
||
|
||
# Figure out the appropriate name for this class
|
||
determineName: ->
|
||
return null unless @variable
|
||
[..., tail] = @variable.properties
|
||
node = if tail
|
||
tail instanceof Access and tail.name
|
||
else
|
||
@variable.base
|
||
unless node instanceof IdentifierLiteral or node instanceof PropertyName
|
||
return null
|
||
name = node.value
|
||
unless tail
|
||
message = isUnassignable name
|
||
@variable.error message if message
|
||
if name in JS_FORBIDDEN then "_#{name}" else name
|
||
|
||
walkBody: (o) ->
|
||
@ctor = null
|
||
@boundMethods = []
|
||
executableBody = null
|
||
|
||
initializer = []
|
||
{ expressions } = @body
|
||
|
||
i = 0
|
||
for expression in expressions.slice()
|
||
if expression instanceof Value and expression.isObject true
|
||
{ properties } = expression.base
|
||
exprs = []
|
||
end = 0
|
||
start = 0
|
||
pushSlice = -> exprs.push new Value new Obj properties[start...end], true if end > start
|
||
|
||
while assign = properties[end]
|
||
if initializerExpression = @addInitializerExpression assign, o
|
||
pushSlice()
|
||
exprs.push initializerExpression
|
||
initializer.push initializerExpression
|
||
start = end + 1
|
||
end++
|
||
pushSlice()
|
||
|
||
expressions[i..i] = exprs
|
||
i += exprs.length
|
||
else
|
||
if initializerExpression = @addInitializerExpression expression, o
|
||
initializer.push initializerExpression
|
||
expressions[i] = initializerExpression
|
||
i += 1
|
||
|
||
for method in initializer when method instanceof Code
|
||
if method.ctor
|
||
method.error 'Cannot define more than one constructor in a class' if @ctor
|
||
@ctor = method
|
||
else if method.isStatic and method.bound
|
||
method.context = @name
|
||
else if method.bound
|
||
@boundMethods.push method
|
||
|
||
return unless o.compiling
|
||
if initializer.length isnt expressions.length
|
||
@body.expressions = (expression.hoist() for expression in initializer)
|
||
new Block expressions
|
||
|
||
# Add an expression to the class initializer
|
||
#
|
||
# This is the key method for determining whether an expression in a class
|
||
# body should appear in the initializer or the executable body. If the given
|
||
# `node` is valid in a class body the method will return a (new, modified,
|
||
# or identical) node for inclusion in the class initializer, otherwise
|
||
# nothing will be returned and the node will appear in the executable body.
|
||
#
|
||
# At time of writing, only methods (instance and static) are valid in ES
|
||
# class initializers. As new ES class features (such as class fields) reach
|
||
# Stage 4, this method will need to be updated to support them. We
|
||
# additionally allow `PassthroughLiteral`s (backticked expressions) in the
|
||
# initializer as an escape hatch for ES features that are not implemented
|
||
# (e.g. getters and setters defined via the `get` and `set` keywords as
|
||
# opposed to the `Object.defineProperty` method).
|
||
addInitializerExpression: (node, o) ->
|
||
if node.unwrapAll() instanceof PassthroughLiteral
|
||
node
|
||
else if @validInitializerMethod node
|
||
@addInitializerMethod node
|
||
else if not o.compiling and @validClassProperty node
|
||
@addClassProperty node
|
||
else if not o.compiling and @validClassPrototypeProperty node
|
||
@addClassPrototypeProperty node
|
||
else
|
||
null
|
||
|
||
# Checks if the given node is a valid ES class initializer method.
|
||
validInitializerMethod: (node) ->
|
||
return no unless node instanceof Assign and node.value instanceof Code
|
||
return yes if node.context is 'object' and not node.variable.hasProperties()
|
||
return node.variable.looksStatic(@name) and (@name or not node.value.bound)
|
||
|
||
# Returns a configured class initializer method
|
||
addInitializerMethod: (assign) ->
|
||
{ variable, value: method, operatorToken } = assign
|
||
method.isMethod = yes
|
||
method.isStatic = variable.looksStatic @name
|
||
|
||
if method.isStatic
|
||
method.name = variable.properties[0]
|
||
else
|
||
methodName = variable.base
|
||
method.name = new (if methodName.shouldCache() then Index else Access) methodName
|
||
method.name.updateLocationDataIfMissing methodName.locationData
|
||
isConstructor =
|
||
if methodName instanceof StringLiteral
|
||
methodName.originalValue is 'constructor'
|
||
else
|
||
methodName.value is 'constructor'
|
||
method.ctor = (if @parent then 'derived' else 'base') if isConstructor
|
||
method.error 'Cannot define a constructor as a bound (fat arrow) function' if method.bound and method.ctor
|
||
|
||
method.operatorToken = operatorToken
|
||
method
|
||
|
||
validClassProperty: (node) ->
|
||
return no unless node instanceof Assign
|
||
return node.variable.looksStatic @name
|
||
|
||
addClassProperty: (assign) ->
|
||
{variable, value, operatorToken} = assign
|
||
{staticClassName} = variable.looksStatic @name
|
||
new ClassProperty({
|
||
name: variable.properties[0]
|
||
isStatic: yes
|
||
staticClassName
|
||
value
|
||
operatorToken
|
||
}).withLocationDataFrom assign
|
||
|
||
validClassPrototypeProperty: (node) ->
|
||
return no unless node instanceof Assign
|
||
node.context is 'object' and not node.variable.hasProperties()
|
||
|
||
addClassPrototypeProperty: (assign) ->
|
||
{variable, value} = assign
|
||
new ClassPrototypeProperty({
|
||
name: variable.base
|
||
value
|
||
}).withLocationDataFrom assign
|
||
|
||
makeDefaultConstructor: ->
|
||
ctor = @addInitializerMethod new Assign (new Value new PropertyName 'constructor'), new Code
|
||
@body.unshift ctor
|
||
|
||
if @parent
|
||
ctor.body.push new SuperCall new Super, [new Splat new IdentifierLiteral 'arguments']
|
||
|
||
if @externalCtor
|
||
applyCtor = new Value @externalCtor, [ new Access new PropertyName 'apply' ]
|
||
applyArgs = [ new ThisLiteral, new IdentifierLiteral 'arguments' ]
|
||
ctor.body.push new Call applyCtor, applyArgs
|
||
ctor.body.makeReturn()
|
||
|
||
ctor
|
||
|
||
proxyBoundMethods: ->
|
||
@ctor.thisAssignments = for method in @boundMethods
|
||
method.classVariable = @variableRef if @parent
|
||
|
||
name = new Value(new ThisLiteral, [ method.name ])
|
||
new Assign name, new Call(new Value(name, [new Access new PropertyName 'bind']), [new ThisLiteral])
|
||
|
||
null
|
||
|
||
declareName: (o) ->
|
||
return unless (name = @variable?.unwrap()) instanceof IdentifierLiteral
|
||
alreadyDeclared = o.scope.find name.value
|
||
name.isDeclaration = not alreadyDeclared
|
||
|
||
isStatementAst: -> yes
|
||
|
||
astNode: (o) ->
|
||
if jumpNode = @body.jumps()
|
||
jumpNode.error 'Class bodies cannot contain pure statements'
|
||
if argumentsNode = @body.contains isLiteralArguments
|
||
argumentsNode.error "Class bodies shouldn't reference arguments"
|
||
@declareName o
|
||
@name = @determineName()
|
||
@body.isClassBody = yes
|
||
@body.locationData = zeroWidthLocationDataFromEndLocation @locationData if @hasGeneratedBody
|
||
@walkBody o
|
||
sniffDirectives @body.expressions
|
||
@ctor?.noReturn = yes
|
||
|
||
super o
|
||
|
||
astType: (o) ->
|
||
if o.level is LEVEL_TOP
|
||
'ClassDeclaration'
|
||
else
|
||
'ClassExpression'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
id: @variable?.ast(o) ? null
|
||
superClass: @parent?.ast(o, LEVEL_PAREN) ? null
|
||
body: @body.ast o, LEVEL_TOP
|
||
|
||
exports.ExecutableClassBody = class ExecutableClassBody extends Base
|
||
children: [ 'class', 'body' ]
|
||
|
||
defaultClassVariableName: '_Class'
|
||
|
||
constructor: (@class, @body = new Block) ->
|
||
super()
|
||
|
||
compileNode: (o) ->
|
||
if jumpNode = @body.jumps()
|
||
jumpNode.error 'Class bodies cannot contain pure statements'
|
||
if argumentsNode = @body.contains isLiteralArguments
|
||
argumentsNode.error "Class bodies shouldn't reference arguments"
|
||
|
||
params = []
|
||
args = [new ThisLiteral]
|
||
wrapper = new Code params, @body
|
||
klass = new Parens new Call (new Value wrapper, [new Access new PropertyName 'call']), args
|
||
|
||
@body.spaced = true
|
||
|
||
o.classScope = wrapper.makeScope o.scope
|
||
|
||
@name = @class.name ? o.classScope.freeVariable @defaultClassVariableName
|
||
ident = new IdentifierLiteral @name
|
||
directives = @walkBody()
|
||
@setContext()
|
||
|
||
if @class.hasNameClash
|
||
parent = new IdentifierLiteral o.classScope.freeVariable 'superClass'
|
||
wrapper.params.push new Param parent
|
||
args.push @class.parent
|
||
@class.parent = parent
|
||
|
||
if @externalCtor
|
||
externalCtor = new IdentifierLiteral o.classScope.freeVariable 'ctor', reserve: no
|
||
@class.externalCtor = externalCtor
|
||
@externalCtor.variable.base = externalCtor
|
||
|
||
if @name isnt @class.name
|
||
@body.expressions.unshift new Assign (new IdentifierLiteral @name), @class
|
||
else
|
||
@body.expressions.unshift @class
|
||
@body.expressions.unshift directives...
|
||
@body.push ident
|
||
|
||
klass.compileToFragments o
|
||
|
||
# Traverse the class's children and:
|
||
# - Hoist valid ES properties into `@properties`
|
||
# - Hoist static assignments into `@properties`
|
||
# - Convert invalid ES properties into class or prototype assignments
|
||
walkBody: ->
|
||
directives = []
|
||
|
||
index = 0
|
||
while expr = @body.expressions[index]
|
||
break unless expr instanceof Value and expr.isString()
|
||
if expr.hoisted
|
||
index++
|
||
else
|
||
directives.push @body.expressions.splice(index, 1)...
|
||
|
||
@traverseChildren false, (child) =>
|
||
return false if child instanceof Class or child instanceof HoistTarget
|
||
|
||
cont = true
|
||
if child instanceof Block
|
||
for node, i in child.expressions
|
||
if node instanceof Value and node.isObject(true)
|
||
cont = false
|
||
child.expressions[i] = @addProperties node.base.properties
|
||
else if node instanceof Assign and node.variable.looksStatic @name
|
||
node.value.isStatic = yes
|
||
child.expressions = flatten child.expressions
|
||
cont
|
||
|
||
directives
|
||
|
||
setContext: ->
|
||
@body.traverseChildren false, (node) =>
|
||
if node instanceof ThisLiteral
|
||
node.value = @name
|
||
else if node instanceof Code and node.bound and (node.isStatic or not node.name)
|
||
node.context = @name
|
||
|
||
# Make class/prototype assignments for invalid ES properties
|
||
addProperties: (assigns) ->
|
||
result = for assign in assigns
|
||
variable = assign.variable
|
||
base = variable?.base
|
||
value = assign.value
|
||
delete assign.context
|
||
|
||
if base.value is 'constructor'
|
||
if value instanceof Code
|
||
base.error 'constructors must be defined at the top level of a class body'
|
||
|
||
# The class scope is not available yet, so return the assignment to update later
|
||
assign = @externalCtor = new Assign new Value, value
|
||
else if not assign.variable.this
|
||
name =
|
||
if base instanceof ComputedPropertyName
|
||
new Index base.value
|
||
else
|
||
new (if base.shouldCache() then Index else Access) base
|
||
prototype = new Access new PropertyName 'prototype'
|
||
variable = new Value new ThisLiteral(), [ prototype, name ]
|
||
|
||
assign.variable = variable
|
||
else if assign.value instanceof Code
|
||
assign.value.isStatic = true
|
||
|
||
assign
|
||
compact result
|
||
|
||
exports.ClassProperty = class ClassProperty extends Base
|
||
constructor: ({@name, @isStatic, @staticClassName, @value, @operatorToken}) ->
|
||
super()
|
||
|
||
children: ['name', 'value', 'staticClassName']
|
||
|
||
isStatement: YES
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
key: @name.ast o, LEVEL_LIST
|
||
value: @value.ast o, LEVEL_LIST
|
||
static: !!@isStatic
|
||
computed: @name instanceof Index or @name instanceof ComputedPropertyName
|
||
operator: @operatorToken?.value ? '='
|
||
staticClassName: @staticClassName?.ast(o) ? null
|
||
|
||
exports.ClassPrototypeProperty = class ClassPrototypeProperty extends Base
|
||
constructor: ({@name, @value}) ->
|
||
super()
|
||
|
||
children: ['name', 'value']
|
||
|
||
isStatement: YES
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
key: @name.ast o, LEVEL_LIST
|
||
value: @value.ast o, LEVEL_LIST
|
||
computed: @name instanceof ComputedPropertyName or @name instanceof StringWithInterpolations
|
||
|
||
#### Import and Export
|
||
|
||
exports.ModuleDeclaration = class ModuleDeclaration extends Base
|
||
constructor: (@clause, @source, @assertions) ->
|
||
super()
|
||
@checkSource()
|
||
|
||
children: ['clause', 'source', 'assertions']
|
||
|
||
isStatement: YES
|
||
jumps: THIS
|
||
makeReturn: THIS
|
||
|
||
checkSource: ->
|
||
if @source? and @source instanceof StringWithInterpolations
|
||
@source.error 'the name of the module to be imported from must be an uninterpolated string'
|
||
|
||
checkScope: (o, moduleDeclarationType) ->
|
||
# TODO: would be appropriate to flag this error during AST generation (as
|
||
# well as when compiling to JS). But `o.indent` isn’t tracked during AST
|
||
# generation, and there doesn’t seem to be a current alternative way to track
|
||
# whether we’re at the “program top-level”.
|
||
if o.indent.length isnt 0
|
||
@error "#{moduleDeclarationType} statements must be at top-level scope"
|
||
|
||
astAssertions: (o) ->
|
||
if @assertions?.properties?
|
||
@assertions.properties.map (assertion) =>
|
||
{ start, end, loc, left, right } = assertion.ast(o)
|
||
{ type: 'ImportAttribute', start, end, loc, key: left, value: right }
|
||
else
|
||
[]
|
||
|
||
exports.ImportDeclaration = class ImportDeclaration extends ModuleDeclaration
|
||
compileNode: (o) ->
|
||
@checkScope o, 'import'
|
||
o.importedSymbols = []
|
||
|
||
code = []
|
||
code.push @makeCode "#{@tab}import "
|
||
code.push @clause.compileNode(o)... if @clause?
|
||
|
||
if @source?.value?
|
||
code.push @makeCode ' from ' unless @clause is null
|
||
code.push @makeCode @source.value
|
||
if @assertions?
|
||
code.push @makeCode ' assert '
|
||
code.push @assertions.compileToFragments(o)...
|
||
|
||
code.push @makeCode ';'
|
||
code
|
||
|
||
astNode: (o) ->
|
||
o.importedSymbols = []
|
||
super o
|
||
|
||
astProperties: (o) ->
|
||
ret =
|
||
specifiers: @clause?.ast(o) ? []
|
||
source: @source.ast o
|
||
assertions: @astAssertions(o)
|
||
ret.importKind = 'value' if @clause
|
||
ret
|
||
|
||
exports.ImportClause = class ImportClause extends Base
|
||
constructor: (@defaultBinding, @namedImports) ->
|
||
super()
|
||
|
||
children: ['defaultBinding', 'namedImports']
|
||
|
||
compileNode: (o) ->
|
||
code = []
|
||
|
||
if @defaultBinding?
|
||
code.push @defaultBinding.compileNode(o)...
|
||
code.push @makeCode ', ' if @namedImports?
|
||
|
||
if @namedImports?
|
||
code.push @namedImports.compileNode(o)...
|
||
|
||
code
|
||
|
||
astNode: (o) ->
|
||
# The AST for `ImportClause` is the non-nested list of import specifiers
|
||
# that will be the `specifiers` property of an `ImportDeclaration` AST
|
||
compact flatten [
|
||
@defaultBinding?.ast o
|
||
@namedImports?.ast o
|
||
]
|
||
|
||
exports.ExportDeclaration = class ExportDeclaration extends ModuleDeclaration
|
||
compileNode: (o) ->
|
||
@checkScope o, 'export'
|
||
@checkForAnonymousClassExport()
|
||
|
||
code = []
|
||
code.push @makeCode "#{@tab}export "
|
||
code.push @makeCode 'default ' if @ instanceof ExportDefaultDeclaration
|
||
|
||
if @ not instanceof ExportDefaultDeclaration and
|
||
(@clause instanceof Assign or @clause instanceof Class)
|
||
code.push @makeCode 'var '
|
||
@clause.moduleDeclaration = 'export'
|
||
|
||
if @clause.body? and @clause.body instanceof Block
|
||
code = code.concat @clause.compileToFragments o, LEVEL_TOP
|
||
else
|
||
code = code.concat @clause.compileNode o
|
||
|
||
if @source?.value?
|
||
code.push @makeCode " from #{@source.value}"
|
||
if @assertions?
|
||
code.push @makeCode ' assert '
|
||
code.push @assertions.compileToFragments(o)...
|
||
|
||
code.push @makeCode ';'
|
||
code
|
||
|
||
# Prevent exporting an anonymous class; all exported members must be named
|
||
checkForAnonymousClassExport: ->
|
||
if @ not instanceof ExportDefaultDeclaration and @clause instanceof Class and not @clause.variable
|
||
@clause.error 'anonymous classes cannot be exported'
|
||
|
||
astNode: (o) ->
|
||
@checkForAnonymousClassExport()
|
||
super o
|
||
|
||
exports.ExportNamedDeclaration = class ExportNamedDeclaration extends ExportDeclaration
|
||
astProperties: (o) ->
|
||
ret =
|
||
source: @source?.ast(o) ? null
|
||
assertions: @astAssertions(o)
|
||
exportKind: 'value'
|
||
clauseAst = @clause.ast o
|
||
if @clause instanceof ExportSpecifierList
|
||
ret.specifiers = clauseAst
|
||
ret.declaration = null
|
||
else
|
||
ret.specifiers = []
|
||
ret.declaration = clauseAst
|
||
ret
|
||
|
||
exports.ExportDefaultDeclaration = class ExportDefaultDeclaration extends ExportDeclaration
|
||
astProperties: (o) ->
|
||
return
|
||
declaration: @clause.ast o
|
||
assertions: @astAssertions(o)
|
||
|
||
exports.ExportAllDeclaration = class ExportAllDeclaration extends ExportDeclaration
|
||
astProperties: (o) ->
|
||
return
|
||
source: @source.ast o
|
||
assertions: @astAssertions(o)
|
||
exportKind: 'value'
|
||
|
||
exports.ModuleSpecifierList = class ModuleSpecifierList extends Base
|
||
constructor: (@specifiers) ->
|
||
super()
|
||
|
||
children: ['specifiers']
|
||
|
||
compileNode: (o) ->
|
||
code = []
|
||
o.indent += TAB
|
||
compiledList = (specifier.compileToFragments o, LEVEL_LIST for specifier in @specifiers)
|
||
|
||
if @specifiers.length isnt 0
|
||
code.push @makeCode "{\n#{o.indent}"
|
||
for fragments, index in compiledList
|
||
code.push @makeCode(",\n#{o.indent}") if index
|
||
code.push fragments...
|
||
code.push @makeCode "\n}"
|
||
else
|
||
code.push @makeCode '{}'
|
||
code
|
||
|
||
astNode: (o) ->
|
||
specifier.ast(o) for specifier in @specifiers
|
||
|
||
exports.ImportSpecifierList = class ImportSpecifierList extends ModuleSpecifierList
|
||
|
||
exports.ExportSpecifierList = class ExportSpecifierList extends ModuleSpecifierList
|
||
|
||
exports.ModuleSpecifier = class ModuleSpecifier extends Base
|
||
constructor: (@original, @alias, @moduleDeclarationType) ->
|
||
super()
|
||
|
||
if @original.comments or @alias?.comments
|
||
@comments = []
|
||
@comments.push @original.comments... if @original.comments
|
||
@comments.push @alias.comments... if @alias?.comments
|
||
|
||
# The name of the variable entering the local scope
|
||
@identifier = if @alias? then @alias.value else @original.value
|
||
|
||
children: ['original', 'alias']
|
||
|
||
compileNode: (o) ->
|
||
@addIdentifierToScope o
|
||
code = []
|
||
code.push @makeCode @original.value
|
||
code.push @makeCode " as #{@alias.value}" if @alias?
|
||
code
|
||
|
||
addIdentifierToScope: (o) ->
|
||
o.scope.find @identifier, @moduleDeclarationType
|
||
|
||
astNode: (o) ->
|
||
@addIdentifierToScope o
|
||
super o
|
||
|
||
exports.ImportSpecifier = class ImportSpecifier extends ModuleSpecifier
|
||
constructor: (imported, local) ->
|
||
super imported, local, 'import'
|
||
|
||
addIdentifierToScope: (o) ->
|
||
# Per the spec, symbols can’t be imported multiple times
|
||
# (e.g. `import { foo, foo } from 'lib'` is invalid)
|
||
if @identifier in o.importedSymbols or o.scope.check(@identifier)
|
||
@error "'#{@identifier}' has already been declared"
|
||
else
|
||
o.importedSymbols.push @identifier
|
||
super o
|
||
|
||
astProperties: (o) ->
|
||
originalAst = @original.ast o
|
||
return
|
||
imported: originalAst
|
||
local: @alias?.ast(o) ? originalAst
|
||
importKind: null
|
||
|
||
exports.ImportDefaultSpecifier = class ImportDefaultSpecifier extends ImportSpecifier
|
||
astProperties: (o) ->
|
||
return
|
||
local: @original.ast o
|
||
|
||
exports.ImportNamespaceSpecifier = class ImportNamespaceSpecifier extends ImportSpecifier
|
||
astProperties: (o) ->
|
||
return
|
||
local: @alias.ast o
|
||
|
||
exports.ExportSpecifier = class ExportSpecifier extends ModuleSpecifier
|
||
constructor: (local, exported) ->
|
||
super local, exported, 'export'
|
||
|
||
astProperties: (o) ->
|
||
originalAst = @original.ast o
|
||
return
|
||
local: originalAst
|
||
exported: @alias?.ast(o) ? originalAst
|
||
|
||
exports.DynamicImport = class DynamicImport extends Base
|
||
compileNode: ->
|
||
[@makeCode 'import']
|
||
|
||
astType: -> 'Import'
|
||
|
||
exports.DynamicImportCall = class DynamicImportCall extends Call
|
||
compileNode: (o) ->
|
||
@checkArguments()
|
||
super o
|
||
|
||
checkArguments: ->
|
||
unless 1 <= @args.length <= 2
|
||
@error 'import() accepts either one or two arguments'
|
||
|
||
astNode: (o) ->
|
||
@checkArguments()
|
||
super 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 = {}) ->
|
||
super()
|
||
{@param, @subpattern, @operatorToken, @moduleDeclaration, @originalContext = @context} = options
|
||
@propagateLhs()
|
||
|
||
children: ['variable', 'value']
|
||
|
||
isAssignable: YES
|
||
|
||
isStatement: (o) ->
|
||
o?.level is LEVEL_TOP and @context? and (@moduleDeclaration or "?" in @context)
|
||
|
||
checkNameAssignability: (o, varBase) ->
|
||
if o.scope.type(varBase.value) is 'import'
|
||
varBase.error "'#{varBase.value}' is read-only"
|
||
|
||
assigns: (name) ->
|
||
@[if @context is 'object' then 'value' else 'variable'].assigns name
|
||
|
||
unfoldSoak: (o) ->
|
||
unfoldSoak o, this, 'variable'
|
||
|
||
addScopeVariables: (o, {
|
||
# During AST generation, we need to allow assignment to these constructs
|
||
# that are considered “unassignable” during compile-to-JS, while still
|
||
# flagging things like `[null] = b`.
|
||
allowAssignmentToExpansion = no,
|
||
allowAssignmentToNontrailingSplat = no,
|
||
allowAssignmentToEmptyArray = no,
|
||
allowAssignmentToComplexSplat = no
|
||
} = {}) ->
|
||
return unless not @context or @context is '**='
|
||
|
||
varBase = @variable.unwrapAll()
|
||
if not varBase.isAssignable {
|
||
allowExpansion: allowAssignmentToExpansion
|
||
allowNontrailingSplat: allowAssignmentToNontrailingSplat
|
||
allowEmptyArray: allowAssignmentToEmptyArray
|
||
allowComplexSplat: allowAssignmentToComplexSplat
|
||
}
|
||
@variable.error "'#{@variable.compile o}' can't be assigned"
|
||
|
||
varBase.eachName (name) =>
|
||
return if name.hasProperties?()
|
||
|
||
message = isUnassignable name.value
|
||
name.error message if message
|
||
|
||
# `moduleDeclaration` can be `'import'` or `'export'`.
|
||
@checkNameAssignability o, name
|
||
if @moduleDeclaration
|
||
o.scope.add name.value, @moduleDeclaration
|
||
name.isDeclaration = yes
|
||
else if @param
|
||
o.scope.add name.value,
|
||
if @param is 'alwaysDeclare'
|
||
'var'
|
||
else
|
||
'param'
|
||
else
|
||
alreadyDeclared = o.scope.find name.value
|
||
name.isDeclaration ?= not alreadyDeclared
|
||
# If this assignment identifier has one or more herecomments
|
||
# attached, output them as part of the declarations line (unless
|
||
# other herecomments are already staged there) for compatibility
|
||
# with Flow typing. Don’t do this if this assignment is for a
|
||
# class, e.g. `ClassName = class ClassName {`, as Flow requires
|
||
# the comment to be between the class name and the `{`.
|
||
if name.comments and not o.scope.comments[name.value] and
|
||
@value not instanceof Class and
|
||
name.comments.every((comment) -> comment.here and not comment.multiline)
|
||
commentsNode = new IdentifierLiteral name.value
|
||
commentsNode.comments = name.comments
|
||
commentFragments = []
|
||
@compileCommentFragments o, commentsNode, commentFragments
|
||
o.scope.comments[name.value] = commentFragments
|
||
|
||
# Compile an assignment, delegating to `compileDestructuring` 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) ->
|
||
isValue = @variable instanceof Value
|
||
if isValue
|
||
# If `@variable` is an array or an object, we’re destructuring;
|
||
# if it’s also `isAssignable()`, the destructuring syntax is supported
|
||
# in ES and we can output it as is; otherwise we `@compileDestructuring`
|
||
# and convert this ES-unsupported destructuring into acceptable output.
|
||
if @variable.isArray() or @variable.isObject()
|
||
unless @variable.isAssignable()
|
||
if @variable.isObject() and @variable.base.hasSplat()
|
||
return @compileObjectDestruct o
|
||
else
|
||
return @compileDestructuring o
|
||
|
||
return @compileSplice o if @variable.isSplice()
|
||
return @compileConditional o if @isConditional()
|
||
return @compileSpecialMath o if @context in ['//=', '%%=']
|
||
|
||
@addScopeVariables o
|
||
if @value instanceof Code
|
||
if @value.isStatic
|
||
@value.name = @variable.properties[0]
|
||
else if @variable.properties?.length >= 2
|
||
[properties..., prototype, name] = @variable.properties
|
||
@value.name = name if prototype.name?.value is 'prototype'
|
||
|
||
val = @value.compileToFragments o, LEVEL_LIST
|
||
compiledName = @variable.compileToFragments o, LEVEL_LIST
|
||
|
||
if @context is 'object'
|
||
if @variable.shouldCache()
|
||
compiledName.unshift @makeCode '['
|
||
compiledName.push @makeCode ']'
|
||
return compiledName.concat @makeCode(': '), val
|
||
|
||
answer = compiledName.concat @makeCode(" #{ @context or '=' } "), val
|
||
# Per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Assignment_without_declaration,
|
||
# if we’re destructuring without declaring, the destructuring assignment must be wrapped in parentheses.
|
||
# The assignment is wrapped in parentheses if 'o.level' has lower precedence than LEVEL_LIST (3)
|
||
# (i.e. LEVEL_COND (4), LEVEL_OP (5) or LEVEL_ACCESS (6)), or if we're destructuring object, e.g. {a,b} = obj.
|
||
if o.level > LEVEL_LIST or isValue and @variable.base instanceof Obj and not @nestedLhs and not (@param is yes)
|
||
@wrapInParentheses answer
|
||
else
|
||
answer
|
||
|
||
# Object rest property is not assignable: `{{a}...}`
|
||
compileObjectDestruct: (o) ->
|
||
@variable.base.reorderProperties()
|
||
{properties: props} = @variable.base
|
||
[..., splat] = props
|
||
splatProp = splat.name
|
||
assigns = []
|
||
refVal = new Value new IdentifierLiteral o.scope.freeVariable 'ref'
|
||
props.splice -1, 1, new Splat refVal
|
||
assigns.push new Assign(new Value(new Obj props), @value).compileToFragments o, LEVEL_LIST
|
||
assigns.push new Assign(new Value(splatProp), refVal).compileToFragments o, LEVEL_LIST
|
||
@joinFragmentArrays assigns, ', '
|
||
|
||
# Brief implementation of recursive pattern matching, when assigning array or
|
||
# object literals to a value. Peeks at their properties to assign inner names.
|
||
compileDestructuring: (o) ->
|
||
top = o.level is LEVEL_TOP
|
||
{value} = this
|
||
{objects} = @variable.base
|
||
olen = objects.length
|
||
|
||
# Special-case for `{} = a` and `[] = a` (empty patterns).
|
||
# Compile to simply `a`.
|
||
if olen is 0
|
||
code = value.compileToFragments o
|
||
return if o.level >= LEVEL_OP then @wrapInParentheses code else code
|
||
[obj] = objects
|
||
|
||
@disallowLoneExpansion()
|
||
{splats, expans, splatsAndExpans} = @getAndCheckSplatsAndExpansions()
|
||
|
||
isSplat = splats?.length > 0
|
||
isExpans = expans?.length > 0
|
||
|
||
vvar = value.compileToFragments o, LEVEL_LIST
|
||
vvarText = fragmentsToText vvar
|
||
assigns = []
|
||
pushAssign = (variable, val) =>
|
||
assigns.push new Assign(variable, val, null, param: @param, subpattern: yes).compileToFragments o, LEVEL_LIST
|
||
|
||
if isSplat
|
||
splatVar = objects[splats[0]].name.unwrap()
|
||
if splatVar instanceof Arr or splatVar instanceof Obj
|
||
splatVarRef = new IdentifierLiteral o.scope.freeVariable 'ref'
|
||
objects[splats[0]].name = splatVarRef
|
||
splatVarAssign = -> pushAssign new Value(splatVar), splatVarRef
|
||
|
||
# At this point, there are several things to destructure. So the `fn()` in
|
||
# `{a, b} = fn()` must be cached, for example. Make vvar into a simple
|
||
# variable if it isn’t already.
|
||
if value.unwrap() not instanceof IdentifierLiteral or @variable.assigns(vvarText)
|
||
ref = o.scope.freeVariable 'ref'
|
||
assigns.push [@makeCode(ref + ' = '), vvar...]
|
||
vvar = [@makeCode ref]
|
||
vvarText = ref
|
||
|
||
slicer = (type) -> (vvar, start, end = no) ->
|
||
vvar = new IdentifierLiteral vvar unless vvar instanceof Value
|
||
args = [vvar, new NumberLiteral(start)]
|
||
args.push new NumberLiteral end if end
|
||
slice = new Value (new IdentifierLiteral utility type, o), [new Access new PropertyName 'call']
|
||
new Value new Call slice, args
|
||
|
||
# Helper which outputs `[].slice` code.
|
||
compSlice = slicer "slice"
|
||
|
||
# Helper which outputs `[].splice` code.
|
||
compSplice = slicer "splice"
|
||
|
||
# Check if `objects` array contains any instance of `Assign`, e.g. {a:1}.
|
||
hasObjAssigns = (objs) ->
|
||
(i for obj, i in objs when obj instanceof Assign and obj.context is 'object')
|
||
|
||
# Check if `objects` array contains any unassignable object.
|
||
objIsUnassignable = (objs) ->
|
||
return yes for obj in objs when not obj.isAssignable()
|
||
no
|
||
|
||
# `objects` are complex when there is object assign ({a:1}),
|
||
# unassignable object, or just a single node.
|
||
complexObjects = (objs) ->
|
||
hasObjAssigns(objs).length or objIsUnassignable(objs) or olen is 1
|
||
|
||
# "Complex" `objects` are processed in a loop.
|
||
# Examples: [a, b, {c, r...}, d], [a, ..., {b, r...}, c, d]
|
||
loopObjects = (objs, vvar, vvarTxt) =>
|
||
for obj, i in objs
|
||
# `Elision` can be skipped.
|
||
continue if obj instanceof Elision
|
||
# If `obj` is {a: 1}
|
||
if obj instanceof Assign and obj.context is 'object'
|
||
{variable: {base: idx}, value: vvar} = obj
|
||
{variable: vvar} = vvar if vvar instanceof Assign
|
||
idx =
|
||
if vvar.this
|
||
vvar.properties[0].name
|
||
else
|
||
new PropertyName vvar.unwrap().value
|
||
acc = idx.unwrap() instanceof PropertyName
|
||
vval = new Value value, [new (if acc then Access else Index) idx]
|
||
else
|
||
# `obj` is [a...], {a...} or a
|
||
vvar = switch
|
||
when obj instanceof Splat then new Value obj.name
|
||
else obj
|
||
vval = switch
|
||
when obj instanceof Splat then compSlice(vvarTxt, i)
|
||
else new Value new Literal(vvarTxt), [new Index new NumberLiteral i]
|
||
message = isUnassignable vvar.unwrap().value
|
||
vvar.error message if message
|
||
pushAssign vvar, vval
|
||
|
||
# "Simple" `objects` can be split and compiled to arrays, [a, b, c] = arr, [a, b, c...] = arr
|
||
assignObjects = (objs, vvar, vvarTxt) =>
|
||
vvar = new Value new Arr(objs, yes)
|
||
vval = if vvarTxt instanceof Value then vvarTxt else new Value new Literal(vvarTxt)
|
||
pushAssign vvar, vval
|
||
|
||
processObjects = (objs, vvar, vvarTxt) ->
|
||
if complexObjects objs
|
||
loopObjects objs, vvar, vvarTxt
|
||
else
|
||
assignObjects objs, vvar, vvarTxt
|
||
|
||
# In case there is `Splat` or `Expansion` in `objects`,
|
||
# we can split array in two simple subarrays.
|
||
# `Splat` [a, b, c..., d, e] can be split into [a, b, c...] and [d, e].
|
||
# `Expansion` [a, b, ..., c, d] can be split into [a, b] and [c, d].
|
||
# Examples:
|
||
# a) `Splat`
|
||
# CS: [a, b, c..., d, e] = arr
|
||
# JS: [a, b, ...c] = arr, [d, e] = splice.call(c, -2)
|
||
# b) `Expansion`
|
||
# CS: [a, b, ..., d, e] = arr
|
||
# JS: [a, b] = arr, [d, e] = slice.call(arr, -2)
|
||
if splatsAndExpans.length
|
||
expIdx = splatsAndExpans[0]
|
||
leftObjs = objects.slice 0, expIdx + (if isSplat then 1 else 0)
|
||
rightObjs = objects.slice expIdx + 1
|
||
processObjects leftObjs, vvar, vvarText if leftObjs.length isnt 0
|
||
if rightObjs.length isnt 0
|
||
# Slice or splice `objects`.
|
||
refExp = switch
|
||
when isSplat then compSplice new Value(objects[expIdx].name), rightObjs.length * -1
|
||
when isExpans then compSlice vvarText, rightObjs.length * -1
|
||
if complexObjects rightObjs
|
||
restVar = refExp
|
||
refExp = o.scope.freeVariable 'ref'
|
||
assigns.push [@makeCode(refExp + ' = '), restVar.compileToFragments(o, LEVEL_LIST)...]
|
||
processObjects rightObjs, vvar, refExp
|
||
else
|
||
# There is no `Splat` or `Expansion` in `objects`.
|
||
processObjects objects, vvar, vvarText
|
||
splatVarAssign?()
|
||
assigns.push vvar unless top or @subpattern
|
||
fragments = @joinFragmentArrays assigns, ', '
|
||
if o.level < LEVEL_LIST then fragments else @wrapInParentheses fragments
|
||
|
||
# Disallow `[...] = a` for some reason. (Could be equivalent to `[] = a`?)
|
||
disallowLoneExpansion: ->
|
||
return unless @variable.base instanceof Arr
|
||
{objects} = @variable.base
|
||
return unless objects?.length is 1
|
||
[loneObject] = objects
|
||
if loneObject instanceof Expansion
|
||
loneObject.error 'Destructuring assignment has no target'
|
||
|
||
# Show error if there is more than one `Splat`, or `Expansion`.
|
||
# Examples: [a, b, c..., d, e, f...], [a, b, ..., c, d, ...], [a, b, ..., c, d, e...]
|
||
getAndCheckSplatsAndExpansions: ->
|
||
return {splats: [], expans: [], splatsAndExpans: []} unless @variable.base instanceof Arr
|
||
{objects} = @variable.base
|
||
|
||
# Count all `Splats`: [a, b, c..., d, e]
|
||
splats = (i for obj, i in objects when obj instanceof Splat)
|
||
# Count all `Expansions`: [a, b, ..., c, d]
|
||
expans = (i for obj, i in objects when obj instanceof Expansion)
|
||
# Combine splats and expansions.
|
||
splatsAndExpans = [splats..., expans...]
|
||
if splatsAndExpans.length > 1
|
||
# Sort 'splatsAndExpans' so we can show error at first disallowed token.
|
||
objects[splatsAndExpans.sort()[1]].error "multiple splats/expansions are disallowed in an assignment"
|
||
{splats, expans, splatsAndExpans}
|
||
|
||
# When compiling a conditional assignment, take care to ensure that the
|
||
# operands are only evaluated once, even though we have to reference them
|
||
# more than once.
|
||
compileConditional: (o) ->
|
||
[left, right] = @variable.cacheReference o
|
||
# Disallow conditional assignment of undefined variables.
|
||
if not left.properties.length and left.base instanceof Literal and
|
||
left.base not instanceof ThisLiteral and not o.scope.check left.base.value
|
||
@throwUnassignableConditionalError left.base.value
|
||
if "?" in @context
|
||
o.isExistentialEquals = true
|
||
new If(new Existence(left), right, type: 'if').addElse(new Assign(right, @value, '=')).compileToFragments o
|
||
else
|
||
fragments = new Op(@context[...-1], left, new Assign(right, @value, '=')).compileToFragments o
|
||
if o.level <= LEVEL_LIST then fragments else @wrapInParentheses fragments
|
||
|
||
# Convert special math assignment operators like `a //= b` to the equivalent
|
||
# extended form `a = a ** b` and then compiles that.
|
||
compileSpecialMath: (o) ->
|
||
[left, right] = @variable.cacheReference o
|
||
new Assign(left, new Op(@context[...-1], right, @value)).compileToFragments o
|
||
|
||
# Compile the assignment from an array splice literal, using JavaScript's
|
||
# `Array#splice` method.
|
||
compileSplice: (o) ->
|
||
{range: {from, to, exclusive}} = @variable.properties.pop()
|
||
unwrappedVar = @variable.unwrapAll()
|
||
if unwrappedVar.comments
|
||
moveComments unwrappedVar, @
|
||
delete @variable.comments
|
||
name = @variable.compile o
|
||
if from
|
||
[fromDecl, fromRef] = @cacheToCodeFragments from.cache o, LEVEL_OP
|
||
else
|
||
fromDecl = fromRef = '0'
|
||
if to
|
||
if from?.isNumber() and to.isNumber()
|
||
to = to.compile(o) - fromRef
|
||
to += 1 unless exclusive
|
||
else
|
||
to = to.compile(o, LEVEL_ACCESS) + ' - ' + fromRef
|
||
to += ' + 1' unless exclusive
|
||
else
|
||
to = "9e9"
|
||
[valDef, valRef] = @value.cache o, LEVEL_LIST
|
||
answer = [].concat @makeCode("#{utility 'splice', o}.apply(#{name}, [#{fromDecl}, #{to}].concat("), valDef, @makeCode(")), "), valRef
|
||
if o.level > LEVEL_TOP then @wrapInParentheses answer else answer
|
||
|
||
eachName: (iterator) ->
|
||
@variable.unwrapAll().eachName iterator
|
||
|
||
isDefaultAssignment: -> @param or @nestedLhs
|
||
|
||
propagateLhs: ->
|
||
return unless @variable?.isArray?() or @variable?.isObject?()
|
||
# This is the left-hand side of an assignment; let `Arr` and `Obj`
|
||
# know that, so that those nodes know that they’re assignable as
|
||
# destructured variables.
|
||
@variable.base.propagateLhs yes
|
||
|
||
throwUnassignableConditionalError: (name) ->
|
||
@variable.error "the variable \"#{name}\" can't be assigned with #{@context} because it has not been declared before"
|
||
|
||
isConditional: ->
|
||
@context in ['||=', '&&=', '?=']
|
||
|
||
isStatementAst: NO
|
||
|
||
astNode: (o) ->
|
||
@disallowLoneExpansion()
|
||
@getAndCheckSplatsAndExpansions()
|
||
if @isConditional()
|
||
variable = @variable.unwrap()
|
||
if variable instanceof IdentifierLiteral and not o.scope.check variable.value
|
||
@throwUnassignableConditionalError variable.value
|
||
@addScopeVariables o, allowAssignmentToExpansion: yes, allowAssignmentToNontrailingSplat: yes, allowAssignmentToEmptyArray: yes, allowAssignmentToComplexSplat: yes
|
||
super o
|
||
|
||
astType: ->
|
||
if @isDefaultAssignment()
|
||
'AssignmentPattern'
|
||
else
|
||
'AssignmentExpression'
|
||
|
||
astProperties: (o) ->
|
||
ret =
|
||
right: @value.ast o, LEVEL_LIST
|
||
left: @variable.ast o, LEVEL_LIST
|
||
|
||
unless @isDefaultAssignment()
|
||
ret.operator = @originalContext ? '='
|
||
|
||
ret
|
||
|
||
#### FuncGlyph
|
||
|
||
exports.FuncGlyph = class FuncGlyph extends Base
|
||
constructor: (@glyph) ->
|
||
super()
|
||
|
||
#### Code
|
||
|
||
# A function definition. This is the only node that creates a new Scope.
|
||
# When for the purposes of walking the contents of a function body, the Code
|
||
# has no *children* -- they're within the inner scope.
|
||
exports.Code = class Code extends Base
|
||
constructor: (params, body, @funcGlyph, @paramStart) ->
|
||
super()
|
||
|
||
@params = params or []
|
||
@body = body or new Block
|
||
@bound = @funcGlyph?.glyph is '=>'
|
||
@isGenerator = no
|
||
@isAsync = no
|
||
@isMethod = no
|
||
|
||
@body.traverseChildren no, (node) =>
|
||
if (node instanceof Op and node.isYield()) or node instanceof YieldReturn
|
||
@isGenerator = yes
|
||
if (node instanceof Op and node.isAwait()) or node instanceof AwaitReturn
|
||
@isAsync = yes
|
||
if node instanceof For and node.isAwait()
|
||
@isAsync = yes
|
||
|
||
@propagateLhs()
|
||
|
||
children: ['params', 'body']
|
||
|
||
isStatement: -> @isMethod
|
||
|
||
jumps: NO
|
||
|
||
makeScope: (parentScope) -> new Scope parentScope, @body, this
|
||
|
||
# Compilation creates a new scope unless explicitly asked to share with the
|
||
# outer scope. Handles splat parameters in the parameter list by setting
|
||
# such parameters to be the final parameter in the function definition, as
|
||
# required per the ES2015 spec. If the CoffeeScript function definition had
|
||
# parameters after the splat, they are declared via expressions in the
|
||
# function body.
|
||
compileNode: (o) ->
|
||
@checkForAsyncOrGeneratorConstructor()
|
||
|
||
if @bound
|
||
@context = o.scope.method.context if o.scope.method?.bound
|
||
@context = 'this' unless @context
|
||
|
||
@updateOptions o
|
||
params = []
|
||
exprs = []
|
||
thisAssignments = @thisAssignments?.slice() ? []
|
||
paramsAfterSplat = []
|
||
haveSplatParam = no
|
||
haveBodyParam = no
|
||
|
||
@checkForDuplicateParams()
|
||
@disallowLoneExpansionAndMultipleSplats()
|
||
|
||
# Separate `this` assignments.
|
||
@eachParamName (name, node, param, obj) ->
|
||
if node.this
|
||
name = node.properties[0].name.value
|
||
name = "_#{name}" if name in JS_FORBIDDEN
|
||
target = new IdentifierLiteral o.scope.freeVariable name, reserve: no
|
||
# `Param` is object destructuring with a default value: ({@prop = 1}) ->
|
||
# In a case when the variable name is already reserved, we have to assign
|
||
# a new variable name to the destructured variable: ({prop:prop1 = 1}) ->
|
||
replacement =
|
||
if param.name instanceof Obj and obj instanceof Assign and
|
||
obj.operatorToken.value is '='
|
||
new Assign (new IdentifierLiteral name), target, 'object' #, operatorToken: new Literal ':'
|
||
else
|
||
target
|
||
param.renameParam node, replacement
|
||
thisAssignments.push new Assign node, target
|
||
|
||
# Parse the parameters, adding them to the list of parameters to put in the
|
||
# function definition; and dealing with splats or expansions, including
|
||
# adding expressions to the function body to declare all parameter
|
||
# variables that would have been after the splat/expansion parameter.
|
||
# If we encounter a parameter that needs to be declared in the function
|
||
# body for any reason, for example it’s destructured with `this`, also
|
||
# declare and assign all subsequent parameters in the function body so that
|
||
# any non-idempotent parameters are evaluated in the correct order.
|
||
for param, i in @params
|
||
# Was `...` used with this parameter? Splat/expansion parameters cannot
|
||
# have default values, so we need not worry about that.
|
||
if param.splat or param instanceof Expansion
|
||
haveSplatParam = yes
|
||
if param.splat
|
||
if param.name instanceof Arr or param.name instanceof Obj
|
||
# Splat arrays are treated oddly by ES; deal with them the legacy
|
||
# way in the function body. TODO: Should this be handled in the
|
||
# function parameter list, and if so, how?
|
||
splatParamName = o.scope.freeVariable 'arg'
|
||
params.push ref = new Value new IdentifierLiteral splatParamName
|
||
exprs.push new Assign new Value(param.name), ref
|
||
else
|
||
params.push ref = param.asReference o
|
||
splatParamName = fragmentsToText ref.compileNodeWithoutComments o
|
||
if param.shouldCache()
|
||
exprs.push new Assign new Value(param.name), ref
|
||
else # `param` is an Expansion
|
||
splatParamName = o.scope.freeVariable 'args'
|
||
params.push new Value new IdentifierLiteral splatParamName
|
||
|
||
o.scope.parameter splatParamName
|
||
|
||
# Parse all other parameters; if a splat paramater has not yet been
|
||
# encountered, add these other parameters to the list to be output in
|
||
# the function definition.
|
||
else
|
||
if param.shouldCache() or haveBodyParam
|
||
param.assignedInBody = yes
|
||
haveBodyParam = yes
|
||
# This parameter cannot be declared or assigned in the parameter
|
||
# list. So put a reference in the parameter list and add a statement
|
||
# to the function body assigning it, e.g.
|
||
# `(arg) => { var a = arg.a; }`, with a default value if it has one.
|
||
if param.value?
|
||
condition = new Op '===', param, new UndefinedLiteral
|
||
ifTrue = new Assign new Value(param.name), param.value
|
||
exprs.push new If condition, ifTrue
|
||
else
|
||
exprs.push new Assign new Value(param.name), param.asReference(o), null, param: 'alwaysDeclare'
|
||
|
||
# If this parameter comes before the splat or expansion, it will go
|
||
# in the function definition parameter list.
|
||
unless haveSplatParam
|
||
# If this parameter has a default value, and it hasn’t already been
|
||
# set by the `shouldCache()` block above, define it as a statement in
|
||
# the function body. This parameter comes after the splat parameter,
|
||
# so we can’t define its default value in the parameter list.
|
||
if param.shouldCache()
|
||
ref = param.asReference o
|
||
else
|
||
if param.value? and not param.assignedInBody
|
||
ref = new Assign new Value(param.name), param.value, null, param: yes
|
||
else
|
||
ref = param
|
||
# Add this parameter’s reference(s) to the function scope.
|
||
if param.name instanceof Arr or param.name instanceof Obj
|
||
# This parameter is destructured.
|
||
param.name.lhs = yes
|
||
unless param.shouldCache()
|
||
param.name.eachName (prop) ->
|
||
o.scope.parameter prop.value
|
||
else
|
||
# This compilation of the parameter is only to get its name to add
|
||
# to the scope name tracking; since the compilation output here
|
||
# isn’t kept for eventual output, don’t include comments in this
|
||
# compilation, so that they get output the “real” time this param
|
||
# is compiled.
|
||
paramToAddToScope = if param.value? then param else ref
|
||
o.scope.parameter fragmentsToText paramToAddToScope.compileToFragmentsWithoutComments o
|
||
params.push ref
|
||
else
|
||
paramsAfterSplat.push param
|
||
# If this parameter had a default value, since it’s no longer in the
|
||
# function parameter list we need to assign its default value
|
||
# (if necessary) as an expression in the body.
|
||
if param.value? and not param.shouldCache()
|
||
condition = new Op '===', param, new UndefinedLiteral
|
||
ifTrue = new Assign new Value(param.name), param.value
|
||
exprs.push new If condition, ifTrue
|
||
# Add this parameter to the scope, since it wouldn’t have been added
|
||
# yet since it was skipped earlier.
|
||
o.scope.add param.name.value, 'var', yes if param.name?.value?
|
||
|
||
# If there were parameters after the splat or expansion parameter, those
|
||
# parameters need to be assigned in the body of the function.
|
||
if paramsAfterSplat.length isnt 0
|
||
# Create a destructured assignment, e.g. `[a, b, c] = [args..., b, c]`
|
||
exprs.unshift new Assign new Value(
|
||
new Arr [new Splat(new IdentifierLiteral(splatParamName)), (param.asReference o for param in paramsAfterSplat)...]
|
||
), new Value new IdentifierLiteral splatParamName
|
||
|
||
# Add new expressions to the function body
|
||
wasEmpty = @body.isEmpty()
|
||
@disallowSuperInParamDefaults()
|
||
@checkSuperCallsInConstructorBody()
|
||
@body.expressions.unshift thisAssignments... unless @expandCtorSuper thisAssignments
|
||
@body.expressions.unshift exprs...
|
||
if @isMethod and @bound and not @isStatic and @classVariable
|
||
boundMethodCheck = new Value new Literal utility 'boundMethodCheck', o
|
||
@body.expressions.unshift new Call(boundMethodCheck, [new Value(new ThisLiteral), @classVariable])
|
||
@body.makeReturn() unless wasEmpty or @noReturn
|
||
|
||
# JavaScript doesn’t allow bound (`=>`) functions to also be generators.
|
||
# This is usually caught via `Op::compileContinuation`, but double-check:
|
||
if @bound and @isGenerator
|
||
yieldNode = @body.contains (node) -> node instanceof Op and node.operator is 'yield'
|
||
(yieldNode or @).error 'yield cannot occur inside bound (fat arrow) functions'
|
||
|
||
# Assemble the output
|
||
modifiers = []
|
||
modifiers.push 'static' if @isMethod and @isStatic
|
||
modifiers.push 'async' if @isAsync
|
||
unless @isMethod or @bound
|
||
modifiers.push "function#{if @isGenerator then '*' else ''}"
|
||
else if @isGenerator
|
||
modifiers.push '*'
|
||
|
||
signature = [@makeCode '(']
|
||
# Block comments between a function name and `(` get output between
|
||
# `function` and `(`.
|
||
if @paramStart?.comments?
|
||
@compileCommentFragments o, @paramStart, signature
|
||
for param, i in params
|
||
signature.push @makeCode ', ' if i isnt 0
|
||
signature.push @makeCode '...' if haveSplatParam and i is params.length - 1
|
||
# Compile this parameter, but if any generated variables get created
|
||
# (e.g. `ref`), shift those into the parent scope since we can’t put a
|
||
# `var` line inside a function parameter list.
|
||
scopeVariablesCount = o.scope.variables.length
|
||
signature.push param.compileToFragments(o, LEVEL_PAREN)...
|
||
if scopeVariablesCount isnt o.scope.variables.length
|
||
generatedVariables = o.scope.variables.splice scopeVariablesCount
|
||
o.scope.parent.variables.push generatedVariables...
|
||
signature.push @makeCode ')'
|
||
# Block comments between `)` and `->`/`=>` get output between `)` and `{`.
|
||
if @funcGlyph?.comments?
|
||
comment.unshift = no for comment in @funcGlyph.comments
|
||
@compileCommentFragments o, @funcGlyph, signature
|
||
|
||
body = @body.compileWithDeclarations o unless @body.isEmpty()
|
||
|
||
# We need to compile the body before method names to ensure `super`
|
||
# references are handled.
|
||
if @isMethod
|
||
[methodScope, o.scope] = [o.scope, o.scope.parent]
|
||
name = @name.compileToFragments o
|
||
name.shift() if name[0].code is '.'
|
||
o.scope = methodScope
|
||
|
||
answer = @joinFragmentArrays (@makeCode m for m in modifiers), ' '
|
||
answer.push @makeCode ' ' if modifiers.length and name
|
||
answer.push name... if name
|
||
answer.push signature...
|
||
answer.push @makeCode ' =>' if @bound and not @isMethod
|
||
answer.push @makeCode ' {'
|
||
answer.push @makeCode('\n'), body..., @makeCode("\n#{@tab}") if body?.length
|
||
answer.push @makeCode '}'
|
||
|
||
return indentInitial answer, @ if @isMethod
|
||
if @front or (o.level >= LEVEL_ACCESS) then @wrapInParentheses answer else answer
|
||
|
||
updateOptions: (o) ->
|
||
o.scope = del(o, 'classScope') or @makeScope o.scope
|
||
o.scope.shared = del(o, 'sharedScope')
|
||
o.indent += TAB
|
||
delete o.bare
|
||
delete o.isExistentialEquals
|
||
|
||
checkForDuplicateParams: ->
|
||
paramNames = []
|
||
@eachParamName (name, node, param) ->
|
||
node.error "multiple parameters named '#{name}'" if name in paramNames
|
||
paramNames.push name
|
||
|
||
eachParamName: (iterator) ->
|
||
param.eachName iterator for param in @params
|
||
|
||
# Short-circuit `traverseChildren` method to prevent it from crossing scope
|
||
# boundaries unless `crossScope` is `true`.
|
||
traverseChildren: (crossScope, func) ->
|
||
super(crossScope, func) if crossScope
|
||
|
||
# Short-circuit `replaceInContext` method to prevent it from crossing context boundaries. Bound
|
||
# functions have the same context.
|
||
replaceInContext: (child, replacement) ->
|
||
if @bound
|
||
super child, replacement
|
||
else
|
||
false
|
||
|
||
disallowSuperInParamDefaults: ({forAst} = {}) ->
|
||
return false unless @ctor
|
||
|
||
@eachSuperCall Block.wrap(@params), (superCall) ->
|
||
superCall.error "'super' is not allowed in constructor parameter defaults"
|
||
, checkForThisBeforeSuper: not forAst
|
||
|
||
checkSuperCallsInConstructorBody: ->
|
||
return false unless @ctor
|
||
|
||
seenSuper = @eachSuperCall @body, (superCall) =>
|
||
superCall.error "'super' is only allowed in derived class constructors" if @ctor is 'base'
|
||
|
||
seenSuper
|
||
|
||
flagThisParamInDerivedClassConstructorWithoutCallingSuper: (param) ->
|
||
param.error "Can't use @params in derived class constructors without calling super"
|
||
|
||
checkForAsyncOrGeneratorConstructor: ->
|
||
if @ctor
|
||
@name.error 'Class constructor may not be async' if @isAsync
|
||
@name.error 'Class constructor may not be a generator' if @isGenerator
|
||
|
||
disallowLoneExpansionAndMultipleSplats: ->
|
||
seenSplatParam = no
|
||
for param in @params
|
||
# Was `...` used with this parameter? (Only one such parameter is allowed
|
||
# per function.)
|
||
if param.splat or param instanceof Expansion
|
||
if seenSplatParam
|
||
param.error 'only one splat or expansion parameter is allowed per function definition'
|
||
else if param instanceof Expansion and @params.length is 1
|
||
param.error 'an expansion parameter cannot be the only parameter in a function definition'
|
||
seenSplatParam = yes
|
||
|
||
expandCtorSuper: (thisAssignments) ->
|
||
return false unless @ctor
|
||
|
||
seenSuper = @eachSuperCall @body, (superCall) =>
|
||
superCall.expressions = thisAssignments
|
||
|
||
haveThisParam = thisAssignments.length and thisAssignments.length isnt @thisAssignments?.length
|
||
if @ctor is 'derived' and not seenSuper and haveThisParam
|
||
param = thisAssignments[0].variable
|
||
@flagThisParamInDerivedClassConstructorWithoutCallingSuper param
|
||
|
||
seenSuper
|
||
|
||
# Find all super calls in the given context node;
|
||
# returns `true` if `iterator` is called.
|
||
eachSuperCall: (context, iterator, {checkForThisBeforeSuper = yes} = {}) ->
|
||
seenSuper = no
|
||
|
||
context.traverseChildren yes, (child) =>
|
||
if child instanceof SuperCall
|
||
# `super` in a constructor (the only `super` without an accessor)
|
||
# cannot be given an argument with a reference to `this`, as that would
|
||
# be referencing `this` before calling `super`.
|
||
unless child.variable.accessor
|
||
childArgs = child.args.filter (arg) ->
|
||
arg not instanceof Class and (arg not instanceof Code or arg.bound)
|
||
Block.wrap(childArgs).traverseChildren yes, (node) =>
|
||
node.error "Can't call super with @params in derived class constructors" if node.this
|
||
seenSuper = yes
|
||
iterator child
|
||
else if checkForThisBeforeSuper and child instanceof ThisLiteral and @ctor is 'derived' and not seenSuper
|
||
child.error "Can't reference 'this' before calling super in derived class constructors"
|
||
|
||
# `super` has the same target in bound (arrow) functions, so check them too
|
||
child not instanceof SuperCall and (child not instanceof Code or child.bound)
|
||
|
||
seenSuper
|
||
|
||
propagateLhs: ->
|
||
for param in @params
|
||
{name} = param
|
||
if name instanceof Arr or name instanceof Obj
|
||
name.propagateLhs yes
|
||
else if param instanceof Expansion
|
||
param.lhs = yes
|
||
|
||
astAddParamsToScope: (o) ->
|
||
@eachParamName (name) ->
|
||
o.scope.add name, 'param'
|
||
|
||
astNode: (o) ->
|
||
@updateOptions o
|
||
@checkForAsyncOrGeneratorConstructor()
|
||
@checkForDuplicateParams()
|
||
@disallowSuperInParamDefaults forAst: yes
|
||
@disallowLoneExpansionAndMultipleSplats()
|
||
seenSuper = @checkSuperCallsInConstructorBody()
|
||
if @ctor is 'derived' and not seenSuper
|
||
@eachParamName (name, node) =>
|
||
if node.this
|
||
@flagThisParamInDerivedClassConstructorWithoutCallingSuper node
|
||
@astAddParamsToScope o
|
||
@body.makeReturn null, yes unless @body.isEmpty() or @noReturn
|
||
|
||
super o
|
||
|
||
astType: ->
|
||
if @isMethod
|
||
'ClassMethod'
|
||
else if @bound
|
||
'ArrowFunctionExpression'
|
||
else
|
||
'FunctionExpression'
|
||
|
||
paramForAst: (param) ->
|
||
return param if param instanceof Expansion
|
||
{name, value, splat} = param
|
||
if splat
|
||
new Splat name, lhs: yes, postfix: splat.postfix
|
||
.withLocationDataFrom param
|
||
else if value?
|
||
new Assign name, value, null, param: yes
|
||
.withLocationDataFrom locationData: mergeLocationData name.locationData, value.locationData
|
||
else
|
||
name
|
||
|
||
methodAstProperties: (o) ->
|
||
getIsComputed = =>
|
||
return yes if @name instanceof Index
|
||
return yes if @name instanceof ComputedPropertyName
|
||
return yes if @name.name instanceof ComputedPropertyName
|
||
no
|
||
|
||
return
|
||
static: !!@isStatic
|
||
key: @name.ast o
|
||
computed: getIsComputed()
|
||
kind:
|
||
if @ctor
|
||
'constructor'
|
||
else
|
||
'method'
|
||
operator: @operatorToken?.value ? '='
|
||
staticClassName: @isStatic.staticClassName?.ast(o) ? null
|
||
bound: !!@bound
|
||
|
||
astProperties: (o) ->
|
||
return Object.assign
|
||
params: @paramForAst(param).ast(o) for param in @params
|
||
body: @body.ast (Object.assign {}, o, checkForDirectives: yes), LEVEL_TOP
|
||
generator: !!@isGenerator
|
||
async: !!@isAsync
|
||
# We never generate named functions, so specify `id` as `null`, which
|
||
# matches the Babel AST for anonymous function expressions/arrow functions
|
||
id: null
|
||
hasIndentedBody: @body.locationData.first_line > @funcGlyph?.locationData.first_line
|
||
,
|
||
if @isMethod then @methodAstProperties o else {}
|
||
|
||
astLocationData: ->
|
||
functionLocationData = super()
|
||
return functionLocationData unless @isMethod
|
||
|
||
astLocationData = mergeAstLocationData @name.astLocationData(), functionLocationData
|
||
if @isStatic.staticClassName?
|
||
astLocationData = mergeAstLocationData @isStatic.staticClassName.astLocationData(), astLocationData
|
||
astLocationData
|
||
|
||
#### Param
|
||
|
||
# A parameter in a function definition. Beyond a typical JavaScript parameter,
|
||
# these parameters can also attach themselves to the context of the function,
|
||
# as well as be a splat, gathering up a group of parameters into an array.
|
||
exports.Param = class Param extends Base
|
||
constructor: (@name, @value, @splat) ->
|
||
super()
|
||
|
||
message = isUnassignable @name.unwrapAll().value
|
||
@name.error message if message
|
||
if @name instanceof Obj and @name.generated
|
||
token = @name.objects[0].operatorToken
|
||
token.error "unexpected #{token.value}"
|
||
|
||
children: ['name', 'value']
|
||
|
||
compileToFragments: (o) ->
|
||
@name.compileToFragments o, LEVEL_LIST
|
||
|
||
compileToFragmentsWithoutComments: (o) ->
|
||
@name.compileToFragmentsWithoutComments o, LEVEL_LIST
|
||
|
||
asReference: (o) ->
|
||
return @reference if @reference
|
||
node = @name
|
||
if node.this
|
||
name = node.properties[0].name.value
|
||
name = "_#{name}" if name in JS_FORBIDDEN
|
||
node = new IdentifierLiteral o.scope.freeVariable name
|
||
else if node.shouldCache()
|
||
node = new IdentifierLiteral o.scope.freeVariable 'arg'
|
||
node = new Value node
|
||
node.updateLocationDataIfMissing @locationData
|
||
@reference = node
|
||
|
||
shouldCache: ->
|
||
@name.shouldCache()
|
||
|
||
# Iterates the name or names of a `Param`.
|
||
# In a sense, a destructured parameter represents multiple JS parameters. This
|
||
# method allows to iterate them all.
|
||
# The `iterator` function will be called as `iterator(name, node)` where
|
||
# `name` is the name of the parameter and `node` is the AST node corresponding
|
||
# to that name.
|
||
eachName: (iterator, name = @name) ->
|
||
checkAssignabilityOfLiteral = (literal) ->
|
||
message = isUnassignable literal.value
|
||
if message
|
||
literal.error message
|
||
unless literal.isAssignable()
|
||
literal.error "'#{literal.value}' can't be assigned"
|
||
|
||
atParam = (obj, originalObj = null) => iterator "@#{obj.properties[0].name.value}", obj, @, originalObj
|
||
if name instanceof Call
|
||
name.error "Function invocation can't be assigned"
|
||
|
||
# * simple literals `foo`
|
||
if name instanceof Literal
|
||
checkAssignabilityOfLiteral name
|
||
return iterator name.value, name, @
|
||
# * at-params `@foo`
|
||
return atParam name if name instanceof Value
|
||
for obj in name.objects ? []
|
||
# Save original obj.
|
||
nObj = obj
|
||
# * destructured parameter with default value
|
||
if obj instanceof Assign and not obj.context?
|
||
obj = obj.variable
|
||
# * assignments within destructured parameters `{foo:bar}`
|
||
if obj instanceof Assign
|
||
# ... possibly with a default value
|
||
if obj.value instanceof Assign
|
||
obj = obj.value.variable
|
||
else
|
||
obj = obj.value
|
||
@eachName iterator, obj.unwrap()
|
||
# * splats within destructured parameters `[xs...]`
|
||
else if obj instanceof Splat
|
||
node = obj.name.unwrap()
|
||
iterator node.value, node, @
|
||
else if obj instanceof Value
|
||
# * destructured parameters within destructured parameters `[{a}]`
|
||
if obj.isArray() or obj.isObject()
|
||
@eachName iterator, obj.base
|
||
# * at-params within destructured parameters `{@foo}`
|
||
else if obj.this
|
||
atParam obj, nObj
|
||
# * simple destructured parameters {foo}
|
||
else
|
||
checkAssignabilityOfLiteral obj.base
|
||
iterator obj.base.value, obj.base, @
|
||
else if obj instanceof Elision
|
||
obj
|
||
else if obj not instanceof Expansion
|
||
obj.error "illegal parameter #{obj.compile()}"
|
||
return
|
||
|
||
# Rename a param by replacing the given AST node for a name with a new node.
|
||
# This needs to ensure that the the source for object destructuring does not change.
|
||
renameParam: (node, newNode) ->
|
||
isNode = (candidate) -> candidate is node
|
||
replacement = (node, parent) =>
|
||
if parent instanceof Obj
|
||
key = node
|
||
key = node.properties[0].name if node.this
|
||
# No need to assign a new variable for the destructured variable if the variable isn't reserved.
|
||
# Examples:
|
||
# `({@foo}) ->` should compile to `({foo}) { this.foo = foo}`
|
||
# `foo = 1; ({@foo}) ->` should compile to `foo = 1; ({foo:foo1}) { this.foo = foo1 }`
|
||
if node.this and key.value is newNode.value
|
||
new Value newNode
|
||
else
|
||
new Assign new Value(key), newNode, 'object'
|
||
else
|
||
newNode
|
||
|
||
@replaceInContext isNode, replacement
|
||
|
||
#### Splat
|
||
|
||
# A splat, either as a parameter to a function, an argument to a call,
|
||
# or as part of a destructuring assignment.
|
||
exports.Splat = class Splat extends Base
|
||
constructor: (name, {@lhs, @postfix = true} = {}) ->
|
||
super()
|
||
@name = if name.compile then name else new Literal name
|
||
|
||
children: ['name']
|
||
|
||
shouldCache: -> no
|
||
|
||
isAssignable: ({allowComplexSplat = no} = {})->
|
||
return allowComplexSplat if @name instanceof Obj or @name instanceof Parens
|
||
@name.isAssignable() and (not @name.isAtomic or @name.isAtomic())
|
||
|
||
assigns: (name) ->
|
||
@name.assigns name
|
||
|
||
compileNode: (o) ->
|
||
compiledSplat = [@makeCode('...'), @name.compileToFragments(o, LEVEL_OP)...]
|
||
return compiledSplat unless @jsx
|
||
return [@makeCode('{'), compiledSplat..., @makeCode('}')]
|
||
|
||
unwrap: -> @name
|
||
|
||
propagateLhs: (setLhs) ->
|
||
@lhs = yes if setLhs
|
||
return unless @lhs
|
||
@name.propagateLhs? yes
|
||
|
||
astType: ->
|
||
if @jsx
|
||
'JSXSpreadAttribute'
|
||
else if @lhs
|
||
'RestElement'
|
||
else
|
||
'SpreadElement'
|
||
|
||
astProperties: (o) -> {
|
||
argument: @name.ast o, LEVEL_OP
|
||
@postfix
|
||
}
|
||
|
||
#### Expansion
|
||
|
||
# Used to skip values inside an array destructuring (pattern matching) or
|
||
# parameter list.
|
||
exports.Expansion = class Expansion extends Base
|
||
|
||
shouldCache: NO
|
||
|
||
compileNode: (o) ->
|
||
@throwLhsError()
|
||
|
||
asReference: (o) ->
|
||
this
|
||
|
||
eachName: (iterator) ->
|
||
|
||
throwLhsError: ->
|
||
@error 'Expansion must be used inside a destructuring assignment or parameter list'
|
||
|
||
astNode: (o) ->
|
||
unless @lhs
|
||
@throwLhsError()
|
||
|
||
super o
|
||
|
||
astType: -> 'RestElement'
|
||
|
||
astProperties: ->
|
||
return
|
||
argument: null
|
||
|
||
#### Elision
|
||
|
||
# Array elision element (for example, [,a, , , b, , c, ,]).
|
||
exports.Elision = class Elision extends Base
|
||
|
||
isAssignable: YES
|
||
|
||
shouldCache: NO
|
||
|
||
compileToFragments: (o, level) ->
|
||
fragment = super o, level
|
||
fragment.isElision = yes
|
||
fragment
|
||
|
||
compileNode: (o) ->
|
||
[@makeCode ', ']
|
||
|
||
asReference: (o) ->
|
||
this
|
||
|
||
eachName: (iterator) ->
|
||
|
||
astNode: ->
|
||
null
|
||
|
||
#### While
|
||
|
||
# A while loop, the only sort of low-level loop exposed by CoffeeScript. From
|
||
# it, all other loops can be manufactured. Useful in cases where you need more
|
||
# flexibility or more speed than a comprehension can provide.
|
||
exports.While = class While extends Base
|
||
constructor: (@condition, {invert: @inverted, @guard, @isLoop} = {}) ->
|
||
super()
|
||
|
||
children: ['condition', 'guard', 'body']
|
||
|
||
isStatement: YES
|
||
|
||
makeReturn: (results, mark) ->
|
||
return super(results, mark) if results
|
||
@returns = not @jumps()
|
||
if mark
|
||
@body.makeReturn(results, mark) if @returns
|
||
return
|
||
this
|
||
|
||
addBody: (@body) ->
|
||
this
|
||
|
||
jumps: ->
|
||
{expressions} = @body
|
||
return no unless expressions.length
|
||
for node in expressions
|
||
return jumpNode if jumpNode = node.jumps loop: yes
|
||
no
|
||
|
||
# The main difference from a JavaScript *while* is that the CoffeeScript
|
||
# *while* can be used as a part of a larger expression -- while loops may
|
||
# return an array containing the computed result of each iteration.
|
||
compileNode: (o) ->
|
||
o.indent += TAB
|
||
set = ''
|
||
{body} = this
|
||
if body.isEmpty()
|
||
body = @makeCode ''
|
||
else
|
||
if @returns
|
||
body.makeReturn rvar = o.scope.freeVariable 'results'
|
||
set = "#{@tab}#{rvar} = [];\n"
|
||
if @guard
|
||
if body.expressions.length > 1
|
||
body.expressions.unshift new If (new Parens @guard).invert(), new StatementLiteral "continue"
|
||
else
|
||
body = Block.wrap [new If @guard, body] if @guard
|
||
body = [].concat @makeCode("\n"), (body.compileToFragments o, LEVEL_TOP), @makeCode("\n#{@tab}")
|
||
answer = [].concat @makeCode(set + @tab + "while ("), @processedCondition().compileToFragments(o, LEVEL_PAREN),
|
||
@makeCode(") {"), body, @makeCode("}")
|
||
if @returns
|
||
answer.push @makeCode "\n#{@tab}return #{rvar};"
|
||
answer
|
||
|
||
processedCondition: ->
|
||
@processedConditionCache ?= if @inverted then @condition.invert() else @condition
|
||
|
||
astType: -> 'WhileStatement'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
test: @condition.ast o, LEVEL_PAREN
|
||
body: @body.ast o, LEVEL_TOP
|
||
guard: @guard?.ast(o) ? null
|
||
inverted: !!@inverted
|
||
postfix: !!@postfix
|
||
loop: !!@isLoop
|
||
|
||
#### Op
|
||
|
||
# Simple Arithmetic and logical operations. Performs some conversion from
|
||
# CoffeeScript operations into their JavaScript equivalents.
|
||
exports.Op = class Op extends Base
|
||
constructor: (op, first, second, flip, {@invertOperator, @originalOperator = op} = {}) ->
|
||
super()
|
||
|
||
if op is 'new'
|
||
if ((firstCall = unwrapped = first.unwrap()) instanceof Call or (firstCall = unwrapped.base) instanceof Call) and not firstCall.do and not firstCall.isNew
|
||
return new Value firstCall.newInstance(), if firstCall is unwrapped then [] else unwrapped.properties
|
||
first = new Parens first unless first instanceof Parens or first.unwrap() instanceof IdentifierLiteral or first.hasProperties?()
|
||
call = new Call first, []
|
||
call.locationData = @locationData
|
||
call.isNew = yes
|
||
return call
|
||
|
||
@operator = CONVERSIONS[op] or op
|
||
@first = first
|
||
@second = second
|
||
@flip = !!flip
|
||
|
||
if @operator in ['--', '++']
|
||
message = isUnassignable @first.unwrapAll().value
|
||
@first.error message if message
|
||
|
||
return this
|
||
|
||
# The map of conversions from CoffeeScript to JavaScript symbols.
|
||
CONVERSIONS =
|
||
'==': '==='
|
||
'!=': '!=='
|
||
'of': 'in'
|
||
'yieldfrom': 'yield*'
|
||
|
||
# The map of invertible operators.
|
||
INVERSIONS =
|
||
'!==': '==='
|
||
'===': '!=='
|
||
|
||
children: ['first', 'second']
|
||
|
||
isNumber: ->
|
||
@isUnary() and @operator in ['+', '-'] and
|
||
@first instanceof Value and @first.isNumber()
|
||
|
||
isAwait: ->
|
||
@operator is 'await'
|
||
|
||
isYield: ->
|
||
@operator in ['yield', 'yield*']
|
||
|
||
isUnary: ->
|
||
not @second
|
||
|
||
shouldCache: ->
|
||
not @isNumber()
|
||
|
||
# Am I capable of
|
||
# [Python-style comparison chaining](https://docs.python.org/3/reference/expressions.html#not-in)?
|
||
isChainable: ->
|
||
@operator in ['<', '>', '>=', '<=', '===', '!==']
|
||
|
||
isChain: ->
|
||
@isChainable() and @first.isChainable()
|
||
|
||
invert: ->
|
||
if @isInOperator()
|
||
@invertOperator = '!'
|
||
return @
|
||
if @isChain()
|
||
allInvertable = yes
|
||
curr = this
|
||
while curr and curr.operator
|
||
allInvertable and= (curr.operator of INVERSIONS)
|
||
curr = curr.first
|
||
return new Parens(this).invert() unless allInvertable
|
||
curr = this
|
||
while curr and curr.operator
|
||
curr.invert = !curr.invert
|
||
curr.operator = INVERSIONS[curr.operator]
|
||
curr = curr.first
|
||
this
|
||
else if op = INVERSIONS[@operator]
|
||
@operator = op
|
||
if @first.unwrap() instanceof Op
|
||
@first.invert()
|
||
this
|
||
else if @second
|
||
new Parens(this).invert()
|
||
else if @operator is '!' and (fst = @first.unwrap()) instanceof Op and
|
||
fst.operator in ['!', 'in', 'instanceof']
|
||
fst
|
||
else
|
||
new Op '!', this
|
||
|
||
unfoldSoak: (o) ->
|
||
@operator in ['++', '--', 'delete'] and unfoldSoak o, this, 'first'
|
||
|
||
generateDo: (exp) ->
|
||
passedParams = []
|
||
func = if exp instanceof Assign and (ref = exp.value.unwrap()) instanceof Code
|
||
ref
|
||
else
|
||
exp
|
||
for param in func.params or []
|
||
if param.value
|
||
passedParams.push param.value
|
||
delete param.value
|
||
else
|
||
passedParams.push param
|
||
call = new Call exp, passedParams
|
||
call.do = yes
|
||
call
|
||
|
||
isInOperator: ->
|
||
@originalOperator is 'in'
|
||
|
||
compileNode: (o) ->
|
||
if @isInOperator()
|
||
inNode = new In @first, @second
|
||
return (if @invertOperator then inNode.invert() else inNode).compileNode o
|
||
if @invertOperator
|
||
@invertOperator = null
|
||
return @invert().compileNode(o)
|
||
return Op::generateDo(@first).compileNode o if @operator is 'do'
|
||
isChain = @isChain()
|
||
# In chains, there's no need to wrap bare obj literals in parens,
|
||
# as the chained expression is wrapped.
|
||
@first.front = @front unless isChain
|
||
@checkDeleteOperand o
|
||
return @compileContinuation o if @isYield() or @isAwait()
|
||
return @compileUnary o if @isUnary()
|
||
return @compileChain o if isChain
|
||
switch @operator
|
||
when '?' then @compileExistence o, @second.isDefaultValue
|
||
when '//' then @compileFloorDivision o
|
||
when '%%' then @compileModulo o
|
||
else
|
||
lhs = @first.compileToFragments o, LEVEL_OP
|
||
rhs = @second.compileToFragments o, LEVEL_OP
|
||
answer = [].concat lhs, @makeCode(" #{@operator} "), rhs
|
||
if o.level <= LEVEL_OP then answer else @wrapInParentheses answer
|
||
|
||
# Mimic Python's chained comparisons when multiple comparison operators are
|
||
# used sequentially. For example:
|
||
#
|
||
# bin/coffee -e 'console.log 50 < 65 > 10'
|
||
# true
|
||
compileChain: (o) ->
|
||
[@first.second, shared] = @first.second.cache o
|
||
fst = @first.compileToFragments o, LEVEL_OP
|
||
fragments = fst.concat @makeCode(" #{if @invert then '&&' else '||'} "),
|
||
(shared.compileToFragments o), @makeCode(" #{@operator} "), (@second.compileToFragments o, LEVEL_OP)
|
||
@wrapInParentheses fragments
|
||
|
||
# Keep reference to the left expression, unless this an existential assignment
|
||
compileExistence: (o, checkOnlyUndefined) ->
|
||
if @first.shouldCache()
|
||
ref = new IdentifierLiteral o.scope.freeVariable 'ref'
|
||
fst = new Parens new Assign ref, @first
|
||
else
|
||
fst = @first
|
||
ref = fst
|
||
new If(new Existence(fst, checkOnlyUndefined), ref, type: 'if').addElse(@second).compileToFragments o
|
||
|
||
# Compile a unary **Op**.
|
||
compileUnary: (o) ->
|
||
parts = []
|
||
op = @operator
|
||
parts.push [@makeCode op]
|
||
if op is '!' and @first instanceof Existence
|
||
@first.negated = not @first.negated
|
||
return @first.compileToFragments o
|
||
if o.level >= LEVEL_ACCESS
|
||
return (new Parens this).compileToFragments o
|
||
plusMinus = op in ['+', '-']
|
||
parts.push [@makeCode(' ')] if op in ['typeof', 'delete'] or
|
||
plusMinus and @first instanceof Op and @first.operator is op
|
||
if plusMinus and @first instanceof Op
|
||
@first = new Parens @first
|
||
parts.push @first.compileToFragments o, LEVEL_OP
|
||
parts.reverse() if @flip
|
||
@joinFragmentArrays parts, ''
|
||
|
||
compileContinuation: (o) ->
|
||
parts = []
|
||
op = @operator
|
||
@checkContinuation o unless @isAwait()
|
||
if 'expression' in Object.keys(@first) and not (@first instanceof Throw)
|
||
parts.push @first.expression.compileToFragments o, LEVEL_OP if @first.expression?
|
||
else
|
||
parts.push [@makeCode "("] if o.level >= LEVEL_PAREN
|
||
parts.push [@makeCode op]
|
||
parts.push [@makeCode " "] if @first.base?.value isnt ''
|
||
parts.push @first.compileToFragments o, LEVEL_OP
|
||
parts.push [@makeCode ")"] if o.level >= LEVEL_PAREN
|
||
@joinFragmentArrays parts, ''
|
||
|
||
checkContinuation: (o) ->
|
||
unless o.scope.parent?
|
||
@error "#{@operator} can only occur inside functions"
|
||
if o.scope.method?.bound and o.scope.method.isGenerator
|
||
@error 'yield cannot occur inside bound (fat arrow) functions'
|
||
|
||
compileFloorDivision: (o) ->
|
||
floor = new Value new IdentifierLiteral('Math'), [new Access new PropertyName 'floor']
|
||
second = if @second.shouldCache() then new Parens @second else @second
|
||
div = new Op '/', @first, second
|
||
new Call(floor, [div]).compileToFragments o
|
||
|
||
compileModulo: (o) ->
|
||
mod = new Value new Literal utility 'modulo', o
|
||
new Call(mod, [@first, @second]).compileToFragments o
|
||
|
||
toString: (idt) ->
|
||
super idt, @constructor.name + ' ' + @operator
|
||
|
||
checkDeleteOperand: (o) ->
|
||
if @operator is 'delete' and o.scope.check(@first.unwrapAll().value)
|
||
@error 'delete operand may not be argument or var'
|
||
|
||
astNode: (o) ->
|
||
@checkContinuation o if @isYield()
|
||
@checkDeleteOperand o
|
||
super o
|
||
|
||
astType: ->
|
||
return 'AwaitExpression' if @isAwait()
|
||
return 'YieldExpression' if @isYield()
|
||
return 'ChainedComparison' if @isChain()
|
||
switch @operator
|
||
when '||', '&&', '?' then 'LogicalExpression'
|
||
when '++', '--' then 'UpdateExpression'
|
||
else
|
||
if @isUnary() then 'UnaryExpression'
|
||
else 'BinaryExpression'
|
||
|
||
operatorAst: ->
|
||
"#{if @invertOperator then "#{@invertOperator} " else ''}#{@originalOperator}"
|
||
|
||
chainAstProperties: (o) ->
|
||
operators = [@operatorAst()]
|
||
operands = [@second]
|
||
currentOp = @first
|
||
loop
|
||
operators.unshift currentOp.operatorAst()
|
||
operands.unshift currentOp.second
|
||
currentOp = currentOp.first
|
||
unless currentOp.isChainable()
|
||
operands.unshift currentOp
|
||
break
|
||
return {
|
||
operators
|
||
operands: (operand.ast(o, LEVEL_OP) for operand in operands)
|
||
}
|
||
|
||
astProperties: (o) ->
|
||
return @chainAstProperties(o) if @isChain()
|
||
|
||
firstAst = @first.ast o, LEVEL_OP
|
||
secondAst = @second?.ast o, LEVEL_OP
|
||
operatorAst = @operatorAst()
|
||
switch
|
||
when @isUnary()
|
||
argument =
|
||
if @isYield() and @first.unwrap().value is ''
|
||
null
|
||
else
|
||
firstAst
|
||
return {argument} if @isAwait()
|
||
return {
|
||
argument
|
||
delegate: @operator is 'yield*'
|
||
} if @isYield()
|
||
return {
|
||
argument
|
||
operator: operatorAst
|
||
prefix: !@flip
|
||
}
|
||
else
|
||
return
|
||
left: firstAst
|
||
right: secondAst
|
||
operator: operatorAst
|
||
|
||
#### In
|
||
exports.In = class In extends Base
|
||
constructor: (@object, @array) ->
|
||
super()
|
||
|
||
children: ['object', 'array']
|
||
|
||
invert: NEGATE
|
||
|
||
compileNode: (o) ->
|
||
if @array instanceof Value and @array.isArray() and @array.base.objects.length
|
||
for obj in @array.base.objects when obj instanceof Splat
|
||
hasSplat = yes
|
||
break
|
||
# `compileOrTest` only if we have an array literal with no splats
|
||
return @compileOrTest o unless hasSplat
|
||
@compileLoopTest o
|
||
|
||
compileOrTest: (o) ->
|
||
[sub, ref] = @object.cache o, LEVEL_OP
|
||
[cmp, cnj] = if @negated then [' !== ', ' && '] else [' === ', ' || ']
|
||
tests = []
|
||
for item, i in @array.base.objects
|
||
if i then tests.push @makeCode cnj
|
||
tests = tests.concat (if i then ref else sub), @makeCode(cmp), item.compileToFragments(o, LEVEL_ACCESS)
|
||
if o.level < LEVEL_OP then tests else @wrapInParentheses tests
|
||
|
||
compileLoopTest: (o) ->
|
||
[sub, ref] = @object.cache o, LEVEL_LIST
|
||
fragments = [].concat @makeCode(utility('indexOf', o) + ".call("), @array.compileToFragments(o, LEVEL_LIST),
|
||
@makeCode(", "), ref, @makeCode(") " + if @negated then '< 0' else '>= 0')
|
||
return fragments if fragmentsToText(sub) is fragmentsToText(ref)
|
||
fragments = sub.concat @makeCode(', '), fragments
|
||
if o.level < LEVEL_LIST then fragments else @wrapInParentheses fragments
|
||
|
||
toString: (idt) ->
|
||
super idt, @constructor.name + if @negated then '!' else ''
|
||
|
||
#### Try
|
||
|
||
# A classic *try/catch/finally* block.
|
||
exports.Try = class Try extends Base
|
||
constructor: (@attempt, @catch, @ensure, @finallyTag) ->
|
||
super()
|
||
|
||
children: ['attempt', 'catch', 'ensure']
|
||
|
||
isStatement: YES
|
||
|
||
jumps: (o) -> @attempt.jumps(o) or @catch?.jumps(o)
|
||
|
||
makeReturn: (results, mark) ->
|
||
if mark
|
||
@attempt?.makeReturn results, mark
|
||
@catch?.makeReturn results, mark
|
||
return
|
||
@attempt = @attempt.makeReturn results if @attempt
|
||
@catch = @catch .makeReturn results if @catch
|
||
this
|
||
|
||
# Compilation is more or less as you would expect -- the *finally* clause
|
||
# is optional, the *catch* is not.
|
||
compileNode: (o) ->
|
||
originalIndent = o.indent
|
||
o.indent += TAB
|
||
tryPart = @attempt.compileToFragments o, LEVEL_TOP
|
||
|
||
catchPart = if @catch
|
||
@catch.compileToFragments merge(o, indent: originalIndent), LEVEL_TOP
|
||
else unless @ensure or @catch
|
||
generatedErrorVariableName = o.scope.freeVariable 'error', reserve: no
|
||
[@makeCode(" catch (#{generatedErrorVariableName}) {}")]
|
||
else
|
||
[]
|
||
|
||
ensurePart = if @ensure then ([].concat @makeCode(" finally {\n"), @ensure.compileToFragments(o, LEVEL_TOP),
|
||
@makeCode("\n#{@tab}}")) else []
|
||
|
||
[].concat @makeCode("#{@tab}try {\n"),
|
||
tryPart,
|
||
@makeCode("\n#{@tab}}"), catchPart, ensurePart
|
||
|
||
astType: -> 'TryStatement'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
block: @attempt.ast o, LEVEL_TOP
|
||
handler: @catch?.ast(o) ? null
|
||
finalizer:
|
||
if @ensure?
|
||
Object.assign @ensure.ast(o, LEVEL_TOP),
|
||
# Include `finally` keyword in location data.
|
||
mergeAstLocationData(
|
||
jisonLocationDataToAstLocationData(@finallyTag.locationData),
|
||
@ensure.astLocationData()
|
||
)
|
||
else
|
||
null
|
||
|
||
exports.Catch = class Catch extends Base
|
||
constructor: (@recovery, @errorVariable) ->
|
||
super()
|
||
@errorVariable?.unwrap().propagateLhs? yes
|
||
|
||
children: ['recovery', 'errorVariable']
|
||
|
||
isStatement: YES
|
||
|
||
jumps: (o) -> @recovery.jumps o
|
||
|
||
makeReturn: (results, mark) ->
|
||
ret = @recovery.makeReturn results, mark
|
||
return if mark
|
||
@recovery = ret
|
||
this
|
||
|
||
compileNode: (o) ->
|
||
o.indent += TAB
|
||
generatedErrorVariableName = o.scope.freeVariable 'error', reserve: no
|
||
placeholder = new IdentifierLiteral generatedErrorVariableName
|
||
@checkUnassignable()
|
||
if @errorVariable
|
||
@recovery.unshift new Assign @errorVariable, placeholder
|
||
[].concat @makeCode(" catch ("), placeholder.compileToFragments(o), @makeCode(") {\n"),
|
||
@recovery.compileToFragments(o, LEVEL_TOP), @makeCode("\n#{@tab}}")
|
||
|
||
checkUnassignable: ->
|
||
if @errorVariable
|
||
message = isUnassignable @errorVariable.unwrapAll().value
|
||
@errorVariable.error message if message
|
||
|
||
astNode: (o) ->
|
||
@checkUnassignable()
|
||
@errorVariable?.eachName (name) ->
|
||
alreadyDeclared = o.scope.find name.value
|
||
name.isDeclaration = not alreadyDeclared
|
||
|
||
super o
|
||
|
||
astType: -> 'CatchClause'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
param: @errorVariable?.ast(o) ? null
|
||
body: @recovery.ast o, LEVEL_TOP
|
||
|
||
#### Throw
|
||
|
||
# Simple node to throw an exception.
|
||
exports.Throw = class Throw extends Base
|
||
constructor: (@expression) ->
|
||
super()
|
||
|
||
children: ['expression']
|
||
|
||
isStatement: YES
|
||
jumps: NO
|
||
|
||
# A **Throw** is already a return, of sorts...
|
||
makeReturn: THIS
|
||
|
||
compileNode: (o) ->
|
||
fragments = @expression.compileToFragments o, LEVEL_LIST
|
||
unshiftAfterComments fragments, @makeCode 'throw '
|
||
fragments.unshift @makeCode @tab
|
||
fragments.push @makeCode ';'
|
||
fragments
|
||
|
||
astType: -> 'ThrowStatement'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
argument: @expression.ast o, LEVEL_LIST
|
||
|
||
#### Existence
|
||
|
||
# Checks a variable for existence -- not `null` and not `undefined`. This is
|
||
# similar to `.nil?` in Ruby, and avoids having to consult a JavaScript truth
|
||
# table. Optionally only check if a variable is not `undefined`.
|
||
exports.Existence = class Existence extends Base
|
||
constructor: (@expression, onlyNotUndefined = no) ->
|
||
super()
|
||
@comparisonTarget = if onlyNotUndefined then 'undefined' else 'null'
|
||
salvagedComments = []
|
||
@expression.traverseChildren yes, (child) ->
|
||
if child.comments
|
||
for comment in child.comments
|
||
salvagedComments.push comment unless comment in salvagedComments
|
||
delete child.comments
|
||
attachCommentsToNode salvagedComments, @
|
||
moveComments @expression, @
|
||
|
||
children: ['expression']
|
||
|
||
invert: NEGATE
|
||
|
||
compileNode: (o) ->
|
||
@expression.front = @front
|
||
code = @expression.compile o, LEVEL_OP
|
||
if @expression.unwrap() instanceof IdentifierLiteral and not o.scope.check code
|
||
[cmp, cnj] = if @negated then ['===', '||'] else ['!==', '&&']
|
||
code = "typeof #{code} #{cmp} \"undefined\"" + if @comparisonTarget isnt 'undefined' then " #{cnj} #{code} #{cmp} #{@comparisonTarget}" else ''
|
||
else
|
||
# We explicity want to use loose equality (`==`) when comparing against `null`,
|
||
# so that an existence check roughly corresponds to a check for truthiness.
|
||
# Do *not* change this to `===` for `null`, as this will break mountains of
|
||
# existing code. When comparing only against `undefined`, however, we want to
|
||
# use `===` because this use case is for parity with ES2015+ default values,
|
||
# which only get assigned when the variable is `undefined` (but not `null`).
|
||
cmp = if @comparisonTarget is 'null'
|
||
if @negated then '==' else '!='
|
||
else # `undefined`
|
||
if @negated then '===' else '!=='
|
||
code = "#{code} #{cmp} #{@comparisonTarget}"
|
||
[@makeCode(if o.level <= LEVEL_COND then code else "(#{code})")]
|
||
|
||
astType: -> 'UnaryExpression'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
argument: @expression.ast o
|
||
operator: '?'
|
||
prefix: no
|
||
|
||
#### Parens
|
||
|
||
# An extra set of parentheses, specified explicitly in the source. At one time
|
||
# we tried to clean up the results by detecting and removing redundant
|
||
# parentheses, but no longer -- you can put in as many as you please.
|
||
#
|
||
# Parentheses are a good way to force any statement to become an expression.
|
||
exports.Parens = class Parens extends Base
|
||
constructor: (@body) ->
|
||
super()
|
||
|
||
children: ['body']
|
||
|
||
unwrap: -> @body
|
||
|
||
shouldCache: -> @body.shouldCache()
|
||
|
||
compileNode: (o) ->
|
||
expr = @body.unwrap()
|
||
# If these parentheses are wrapping an `IdentifierLiteral` followed by a
|
||
# block comment, output the parentheses (or put another way, don’t optimize
|
||
# away these redundant parentheses). This is because Flow requires
|
||
# parentheses in certain circumstances to distinguish identifiers followed
|
||
# by comment-based type annotations from JavaScript labels.
|
||
shouldWrapComment = expr.comments?.some(
|
||
(comment) -> comment.here and not comment.unshift and not comment.newLine)
|
||
if expr instanceof Value and expr.isAtomic() and not @jsxAttribute and not shouldWrapComment
|
||
expr.front = @front
|
||
return expr.compileToFragments o
|
||
fragments = expr.compileToFragments o, LEVEL_PAREN
|
||
bare = o.level < LEVEL_OP and not shouldWrapComment and (
|
||
expr instanceof Op and not expr.isInOperator() or expr.unwrap() instanceof Call or
|
||
(expr instanceof For and expr.returns)
|
||
) and (o.level < LEVEL_COND or fragments.length <= 3)
|
||
return @wrapInBraces fragments if @jsxAttribute
|
||
if bare then fragments else @wrapInParentheses fragments
|
||
|
||
astNode: (o) -> @body.unwrap().ast o, LEVEL_PAREN
|
||
|
||
#### StringWithInterpolations
|
||
|
||
exports.StringWithInterpolations = class StringWithInterpolations extends Base
|
||
constructor: (@body, {@quote, @startQuote, @jsxAttribute} = {}) ->
|
||
super()
|
||
|
||
@fromStringLiteral: (stringLiteral) ->
|
||
updatedString = stringLiteral.withoutQuotesInLocationData()
|
||
updatedStringValue = new Value(updatedString).withLocationDataFrom updatedString
|
||
new StringWithInterpolations Block.wrap([updatedStringValue]), quote: stringLiteral.quote, jsxAttribute: stringLiteral.jsxAttribute
|
||
.withLocationDataFrom stringLiteral
|
||
|
||
children: ['body']
|
||
|
||
# `unwrap` returns `this` to stop ancestor nodes reaching in to grab @body,
|
||
# and using @body.compileNode. `StringWithInterpolations.compileNode` is
|
||
# _the_ custom logic to output interpolated strings as code.
|
||
unwrap: -> this
|
||
|
||
shouldCache: -> @body.shouldCache()
|
||
|
||
extractElements: (o, {includeInterpolationWrappers, isJsx} = {}) ->
|
||
# Assumes that `expr` is `Block`
|
||
expr = @body.unwrap()
|
||
|
||
elements = []
|
||
salvagedComments = []
|
||
expr.traverseChildren no, (node) =>
|
||
if node instanceof StringLiteral
|
||
if node.comments
|
||
salvagedComments.push node.comments...
|
||
delete node.comments
|
||
elements.push node
|
||
return yes
|
||
else if node instanceof Interpolation
|
||
if salvagedComments.length isnt 0
|
||
for comment in salvagedComments
|
||
comment.unshift = yes
|
||
comment.newLine = yes
|
||
attachCommentsToNode salvagedComments, node
|
||
if (unwrapped = node.expression?.unwrapAll()) instanceof PassthroughLiteral and unwrapped.generated and not (isJsx and o.compiling)
|
||
if o.compiling
|
||
commentPlaceholder = new StringLiteral('').withLocationDataFrom node
|
||
commentPlaceholder.comments = unwrapped.comments
|
||
(commentPlaceholder.comments ?= []).push node.comments... if node.comments
|
||
elements.push new Value commentPlaceholder
|
||
else
|
||
empty = new Interpolation().withLocationDataFrom node
|
||
empty.comments = node.comments
|
||
elements.push empty
|
||
else if node.expression or includeInterpolationWrappers
|
||
(node.expression?.comments ?= []).push node.comments... if node.comments
|
||
elements.push if includeInterpolationWrappers then node else node.expression
|
||
return no
|
||
else if node.comments
|
||
# This node is getting discarded, but salvage its comments.
|
||
if elements.length isnt 0 and elements[elements.length - 1] not instanceof StringLiteral
|
||
for comment in node.comments
|
||
comment.unshift = no
|
||
comment.newLine = yes
|
||
attachCommentsToNode node.comments, elements[elements.length - 1]
|
||
else
|
||
salvagedComments.push node.comments...
|
||
delete node.comments
|
||
return yes
|
||
|
||
elements
|
||
|
||
compileNode: (o) ->
|
||
@comments ?= @startQuote?.comments
|
||
|
||
if @jsxAttribute
|
||
wrapped = new Parens new StringWithInterpolations @body
|
||
wrapped.jsxAttribute = yes
|
||
return wrapped.compileNode o
|
||
|
||
elements = @extractElements o, isJsx: @jsx
|
||
|
||
fragments = []
|
||
fragments.push @makeCode '`' unless @jsx
|
||
for element in elements
|
||
if element instanceof StringLiteral
|
||
unquotedElementValue = if @jsx then element.unquotedValueForJSX else element.unquotedValueForTemplateLiteral
|
||
fragments.push @makeCode unquotedElementValue
|
||
else
|
||
fragments.push @makeCode '$' unless @jsx
|
||
code = element.compileToFragments(o, LEVEL_PAREN)
|
||
if not @isNestedTag(element) or
|
||
code.some((fragment) -> fragment.comments?.some((comment) -> comment.here is no))
|
||
code = @wrapInBraces code
|
||
# Flag the `{` and `}` fragments as having been generated by this
|
||
# `StringWithInterpolations` node, so that `compileComments` knows
|
||
# to treat them as bounds. But the braces are unnecessary if all of
|
||
# the enclosed comments are `/* */` comments. Don’t trust
|
||
# `fragment.type`, which can report minified variable names when
|
||
# this compiler is minified.
|
||
code[0].isStringWithInterpolations = yes
|
||
code[code.length - 1].isStringWithInterpolations = yes
|
||
fragments.push code...
|
||
fragments.push @makeCode '`' unless @jsx
|
||
fragments
|
||
|
||
isNestedTag: (element) ->
|
||
call = element.unwrapAll?()
|
||
@jsx and call instanceof JSXElement
|
||
|
||
astType: -> 'TemplateLiteral'
|
||
|
||
astProperties: (o) ->
|
||
elements = @extractElements o, includeInterpolationWrappers: yes
|
||
[..., last] = elements
|
||
|
||
quasis = []
|
||
expressions = []
|
||
|
||
for element, index in elements
|
||
if element instanceof StringLiteral
|
||
quasis.push new TemplateElement(
|
||
element.originalValue
|
||
tail: element is last
|
||
).withLocationDataFrom(element).ast o
|
||
else # Interpolation
|
||
{expression} = element
|
||
node =
|
||
unless expression?
|
||
emptyInterpolation = new EmptyInterpolation()
|
||
emptyInterpolation.locationData = emptyExpressionLocationData {
|
||
interpolationNode: element
|
||
openingBrace: '#{'
|
||
closingBrace: '}'
|
||
}
|
||
emptyInterpolation
|
||
else
|
||
expression.unwrapAll()
|
||
expressions.push astAsBlockIfNeeded node, o
|
||
|
||
{expressions, quasis, @quote}
|
||
|
||
exports.TemplateElement = class TemplateElement extends Base
|
||
constructor: (@value, {@tail} = {}) ->
|
||
super()
|
||
|
||
astProperties: ->
|
||
return
|
||
value:
|
||
raw: @value
|
||
tail: !!@tail
|
||
|
||
exports.Interpolation = class Interpolation extends Base
|
||
constructor: (@expression) ->
|
||
super()
|
||
|
||
children: ['expression']
|
||
|
||
# Represents the contents of an empty interpolation (e.g. `#{}`).
|
||
# Only used during AST generation.
|
||
exports.EmptyInterpolation = class EmptyInterpolation extends Base
|
||
constructor: ->
|
||
super()
|
||
|
||
#### For
|
||
|
||
# CoffeeScript's replacement for the *for* loop is our array and object
|
||
# comprehensions, that compile into *for* loops here. They also act as an
|
||
# expression, able to return the result of each filtered iteration.
|
||
#
|
||
# Unlike Python array comprehensions, they can be multi-line, and you can pass
|
||
# the current index of the loop as a second parameter. Unlike Ruby blocks,
|
||
# you can map and filter in a single pass.
|
||
exports.For = class For extends While
|
||
constructor: (body, source) ->
|
||
super()
|
||
@addBody body
|
||
@addSource source
|
||
|
||
children: ['body', 'source', 'guard', 'step']
|
||
|
||
isAwait: -> @await ? no
|
||
|
||
addBody: (body) ->
|
||
@body = Block.wrap [body]
|
||
{expressions} = @body
|
||
if expressions.length
|
||
@body.locationData ?= mergeLocationData expressions[0].locationData, expressions[expressions.length - 1].locationData
|
||
this
|
||
|
||
addSource: (source) ->
|
||
{@source = no} = source
|
||
attribs = ["name", "index", "guard", "step", "own", "ownTag", "await", "awaitTag", "object", "from"]
|
||
@[attr] = source[attr] ? @[attr] for attr in attribs
|
||
return this unless @source
|
||
@index.error 'cannot use index with for-from' if @from and @index
|
||
@ownTag.error "cannot use own with for-#{if @from then 'from' else 'in'}" if @own and not @object
|
||
[@name, @index] = [@index, @name] if @object
|
||
@index.error 'index cannot be a pattern matching expression' if @index?.isArray?() or @index?.isObject?()
|
||
@awaitTag.error 'await must be used with for-from' if @await and not @from
|
||
@range = @source instanceof Value and @source.base instanceof Range and not @source.properties.length and not @from
|
||
@pattern = @name instanceof Value
|
||
@name.unwrap().propagateLhs?(yes) if @pattern
|
||
@index.error 'indexes do not apply to range loops' if @range and @index
|
||
@name.error 'cannot pattern match over range loops' if @range and @pattern
|
||
@returns = no
|
||
# Move up any comments in the “`for` line”, i.e. the line of code with `for`,
|
||
# from any child nodes of that line up to the `for` node itself so that these
|
||
# comments get output, and get output above the `for` loop.
|
||
for attribute in ['source', 'guard', 'step', 'name', 'index'] when @[attribute]
|
||
@[attribute].traverseChildren yes, (node) =>
|
||
if node.comments
|
||
# These comments are buried pretty deeply, so if they happen to be
|
||
# trailing comments the line they trail will be unrecognizable when
|
||
# we’re done compiling this `for` loop; so just shift them up to
|
||
# output above the `for` line.
|
||
comment.newLine = comment.unshift = yes for comment in node.comments
|
||
moveComments node, @[attribute]
|
||
moveComments @[attribute], @
|
||
this
|
||
|
||
# Welcome to the hairiest method in all of CoffeeScript. Handles the inner
|
||
# loop, filtering, stepping, and result saving for array, object, and range
|
||
# comprehensions. Some of the generated code can be shared in common, and
|
||
# some cannot.
|
||
compileNode: (o) ->
|
||
body = Block.wrap [@body]
|
||
[..., last] = body.expressions
|
||
@returns = no if last?.jumps() instanceof Return
|
||
source = if @range then @source.base else @source
|
||
scope = o.scope
|
||
name = @name and (@name.compile o, LEVEL_LIST) if not @pattern
|
||
index = @index and (@index.compile o, LEVEL_LIST)
|
||
scope.find(name) if name and not @pattern
|
||
scope.find(index) if index and @index not instanceof Value
|
||
rvar = scope.freeVariable 'results' if @returns
|
||
if @from
|
||
ivar = scope.freeVariable 'x', single: true if @pattern
|
||
else
|
||
ivar = (@object and index) or scope.freeVariable 'i', single: true
|
||
kvar = ((@range or @from) and name) or index or ivar
|
||
kvarAssign = if kvar isnt ivar then "#{kvar} = " else ""
|
||
if @step and not @range
|
||
[step, stepVar] = @cacheToCodeFragments @step.cache o, LEVEL_LIST, shouldCacheOrIsAssignable
|
||
stepNum = parseNumber stepVar if @step.isNumber()
|
||
name = ivar if @pattern
|
||
varPart = ''
|
||
guardPart = ''
|
||
defPart = ''
|
||
idt1 = @tab + TAB
|
||
if @range
|
||
forPartFragments = source.compileToFragments merge o,
|
||
{index: ivar, name, @step, shouldCache: shouldCacheOrIsAssignable}
|
||
else
|
||
svar = @source.compile o, LEVEL_LIST
|
||
if (name or @own) and not @from and @source.unwrap() not instanceof IdentifierLiteral
|
||
defPart += "#{@tab}#{ref = scope.freeVariable 'ref'} = #{svar};\n"
|
||
svar = ref
|
||
if name and not @pattern and not @from
|
||
namePart = "#{name} = #{svar}[#{kvar}]"
|
||
if not @object and not @from
|
||
defPart += "#{@tab}#{step};\n" if step isnt stepVar
|
||
down = stepNum < 0
|
||
lvar = scope.freeVariable 'len' unless @step and stepNum? and down
|
||
declare = "#{kvarAssign}#{ivar} = 0, #{lvar} = #{svar}.length"
|
||
declareDown = "#{kvarAssign}#{ivar} = #{svar}.length - 1"
|
||
compare = "#{ivar} < #{lvar}"
|
||
compareDown = "#{ivar} >= 0"
|
||
if @step
|
||
if stepNum?
|
||
if down
|
||
compare = compareDown
|
||
declare = declareDown
|
||
else
|
||
compare = "#{stepVar} > 0 ? #{compare} : #{compareDown}"
|
||
declare = "(#{stepVar} > 0 ? (#{declare}) : #{declareDown})"
|
||
increment = "#{ivar} += #{stepVar}"
|
||
else
|
||
increment = "#{if kvar isnt ivar then "++#{ivar}" else "#{ivar}++"}"
|
||
forPartFragments = [@makeCode("#{declare}; #{compare}; #{kvarAssign}#{increment}")]
|
||
if @returns
|
||
resultPart = "#{@tab}#{rvar} = [];\n"
|
||
returnResult = "\n#{@tab}return #{rvar};"
|
||
body.makeReturn rvar
|
||
if @guard
|
||
if body.expressions.length > 1
|
||
body.expressions.unshift new If (new Parens @guard).invert(), new StatementLiteral "continue"
|
||
else
|
||
body = Block.wrap [new If @guard, body] if @guard
|
||
if @pattern
|
||
body.expressions.unshift new Assign @name, if @from then new IdentifierLiteral kvar else new Literal "#{svar}[#{kvar}]"
|
||
|
||
varPart = "\n#{idt1}#{namePart};" if namePart
|
||
if @object
|
||
forPartFragments = [@makeCode("#{kvar} in #{svar}")]
|
||
guardPart = "\n#{idt1}if (!#{utility 'hasProp', o}.call(#{svar}, #{kvar})) continue;" if @own
|
||
else if @from
|
||
if @await
|
||
forPartFragments = new Op 'await', new Parens new Literal "#{kvar} of #{svar}"
|
||
forPartFragments = forPartFragments.compileToFragments o, LEVEL_TOP
|
||
else
|
||
forPartFragments = [@makeCode("#{kvar} of #{svar}")]
|
||
bodyFragments = body.compileToFragments merge(o, indent: idt1), LEVEL_TOP
|
||
if bodyFragments and bodyFragments.length > 0
|
||
bodyFragments = [].concat @makeCode('\n'), bodyFragments, @makeCode('\n')
|
||
|
||
fragments = [@makeCode(defPart)]
|
||
fragments.push @makeCode(resultPart) if resultPart
|
||
forCode = if @await then 'for ' else 'for ('
|
||
forClose = if @await then '' else ')'
|
||
fragments = fragments.concat @makeCode(@tab), @makeCode( forCode),
|
||
forPartFragments, @makeCode("#{forClose} {#{guardPart}#{varPart}"), bodyFragments,
|
||
@makeCode(@tab), @makeCode('}')
|
||
fragments.push @makeCode(returnResult) if returnResult
|
||
fragments
|
||
|
||
astNode: (o) ->
|
||
addToScope = (name) ->
|
||
alreadyDeclared = o.scope.find name.value
|
||
name.isDeclaration = not alreadyDeclared
|
||
@name?.eachName addToScope, checkAssignability: no
|
||
@index?.eachName addToScope, checkAssignability: no
|
||
super o
|
||
|
||
astType: -> 'For'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
source: @source?.ast o
|
||
body: @body.ast o, LEVEL_TOP
|
||
guard: @guard?.ast(o) ? null
|
||
name: @name?.ast(o) ? null
|
||
index: @index?.ast(o) ? null
|
||
step: @step?.ast(o) ? null
|
||
postfix: !!@postfix
|
||
own: !!@own
|
||
await: !!@await
|
||
style: switch
|
||
when @from then 'from'
|
||
when @object then 'of'
|
||
when @name then 'in'
|
||
else 'range'
|
||
|
||
#### Switch
|
||
|
||
# A JavaScript *switch* statement. Converts into a returnable expression on-demand.
|
||
exports.Switch = class Switch extends Base
|
||
constructor: (@subject, @cases, @otherwise) ->
|
||
super()
|
||
|
||
children: ['subject', 'cases', 'otherwise']
|
||
|
||
isStatement: YES
|
||
|
||
jumps: (o = {block: yes}) ->
|
||
for {block} in @cases
|
||
return jumpNode if jumpNode = block.jumps o
|
||
@otherwise?.jumps o
|
||
|
||
makeReturn: (results, mark) ->
|
||
block.makeReturn(results, mark) for {block} in @cases
|
||
@otherwise or= new Block [new Literal 'void 0'] if results
|
||
@otherwise?.makeReturn results, mark
|
||
this
|
||
|
||
compileNode: (o) ->
|
||
idt1 = o.indent + TAB
|
||
idt2 = o.indent = idt1 + TAB
|
||
fragments = [].concat @makeCode(@tab + "switch ("),
|
||
(if @subject then @subject.compileToFragments(o, LEVEL_PAREN) else @makeCode "false"),
|
||
@makeCode(") {\n")
|
||
for {conditions, block}, i in @cases
|
||
for cond in flatten [conditions]
|
||
cond = cond.invert() unless @subject
|
||
fragments = fragments.concat @makeCode(idt1 + "case "), cond.compileToFragments(o, LEVEL_PAREN), @makeCode(":\n")
|
||
fragments = fragments.concat body, @makeCode('\n') if (body = block.compileToFragments o, LEVEL_TOP).length > 0
|
||
break if i is @cases.length - 1 and not @otherwise
|
||
expr = @lastNode block.expressions
|
||
continue if expr instanceof Return or expr instanceof Throw or (expr instanceof Literal and expr.jumps() and expr.value isnt 'debugger')
|
||
fragments.push cond.makeCode(idt2 + 'break;\n')
|
||
if @otherwise and @otherwise.expressions.length
|
||
fragments.push @makeCode(idt1 + "default:\n"), (@otherwise.compileToFragments o, LEVEL_TOP)..., @makeCode("\n")
|
||
fragments.push @makeCode @tab + '}'
|
||
fragments
|
||
|
||
astType: -> 'SwitchStatement'
|
||
|
||
casesAst: (o) ->
|
||
cases = []
|
||
|
||
for kase, caseIndex in @cases
|
||
{conditions: tests, block: consequent} = kase
|
||
tests = flatten [tests]
|
||
lastTestIndex = tests.length - 1
|
||
for test, testIndex in tests
|
||
testConsequent =
|
||
if testIndex is lastTestIndex
|
||
consequent
|
||
else
|
||
null
|
||
|
||
caseLocationData = test.locationData
|
||
caseLocationData = mergeLocationData caseLocationData, testConsequent.expressions[testConsequent.expressions.length - 1].locationData if testConsequent?.expressions.length
|
||
caseLocationData = mergeLocationData caseLocationData, kase.locationData, justLeading: yes if testIndex is 0
|
||
caseLocationData = mergeLocationData caseLocationData, kase.locationData, justEnding: yes if testIndex is lastTestIndex
|
||
|
||
cases.push new SwitchCase(test, testConsequent, trailing: testIndex is lastTestIndex).withLocationDataFrom locationData: caseLocationData
|
||
|
||
if @otherwise?.expressions.length
|
||
cases.push new SwitchCase(null, @otherwise).withLocationDataFrom @otherwise
|
||
|
||
kase.ast(o) for kase in cases
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
discriminant: @subject?.ast(o, LEVEL_PAREN) ? null
|
||
cases: @casesAst o
|
||
|
||
class SwitchCase extends Base
|
||
constructor: (@test, @block, {@trailing} = {}) ->
|
||
super()
|
||
|
||
children: ['test', 'block']
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
test: @test?.ast(o, LEVEL_PAREN) ? null
|
||
consequent: @block?.ast(o, LEVEL_TOP).body ? []
|
||
trailing: !!@trailing
|
||
|
||
exports.SwitchWhen = class SwitchWhen extends Base
|
||
constructor: (@conditions, @block) ->
|
||
super()
|
||
|
||
children: ['conditions', 'block']
|
||
|
||
#### If
|
||
|
||
# *If/else* statements. Acts as an expression by pushing down requested returns
|
||
# to the last line of each clause.
|
||
#
|
||
# Single-expression **Ifs** are compiled into conditional operators if possible,
|
||
# because ternaries are already proper expressions, and don’t need conversion.
|
||
exports.If = class If extends Base
|
||
constructor: (@condition, @body, options = {}) ->
|
||
super()
|
||
@elseBody = null
|
||
@isChain = false
|
||
{@soak, @postfix, @type} = options
|
||
moveComments @condition, @ if @condition.comments
|
||
|
||
children: ['condition', 'body', 'elseBody']
|
||
|
||
bodyNode: -> @body?.unwrap()
|
||
elseBodyNode: -> @elseBody?.unwrap()
|
||
|
||
# Rewrite a chain of **Ifs** to add a default case as the final *else*.
|
||
addElse: (elseBody) ->
|
||
if @isChain
|
||
@elseBodyNode().addElse elseBody
|
||
@locationData = mergeLocationData @locationData, @elseBodyNode().locationData
|
||
else
|
||
@isChain = elseBody instanceof If
|
||
@elseBody = @ensureBlock elseBody
|
||
@elseBody.updateLocationDataIfMissing elseBody.locationData
|
||
@locationData = mergeLocationData @locationData, @elseBody.locationData if @locationData? and @elseBody.locationData?
|
||
this
|
||
|
||
# The **If** only compiles into a statement if either of its bodies needs
|
||
# to be a statement. Otherwise a conditional operator is safe.
|
||
isStatement: (o) ->
|
||
o?.level is LEVEL_TOP or
|
||
@bodyNode().isStatement(o) or @elseBodyNode()?.isStatement(o)
|
||
|
||
jumps: (o) -> @body.jumps(o) or @elseBody?.jumps(o)
|
||
|
||
compileNode: (o) ->
|
||
if @isStatement o then @compileStatement o else @compileExpression o
|
||
|
||
makeReturn: (results, mark) ->
|
||
if mark
|
||
@body?.makeReturn results, mark
|
||
@elseBody?.makeReturn results, mark
|
||
return
|
||
@elseBody or= new Block [new Literal 'void 0'] if results
|
||
@body and= new Block [@body.makeReturn results]
|
||
@elseBody and= new Block [@elseBody.makeReturn results]
|
||
this
|
||
|
||
ensureBlock: (node) ->
|
||
if node instanceof Block then node else new Block [node]
|
||
|
||
# Compile the `If` as a regular *if-else* statement. Flattened chains
|
||
# force inner *else* bodies into statement form.
|
||
compileStatement: (o) ->
|
||
child = del o, 'chainChild'
|
||
exeq = del o, 'isExistentialEquals'
|
||
|
||
if exeq
|
||
return new If(@processedCondition().invert(), @elseBodyNode(), type: 'if').compileToFragments o
|
||
|
||
indent = o.indent + TAB
|
||
cond = @processedCondition().compileToFragments o, LEVEL_PAREN
|
||
body = @ensureBlock(@body).compileToFragments merge o, {indent}
|
||
ifPart = [].concat @makeCode("if ("), cond, @makeCode(") {\n"), body, @makeCode("\n#{@tab}}")
|
||
ifPart.unshift @makeCode @tab unless child
|
||
return ifPart unless @elseBody
|
||
answer = ifPart.concat @makeCode(' else ')
|
||
if @isChain
|
||
o.chainChild = yes
|
||
answer = answer.concat @elseBody.unwrap().compileToFragments o, LEVEL_TOP
|
||
else
|
||
answer = answer.concat @makeCode("{\n"), @elseBody.compileToFragments(merge(o, {indent}), LEVEL_TOP), @makeCode("\n#{@tab}}")
|
||
answer
|
||
|
||
# Compile the `If` as a conditional operator.
|
||
compileExpression: (o) ->
|
||
cond = @processedCondition().compileToFragments o, LEVEL_COND
|
||
body = @bodyNode().compileToFragments o, LEVEL_LIST
|
||
alt = if @elseBodyNode() then @elseBodyNode().compileToFragments(o, LEVEL_LIST) else [@makeCode('void 0')]
|
||
fragments = cond.concat @makeCode(" ? "), body, @makeCode(" : "), alt
|
||
if o.level >= LEVEL_COND then @wrapInParentheses fragments else fragments
|
||
|
||
unfoldSoak: ->
|
||
@soak and this
|
||
|
||
processedCondition: ->
|
||
@processedConditionCache ?= if @type is 'unless' then @condition.invert() else @condition
|
||
|
||
isStatementAst: (o) ->
|
||
o.level is LEVEL_TOP
|
||
|
||
astType: (o) ->
|
||
if @isStatementAst o
|
||
'IfStatement'
|
||
else
|
||
'ConditionalExpression'
|
||
|
||
astProperties: (o) ->
|
||
isStatement = @isStatementAst o
|
||
|
||
return
|
||
test: @condition.ast o, if isStatement then LEVEL_PAREN else LEVEL_COND
|
||
consequent:
|
||
if isStatement
|
||
@body.ast o, LEVEL_TOP
|
||
else
|
||
@bodyNode().ast o, LEVEL_TOP
|
||
alternate:
|
||
if @isChain
|
||
@elseBody.unwrap().ast o, if isStatement then LEVEL_TOP else LEVEL_COND
|
||
else if not isStatement and @elseBody?.expressions?.length is 1
|
||
@elseBody.expressions[0].ast o, LEVEL_TOP
|
||
else
|
||
@elseBody?.ast(o, LEVEL_TOP) ? null
|
||
postfix: !!@postfix
|
||
inverted: @type is 'unless'
|
||
|
||
# A sequence expression e.g. `(a; b)`.
|
||
# Currently only used during AST generation.
|
||
exports.Sequence = class Sequence extends Base
|
||
children: ['expressions']
|
||
|
||
constructor: (@expressions) ->
|
||
super()
|
||
|
||
astNode: (o) ->
|
||
return @expressions[0].ast(o) if @expressions.length is 1
|
||
super o
|
||
|
||
astType: -> 'SequenceExpression'
|
||
|
||
astProperties: (o) ->
|
||
return
|
||
expressions:
|
||
expression.ast(o) for expression in @expressions
|
||
|
||
# Constants
|
||
# ---------
|
||
|
||
UTILITIES =
|
||
modulo: -> 'function(a, b) { return (+a % (b = +b) + b) % b; }'
|
||
|
||
boundMethodCheck: -> "
|
||
function(instance, Constructor) {
|
||
if (!(instance instanceof Constructor)) {
|
||
throw new Error('Bound instance method accessed before binding');
|
||
}
|
||
}
|
||
"
|
||
|
||
# Shortcuts to speed up the lookup time for native functions.
|
||
hasProp: -> '{}.hasOwnProperty'
|
||
indexOf: -> '[].indexOf'
|
||
slice : -> '[].slice'
|
||
splice : -> '[].splice'
|
||
|
||
# Levels indicate a node's position in the AST. Useful for knowing if
|
||
# parens are necessary or superfluous.
|
||
LEVEL_TOP = 1 # ...;
|
||
LEVEL_PAREN = 2 # (...)
|
||
LEVEL_LIST = 3 # [...]
|
||
LEVEL_COND = 4 # ... ? x : y
|
||
LEVEL_OP = 5 # !...
|
||
LEVEL_ACCESS = 6 # ...[0]
|
||
|
||
# Tabs are two spaces for pretty printing.
|
||
TAB = ' '
|
||
|
||
SIMPLENUM = /^[+-]?\d+(?:_\d+)*$/
|
||
SIMPLE_STRING_OMIT = /\s*\n\s*/g
|
||
LEADING_BLANK_LINE = /^[^\n\S]*\n/
|
||
TRAILING_BLANK_LINE = /\n[^\n\S]*$/
|
||
STRING_OMIT = ///
|
||
((?:\\\\)+) # Consume (and preserve) an even number of backslashes.
|
||
| \\[^\S\n]*\n\s* # Remove escaped newlines.
|
||
///g
|
||
HEREGEX_OMIT = ///
|
||
((?:\\\\)+) # Consume (and preserve) an even number of backslashes.
|
||
| \\(\s) # Preserve escaped whitespace.
|
||
| \s+(?:#.*)? # Remove whitespace and comments.
|
||
///g
|
||
|
||
# Helper Functions
|
||
# ----------------
|
||
|
||
# Helper for ensuring that utility functions are assigned at the top level.
|
||
utility = (name, o) ->
|
||
{root} = o.scope
|
||
if name of root.utilities
|
||
root.utilities[name]
|
||
else
|
||
ref = root.freeVariable name
|
||
root.assign ref, UTILITIES[name] o
|
||
root.utilities[name] = ref
|
||
|
||
multident = (code, tab, includingFirstLine = yes) ->
|
||
endsWithNewLine = code[code.length - 1] is '\n'
|
||
code = (if includingFirstLine then tab else '') + code.replace /\n/g, "$&#{tab}"
|
||
code = code.replace /\s+$/, ''
|
||
code = code + '\n' if endsWithNewLine
|
||
code
|
||
|
||
# Wherever in CoffeeScript 1 we might’ve inserted a `makeCode "#{@tab}"` to
|
||
# indent a line of code, now we must account for the possibility of comments
|
||
# preceding that line of code. If there are such comments, indent each line of
|
||
# such comments, and _then_ indent the first following line of code.
|
||
indentInitial = (fragments, node) ->
|
||
for fragment, fragmentIndex in fragments
|
||
if fragment.isHereComment
|
||
fragment.code = multident fragment.code, node.tab
|
||
else
|
||
fragments.splice fragmentIndex, 0, node.makeCode "#{node.tab}"
|
||
break
|
||
fragments
|
||
|
||
hasLineComments = (node) ->
|
||
return no unless node.comments
|
||
for comment in node.comments
|
||
return yes if comment.here is no
|
||
return no
|
||
|
||
# Move the `comments` property from one object to another, deleting it from
|
||
# the first object.
|
||
moveComments = (from, to) ->
|
||
return unless from?.comments
|
||
attachCommentsToNode from.comments, to
|
||
delete from.comments
|
||
|
||
# Sometimes when compiling a node, we want to insert a fragment at the start
|
||
# of an array of fragments; but if the start has one or more comment fragments,
|
||
# we want to insert this fragment after those but before any non-comments.
|
||
unshiftAfterComments = (fragments, fragmentToInsert) ->
|
||
inserted = no
|
||
for fragment, fragmentIndex in fragments when not fragment.isComment
|
||
fragments.splice fragmentIndex, 0, fragmentToInsert
|
||
inserted = yes
|
||
break
|
||
fragments.push fragmentToInsert unless inserted
|
||
fragments
|
||
|
||
isLiteralArguments = (node) ->
|
||
node instanceof IdentifierLiteral and node.value is 'arguments'
|
||
|
||
isLiteralThis = (node) ->
|
||
node instanceof ThisLiteral or (node instanceof Code and node.bound)
|
||
|
||
shouldCacheOrIsAssignable = (node) -> node.shouldCache() or node.isAssignable?()
|
||
|
||
# Unfold a node's child if soak, then tuck the node under created `If`
|
||
unfoldSoak = (o, parent, name) ->
|
||
return unless ifn = parent[name].unfoldSoak o
|
||
parent[name] = ifn.body
|
||
ifn.body = new Value parent
|
||
ifn
|
||
|
||
# Constructs a string or regex by escaping certain characters.
|
||
makeDelimitedLiteral = (body, {delimiter: delimiterOption, escapeNewlines, double, includeDelimiters = yes, escapeDelimiter = yes, convertTrailingNullEscapes} = {}) ->
|
||
body = '(?:)' if body is '' and delimiterOption is '/'
|
||
escapeTemplateLiteralCurlies = delimiterOption is '`'
|
||
regex = ///
|
||
(\\\\) # Escaped backslash.
|
||
| (\\0(?=\d)) # Null character mistaken as octal escape.
|
||
#{
|
||
if convertTrailingNullEscapes
|
||
/// | (\\0) $ ///.source # Trailing null character that could be mistaken as octal escape.
|
||
else
|
||
''
|
||
}
|
||
#{
|
||
if escapeDelimiter
|
||
/// | \\?(#{delimiterOption}) ///.source # (Possibly escaped) delimiter.
|
||
else
|
||
''
|
||
}
|
||
#{
|
||
if escapeTemplateLiteralCurlies
|
||
/// | \\?(\$\{) ///.source # `${` inside template literals must be escaped.
|
||
else
|
||
''
|
||
}
|
||
| \\?(?:
|
||
#{if escapeNewlines then '(\n)|' else ''}
|
||
(\r)
|
||
| (\u2028)
|
||
| (\u2029)
|
||
) # (Possibly escaped) newlines.
|
||
| (\\.) # Other escapes.
|
||
///g
|
||
body = body.replace regex, (match, backslash, nul, ...args) ->
|
||
trailingNullEscape =
|
||
args.shift() if convertTrailingNullEscapes
|
||
delimiter =
|
||
args.shift() if escapeDelimiter
|
||
templateLiteralCurly =
|
||
args.shift() if escapeTemplateLiteralCurlies
|
||
lf =
|
||
args.shift() if escapeNewlines
|
||
[cr, ls, ps, other] = args
|
||
switch
|
||
# Ignore escaped backslashes.
|
||
when backslash then (if double then backslash + backslash else backslash)
|
||
when nul then '\\x00'
|
||
when trailingNullEscape then "\\x00"
|
||
when delimiter then "\\#{delimiter}"
|
||
when templateLiteralCurly then "\\${"
|
||
when lf then '\\n'
|
||
when cr then '\\r'
|
||
when ls then '\\u2028'
|
||
when ps then '\\u2029'
|
||
when other then (if double then "\\#{other}" else other)
|
||
printedDelimiter = if includeDelimiters then delimiterOption else ''
|
||
"#{printedDelimiter}#{body}#{printedDelimiter}"
|
||
|
||
sniffDirectives = (expressions, {notFinalExpression} = {}) ->
|
||
index = 0
|
||
lastIndex = expressions.length - 1
|
||
while index <= lastIndex
|
||
break if index is lastIndex and notFinalExpression
|
||
expression = expressions[index]
|
||
if (unwrapped = expression?.unwrap?()) instanceof PassthroughLiteral and unwrapped.generated
|
||
index++
|
||
continue
|
||
break unless expression instanceof Value and expression.isString() and not expression.unwrap().shouldGenerateTemplateLiteral()
|
||
expressions[index] =
|
||
new Directive expression
|
||
.withLocationDataFrom expression
|
||
index++
|
||
|
||
astAsBlockIfNeeded = (node, o) ->
|
||
unwrapped = node.unwrap()
|
||
if unwrapped instanceof Block and unwrapped.expressions.length > 1
|
||
unwrapped.makeReturn null, yes
|
||
unwrapped.ast o, LEVEL_TOP
|
||
else
|
||
node.ast o, LEVEL_PAREN
|
||
|
||
# Helpers for `mergeLocationData` and `mergeAstLocationData` below.
|
||
lesser = (a, b) -> if a < b then a else b
|
||
greater = (a, b) -> if a > b then a else b
|
||
|
||
isAstLocGreater = (a, b) ->
|
||
return yes if a.line > b.line
|
||
return no unless a.line is b.line
|
||
a.column > b.column
|
||
|
||
isLocationDataStartGreater = (a, b) ->
|
||
return yes if a.first_line > b.first_line
|
||
return no unless a.first_line is b.first_line
|
||
a.first_column > b.first_column
|
||
|
||
isLocationDataEndGreater = (a, b) ->
|
||
return yes if a.last_line > b.last_line
|
||
return no unless a.last_line is b.last_line
|
||
a.last_column > b.last_column
|
||
|
||
# Take two nodes’ location data and return a new `locationData` object that
|
||
# encompasses the location data of both nodes. So the new `first_line` value
|
||
# will be the earlier of the two nodes’ `first_line` values, the new
|
||
# `last_column` the later of the two nodes’ `last_column` values, etc.
|
||
#
|
||
# If you only want to extend the first node’s location data with the start or
|
||
# end location data of the second node, pass the `justLeading` or `justEnding`
|
||
# options. So e.g. if `first`’s range is [4, 5] and `second`’s range is [1, 10],
|
||
# you’d get:
|
||
# ```
|
||
# mergeLocationData(first, second).range # [1, 10]
|
||
# mergeLocationData(first, second, justLeading: yes).range # [1, 5]
|
||
# mergeLocationData(first, second, justEnding: yes).range # [4, 10]
|
||
# ```
|
||
exports.mergeLocationData = mergeLocationData = (locationDataA, locationDataB, {justLeading, justEnding} = {}) ->
|
||
return Object.assign(
|
||
if justEnding
|
||
first_line: locationDataA.first_line
|
||
first_column: locationDataA.first_column
|
||
else
|
||
if isLocationDataStartGreater locationDataA, locationDataB
|
||
first_line: locationDataB.first_line
|
||
first_column: locationDataB.first_column
|
||
else
|
||
first_line: locationDataA.first_line
|
||
first_column: locationDataA.first_column
|
||
,
|
||
if justLeading
|
||
last_line: locationDataA.last_line
|
||
last_column: locationDataA.last_column
|
||
last_line_exclusive: locationDataA.last_line_exclusive
|
||
last_column_exclusive: locationDataA.last_column_exclusive
|
||
else
|
||
if isLocationDataEndGreater locationDataA, locationDataB
|
||
last_line: locationDataA.last_line
|
||
last_column: locationDataA.last_column
|
||
last_line_exclusive: locationDataA.last_line_exclusive
|
||
last_column_exclusive: locationDataA.last_column_exclusive
|
||
else
|
||
last_line: locationDataB.last_line
|
||
last_column: locationDataB.last_column
|
||
last_line_exclusive: locationDataB.last_line_exclusive
|
||
last_column_exclusive: locationDataB.last_column_exclusive
|
||
,
|
||
range: [
|
||
if justEnding
|
||
locationDataA.range[0]
|
||
else
|
||
lesser locationDataA.range[0], locationDataB.range[0]
|
||
,
|
||
if justLeading
|
||
locationDataA.range[1]
|
||
else
|
||
greater locationDataA.range[1], locationDataB.range[1]
|
||
]
|
||
)
|
||
|
||
# Take two AST nodes, or two AST nodes’ location data objects, and return a new
|
||
# location data object that encompasses the location data of both nodes. So the
|
||
# new `start` value will be the earlier of the two nodes’ `start` values, the
|
||
# new `end` value will be the later of the two nodes’ `end` values, etc.
|
||
#
|
||
# If you only want to extend the first node’s location data with the start or
|
||
# end location data of the second node, pass the `justLeading` or `justEnding`
|
||
# options. So e.g. if `first`’s range is [4, 5] and `second`’s range is [1, 10],
|
||
# you’d get:
|
||
# ```
|
||
# mergeAstLocationData(first, second).range # [1, 10]
|
||
# mergeAstLocationData(first, second, justLeading: yes).range # [1, 5]
|
||
# mergeAstLocationData(first, second, justEnding: yes).range # [4, 10]
|
||
# ```
|
||
exports.mergeAstLocationData = mergeAstLocationData = (nodeA, nodeB, {justLeading, justEnding} = {}) ->
|
||
return
|
||
loc:
|
||
start:
|
||
if justEnding
|
||
nodeA.loc.start
|
||
else
|
||
if isAstLocGreater nodeA.loc.start, nodeB.loc.start
|
||
nodeB.loc.start
|
||
else
|
||
nodeA.loc.start
|
||
end:
|
||
if justLeading
|
||
nodeA.loc.end
|
||
else
|
||
if isAstLocGreater nodeA.loc.end, nodeB.loc.end
|
||
nodeA.loc.end
|
||
else
|
||
nodeB.loc.end
|
||
range: [
|
||
if justEnding
|
||
nodeA.range[0]
|
||
else
|
||
lesser nodeA.range[0], nodeB.range[0]
|
||
,
|
||
if justLeading
|
||
nodeA.range[1]
|
||
else
|
||
greater nodeA.range[1], nodeB.range[1]
|
||
]
|
||
start:
|
||
if justEnding
|
||
nodeA.start
|
||
else
|
||
lesser nodeA.start, nodeB.start
|
||
end:
|
||
if justLeading
|
||
nodeA.end
|
||
else
|
||
greater nodeA.end, nodeB.end
|
||
|
||
# Convert Jison-style node class location data to Babel-style location data
|
||
exports.jisonLocationDataToAstLocationData = jisonLocationDataToAstLocationData = ({first_line, first_column, last_line_exclusive, last_column_exclusive, range}) ->
|
||
return
|
||
loc:
|
||
start:
|
||
line: first_line + 1
|
||
column: first_column
|
||
end:
|
||
line: last_line_exclusive + 1
|
||
column: last_column_exclusive
|
||
range: [
|
||
range[0]
|
||
range[1]
|
||
]
|
||
start: range[0]
|
||
end: range[1]
|
||
|
||
# Generate a zero-width location data that corresponds to the end of another node’s location.
|
||
zeroWidthLocationDataFromEndLocation = ({range: [, endRange], last_line_exclusive, last_column_exclusive}) -> {
|
||
first_line: last_line_exclusive
|
||
first_column: last_column_exclusive
|
||
last_line: last_line_exclusive
|
||
last_column: last_column_exclusive
|
||
last_line_exclusive
|
||
last_column_exclusive
|
||
range: [endRange, endRange]
|
||
}
|
||
|
||
extractSameLineLocationDataFirst = (numChars) -> ({range: [startRange], first_line, first_column}) -> {
|
||
first_line
|
||
first_column
|
||
last_line: first_line
|
||
last_column: first_column + numChars - 1
|
||
last_line_exclusive: first_line
|
||
last_column_exclusive: first_column + numChars
|
||
range: [startRange, startRange + numChars]
|
||
}
|
||
|
||
extractSameLineLocationDataLast = (numChars) -> ({range: [, endRange], last_line, last_column, last_line_exclusive, last_column_exclusive}) -> {
|
||
first_line: last_line
|
||
first_column: last_column - (numChars - 1)
|
||
last_line: last_line
|
||
last_column: last_column
|
||
last_line_exclusive
|
||
last_column_exclusive
|
||
range: [endRange - numChars, endRange]
|
||
}
|
||
|
||
# We don’t currently have a token corresponding to the empty space
|
||
# between interpolation/JSX expression braces, so piece together the location
|
||
# data by trimming the braces from the Interpolation’s location data.
|
||
# Technically the last_line/last_column calculation here could be
|
||
# incorrect if the ending brace is preceded by a newline, but
|
||
# last_line/last_column aren’t used for AST generation anyway.
|
||
emptyExpressionLocationData = ({interpolationNode: element, openingBrace, closingBrace}) ->
|
||
first_line: element.locationData.first_line
|
||
first_column: element.locationData.first_column + openingBrace.length
|
||
last_line: element.locationData.last_line
|
||
last_column: element.locationData.last_column - closingBrace.length
|
||
last_line_exclusive: element.locationData.last_line
|
||
last_column_exclusive: element.locationData.last_column
|
||
range: [
|
||
element.locationData.range[0] + openingBrace.length
|
||
element.locationData.range[1] - closingBrace.length
|
||
]
|