violet 0.0.1

data/lib/violet/parser.rb

@@ -0,0 +1,1440 @@
+# -*- encoding: utf-8 -*-
+
+module Violet
+  # Internal: Records errors emitted by the parser.
+  class ParserError < Error
+    # Public: Gets the malformed `Token` associated with this error.
+    attr_reader :token
+
+    # Public: Creates a new `ParserError`.
+    #
+    # message - The error message.
+    # token - The malformed `Token`.
+    def initialize(message, token)
+      @token = token
+      super message
+    end
+  end
+
+  # Public: Parses a JavaScript source string.
+  class Parser
+    # Public: Parses a string of JavaScript source code.
+    #
+    # source - The source `String`.
+    #
+    # Returns the resulting `Token` stream as an `Array`.
+    def self.parse(source)
+      new(source).parse
+    end
+
+    # Public: The future reserved words specified in section 7.6.1.2.
+    FUTURE_RESERVED_WORDS = %w( class const enum export extends import super )
+
+    # Public: The reserved keywords specified in section 7.6.1.1, excluding
+    # `this` and the four unary operators.
+    KEYWORDS = %w( break case catch continue debugger default do else finally for function if in instanceof return switch throw try var while with )
+
+    # Public: The `true`, `false`, and `null` literals specified in section 7.8.
+    # The `this` keyword is grouped with the literals for convenience.
+    LITERALS = %w( this null true false )
+
+    # Public: The four unary keyword operators.
+    UNARY_KEYWORDS = %w( delete void typeof new )
+
+    # 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.
+    KEYWORD_OR_RESERVED = FUTURE_RESERVED_WORDS.dup.push(*KEYWORDS, *LITERALS, *UNARY_KEYWORDS)
+
+    # Public: Matches valid left-hand side start operators.
+    LHS_START = /[-+~!({\[]/
+
+    # Public: Matches unary operators.
+    UNARY_OPERATORS = /[-+~!]/
+
+    # Public: Matches assignment operators.
+    ASSIGNMENTS = /^[\+\-\*\%\&\|\^\/]?=$|^\<\<\=$|^\>{2,3}\=$/
+
+    # Public: Matches binary operators.
+    BINARY_OPERATORS = /^[\+\-\*\%\|\^\&\?\/]$|^[\<\>]\=?$|^[\=\!]\=\=?$|^\<\<|\>\>\>?$|^\&\&$|^\|\|$/
+
+    # Internal: The error message produced when a statement cannot be parsed.
+    STATEMENT_ERROR = "Expected a statement."
+
+    # Public: Gets the `Lexer` instance associated with this parser.
+    attr_reader :lexer
+
+    # Public: Creates a new `Parser` with a source string.
+    #
+    # source - The source `String`.
+    def initialize(source)
+      @lexer = Lexer.new(source)
+      @tokens = []
+      @exception = nil
+      @try = false
+    end
+
+    # Public: Parses the JavaScript source string associated with this parser
+    # instance.
+    #
+    # Returns the token stream as an `Array`.
+    def parse
+      continue false
+      @tokens
+    end
+
+    # Internal: Stores the token in the parser token stream.
+    #
+    # token - The token to store.
+    #
+    # Returns nothing.
+    def save(token)
+      @tokens << token
+      nil
+    end
+
+    # 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`.
+    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
+
+    # Internal: Recursively parses tokens until the source string is consumed.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately before the end-of-file mark.
+    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
+
+    # Internal: Parses a function declaration.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately following the function body.
+    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
+
+    # 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.
+    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
+
+    # 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.
+    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
+
+    # Internal: A `Hash` containing the default options for the `expressions`
+    # method.
+    PARSE_EXPRESSIONS_DEFAULTS = {
+      # 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
+    }
+
+    # 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.
+    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
+
+    # Internal: Parses an object literal member.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately following the member.
+    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
+
+    # Internal: Parses a semicolon.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately adjacent to the semicolon.
+    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
+
+    # Internal: Parses a statement.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately adjacent to the statement.
+    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
+
+    # Internal: Parses a block.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately adjacent to the block.
+    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
+
+    # Internal: Parses an expression or labeled statement.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately following the result.
+    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
+
+    # 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.
+    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
+
+    # Internal: Continuously parses statements.
+    def parse_statements(token)
+      parse_tokens(token)
+    end
+
+    # Internal: Continuously parses source elements.
+    def parse_source_elements(token)
+      parse_tokens(token, :functions)
+    end
+
+    # Internal.
+    def parse_var_statement(token)
+      token = parse_variable_declarations token
+      parse_semicolon token
+    end
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    def parse_else_statement(token)
+      save token
+      token = get :pattern
+      parse_statement token
+    end
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Public: Parses a `for` or `for...in` loop.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    def parse_switch_clause(token)
+      token = parse_switch_header token
+      parse_switch_block token
+    end
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    def parse_switch_default(token)
+      save token
+      get :pattern
+    end
+
+    # Public: Parses a `try...catch...finally` statement.
+    # Returns the token immediately following the statement.
+    #
+    # token - The current token.
+    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
+
+    # Internal.
+    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
+
+    # Internal.
+    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
+
+    # Internal: Parses a `finally` clause of a `try` block.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately following the block.
+    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
+
+    # Internal: Parses a `debugger` statement.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately following the statement.
+    def parse_debugger_statement(token)
+      save token
+      token = get :pattern
+      parse_semicolon token
+    end
+
+    # Internal: Parses a `with` statement.
+    #
+    # token - The current token.
+    #
+    # Returns the token immediately following the statement.
+    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
+
+    # Internal: Emits a warning.
+    #
+    # message - The warning message.
+    # token - The malformed token.
+    #
+    # Returns the warning `Token`.
+    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
+
+    # Internal: Emits an error.
+    #
+    # message - The warning message.
+    # token - The malformed token.
+    #
+    # Returns nothing.
+    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
+  end
+end