nodes.coffee

Error.stackTraceLimit = Infinity

{Scope} = require './scope'
{isUnassignable, JS_FORBIDDEN} = require './lexer'

{compact, flatten, extend, merge, del, starts, ends, some,
addDataToNode, attachCommentsToNode, locationDataToString,
throwSyntaxError, replaceUnicodeCodePointEscapes,
isFunction, isPlainObject, isNumber, parseNumber} = require './helpers'

exports.extend = extend
exports.addDataToNode = addDataToNode

YES     = -> yes
NO      = -> no
THIS    = -> this
NEGATE  = -> @negated = not @negated; this

exports.CodeFragment = class CodeFragment
  constructor: (parent, code) ->
    @code = "#{code}"
    @type = parent?.constructor?.name or 'unknown'
    @locationData = parent?.locationData
    @comments = parent?.comments

  toString: ->

    "#{@code}#{if @locationData then ": " + locationDataToString(@locationData) else ''}"

fragmentsToText = (fragments) ->
  (fragment.code for fragment in fragments).join('')

exports.Base = class Base

  compile: (o, lvl) ->
    fragmentsToText @compileToFragments o, lvl

  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'

  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'

  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

    unshiftCommentFragment = (commentFragment) ->
      if commentFragment.unshift

        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.

      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()

        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

  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]

  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])]

  makeReturn: (results, mark) ->
    if mark

      @canBeReturned = yes
      return
    node = @unwrapAll()
    if results
      new Call new Literal("#{results}.push"), [node]
    else
      new Return node

  contains: (pred) ->
    node = undefined
    @traverseChildren no, (n) ->
      if pred n
        node = n
        return no
    node

  lastNode: (list) ->
    if list.length is 0 then null else list[list.length - 1]

  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'

  ast: (o, level) ->

    o = @astInitialize o, level

    astNode = @astNode o

    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 null, yes if @isStatement(o) and o.level isnt LEVEL_TOP and o.scope?
    o

  astNode: (o) ->

    Object.assign {}, {type: @astType(o)}, @astProperties(o), @astLocationData()

  astProperties: -> {}

  astType: -> @constructor.name

  astLocationData: ->
    jisonLocationDataToAstLocationData @locationData

  isStatementAst: (o) ->
    @isStatement o

  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: (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

  children: []

  isStatement: NO

  compiledComments: []

  includeCommentFragments: NO

  jumps: NO

  shouldCache: YES

  isChainable: NO
  isAssignable: NO
  isNumber: NO

  unwrap: THIS
  unfoldSoak: NO

  assigns: NO

  updateLocationDataIfMissing: (locationData, force) ->
    @forceUpdateLocation = yes if force
    return this if @locationData and not @forceUpdateLocation
    delete @forceUpdateLocation
    @locationData = locationData

    @eachChild (child) ->
      child.updateLocationDataIfMissing locationData

  withLocationDataFrom: ({locationData}) ->
    @updateLocationDataIfMissing locationData

  withLocationDataAndCommentsFrom: (node) ->
    @withLocationDataFrom node
    {comments} = node
    @comments = comments if comments?.length
    this

  error: (message) ->
    throwSyntaxError message, @locationData

  makeCode: (code) ->
    new CodeFragment this, code

  wrapInParentheses: (fragments) ->
    [@makeCode('('), fragments..., @makeCode(')')]

  wrapInBraces: (fragments) ->
    [@makeCode('{'), fragments..., @makeCode('}')]

  joinFragmentArrays: (fragmentsList, joinStr) ->
    answer = []
    for fragments, i in fragmentsList
      if i then answer.push @makeCode joinStr
      answer = answer.concat fragments
    answer

exports.HoistTarget = class HoistTarget extends Base

  @expand = (fragments) ->
    for fragment, i in fragments by -1 when fragment.fragments
      fragments[i..i] = @expand fragment.fragments
    fragments

  constructor: (@source) ->
    super()

    @options = {}

    @targetFragments = { fragments: [] }

  isStatement: (o) ->
    @source.isStatement o

  update: (compile, o) ->
    @targetFragments.fragments = compile.call @source, merge o, @options

  compileToFragments: (o, level) ->
    @options.indent = o.indent
    @options.level  = level ? o.level
    [ @targetFragments ]

  compileNode: (o) ->
    @compileToFragments o

  compileClosure: (o) ->
    @compileToFragments o

exports.Root = class Root extends Base
  constructor: (@body) ->
    super()

    @isAsync = (new Code [], @body).isAsync

  children: ['body']

  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 ? []

    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()

exports.Block = class Block extends Base
  constructor: (nodes) ->
    super()

    @expressions = compact flatten nodes or []

  children: ['expressions']

  push: (node) ->
    @expressions.push node
    this

  pop: ->
    @expressions.pop()

  unshift: (node) ->
    @expressions.unshift node
    this

  unwrap: ->
    if @expressions.length is 1 then @expressions[0] else this

  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

  makeReturn: (results, mark) ->
    len = @expressions.length
    [..., lastExp] = @expressions
    lastExp = lastExp?.unwrap() or no

    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

  compileNode: (o) ->
    @tab  = o.indent
    top   = o.level is LEVEL_TOP
    compiledNodes = []

    for node, index in @expressions
      if node.hoisted

        node.compileToFragments o
        continue
      node = (node.unfoldSoak(o) or node)
      if node instanceof Block

        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

  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

      if fragment.precedingComments

        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

            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

      if fragment.followingComments

        trail = fragment.followingComments[0].trail
        fragmentIndent = ''

        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

        code = if fragmentIndex is 1 and /^\s+$/.test fragments[0].code
          ''
        else if trail
          ' '
        else
          "\n#{fragmentIndent}"

        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

            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

          code = code.replace /^\n/, '' if upcomingFragment.code is '\n'
          upcomingFragment.code = upcomingFragment.code[0...newLineIndex] +
            code + upcomingFragment.code[newLineIndex..]
          break

    fragments

  @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

      if not expressionAst?
        continue
      else if expression instanceof Directive
        directives.push expressionAst

      else if expression.isStatementAst o
        body.push expressionAst

      else
        body.push Object.assign
            type: 'ExpressionStatement'
            expression: expressionAst
          ,
            expression.astLocationData()

    return {

      body, directives
    }

  astLocationData: ->
    return if @isRootBlock and not @locationData?
    super()

exports.Directive = class Directive extends Base
  constructor: (@value) ->
    super()

  astProperties: (o) ->
    return
      value: Object.assign {},
        @value.ast o
        type: 'DirectiveLiteral'

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: ->

    " #{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

  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[-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

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 = []

    if @expression
      answer = @expression.compileToFragments o, LEVEL_PAREN
      unshiftAfterComments answer, @makeCode "#{@tab}return "

      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: ->

    return if @belongsToFuncDirectiveReturn
    super()

  astType: -> 'ReturnStatement'

  astProperties: (o) ->
    argument: @expression?.ast(o, LEVEL_PAREN) ? null

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

exports.YieldReturn = class YieldReturn extends FuncDirectiveReturn
  keyword: 'yield'

exports.AwaitReturn = class AwaitReturn extends FuncDirectiveReturn
  keyword: 'await'

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 @base?.comments and @base instanceof ThisLiteral and @properties[0]?.name?
      moveComments @base, @properties[0].name

  children: ['base', 'properties']

  add: (props) ->
    @properties = @properties.concat props
    @forceUpdateLocation = yes
    this

  hasProperties: ->
    @properties.length isnt 0

  bareLiteral: (type) ->
    not @properties.length and @base instanceof type

  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

  unwrap: ->
    if @properties.length then this else @base

  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])]

  compileNode: (o) ->
    @base.front = @front
    props = @properties
    if props.length and @base.cached?

      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

  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'

  object: ->
    return @ unless @hasProperties()

    initialProperties = @properties[0.[email protected] - 1]

    object = new Value @base, initialProperties, @tag, @isDefaultValue

    object.locationData =
      if initialProperties.length is 0

        @base.locationData
      else

        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) ->

    return @base.ast o unless @hasProperties()

    super o

  astType: ->
    if @isJSXTag()
      'JSXMemberExpression'
    else if @containsSoak()
      'OptionalMemberExpression'
    else
      'MemberExpression'

  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()

    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

exports.HereComment = class HereComment extends Base
  constructor: ({ @content, @newLine, @unshift, @locationData }) ->
    super()

  compileNode: (o) ->
    multiline = '\n' in @content

    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

    fragment.isComment = fragment.isHereComment = yes
    fragment

  astType: -> 'CommentBlock'

  astProperties: ->
    return
      value: @content

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

    fragment.isComment = fragment.isLineComment = yes
    fragment

  astType: -> 'CommentLine'

  astProperties: ->
    return
      value: @content

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 = new JSXAttribute name: new JSXIdentifier(base.value).withLocationDataAndCommentsFrom base
        attribute.locationData = base.locationData
        @attributes.push attribute
      else if not base.generated

        attribute = base.properties[0]
        attribute.jsx = yes
        attribute.locationData = base.locationData
        @attributes.push attribute
      else

        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']

  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

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: ->
    [email protected]

  astNode: (o) ->

    @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

                  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

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]
      )

    if @variable.base?.value is 'RegExp' and @args.length isnt 0
      moveComments @variable, @args[0]

  children: ['variable', 'args']

  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

  newInstance: ->
    base = @variable?.base or @variable
    if base instanceof Call and not base.isNew
      base.newInstance()
    else
      @isNew = true
    @needsUpdatedStartLocation = true
    this

  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

  compileNode: (o) ->
    @checkForNewSuper()
    @variable?.front = @front
    compiledArgs = []

    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

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

      [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

      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

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

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

exports.Extends = class Extends extends Base
  constructor: (@child, @parent) ->
    super()

  children: ['child', 'parent']

  compileToFragments: (o) ->
    new Call(new Value(new Literal utility 'extend', o), [@child, @parent]).compileToFragments o

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) ->

    @name.ast o

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) ->

    @index.ast o

exports.Range = class Range extends Base

  children: ['from', 'to']

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

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

  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

  compileNode: (o) ->
    @compileVariables o unless @fromVar
    return @compileArray(o) unless o.index

    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}"]

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

    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}"

    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

    [@makeCode "#{varPart}; #{condPart}; #{stepPart}"]

  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
    }

exports.Slice = class Slice extends Base

  children: ['range']

  constructor: (@range) ->
    super()

  compileNode: (o) ->
    {to, from} = @range

    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

exports.Obj = class Obj extends Base
  constructor: (props, @generated = no) ->
    super()

    @objects = @properties = props or []

  children: ['properties']

  isAssignable: (opts) ->
    for prop in @properties

      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()

  hasSplat: ->
    return yes for prop in @properties when prop instanceof Splat
    no

  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

    @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

          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

            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?

  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

        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'

        @value = value
      else

        @value = fromAssign
        @shorthand = yes
      @locationData = fromAssign.locationData
    else

      @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

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 ','

    passedElision = no

    answer = []
    for obj, objIndex in @objects
      unwrappedObj = obj.unwrapAll()

      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

    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

      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

  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

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

    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

      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

  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

  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

  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)

  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

  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

  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'

        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

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) ->

    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) ->

    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

  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

    @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) ->

    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

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, {

    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

      @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 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

  compileNode: (o) ->
    isValue = @variable instanceof Value
    if isValue

      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

    if o.level > LEVEL_LIST or isValue and @variable.base instanceof Obj and not @nestedLhs and not (@param is yes)
      @wrapInParentheses answer
    else
      answer

  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, ', '

  compileDestructuring: (o) ->
    top       = o.level is LEVEL_TOP
    {value}   = this
    {objects} = @variable.base
    olen      = objects.length

    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

    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

    compSlice = slicer "slice"

    compSplice = slicer "splice"

    hasObjAssigns = (objs) ->
      (i for obj, i in objs when obj instanceof Assign and obj.context is 'object')

    objIsUnassignable = (objs) ->
      return yes for obj in objs when not obj.isAssignable()
      no

    complexObjects = (objs) ->
      hasObjAssigns(objs).length or objIsUnassignable(objs) or olen is 1

    loopObjects = (objs, vvar, vvarTxt) =>
      for obj, i in objs

        continue if obj instanceof Elision

        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

          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

    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

    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

        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

      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

  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'

  getAndCheckSplatsAndExpansions: ->
    return {splats: [], expans: [], splatsAndExpans: []} unless @variable.base instanceof Arr
    {objects} = @variable.base

    splats = (i for obj, i in objects when obj instanceof Splat)

    expans = (i for obj, i in objects when obj instanceof Expansion)

    splatsAndExpans = [splats..., expans...]
    if splatsAndExpans.length > 1

      objects[splatsAndExpans.sort()[1]].error "multiple splats/expansions are disallowed in an assignment"
    {splats, expans, splatsAndExpans}

  compileConditional: (o) ->
    [left, right] = @variable.cacheReference o

    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

  compileSpecialMath: (o) ->
    [left, right] = @variable.cacheReference o
    new Assign(left, new Op(@context[...-1], right, @value)).compileToFragments o

  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?()

    @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

exports.FuncGlyph = class FuncGlyph extends Base
  constructor: (@glyph) ->
    super()

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

  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()

    @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

        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

    for param, i in @params

      if param.splat or param instanceof Expansion
        haveSplatParam = yes
        if param.splat
          if param.name instanceof Arr or param.name instanceof Obj

            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

      else
        if param.shouldCache() or haveBodyParam
          param.assignedInBody = yes
          haveBodyParam = yes

          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'

        unless haveSplatParam

          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

          if param.name instanceof Arr or param.name instanceof Obj

            param.name.lhs = yes
            unless param.shouldCache()
              param.name.eachName (prop) ->
                o.scope.parameter prop.value
          else

            paramToAddToScope = if param.value? then param else ref
            o.scope.parameter fragmentsToText paramToAddToScope.compileToFragmentsWithoutComments o
          params.push ref
        else
          paramsAfterSplat.push param

          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

          o.scope.add param.name.value, 'var', yes if param.name?.value?

    if paramsAfterSplat.length isnt 0

      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

    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

    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'

    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 '(']

    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

      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 ')'

    if @funcGlyph?.comments?
      comment.unshift = no for comment in @funcGlyph.comments
      @compileCommentFragments o, @funcGlyph, signature

    body = @body.compileWithDeclarations o unless @body.isEmpty()

    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

  traverseChildren: (crossScope, func) ->
    super(crossScope, func) if crossScope

  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

      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

  eachSuperCall: (context, iterator, {checkForThisBeforeSuper = yes} = {}) ->
    seenSuper = no

    context.traverseChildren yes, (child) =>
      if child instanceof SuperCall

        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"

      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

      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

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()

  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"

    if name instanceof Literal
      checkAssignabilityOfLiteral name
      return iterator name.value, name, @

    return atParam name if name instanceof Value
    for obj in name.objects ? []

      nObj = obj

      if obj instanceof Assign and not obj.context?
        obj = obj.variable

      if obj instanceof Assign

        if obj.value instanceof Assign
          obj = obj.value.variable
        else
          obj = obj.value
        @eachName iterator, obj.unwrap()

      else if obj instanceof Splat
        node = obj.name.unwrap()
        iterator node.value, node, @
      else if obj instanceof Value

        if obj.isArray() or obj.isObject()
          @eachName iterator, obj.base

        else if obj.this
          atParam obj, nObj

        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

  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

        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

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
  }

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

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

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

  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

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

  CONVERSIONS =
    '==':        '==='
    '!=':        '!=='
    'of':        'in'
    'yieldfrom': 'yield*'

  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()

  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()

    @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

  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

  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

  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