Class: Violet::Parser

Inherits:

Object

• Object
• Violet::Parser

Defined in:

lib/violet/parser.rb

Overview

Public: Parses a JavaScript source string.

Constant Summary

FUTURE_RESERVED_WORDS =

Public: The future reserved words specified in section 7.6.1.2.

%w( class const enum export extends import super )

KEYWORDS =

Public: The reserved keywords specified in section 7.6.1.1, excluding ‘this` and the four unary operators.

%w( break case catch continue debugger default do else finally for function if in instanceof return switch throw try var while with )

LITERALS =

Public: The ‘true`, `false`, and `null` literals specified in section 7.8. The `this` keyword is grouped with the literals for convenience.

%w( this null true false )

UNARY_KEYWORDS =

Public: The four unary keyword operators.

%w( delete void typeof new )

KEYWORD_OR_RESERVED =

Public: A list of reserved words that may not be used as labels or function, argument, or variable names. Comprises the future reserved words, keywords, and literals.

FUTURE_RESERVED_WORDS.dup.push(*KEYWORDS, *LITERALS, *UNARY_KEYWORDS)

LHS_START =

Public: Matches valid left-hand side start operators.

/[-+~!({\[]/

UNARY_OPERATORS =

Public: Matches unary operators.

/[-+~!]/

ASSIGNMENTS =

Public: Matches assignment operators.

/^[\+\-\*\%\&\|\^\/]?=$|^\<\<\=$|^\>{2,3}\=$/

BINARY_OPERATORS =

Public: Matches binary operators.

/^[\+\-\*\%\|\^\&\?\/]$|^[\<\>]\=?$|^[\=\!]\=\=?$|^\<\<|\>\>\>?$|^\&\&$|^\|\|$/

STATEMENT_ERROR =

Internal: The error message produced when a statement cannot be parsed.

"Expected a statement."

PARSE_EXPRESSIONS_DEFAULTS =

Internal: A ‘Hash` containing the default options for the `expressions` method.

{
  # If the two initial tokens comprise an identifier followed by a colon
  # and this option is set to `true`, the parser will treat the lexed
  # token as a labeled statement. The identifier must not be a reserved
  # word.
  :label => false,
  # Parses a single assignment expression if set to `true`.
  :single => false,
  # Parses the expression as part of a `for` loop header. If set to `true`,
  # the `in` operator is disallowed.
  :header => false,
  # Parses the expression as an identifier following a `break` or
  # `continue` statement.
  :identifier => false
}

Instance Attribute Summary

• #lexer ⇒ Object readonly

  Public: Gets the ‘Lexer` instance associated with this parser.

Class Method Summary

• .parse(source) ⇒ Object

  Public: Parses a string of JavaScript source code.

Instance Method Summary

• #continue(token) ⇒ Object

  Internal: Recursively parses tokens until the source string is consumed.

• #fail(message, token) ⇒ Object

  Internal: Emits an error.

• #get(pattern = false) ⇒ Object

  Internal: Lexes the next non-whitespace token.

• #initialize(source) ⇒ Parser constructor

  Public: Creates a new ‘Parser` with a source string.

• #parse ⇒ Object

  Public: Parses the JavaScript source string associated with this parser instance.

• #parse_assignment_expressions(token, options = {}) ⇒ Object

  Internal: Parses one or more assignment expressions or a labeled statement.

• #parse_block(token) ⇒ Object

  Internal: Parses a block.

• #parse_break_statement(token) ⇒ Object

  Internal.

• #parse_catch_block(token) ⇒ Object

  Internal.

• #parse_continue_statement(token) ⇒ Object

  Internal.

• #parse_debugger_statement(token) ⇒ Object

  Internal: Parses a ‘debugger` statement.

• #parse_do_statement(token) ⇒ Object

  Internal.

• #parse_else_statement(token) ⇒ Object

  Internal.

• #parse_expression_or_label(token) ⇒ Object

  Internal: Parses an expression or labeled statement.

• #parse_finally_block(token) ⇒ Object

  Internal: Parses a ‘finally` clause of a `try` block.

• #parse_for_statement(token) ⇒ Object

  Public: Parses a ‘for` or `for…in` loop.

• #parse_function_arguments(token, pattern = false) ⇒ Object

  Internal: Parses an arguments list.

• #parse_function_body(token, pattern = false) ⇒ Object

  Internal: Parses a function body.

• #parse_function_declaration(token) ⇒ Object

  Internal: Parses a function declaration.

• #parse_if_statement(token) ⇒ Object

  Internal.

• #parse_object_literal_member(token) ⇒ Object

  Internal: Parses an object literal member.

• #parse_return_statement(token) ⇒ Object

  Internal.

• #parse_semicolon(token) ⇒ Object

  Internal: Parses a semicolon.

• #parse_source_elements(token) ⇒ Object

  Internal: Continuously parses source elements.

• #parse_statement(token, optional = false) ⇒ Object

  Internal: Parses a statement.

• #parse_statements(token) ⇒ Object

  Internal: Continuously parses statements.

• #parse_switch_block(token) ⇒ Object

  Internal.

• #parse_switch_case(token) ⇒ Object

  Internal.

• #parse_switch_clause(token) ⇒ Object

  Internal.

• #parse_switch_default(token) ⇒ Object

  Internal.

• #parse_switch_header(token) ⇒ Object

  Internal.

• #parse_switch_statement(token) ⇒ Object

  Internal.

• #parse_throw_statement(token) ⇒ Object

  Internal.

• #parse_tokens(token, allow_functions = false) ⇒ Object

  Internal: Continuously parses statements.

• #parse_try_block(token) ⇒ Object

  Internal.

• #parse_try_statement(token) ⇒ Object

  Public: Parses a ‘try…catch…finally` statement.

• #parse_var_statement(token) ⇒ Object

  Internal.

• #parse_variable_declarations(token, header = false) ⇒ Object

  Internal.

• #parse_while_statement(token) ⇒ Object

  Internal.

• #parse_with_statement(token) ⇒ Object

  Internal: Parses a ‘with` statement.

• #save(token) ⇒ Object

  Internal: Stores the token in the parser token stream.

• #warn(message, token) ⇒ Object

  Internal: Emits a warning.

Constructor Details

#initialize(source) ⇒ Parser

Public: Creates a new ‘Parser` with a source string.

source - The source ‘String`.

# File 'lib/violet/parser.rb', line 70

def initialize(source)
  @lexer = Lexer.new(source)
  @tokens = []
  @exception = nil
  @try = false
end

Instance Attribute Details

#lexer ⇒ Object (readonly)

Public: Gets the ‘Lexer` instance associated with this parser.

# File 'lib/violet/parser.rb', line 65

def lexer
  @lexer
end

Class Method Details

.parse(source) ⇒ Object

Public: Parses a string of JavaScript source code.

source - The source ‘String`.

Returns the resulting ‘Token` stream as an `Array`.

# File 'lib/violet/parser.rb', line 26

def self.parse(source)
  new(source).parse
end

Instance Method Details

#continue(token) ⇒ Object

Internal: Recursively parses tokens until the source string is consumed.

token - The current token.

Returns the token immediately before the end-of-file mark.

# File 'lib/violet/parser.rb', line 142

def continue(token)
  save token if token
  # Parse as many tokens as possible. `token` should be the end-of-file mark
  # following the call to `parse_source_elements`. If it is not, the source
  # is malformed and requires additional parsing.
  token = parse_source_elements get(:pattern)
  parsed = false
  loop do
    unless token[:name] == 12
      # Add a generic error to the token stream unless the current token
      # already contains an error.
      unless token[:name] == 14
        fail "Unexpected token.", token
      end
      # Save the malformed token as-is and continue parsing.
      save token
      token = get :pattern
      parsed = true
    end
    break unless token[:name] == 14
  end
  # Recursively parse the source until the end-of-file mark is reached.
  token = continue(token) if token[:name] != 12 && parsed
  # If an error occured at the end of the file, add it to the token stream.
  if @exception
    save @exception
    @exception = nil
  end
  token
end

#fail(message, token) ⇒ Object

Internal: Emits an error.

message - The warning message. token - The malformed token.

Returns nothing.

# File 'lib/violet/parser.rb', line 1429

def fail(message, token)
  message = ParserError.new(message, token)
  # Ignore the parse error. This will affect how the remainder of the
  # source is parsed.
  error = Token.new(lexer, :error, token[:start]...token[:start])
  error[:error] = message
  save error
  lexer.insert_before(error, token)
  nil
end

#get(pattern = false) ⇒ Object

Internal: Lexes the next non-whitespace token.

pattern - If the token is ‘/` or `/=`, specifies whether it may be lexed

as part of a regular expression. If `false`, the token will be lexed as
a division operator instead (default: false).

Returns the lexed ‘Token`.

# File 'lib/violet/parser.rb', line 103

def get(pattern = false)
  # If the parser encountered an exception, the `@exception` instance
  # variable will be set to the token that triggered the error.
  if @exception
    token, @exception = @exception, nil
    return token
  end

  # Mark lines for automatic semicolon insertion.
  multiline = false

  # Consume tokens until a non-whitespace token is encountered.
  loop do
    token = lexer.lex pattern
    # The end-of-file token is not stored in the syntax tree.
    return token if token[:name] == 12
    multiline ||= true if token[:lines] && token[:lines] > 0

    # If the lexed token is a whitespace token, save it and continue
    # consuming tokens. Otherwise, break and return the token. Note
    # that the non-whitespace token is **not** automatically saved.
    if token[:isWhite]
      save token
    else
      break
    end
  end

  # If multiple lines were lexed, mark the token for automatic semicolon
  # insertion.
  token[:asi] = true if multiline
  token
end

#parse ⇒ Object

Public: Parses the JavaScript source string associated with this parser instance.

Returns the token stream as an ‘Array`.

# File 'lib/violet/parser.rb', line 81

def parse
  continue false
  @tokens
end

#parse_assignment_expressions(token, options = {}) ⇒ Object

Internal: Parses one or more assignment expressions or a labeled statement.

token - The current token. options - The expression parsing options.

Returns the token immediately following the last expression.

# File 'lib/violet/parser.rb', line 283

def parse_assignment_expressions(token, options = {})
  # @kitcambridge: This method should be broken up into several smaller
  # helper methods.
  options = PARSE_EXPRESSIONS_DEFAULTS.merge(options)
  initial = true

  loop do
    # Specifies whether the current expression is a reference. Once a non-
    # reference expression is encountered, subsequent expressions may not
    # contain assignments.
    reference = true
    unless initial
      save token
      token = get :pattern
      # A left-hand side start expression must follow the initial
      # expression.
      unless token[:name] <= 6 || LHS_START.match(token[:value])
        token = warn "Expected a left-hand side expression following `,`.", token
      end
    end

    # The following loop begins by parsing the left-hand side expression.
    # If an identifier is encountered, an assignment operator is parsed.
    # Otherwise, unary expressions are consumed until a binary operator
    # is encountered. If a `new` or `()` expression was parsed, assignments
    # are permitted. The right-hand side is then parsed.
    continue = true
    while continue
      unary = false
      # A unary operator cannot be used as an identifier following a
      # `break` or `continue` statement, as it is reserved.
      unless options[:identifier]
        loop do
          unary = token[:value] && UNARY_KEYWORDS.include?(token[:value])
          # Break if the token is not a unary keyword or operator.
          break unless unary || token[:name] == 11 && UNARY_OPERATORS.match(token[:value])
          token[:isUnaryOp] = true if unary
          save token
          token = get :pattern
          # A left-hand side expression must follow a unary operator.
          unless token[:name] <= 6 || LHS_START.match(token[:value])
            token = warn "Expected a left-hand side expression.", token
          end
        end
      end
      # If a unary operator was encountered, subsequent expressions may not
      # be parsed as labeled statements.
      options[:label] = false if unary
      # Specifies whether an assignment may follow a parsed expression.
      assignment_accepted = false

      case token[:value]
      # Parse a grouped expression.
      # ---------------------------
      when ?(
        save token
        token = get :pattern
        unless token[:name] <= 6 || LHS_START.match(token[:value])
          token = warn "A grouped expression should start with a left-hand-side expression.", token
        end
        # Recursively consume comma-separated expressions. The final token
        # should close the group.
        token = parse_assignment_expressions token
        unless token[:value] == ?)
          token = warn "Unterminated grouped expression.", token
        end
        save token
        # In this context, `/` and `/=` are interpreted as division
        # operators, rather than regular expressions.
        token = get
        # If the grouped expression contains a valid reference and excludes
        # the comma operator, it may precede an assignment. `(b) = 1` is
        # valid; `(a, b) = 1` is not.
        assignment_accepted = true
      # Parse an array literal.
      # -----------------------
      when ?[
        save token
        token = get :pattern
        # Leading commas are treated as elisions.
        while token[:value] == ?,
          save token
          token = get :pattern
        end
        # Parse the contents of the array literal. `token` should contain
        # the closing array punctuator at the end of the following loop.
        until token[:value] == ?]
          unless token[:name] <= 6 || LHS_START.match(token[:value]) || token[:name] == 14
            token = warn "An array literal should start with a left-hand side expression.", token
          end
          # Recursively parse each expression stored in the array.
          # Consecutive commas are treated as elisions.
          token = parse_assignment_expressions token, :single => true
          while token[:value] == ?,
            save token
            token = get :pattern
          end
        end
        unless token[:value] == ?]
          token = warn "Unterminated array literal.", token
        end
        save token
        # Treat `/` and `/=` as the division and division assignment
        # operators, respectively.
        token = get
        # The postfix increment and decrement operators cannot follow
        # values that are not references.
        while %w(++ --).include? token[:value]
          fail "The unary increment (`++`) and decrement (`--`) operators cannot be applied to an array literal.", token
          save token
          token = get :pattern
        end
      # Parse an object literal.
      # ------------------------
      when ?{
        save token
        token = get :pattern
        # Unexpected end-of-file mark encountered.
        if token[:name] == 12
          token = warn "A colon should precede every object property value.", token
        end
        # Parse object members until either the closing brace or a parse
        # error is encountered.
        until token[:value] == ?} || token[:name] == 14
          unless token[:isNumber] || token[:isString] || token[:name] == 2
            token = warn "Object literal property names can only be strings, numbers, or identifiers.", token
          end
          # The `accessor` token references the property name.
          accessor = token[:value]
          save token
          token = get :pattern
          # Parse attribute accessors-getters and setters.
          case accessor
          when "get"
            # If the current token is the `:` delimiter, the object member
            # is a standard property, not a getter.
            if token[:value] == ?:
              token = parse_object_literal_member token
            else
              # Parse the getter as a function.
              unless token[:isNumber] || token[:isString] || token[:name] == 2
                # @kitcambridge: This error token is not added to the token
                # stream in Peter's original implementation.
                token = warn "Getter names can only be strings, numbers, or identifiers.", token
              end
              save token
              token = get :pattern
              # Getters cannot accept arguments.
              unless token[:value] == ?(
                token = warn "The name of the getter should be followed by the opening parenthesis.", token
              end
              save token
              token = get :pattern
              unless token[:value] == ?)
                token = warn "A getter cannot accept arguments.", token
              end
              save token
              token = get :pattern
              token = parse_function_body(token, :pattern)
            end
          when "set"
            if token[:value] == ?:
              # The member is a standard property, not a setter.
              token = parse_object_literal_member token
            else
              unless token[:isNumber] || token[:isString] || token[:name] == 2
                # @kitcambridge: This error token *is* added in Peter's
                # implementation.
                token = warn "Setter names can only be strings, numbers, or identifiers.", token
              end
              save token
              token = get :pattern
              unless token[:value] == ?(
                token = warn "The name of the setter should be followed by the opening parenthesis.", token
              end
              save token
              token = get :pattern
              # Setters can accept only one argument.
              unless token[:name] == 2
                if token[:value] == ?)
                  token = warn "Setter functions must accept only one argument.", token
                else
                  token = warn "The setter argument name must be an identifier.", token
                end
              end
              save token
              token = get :pattern
              unless token[:value] == ?)
                if token[:value] == ?,
                  token = warn "Setters may not accept multiple arguments.", token
                else
                  token = warn "A closing parenthesis should follow the setter argument.", token
                end
              end
              save token
              token = get :pattern
              token = parse_function_body(token, :pattern)
            end
          else
            # Standard object member.
            token = parse_object_literal_member token
          end
          # A single trailing comma is permitted.
          if token[:value] == ?,
            save token
            token = get :pattern
            if token[:value] == ?,
              token = warn "Multiple trailing commas in object literals are not permitted.", token
            end
          elsif token[:value] != ?}
            token = warn "Expected `,` or `}`. Unexpected member delimiter.", token
          end
        end
        save token
        # `/` and `/=` are treated as division operators.
        token = get
        # Object literals are not references.
        while %w(++ --).include? token[:value]
          fail "The unary increment (`++`) and decrement (`--`) operators cannot be applied to an object literal.", token
          save token
          token = get :pattern
        end
      # Parse a function expression.
      # ----------------------------
      when "function"
        save token
        token = get :pattern
        # A label may precede a function expression or declaration.
        if options[:label] && token[:value] == ?:
          token = warn "Labels may not be keywords or future reserved words.", token
        end
        # Validate the function name, if one is found. Anonymous function
        # expressions will omit the name.
        if token[:name] == 2
          if KEYWORD_OR_RESERVED.include?(token[:value])
            token = warn "Function names may not be keywords or future reserved words.", token
          end
          save token
          token = get :pattern
        end
        # Parse the function arguments and body. The returned token should
        # be the token immediately following the closing brace of the body.
        token = parse_function_arguments token
        while %w(++ --).include? token[:value]
          fail "The unary increment (`++`) and decrement (`--`) operators cannot be applied to a function.", token
          save token
          token = get :pattern
        end
      # Parse labels and error cases.
      # -----------------------------
      else
        # Parse labels for right-hand side expressions.
        if token[:name] <= 6
          # Save the current token, which may be a label.
          possible_label = token

          # Validate the label identifier. This is not optional if the
          # expression should be parsed as an identifier following a
          # `break` or `continue` statement.
          if token[:name] == 2
            # @kitcambridge: Peter's original parser allows `LITERALS` to
            # be used as label names; all popular implementations disagree.
            # Removing this causes an unexpected token error to be emitted
            # for standalone literals. @qfox/ZeParser#9.
            if !LITERALS.include?(token[:value]) && KEYWORD_OR_RESERVED.include?(token[:value])
              # A statement label is an identifier, which may not be a
              # reserved word.
              if options[:identifier]
                fail "Statement labels passed to `break` and `continue` must be identifiers.", token
              elsif token[:value] == "else"
                fail "Dangling `else`.", token
              else
                # @kitcambridge: Peter is considering adding a lookahead to
                # check for a trailing colon and emit a malformed label
                # error. This may also solve issue #9 above.
                fail "Unexpected token.", token
              end
            end
            # Assignments are only accepted after member expressions:
            # either an identifier or square brackets.
            assignment_accepted = true
          elsif options[:identifier]
            # Malformed label.
            token = warn "Statement labels passed to `break` and `continue` must be identifiers.", token
          end
          save token
          # `/` and `/=` are treated as division operators.
          token = get
          # Check for a labeled statement. If the `label` option was
          # specified and the current token is the `:` delimiter,
          # the previous `possible_label` token must be an
          # identifier (validation occured above; this routine merely
          # catches malformed labels).
          if options[:label] && token[:value] == ?:
            unless possible_label[:name] == 2
              fail "Label names must be identifiers.", token
            end
            save token
            token = get :pattern
            possible_label[:isLabel] = true
            # If the label is valid, the subsequent token marks the
            # beginning of the labeled statement. `token` should
            # reference the first token following the statement.
            token = parse_statement token
            # If the statement could not be parsed, correct the error to
            # account for the label.
            if token[:error] && token[:error].message == STATEMENT_ERROR
              token[:error] = ParserError.new("Expected a statement after the label.", token)
            end
            token[:wasLabel] = true
            return token
          end
          options[:label] = false
        # Lexer Errors.
        # -------------
        elsif token[:name] == 14
          loop do
            if token[:tokenError]
              error = Token.new(lexer, :error, token[:start]...token[:start])
              error[:error] = ParserError.new("Lexer Error: #{token[:error].message}", token)
              save error
              lexer.insert_before(error, token)
            end
            save token
            token = get :pattern
            break unless token[:name] == 14
          end
        # Unexpected End-of-File.
        # -----------------------
        elsif token[:name] == 12
          return token
        # Fail.
        # -----
        # If the token value is the closing curly brace (`}`), it is
        # ignored. According to Peter, automatic semicolon insertion may be
        # applied; alternatively, this may be part of an object literal.
        # The other parsing routines will attempt to handle it.
        elsif token[:value] != ?}
          fail "Unexpected token.", token
          save token
          token = get :pattern
        end
      end
      # Property Access and Call Expressions.
      # -------------------------------------
      while token[:value] == ?. || token[:value] == ?[ || token[:value] == ?(
        # None of the characters may occur in an identifier.
        if options[:identifier]
          token = warn "Statement labels passed to `break` and `continue` must be identifiers.", token
        end
        case token[:value]
        # Dot Member Operator.
        # --------------------
        when ?.
          save token
          token = get :pattern
          # The referenced property name must be an identifier. ES 5 allows
          # the use of reserved words as property names, so no additional
          # checks are performed.
          unless token[:name] == 2
            fail "Property names following the dot member operator must be identifiers.", token
          end
          save token
          # `/` and `/=` are treated as division operators.
          token = get
          # The result of a member access operation may be assigned to.
          assignment_accepted = true
        # Square Bracket Member Operator.
        # -------------------------------
        when ?[
          save token
          token = get :pattern
          # The brackets must contain at least one left-hand side start
          # expression.
          unless token[:name] <= 6 || LHS_START.match(token[:value])
            token = warn "Square brackets must contain an expression.", token
          end
          # Recursively parse assignment expressions. The final token should
          # be the terminating bracket.
          token = parse_assignment_expressions token
          unless token[:value] == ?]
            token = warn "Unterminated square bracket member accessor.", token
          end
          save token
          # `/` and `/=` are treated as division operators.
          token = get
          assignment_accepted = true
        # Call Expression.
        # ----------------
        when ?(
          save token
          token = get :pattern
          # The current token marks either the closing parenthesis of an
          # empty argument list, or the first argument, which must be a
          # left-hand side start expression.
          if token[:name] <= 6 || LHS_START.match(token[:value])
            # Recursively parse the arguments, which may be assignment
            # expressions. The comma is used as a separator, not as an
            # operator.
            token = parse_assignment_expressions token
          end
          unless token[:value] == ?)
            token = warn "Unterminated parentheses following the call expression.", token
          end
          save token
          # `/` and `/=` are treated as division operators.
          token = get
          # The result of a function call may not be assigned to.
          assignment_accepted = false
        end
      end
      # Postfix unary increment and decrement operators.
      if (token[:value] == "++" || token[:value] == "--") && !token[:asi]
        if options[:identifier]
          token = warn "Statement labels passed to `break` and `continue` must be identifiers.", token
        end
        save token
        # `/` and `/=` are treated as division operators.
        token = get
      end

      # Parse any subsequent operators.
      # -------------------------------
      loop do
        conditional = false
        # Parse the `instanceof` operator, assignment operators (+=, /=,
        # >>=, etc.), and binary expression operators. The `in` operator
        # is parsed only if the `header` option is set-this specifies
        # that the expression should be treated as part of a `for` loop
        # header.
        if !options[:header] && token[:value] == "in" || token[:value] == "instanceof" || (token[:name] == 11 && (token[:isAssignment] = !!ASSIGNMENTS.match(token[:value])) || BINARY_OPERATORS.match(token[:value]))
          if token[:isAssignment]
            # Emit an error if an expression may not be assigned to or is
            # not a valid reference.
            case false
            when assignment_accepted
              fail "The left-hand side of the assignment expression is not a reference.", token
            when reference
              fail "An assignment expression may not follow a non-assignment operator.", token
            end
          end
          # Labels may not share operator names.
          if options[:identifier]
            token = warn "Statement labels passed to `break` and `continue` must be identifiers.", token
          end
          # If a non-assignment operator was parsed, the remainder of the
          # expression may not contain assignments.
          reference = false unless token[:isAssignment]

          # Conditional (Ternary) Operator.
          # -------------------------------
          conditional = token[:value] == ??
          save token
          token = get :pattern
          if conditional
            # The `true` condition should begin with a left-hand side
            # expression.
            unless token[:name] <= 6 || LHS_START.match(token[:value])
              fail "Invalid conditional expression.", token
            end
            # Recursively parse the `true` assignment expression.
            token = parse_assignment_expressions token, :single => true, :header => options[:header]
            unless token[:value] == ?:
              if token[:value] == ?,
                token = warn "The comma operator may only be used as part of a nested expression.", token
              else
                token = warn "Missing second conditional expression.", token
              end
            end
            save token
            token = get :pattern
            # Parse the `false` assignment expression.
            token = parse_assignment_expressions token, :single => true, :header => options[:header]
          end
        else
          # The operator is invalid.
          continue = false
        end
        # If a ternary expression was parsed, verify if the next token is a
        # binary operator.
        break unless conditional
      end
      # Parse the next component. `token` marks the end of the right-hand
      # side for the current left-hand side expression, and the left-hand
      # side for the next.
      if continue && !(token[:name] <= 6 || LHS_START.match(token[:value]))
        fail "Expected a right-hand side expression following the assignment operator.", token
      end
    end

    # Cleanup
    # -------
    # Subsequent tokens may not be parsed as labeled statements, and do not
    # require an initial left-hand side expression.
    options[:label] = initial = false
    # Continue parsing expressions unless the `single` option was explicitly
    # specified or the current token is the comma operator.
    break unless !options[:single] && token[:value] == ?,
  end
  token
end

#parse_block(token) ⇒ Object

Internal: Parses a block.

token - The current token.

Returns the token immediately adjacent to the block.

# File 'lib/violet/parser.rb', line 886

def parse_block(token)
  save token
  token = get :pattern
  unless token[:value] == ?}
    token = parse_statements token
  end
  unless token[:value] == ?}
    token = warn "Unterminated block. Expected `}`.", token
  end
  save token
  get :pattern
end

#parse_break_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1140

def parse_break_statement(token)
  save token
  token = get :pattern
  unless token[:asi] || token[:value] == ?; || token[:name] == 12 || token[:value] == ?}
    token = parse_assignment_expressions token, :single => true, :identifier => true
    unless token[:asi] || token[:value] == ?; || token[:name] == 12 || token[:value] == ?}
      token = warn "The argument to a `break` statement must be an identifier that references an existing label.", token
    end
  end
  parse_semicolon token
end

#parse_catch_block(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1307

def parse_catch_block(token)
  @try = true
  save token
  token = get :pattern
  unless token[:value] == ?(
    token = warn "The `catch` block header must accept a single argument.", token
  end
  save token
  token = get :pattern
  if token[:name] != 2
    token = warn "The `catch` block argument must be an identifier.", token
  elsif KEYWORD_OR_RESERVED.include?(token[:value])
    fail "The `catch` block argument may not be a keyword or future reserved word.", token
  end
  save token
  token = get :pattern
  unless token[:value] == ?)
    token = warn "Expected `)`.", token
  end
  save token
  token = get :pattern
  unless token[:value] == ?{
    token = warn "A `catch` block must begin with `{`.", token
  end
  save token
  token = get :pattern
  # Statements inside the `catch` block are optional.
  token = parse_statements(token) unless token[:value] == ?}
  unless token[:value] == ?}
    token = warn "A `catch` block must end with `}`.", token
  end
  save token
  get :pattern
end

#parse_continue_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1126

def parse_continue_statement(token)
  save token
  token = get :pattern
  unless token[:asi] || token[:value] == ?; || token[:name] == 12 || token[:value] == ?}
    # Only identifiers may follow a `continue` statement.
    token = parse_assignment_expressions token, :single => true, :identifier => true
    unless token[:asi] || token[:value] == ?; || token[:name] == 12 || token[:value] == ?}
      token = warn "The argument to a `continue` statement must be an identifier that references an existing label.", token
    end
  end
  parse_semicolon token
end

#parse_debugger_statement(token) ⇒ Object

Internal: Parses a ‘debugger` statement.

token - The current token.

Returns the token immediately following the statement.

# File 'lib/violet/parser.rb', line 1370

def parse_debugger_statement(token)
  save token
  token = get :pattern
  parse_semicolon token
end

#parse_do_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1023

def parse_do_statement(token)
  save token
  token = get :pattern
  token = parse_statement token
  unless token[:value] == "while"
    token = warn "The `do...while` loop requires the `while` statement after the loop body.", token
  end
  save token
  token = get :pattern
  unless token[:value] == ?(
    token = warn "Expected `(`.", token
  end
  save token
  token = get :pattern
  unless token[:name] <= 6 || LHS_START.match(token[:value])
    token = warn "A statement header must contain at least one expression.", token
  end
  token = parse_assignment_expressions token
  unless token[:value] == ?)
    token = warn "Expected `)`.", token
  end
  save token
  token = get :pattern
  # @kitcambridge: According to Peter, the trailing semicolon is not
  # optional, though implementations apply ASI nonetheless.
  parse_semicolon token
end

#parse_else_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1016

def parse_else_statement(token)
  save token
  token = get :pattern
  parse_statement token
end

#parse_expression_or_label(token) ⇒ Object

Internal: Parses an expression or labeled statement.

token - The current token.

Returns the token immediately following the result.

# File 'lib/violet/parser.rb', line 904

def parse_expression_or_label(token)
  token = parse_assignment_expressions token, :label => true
  # Only parse a semicolon if a label was not parsed.
  unless token[:wasLabel]
    token = parse_semicolon token
  end
  token
end

#parse_finally_block(token) ⇒ Object

Internal: Parses a ‘finally` clause of a `try` block.

token - The current token.

Returns the token immediately following the block.

# File 'lib/violet/parser.rb', line 1347

def parse_finally_block(token)
  @try = true
  save token
  token = get :pattern
  unless token[:value] == ?{
    token = warn "A `finally` block must begin with `{`.", token
  end
  save token
  token = get :pattern
  # A `finally` block can be empty.
  token = parse_statements(token) unless token[:value] == ?}
  unless token[:value] == ?}
    token = warn "A `finally` block must end with `}`.", token
  end
  save token
  get :pattern
end

#parse_for_statement(token) ⇒ Object

Public: Parses a ‘for` or `for…in` loop.

# File 'lib/violet/parser.rb', line 1075

def parse_for_statement(token)
  save token
  token = get :pattern
  unless token[:value] == ?(
    token = warn "Expected `(`.", token
  end
  save token
  token = get :pattern
  # Parse either the initialization section of a `for` loop or the left-hand
  # side `in` operand of a `for...in` loop. The parser subsequently
  # determines which loop type is used.
  if token[:value] == "var"
    token = parse_variable_declarations(token, :header)
  elsif token[:value] != ?;
    unless token[:name] <= 6 || LHS_START.match(token[:value])
      fail "A `for` statement header must contain at least one expression.", token
    end
    # Multiple expressions are permitted, but the `in` operator is not.
    token = parse_assignment_expressions token, :header => true
  end
  if token[:value] == "in"
    # @kitcambridge: Violet does not verify if the `for...in` loop header
    # introduces only one variable. This requires the full AST.
    save token
    token = get :pattern
    token = parse_assignment_expressions token
  else
    unless token[:value] == ?;
      token = warn "A `for` loop header must contain either the `in` operator or two consecutive semicolons (`;;`).", token
    end
    # Parse two optional expressions separated by a semicolon. The `in`
    # operator is permitted.
    save token
    token = get :pattern
    token = parse_assignment_expressions(token) if token[:name] <= 6 || LHS_START.match(token[:value])
    unless token[:value] == ?;
      token = warn "Expected `;`.", token
    end
    save token
    token = get :pattern
    token = parse_assignment_expressions(token) if token[:name] <= 6 || LHS_START.match(token[:value])
  end
  unless token[:value] == ?)
    token = warn "Expected `)`.", token
  end
  save token
  token = get :pattern
  parse_statement(token)
end

#parse_function_arguments(token, pattern = false) ⇒ Object

Internal: Parses an arguments list.

token - The current token. pattern - If the ‘/` or `/=` token immediately follows the function body,

this boolean argument specifies whether it may be lexed as part of a
regular expression (default: false).

Returns the token immediately following the arguments list.

# File 'lib/violet/parser.rb', line 201

def parse_function_arguments(token, pattern = false)
  unless token[:value] == ?(
    token = warn "Expected to see an opening parenthesis after the function name.", token
  end
  save token
  token = get :pattern

  if token[:name] == 2
    if KEYWORD_OR_RESERVED.include? token[:value]
      fail "Function argument names may not be keywords or future reserved words.", token
    end
    save token
    token = get :pattern

    # Parse the argument list.
    while token[:value] == ?,
      save token
      token = get :pattern
      if token[:name] != 2
        fail "Function argument names must be identifiers.", token
      elsif KEYWORD_OR_RESERVED.include? token[:value]
        fail "Function argument names may not be keywords or future reserved words.", token
      end
      save token
      token = get :pattern
    end
  end
  unless token[:value] == ?)
    token = warn "Expected to see a closing parenthesis after the list of arguments.", token
  end
  save token
  token = get :pattern
  parse_function_body(token, pattern)
end

#parse_function_body(token, pattern = false) ⇒ Object

Internal: Parses a function body.

token - The current token. pattern - If the ‘/` or `/=` token immediately follows the function body,

this boolean argument specifies whether it may be lexed as part of a
regular expression (default: false).

Returns the token immediately following the function body.

# File 'lib/violet/parser.rb', line 244

def parse_function_body(token, pattern = false)
  unless token[:value] == ?{
    token = warn "Expected `{` after the function header.", token
  end
  save token
  token = get :pattern
  token = parse_source_elements token
  unless token[:value] == ?}
    token = warn "Expected `}` after the function body.", token
  end
  save token
  get pattern
end

#parse_function_declaration(token) ⇒ Object

Internal: Parses a function declaration.

token - The current token.

Returns the token immediately following the function body.

# File 'lib/violet/parser.rb', line 178

def parse_function_declaration(token)
  save token
  token = get :pattern
  if token[:name] != 2
    token = warn "Function declarations cannot be anonymous.", token
  elsif KEYWORD_OR_RESERVED.include? token[:value]
    token = warn "Function names may not be keywords or future reserved words.", token
  end
  # The subsequent token marks the beginning of the argument list.
  save token
  token = get :pattern
  # Parse the function arguments and body.
  parse_function_arguments(token, :pattern)
end

#parse_if_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 993

def parse_if_statement(token)
  save token
  token = get :pattern
  unless token[:value] == ?(
    token = warn "Expected `(`.", token
  end
  save token
  token = get :pattern
  unless token[:name] <= 6 || LHS_START.match(token[:value])
    token = warn "A statement header must contain at least one expression.", token
  end
  token = parse_assignment_expressions token
  unless token[:value] == ?)
    token = warn "Expected `)`.", token
  end
  save token
  token = get :pattern
  token = parse_statement token
  token = parse_else_statement(token) if token[:value] == "else"
  token
end

#parse_object_literal_member(token) ⇒ Object

Internal: Parses an object literal member.

token - The current token.

Returns the token immediately following the member.

# File 'lib/violet/parser.rb', line 790

def parse_object_literal_member(token)
  unless token[:value] == ?:
    token = warn "A colon should follow every property name.", token
  end
  save token
  token = get :pattern
  previous_token = token
  token = parse_assignment_expressions token, :single => true
  if previous_token == token
    token = warn "Missing object literal property value.", token
  end
  token
end

#parse_return_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1153

def parse_return_statement(token)
  save token
  token = get :pattern
  unless token[:asi] || token[:value] == ?; || token[:name] == 12 || token[:value] == ?}
    token = parse_assignment_expressions token
  end
  parse_semicolon token
end

#parse_semicolon(token) ⇒ Object

Internal: Parses a semicolon.

token - The current token.

Returns the token immediately adjacent to the semicolon.

# File 'lib/violet/parser.rb', line 809

def parse_semicolon(token)
  if token[:value] == ?;
    save token
    token = get :pattern
  else
    # Automatic semicolon insertion cannot be applied if the end-of-file
    # mark has not been reached and the current token either is a semicolon,
    # or does not follow at least one line terminator and is not a closing
    # curly brace, and is not preceded by a line terminator or is not a
    # unary increment or decrement operator.
    if token[:name] != 12 && (token[:semicolon] || !(token[:asi] || token[:value] == ?})) && !(token[:asi] && %w(++ --).include?(token[:value]))
      fail "Expected `;`. Automatic semicolon insertion cannot be applied.", token
    else
      # @kitcambridge: This is an inversion of Peter's code, which checks
      # for the affirmative condition. Peter also notes that this method
      # does not check for restricted productions (`break`, `continue`, and
      # `return`), if the subsequent line is a regular expression, or the
      # semicolon is part of a `for` loop header. He notes that the parser
      # is designed to automatically catch the latter two exceptions.
      #
      # The current token is the token that occurs *after* the insertion,
      # not before; hence, its position is the *beginning* of the current
      # token.
      semicolon = Token.new(lexer, :asi, token[:start]...token[:start])
      save semicolon
      lexer.insert_before(semicolon, token)
    end
  end
  token[:semicolon] = true
  token
end

#parse_source_elements(token) ⇒ Object

Internal: Continuously parses source elements.

# File 'lib/violet/parser.rb', line 943

def parse_source_elements(token)
  parse_tokens(token, :functions)
end

#parse_statement(token, optional = false) ⇒ Object

Internal: Parses a statement.

token - The current token.

Returns the token immediately adjacent to the statement.

# File 'lib/violet/parser.rb', line 846

def parse_statement(token, optional = false)
  # @kitcambridge: Peter's parser returns the value of the `token` parameter
  # if it is falsy and the `optional` option is set. Because Ruby enforces
  # method arity and none of the operations may produce a `nil` token, this
  # seems redundant.
  if token[:name] == 2
    # If the token is an identifier, determine if it can be parsed as a
    # statement.
    if %w( var if do while for continue break return throw switch try debugger with ).include? token[:value]
      token = send "parse_#{token[:value]}_statement", token
    elsif token[:value] == "function"
      fail "Function statements are an extension of ECMAScript semantics. Their use is discouraged.", token
      token = parse_function_declaration token
    else
      token = parse_expression_or_label token
    end
  elsif token[:value] == ?{
    # Blocks are parsed before expressions.
    token = parse_block token
  elsif token[:isString] || token[:isNumber] || token[:name] == 1 || LHS_START.match(token[:value])
    # Parse expressions (strings, numbers, RegExps, and left-hand side start
    # values). Each expression should be followed by a semicolon, whether
    # explicit or implicit through ASI.
    token = parse_assignment_expressions token
    token = parse_semicolon token
  elsif token[:value] == ?;
    # The empty statement. Parse the current token as a semicolon.
    token[:emptyStatement] = true
    token = parse_semicolon token
  elsif !optional
    token = warn STATEMENT_ERROR, token
  end
  token
end

#parse_statements(token) ⇒ Object

Internal: Continuously parses statements.

# File 'lib/violet/parser.rb', line 938

def parse_statements(token)
  parse_tokens(token)
end

#parse_switch_block(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1242

def parse_switch_block(token)
  previous_token = nil
  # `switch` clauses may be empty.
  until %w( } case default).include?(token[:value]) || [14, 12].include?(token[:name]) || previous_token == token
    previous_token = token
    token = parse_statement token, :optional
  end
  if previous_token == token
    warn "Unexpected token in `switch` block.", token
  end
  token
end

#parse_switch_case(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1256

def parse_switch_case(token)
  save token
  token = get :pattern
  if token[:value] == ?:
    fail "A `case` clause expects an expression as its argument.", token
  else
    token = parse_assignment_expressions token
  end
  token
end

#parse_switch_clause(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1222

def parse_switch_clause(token)
  token = parse_switch_header token
  parse_switch_block token
end

#parse_switch_default(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1268

def parse_switch_default(token)
  save token
  get :pattern
end

#parse_switch_header(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1228

def parse_switch_header(token)
  if token[:value] == "case"
    token = parse_switch_case token
  else
    token = parse_switch_default token
  end
  unless token[:value] == ?:
    token = warn "`switch` clauses must be followed by a colon.", token
  end
  save token
  get :pattern
end

#parse_switch_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1179

def parse_switch_statement(token)
  save token
  token = get :pattern
  unless token[:value] == ?(
    token = warn "Expected `(`.", token
  end
  save token
  token = get :pattern
  unless token[:name] <= 6 || LHS_START.match(token[:value])
    fail "A `switch` statement header must contain at least one expression.", token
  end
  token = parse_assignment_expressions token
  unless token[:value] == ?)
    token = warn "Expected `)`.", token
  end
  save token
  token = get :pattern
  unless token[:value] == ?{
    token = warn "A `switch` block must begin with `{`.", token
  end
  save token
  token = get :pattern
  # A `default` case may occur only once in a `switch` block, but may
  # occur anywhere.
  has_cases, default = false, false
  while token[:value] == "case" || !default && (default = token[:value] == "default")
    has_cases = true
    token = parse_switch_clause token
  end
  unless has_cases || token[:value] == ?}
    token = warn "A `switch` block must begin with a `case` or `default` clause.", token
  end
  if default && token[:value] == "default"
    fail "`switch` blocks may not contain multiple `default` clauses.", token
  end
  unless token[:value] == ?} || token[:name] == 14
    token = warn "A `switch` block must end with `}`.", token
  end
  save token
  get :pattern
end

#parse_throw_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1163

def parse_throw_statement(token)
  save token
  token = get :pattern
  # `throw` may not precede a line terminator, as it is a restricted
  # production for automatic semicolon insertion.
  if token[:asi]
    token = warn "A line terminator may not occur between a `throw` statement and its argument.", token
  end
  if token[:value] == ?;
    token = warn "The argument to `throw` is not optional.", token
  end
  token = parse_assignment_expressions token
  parse_semicolon token
end

#parse_tokens(token, allow_functions = false) ⇒ Object

Internal: Continuously parses statements.

token - The current token. allow_functions - If this option is set to ‘true`, function declarations

may be parsed. Statements should not begin with functions.

Returns the token immediately following the result.

# File 'lib/violet/parser.rb', line 920

def parse_tokens(token, allow_functions = false)
  # @kitcambridge: Peter notes that detecting the beginning of a statement
  # is difficult. The parser consumes statements until the current token is
  # identical to the previous, which occurs if a statement is optional.
  previous_token = token
  loop do
    token = if allow_functions && previous_token[:value] == "function"
      parse_function_declaration previous_token
    else
      parse_statement(previous_token, :optional)
    end
    break if previous_token == token
    previous_token = token
  end
  token
end

#parse_try_block(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1290

def parse_try_block(token)
  save token
  token = get :pattern
  unless token[:value] == ?{
    token = warn "A `try` block must begin with `{`."
  end
  save token
  token = get :pattern
  token = parse_statements(token) unless token[:value] == ?}
  unless token[:value] == ?}
    token = warn "A `try` block must end with `}`.", token
  end
  save token
  get :pattern
end

#parse_try_statement(token) ⇒ Object

Public: Parses a ‘try…catch…finally` statement. Returns the token immediately following the statement.

token - The current token.

# File 'lib/violet/parser.rb', line 1277

def parse_try_statement(token)
  token = parse_try_block token
  token = parse_catch_block(token) if token[:value] == "catch"
  token = parse_finally_block(token) if token[:value] == "finally"
  unless @try
    fail "A `try` statement must be followed by either a `catch` block, a `finally` block, or both.", token
  end
  token
ensure
  @try = false
end

#parse_var_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 948

def parse_var_statement(token)
  token = parse_variable_declarations token
  parse_semicolon token
end

#parse_variable_declarations(token, header = false) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 954

def parse_variable_declarations(token, header = false)
  initial = true
  loop do
    save token
    # `token` references the `var` statement on the first iteration, and
    # the comma separator for all subsequent iterations.
    token = get :pattern
    # The subsequent token should be an identifier that specifies the
    # variable name.
    if token[:name] == 12
      # @kitcambridge: Peter proposes returning if an illegal trailing comma
      # is encountered.
      token = warn(initial ? "A `var` declaration should be followed by the variable name." : "Illegal trailing comma.", token)
    elsif token[:name] != 2
      token = warn "Variable names can only be identifiers.", token
    elsif KEYWORD_OR_RESERVED.include? token[:value]
      token = warn "Variable names may not be keywords or future reserved words.", token
    end
    save token
    # The next token should be either `=`, `;`, or `,`.
    token = get :pattern
    if token[:value] == ?=
      # Parse a single assignment expression and an optional trailing comma.
      token[:initializer] = true
      save token
      token = get :pattern
      unless token[:name] <= 6 || token[:name] == 14 || LHS_START.match(token[:value])
        token = warn "The variable value must be an expression that does not contain a comma.", token
      end
      token = parse_assignment_expressions token, :single => true, :header => header
    end
    initial = false
    # Loop until all trailing commas have been consumed.
    break unless token[:value] == ?,
  end
  token
end

#parse_while_statement(token) ⇒ Object

Internal.

# File 'lib/violet/parser.rb', line 1052

def parse_while_statement(token)
  save token
  token = get :pattern
  unless token[:value] == ?(
    token = warn "Expected `(`.", token
  end
  save token
  token = get :pattern
  # The `while` loop header must contain a valid left-hand side start
  # value.
  unless token[:name] <= 6 || LHS_START.match(token[:value])
    token = warn "A statement header must contain at least one expression.", token
  end
  token = parse_assignment_expressions token
  unless token[:value] == ?)
    token = "Expected `)`.", token
  end
  save token
  token = get :pattern
  parse_statement(token)
end

#parse_with_statement(token) ⇒ Object

Internal: Parses a ‘with` statement.

token - The current token.

Returns the token immediately following the statement.

# File 'lib/violet/parser.rb', line 1381

def parse_with_statement(token)
  save token
  token = get :pattern
  unless token[:value] == ?(
    token = warn "The `with` statement must begin with `{`.", token
  end
  save token
  token = get :pattern
  # The statement header must contain a left-hand side start value.
  unless token[:name] <= 6 || LHS_START.match(token[:value])
    token = warn "The `with` statement header cannot be empty.", token
  end
  token = parse_assignment_expressions token
  unless token[:value] == ?)
    token = warn "The `with` statement must end with `}`.", token
  end
  save token
  token = get :pattern
  parse_statement token
end

#save(token) ⇒ Object

Internal: Stores the token in the parser token stream.

token - The token to store.

Returns nothing.

# File 'lib/violet/parser.rb', line 91

def save(token)
  @tokens << token
  nil
end

#warn(message, token) ⇒ Object

Internal: Emits a warning.

message - The warning message. token - The malformed token.

Returns the warning ‘Token`.

# File 'lib/violet/parser.rb', line 1408

def warn(message, token)
  message = ParserError.new(message, token)
  # If a malformed token was previously encountered, insert it into the
  # token stream at the current position.
  save(@exception) if @exception
  # Store the current malformed token.
  @exception = token
  # Produce an error token at the current position and add it to the
  # lexer's token stream.
  error = Token.new(lexer, :error, token[:start]...token[:start])
  error[:error] = message
  lexer.insert_before(error, token)
  error
end