From eb6d701502b008e2b524af8e5ced8766a07d0a04 Mon Sep 17 00:00:00 2001
From: Sami Samhuri <sami.samhuri@gmail.com>
Date: Sat, 21 Nov 2009 05:07:24 -0800
Subject: [PATCH] [NEW] js2-mode for Emacs. updated .gitignore with
 emacs.d/auto-save-list/*

---
 .gitignore           |     1 +
 emacs.d/js2-mode.el  | 11927 +++++++++++++++++++++++++++++++++++++++++
 emacs.d/js2-mode.elc |   Bin 0 -> 1484001 bytes
 3 files changed, 11928 insertions(+)
 create mode 100644 emacs.d/js2-mode.el
 create mode 100644 emacs.d/js2-mode.elc

diff --git a/.gitignore b/.gitignore
index 30aedff..573da0b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 zsh/zhistory
+.emacs.d/auto-save-list/.saves*
diff --git a/emacs.d/js2-mode.el b/emacs.d/js2-mode.el
new file mode 100644
index 0000000..2f5d76a
--- /dev/null
+++ b/emacs.d/js2-mode.el
@@ -0,0 +1,11927 @@
+;;; js2.el -- an improved JavaScript editing mode
+;;;
+;;; This file was auto-generated on Thu Jul 23 16:21:42 2009 from files:
+;;;  js2-externs.el
+;;;  js2-vars.el
+;;;  js2-util.el
+;;;  js2-scan.el
+;;;  js2-messages.el
+;;;  js2-ast.el
+;;;  js2-highlight.el
+;;;  js2-browse.el
+;;;  js2-parse.el
+;;;  js2-indent.el
+;;;  js2-mode.el
+
+;;; js2-mode.el --- an improved JavaScript editing mode
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Version: 20090723
+;; Keywords:  javascript languages
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This JavaScript editing mode supports:
+;;
+;;  - the full JavaScript language through version 1.8
+;;  - support for most Rhino and SpiderMonkey extensions from 1.5 to 1.8
+;;  - accurate syntax highlighting using a recursive-descent parser
+;;  - syntax-error and strict-mode warning reporting
+;;  - "bouncing" line indentation to choose among alternate indentation points
+;;  - smart line-wrapping within comments (Emacs 22+) and strings
+;;  - code folding:
+;;    - show some or all function bodies as {...}
+;;    - show some or all block comments as /*...*/
+;;  - context-sensitive menu bar and popup menus
+;;  - code browsing using the `imenu' package
+;;  - typing helpers (e.g. inserting matching braces/parens)
+;;  - many customization options
+;;
+;; It is only compatible with GNU Emacs versions 21 and higher (not XEmacs).
+;;
+;; Installation:
+;;
+;;  - put `js2.el' somewhere in your emacs load path
+;;  - M-x byte-compile-file RET <path-to-js2.el> RET
+;;    Note:  it will refuse to run unless byte-compiled
+;;  - add these lines to your .emacs file:
+;;    (autoload 'js2-mode "js2" nil t)
+;;    (add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
+;;
+;; To customize how it works:
+;;   M-x customize-group RET js2-mode RET
+;;
+;; The variable `js2-mode-version' is a date stamp.  When you upgrade
+;; to a newer version, you must byte-compile the file again.
+;;
+;; Notes:
+;;
+;; This mode is different in many ways from standard Emacs language editing
+;; modes, inasmuch as it attempts to be more like an IDE.  If this drives
+;; you crazy, it IS possible to customize it to be more like other Emacs
+;; editing modes.  Please customize the group `js2-mode' to see all of the
+;; configuration options.
+;;
+;; Some of the functionality does not work in Emacs 21 -- upgrading to
+;; Emacs 22 or higher will get you better results.  If you byte-compiled
+;; js2.el with Emacs 21, you should re-compile it for Emacs 22.
+;;
+;; Unlike cc-engine based language modes, js2-mode's line-indentation is not
+;; customizable.  It is a surprising amount of work to support customizable
+;; indentation.  The current compromise is that the tab key lets you cycle among
+;; various likely indentation points, similar to the behavior of python-mode.
+;;
+;; This mode does not yet work with "multi-mode" modes such as mmm-mode
+;; and mumamo, although it could possibly be made to do so with some effort.
+;; This means that js2-mode is currently only useful for editing JavaScript
+;; files, and not for editing JavaScript within <script> tags or templates.
+;;
+;; This code is part of a larger project, in progress, to enable writing
+;; Emacs customizations in JavaScript.
+;;
+;; Please email bug reports and suggestions to the author, or submit them
+;; at http://code.google.com/p/js2-mode/issues
+
+;; TODO:
+;;  - add unreachable-code warning (error?) using the inconsistent-return analysis
+;;  - labeled stmt length is now 1
+;;  - "anonymous function does not always return a value" - use getter/setter name
+;;  - extend js2-missing-semi-one-line-override to handle catch (e) {return x}
+;;  - set a text prop on autoinserted delimiters and don't biff user-entered ones
+;;  - when inserting magic curlies, look for matching close-curly before inserting
+;;  - get more use out of the symbol table:
+;;    - jump to declaration (put hyperlinks on all non-decl var usages?)
+;;    - rename variable/function
+;;    - warn on unused var
+;;  - add some dabbrev-expansions for built-in keywords like finally, function
+;;  - add at least some completion support, e.g. for built-ins
+;;  - code formatting
+
+;;; Code:
+;;; js2-externs.el -- JavaScript extern definitions for js2-mode
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;;; Code:
+
+(defvar js2-ecma-262-externs
+  (mapcar 'symbol-name
+          '(Array
+            Boolean
+            Date
+            Error
+            EvalError
+            Function
+            Infinity
+            Math
+            NaN
+            Number
+            Object
+            RangeError
+            ReferenceError
+            RegExp
+            String
+            SyntaxError
+            TypeError
+            URIError
+            arguments
+            decodeURI
+            decodeURIComponent
+            encodeURI
+            encodeURIComponent
+            escape
+            eval
+            isFinite
+            isNaN
+            parseFloat
+            parseInt
+            undefined
+            unescape))
+"Ecma-262 externs.  Included in `js2-externs' by default.")
+
+(defvar js2-browser-externs
+  (mapcar 'symbol-name
+          '(;; DOM level 1
+            Attr
+            CDATASection
+            CharacterData
+            Comment
+            DOMException
+            DOMImplementation
+            Document
+            DocumentFragment
+            DocumentType
+            Element
+            Entity
+            EntityReference
+            ExceptionCode
+            NamedNodeMap
+            Node
+            NodeList
+            Notation
+            ProcessingInstruction
+            Text
+
+            ;; DOM level 2
+            HTMLAnchorElement
+            HTMLAppletElement
+            HTMLAreaElement
+            HTMLBRElement
+            HTMLBaseElement
+            HTMLBaseFontElement
+            HTMLBodyElement
+            HTMLButtonElement
+            HTMLCollection
+            HTMLDListElement
+            HTMLDirectoryElement
+            HTMLDivElement
+            HTMLDocument
+            HTMLElement
+            HTMLFieldSetElement
+            HTMLFontElement
+            HTMLFormElement
+            HTMLFrameElement
+            HTMLFrameSetElement
+            HTMLHRElement
+            HTMLHeadElement
+            HTMLHeadingElement
+            HTMLHtmlElement
+            HTMLIFrameElement
+            HTMLImageElement
+            HTMLInputElement
+            HTMLIsIndexElement
+            HTMLLIElement
+            HTMLLabelElement
+            HTMLLegendElement
+            HTMLLinkElement
+            HTMLMapElement
+            HTMLMenuElement
+            HTMLMetaElement
+            HTMLModElement
+            HTMLOListElement
+            HTMLObjectElement
+            HTMLOptGroupElement
+            HTMLOptionElement
+            HTMLOptionsCollection
+            HTMLParagraphElement
+            HTMLParamElement
+            HTMLPreElement
+            HTMLQuoteElement
+            HTMLScriptElement
+            HTMLSelectElement
+            HTMLStyleElement
+            HTMLTableCaptionElement
+            HTMLTableCellElement
+            HTMLTableColElement
+            HTMLTableElement
+            HTMLTableRowElement
+            HTMLTableSectionElement
+            HTMLTextAreaElement
+            HTMLTitleElement
+            HTMLUListElement
+
+            ;; DOM level 3
+            DOMConfiguration
+            DOMError
+            DOMException
+            DOMImplementationList
+            DOMImplementationSource
+            DOMLocator
+            DOMStringList
+            NameList
+            TypeInfo
+            UserDataHandler
+
+            ;; Window
+            alert
+            confirm
+            document
+            java
+            navigator
+            prompt
+            screen
+            self
+            top
+
+            ;; W3C CSS
+            CSSCharsetRule
+            CSSFontFace
+            CSSFontFaceRule
+            CSSImportRule
+            CSSMediaRule
+            CSSPageRule
+            CSSPrimitiveValue
+            CSSProperties
+            CSSRule
+            CSSRuleList
+            CSSStyleDeclaration
+            CSSStyleRule
+            CSSStyleSheet
+            CSSValue
+            CSSValueList
+            Counter
+            DOMImplementationCSS
+            DocumentCSS
+            DocumentStyle
+            ElementCSSInlineStyle
+            LinkStyle
+            MediaList
+            RGBColor
+            Rect
+            StyleSheet
+            StyleSheetList
+            ViewCSS
+
+            ;; W3C Event
+            EventListener
+            EventTarget
+            Event
+            DocumentEvent
+            UIEvent
+            MouseEvent
+            MutationEvent
+            KeyboardEvent
+
+            ;; W3C Range
+            DocumentRange
+            Range
+            RangeException
+
+            ;; W3C XML
+            XPathResult
+            XMLHttpRequest
+            ))
+  "Browser externs.
+You can cause these to be included or excluded with the custom
+variable `js2-include-browser-externs'.")
+
+(defvar js2-rhino-externs
+  (mapcar 'symbol-name
+          '(Packages
+            importClass
+            importPackage
+            com
+            org
+            java
+
+            ;; Global object (shell) externs
+            defineClass
+            deserialize
+            doctest
+            gc
+            help
+            load
+            loadClass
+            print
+            quit
+            readFile
+            readUrl
+            runCommand
+            seal
+            serialize
+            spawn
+            sync
+            toint32
+            version))
+  "Mozilla Rhino externs.
+Set `js2-include-rhino-externs' to t to include them.")
+
+(defvar js2-gears-externs
+  (mapcar 'symbol-name
+          '(
+            ;; finish me!
+            ))
+  "Google Gears externs.
+Set `js2-include-gears-externs' to t to include them.")
+
+(provide 'js2-externs)
+
+;;; js2-externs.el ends here
+;;; js2-vars.el -- byte-compiler support for js2-mode
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;;; Code:
+
+(eval-when-compile
+  (require 'cl))
+
+(eval-and-compile
+  (require 'cc-mode)     ; (only) for `c-populate-syntax-table'
+  (require 'cc-langs)    ; it's here in Emacs 21...
+  (require 'cc-engine))  ; for `c-paragraph-start' et. al.
+
+
+(defvar js2-emacs22 (>= emacs-major-version 22))
+
+(defcustom js2-highlight-level 2
+  "Amount of syntax highlighting to perform.
+nil, zero or negative means none.
+1 adds basic syntax highlighting.
+2 adds highlighting of some Ecma built-in properties.
+3 adds highlighting of many Ecma built-in functions."
+  :group 'js2-mode
+  :type '(choice (const :tag "None" nil)
+                 (const :tag "Basic" 1)
+                 (const :tag "Include Properties" 2)
+                 (const :tag "Include Functions" 3)))
+
+(defvar js2-mode-dev-mode-p nil
+  "Non-nil if running in development mode.  Normally nil.")
+
+(defgroup js2-mode nil
+  "An improved JavaScript mode."
+  :group 'languages)
+
+(defcustom js2-basic-offset (if (and (boundp 'c-basic-offset)
+                                     (numberp c-basic-offset))
+                                c-basic-offset
+                              4)
+  "Number of spaces to indent nested statements.
+Similar to `c-basic-offset'."
+  :group 'js2-mode
+  :type 'integer)
+(make-variable-buffer-local 'js2-basic-offset)
+
+(defcustom js2-cleanup-whitespace nil
+  "Non-nil to invoke `delete-trailing-whitespace' before saves."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-move-point-on-right-click t
+  "Non-nil to move insertion point when you right-click.
+This makes right-click context menu behavior a bit more intuitive,
+since menu operations generally apply to the point.  The exception
+is if there is a region selection, in which case the point does -not-
+move, so cut/copy/paste etc. can work properly.
+
+Note that IntelliJ moves the point, and Eclipse leaves it alone,
+so this behavior is customizable."
+  :group 'js2-mode
+  :type 'boolean)
+
+(defcustom js2-mirror-mode t
+  "Non-nil to insert closing brackets, parens, etc. automatically."
+  :group 'js2-mode
+  :type 'boolean)
+
+(defcustom js2-auto-indent-p nil
+  "Automatic indentation with punctuation characters. If non-nil, the
+current line is indented when certain punctuations are inserted."
+  :group 'js2-mode
+  :type 'boolean)
+
+(defcustom js2-bounce-indent-p nil
+  "Non-nil to have indent-line function choose among alternatives.
+If nil, the indent-line function will indent to a predetermined column
+based on heuristic guessing.  If non-nil, then if the current line is
+already indented to that predetermined column, indenting will choose
+another likely column and indent to that spot.  Repeated invocation of
+the indent-line function will cycle among the computed alternatives.
+See the function `js2-bounce-indent' for details."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-indent-on-enter-key nil
+  "Non-nil to have Enter/Return key indent the line.
+This is unusual for Emacs modes but common in IDEs like Eclipse."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-enter-indents-newline nil
+  "Non-nil to have Enter/Return key indent the newly-inserted line.
+This is unusual for Emacs modes but common in IDEs like Eclipse."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-rebind-eol-bol-keys t
+  "Non-nil to rebind beginning-of-line and end-of-line keys.
+If non-nil, bounce between bol/eol and first/last non-whitespace char."
+  :group 'js2-mode
+  :type 'boolean)
+
+(defcustom js2-electric-keys '("{" "}" "(" ")" "[" "]" ":" ";" "," "*")
+  "Keys that auto-indent when `js2-auto-indent-p' is non-nil.
+Each value in the list is passed to `define-key'."
+  :type 'list
+  :group 'js2-mode)
+
+(defcustom js2-idle-timer-delay 0.2
+  "Delay in secs before re-parsing after user makes changes.
+Multiplied by `js2-dynamic-idle-timer-adjust', which see."
+  :type 'number
+  :group 'js2-mode)
+(make-variable-buffer-local 'js2-idle-timer-delay)
+
+(defcustom js2-dynamic-idle-timer-adjust 0
+  "Positive to adjust `js2-idle-timer-delay' based on file size.
+The idea is that for short files, parsing is faster so we can be
+more responsive to user edits without interfering with editing.
+The buffer length in characters (typically bytes) is divided by
+this value and used to multiply `js2-idle-timer-delay' for the
+buffer.  For example, a 21k file and 10k adjust yields 21k/10k
+== 2, so js2-idle-timer-delay is multiplied by 2.
+If `js2-dynamic-idle-timer-adjust' is 0 or negative,
+`js2-idle-timer-delay' is not dependent on the file size."
+  :type 'number
+  :group 'js2-mode)
+
+(defcustom js2-mode-escape-quotes t
+  "Non-nil to disable automatic quote-escaping inside strings."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-mode-squeeze-spaces t
+  "Non-nil to normalize whitespace when filling in comments.
+Multiple runs of spaces are converted to a single space."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-mode-show-parse-errors t
+  "True to highlight parse errors."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-mode-show-strict-warnings t
+  "Non-nil to emit Ecma strict-mode warnings.
+Some of the warnings can be individually disabled by other flags,
+even if this flag is non-nil."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-strict-trailing-comma-warning t
+  "Non-nil to warn about trailing commas in array literals.
+Ecma-262 forbids them, but many browsers permit them.  IE is the
+big exception, and can produce bugs if you have trailing commas."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-strict-missing-semi-warning t
+  "Non-nil to warn about semicolon auto-insertion after statement.
+Technically this is legal per Ecma-262, but some style guides disallow
+depending on it."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-missing-semi-one-line-override nil
+  "Non-nil to permit missing semicolons in one-line functions.
+In one-liner functions such as `function identity(x) {return x}'
+people often omit the semicolon for a cleaner look.  If you are
+such a person, you can suppress the missing-semicolon warning
+by setting this variable to t."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-strict-inconsistent-return-warning t
+  "Non-nil to warn about mixing returns with value-returns.
+It's perfectly legal to have a `return' and a `return foo' in the
+same function, but it's often an indicator of a bug, and it also
+interferes with type inference (in systems that support it.)"
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-strict-cond-assign-warning t
+  "Non-nil to warn about expressions like if (a = b).
+This often should have been '==' instead of '='.  If the warning
+is enabled, you can suppress it on a per-expression basis by
+parenthesizing the expression, e.g. if ((a = b)) ..."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-strict-cond-assign-warning t
+  "Non-nil to warn about expressions like if (a = b).
+This often should have been '==' instead of '='.  If the warning
+is enabled, you can suppress it on a per-expression basis by
+parenthesizing the expression, e.g. if ((a = b)) ..."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-strict-var-redeclaration-warning t
+  "Non-nil to warn about redeclaring variables in a script or function."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-strict-var-hides-function-arg-warning t
+  "Non-nil to warn about a var decl hiding a function argument."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-skip-preprocessor-directives nil
+  "Non-nil to treat lines beginning with # as comments.
+Useful for viewing Mozilla JavaScript source code."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-language-version 180
+  "Configures what JavaScript language version to recognize.
+Currently versions 150, 160, 170 and 180 are supported, corresponding
+to JavaScript 1.5, 1.6, 1.7 and 1.8, respectively.  In a nutshell,
+1.6 adds E4X support, 1.7 adds let, yield, and Array comprehensions,
+and 1.8 adds function closures."
+  :type 'integer
+  :group 'js2-mode)
+
+(defcustom js2-allow-keywords-as-property-names t
+  "If non-nil, you can use JavaScript keywords as object property names.
+Examples:
+
+  var foo = {int: 5, while: 6, continue: 7};
+  foo.return = 8;
+
+Ecma-262 forbids this syntax, but many browsers support it."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-instanceof-has-side-effects nil
+  "If non-nil, treats the instanceof operator as having side effects.
+This is useful for xulrunner apps."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-allow-rhino-new-expr-initializer nil
+  "Non-nil to support a Rhino's experimental syntactic construct.
+
+Rhino supports the ability to follow a `new' expression with an object
+literal, which is used to set additional properties on the new object
+after calling its constructor.  Syntax:
+
+  new <expr> [ ( arglist ) ] [initializer]
+
+Hence, this expression:
+
+  new Object {a: 1, b: 2}
+
+results in an Object with properties a=1 and b=2.  This syntax is
+apparently not configurable in Rhino - it's currently always enabled,
+as of Rhino version 1.7R2."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-allow-member-expr-as-function-name nil
+  "Non-nil to support experimental Rhino syntax for function names.
+
+Rhino supports an experimental syntax configured via the Rhino Context
+setting `allowMemberExprAsFunctionName'.  The experimental syntax is:
+
+  function <member-expr> ( [ arg-list ] ) { <body> }
+
+Where member-expr is a non-parenthesized 'member expression', which
+is anything at the grammar level of a new-expression or lower, meaning
+any expression that does not involve infix or unary operators.
+
+When <member-expr> is not a simple identifier, then it is syntactic
+sugar for assigning the anonymous function to the <member-expr>.  Hence,
+this code:
+
+  function a.b().c[2] (x, y) { ... }
+
+is rewritten as:
+
+  a.b().c[2] = function(x, y) {...}
+
+which doesn't seem particularly useful, but Rhino permits it."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defvar js2-mode-version 20090723
+  "Release number for `js2-mode'.")
+
+;; scanner variables
+
+(defmacro deflocal (name value &optional comment)
+  `(progn
+     (defvar ,name ,value ,comment)
+     (make-variable-buffer-local ',name)))
+
+;; We record the start and end position of each token.
+(deflocal js2-token-beg 1)
+(deflocal js2-token-end -1)
+
+(defvar js2-EOF_CHAR -1
+  "Represents end of stream.  Distinct from js2-EOF token type.")
+
+;; I originally used symbols to represent tokens, but Rhino uses
+;; ints and then sets various flag bits in them, so ints it is.
+;; The upshot is that we need a `js2-' prefix in front of each name.
+(defvar js2-ERROR -1)
+(defvar js2-EOF 0)
+(defvar js2-EOL 1)
+(defvar js2-ENTERWITH 2)       ; begin interpreter bytecodes
+(defvar js2-LEAVEWITH 3)
+(defvar js2-RETURN 4)
+(defvar js2-GOTO 5)
+(defvar js2-IFEQ 6)
+(defvar js2-IFNE 7)
+(defvar js2-SETNAME 8)
+(defvar js2-BITOR 9)
+(defvar js2-BITXOR 10)
+(defvar js2-BITAND 11)
+(defvar js2-EQ 12)
+(defvar js2-NE 13)
+(defvar js2-LT 14)
+(defvar js2-LE 15)
+(defvar js2-GT 16)
+(defvar js2-GE 17)
+(defvar js2-LSH 18)
+(defvar js2-RSH 19)
+(defvar js2-URSH 20)
+(defvar js2-ADD 21)            ; infix plus
+(defvar js2-SUB 22)            ; infix minus
+(defvar js2-MUL 23)
+(defvar js2-DIV 24)
+(defvar js2-MOD 25)
+(defvar js2-NOT 26)
+(defvar js2-BITNOT 27)
+(defvar js2-POS 28)            ; unary plus
+(defvar js2-NEG 29)            ; unary minus
+(defvar js2-NEW 30)
+(defvar js2-DELPROP 31)
+(defvar js2-TYPEOF 32)
+(defvar js2-GETPROP 33)
+(defvar js2-GETPROPNOWARN 34)
+(defvar js2-SETPROP 35)
+(defvar js2-GETELEM 36)
+(defvar js2-SETELEM 37)
+(defvar js2-CALL 38)
+(defvar js2-NAME 39)           ; an identifier
+(defvar js2-NUMBER 40)
+(defvar js2-STRING 41)
+(defvar js2-NULL 42)
+(defvar js2-THIS 43)
+(defvar js2-FALSE 44)
+(defvar js2-TRUE 45)
+(defvar js2-SHEQ 46)           ; shallow equality (===)
+(defvar js2-SHNE 47)           ; shallow inequality (!==)
+(defvar js2-REGEXP 48)
+(defvar js2-BINDNAME 49)
+(defvar js2-THROW 50)
+(defvar js2-RETHROW 51)        ; rethrow caught exception: catch (e if ) uses it
+(defvar js2-IN 52)
+(defvar js2-INSTANCEOF 53)
+(defvar js2-LOCAL_LOAD 54)
+(defvar js2-GETVAR 55)
+(defvar js2-SETVAR 56)
+(defvar js2-CATCH_SCOPE 57)
+(defvar js2-ENUM_INIT_KEYS 58)
+(defvar js2-ENUM_INIT_VALUES 59)
+(defvar js2-ENUM_INIT_ARRAY 60)
+(defvar js2-ENUM_NEXT 61)
+(defvar js2-ENUM_ID 62)
+(defvar js2-THISFN 63)
+(defvar js2-RETURN_RESULT 64)  ; to return previously stored return result
+(defvar js2-ARRAYLIT 65)       ; array literal
+(defvar js2-OBJECTLIT 66)      ; object literal
+(defvar js2-GET_REF 67)        ; *reference
+(defvar js2-SET_REF 68)        ; *reference = something
+(defvar js2-DEL_REF 69)        ; delete reference
+(defvar js2-REF_CALL 70)       ; f(args) = something or f(args)++
+(defvar js2-REF_SPECIAL 71)    ; reference for special properties like __proto
+(defvar js2-YIELD 72)          ; JS 1.7 yield pseudo keyword
+
+;; XML support
+(defvar js2-DEFAULTNAMESPACE 73)
+(defvar js2-ESCXMLATTR 74)
+(defvar js2-ESCXMLTEXT 75)
+(defvar js2-REF_MEMBER 76)     ; Reference for x.@y, x..y etc.
+(defvar js2-REF_NS_MEMBER 77)  ; Reference for x.ns::y, x..ns::y etc.
+(defvar js2-REF_NAME 78)       ; Reference for @y, @[y] etc.
+(defvar js2-REF_NS_NAME 79)    ; Reference for ns::y, @ns::y@[y] etc.
+
+(defvar js2-first-bytecode js2-ENTERWITH)
+(defvar js2-last-bytecode js2-REF_NS_NAME)
+
+(defvar js2-TRY 80)
+(defvar js2-SEMI 81)           ; semicolon
+(defvar js2-LB 82)             ; left and right brackets
+(defvar js2-RB 83)
+(defvar js2-LC 84)             ; left and right curly-braces
+(defvar js2-RC 85)
+(defvar js2-LP 86)             ; left and right parens
+(defvar js2-RP 87)
+(defvar js2-COMMA 88)          ; comma operator
+
+(defvar js2-ASSIGN 89)         ; simple assignment (=)
+(defvar js2-ASSIGN_BITOR 90)   ; |=
+(defvar js2-ASSIGN_BITXOR 91)  ; ^=
+(defvar js2-ASSIGN_BITAND 92)  ; &=
+(defvar js2-ASSIGN_LSH 93)     ; <<=
+(defvar js2-ASSIGN_RSH 94)     ; >>=
+(defvar js2-ASSIGN_URSH 95)    ; >>>=
+(defvar js2-ASSIGN_ADD 96)     ; +=
+(defvar js2-ASSIGN_SUB 97)     ; -=
+(defvar js2-ASSIGN_MUL 98)     ; *=
+(defvar js2-ASSIGN_DIV 99)     ; /=
+(defvar js2-ASSIGN_MOD 100)    ; %=
+
+(defvar js2-first-assign js2-ASSIGN)
+(defvar js2-last-assign js2-ASSIGN_MOD)
+
+(defvar js2-HOOK 101)          ; conditional (?:)
+(defvar js2-COLON 102)
+(defvar js2-OR 103)            ; logical or (||)
+(defvar js2-AND 104)           ; logical and (&&)
+(defvar js2-INC 105)           ; increment/decrement (++ --)
+(defvar js2-DEC 106)
+(defvar js2-DOT 107)           ; member operator (.)
+(defvar js2-FUNCTION 108)      ; function keyword
+(defvar js2-EXPORT 109)        ; export keyword
+(defvar js2-IMPORT 110)        ; import keyword
+(defvar js2-IF 111)            ; if keyword
+(defvar js2-ELSE 112)          ; else keyword
+(defvar js2-SWITCH 113)        ; switch keyword
+(defvar js2-CASE 114)          ; case keyword
+(defvar js2-DEFAULT 115)       ; default keyword
+(defvar js2-WHILE 116)         ; while keyword
+(defvar js2-DO 117)            ; do keyword
+(defvar js2-FOR 118)           ; for keyword
+(defvar js2-BREAK 119)         ; break keyword
+(defvar js2-CONTINUE 120)      ; continue keyword
+(defvar js2-VAR 121)           ; var keyword
+(defvar js2-WITH 122)          ; with keyword
+(defvar js2-CATCH 123)         ; catch keyword
+(defvar js2-FINALLY 124)       ; finally keyword
+(defvar js2-VOID 125)          ; void keyword
+(defvar js2-RESERVED 126)      ; reserved keywords
+
+(defvar js2-EMPTY 127)
+
+;; Types used for the parse tree - never returned by scanner.
+
+(defvar js2-BLOCK 128)         ; statement block
+(defvar js2-LABEL 129)         ; label
+(defvar js2-TARGET 130)
+(defvar js2-LOOP 131)
+(defvar js2-EXPR_VOID 132)     ; expression statement in functions
+(defvar js2-EXPR_RESULT 133)   ; expression statement in scripts
+(defvar js2-JSR 134)
+(defvar js2-SCRIPT 135)        ; top-level node for entire script
+(defvar js2-TYPEOFNAME 136)    ; for typeof(simple-name)
+(defvar js2-USE_STACK 137)
+(defvar js2-SETPROP_OP 138)    ; x.y op= something
+(defvar js2-SETELEM_OP 139)    ; x[y] op= something
+(defvar js2-LOCAL_BLOCK 140)
+(defvar js2-SET_REF_OP 141)    ; *reference op= something
+
+;; For XML support:
+(defvar js2-DOTDOT 142)        ; member operator (..)
+(defvar js2-COLONCOLON 143)    ; namespace::name
+(defvar js2-XML 144)           ; XML type
+(defvar js2-DOTQUERY 145)      ; .() -- e.g., x.emps.emp.(name == "terry")
+(defvar js2-XMLATTR 146)       ; @
+(defvar js2-XMLEND 147)
+
+;; Optimizer-only tokens
+(defvar js2-TO_OBJECT 148)
+(defvar js2-TO_DOUBLE 149)
+
+(defvar js2-GET 150)           ; JS 1.5 get pseudo keyword
+(defvar js2-SET 151)           ; JS 1.5 set pseudo keyword
+(defvar js2-LET 152)           ; JS 1.7 let pseudo keyword
+(defvar js2-CONST 153)
+(defvar js2-SETCONST 154)
+(defvar js2-SETCONSTVAR 155)
+(defvar js2-ARRAYCOMP 156)
+(defvar js2-LETEXPR 157)
+(defvar js2-WITHEXPR 158)
+(defvar js2-DEBUGGER 159)
+
+(defvar js2-COMMENT 160)
+(defvar js2-ENUM 161)  ; for "enum" reserved word
+
+(defconst js2-num-tokens (1+ js2-ENUM))
+
+(defconst js2-debug-print-trees nil)
+
+;; Rhino accepts any string or stream as input.
+;; Emacs character processing works best in buffers, so we'll
+;; assume the input is a buffer.  JavaScript strings can be
+;; copied into temp buffers before scanning them.
+
+;; Buffer-local variables yield much cleaner code than using `defstruct'.
+;; They're the Emacs equivalent of instance variables, more or less.
+
+(deflocal js2-ts-dirty-line nil
+  "Token stream buffer-local variable.
+Indicates stuff other than whitespace since start of line.")
+
+(deflocal js2-ts-regexp-flags nil
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-string ""
+  "Token stream buffer-local variable.
+Last string scanned.")
+
+(deflocal js2-ts-number nil
+  "Token stream buffer-local variable.
+Last literal number scanned.")
+
+(deflocal js2-ts-hit-eof nil
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-line-start 0
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-lineno 1
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-line-end-char -1
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-cursor 1  ; emacs buffers are 1-indexed
+  "Token stream buffer-local variable.
+Current scan position.")
+
+(deflocal js2-ts-is-xml-attribute nil
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-xml-is-tag-content nil
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-xml-open-tags-count 0
+  "Token stream buffer-local variable.")
+
+(deflocal js2-ts-string-buffer nil
+  "Token stream buffer-local variable.
+List of chars built up while scanning various tokens.")
+
+(deflocal js2-ts-comment-type nil
+  "Token stream buffer-local variable.")
+
+;;; Parser variables
+
+(deflocal js2-parsed-errors nil
+  "List of errors produced during scanning/parsing.")
+
+(deflocal js2-parsed-warnings nil
+  "List of warnings produced during scanning/parsing.")
+
+(deflocal js2-recover-from-parse-errors t
+  "Non-nil to continue parsing after a syntax error.
+
+In recovery mode, the AST will be built in full, and any error
+nodes will be flagged with appropriate error information.  If
+this flag is nil, a syntax error will result in an error being
+signaled.
+
+The variable is automatically buffer-local, because different
+modes that use the parser will need different settings.")
+
+(deflocal js2-parse-hook nil
+  "List of callbacks for receiving parsing progress.")
+
+(defvar js2-parse-finished-hook nil
+  "List of callbacks to notify when parsing finishes.
+Not called if parsing was interrupted.")
+
+(deflocal js2-is-eval-code nil
+  "True if we're evaluating code in a string.
+If non-nil, the tokenizer will record the token text, and the AST nodes
+will record their source text.  Off by default for IDE modes, since the
+text is available in the buffer.")
+
+(defvar js2-parse-ide-mode t
+  "Non-nil if the parser is being used for `js2-mode'.
+If non-nil, the parser will set text properties for fontification
+and the syntax-table.  The value should be nil when using the
+parser as a frontend to an interpreter or byte compiler.")
+
+;;; Parser instance variables (buffer-local vars for js2-parse)
+
+(defconst js2-clear-ti-mask #xFFFF
+  "Mask to clear token information bits.")
+
+(defconst js2-ti-after-eol (lsh 1 16)
+  "Flag:  first token of the source line.")
+
+(defconst js2-ti-check-label (lsh 1 17)
+  "Flag:  indicates to check for label.")
+
+;; Inline Rhino's CompilerEnvirons vars as buffer-locals.
+
+(deflocal js2-compiler-generate-debug-info t)
+(deflocal js2-compiler-use-dynamic-scope nil)
+(deflocal js2-compiler-reserved-keywords-as-identifier nil)
+(deflocal js2-compiler-xml-available t)
+(deflocal js2-compiler-optimization-level 0)
+(deflocal js2-compiler-generating-source t)
+(deflocal js2-compiler-strict-mode nil)
+(deflocal js2-compiler-report-warning-as-error nil)
+(deflocal js2-compiler-generate-observer-count nil)
+(deflocal js2-compiler-activation-names nil)
+
+;; SKIP:  sourceURI
+
+;; There's a compileFunction method in Context.java - may need it.
+(deflocal js2-called-by-compile-function nil
+  "True if `js2-parse' was called by `js2-compile-function'.
+Will only be used when we finish implementing the interpreter.")
+
+;; SKIP:  ts  (we just call `js2-init-scanner' and use its vars)
+
+(deflocal js2-current-flagged-token js2-EOF)
+(deflocal js2-current-token js2-EOF)
+
+;; SKIP:  node factory - we're going to just call functions directly,
+;; and eventually go to a unified AST format.
+
+(deflocal js2-nesting-of-function 0)
+
+(deflocal js2-recorded-assignments nil
+  "Tracks assignments found during parsing.")
+
+(defcustom js2-global-externs nil
+  "A list of any extern names you'd like to consider always declared.
+This list is global and is used by all js2-mode files.
+You can create buffer-local externs list using `js2-additional-externs'.
+
+There is also a buffer-local variable `js2-default-externs',
+which is initialized by default to include the Ecma-262 externs
+and the standard browser externs.  The three lists are all
+checked during highlighting."
+  :type 'list
+  :group 'js2-mode)
+
+(deflocal js2-default-externs nil
+  "Default external declarations.
+
+These are currently only used for highlighting undeclared variables,
+which only worries about top-level (unqualified) references.
+As js2-mode's processing improves, we will flesh out this list.
+
+The initial value is set to `js2-ecma-262-externs', unless you
+have set `js2-include-browser-externs', in which case the browser
+externs are also included.
+
+See `js2-additional-externs' for more information.")
+
+(defcustom js2-include-browser-externs t
+  "Non-nil to include browser externs in the master externs list.
+If you work on JavaScript files that are not intended for browsers,
+such as Mozilla Rhino server-side JavaScript, set this to nil.
+You can always include them on a per-file basis by calling
+`js2-add-browser-externs' from a function on `js2-mode-hook'.
+
+See `js2-additional-externs' for more information about externs."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-include-rhino-externs t
+  "Non-nil to include Mozilla Rhino externs in the master externs list.
+See `js2-additional-externs' for more information about externs."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-include-gears-externs t
+  "Non-nil to include Google Gears externs in the master externs list.
+See `js2-additional-externs' for more information about externs."
+  :type 'boolean
+  :group 'js2-mode)
+
+(deflocal js2-additional-externs nil
+  "A buffer-local list of additional external declarations.
+It is used to decide whether variables are considered undeclared
+for purposes of highlighting.
+
+Each entry is a lisp string.  The string should be the fully qualified
+name of an external entity.  All externs should be added to this list,
+so that as js2-mode's processing improves it can take advantage of them.
+
+You may want to declare your externs in three ways.
+First, you can add externs that are valid for all your JavaScript files.
+You should probably do this by adding them to `js2-global-externs', which
+is a global list used for all js2-mode files.
+
+Next, you can add a function to `js2-mode-hook' that adds additional
+externs appropriate for the specific file, perhaps based on its path.
+These should go in `js2-additional-externs', which is buffer-local.
+
+Finally, you can add a function to `js2-post-parse-callbacks',
+which is called after parsing completes, and `root' is bound to
+the root of the parse tree.  At this stage you can set up an AST
+node visitor using `js2-visit-ast' and examine the parse tree
+for specific import patterns that may imply the existence of
+other externs, possibly tied to your build system.  These should also
+be added to `js2-additional-externs'.
+
+Your post-parse callback may of course also use the simpler and
+faster (but perhaps less robust) approach of simply scanning the
+buffer text for your imports, using regular expressions.")
+
+;; SKIP:  decompiler
+;; SKIP:  encoded-source
+
+;;; The following variables are per-function and should be saved/restored
+;;; during function parsing...
+
+(deflocal js2-current-script-or-fn nil)
+(deflocal js2-current-scope nil)
+(deflocal js2-nesting-of-with 0)
+(deflocal js2-label-set nil
+  "An alist mapping label names to nodes.")
+
+(deflocal js2-loop-set nil)
+(deflocal js2-loop-and-switch-set nil)
+(deflocal js2-has-return-value nil)
+(deflocal js2-end-flags 0)
+
+;;; ...end of per function variables
+
+;; Without 2-token lookahead, labels are a problem.
+;; These vars store the token info of the last matched name,
+;; iff it wasn't the last matched token.  Only valid in some contexts.
+(defvar js2-prev-name-token-start nil)
+(defvar js2-prev-name-token-string nil)
+
+(defsubst js2-save-name-token-data (pos name)
+  (setq js2-prev-name-token-start pos
+        js2-prev-name-token-string name))
+
+;; These flags enumerate the possible ways a statement/function can
+;; terminate. These flags are used by endCheck() and by the Parser to
+;; detect inconsistent return usage.
+;;
+;; END_UNREACHED is reserved for code paths that are assumed to always be
+;; able to execute (example: throw, continue)
+;;
+;; END_DROPS_OFF indicates if the statement can transfer control to the
+;; next one. Statement such as return dont. A compound statement may have
+;; some branch that drops off control to the next statement.
+;;
+;; END_RETURNS indicates that the statement can return (without arguments)
+;; END_RETURNS_VALUE indicates that the statement can return a value.
+;;
+;; A compound statement such as
+;; if (condition) {
+;;   return value;
+;; }
+;; Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck()
+
+(defconst js2-end-unreached     #x0)
+(defconst js2-end-drops-off     #x1)
+(defconst js2-end-returns       #x2)
+(defconst js2-end-returns-value #x4)
+(defconst js2-end-yields        #x8)
+
+;; Rhino awkwardly passes a statementLabel parameter to the
+;; statementHelper() function, the main statement parser, which
+;; is then used by quite a few of the sub-parsers.  We just make
+;; it a buffer-local variable and make sure it's cleaned up properly.
+(deflocal js2-labeled-stmt nil)  ; type `js2-labeled-stmt-node'
+
+;; Similarly, Rhino passes an inForInit boolean through about half
+;; the expression parsers.  We use a dynamically-scoped variable,
+;; which makes it easier to funcall the parsers individually without
+;; worrying about whether they take the parameter or not.
+(deflocal js2-in-for-init nil)
+(deflocal js2-temp-name-counter 0)
+(deflocal js2-parse-stmt-count 0)
+
+(defsubst js2-get-next-temp-name ()
+  (format "$%d" (incf js2-temp-name-counter)))
+
+(defvar js2-parse-interruptable-p t
+  "Set this to nil to force parse to continue until finished.
+This will mostly be useful for interpreters.")
+
+(defvar js2-statements-per-pause 50
+  "Pause after this many statements to check for user input.
+If user input is pending, stop the parse and discard the tree.
+This makes for a smoother user experience for large files.
+You may have to wait a second or two before the highlighting
+and error-reporting appear, but you can always type ahead if
+you wish.  This appears to be more or less how Eclipse, IntelliJ
+and other editors work.")
+
+(deflocal js2-record-comments t
+  "Instructs the scanner to record comments in `js2-scanned-comments'.")
+
+(deflocal js2-scanned-comments nil
+  "List of all comments from the current parse.")
+
+(defun js2-underline-color (color)
+  "Return a legal value for the :underline face attribute based on COLOR."
+  ;; In XEmacs the :underline attribute can only be a boolean.
+  ;; In GNU it can be the name of a colour.
+  (if (featurep 'xemacs)
+      (if color t nil)
+    color))
+
+(defcustom js2-mode-indent-inhibit-undo nil
+  "Non-nil to disable collection of Undo information when indenting lines.
+Some users have requested this behavior.  It's nil by default because
+other Emacs modes don't work this way."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-mode-indent-ignore-first-tab nil
+  "If non-nil, ignore first TAB keypress if we look indented properly.
+It's fairly common for users to navigate to an already-indented line
+and press TAB for reassurance that it's been indented.  For this class
+of users, we want the first TAB press on a line to be ignored if the
+line is already indented to one of the precomputed alternatives.
+
+This behavior is only partly implemented.  If you TAB-indent a line,
+navigate to another line, and then navigate back, it fails to clear
+the last-indented variable, so it thinks you've already hit TAB once,
+and performs the indent.  A full solution would involve getting on the
+point-motion hooks for the entire buffer.  If we come across another
+use cases that requires watching point motion, I'll consider doing it.
+
+If you set this variable to nil, then the TAB key will always change
+the indentation of the current line, if more than one alternative
+indentation spot exists."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defvar js2-indent-hook nil
+  "A hook for user-defined indentation rules.
+
+Functions on this hook should expect two arguments:    (LIST INDEX)
+The LIST argument is the list of computed indentation points for
+the current line.  INDEX is the list index of the indentation point
+that `js2-bounce-indent' plans to use.  If INDEX is nil, then the
+indent function is not going to change the current line indentation.
+
+If a hook function on this list returns a non-nil value, then
+`js2-bounce-indent' assumes the hook function has performed its own
+indentation, and will do nothing.  If all hook functions on the list
+return nil, then `js2-bounce-indent' will use its computed indentation
+and reindent the line.
+
+When hook functions on this hook list are called, the variable
+`js2-mode-ast' may or may not be set, depending on whether the
+parse tree is available.  If the variable is nil, you can pass a
+callback to `js2-mode-wait-for-parse', and your callback will be
+called after the new parse tree is built.  This can take some time
+in large files.")
+
+(defface js2-warning-face
+  `((((class color) (background light))
+     (:underline ,(js2-underline-color "orange")))
+    (((class color) (background dark))
+     (:underline ,(js2-underline-color "orange")))
+    (t (:underline t)))
+  "Face for JavaScript warnings."
+  :group 'js2-mode)
+
+(defface js2-error-face
+  `((((class color) (background light))
+     (:foreground "red"))
+    (((class color) (background dark))
+     (:foreground "red"))
+    (t (:foreground "red")))
+  "Face for JavaScript errors."
+  :group 'js2-mode)
+
+(defface js2-jsdoc-tag-face
+  '((t :foreground "SlateGray"))
+  "Face used to highlight @whatever tags in jsdoc comments."
+  :group 'js2-mode)
+
+(defface js2-jsdoc-type-face
+  '((t :foreground "SteelBlue"))
+  "Face used to highlight {FooBar} types in jsdoc comments."
+  :group 'js2-mode)
+
+(defface js2-jsdoc-value-face
+  '((t :foreground "PeachPuff3"))
+  "Face used to highlight tag values in jsdoc comments."
+  :group 'js2-mode)
+
+(defface js2-function-param-face
+  '((t :foreground "SeaGreen"))
+  "Face used to highlight function parameters in javascript."
+  :group 'js2-mode)
+
+(defface js2-instance-member-face
+  '((t :foreground "DarkOrchid"))
+  "Face used to highlight instance variables in javascript.
+Not currently used."
+  :group 'js2-mode)
+
+(defface js2-private-member-face
+  '((t :foreground "PeachPuff3"))
+  "Face used to highlight calls to private methods in javascript.
+Not currently used."
+  :group 'js2-mode)
+
+(defface js2-private-function-call-face
+  '((t :foreground "goldenrod"))
+  "Face used to highlight calls to private functions in javascript.
+Not currently used."
+  :group 'js2-mode)
+
+(defface js2-jsdoc-html-tag-name-face
+  (if js2-emacs22
+      '((((class color) (min-colors 88) (background light))
+         (:foreground "rosybrown"))
+        (((class color) (min-colors 8) (background dark))
+         (:foreground "yellow"))
+        (((class color) (min-colors 8) (background light))
+         (:foreground "magenta")))
+    '((((type tty pc) (class color) (background light))
+       (:foreground "magenta"))
+      (((type tty pc) (class color) (background dark))
+       (:foreground "yellow"))
+      (t (:foreground "RosyBrown"))))
+    "Face used to highlight jsdoc html tag names"
+  :group 'js2-mode)
+
+(defface js2-jsdoc-html-tag-delimiter-face
+  (if js2-emacs22
+      '((((class color) (min-colors 88) (background light))
+         (:foreground "dark khaki"))
+        (((class color) (min-colors 8) (background dark))
+         (:foreground "green"))
+        (((class color) (min-colors 8) (background light))
+         (:foreground "green")))
+    '((((type tty pc) (class color) (background light))
+       (:foreground "green"))
+      (((type tty pc) (class color) (background dark))
+       (:foreground "green"))
+      (t (:foreground "dark khaki"))))
+  "Face used to highlight brackets in jsdoc html tags."
+  :group 'js2-mode)
+
+(defface js2-magic-paren-face
+  '((t :underline t))
+  "Face used to color parens that will be auto-overwritten."
+  :group 'js2-mode)
+
+(defcustom js2-post-parse-callbacks nil
+  "A list of callback functions invoked after parsing finishes.
+Currently, the main use for this function is to add synthetic
+declarations to `js2-recorded-assignments', which see."
+  :type 'list
+  :group 'js2-mode)
+
+(defface js2-external-variable-face
+  '((t :foreground "orange"))
+  "Face used to highlight assignments to undeclared variables.
+An undeclared variable is any variable not declared with var or let
+in the current scope or any lexically enclosing scope.  If you assign
+to such a variable, then you are either expecting it to originate from
+another file, or you've got a potential bug."
+  :group 'js2-mode)
+
+(defcustom js2-highlight-external-variables t
+  "Non-nil to higlight assignments to undeclared variables."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defcustom js2-auto-insert-catch-block t
+  "Non-nil to insert matching catch block on open-curly after `try'."
+  :type 'boolean
+  :group 'js2-mode)
+
+(defvar js2-mode-map
+  (let ((map (make-sparse-keymap))
+        keys)
+    (define-key map [mouse-1] #'js2-mode-show-node)
+    (define-key map (kbd "C-m") #'js2-enter-key)
+    (when js2-rebind-eol-bol-keys
+      (define-key map (kbd "C-a") #'js2-beginning-of-line)
+      (define-key map (kbd "C-e") #'js2-end-of-line))
+    (define-key map (kbd "C-c C-e") #'js2-mode-hide-element)
+    (define-key map (kbd "C-c C-s") #'js2-mode-show-element)
+    (define-key map (kbd "C-c C-a") #'js2-mode-show-all)
+    (define-key map (kbd "C-c C-f") #'js2-mode-toggle-hide-functions)
+    (define-key map (kbd "C-c C-t") #'js2-mode-toggle-hide-comments)
+    (define-key map (kbd "C-c C-o") #'js2-mode-toggle-element)
+    (define-key map (kbd "C-c C-w") #'js2-mode-toggle-warnings-and-errors)
+    (define-key map (kbd "C-c C-`") #'js2-next-error)
+    ;; also define user's preference for next-error, if available
+    (if (setq keys (where-is-internal #'next-error))
+        (define-key map (car keys) #'js2-next-error))
+    (define-key map (or (car (where-is-internal #'mark-defun))
+                        (kbd "M-C-h"))
+      #'js2-mark-defun)
+    (define-key map (or (car (where-is-internal #'narrow-to-defun))
+                        (kbd "C-x nd"))
+      #'js2-narrow-to-defun)
+    (define-key map [down-mouse-3] #'js2-down-mouse-3)
+    (when js2-auto-indent-p
+      (mapc (lambda (key)
+              (define-key map key #'js2-insert-and-indent))
+            js2-electric-keys))
+
+    (define-key map [menu-bar javascript]
+      (cons "JavaScript" (make-sparse-keymap "JavaScript")))
+
+    (define-key map [menu-bar javascript customize-js2-mode]
+      '(menu-item "Customize js2-mode" js2-mode-customize
+                  :help "Customize the behavior of this mode"))
+
+    (define-key map [menu-bar javascript js2-force-refresh]
+      '(menu-item "Force buffer refresh" js2-mode-reset
+                  :help "Re-parse the buffer from scratch"))
+
+    (define-key map [menu-bar javascript separator-2]
+      '("--"))
+
+    (define-key map [menu-bar javascript next-error]
+      '(menu-item "Next warning or error" js2-next-error
+                  :enabled (and js2-mode-ast
+                                (or (js2-ast-root-errors js2-mode-ast)
+                                    (js2-ast-root-warnings js2-mode-ast)))
+                  :help "Move to next warning or error"))
+
+    (define-key map [menu-bar javascript display-errors]
+      '(menu-item "Show errors and warnings" js2-mode-display-warnings-and-errors
+                  :visible (not js2-mode-show-parse-errors)
+                  :help "Turn on display of warnings and errors"))
+
+    (define-key map [menu-bar javascript hide-errors]
+      '(menu-item "Hide errors and warnings" js2-mode-hide-warnings-and-errors
+                  :visible js2-mode-show-parse-errors
+                  :help "Turn off display of warnings and errors"))
+
+    (define-key map [menu-bar javascript separator-1]
+      '("--"))
+
+    (define-key map [menu-bar javascript js2-toggle-function]
+      '(menu-item "Show/collapse element" js2-mode-toggle-element
+                  :help "Hide or show function body or comment"))
+
+    (define-key map [menu-bar javascript show-comments]
+      '(menu-item "Show block comments" js2-mode-toggle-hide-comments
+                  :visible js2-mode-comments-hidden
+                  :help "Expand all hidden block comments"))
+
+    (define-key map [menu-bar javascript hide-comments]
+      '(menu-item "Hide block comments" js2-mode-toggle-hide-comments
+                  :visible (not js2-mode-comments-hidden)
+                  :help "Show block comments as /*...*/"))
+
+    (define-key map [menu-bar javascript show-all-functions]
+      '(menu-item "Show function bodies" js2-mode-toggle-hide-functions
+                  :visible js2-mode-functions-hidden
+                  :help "Expand all hidden function bodies"))
+
+    (define-key map [menu-bar javascript hide-all-functions]
+      '(menu-item "Hide function bodies" js2-mode-toggle-hide-functions
+                  :visible (not js2-mode-functions-hidden)
+                  :help "Show {...} for all top-level function bodies"))
+
+    map)
+  "Keymap used in `js2-mode' buffers.")
+
+(defconst js2-mode-identifier-re "[a-zA-Z_$][a-zA-Z0-9_$]*")
+
+(defvar js2-mode-//-comment-re "^\\(\\s-*\\)//.+"
+  "Matches a //-comment line.  Must be first non-whitespace on line.
+First match-group is the leading whitespace.")
+
+(defvar js2-mode-hook nil)
+
+(deflocal js2-mode-ast nil "Private variable.")
+(deflocal js2-mode-parse-timer nil "Private variable.")
+(deflocal js2-mode-buffer-dirty-p nil "Private variable.")
+(deflocal js2-mode-parsing nil "Private variable.")
+(deflocal js2-mode-node-overlay nil)
+
+(defvar js2-mode-show-overlay js2-mode-dev-mode-p
+  "Debug:  Non-nil to highlight AST nodes on mouse-down.")
+
+(deflocal js2-mode-fontifications nil "Private variable")
+(deflocal js2-mode-deferred-properties nil "Private variable")
+(deflocal js2-imenu-recorder nil "Private variable")
+(deflocal js2-imenu-function-map nil "Private variable")
+
+(defvar js2-paragraph-start
+  "\\(@[a-zA-Z]+\\>\\|$\\)")
+
+;; Note that we also set a 'c-in-sws text property in html comments,
+;; so that `c-forward-sws' and `c-backward-sws' work properly.
+(defvar js2-syntactic-ws-start
+  "\\s \\|/[*/]\\|[\n\r]\\|\\\\[\n\r]\\|\\s!\\|<!--\\|^\\s-*-->")
+
+(defvar js2-syntactic-ws-end
+  "\\s \\|[\n\r/]\\|\\s!")
+
+(defvar js2-syntactic-eol
+  (concat "\\s *\\(/\\*[^*\n\r]*"
+          "\\(\\*+[^*\n\r/][^*\n\r]*\\)*"
+          "\\*+/\\s *\\)*"
+          "\\(//\\|/\\*[^*\n\r]*"
+          "\\(\\*+[^*\n\r/][^*\n\r]*\\)*$"
+          "\\|\\\\$\\|$\\)")
+  "Copied from java-mode.  Needed for some cc-engine functions.")
+
+(defvar js2-comment-prefix-regexp
+  "//+\\|\\**")
+
+(defvar js2-comment-start-skip
+  "\\(//+\\|/\\*+\\)\\s *")
+
+(defvar js2-mode-verbose-parse-p js2-mode-dev-mode-p
+  "Non-nil to emit status messages during parsing.")
+
+(defvar js2-mode-functions-hidden nil "private variable")
+(defvar js2-mode-comments-hidden nil "private variable")
+
+(defvar js2-mode-syntax-table
+  (let ((table (make-syntax-table)))
+    (c-populate-syntax-table table)
+    table)
+  "Syntax table used in js2-mode buffers.")
+
+(defvar js2-mode-abbrev-table nil
+  "Abbrev table in use in `js2-mode' buffers.")
+(define-abbrev-table 'js2-mode-abbrev-table ())
+
+(defvar js2-mode-must-byte-compile (not js2-mode-dev-mode-p)
+  "Non-nil to have `js2-mode' signal an error if not byte-compiled.")
+
+(defvar js2-mode-pending-parse-callbacks nil
+  "List of functions waiting to be notified that parse is finished.")
+
+(defvar js2-mode-last-indented-line -1)
+
+(eval-when-compile
+  (defvar c-paragraph-start nil)
+  (defvar c-paragraph-separate nil)
+  (defvar c-syntactic-ws-start nil)
+  (defvar c-syntactic-ws-end nil)
+  (defvar c-syntactic-eol nil)
+  (defvar running-xemacs nil)
+  (defvar font-lock-mode nil)
+  (defvar font-lock-keywords nil))
+
+;; Workaround for buggy Emacs 21 behavior.
+(eval-when-compile
+  (if (< emacs-major-version 22)
+      (defun c-setup-paragraph-variables () nil)))
+
+(provide 'js2-vars)
+
+;;; js2-vars.el ends here
+;;; js2-util.el -- JavaScript utilities
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;;; Code
+
+(eval-when-compile
+  (require 'cl))
+
+
+;; Emacs21 compatibility, plus some stuff to avoid runtime dependency on CL
+
+(unless (fboundp #'looking-back)
+  (defun looking-back (regexp &optional limit greedy)
+    "Return non-nil if text before point matches regular expression REGEXP.
+Like `looking-at' except matches before point, and is slower.
+LIMIT if non-nil speeds up the search by specifying a minimum
+starting position, to avoid checking matches that would start
+before LIMIT.
+
+If GREEDY is non-nil, extend the match backwards as far as possible,
+stopping when a single additional previous character cannot be part
+of a match for REGEXP."
+    (let ((start (point))
+          (pos
+           (save-excursion
+             (and (re-search-backward (concat "\\(?:" regexp "\\)\\=") limit t)
+                  (point)))))
+      (if (and greedy pos)
+          (save-restriction
+            (narrow-to-region (point-min) start)
+            (while (and (> pos (point-min))
+                        (save-excursion
+                          (goto-char pos)
+                          (backward-char 1)
+                          (looking-at (concat "\\(?:"  regexp "\\)\\'"))))
+              (setq pos (1- pos)))
+            (save-excursion
+              (goto-char pos)
+              (looking-at (concat "\\(?:"  regexp "\\)\\'")))))
+      (not (null pos)))))
+
+(unless (fboundp #'copy-overlay)
+  (defun copy-overlay (o)
+    "Return a copy of overlay O."
+    (let ((o1 (make-overlay (overlay-start o) (overlay-end o)
+                            ;; FIXME: there's no easy way to find the
+                            ;; insertion-type of the two markers.
+                            (overlay-buffer o)))
+          (props (overlay-properties o)))
+      (while props
+        (overlay-put o1 (pop props) (pop props)))
+      o1)))
+
+(unless (fboundp #'remove-overlays)
+  (defun remove-overlays (&optional beg end name val)
+    "Clear BEG and END of overlays whose property NAME has value VAL.
+Overlays might be moved and/or split.
+BEG and END default respectively to the beginning and end of buffer."
+    (unless beg (setq beg (point-min)))
+    (unless end (setq end (point-max)))
+    (if (< end beg)
+        (setq beg (prog1 end (setq end beg))))
+    (save-excursion
+      (dolist (o (overlays-in beg end))
+        (when (eq (overlay-get o name) val)
+          ;; Either push this overlay outside beg...end
+          ;; or split it to exclude beg...end
+          ;; or delete it entirely (if it is contained in beg...end).
+          (if (< (overlay-start o) beg)
+              (if (> (overlay-end o) end)
+                  (progn
+                    (move-overlay (copy-overlay o)
+                                  (overlay-start o) beg)
+                    (move-overlay o end (overlay-end o)))
+                (move-overlay o (overlay-start o) beg))
+            (if (> (overlay-end o) end)
+                (move-overlay o end (overlay-end o))
+              (delete-overlay o))))))))
+
+;; we don't want a runtime dependency on the CL package, so define
+;; our own versions of these functions.
+
+(defun js2-delete-if (predicate list)
+  "Remove all items satisfying PREDICATE in LIST."
+  (loop for item in list
+        if (not (funcall predicate item))
+        collect item))
+
+(defun js2-position (element list)
+  "Find 0-indexed position of ELEMENT in LIST comparing with `eq'.
+Returns nil if element is not found in the list."
+  (let ((count 0)
+        found)
+    (while (and list (not found))
+      (if (eq element (car list))
+          (setq found t)
+        (setq count (1+ count)
+              list (cdr list))))
+    (if found count)))
+
+(defun js2-find-if (predicate list)
+  "Find first item satisfying PREDICATE in LIST."
+  (let (result)
+    (while (and list (not result))
+      (if (funcall predicate (car list))
+          (setq result (car list)))
+      (setq list (cdr list)))
+    result))
+
+;;; end Emacs 21 compat
+
+(defmacro js2-time (form)
+  "Evaluate FORM, discard result, and return elapsed time in sec"
+  (let ((beg (make-symbol "--js2-time-beg--"))
+        (delta (make-symbol "--js2-time-end--")))
+    `(let ((,beg (current-time))
+           ,delta)
+       ,form
+       (/ (truncate (* (- (float-time (current-time))
+                          (float-time ,beg)))
+                    10000)
+          10000.0))))
+
+(def-edebug-spec js2-time t)
+
+(defsubst neq (expr1 expr2)
+  "Return (not (eq expr1 expr2))."
+  (not (eq expr1 expr2)))
+
+(defsubst js2-same-line (pos)
+  "Return t if POS is on the same line as current point."
+  (and (>= pos (point-at-bol))
+       (<= pos (point-at-eol))))
+
+(defsubst js2-same-line-2 (p1 p2)
+  "Return t if p1 is on the same line as p2."
+  (save-excursion
+    (goto-char p1)
+    (js2-same-line p2)))
+
+(defun js2-code-bug ()
+  "Signal an error when we encounter an unexpected code path."
+  (error "failed assertion"))
+
+;; I'd like to associate errors with nodes, but for now the
+;; easiest thing to do is get the context info from the last token.
+(defsubst js2-record-parse-error (msg &optional arg pos len)
+  (push (list (list msg arg)
+              (or pos js2-token-beg)
+              (or len (- js2-token-end js2-token-beg)))
+        js2-parsed-errors))
+
+(defsubst js2-report-error (msg &optional msg-arg pos len)
+  "Signal a syntax error or record a parse error."
+  (if js2-recover-from-parse-errors
+      (js2-record-parse-error msg msg-arg pos len)
+  (signal 'js2-syntax-error
+          (list msg
+                js2-ts-lineno
+                (save-excursion
+                  (goto-char js2-ts-cursor)
+                  (current-column))
+                js2-ts-hit-eof))))
+
+(defsubst js2-report-warning (msg &optional msg-arg pos len)
+  (if js2-compiler-report-warning-as-error
+      (js2-report-error msg msg-arg pos len)
+    (push (list (list msg msg-arg)
+                (or pos js2-token-beg)
+                (or len (- js2-token-end js2-token-beg)))
+          js2-parsed-warnings)))
+
+(defsubst js2-add-strict-warning (msg-id &optional msg-arg beg end)
+  (if js2-compiler-strict-mode
+      (js2-report-warning msg-id msg-arg beg
+                          (and beg end (- end beg)))))
+
+(put 'js2-syntax-error 'error-conditions
+     '(error syntax-error js2-syntax-error))
+(put 'js2-syntax-error 'error-message "Syntax error")
+
+(put 'js2-parse-error 'error-conditions
+     '(error parse-error js2-parse-error))
+(put 'js2-parse-error 'error-message "Parse error")
+
+(defmacro js2-clear-flag (flags flag)
+  `(setq ,flags (logand ,flags (lognot ,flag))))
+
+(defmacro js2-set-flag (flags flag)
+  "Logical-or FLAG into FLAGS."
+  `(setq ,flags (logior ,flags ,flag)))
+
+(defsubst js2-flag-set-p (flags flag)
+  (/= 0 (logand flags flag)))
+
+(defsubst js2-flag-not-set-p (flags flag)
+  (zerop (logand flags flag)))
+
+;; Stolen shamelessly from James Clark's nxml-mode.
+(defmacro js2-with-unmodifying-text-property-changes (&rest body)
+  "Evaluate BODY without any text property changes modifying the buffer.
+Any text properties changes happen as usual but the changes are not treated as
+modifications to the buffer."
+  (let ((modified (make-symbol "modified")))
+    `(let ((,modified (buffer-modified-p))
+	   (inhibit-read-only t)
+	   (inhibit-modification-hooks t)
+	   (buffer-undo-list t)
+	   (deactivate-mark nil)
+	   ;; Apparently these avoid file locking problems.
+	   (buffer-file-name nil)
+	   (buffer-file-truename nil))
+       (unwind-protect
+	   (progn ,@body)
+	 (unless ,modified
+	   (restore-buffer-modified-p nil))))))
+
+(put 'js2-with-unmodifying-text-property-changes 'lisp-indent-function 0)
+(def-edebug-spec js2-with-unmodifying-text-property-changes t)
+
+(defmacro js2-with-underscore-as-word-syntax (&rest body)
+  "Evaluate BODY with the _ character set to be word-syntax."
+  (let ((old-syntax (make-symbol "old-syntax")))
+  `(let ((,old-syntax (string (char-syntax ?_))))
+     (unwind-protect
+         (progn
+           (modify-syntax-entry ?_ "w" js2-mode-syntax-table)
+           ,@body)
+       (modify-syntax-entry ?_ ,old-syntax js2-mode-syntax-table)))))
+
+(put 'js2-with-underscore-as-word-syntax 'lisp-indent-function 0)
+(def-edebug-spec js2-with-underscore-as-word-syntax t)
+
+(defmacro with-buffer (buf form)
+  "Executes FORM in buffer BUF.
+BUF can be a buffer name or a buffer object.
+If the buffer doesn't exist, it's created."
+  `(let ((buffer (gentemp)))
+    (setq buffer
+	  (if (stringp ,buf)
+	      (get-buffer-create ,buf)
+	    ,buf))
+    (save-excursion
+      (set-buffer buffer)
+      ,form)))
+
+(defsubst char-is-uppercase (c)
+  "Return t if C is an uppercase character.
+Handles unicode and latin chars properly."
+  (/= c (downcase c)))
+
+(defsubst char-is-lowercase (c)
+  "Return t if C is an uppercase character.
+Handles unicode and latin chars properly."
+  (/= c (upcase c)))
+
+(put 'with-buffer 'lisp-indent-function 1)
+(def-edebug-spec with-buffer t)
+
+(provide 'js2-util)
+
+;;; js2-util.el ends here
+;;; js2-scan.el --- JavaScript scanner
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;;; Commentary:
+
+;; A port of Mozilla Rhino's scanner.
+;; Corresponds to Rhino files Token.java and TokenStream.java.
+
+;;; Code:
+
+
+(eval-when-compile
+  (require 'cl))
+
+(defvar js2-tokens nil
+  "List of all defined token names.")  ; initialized in `js2-token-names'
+
+(defconst js2-token-names
+  (let* ((names (make-vector js2-num-tokens -1))
+         (case-fold-search nil)  ; only match js2-UPPER_CASE
+         (syms (apropos-internal "^js2-\\(?:[A-Z_]+\\)")))
+    (loop for sym in syms
+          for i from 0
+          do
+          (unless (or (memq sym '(js2-EOF_CHAR js2-ERROR))
+                      (not (boundp sym)))
+            (aset names (symbol-value sym)         ; code, e.g. 152
+                  (substring (symbol-name sym) 4)) ; name, e.g. "LET"
+            (push sym js2-tokens)))
+    names)
+  "Vector mapping int values to token string names, sans `js2-' prefix.")
+
+(defun js2-token-name (tok)
+  "Return a string name for TOK, a token symbol or code.
+Signals an error if it's not a recognized token."
+  (let ((code tok))
+    (if (symbolp tok)
+        (setq code (symbol-value tok)))
+    (if (eq code -1)
+        "ERROR"
+      (if (and (numberp code)
+               (not (minusp code))
+               (< code js2-num-tokens))
+          (aref js2-token-names code)
+        (error "Invalid token: %s" code)))))
+
+(defsubst js2-token-sym (tok)
+  "Return symbol for TOK given its code, e.g. 'js2-LP for code 86."
+  (intern (js2-token-name tok)))
+
+(defconst js2-token-codes
+  (let ((table (make-hash-table :test 'eq :size 256)))
+    (loop for name across js2-token-names
+          for sym = (intern (concat "js2-" name))
+          do
+          (puthash sym (symbol-value sym) table))
+    ;; clean up a few that are "wrong" in Rhino's token codes
+    (puthash 'js2-DELETE js2-DELPROP table)
+    table)
+  "Hashtable mapping token symbols to their bytecodes.")
+
+(defsubst js2-token-code (sym)
+  "Return code for token symbol SYM, e.g. 86 for 'js2-LP."
+  (or (gethash sym js2-token-codes)
+      (error "Invalid token symbol: %s " sym)))  ; signal code bug
+
+(defsubst js2-report-scan-error (msg &optional no-throw beg len)
+  (setq js2-token-end js2-ts-cursor)
+  (js2-report-error msg nil
+                    (or beg js2-token-beg)
+                    (or len (- js2-token-end js2-token-beg)))
+  (unless no-throw
+    (throw 'return js2-ERROR)))
+
+(defsubst js2-get-string-from-buffer ()
+  "Reverse the char accumulator and return it as a string."
+  (setq js2-token-end js2-ts-cursor)
+  (if js2-ts-string-buffer
+      (apply #'string (nreverse js2-ts-string-buffer))
+    ""))
+
+;; TODO:  could potentially avoid a lot of consing by allocating a
+;; char buffer the way Rhino does.
+(defsubst js2-add-to-string (c)
+  (push c js2-ts-string-buffer))
+
+;; Note that when we "read" the end-of-file, we advance js2-ts-cursor
+;; to (1+ (point-max)), which lets the scanner treat end-of-file like
+;; any other character:  when it's not part of the current token, we
+;; unget it, allowing it to be read again by the following call.
+(defsubst js2-unget-char ()
+  (decf js2-ts-cursor))
+
+;; Rhino distinguishes \r and \n line endings.  We don't need to
+;; because we only scan from Emacs buffers, which always use \n.
+(defsubst js2-get-char ()
+  "Read and return the next character from the input buffer.
+Increments `js2-ts-lineno' if the return value is a newline char.
+Updates `js2-ts-cursor' to the point after the returned char.
+Returns `js2-EOF_CHAR' if we hit the end of the buffer.
+Also updates `js2-ts-hit-eof' and `js2-ts-line-start' as needed."
+  (let (c)
+    ;; check for end of buffer
+    (if (>= js2-ts-cursor (point-max))
+        (setq js2-ts-hit-eof t
+              js2-ts-cursor (1+ js2-ts-cursor)
+              c js2-EOF_CHAR)  ; return value
+      ;; otherwise read next char
+      (setq c (char-before (incf js2-ts-cursor)))
+      ;; if we read a newline, update counters
+      (if (= c ?\n)
+          (setq js2-ts-line-start js2-ts-cursor
+                js2-ts-lineno (1+ js2-ts-lineno)))
+      ;; TODO:  skip over format characters
+      c)))
+
+(defsubst js2-read-unicode-escape ()
+  "Read a \\uNNNN sequence from the input.
+Assumes the ?\ and ?u have already been read.
+Returns the unicode character, or nil if it wasn't a valid character.
+Doesn't change the values of any scanner variables."
+  ;; I really wish I knew a better way to do this, but I can't
+  ;; find the Emacs function that takes a 16-bit int and converts
+  ;; it to a Unicode/utf-8 character.  So I basically eval it with (read).
+  ;; Have to first check that it's 4 hex characters or it may stop
+  ;; the read early.
+  (ignore-errors
+    (let ((s (buffer-substring-no-properties js2-ts-cursor
+                                             (+ 4 js2-ts-cursor))))
+      (if (string-match "[a-zA-Z0-9]\\{4\\}" s)
+          (read (concat "?\\u" s))))))
+
+(defsubst js2-match-char (test)
+  "Consume and return next character if it matches TEST, a character.
+Returns nil and consumes nothing if TEST is not the next character."
+  (let ((c (js2-get-char)))
+    (if (eq c test)
+        t
+      (js2-unget-char)
+      nil)))
+
+(defsubst js2-peek-char ()
+  (prog1
+      (js2-get-char)
+    (js2-unget-char)))
+
+(defsubst js2-java-identifier-start-p (c)
+  (or
+   (memq c '(?$ ?_))
+   (char-is-uppercase c)
+   (char-is-lowercase c)))
+
+(defsubst js2-java-identifier-part-p (c)
+  "Implementation of java.lang.Character.isJavaIdentifierPart()"
+  ;; TODO:  make me Unicode-friendly.  See comments above.
+  (or
+   (memq c '(?$ ?_))
+   (char-is-uppercase c)
+   (char-is-lowercase c)
+   (and (>= c ?0) (<= c ?9))))
+
+(defsubst js2-alpha-p (c)
+  (cond ((and (<= ?A c) (<= c ?Z)) t)
+        ((and (<= ?a c) (<= c ?z)) t)
+        (t nil)))
+
+(defsubst js2-digit-p (c)
+  (and (<= ?0 c) (<= c ?9)))
+
+(defsubst js2-js-space-p (c)
+  (if (<= c 127)
+      (memq c '(#x20 #x9 #xB #xC #xD))
+    (or
+     (eq c #xA0)
+     ;; TODO:  change this nil to check for Unicode space character
+     nil)))
+
+(defconst js2-eol-chars (list js2-EOF_CHAR ?\n ?\r))
+
+(defsubst js2-skip-line ()
+  "Skip to end of line"
+  (let (c)
+    (while (not (memq (setq c (js2-get-char)) js2-eol-chars)))
+    (js2-unget-char)
+    (setq js2-token-end js2-ts-cursor)))
+
+(defun js2-init-scanner (&optional buf line)
+  "Create token stream for BUF starting on LINE.
+BUF defaults to current-buffer and line defaults to 1.
+
+A buffer can only have one scanner active at a time, which yields
+dramatically simpler code than using a defstruct.  If you need to
+have simultaneous scanners in a buffer, copy the regions to scan
+into temp buffers."
+  (save-excursion
+    (when buf
+      (set-buffer buf))
+    (setq js2-ts-dirty-line nil
+          js2-ts-regexp-flags nil
+          js2-ts-string ""
+          js2-ts-number nil
+          js2-ts-hit-eof nil
+          js2-ts-line-start 0
+          js2-ts-lineno (or line 1)
+          js2-ts-line-end-char -1
+          js2-ts-cursor (point-min)
+          js2-ts-is-xml-attribute nil
+          js2-ts-xml-is-tag-content nil
+          js2-ts-xml-open-tags-count 0
+          js2-ts-string-buffer nil)))
+
+;; This function uses the cached op, string and number fields in
+;; TokenStream; if getToken has been called since the passed token
+;; was scanned, the op or string printed may be incorrect.
+(defun js2-token-to-string (token)
+  ;; Not sure where this function is used in Rhino.  Not tested.
+  (if (not js2-debug-print-trees)
+      ""
+    (let ((name (js2-token-name token)))
+      (cond
+       ((memq token (list js2-STRING js2-REGEXP js2-NAME))
+        (concat name " `" js2-ts-string "'"))
+       ((eq token js2-NUMBER)
+        (format "NUMBER %g" js2-ts-number))
+       (t
+        name)))))
+
+(defconst js2-keywords
+  '(break
+    case catch const continue
+    debugger default delete do
+    else enum
+    false finally for function
+    if in instanceof import
+    let
+    new null
+    return
+    switch
+    this throw true try typeof
+    var void
+    while with
+    yield))
+
+;; Token names aren't exactly the same as the keywords, unfortunately.
+;; E.g. enum isn't in the tokens, and delete is js2-DELPROP.
+(defconst js2-kwd-tokens
+  (let ((table (make-vector js2-num-tokens nil))
+        (tokens
+         (list js2-BREAK
+               js2-CASE js2-CATCH js2-CONST js2-CONTINUE
+               js2-DEBUGGER js2-DEFAULT js2-DELPROP js2-DO
+               js2-ELSE
+               js2-FALSE js2-FINALLY js2-FOR js2-FUNCTION
+               js2-IF js2-IN js2-INSTANCEOF js2-IMPORT
+               js2-LET
+               js2-NEW js2-NULL
+               js2-RETURN
+               js2-SWITCH
+               js2-THIS js2-THROW js2-TRUE js2-TRY js2-TYPEOF
+               js2-VAR
+               js2-WHILE js2-WITH
+               js2-YIELD)))
+    (dolist (i tokens)
+      (aset table i 'font-lock-keyword-face))
+    (aset table js2-STRING 'font-lock-string-face)
+    (aset table js2-REGEXP 'font-lock-string-face)
+    (aset table js2-COMMENT 'font-lock-comment-face)
+    (aset table js2-THIS 'font-lock-builtin-face)
+    (aset table js2-VOID 'font-lock-constant-face)
+    (aset table js2-NULL 'font-lock-constant-face)
+    (aset table js2-TRUE 'font-lock-constant-face)
+    (aset table js2-FALSE 'font-lock-constant-face)
+    table)
+  "Vector whose values are non-nil for tokens that are keywords.
+The values are default faces to use for highlighting the keywords.")
+
+(defconst js2-reserved-words
+  '(abstract
+    boolean byte
+    char class
+    double
+    enum export extends
+    final float
+    goto
+    implements import int interface
+    long
+    native
+    package private protected public
+    short static super synchronized
+    throws transient
+    volatile))
+
+(defconst js2-keyword-names
+  (let ((table (make-hash-table :test 'equal)))
+    (loop for k in js2-keywords
+          do (puthash
+              (symbol-name k)                            ; instanceof
+              (intern (concat "js2-"
+                              (upcase (symbol-name k)))) ; js2-INSTANCEOF
+              table))
+    table)
+  "JavaScript keywords by name, mapped to their symbols.")
+
+(defconst js2-reserved-word-names
+  (let ((table (make-hash-table :test 'equal)))
+    (loop for k in js2-reserved-words
+          do
+          (puthash (symbol-name k) 'js2-RESERVED table))
+    table)
+  "JavaScript reserved words by name, mapped to 'js2-RESERVED.")
+
+(defsubst js2-collect-string (buf)
+  "Convert BUF, a list of chars, to a string.
+Reverses BUF before converting."
+  (cond
+   ((stringp buf)
+    buf)
+   ((null buf)  ; for emacs21 compat
+    "")
+   (t
+    (if buf
+        (apply #'string (nreverse buf))
+      ""))))
+
+(defun js2-string-to-keyword (s)
+  "Return token for S, a string, if S is a keyword or reserved word.
+Returns a symbol such as 'js2-BREAK, or nil if not keyword/reserved."
+  (or (gethash s js2-keyword-names)
+      (gethash s js2-reserved-word-names)))
+
+(defsubst js2-ts-set-char-token-bounds ()
+  "Used when next token is one character."
+  (setq js2-token-beg (1- js2-ts-cursor)
+        js2-token-end js2-ts-cursor))
+
+(defsubst js2-ts-return (token)
+  "Return an N-character TOKEN from `js2-get-token'.
+Updates `js2-token-end' accordingly."
+  (setq js2-token-end js2-ts-cursor)
+  (throw 'return token))
+
+(defsubst js2-x-digit-to-int (c accumulator)
+  "Build up a hex number.
+If C is a hexadecimal digit, return ACCUMULATOR * 16 plus
+corresponding number.  Otherwise return -1."
+  (catch 'return
+    (catch 'check
+      ;; Use 0..9 < A..Z < a..z
+      (cond
+       ((<= c ?9)
+        (decf c ?0)
+        (if (<= 0 c)
+            (throw 'check nil)))
+       ((<= c ?F)
+        (when (<= ?A c)
+          (decf c (- ?A 10))
+          (throw 'check nil)))
+       ((<= c ?f)
+        (when (<= ?a c)
+          (decf c (- ?a 10))
+          (throw 'check nil))))
+      (throw 'return -1))
+    (logior c (lsh accumulator 4))))
+
+(defun js2-get-token ()
+  "Return next JavaScript token, an int such as js2-RETURN."
+  (let (c
+        c1
+        identifier-start
+        is-unicode-escape-start
+        contains-escape
+        escape-val
+        escape-start
+        str
+        result
+        base
+        is-integer
+        quote-char
+        val
+        look-for-slash
+        continue)
+    (catch 'return
+      (while t
+        ;; Eat whitespace, possibly sensitive to newlines.
+        (setq continue t)
+        (while continue
+          (setq c (js2-get-char))
+          (cond
+           ((eq c js2-EOF_CHAR)
+            (js2-ts-set-char-token-bounds)
+            (throw 'return js2-EOF))
+           ((eq c ?\n)
+            (js2-ts-set-char-token-bounds)
+            (setq js2-ts-dirty-line nil)
+            (throw 'return js2-EOL))
+           ((not (js2-js-space-p c))
+            (if (/= c ?-)               ; in case end of HTML comment
+                (setq js2-ts-dirty-line t))
+            (setq continue nil))))
+        ;; Assume the token will be 1 char - fixed up below.
+        (js2-ts-set-char-token-bounds)
+        (when (eq c ?@)
+          (throw 'return js2-XMLATTR))
+        ;; identifier/keyword/instanceof?
+        ;; watch out for starting with a <backslash>
+        (cond
+         ((eq c ?\\)
+          (setq c (js2-get-char))
+          (if (eq c ?u)
+              (setq identifier-start t
+                    is-unicode-escape-start t
+                    js2-ts-string-buffer nil)
+            (setq identifier-start nil)
+            (js2-unget-char)
+            (setq c ?\\)))
+         (t
+          (when (setq identifier-start (js2-java-identifier-start-p c))
+            (setq js2-ts-string-buffer nil)
+            (js2-add-to-string c))))
+        (when identifier-start
+          (setq contains-escape is-unicode-escape-start)
+          (catch 'break
+            (while t
+              (if is-unicode-escape-start
+                  ;; strictly speaking we should probably push-back
+                  ;; all the bad characters if the <backslash>uXXXX
+                  ;; sequence is malformed. But since there isn't a
+                  ;; correct context(is there?) for a bad Unicode
+                  ;; escape sequence in an identifier, we can report
+                  ;; an error here.
+                  (progn
+                    (setq escape-val 0)
+                    (dotimes (i 4)
+                      (setq c (js2-get-char)
+                            escape-val (js2-x-digit-to-int c escape-val))
+                      ;; Next check takes care of c < 0 and bad escape
+                      (if (minusp escape-val)
+                          (throw 'break nil)))
+                    (if (minusp escape-val)
+                        (js2-report-scan-error "msg.invalid.escape" t))
+                    (js2-add-to-string escape-val)
+                    (setq is-unicode-escape-start nil))
+                (setq c (js2-get-char))
+                (cond
+                 ((eq c ?\\)
+                  (setq c (js2-get-char))
+                  (if (eq c ?u)
+                      (setq is-unicode-escape-start t
+                            contains-escape t)
+                    (js2-report-scan-error "msg.illegal.character" t)))
+                 (t
+                  (if (or (eq c js2-EOF_CHAR)
+                          (not (js2-java-identifier-part-p c)))
+                      (throw 'break nil))
+                  (js2-add-to-string c))))))
+          (js2-unget-char)
+          (setq str (js2-get-string-from-buffer))
+          (unless contains-escape
+            ;; OPT we shouldn't have to make a string (object!) to
+            ;; check if it's a keyword.
+            ;; Return the corresponding token if it's a keyword
+            (when (setq result (js2-string-to-keyword str))
+              (if (and (< js2-language-version 170)
+                       (memq result '(js2-LET js2-YIELD)))
+                  ;; LET and YIELD are tokens only in 1.7 and later
+                  (setq result 'js2-NAME))
+              (if (neq result js2-RESERVED)
+                  (throw 'return (js2-token-code result)))
+              (js2-report-warning "msg.reserved.keyword" str)))
+          ;; If we want to intern these as Rhino does, just use (intern str)
+          (setq js2-ts-string str)
+          (throw 'return js2-NAME))     ; end identifier/kwd check
+        ;; is it a number?
+        (when (or (js2-digit-p c)
+                  (and (eq c ?.) (js2-digit-p (js2-peek-char))))
+          (setq js2-ts-string-buffer nil
+                base 10)
+          (when (eq c ?0)
+            (setq c (js2-get-char))
+            (cond
+             ((or (eq c ?x) (eq c ?X))
+              (setq base 16)
+              (setq c (js2-get-char)))
+             ((js2-digit-p c)
+              (setq base 8))
+             (t
+              (js2-add-to-string ?0))))
+          (if (eq base 16)
+              (while (<= 0 (js2-x-digit-to-int c 0))
+                (js2-add-to-string c)
+                (setq c (js2-get-char)))
+            (while (and (<= ?0 c) (<= c ?9))
+              ;; We permit 08 and 09 as decimal numbers, which
+              ;; makes our behavior a superset of the ECMA
+              ;; numeric grammar.  We might not always be so
+              ;; permissive, so we warn about it.
+              (when (and (eq base 8) (>= c ?8))
+                (js2-report-warning "msg.bad.octal.literal"
+                                    (if (eq c ?8) "8" "9"))
+                (setq base 10))
+              (js2-add-to-string c)
+              (setq c (js2-get-char))))
+          (setq is-integer t)
+          (when (and (eq base 10) (memq c '(?. ?e ?E)))
+            (setq is-integer nil)
+            (when (eq c ?.)
+              (loop do
+                    (js2-add-to-string c)
+                    (setq c (js2-get-char))
+                    while (js2-digit-p c)))
+            (when (memq c '(?e ?E))
+              (js2-add-to-string c)
+              (setq c (js2-get-char))
+              (when (memq c '(?+ ?-))
+                (js2-add-to-string c)
+                (setq c (js2-get-char)))
+              (unless (js2-digit-p c)
+                (js2-report-scan-error "msg.missing.exponent" t))
+              (loop do
+                    (js2-add-to-string c)
+                    (setq c (js2-get-char))
+                    while (js2-digit-p c))))
+          (js2-unget-char)
+          (setq js2-ts-string (js2-get-string-from-buffer)
+                js2-ts-number
+                (if (and (eq base 10) (not is-integer))
+                    (string-to-number js2-ts-string)
+                  ;; TODO:  call runtime number-parser.  Some of it is in
+                  ;; js2-util.el, but I need to port ScriptRuntime.stringToNumber.
+                  (string-to-number js2-ts-string)))
+          (throw 'return js2-NUMBER))
+        ;; is it a string?
+        (when (memq c '(?\" ?\'))
+          ;; We attempt to accumulate a string the fast way, by
+          ;; building it directly out of the reader.  But if there
+          ;; are any escaped characters in the string, we revert to
+          ;; building it out of a string buffer.
+          (setq quote-char c
+                js2-ts-string-buffer nil
+                c (js2-get-char))
+          (catch 'break
+            (while (/= c quote-char)
+              (catch 'continue
+                (when (or (eq c ?\n) (eq c js2-EOF_CHAR))
+                  (js2-unget-char)
+                  (setq js2-token-end js2-ts-cursor)
+                  (js2-report-error "msg.unterminated.string.lit")
+                  (throw 'return js2-STRING))
+                (when (eq c ?\\)
+                  ;; We've hit an escaped character
+                  (setq c (js2-get-char))
+                  (case c
+                    (?b (setq c ?\b))
+                    (?f (setq c ?\f))
+                    (?n (setq c ?\n))
+                    (?r (setq c ?\r))
+                    (?t (setq c ?\t))
+                    (?v (setq c ?\v))
+                    (?u
+                     (setq c1 (js2-read-unicode-escape))
+                     (if js2-parse-ide-mode
+                         (if c1
+                             (progn
+                               ;; just copy the string in IDE-mode
+                               (js2-add-to-string ?\\)
+                               (js2-add-to-string ?u)
+                               (dotimes (i 3)
+                                 (js2-add-to-string (js2-get-char)))
+                               (setq c (js2-get-char))) ; added at end of loop
+                           ;; flag it as an invalid escape
+                           (js2-report-warning "msg.invalid.escape"
+                                               nil (- js2-ts-cursor 2) 6))
+                       ;; Get 4 hex digits; if the u escape is not
+                       ;; followed by 4 hex digits, use 'u' + the
+                       ;; literal character sequence that follows.
+                       (js2-add-to-string ?u)
+                       (setq escape-val 0)
+                       (dotimes (i 4)
+                         (setq c (js2-get-char)
+                               escape-val (js2-x-digit-to-int c escape-val))
+                         (if (minusp escape-val)
+                             (throw 'continue nil))
+                         (js2-add-to-string c))
+                       ;; prepare for replace of stored 'u' sequence by escape value
+                       (setq js2-ts-string-buffer (nthcdr 5 js2-ts-string-buffer)
+                             c escape-val)))
+                    (?x
+                     ;; Get 2 hex digits, defaulting to 'x'+literal
+                     ;; sequence, as above.
+                     (setq c (js2-get-char)
+                           escape-val (js2-x-digit-to-int c 0))
+                     (if (minusp escape-val)
+                         (progn
+                           (js2-add-to-string ?x)
+                           (throw 'continue nil))
+                       (setq c1 c
+                             c (js2-get-char)
+                             escape-val (js2-x-digit-to-int c escape-val))
+                       (if (minusp escape-val)
+                           (progn
+                             (js2-add-to-string ?x)
+                             (js2-add-to-string c1)
+                             (throw 'continue nil))
+                         ;; got 2 hex digits
+                         (setq c escape-val))))
+                    (?\n
+                     ;; Remove line terminator after escape to follow
+                     ;; SpiderMonkey and C/C++
+                     (setq c (js2-get-char))
+                     (throw 'continue nil))
+                    (t
+                     (when (and (<= ?0 c) (< c ?8))
+                       (setq val (- c ?0)
+                             c (js2-get-char))
+                       (when (and (<= ?0 c) (< c ?8))
+                         (setq val (- (+ (* 8 val) c) ?0)
+                               c (js2-get-char))
+                         (when (and (<= ?0 c)
+                                    (< c ?8)
+                                    (< val #o37))
+                           ;; c is 3rd char of octal sequence only
+                           ;; if the resulting val <= 0377
+                           (setq val (- (+ (* 8 val) c) ?0)
+                                 c (js2-get-char))))
+                       (js2-unget-char)
+                       (setq c val)))))
+                (js2-add-to-string c)
+                (setq c (js2-get-char)))))
+          (setq js2-ts-string (js2-get-string-from-buffer))
+          (throw 'return js2-STRING))
+        (case c
+          (?\;
+           (throw 'return js2-SEMI))
+          (?\[
+           (throw 'return js2-LB))
+          (?\]
+           (throw 'return js2-RB))
+          (?{
+           (throw 'return js2-LC))
+          (?}
+           (throw 'return js2-RC))
+          (?\(
+           (throw 'return js2-LP))
+          (?\)
+           (throw 'return js2-RP))
+          (?,
+           (throw 'return js2-COMMA))
+          (??
+           (throw 'return js2-HOOK))
+          (?:
+           (if (js2-match-char ?:)
+               (js2-ts-return js2-COLONCOLON)
+             (throw 'return js2-COLON)))
+          (?.
+           (if (js2-match-char ?.)
+               (js2-ts-return js2-DOTDOT)
+             (if (js2-match-char ?\()
+                 (js2-ts-return js2-DOTQUERY)
+               (throw 'return js2-DOT))))
+          (?|
+           (if (js2-match-char ?|)
+               (throw 'return js2-OR)
+             (if (js2-match-char ?=)
+                 (js2-ts-return js2-ASSIGN_BITOR)
+               (throw 'return js2-BITOR))))
+          (?^
+           (if (js2-match-char ?=)
+               (js2-ts-return js2-ASSIGN_BITOR)
+             (throw 'return js2-BITXOR)))
+          (?&
+           (if (js2-match-char ?&)
+               (throw 'return js2-AND)
+             (if (js2-match-char ?=)
+                 (js2-ts-return js2-ASSIGN_BITAND)
+               (throw 'return js2-BITAND))))
+          (?=
+           (if (js2-match-char ?=)
+               (if (js2-match-char ?=)
+                   (js2-ts-return js2-SHEQ)
+                 (throw 'return js2-EQ))
+             (throw 'return js2-ASSIGN)))
+          (?!
+           (if (js2-match-char ?=)
+               (if (js2-match-char ?=)
+                   (js2-ts-return js2-SHNE)
+                 (js2-ts-return js2-NE))
+             (throw 'return js2-NOT)))
+          (?<
+           ;; NB:treat HTML begin-comment as comment-till-eol
+           (when (js2-match-char ?!)
+             (when (js2-match-char ?-)
+               (when (js2-match-char ?-)
+                 (js2-skip-line)
+                 (setq js2-ts-comment-type 'html)
+                 (throw 'return js2-COMMENT)))
+             (js2-unget-char))
+           (if (js2-match-char ?<)
+               (if (js2-match-char ?=)
+                   (js2-ts-return js2-ASSIGN_LSH)
+                 (js2-ts-return js2-LSH))
+             (if (js2-match-char ?=)
+                 (js2-ts-return js2-LE)
+               (throw 'return js2-LT))))
+          (?>
+           (if (js2-match-char ?>)
+               (if (js2-match-char ?>)
+                   (if (js2-match-char ?=)
+                       (js2-ts-return js2-ASSIGN_URSH)
+                     (js2-ts-return js2-URSH))
+                 (if (js2-match-char ?=)
+                     (js2-ts-return js2-ASSIGN_RSH)
+                   (js2-ts-return js2-RSH)))
+             (if (js2-match-char ?=)
+                 (js2-ts-return js2-GE)
+               (throw 'return js2-GT))))
+          (?*
+           (if (js2-match-char ?=)
+               (js2-ts-return js2-ASSIGN_MUL)
+             (throw 'return js2-MUL)))
+          (?/
+           ;; is it a // comment?
+           (when (js2-match-char ?/)
+             (setq js2-token-beg (- js2-ts-cursor 2))
+             (js2-skip-line)
+             (setq js2-ts-comment-type 'line)
+             ;; include newline so highlighting goes to end of window
+             (incf js2-token-end)
+             (throw 'return js2-COMMENT))
+           ;; is it a /* comment?
+           (when (js2-match-char ?*)
+             (setq look-for-slash nil
+                   js2-token-beg (- js2-ts-cursor 2)
+                   js2-ts-comment-type
+                   (if (js2-match-char ?*)
+                       (progn
+                         (setq look-for-slash t)
+                         'jsdoc)
+                     'block))
+             (while t
+               (setq c (js2-get-char))
+               (cond
+                ((eq c js2-EOF_CHAR)
+                 (setq js2-token-end (1- js2-ts-cursor))
+                 (js2-report-error "msg.unterminated.comment")
+                 (throw 'return js2-COMMENT))
+                ((eq c ?*)
+                 (setq look-for-slash t))
+                ((eq c ?/)
+                 (if look-for-slash
+                   (js2-ts-return js2-COMMENT)))
+                (t
+                 (setq look-for-slash nil
+                       js2-token-end js2-ts-cursor)))))
+           (if (js2-match-char ?=)
+               (js2-ts-return js2-ASSIGN_DIV)
+             (throw 'return js2-DIV)))
+           (?#
+            (when js2-skip-preprocessor-directives
+              (js2-skip-line)
+              (setq js2-ts-comment-type 'preprocessor
+                    js2-token-end js2-ts-cursor)
+              (throw 'return js2-COMMENT))
+            (throw 'return js2-ERROR))
+          (?%
+           (if (js2-match-char ?=)
+               (js2-ts-return js2-ASSIGN_MOD)
+             (throw 'return js2-MOD)))
+          (?~
+           (throw 'return js2-BITNOT))
+          (?+
+           (if (js2-match-char ?=)
+               (js2-ts-return js2-ASSIGN_ADD)
+             (if (js2-match-char ?+)
+                 (js2-ts-return js2-INC)
+               (throw 'return js2-ADD))))
+          (?-
+           (cond
+            ((js2-match-char ?=)
+             (setq c js2-ASSIGN_SUB))
+            ((js2-match-char ?-)
+             (unless js2-ts-dirty-line
+               ;; treat HTML end-comment after possible whitespace
+               ;; after line start as comment-until-eol
+               (when (js2-match-char ?>)
+                 (js2-skip-line)
+                 (setq js2-ts-comment-type 'html)
+                 (throw 'return js2-COMMENT)))
+             (setq c js2-DEC))
+            (t
+             (setq c js2-SUB)))
+           (setq js2-ts-dirty-line t)
+           (js2-ts-return c))
+          (otherwise
+           (js2-report-scan-error "msg.illegal.character")))))))
+
+(defun js2-read-regexp (start-token)
+  "Called by parser when it gets / or /= in literal context."
+  (let (c
+        err
+        in-class  ; inside a '[' .. ']' character-class
+        flags
+        (continue t))
+    (setq js2-token-beg js2-ts-cursor
+          js2-ts-string-buffer nil
+          js2-ts-regexp-flags nil)
+    (if (eq start-token js2-ASSIGN_DIV)
+        ;; mis-scanned /=
+        (js2-add-to-string ?=)
+      (if (neq start-token js2-DIV)
+          (error "failed assertion")))
+    (while (and (not err)
+                (or (/= (setq c (js2-get-char)) ?/)
+                    in-class))
+      (cond
+       ((or (= c ?\n)
+            (= c js2-EOF_CHAR))
+        (setq js2-token-end (1- js2-ts-cursor)
+              err t
+              js2-ts-string (js2-collect-string js2-ts-string-buffer))
+        (js2-report-error "msg.unterminated.re.lit"))
+       (t (cond
+           ((= c ?\\)
+            (js2-add-to-string c)
+            (setq c (js2-get-char)))
+           ((= c ?\[)
+            (setq in-class t))
+           ((= c ?\])
+            (setq in-class nil)))
+          (js2-add-to-string c))))
+    (unless err
+      (while continue
+        (cond
+         ((js2-match-char ?g)
+          (push ?g flags))
+         ((js2-match-char ?i)
+          (push ?i flags))
+         ((js2-match-char ?m)
+          (push ?m flags))
+         (t
+          (setq continue nil))))
+      (if (js2-alpha-p (js2-peek-char))
+          (js2-report-scan-error "msg.invalid.re.flag" t
+                                 js2-ts-cursor 1))
+      (setq js2-ts-string (js2-collect-string js2-ts-string-buffer)
+            js2-ts-regexp-flags (js2-collect-string flags)
+            js2-token-end js2-ts-cursor)
+      ;; tell `parse-partial-sexp' to ignore this range of chars
+      (put-text-property js2-token-beg js2-token-end 'syntax-class '(2)))))
+
+(defun js2-get-first-xml-token ()
+  (setq js2-ts-xml-open-tags-count 0
+        js2-ts-is-xml-attribute nil
+        js2-ts-xml-is-tag-content nil)
+  (js2-unget-char)
+  (js2-get-next-xml-token))
+
+(defsubst js2-xml-discard-string ()
+  "Throw away the string in progress and flag an XML parse error."
+  (setq js2-ts-string-buffer nil
+        js2-ts-string nil)
+  (js2-report-scan-error "msg.XML.bad.form" t))
+
+(defun js2-get-next-xml-token ()
+  (setq js2-ts-string-buffer nil  ; for recording the XML
+        js2-token-beg js2-ts-cursor)
+  (let (c result)
+    (setq result
+          (catch 'return
+            (while t
+              (setq c (js2-get-char))
+              (cond
+               ((= c js2-EOF_CHAR)
+                (throw 'return js2-ERROR))
+               (js2-ts-xml-is-tag-content
+                (case c
+                  (?>
+                   (js2-add-to-string c)
+                   (setq js2-ts-xml-is-tag-content nil
+                         js2-ts-is-xml-attribute nil))
+                  (?/
+                   (js2-add-to-string c)
+                   (when (eq ?> (js2-peek-char))
+                     (setq c (js2-get-char))
+                     (js2-add-to-string c)
+                     (setq js2-ts-xml-is-tag-content nil)
+                     (decf js2-ts-xml-open-tags-count)))
+                  (?{
+                   (js2-unget-char)
+                   (setq js2-ts-string (js2-get-string-from-buffer))
+                   (throw 'return js2-XML))
+                  ((?\' ?\")
+                   (js2-add-to-string c)
+                   (unless (js2-read-quoted-string c)
+                     (throw 'return js2-ERROR)))
+                  (?=
+                   (js2-add-to-string c)
+                   (setq js2-ts-is-xml-attribute t))
+                  ((? ?\t ?\r ?\n)
+                   (js2-add-to-string c))
+                  (t
+                   (js2-add-to-string c)
+                   (setq js2-ts-is-xml-attribute nil)))
+                (when (and (not js2-ts-xml-is-tag-content)
+                           (zerop js2-ts-xml-open-tags-count))
+                  (setq js2-ts-string (js2-get-string-from-buffer))
+                  (throw 'return js2-XMLEND)))
+               (t
+                ;; else not tag content
+                (case c
+                  (?<
+                   (js2-add-to-string c)
+                   (setq c (js2-peek-char))
+                   (case c
+                     (?!
+                      (setq c (js2-get-char)) ;; skip !
+                      (js2-add-to-string c)
+                      (setq c (js2-peek-char))
+                      (case c
+                        (?-
+                         (setq c (js2-get-char)) ;; skip -
+                         (js2-add-to-string c)
+                         (if (eq c ?-)
+                             (progn
+                               (js2-add-to-string c)
+                               (unless (js2-read-xml-comment)
+                                 (throw 'return js2-ERROR)))
+                           (js2-xml-discard-string)
+                           (throw 'return js2-ERROR)))
+                        (?\[
+                         (setq c (js2-get-char)) ;; skip [
+                         (js2-add-to-string c)
+                         (if (and (= (js2-get-char) ?C)
+                                  (= (js2-get-char) ?D)
+                                  (= (js2-get-char) ?A)
+                                  (= (js2-get-char) ?T)
+                                  (= (js2-get-char) ?A)
+                                  (= (js2-get-char) ?\[))
+                             (progn
+                               (js2-add-to-string ?C)
+                               (js2-add-to-string ?D)
+                               (js2-add-to-string ?A)
+                               (js2-add-to-string ?T)
+                               (js2-add-to-string ?A)
+                               (js2-add-to-string ?\[)
+                               (unless (js2-read-cdata)
+                                 (throw 'return js2-ERROR)))
+                           (js2-xml-discard-string)
+                           (throw 'return js2-ERROR)))
+                        (t
+                         (unless (js2-read-entity)
+                           (throw 'return js2-ERROR)))))
+                     (??
+                      (setq c (js2-get-char)) ;; skip ?
+                      (js2-add-to-string c)
+                      (unless (js2-read-PI)
+                        (throw 'return js2-ERROR)))
+                     (?/
+                      ;; end tag
+                      (setq c (js2-get-char)) ;; skip /
+                      (js2-add-to-string c)
+                      (when (zerop js2-ts-xml-open-tags-count)
+                        (js2-xml-discard-string)
+                        (throw 'return js2-ERROR))
+                      (setq js2-ts-xml-is-tag-content t)
+                      (decf js2-ts-xml-open-tags-count))
+                     (t
+                      ;; start tag
+                      (setq js2-ts-xml-is-tag-content t)
+                      (incf js2-ts-xml-open-tags-count))))
+                  (?{
+                   (js2-unget-char)
+                   (setq js2-ts-string (js2-get-string-from-buffer))
+                   (throw 'return js2-XML))
+                  (t
+                   (js2-add-to-string c))))))))
+    (setq js2-token-end js2-ts-cursor)
+    result))
+
+(defun js2-read-quoted-string (quote)
+  (let (c)
+    (catch 'return
+      (while (/= (setq c (js2-get-char)) js2-EOF_CHAR)
+        (js2-add-to-string c)
+        (if (eq c quote)
+            (throw 'return t)))
+      (js2-xml-discard-string)  ;; throw away string in progress
+      nil)))
+
+(defun js2-read-xml-comment ()
+  (let ((c (js2-get-char)))
+    (catch 'return
+      (while (/= c js2-EOF_CHAR)
+        (catch 'continue
+          (js2-add-to-string c)
+          (when (and (eq c ?-) (eq ?- (js2-peek-char)))
+            (setq c (js2-get-char))
+            (js2-add-to-string c)
+            (if (eq (js2-peek-char) ?>)
+                (progn
+                  (setq c (js2-get-char)) ;; skip >
+                  (js2-add-to-string c)
+                  (throw 'return t))
+              (throw 'continue nil)))
+          (setq c (js2-get-char))))
+      (js2-xml-discard-string)
+      nil)))
+
+(defun js2-read-cdata ()
+  (let ((c (js2-get-char)))
+    (catch 'return
+      (while (/= c js2-EOF_CHAR)
+        (catch 'continue
+          (js2-add-to-string c)
+          (when (and (eq c ?\]) (eq (js2-peek-char) ?\]))
+            (setq c (js2-get-char))
+            (js2-add-to-string c)
+            (if (eq (js2-peek-char) ?>)
+                (progn
+                  (setq c (js2-get-char)) ;; Skip >
+                  (js2-add-to-string c)
+                  (throw 'return t))
+              (throw 'continue nil)))
+          (setq c (js2-get-char))))
+      (js2-xml-discard-string)
+      nil)))
+
+(defun js2-read-entity ()
+  (let ((decl-tags 1)
+        c)
+    (catch 'return
+      (while (/= js2-EOF_CHAR (setq c (js2-get-char)))
+        (js2-add-to-string c)
+        (case c
+          (?<
+           (incf decl-tags))
+          (?>
+           (decf decl-tags)
+           (if (zerop decl-tags)
+               (throw 'return t)))))
+      (js2-xml-discard-string)
+      nil)))
+
+(defun js2-read-PI ()
+  "Scan an XML processing instruction."
+  (let (c)
+    (catch 'return
+      (while (/= js2-EOF_CHAR (setq c (js2-get-char)))
+        (js2-add-to-string c)
+        (when (and (eq c ??) (eq (js2-peek-char) ?>))
+          (setq c (js2-get-char))  ;; Skip >
+          (js2-add-to-string c)
+          (throw 'return t)))
+      (js2-xml-discard-string)
+      nil)))
+
+(defun js2-scanner-get-line ()
+  "Return the text of the current scan line."
+  (buffer-substring (point-at-bol) (point-at-eol)))
+
+(provide 'js2-scan)
+
+;;; js2-scan.el ends here
+;;; js2-messages:  localizable messages for js2-mode
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;;; Commentary:
+
+;; Messages are copied from Rhino's Messages.properties.
+;; Many of the Java-specific messages have been elided.
+;; Add any js2-specific ones at the end, so we can keep
+;; this file synced with changes to Rhino's.
+;;
+;; TODO:
+;;  - move interpreter messages into separate file
+
+;;; Code:
+
+(defvar js2-message-table
+  (make-hash-table :test 'equal :size 250)
+  "Contains localized messages for js2-mode.")
+
+;; TODO:  construct this hashtable at compile-time.
+(defmacro js2-msg (key &rest strings)
+  `(puthash ,key (funcall #'concat ,@strings)
+            js2-message-table))
+
+(defun js2-get-msg (msg-key)
+  "Look up a localized message.
+MSG-KEY is a list of (MSG ARGS).  If the message takes parameters,
+the correct number of ARGS must be provided."
+  (let* ((key (if (listp msg-key) (car msg-key) msg-key))
+         (args (if (listp msg-key) (cdr msg-key)))
+         (msg (gethash key js2-message-table)))
+    (if msg
+        (apply #'format msg args)
+      key)))  ; default to showing the key
+
+(js2-msg "msg.dup.parms"
+         "Duplicate parameter name '%s'.")
+
+(js2-msg "msg.too.big.jump"
+         "Program too complex: jump offset too big.")
+
+(js2-msg "msg.too.big.index"
+         "Program too complex: internal index exceeds 64K limit.")
+
+(js2-msg "msg.while.compiling.fn"
+         "Encountered code generation error while compiling function '%s': %s")
+
+(js2-msg "msg.while.compiling.script"
+         "Encountered code generation error while compiling script: %s")
+
+;; Context
+(js2-msg "msg.ctor.not.found"
+         "Constructor for '%s' not found.")
+
+(js2-msg "msg.not.ctor"
+         "'%s' is not a constructor.")
+
+;; FunctionObject
+(js2-msg "msg.varargs.ctor"
+         "Method or constructor '%s' must be static "
+         "with the signature (Context cx, Object[] args, "
+         "Function ctorObj, boolean inNewExpr) "
+         "to define a variable arguments constructor.")
+
+(js2-msg "msg.varargs.fun"
+         "Method '%s' must be static with the signature "
+         "(Context cx, Scriptable thisObj, Object[] args, Function funObj) "
+         "to define a variable arguments function.")
+
+(js2-msg "msg.incompat.call"
+         "Method '%s' called on incompatible object.")
+
+(js2-msg "msg.bad.parms"
+         "Unsupported parameter type '%s' in method '%s'.")
+
+(js2-msg "msg.bad.method.return"
+         "Unsupported return type '%s' in method '%s'.")
+
+(js2-msg "msg.bad.ctor.return"
+         "Construction of objects of type '%s' is not supported.")
+
+(js2-msg "msg.no.overload"
+         "Method '%s' occurs multiple times in class '%s'.")
+
+(js2-msg "msg.method.not.found"
+         "Method '%s' not found in '%s'.")
+
+;; IRFactory
+
+(js2-msg "msg.bad.for.in.lhs"
+         "Invalid left-hand side of for..in loop.")
+
+(js2-msg "msg.mult.index"
+         "Only one variable allowed in for..in loop.")
+
+(js2-msg "msg.bad.for.in.destruct"
+         "Left hand side of for..in loop must be an array of "
+         "length 2 to accept key/value pair.")
+
+(js2-msg "msg.cant.convert"
+         "Can't convert to type '%s'.")
+
+(js2-msg "msg.bad.assign.left"
+         "Invalid assignment left-hand side.")
+
+(js2-msg "msg.bad.decr"
+         "Invalid decerement operand.")
+
+(js2-msg "msg.bad.incr"
+         "Invalid increment operand.")
+
+(js2-msg "msg.bad.yield"
+         "yield must be in a function.")
+
+(js2-msg "msg.yield.parenthesized"
+         "yield expression must be parenthesized.")
+
+;; NativeGlobal
+(js2-msg "msg.cant.call.indirect"
+          "Function '%s' must be called directly, and not by way of a "
+          "function of another name.")
+
+(js2-msg "msg.eval.nonstring"
+          "Calling eval() with anything other than a primitive "
+          "string value will simply return the value. "
+          "Is this what you intended?")
+
+(js2-msg "msg.eval.nonstring.strict"
+         "Calling eval() with anything other than a primitive "
+         "string value is not allowed in strict mode.")
+
+(js2-msg "msg.bad.destruct.op"
+         "Invalid destructuring assignment operator")
+
+;; NativeCall
+(js2-msg "msg.only.from.new"
+         "'%s' may only be invoked from a `new' expression.")
+
+(js2-msg "msg.deprec.ctor"
+         "The '%s' constructor is deprecated.")
+
+;; NativeFunction
+(js2-msg "msg.no.function.ref.found"
+         "no source found to decompile function reference %s")
+
+(js2-msg "msg.arg.isnt.array"
+         "second argument to Function.prototype.apply must be an array")
+
+;; NativeGlobal
+(js2-msg "msg.bad.esc.mask"
+         "invalid string escape mask")
+
+;; NativeRegExp
+(js2-msg "msg.bad.quant"
+  "Invalid quantifier %s")
+
+(js2-msg "msg.overlarge.backref"
+  "Overly large back reference %s")
+
+(js2-msg "msg.overlarge.min"
+  "Overly large minimum %s")
+
+(js2-msg "msg.overlarge.max"
+  "Overly large maximum %s")
+
+(js2-msg "msg.zero.quant"
+  "Zero quantifier %s")
+
+(js2-msg "msg.max.lt.min"
+  "Maximum %s less than minimum")
+
+(js2-msg "msg.unterm.quant"
+  "Unterminated quantifier %s")
+
+(js2-msg "msg.unterm.paren"
+  "Unterminated parenthetical %s")
+
+(js2-msg "msg.unterm.class"
+  "Unterminated character class %s")
+
+(js2-msg "msg.bad.range"
+  "Invalid range in character class.")
+
+(js2-msg "msg.trail.backslash"
+  "Trailing \\ in regular expression.")
+
+(js2-msg "msg.re.unmatched.right.paren"
+  "unmatched ) in regular expression.")
+
+(js2-msg "msg.no.regexp"
+  "Regular expressions are not available.")
+
+(js2-msg "msg.bad.backref"
+  "back-reference exceeds number of capturing parentheses.")
+
+(js2-msg "msg.bad.regexp.compile"
+         "Only one argument may be specified if the first "
+         "argument to RegExp.prototype.compile is a RegExp object.")
+
+;; Parser
+(js2-msg "msg.got.syntax.errors"
+         "Compilation produced %s syntax errors.")
+
+(js2-msg "msg.var.redecl"
+         "TypeError: redeclaration of var %s.")
+
+(js2-msg "msg.const.redecl"
+         "TypeError: redeclaration of const %s.")
+
+(js2-msg "msg.let.redecl"
+         "TypeError: redeclaration of variable %s.")
+
+(js2-msg "msg.parm.redecl"
+         "TypeError: redeclaration of formal parameter %s.")
+
+(js2-msg "msg.fn.redecl"
+         "TypeError: redeclaration of function %s.")
+
+(js2-msg "msg.let.decl.not.in.block"
+         "SyntaxError: let declaration not directly within block")
+
+;; NodeTransformer
+(js2-msg "msg.dup.label"
+         "duplicated label")
+
+(js2-msg "msg.undef.label"
+         "undefined label")
+
+(js2-msg "msg.bad.break"
+         "unlabelled break must be inside loop or switch")
+
+(js2-msg "msg.continue.outside"
+         "continue must be inside loop")
+
+(js2-msg "msg.continue.nonloop"
+         "continue can only use labels of iteration statements")
+
+(js2-msg "msg.bad.throw.eol"
+         "Line terminator is not allowed between the throw "
+         "keyword and throw expression.")
+
+(js2-msg "msg.no.paren.parms"
+         "missing ( before function parameters.")
+
+(js2-msg "msg.no.parm"
+         "missing formal parameter")
+
+(js2-msg "msg.no.paren.after.parms"
+         "missing ) after formal parameters")
+
+(js2-msg "msg.no.brace.body"
+         "missing '{' before function body")
+
+(js2-msg "msg.no.brace.after.body"
+         "missing } after function body")
+
+(js2-msg "msg.no.paren.cond"
+         "missing ( before condition")
+
+(js2-msg "msg.no.paren.after.cond"
+         "missing ) after condition")
+
+(js2-msg "msg.no.semi.stmt"
+         "missing ; before statement")
+
+(js2-msg "msg.missing.semi"
+         "missing ; after statement")
+
+(js2-msg "msg.no.name.after.dot"
+         "missing name after . operator")
+
+(js2-msg "msg.no.name.after.coloncolon"
+         "missing name after :: operator")
+
+(js2-msg "msg.no.name.after.dotdot"
+         "missing name after .. operator")
+
+(js2-msg "msg.no.name.after.xmlAttr"
+         "missing name after .@")
+
+(js2-msg "msg.no.bracket.index"
+         "missing ] in index expression")
+
+(js2-msg "msg.no.paren.switch"
+         "missing ( before switch expression")
+
+(js2-msg "msg.no.paren.after.switch"
+         "missing ) after switch expression")
+
+(js2-msg "msg.no.brace.switch"
+         "missing '{' before switch body")
+
+(js2-msg "msg.bad.switch"
+         "invalid switch statement")
+
+(js2-msg "msg.no.colon.case"
+         "missing : after case expression")
+
+(js2-msg "msg.double.switch.default"
+         "double default label in the switch statement")
+
+(js2-msg "msg.no.while.do"
+         "missing while after do-loop body")
+
+(js2-msg "msg.no.paren.for"
+         "missing ( after for")
+
+(js2-msg "msg.no.semi.for"
+         "missing ; after for-loop initializer")
+
+(js2-msg "msg.no.semi.for.cond"
+         "missing ; after for-loop condition")
+
+(js2-msg "msg.in.after.for.name"
+         "missing in after for")
+
+(js2-msg "msg.no.paren.for.ctrl"
+         "missing ) after for-loop control")
+
+(js2-msg "msg.no.paren.with"
+         "missing ( before with-statement object")
+
+(js2-msg "msg.no.paren.after.with"
+         "missing ) after with-statement object")
+
+(js2-msg "msg.no.paren.after.let"
+         "missing ( after let")
+
+(js2-msg "msg.no.paren.let"
+         "missing ) after variable list")
+
+(js2-msg "msg.no.curly.let"
+         "missing } after let statement")
+
+(js2-msg "msg.bad.return"
+         "invalid return")
+
+(js2-msg "msg.no.brace.block"
+         "missing } in compound statement")
+
+(js2-msg "msg.bad.label"
+         "invalid label")
+
+(js2-msg "msg.bad.var"
+         "missing variable name")
+
+(js2-msg "msg.bad.var.init"
+         "invalid variable initialization")
+
+(js2-msg "msg.no.colon.cond"
+         "missing : in conditional expression")
+
+(js2-msg "msg.no.paren.arg"
+         "missing ) after argument list")
+
+(js2-msg "msg.no.bracket.arg"
+         "missing ] after element list")
+
+(js2-msg "msg.bad.prop"
+         "invalid property id")
+
+(js2-msg "msg.no.colon.prop"
+         "missing : after property id")
+
+(js2-msg "msg.no.brace.prop"
+         "missing } after property list")
+
+(js2-msg "msg.no.paren"
+         "missing ) in parenthetical")
+
+(js2-msg "msg.reserved.id"
+         "identifier is a reserved word")
+
+(js2-msg "msg.no.paren.catch"
+         "missing ( before catch-block condition")
+
+(js2-msg "msg.bad.catchcond"
+         "invalid catch block condition")
+
+(js2-msg "msg.catch.unreachable"
+         "any catch clauses following an unqualified catch are unreachable")
+
+(js2-msg "msg.no.brace.try"
+         "missing '{' before try block")
+
+(js2-msg "msg.no.brace.catchblock"
+         "missing '{' before catch-block body")
+
+(js2-msg "msg.try.no.catchfinally"
+         "'try' without 'catch' or 'finally'")
+
+(js2-msg "msg.no.return.value"
+         "function %s does not always return a value")
+
+(js2-msg "msg.anon.no.return.value"
+         "anonymous function does not always return a value")
+
+(js2-msg "msg.return.inconsistent"
+         "return statement is inconsistent with previous usage")
+
+(js2-msg "msg.generator.returns"
+         "TypeError: generator function '%s' returns a value")
+
+(js2-msg "msg.anon.generator.returns"
+         "TypeError: anonymous generator function returns a value")
+
+(js2-msg "msg.syntax"
+         "syntax error")
+
+(js2-msg "msg.unexpected.eof"
+         "Unexpected end of file")
+
+(js2-msg "msg.XML.bad.form"
+         "illegally formed XML syntax")
+
+(js2-msg "msg.XML.not.available"
+         "XML runtime not available")
+
+(js2-msg "msg.too.deep.parser.recursion"
+         "Too deep recursion while parsing")
+
+(js2-msg "msg.no.side.effects"
+         "Code has no side effects")
+
+(js2-msg "msg.extra.trailing.comma"
+         "Trailing comma is not legal in an ECMA-262 object initializer")
+
+(js2-msg "msg.array.trailing.comma"
+         "Trailing comma yields different behavior across browsers")
+
+(js2-msg "msg.equal.as.assign"
+         (concat "Test for equality (==) mistyped as assignment (=)?"
+                 " (parenthesize to suppress warning)"))
+
+(js2-msg "msg.var.hides.arg"
+         "Variable %s hides argument")
+
+(js2-msg "msg.destruct.assign.no.init"
+         "Missing = in destructuring declaration")
+
+;; ScriptRuntime
+(js2-msg "msg.no.properties"
+         "%s has no properties.")
+
+(js2-msg "msg.invalid.iterator"
+         "Invalid iterator value")
+
+(js2-msg "msg.iterator.primitive"
+         "__iterator__ returned a primitive value")
+
+(js2-msg "msg.assn.create.strict"
+         "Assignment to undeclared variable %s")
+
+(js2-msg "msg.ref.undefined.prop"
+         "Reference to undefined property '%s'")
+
+(js2-msg "msg.prop.not.found"
+         "Property %s not found.")
+
+(js2-msg "msg.invalid.type"
+         "Invalid JavaScript value of type %s")
+
+(js2-msg "msg.primitive.expected"
+         "Primitive type expected (had %s instead)")
+
+(js2-msg "msg.namespace.expected"
+         "Namespace object expected to left of :: (found %s instead)")
+
+(js2-msg "msg.null.to.object"
+         "Cannot convert null to an object.")
+
+(js2-msg "msg.undef.to.object"
+         "Cannot convert undefined to an object.")
+
+(js2-msg "msg.cyclic.value"
+         "Cyclic %s value not allowed.")
+
+(js2-msg "msg.is.not.defined"
+         "'%s' is not defined.")
+
+(js2-msg "msg.undef.prop.read"
+         "Cannot read property '%s' from %s")
+
+(js2-msg "msg.undef.prop.write"
+         "Cannot set property '%s' of %s to '%s'")
+
+(js2-msg "msg.undef.prop.delete"
+         "Cannot delete property '%s' of %s")
+
+(js2-msg "msg.undef.method.call"
+         "Cannot call method '%s' of %s")
+
+(js2-msg "msg.undef.with"
+         "Cannot apply 'with' to %s")
+
+(js2-msg "msg.isnt.function"
+         "%s is not a function, it is %s.")
+
+(js2-msg "msg.isnt.function.in"
+         "Cannot call property %s in object %s. "
+         "It is not a function, it is '%s'.")
+
+(js2-msg "msg.function.not.found"
+         "Cannot find function %s.")
+
+(js2-msg "msg.function.not.found.in"
+         "Cannot find function %s in object %s.")
+
+(js2-msg "msg.isnt.xml.object"
+         "%s is not an xml object.")
+
+(js2-msg "msg.no.ref.to.get"
+         "%s is not a reference to read reference value.")
+
+(js2-msg "msg.no.ref.to.set"
+         "%s is not a reference to set reference value to %s.")
+
+(js2-msg "msg.no.ref.from.function"
+         "Function %s can not be used as the left-hand "
+         "side of assignment or as an operand of ++ or -- operator.")
+
+(js2-msg "msg.bad.default.value"
+         "Object's getDefaultValue() method returned an object.")
+
+(js2-msg "msg.instanceof.not.object"
+         "Can't use instanceof on a non-object.")
+
+(js2-msg "msg.instanceof.bad.prototype"
+         "'prototype' property of %s is not an object.")
+
+(js2-msg "msg.bad.radix"
+         "illegal radix %s.")
+
+;; ScriptableObject
+(js2-msg "msg.default.value"
+         "Cannot find default value for object.")
+
+(js2-msg "msg.zero.arg.ctor"
+         "Cannot load class '%s' which has no zero-parameter constructor.")
+
+(js2-msg "msg.ctor.multiple.parms"
+         "Can't define constructor or class %s since more than "
+         "one constructor has multiple parameters.")
+
+(js2-msg "msg.extend.scriptable"
+         "%s must extend ScriptableObject in order to define property %s.")
+
+(js2-msg "msg.bad.getter.parms"
+         "In order to define a property, getter %s must have zero "
+         "parameters or a single ScriptableObject parameter.")
+
+(js2-msg "msg.obj.getter.parms"
+         "Expected static or delegated getter %s to take "
+         "a ScriptableObject parameter.")
+
+(js2-msg "msg.getter.static"
+         "Getter and setter must both be static or neither be static.")
+
+(js2-msg "msg.setter.return"
+         "Setter must have void return type: %s")
+
+(js2-msg "msg.setter2.parms"
+         "Two-parameter setter must take a ScriptableObject as "
+         "its first parameter.")
+
+(js2-msg "msg.setter1.parms"
+         "Expected single parameter setter for %s")
+
+(js2-msg "msg.setter2.expected"
+         "Expected static or delegated setter %s to take two parameters.")
+
+(js2-msg "msg.setter.parms"
+         "Expected either one or two parameters for setter.")
+
+(js2-msg "msg.setter.bad.type"
+         "Unsupported parameter type '%s' in setter '%s'.")
+
+(js2-msg "msg.add.sealed"
+         "Cannot add a property to a sealed object: %s.")
+
+(js2-msg "msg.remove.sealed"
+         "Cannot remove a property from a sealed object: %s.")
+
+(js2-msg "msg.modify.sealed"
+         "Cannot modify a property of a sealed object: %s.")
+
+(js2-msg "msg.modify.readonly"
+         "Cannot modify readonly property: %s.")
+
+;; TokenStream
+(js2-msg "msg.missing.exponent"
+         "missing exponent")
+
+(js2-msg "msg.caught.nfe"
+         "number format error")
+
+(js2-msg "msg.unterminated.string.lit"
+         "unterminated string literal")
+
+(js2-msg "msg.unterminated.comment"
+         "unterminated comment")
+
+(js2-msg "msg.unterminated.re.lit"
+         "unterminated regular expression literal")
+
+(js2-msg "msg.invalid.re.flag"
+         "invalid flag after regular expression")
+
+(js2-msg "msg.no.re.input.for"
+         "no input for %s")
+
+(js2-msg "msg.illegal.character"
+         "illegal character")
+
+(js2-msg "msg.invalid.escape"
+         "invalid Unicode escape sequence")
+
+(js2-msg "msg.bad.namespace"
+         "not a valid default namespace statement. "
+         "Syntax is: default xml namespace = EXPRESSION;")
+
+;; TokensStream warnings
+(js2-msg "msg.bad.octal.literal"
+         "illegal octal literal digit %s; "
+         "interpreting it as a decimal digit")
+
+(js2-msg "msg.reserved.keyword"
+         "illegal usage of future reserved keyword %s; "
+         "interpreting it as ordinary identifier")
+
+(js2-msg "msg.script.is.not.constructor"
+         "Script objects are not constructors.")
+
+;; Arrays
+(js2-msg "msg.arraylength.bad"
+         "Inappropriate array length.")
+
+;; Arrays
+(js2-msg "msg.arraylength.too.big"
+         "Array length %s exceeds supported capacity limit.")
+
+;; URI
+(js2-msg "msg.bad.uri"
+         "Malformed URI sequence.")
+
+;; Number
+(js2-msg "msg.bad.precision"
+         "Precision %s out of range.")
+
+;; NativeGenerator
+(js2-msg "msg.send.newborn"
+         "Attempt to send value to newborn generator")
+
+(js2-msg "msg.already.exec.gen"
+         "Already executing generator")
+
+(js2-msg "msg.StopIteration.invalid"
+         "StopIteration may not be changed to an arbitrary object.")
+
+;; Interpreter
+(js2-msg "msg.yield.closing"
+         "Yield from closing generator")
+
+(provide 'js2-messages)
+;;; js2-ast.el --- JavaScript syntax tree node definitions
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;;; Code:
+
+(eval-and-compile
+  (require 'cl))
+
+
+;; flags for ast node property 'member-type (used for e4x operators)
+(defvar js2-property-flag    #x1 "property access: element is valid name")
+(defvar js2-attribute-flag   #x2 "x.@y or x..@y")
+(defvar js2-descendants-flag #x4 "x..y or x..@i")
+
+(defsubst js2-relpos (pos anchor)
+  "Convert POS to be relative to ANCHOR.
+If POS is nil, returns nil."
+  (and pos (- pos anchor)))
+
+(defsubst js2-make-pad (indent)
+  (if (zerop indent)
+      ""
+    (make-string (* indent js2-basic-offset) ? )))
+
+(defsubst js2-visit-ast (node callback)
+  "Visit every node in ast NODE with visitor CALLBACK.
+
+CALLBACK is a function that takes two arguments:  (NODE END-P).  It is
+called twice:  once to visit the node, and again after all the node's
+children have been processed.  The END-P argument is nil on the first
+call and non-nil on the second call.  The return value of the callback
+affects the traversal:  if non-nil, the children of NODE are processed.
+If the callback returns nil, or if the node has no children, then the
+callback is called immediately with a non-nil END-P argument.
+
+The node traversal is approximately lexical-order, although there
+are currently no guarantees around this."
+  (let ((vfunc (get (aref node 0) 'js2-visitor)))
+    ;; visit the node
+    (when  (funcall callback node nil)
+      ;; visit the kids
+      (cond
+       ((eq vfunc 'js2-visit-none)
+        nil)                            ; don't even bother calling it
+       ;; Each AST node type has to define a `js2-visitor' function
+       ;; that takes a node and a callback, and calls `js2-visit-ast'
+       ;; on each child of the node.
+       (vfunc
+        (funcall vfunc node callback))
+       (t
+        (error "%s does not define a visitor-traversal function"
+               (aref node 0)))))
+    ;; call the end-visit
+    (funcall callback node t)))
+
+(defstruct (js2-node
+            (:constructor nil))  ; abstract
+  "Base AST node type."
+  (type -1)  ; token type
+  (pos -1)   ; start position of this AST node in parsed input
+  (len 1)    ; num characters spanned by the node
+  props      ; optional node property list (an alist)
+  parent)    ; link to parent node; null for root
+
+(defsubst js2-node-get-prop (node prop &optional default)
+  (or (cadr (assoc prop (js2-node-props node))) default))
+
+(defsubst js2-node-set-prop (node prop value)
+  (setf (js2-node-props node)
+        (cons (list prop value) (js2-node-props node))))
+
+(defsubst js2-fixup-starts (n nodes)
+  "Adjust the start positions of NODES to be relative to N.
+Any node in the list may be nil, for convenience."
+  (dolist (node nodes)
+    (when node
+      (setf (js2-node-pos node) (- (js2-node-pos node)
+                                   (js2-node-pos n))))))
+
+(defsubst js2-node-add-children (parent &rest nodes)
+  "Set parent node of NODES to PARENT, and return PARENT.
+Does nothing if we're not recording parent links.
+If any given node in NODES is nil, doesn't record that link."
+  (js2-fixup-starts parent nodes)
+  (dolist (node nodes)
+    (and node
+         (setf (js2-node-parent node) parent))))
+
+;; Non-recursive since it's called a frightening number of times.
+(defsubst js2-node-abs-pos (n)
+  (let ((pos (js2-node-pos n)))
+    (while (setq n (js2-node-parent n))
+      (setq pos (+ pos (js2-node-pos n))))
+    pos))
+
+(defsubst js2-node-abs-end (n)
+  "Return absolute buffer position of end of N."
+  (+ (js2-node-abs-pos n) (js2-node-len n)))
+
+;; It's important to make sure block nodes have a lisp list for the
+;; child nodes, to limit printing recursion depth in an AST that
+;; otherwise consists of defstruct vectors.  Emacs will crash printing
+;; a sufficiently large vector tree.
+
+(defstruct (js2-block-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-block-node (&key (type js2-BLOCK)
+                                                    (pos js2-token-beg)
+                                                    len
+                                                    props
+                                                    kids)))
+  "A block of statements."
+  kids)  ; a lisp list of the child statement nodes
+
+(put 'cl-struct-js2-block-node 'js2-visitor 'js2-visit-block)
+(put 'cl-struct-js2-block-node 'js2-printer 'js2-print-block)
+
+(defsubst js2-visit-block (ast callback)
+  "Visit the `js2-block-node' children of AST."
+  (dolist (kid (js2-block-node-kids ast))
+    (js2-visit-ast kid callback)))
+
+(defun js2-print-block (n i)
+  (let ((pad (js2-make-pad i)))
+    (insert pad "{\n")
+    (dolist (kid (js2-block-node-kids n))
+      (js2-print-ast kid (1+ i)))
+    (insert pad "}")))
+
+(defstruct (js2-scope
+            (:include js2-block-node)
+            (:constructor nil)
+            (:constructor make-js2-scope (&key (type js2-BLOCK)
+                                               (pos js2-token-beg)
+                                               len
+                                               kids)))
+  ;; The symbol-table is a LinkedHashMap<String,Symbol> in Rhino.
+  ;; I don't have one of those handy, so I'll use an alist for now.
+  ;; It's as fast as an emacs hashtable for up to about 50 elements,
+  ;; and is much lighter-weight to construct (both CPU and mem).
+  ;; The keys are interned strings (symbols) for faster lookup.
+  ;; Should switch to hybrid alist/hashtable eventually.
+  symbol-table  ; an alist of (symbol . js2-symbol)
+  parent-scope  ; a `js2-scope'
+  top)          ; top-level `js2-scope' (script/function)
+
+(put 'cl-struct-js2-scope 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-scope 'js2-printer 'js2-print-none)
+
+(defun js2-scope-set-parent-scope (scope parent)
+  (setf (js2-scope-parent-scope scope) parent
+        (js2-scope-top scope) (if (null parent)
+                                  scope
+                                (js2-scope-top parent))))
+
+(defun js2-node-get-enclosing-scope (node)
+  "Return the innermost `js2-scope' node surrounding NODE.
+Returns nil if there is no enclosing scope node."
+  (let ((parent (js2-node-parent node)))
+    (while (not (js2-scope-p parent))
+      (setq parent (js2-node-parent parent)))
+    parent))
+
+(defun js2-get-defining-scope (scope name)
+  "Search up scope chain from SCOPE looking for NAME, a string or symbol.
+Returns `js2-scope' in which NAME is defined, or nil if not found."
+  (let ((sym (if (symbolp name)
+                 name
+               (intern name)))
+        table
+        result
+        (continue t))
+    (while (and scope continue)
+      (if (and (setq table (js2-scope-symbol-table scope))
+               (assq sym table))
+          (setq continue nil
+                result scope)
+        (setq scope (js2-scope-parent-scope scope))))
+    result))
+
+(defsubst js2-scope-get-symbol (scope name)
+  "Return symbol table entry for NAME in SCOPE.
+NAME can be a string or symbol.   Returns a `js2-symbol' or nil if not found."
+  (and (js2-scope-symbol-table scope)
+       (cdr (assq (if (symbolp name)
+                      name
+                    (intern name))
+                  (js2-scope-symbol-table scope)))))
+
+(defsubst js2-scope-put-symbol (scope name symbol)
+  "Enter SYMBOL into symbol-table for SCOPE under NAME.
+NAME can be a lisp symbol or string.  SYMBOL is a `js2-symbol'."
+  (let* ((table (js2-scope-symbol-table scope))
+         (sym (if (symbolp name) name (intern name)))
+         (entry (assq sym table)))
+    (if entry
+        (setcdr entry symbol)
+      (push (cons sym symbol)
+            (js2-scope-symbol-table scope)))))
+
+(defstruct (js2-symbol
+            (:constructor nil)
+            (:constructor make-js2-symbol (decl-type name &optional ast-node)))
+  "A symbol table entry."
+  ;; One of js2-FUNCTION, js2-LP (for parameters), js2-VAR,
+  ;; js2-LET, or js2-CONST
+  decl-type
+  name  ; string
+  ast-node) ; a `js2-node'
+
+(defstruct (js2-error-node
+            (:include js2-node)
+            (:constructor nil) ; silence emacs21 byte-compiler
+            (:constructor make-js2-error-node (&key (type js2-ERROR)
+                                                    (pos js2-token-beg)
+                                                    len)))
+  "AST node representing a parse error.")
+
+(put 'cl-struct-js2-error-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-error-node 'js2-printer 'js2-print-none)
+
+(defstruct (js2-script-node
+            (:include js2-scope)
+            (:constructor nil)
+            (:constructor make-js2-script-node (&key (type js2-SCRIPT)
+                                                     (pos js2-token-beg)
+                                                     len
+                                                     var-decls
+                                                     fun-decls)))
+  functions   ; lisp list of nested functions
+  regexps     ; lisp list of (string . flags)
+  symbols     ; alist (every symbol gets unique index)
+  (param-count 0)
+  var-names   ; vector of string names
+  consts      ; bool-vector matching var-decls
+  (temp-number 0))  ; for generating temp variables
+
+(put 'cl-struct-js2-script-node 'js2-visitor 'js2-visit-block)
+(put 'cl-struct-js2-script-node 'js2-printer 'js2-print-script)
+
+(defun js2-print-script (node indent)
+  (dolist (kid (js2-block-node-kids node))
+    (js2-print-ast kid indent)))
+
+(defstruct (js2-ast-root
+            (:include js2-script-node)
+            (:constructor nil)
+            (:constructor make-js2-ast-root (&key (type js2-SCRIPT)
+                                                  (pos js2-token-beg)
+                                                  len
+                                                  buffer)))
+  "The root node of a js2 AST."
+  buffer         ; the source buffer from which the code was parsed
+  comments       ; a lisp list of comments, ordered by start position
+  errors         ; a lisp list of errors found during parsing
+  warnings       ; a lisp list of warnings found during parsing
+  node-count)    ; number of nodes in the tree, including the root
+
+(put 'cl-struct-js2-ast-root 'js2-visitor 'js2-visit-ast-root)
+(put 'cl-struct-js2-ast-root 'js2-printer 'js2-print-script)
+
+(defun js2-visit-ast-root (ast callback)
+  (dolist (kid (js2-ast-root-kids ast))
+    (js2-visit-ast kid callback))
+  (dolist (comment (js2-ast-root-comments ast))
+    (js2-visit-ast comment callback)))
+
+(defstruct (js2-comment-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-comment-node (&key (type js2-COMMENT)
+                                                      (pos js2-token-beg)
+                                                      len
+                                                      (format js2-ts-comment-type))))
+  format)  ; 'line, 'block, 'jsdoc or 'html
+
+(put 'cl-struct-js2-comment-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-comment-node 'js2-printer 'js2-print-comment)
+
+(defun js2-print-comment (n i)
+  ;; We really ought to link end-of-line comments to their nodes.
+  ;; Or maybe we could add a new comment type, 'endline.
+  (insert (js2-make-pad i)
+          (js2-node-string n)))
+
+(defstruct (js2-expr-stmt-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-expr-stmt-node (&key (type js2-EXPR_VOID)
+                                                        (pos js2-ts-cursor)
+                                                        len
+                                                        expr)))
+  "An expression statement."
+  expr)
+
+(defsubst js2-expr-stmt-node-set-has-result (node)
+  "Change the node type to `js2-EXPR_RESULT'.  Used for code generation."
+  (setf (js2-node-type node) js2-EXPR_RESULT))
+
+(put 'cl-struct-js2-expr-stmt-node 'js2-visitor 'js2-visit-expr-stmt-node)
+(put 'cl-struct-js2-expr-stmt-node 'js2-printer 'js2-print-expr-stmt-node)
+
+(defun js2-visit-expr-stmt-node (n v)
+  (js2-visit-ast (js2-expr-stmt-node-expr n) v))
+
+(defun js2-print-expr-stmt-node (n indent)
+  (js2-print-ast (js2-expr-stmt-node-expr n) indent)
+  (insert ";\n"))
+
+(defstruct (js2-loop-node
+            (:include js2-scope)
+            (:constructor nil))
+  "Abstract supertype of loop nodes."
+  body      ; a `js2-block-node'
+  lp        ; position of left-paren, nil if omitted
+  rp)       ; position of right-paren, nil if omitted
+
+(defstruct (js2-do-node
+            (:include js2-loop-node)
+            (:constructor nil)
+            (:constructor make-js2-do-node (&key (type js2-DO)
+                                                 (pos js2-token-beg)
+                                                 len
+                                                 body
+                                                 condition
+                                                 while-pos
+                                                 lp
+                                                 rp)))
+  "AST node for do-loop."
+  condition  ; while (expression)
+  while-pos) ; buffer position of 'while' keyword
+
+(put 'cl-struct-js2-do-node 'js2-visitor 'js2-visit-do-node)
+(put 'cl-struct-js2-do-node 'js2-printer 'js2-print-do-node)
+
+(defun js2-visit-do-node (n v)
+  (js2-visit-ast (js2-do-node-body n) v)
+  (js2-visit-ast (js2-do-node-condition n) v))
+
+(defun js2-print-do-node (n i)
+  (let ((pad (js2-make-pad i)))
+    (insert pad "do {\n")
+    (dolist (kid (js2-block-node-kids (js2-do-node-body n)))
+      (js2-print-ast kid (1+ i)))
+    (insert pad "} while (")
+    (js2-print-ast (js2-do-node-condition n) 0)
+    (insert ");\n")))
+
+(defstruct (js2-while-node
+            (:include js2-loop-node)
+            (:constructor nil)
+            (:constructor make-js2-while-node (&key (type js2-WHILE)
+                                                    (pos js2-token-beg)
+                                                    len
+                                                    body
+                                                    condition
+                                                    lp
+                                                    rp)))
+  "AST node for while-loop."
+  condition)    ; while-condition
+
+(put 'cl-struct-js2-while-node 'js2-visitor 'js2-visit-while-node)
+(put 'cl-struct-js2-while-node 'js2-printer 'js2-print-while-node)
+
+(defun js2-visit-while-node (n v)
+  (js2-visit-ast (js2-while-node-condition n) v)
+  (js2-visit-ast (js2-while-node-body n) v))
+
+(defun js2-print-while-node (n i)
+  (let ((pad (js2-make-pad i)))
+    (insert pad "while (")
+    (js2-print-ast (js2-while-node-condition n) 0)
+    (insert ") {\n")
+    (js2-print-body (js2-while-node-body n) (1+ i))
+    (insert pad "}\n")))
+
+(defstruct (js2-for-node
+            (:include js2-loop-node)
+            (:constructor nil)
+            (:constructor make-js2-for-node (&key (type js2-FOR)
+                                                  (pos js2-ts-cursor)
+                                                  len
+                                                  body
+                                                  init
+                                                  condition
+                                                  update
+                                                  lp
+                                                  rp)))
+  "AST node for a C-style for-loop."
+  init       ; initialization expression
+  condition  ; loop condition
+  update)    ; update clause
+
+(put 'cl-struct-js2-for-node 'js2-visitor 'js2-visit-for-node)
+(put 'cl-struct-js2-for-node 'js2-printer 'js2-print-for-node)
+
+(defun js2-visit-for-node (n v)
+  (js2-visit-ast (js2-for-node-init n) v)
+  (js2-visit-ast (js2-for-node-condition n) v)
+  (js2-visit-ast (js2-for-node-update n) v)
+  (js2-visit-ast (js2-for-node-body n) v))
+
+(defun js2-print-for-node (n i)
+  (let ((pad (js2-make-pad i)))
+    (insert pad "for (")
+    (js2-print-ast (js2-for-node-init n) 0)
+    (insert "; ")
+    (js2-print-ast (js2-for-node-condition n) 0)
+    (insert "; ")
+    (js2-print-ast (js2-for-node-update n) 0)
+    (insert ") {\n")
+    (js2-print-body (js2-for-node-body n) (1+ i))
+    (insert pad "}\n")))
+
+(defstruct (js2-for-in-node
+            (:include js2-loop-node)
+            (:constructor nil)
+            (:constructor make-js2-for-in-node (&key (type js2-FOR)
+                                                     (pos js2-ts-cursor)
+                                                     len
+                                                     body
+                                                     iterator
+                                                     object
+                                                     in-pos
+                                                     each-pos
+                                                     foreach-p
+                                                     lp
+                                                     rp)))
+  "AST node for a for..in loop."
+  iterator  ; [var] foo in ...
+  object    ; object over which we're iterating
+  in-pos    ; buffer position of 'in' keyword
+  each-pos  ; buffer position of 'each' keyword, if foreach-p
+  foreach-p) ; t if it's a for-each loop
+
+(put 'cl-struct-js2-for-in-node 'js2-visitor 'js2-visit-for-in-node)
+(put 'cl-struct-js2-for-in-node 'js2-printer 'js2-print-for-in-node)
+
+(defun js2-visit-for-in-node (n v)
+  (js2-visit-ast (js2-for-in-node-iterator n) v)
+  (js2-visit-ast (js2-for-in-node-object n) v)
+  (js2-visit-ast (js2-for-in-node-body n) v))
+
+(defun js2-print-for-in-node (n i)
+  (let ((pad (js2-make-pad i))
+        (foreach (js2-for-in-node-foreach-p n)))
+    (insert pad "for ")
+    (if foreach
+        (insert "each "))
+    (insert "(")
+    (js2-print-ast (js2-for-in-node-iterator n) 0)
+    (insert " in ")
+    (js2-print-ast (js2-for-in-node-object n) 0)
+    (insert ") {\n")
+    (js2-print-body (js2-for-in-node-body n) (1+ i))
+    (insert pad "}\n")))
+
+(defstruct (js2-return-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-return-node (&key (type js2-RETURN)
+                                                     (pos js2-ts-cursor)
+                                                     len
+                                                     retval)))
+  "AST node for a return statement."
+  retval)  ; expression to return, or 'undefined
+
+(put 'cl-struct-js2-return-node 'js2-visitor 'js2-visit-return-node)
+(put 'cl-struct-js2-return-node 'js2-printer 'js2-print-return-node)
+
+(defun js2-visit-return-node (n v)
+  (if (js2-return-node-retval n)
+      (js2-visit-ast (js2-return-node-retval n) v)))
+
+(defun js2-print-return-node (n i)
+  (insert (js2-make-pad i) "return")
+  (when (js2-return-node-retval n)
+    (insert " ")
+    (js2-print-ast (js2-return-node-retval n) 0))
+  (insert ";\n"))
+
+(defstruct (js2-if-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-if-node (&key (type js2-IF)
+                                                 (pos js2-ts-cursor)
+                                                 len
+                                                 condition
+                                                 then-part
+                                                 else-pos
+                                                 else-part
+                                                 lp
+                                                 rp)))
+  "AST node for an if-statement."
+  condition   ; expression
+  then-part   ; statement or block
+  else-pos    ; optional buffer position of 'else' keyword
+  else-part   ; optional statement or block
+  lp          ; position of left-paren, nil if omitted
+  rp)         ; position of right-paren, nil if omitted
+
+(put 'cl-struct-js2-if-node 'js2-visitor 'js2-visit-if-node)
+(put 'cl-struct-js2-if-node 'js2-printer 'js2-print-if-node)
+
+(defun js2-visit-if-node (n v)
+  (js2-visit-ast (js2-if-node-condition n) v)
+  (js2-visit-ast (js2-if-node-then-part n) v)
+  (if (js2-if-node-else-part n)
+      (js2-visit-ast (js2-if-node-else-part n) v)))
+
+(defun js2-print-if-node (n i)
+  (let ((pad (js2-make-pad i))
+        (then-part (js2-if-node-then-part n))
+        (else-part (js2-if-node-else-part n)))
+    (insert pad "if (")
+    (js2-print-ast (js2-if-node-condition n) 0)
+    (insert ") {\n")
+    (js2-print-body then-part (1+ i))
+    (insert pad "}")
+    (cond
+     ((not else-part)
+      (insert "\n"))
+     ((js2-if-node-p else-part)
+      (insert " else ")
+      (js2-print-body else-part i))
+     (t
+      (insert " else {\n")
+      (js2-print-body else-part (1+ i))
+      (insert pad "}\n")))))
+
+(defstruct (js2-try-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-try-node (&key (type js2-TRY)
+                                                  (pos js2-ts-cursor)
+                                                  len
+                                                  try-block
+                                                  catch-clauses
+                                                  finally-block)))
+  "AST node for a try-statement."
+  try-block
+  catch-clauses  ; a lisp list of `js2-catch-node'
+  finally-block) ; a `js2-finally-node'
+
+(put 'cl-struct-js2-try-node 'js2-visitor 'js2-visit-try-node)
+(put 'cl-struct-js2-try-node 'js2-printer 'js2-print-try-node)
+
+(defun js2-visit-try-node (n v)
+  (js2-visit-ast (js2-try-node-try-block n) v)
+  (dolist (clause (js2-try-node-catch-clauses n))
+    (js2-visit-ast clause v))
+  (if (js2-try-node-finally-block n)
+      (js2-visit-ast (js2-try-node-finally-block n) v)))
+
+(defun js2-print-try-node (n i)
+  (let ((pad (js2-make-pad i))
+        (catches (js2-try-node-catch-clauses n))
+        (finally (js2-try-node-finally-block n)))
+    (insert pad "try {\n")
+    (js2-print-body (js2-try-node-try-block n) (1+ i))
+    (insert pad "}")
+    (when catches
+      (dolist (catch catches)
+        (js2-print-ast catch i)))
+    (if finally
+        (js2-print-ast finally i)
+      (insert "\n"))))
+
+(defstruct (js2-catch-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-catch-node (&key (type js2-CATCH)
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    var-name
+                                                    guard-kwd
+                                                    guard-expr
+                                                    block
+                                                    lp
+                                                    rp)))
+  "AST node for a catch clause."
+  var-name    ; a `js2-name-node'
+  guard-kwd   ; relative buffer position of "if" in "catch (x if ...)"
+  guard-expr  ; catch condition, a `js2-node'
+  block       ; statements, a `js2-block-node'
+  lp          ; buffer position of left-paren, nil if omitted
+  rp)         ; buffer position of right-paren, nil if omitted
+
+(put 'cl-struct-js2-catch-node 'js2-visitor 'js2-visit-catch-node)
+(put 'cl-struct-js2-catch-node 'js2-printer 'js2-print-catch-node)
+
+(defun js2-visit-catch-node (n v)
+  (js2-visit-ast (js2-catch-node-var-name n) v)
+  (when (js2-catch-node-guard-kwd n)
+    (js2-visit-ast (js2-catch-node-guard-expr n) v))
+  (js2-visit-ast (js2-catch-node-block n) v))
+
+(defun js2-print-catch-node (n i)
+  (let ((pad (js2-make-pad i))
+        (guard-kwd (js2-catch-node-guard-kwd n))
+        (guard-expr (js2-catch-node-guard-expr n)))
+    (insert " catch (")
+    (js2-print-ast (js2-catch-node-var-name n) 0)
+    (when guard-kwd
+      (insert " if ")
+      (js2-print-ast guard-expr 0))
+    (insert ") {\n")
+    (js2-print-body (js2-catch-node-block n) (1+ i))
+    (insert pad "}")))
+
+(defstruct (js2-finally-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-finally-node (&key (type js2-FINALLY)
+                                                      (pos js2-ts-cursor)
+                                                      len
+                                                      body)))
+  "AST node for a finally clause."
+  body)  ; a `js2-node', often but not always a block node
+
+(put 'cl-struct-js2-finally-node 'js2-visitor 'js2-visit-finally-node)
+(put 'cl-struct-js2-finally-node 'js2-printer 'js2-print-finally-node)
+
+(defun js2-visit-finally-node (n v)
+  (js2-visit-ast (js2-finally-node-body n) v))
+
+(defun js2-print-finally-node (n i)
+  (let ((pad (js2-make-pad i)))
+    (insert " finally {\n")
+    (js2-print-body (js2-finally-node-body n) (1+ i))
+    (insert pad "}\n")))
+
+(defstruct (js2-switch-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-switch-node (&key (type js2-SWITCH)
+                                                     (pos js2-ts-cursor)
+                                                     len
+                                                     discriminant
+                                                     cases
+                                                     lp
+                                                     rp)))
+  "AST node for a switch statement."
+  discriminant  ; a `js2-node' (switch expression)
+  cases  ; a lisp list of `js2-case-node'
+  lp     ; position of open-paren for discriminant, nil if omitted
+  rp)    ; position of close-paren for discriminant, nil if omitted
+
+(put 'cl-struct-js2-switch-node 'js2-visitor 'js2-visit-switch-node)
+(put 'cl-struct-js2-switch-node 'js2-printer 'js2-print-switch-node)
+
+(defun js2-visit-switch-node (n v)
+  (js2-visit-ast (js2-switch-node-discriminant n) v)
+  (dolist (c (js2-switch-node-cases n))
+    (js2-visit-ast c v)))
+
+(defun js2-print-switch-node (n i)
+  (let ((pad (js2-make-pad i))
+        (cases (js2-switch-node-cases n)))
+    (insert pad "switch (")
+    (js2-print-ast (js2-switch-node-discriminant n) 0)
+    (insert ") {\n")
+    (dolist (case cases)
+      (js2-print-ast case i))
+    (insert pad "}\n")))
+
+(defstruct (js2-case-node
+            (:include js2-block-node)
+            (:constructor nil)
+            (:constructor make-js2-case-node (&key (type js2-CASE)
+                                                   (pos js2-ts-cursor)
+                                                   len
+                                                   kids
+                                                   expr)))
+  "AST node for a case clause of a switch statement."
+  expr)   ; the case expression (nil for default)
+
+(put 'cl-struct-js2-case-node 'js2-visitor 'js2-visit-case-node)
+(put 'cl-struct-js2-case-node 'js2-printer 'js2-print-case-node)
+
+(defun js2-visit-case-node (n v)
+  (if (js2-case-node-expr n)  ; nil for default: case
+      (js2-visit-ast (js2-case-node-expr n) v))
+  (js2-visit-block n v))
+
+(defun js2-print-case-node (n i)
+  (let ((pad (js2-make-pad i))
+        (expr (js2-case-node-expr n)))
+    (insert pad)
+    (if (null expr)
+        (insert "default:\n")
+      (insert "case ")
+      (js2-print-ast expr 0)
+      (insert ":\n"))
+    (dolist (kid (js2-case-node-kids n))
+      (js2-print-ast kid (1+ i)))))
+
+(defstruct (js2-throw-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-throw-node (&key (type js2-THROW)
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    expr)))
+  "AST node for a throw statement."
+  expr)   ; the expression to throw
+
+(put 'cl-struct-js2-throw-node 'js2-visitor 'js2-visit-throw-node)
+(put 'cl-struct-js2-throw-node 'js2-printer 'js2-print-throw-node)
+
+(defun js2-visit-throw-node (n v)
+  (js2-visit-ast (js2-throw-node-expr n) v))
+
+(defun js2-print-throw-node (n i)
+  (insert (js2-make-pad i) "throw ")
+  (js2-print-ast (js2-throw-node-expr n) 0)
+  (insert ";\n"))
+
+(defstruct (js2-with-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-with-node (&key (type js2-WITH)
+                                                   (pos js2-ts-cursor)
+                                                   len
+                                                   object
+                                                   body
+                                                   lp
+                                                   rp)))
+  "AST node for a with-statement."
+  object
+  body
+  lp    ; buffer position of left-paren around object, nil if omitted
+  rp)   ; buffer position of right-paren around object, nil if omitted
+
+(put 'cl-struct-js2-with-node 'js2-visitor 'js2-visit-with-node)
+(put 'cl-struct-js2-with-node 'js2-printer 'js2-print-with-node)
+
+(defun js2-visit-with-node (n v)
+  (js2-visit-ast (js2-with-node-object n) v)
+  (js2-visit-ast (js2-with-node-body n) v))
+
+(defun js2-print-with-node (n i)
+  (let ((pad (js2-make-pad i)))
+    (insert pad "with (")
+    (js2-print-ast (js2-with-node-object n) 0)
+    (insert ") {\n")
+    (js2-print-body (js2-with-node-body n) (1+ i))
+    (insert pad "}\n")))
+
+(defstruct (js2-label-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-label-node (&key (type js2-LABEL)
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    name)))
+  "AST node for a statement label or case label."
+  name   ; a string
+  loop)  ; for validating and code-generating continue-to-label
+
+(put 'cl-struct-js2-label-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-label-node 'js2-printer 'js2-print-label)
+
+(defun js2-print-label (n i)
+  (insert (js2-make-pad i)
+          (js2-label-node-name n)
+          ":\n"))
+
+(defstruct (js2-labeled-stmt-node
+            (:include js2-node)
+            (:constructor nil)
+            ;; type needs to be in `js2-side-effecting-tokens' to avoid spurious
+            ;; no-side-effects warnings, hence js2-EXPR_RESULT.
+            (:constructor make-js2-labeled-stmt-node (&key (type js2-EXPR_RESULT)
+                                                           (pos js2-ts-cursor)
+                                                           len
+                                                           labels
+                                                           stmt)))
+  "AST node for a statement with one or more labels.
+Multiple labels for a statement are collapsed into the labels field."
+  labels  ; lisp list of `js2-label-node'
+  stmt)   ; the statement these labels are for
+
+(put 'cl-struct-js2-labeled-stmt-node 'js2-visitor 'js2-visit-labeled-stmt)
+(put 'cl-struct-js2-labeled-stmt-node 'js2-printer 'js2-print-labeled-stmt)
+
+(defun js2-get-label-by-name (lbl-stmt name)
+  "Return a `js2-label-node' by NAME from LBL-STMT's labels list.
+Returns nil if no such label is in the list."
+  (let ((label-list (js2-labeled-stmt-node-labels lbl-stmt))
+        result)
+    (while (and label-list (not result))
+      (if (string= (js2-label-node-name (car label-list)) name)
+          (setq result (car label-list))
+        (setq label-list (cdr label-list))))
+    result))
+
+(defun js2-visit-labeled-stmt (n v)
+  (dolist (label (js2-labeled-stmt-node-labels n))
+    (js2-visit-ast label v))
+  (js2-visit-ast (js2-labeled-stmt-node-stmt n) v))
+
+(defun js2-print-labeled-stmt (n i)
+  (dolist (label (js2-labeled-stmt-node-labels n))
+    (js2-print-ast label i))
+  (js2-print-ast (js2-labeled-stmt-node-stmt n) (1+ i)))
+
+(defun js2-labeled-stmt-node-contains (node label)
+  "Return t if NODE contains LABEL in its label set.
+NODE is a `js2-labels-node'.  LABEL is an identifier."
+  (loop for nl in (js2-labeled-stmt-node-labels node)
+        if (string= label (js2-label-node-name nl))
+          return t
+        finally return nil))
+
+(defsubst js2-labeled-stmt-node-add-label (node label)
+  "Add a `js2-label-node' to the label set for this statement."
+  (setf (js2-labeled-stmt-node-labels node)
+        (nconc (js2-labeled-stmt-node-labels node) (list label))))
+
+(defstruct (js2-jump-node
+            (:include js2-node)
+            (:constructor nil))
+  "Abstract supertype of break and continue nodes."
+  label   ; `js2-name-node' for location of label identifier, if present
+  target) ; target js2-labels-node or loop/switch statement
+
+(defun js2-visit-jump-node (n v)
+  ;; we don't visit the target, since it's a back-link
+  (if (js2-jump-node-label n)
+      (js2-visit-ast (js2-jump-node-label n) v)))
+
+(defstruct (js2-break-node
+            (:include js2-jump-node)
+            (:constructor nil)
+            (:constructor make-js2-break-node (&key (type js2-BREAK)
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    label
+                                                    target)))
+  "AST node for a break statement.
+The label field is a `js2-name-node', possibly nil, for the named label
+if provided.  E.g. in 'break foo', it represents 'foo'.  The target field
+is the target of the break - a label node or enclosing loop/switch statement.")
+
+(put 'cl-struct-js2-break-node 'js2-visitor 'js2-visit-jump-node)
+(put 'cl-struct-js2-break-node 'js2-printer 'js2-print-break-node)
+
+(defun js2-print-break-node (n i)
+  (insert (js2-make-pad i) "break")
+  (when (js2-break-node-label n)
+    (insert " ")
+    (js2-print-ast (js2-break-node-label n) 0))
+  (insert ";\n"))
+
+(defstruct (js2-continue-node
+            (:include js2-jump-node)
+            (:constructor nil)
+            (:constructor make-js2-continue-node (&key (type js2-CONTINUE)
+                                                       (pos js2-ts-cursor)
+                                                       len
+                                                       label
+                                                       target)))
+  "AST node for a continue statement.
+The label field is the user-supplied enclosing label name, a `js2-name-node'.
+It is nil if continue specifies no label.  The target field is the jump target:
+a `js2-label-node' or the innermost enclosing loop.")
+
+(put 'cl-struct-js2-continue-node 'js2-visitor 'js2-visit-jump-node)
+(put 'cl-struct-js2-continue-node 'js2-printer 'js2-print-continue-node)
+
+(defun js2-print-continue-node (n i)
+  (insert (js2-make-pad i) "continue")
+  (when (js2-continue-node-label n)
+    (insert " ")
+    (js2-print-ast (js2-continue-node-label n) 0))
+  (insert ";\n"))
+
+(defstruct (js2-function-node
+            (:include js2-script-node)
+            (:constructor nil)
+            (:constructor make-js2-function-node (&key (type js2-FUNCTION)
+                                                       (pos js2-ts-cursor)
+                                                       len
+                                                       (ftype 'FUNCTION)
+                                                       (form 'FUNCTION_STATEMENT)
+                                                       (name "")
+                                                       params
+                                                       body
+                                                       lp
+                                                       rp)))
+  "AST node for a function declaration.
+The `params' field is a lisp list of nodes.  Each node is either a simple
+`js2-name-node', or if it's a destructuring-assignment parameter, a
+`js2-array-node' or `js2-object-node'."
+  ftype            ; FUNCTION, GETTER or SETTER
+  form             ; FUNCTION_{STATEMENT|EXPRESSION|EXPRESSION_STATEMENT}
+  name             ; function name (a `js2-name-node', or nil if anonymous)
+  params           ; a lisp list of destructuring forms or simple name nodes
+  body             ; a `js2-block-node' or expression node (1.8 only)
+  lp               ; position of arg-list open-paren, or nil if omitted
+  rp               ; position of arg-list close-paren, or nil if omitted
+  ignore-dynamic   ; ignore value of the dynamic-scope flag (interpreter only)
+  needs-activation ; t if we need an activation object for this frame
+  is-generator     ; t if this function contains a yield
+  member-expr)     ; nonstandard Ecma extension from Rhino
+
+(put 'cl-struct-js2-function-node 'js2-visitor 'js2-visit-function-node)
+(put 'cl-struct-js2-function-node 'js2-printer 'js2-print-function-node)
+
+(defun js2-visit-function-node (n v)
+  (if (js2-function-node-name n)
+      (js2-visit-ast (js2-function-node-name n) v))
+  (dolist (p (js2-function-node-params n))
+    (js2-visit-ast p v))
+  (js2-visit-ast (js2-function-node-body n) v))
+
+(defun js2-print-function-node (n i)
+  (let ((pad (js2-make-pad i))
+        (getter (js2-node-get-prop n 'GETTER_SETTER))
+        (name (js2-function-node-name n))
+        (params (js2-function-node-params n))
+        (body (js2-function-node-body n))
+        (expr (eq (js2-function-node-form n) 'FUNCTION_EXPRESSION)))
+    (unless getter
+      (insert pad "function"))
+    (when name
+        (insert " ")
+        (js2-print-ast name 0))
+    (insert "(")
+    (loop with len = (length params)
+          for param in params
+          for count from 1
+          do
+          (js2-print-ast param 0)
+          (if (< count len)
+              (insert ", ")))
+    (insert ") {")
+    (unless expr
+      (insert "\n"))
+    ;; TODO:  fix this to be smarter about indenting, etc.
+    (js2-print-body body (1+ i))
+    (insert pad "}")
+    (unless expr
+      (insert "\n"))))
+
+(defsubst js2-function-name (node)
+  "Return function name for NODE, a `js2-function-node', or nil if anonymous."
+  (and (js2-function-node-name node)
+       (js2-name-node-name (js2-function-node-name node))))
+
+;; Having this be an expression node makes it more flexible.
+;; There are IDE contexts, such as indentation in a for-loop initializer,
+;; that work better if you assume it's an expression.  Whenever we have
+;; a standalone var/const declaration, we just wrap with an expr stmt.
+;; Eclipse apparently screwed this up and now has two versions, expr and stmt.
+(defstruct (js2-var-decl-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-var-decl-node (&key (type js2-VAR)
+                                                       (pos js2-token-beg)
+                                                       len
+                                                       kids
+                                                       decl-type)))
+  "AST node for a variable declaration list (VAR, CONST or LET).
+The node bounds differ depending on the declaration type.  For VAR or
+CONST declarations, the bounds include the var/const keyword.  For LET
+declarations, the node begins at the position of the first child."
+  kids        ; a lisp list of `js2-var-init-node' structs.
+  decl-type)  ; js2-VAR, js2-CONST or js2-LET
+
+(put 'cl-struct-js2-var-decl-node 'js2-visitor 'js2-visit-var-decl)
+(put 'cl-struct-js2-var-decl-node 'js2-printer 'js2-print-var-decl)
+
+(defun js2-visit-var-decl (n v)
+  (dolist (kid (js2-var-decl-node-kids n))
+    (js2-visit-ast kid v)))
+
+(defun js2-print-var-decl (n i)
+  (let ((pad (js2-make-pad i))
+        (tt (js2-var-decl-node-decl-type n)))
+    (insert pad)
+    (insert (cond
+             ((= tt js2-VAR) "var ")
+             ((= tt js2-LET) "")  ; handled by parent let-{expr/stmt}
+             ((= tt js2-CONST) "const ")
+             (t
+              (error "malformed var-decl node"))))
+    (loop with kids = (js2-var-decl-node-kids n)
+          with len = (length kids)
+          for kid in kids
+          for count from 1
+          do
+          (js2-print-ast kid 0)
+          (if (< count len)
+              (insert ", ")))))
+
+(defstruct (js2-var-init-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-var-init-node (&key (type js2-VAR)
+                                                       (pos js2-ts-cursor)
+                                                       len
+                                                       target
+                                                       initializer)))
+  "AST node for a variable declaration.
+The type field will be js2-CONST for a const decl."
+  target        ; `js2-name-node', `js2-object-node', or `js2-array-node'
+  initializer)  ; initializer expression, a `js2-node'
+
+(put 'cl-struct-js2-var-init-node 'js2-visitor 'js2-visit-var-init-node)
+(put 'cl-struct-js2-var-init-node 'js2-printer 'js2-print-var-init-node)
+
+(defun js2-visit-var-init-node (n v)
+  (js2-visit-ast (js2-var-init-node-target n) v)
+  (if (js2-var-init-node-initializer n)
+      (js2-visit-ast (js2-var-init-node-initializer n) v)))
+
+(defun js2-print-var-init-node (n i)
+  (let ((pad (js2-make-pad i))
+        (name (js2-var-init-node-target n))
+        (init (js2-var-init-node-initializer n)))
+    (insert pad)
+    (js2-print-ast name 0)
+    (when init
+      (insert " = ")
+      (js2-print-ast init 0))))
+
+(defstruct (js2-cond-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-cond-node (&key (type js2-HOOK)
+                                                   (pos js2-ts-cursor)
+                                                   len
+                                                   test-expr
+                                                   true-expr
+                                                   false-expr
+                                                   q-pos
+                                                   c-pos)))
+  "AST node for the ternary operator"
+  test-expr
+  true-expr
+  false-expr
+  q-pos   ; buffer position of ?
+  c-pos)  ; buffer position of :
+
+(put 'cl-struct-js2-cond-node 'js2-visitor 'js2-visit-cond-node)
+(put 'cl-struct-js2-cond-node 'js2-printer 'js2-print-cond-node)
+
+(defun js2-visit-cond-node (n v)
+  (js2-visit-ast (js2-cond-node-test-expr n) v)
+  (js2-visit-ast (js2-cond-node-true-expr n) v)
+  (js2-visit-ast (js2-cond-node-false-expr n) v))
+
+(defun js2-print-cond-node (n i)
+  (let ((pad (js2-make-pad i)))
+    (insert pad)
+    (js2-print-ast (js2-cond-node-test-expr n) 0)
+    (insert " ? ")
+    (js2-print-ast (js2-cond-node-true-expr n) 0)
+    (insert " : ")
+    (js2-print-ast (js2-cond-node-false-expr n) 0)))
+
+(defstruct (js2-infix-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-infix-node (&key type
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    op-pos
+                                                    left
+                                                    right)))
+  "Represents infix expressions.
+Includes assignment ops like `|=', and the comma operator.
+The type field inherited from `js2-node' holds the operator."
+  op-pos    ; buffer position where operator begins
+  left      ; any `js2-node'
+  right)    ; any `js2-node'
+
+(put 'cl-struct-js2-infix-node 'js2-visitor 'js2-visit-infix-node)
+(put 'cl-struct-js2-infix-node 'js2-printer 'js2-print-infix-node)
+
+(defun js2-visit-infix-node (n v)
+  (when (js2-infix-node-left n)
+    (js2-visit-ast (js2-infix-node-left n) v))
+  (when (js2-infix-node-right n)
+    (js2-visit-ast (js2-infix-node-right n) v)))
+
+(defconst js2-operator-tokens
+  (let ((table (make-hash-table :test 'eq))
+        (tokens
+         (list (cons js2-IN "in")
+               (cons js2-TYPEOF "typeof")
+               (cons js2-INSTANCEOF "instanceof")
+               (cons js2-DELPROP "delete")
+               (cons js2-COMMA ",")
+               (cons js2-COLON ":")
+               (cons js2-OR "||")
+               (cons js2-AND "&&")
+               (cons js2-INC "++")
+               (cons js2-DEC "--")
+               (cons js2-BITOR "|")
+               (cons js2-BITXOR "^")
+               (cons js2-BITAND "&")
+               (cons js2-EQ "==")
+               (cons js2-NE "!=")
+               (cons js2-LT "<")
+               (cons js2-LE "<=")
+               (cons js2-GT ">")
+               (cons js2-GE ">=")
+               (cons js2-LSH "<<")
+               (cons js2-RSH ">>")
+               (cons js2-URSH ">>>")
+               (cons js2-ADD "+")       ; infix plus
+               (cons js2-SUB "-")       ; infix minus
+               (cons js2-MUL "*")
+               (cons js2-DIV "/")
+               (cons js2-MOD "%")
+               (cons js2-NOT "!")
+               (cons js2-BITNOT "~")
+               (cons js2-POS "+")       ; unary plus
+               (cons js2-NEG "-")       ; unary minus
+               (cons js2-SHEQ "===")    ; shallow equality
+               (cons js2-SHNE "!==")    ; shallow inequality
+               (cons js2-ASSIGN "=")
+               (cons js2-ASSIGN_BITOR "|=")
+               (cons js2-ASSIGN_BITXOR "^=")
+               (cons js2-ASSIGN_BITAND "&=")
+               (cons js2-ASSIGN_LSH "<<=")
+               (cons js2-ASSIGN_RSH ">>=")
+               (cons js2-ASSIGN_URSH ">>>=")
+               (cons js2-ASSIGN_ADD "+=")
+               (cons js2-ASSIGN_SUB "-=")
+               (cons js2-ASSIGN_MUL "*=")
+               (cons js2-ASSIGN_DIV "/=")
+               (cons js2-ASSIGN_MOD "%="))))
+    (loop for (k . v) in tokens do
+          (puthash k v table))
+    table))
+
+(defun js2-print-infix-node (n i)
+  (let* ((tt (js2-node-type n))
+         (op (gethash tt js2-operator-tokens)))
+    (unless op
+      (error "unrecognized infix operator %s" (js2-node-type n)))
+    (insert (js2-make-pad i))
+    (js2-print-ast (js2-infix-node-left n) 0)
+    (unless (= tt js2-COMMA)
+      (insert " "))
+    (insert op)
+    (insert " ")
+    (js2-print-ast (js2-infix-node-right n) 0)))
+
+(defstruct (js2-assign-node
+            (:include js2-infix-node)
+            (:constructor nil)
+            (:constructor make-js2-assign-node (&key type
+                                                     (pos js2-ts-cursor)
+                                                     len
+                                                     op-pos
+                                                     left
+                                                     right)))
+  "Represents any assignment.
+The type field holds the actual assignment operator.")
+
+(put 'cl-struct-js2-assign-node 'js2-visitor 'js2-visit-infix-node)
+(put 'cl-struct-js2-assign-node 'js2-printer 'js2-print-infix-node)
+
+(defstruct (js2-unary-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-unary-node (&key type ; required
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    operand)))
+  "AST node type for unary operator nodes.
+The type field can be NOT, BITNOT, POS, NEG, INC, DEC,
+TYPEOF, or DELPROP.  For INC or DEC, a 'postfix node
+property is added if the operator follows the operand."
+  operand)  ; a `js2-node' expression
+
+(put 'cl-struct-js2-unary-node 'js2-visitor 'js2-visit-unary-node)
+(put 'cl-struct-js2-unary-node 'js2-printer 'js2-print-unary-node)
+
+(defun js2-visit-unary-node (n v)
+  (js2-visit-ast (js2-unary-node-operand n) v))
+
+(defun js2-print-unary-node (n i)
+  (let* ((tt (js2-node-type n))
+         (op (gethash tt js2-operator-tokens))
+         (postfix (js2-node-get-prop n 'postfix)))
+    (unless op
+      (error "unrecognized unary operator %s" tt))
+    (insert (js2-make-pad i))
+    (unless postfix
+      (insert op))
+    (if (or (= tt js2-TYPEOF)
+            (= tt js2-DELPROP))
+        (insert " "))
+    (js2-print-ast (js2-unary-node-operand n) 0)
+    (when postfix
+      (insert op))))
+
+(defstruct (js2-let-node
+            (:include js2-scope)
+            (:constructor nil)
+            (:constructor make-js2-let-node (&key (type js2-LETEXPR)
+                                                  (pos js2-token-beg)
+                                                  len
+                                                  vars
+                                                  body
+                                                  lp
+                                                  rp)))
+  "AST node for a let expression or a let statement.
+Note that a let declaration such as let x=6, y=7 is a `js2-var-decl-node'."
+  vars   ; a `js2-var-decl-node'
+  body   ; a `js2-node' representing the expression or body block
+  lp
+  rp)
+
+(put 'cl-struct-js2-let-node 'js2-visitor 'js2-visit-let-node)
+(put 'cl-struct-js2-let-node 'js2-printer 'js2-print-let-node)
+
+(defun js2-visit-let-node (n v)
+  (when (js2-let-node-vars n)
+    (js2-visit-ast (js2-let-node-vars n) v))
+  (when (js2-let-node-body n)
+    (js2-visit-ast (js2-let-node-body n) v)))
+
+(defun js2-print-let-node (n i)
+  (insert (js2-make-pad i) "let (")
+  (js2-print-ast (js2-let-node-vars n) 0)
+  (insert ") ")
+  (js2-print-ast (js2-let-node-body n) i))
+
+(defstruct (js2-keyword-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-keyword-node (&key type
+                                                      (pos js2-token-beg)
+                                                      (len (- js2-ts-cursor pos)))))
+  "AST node representing a literal keyword such as `null'.
+Used for `null', `this', `true', `false' and `debugger'.
+The node type is set to js2-NULL, js2-THIS, etc.")
+
+(put 'cl-struct-js2-keyword-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-keyword-node 'js2-printer 'js2-print-keyword-node)
+
+(defun js2-print-keyword-node (n i)
+  (insert (js2-make-pad i)
+          (let ((tt (js2-node-type n)))
+            (cond
+             ((= tt 'js2-THIS) "this")
+             ((= tt 'js2-NULL) "null")
+             ((= tt 'js2-TRUE) "true")
+             ((= tt 'js2-FALSE) "false")
+             ((= tt 'js2-DEBUGGER) "debugger")
+             (t (error "Invalid keyword literal type: %d" tt))))))
+
+(defsubst js2-this-node-p (node)
+  "Return t if this node is a `js2-literal-node' of type js2-THIS."
+  (eq (js2-node-type node) js2-THIS))
+
+(defstruct (js2-new-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-new-node (&key (type js2-NEW)
+                                                  (pos js2-token-beg)
+                                                  len
+                                                  target
+                                                  args
+                                                  initializer
+                                                  lp
+                                                  rp)))
+  "AST node for new-expression such as new Foo()."
+  target  ; an identifier or reference
+  args    ; a lisp list of argument nodes
+  lp      ; position of left-paren, nil if omitted
+  rp      ; position of right-paren, nil if omitted
+  initializer) ; experimental Rhino syntax:  optional `js2-object-node'
+
+(put 'cl-struct-js2-new-node 'js2-visitor 'js2-visit-new-node)
+(put 'cl-struct-js2-new-node 'js2-printer 'js2-print-new-node)
+
+(defun js2-visit-new-node (n v)
+  (js2-visit-ast (js2-new-node-target n) v)
+  (dolist (arg (js2-new-node-args n))
+    (js2-visit-ast arg v))
+  (when (js2-new-node-initializer n)
+    (js2-visit-ast (js2-new-node-initializer n) v)))
+
+(defun js2-print-new-node (n i)
+  (insert (js2-make-pad i) "new ")
+  (js2-print-ast (js2-new-node-target n))
+  (insert "(")
+  (js2-print-list (js2-new-node-args n))
+  (insert ")")
+  (when (js2-new-node-initializer n)
+    (insert " ")
+    (js2-print-ast (js2-new-node-initializer n))))
+
+(defstruct (js2-name-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-name-node (&key (type js2-NAME)
+                                                   (pos js2-token-beg)
+                                                   (len (- js2-ts-cursor
+                                                           js2-token-beg))
+                                                   (name js2-ts-string))))
+  "AST node for a JavaScript identifier"
+  name   ; a string
+  scope) ; a `js2-scope' (optional, used for codegen)
+
+(put 'cl-struct-js2-name-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-name-node 'js2-printer 'js2-print-name-node)
+
+(defun js2-print-name-node (n i)
+  (insert (js2-make-pad i)
+          (js2-name-node-name n)))
+
+(defsubst js2-name-node-length (node)
+  "Return identifier length of NODE, a `js2-name-node'.
+Returns 0 if NODE is nil or its identifier field is nil."
+  (if node
+      (length (js2-name-node-name node))
+    0))
+
+(defstruct (js2-number-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-number-node (&key (type js2-NUMBER)
+                                                     (pos js2-token-beg)
+                                                     (len (- js2-ts-cursor
+                                                             js2-token-beg))
+                                                     (value js2-ts-string)
+                                                     (num-value js2-ts-number))))
+  "AST node for a number literal."
+  value      ; the original string, e.g. "6.02e23"
+  num-value) ; the parsed number value
+
+(put 'cl-struct-js2-number-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-number-node 'js2-printer 'js2-print-number-node)
+
+(defun js2-print-number-node (n i)
+  (insert (js2-make-pad i)
+          (number-to-string (js2-number-node-value n))))
+
+(defstruct (js2-regexp-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-regexp-node (&key (type js2-REGEXP)
+                                                     (pos js2-token-beg)
+                                                     (len (- js2-ts-cursor
+                                                             js2-token-beg))
+                                                     value
+                                                     flags)))
+  "AST node for a regular expression literal."
+  value  ; the regexp string, without // delimiters
+  flags) ; a string of flags, e.g. `mi'.
+
+(put 'cl-struct-js2-regexp-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-regexp-node 'js2-printer 'js2-print-regexp)
+
+(defun js2-print-regexp (n i)
+  (insert (js2-make-pad i)
+          "/"
+          (js2-regexp-node-value n)
+          "/")
+  (if (js2-regexp-node-flags n)
+      (insert (js2-regexp-node-flags n))))
+
+(defstruct (js2-string-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-string-node (&key (type js2-STRING)
+                                                     (pos js2-token-beg)
+                                                     (len (- js2-ts-cursor
+                                                             js2-token-beg))
+                                                     (value js2-ts-string))))
+  "String literal.
+Escape characters are not evaluated; e.g. \n is 2 chars in value field.
+You can tell the quote type by looking at the first character."
+  value) ; the characters of the string, including the quotes
+
+(put 'cl-struct-js2-string-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-string-node 'js2-printer 'js2-print-string-node)
+
+(defun js2-print-string-node (n i)
+  (insert (js2-make-pad i)
+          (js2-node-string n)))
+
+(defstruct (js2-array-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-array-node (&key (type js2-ARRAYLIT)
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    elems)))
+  "AST node for an array literal."
+  elems)  ; list of expressions.  [foo,,bar] yields a nil middle element.
+
+(put 'cl-struct-js2-array-node 'js2-visitor 'js2-visit-array-node)
+(put 'cl-struct-js2-array-node 'js2-printer 'js2-print-array-node)
+
+(defun js2-visit-array-node (n v)
+  (dolist (e (js2-array-node-elems n))
+    (when e  ; can be nil, e.g. [a, ,b]
+      (js2-visit-ast e v))))
+
+(defun js2-print-array-node (n i)
+  (insert (js2-make-pad i) "[")
+  (js2-print-list (js2-array-node-elems n))
+  (insert "]"))
+
+(defstruct (js2-object-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-object-node (&key (type js2-OBJECTLIT)
+                                                     (pos js2-ts-cursor)
+                                                     len
+                                                     elems)))
+  "AST node for an object literal expression."
+  elems)  ; a lisp list of `js2-object-prop-node'
+
+(put 'cl-struct-js2-object-node 'js2-visitor 'js2-visit-object-node)
+(put 'cl-struct-js2-object-node 'js2-printer 'js2-print-object-node)
+
+(defun js2-visit-object-node (n v)
+  (dolist (e (js2-object-node-elems n))
+    (js2-visit-ast e v)))
+
+(defun js2-print-object-node (n i)
+  (insert (js2-make-pad i) "{")
+  (js2-print-list (js2-object-node-elems n))
+  (insert "}"))
+
+(defstruct (js2-object-prop-node
+            (:include js2-infix-node)
+            (:constructor nil)
+            (:constructor make-js2-object-prop-node (&key (type js2-COLON)
+                                                          (pos js2-ts-cursor)
+                                                          len
+                                                          left
+                                                          right
+                                                          op-pos)))
+  "AST node for an object literal prop:value entry.
+The `left' field is the property:  a name node, string node or number node.
+The `right' field is a `js2-node' representing the initializer value.")
+
+(put 'cl-struct-js2-object-prop-node 'js2-visitor 'js2-visit-infix-node)
+(put 'cl-struct-js2-object-prop-node 'js2-printer 'js2-print-object-prop-node)
+
+(defun js2-print-object-prop-node (n i)
+  (insert (js2-make-pad i))
+  (js2-print-ast (js2-object-prop-node-left n) 0)
+  (insert ":")
+  (js2-print-ast (js2-object-prop-node-right n) 0))
+
+(defstruct (js2-getter-setter-node
+            (:include js2-infix-node)
+            (:constructor nil)
+            (:constructor make-js2-getter-setter-node (&key type ; GET or SET
+                                                            (pos js2-ts-cursor)
+                                                            len
+                                                            left
+                                                            right)))
+  "AST node for a getter/setter property in an object literal.
+The `left' field is the `js2-name-node' naming the getter/setter prop.
+The `right' field is always an anonymous `js2-function-node' with a node
+property `GETTER_SETTER' set to js2-GET or js2-SET. ")
+
+(put 'cl-struct-js2-getter-setter-node 'js2-visitor 'js2-visit-infix-node)
+(put 'cl-struct-js2-getter-setter-node 'js2-printer 'js2-print-getter-setter)
+
+(defun js2-print-getter-setter (n i)
+  (let ((pad (js2-make-pad i))
+        (left (js2-getter-setter-node-left n))
+        (right (js2-getter-setter-node-right n)))
+    (insert pad)
+    (insert (if (= (js2-node-type n) js2-GET) "get " "set "))
+    (js2-print-ast left 0)
+    (js2-print-ast right 0)))
+
+(defstruct (js2-prop-get-node
+            (:include js2-infix-node)
+            (:constructor nil)
+            (:constructor make-js2-prop-get-node (&key (type js2-GETPROP)
+                                                       (pos js2-ts-cursor)
+                                                       len
+                                                       left
+                                                       right)))
+  "AST node for a dotted property reference, e.g. foo.bar or foo().bar")
+
+(put 'cl-struct-js2-prop-get-node 'js2-visitor 'js2-visit-prop-get-node)
+(put 'cl-struct-js2-prop-get-node 'js2-printer 'js2-print-prop-get-node)
+
+(defun js2-visit-prop-get-node (n v)
+  (when (js2-prop-get-node-left n)
+    (js2-visit-ast (js2-prop-get-node-left n) v))
+  (when (js2-prop-get-node-right n)
+    (js2-visit-ast (js2-prop-get-node-right n) v)))
+
+(defun js2-print-prop-get-node (n i)
+  (insert (js2-make-pad i))
+  (js2-print-ast (js2-prop-get-node-left n) 0)
+  (insert ".")
+  (js2-print-ast (js2-prop-get-node-right n) 0))
+
+(defstruct (js2-elem-get-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-elem-get-node (&key (type js2-GETELEM)
+                                                       (pos js2-ts-cursor)
+                                                       len
+                                                       target
+                                                       element
+                                                       lb
+                                                       rb)))
+  "AST node for an array index expression such as foo[bar]."
+  target  ; a `js2-node' - the expression preceding the "."
+  element ; a `js2-node' - the expression in brackets
+  lb      ; position of left-bracket, nil if omitted
+  rb)     ; position of right-bracket, nil if omitted
+
+(put 'cl-struct-js2-elem-get-node 'js2-visitor 'js2-visit-elem-get-node)
+(put 'cl-struct-js2-elem-get-node 'js2-printer 'js2-print-elem-get-node)
+
+(defun js2-visit-elem-get-node (n v)
+  (when (js2-elem-get-node-target n)
+    (js2-visit-ast (js2-elem-get-node-target n) v))
+  (when (js2-elem-get-node-element n)
+    (js2-visit-ast (js2-elem-get-node-element n) v)))
+
+(defun js2-print-elem-get-node (n i)
+  (insert (js2-make-pad i))
+  (js2-print-ast (js2-elem-get-node-target n) 0)
+  (insert "[")
+  (js2-print-ast (js2-elem-get-node-element n) 0)
+  (insert "]"))
+
+(defstruct (js2-call-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-call-node (&key (type js2-CALL)
+                                                   (pos js2-ts-cursor)
+                                                   len
+                                                   target
+                                                   args
+                                                   lp
+                                                   rp)))
+  "AST node for a JavaScript function call."
+  target  ; a `js2-node' evaluating to the function to call
+  args  ; a lisp list of `js2-node' arguments
+  lp    ; position of open-paren, or nil if missing
+  rp)   ; position of close-paren, or nil if missing
+
+(put 'cl-struct-js2-call-node 'js2-visitor 'js2-visit-call-node)
+(put 'cl-struct-js2-call-node 'js2-printer 'js2-print-call-node)
+
+(defun js2-visit-call-node (n v)
+  (js2-visit-ast (js2-call-node-target n) v)
+  (dolist (arg (js2-call-node-args n))
+    (js2-visit-ast arg v)))
+
+(defun js2-print-call-node (n i)
+  (insert (js2-make-pad i))
+  (js2-print-ast (js2-call-node-target n) 0)
+  (insert "(")
+  (js2-print-list (js2-call-node-args n))
+  (insert ")"))
+
+(defstruct (js2-yield-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-yield-node (&key (type js2-YIELD)
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    value)))
+  "AST node for yield statement or expression."
+  value) ; optional:  value to be yielded
+
+(put 'cl-struct-js2-yield-node 'js2-visitor 'js2-visit-yield-node)
+(put 'cl-struct-js2-yield-node 'js2-printer 'js2-print-yield-node)
+
+(defun js2-visit-yield-node (n v)
+  (js2-visit-ast (js2-yield-node-value n) v))
+
+(defun js2-print-yield-node (n i)
+  (insert (js2-make-pad i))
+  (insert "yield")
+  (when (js2-yield-node-value n)
+    (insert " ")
+    (js2-print-ast (js2-yield-node-value n) 0)))
+
+(defstruct (js2-paren-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-paren-node (&key (type js2-LP)
+                                                    (pos js2-ts-cursor)
+                                                    len
+                                                    expr)))
+  "AST node for a parenthesized expression.
+In particular, used when the parens are syntactically optional,
+as opposed to required parens such as those enclosing an if-conditional."
+  expr)   ; `js2-node'
+
+(put 'cl-struct-js2-paren-node 'js2-visitor 'js2-visit-paren-node)
+(put 'cl-struct-js2-paren-node 'js2-printer 'js2-print-paren-node)
+
+(defun js2-visit-paren-node (n v)
+  (js2-visit-ast (js2-paren-node-expr n) v))
+
+(defun js2-print-paren-node (n i)
+  (insert (js2-make-pad i))
+  (insert "(")
+  (js2-print-ast (js2-paren-node-expr n) 0)
+  (insert ")"))
+
+(defstruct (js2-array-comp-node
+            (:include js2-scope)
+            (:constructor nil)
+            (:constructor make-js2-array-comp-node (&key (type js2-ARRAYCOMP)
+                                                         (pos js2-ts-cursor)
+                                                         len
+                                                         result
+                                                         loops
+                                                         filter
+                                                         if-pos
+                                                         lp
+                                                         rp)))
+  "AST node for an Array comprehension such as [[x,y] for (x in foo) for (y in bar)]."
+  result  ; result expression (just after left-bracket)
+  loops   ; a lisp list of `js2-array-comp-loop-node'
+  filter  ; guard/filter expression
+  if-pos  ; buffer pos of 'if' keyword, if present, else nil
+  lp      ; buffer position of if-guard left-paren, or nil if not present
+  rp)     ; buffer position of if-guard right-paren, or nil if not present
+
+(put 'cl-struct-js2-array-comp-node 'js2-visitor 'js2-visit-array-comp-node)
+(put 'cl-struct-js2-array-comp-node 'js2-printer 'js2-print-array-comp-node)
+
+(defun js2-visit-array-comp-node (n v)
+  (js2-visit-ast (js2-array-comp-node-result n) v)
+  (dolist (l (js2-array-comp-node-loops n))
+    (js2-visit-ast l v))
+  (if (js2-array-comp-node-filter n)
+      (js2-visit-ast (js2-array-comp-node-filter n) v)))
+
+(defun js2-print-array-comp-node (n i)
+  (let ((pad (js2-make-pad i))
+        (result (js2-array-comp-node-result n))
+        (loops (js2-array-comp-node-loops n))
+        (filter (js2-array-comp-node-filter n)))
+    (insert pad "[")
+    (js2-print-ast result 0)
+    (dolist (l loops)
+      (insert " ")
+      (js2-print-ast l 0))
+    (when filter
+      (insert " if (")
+      (js2-print-ast filter 0))
+    (insert ")]")))
+
+(defstruct (js2-array-comp-loop-node
+            (:include js2-for-in-node)
+            (:constructor nil)
+            (:constructor make-js2-array-comp-loop-node (&key (type js2-FOR)
+                                                              (pos js2-ts-cursor)
+                                                              len
+                                                              iterator
+                                                              object
+                                                              in-pos
+                                                              foreach-p
+                                                              each-pos
+                                                              lp
+                                                              rp)))
+  "AST subtree for each 'for (foo in bar)' loop in an array comprehension.")
+
+(put 'cl-struct-js2-array-comp-loop-node 'js2-visitor 'js2-visit-array-comp-loop)
+(put 'cl-struct-js2-array-comp-loop-node 'js2-printer 'js2-print-array-comp-loop)
+
+(defun js2-visit-array-comp-loop (n v)
+  (js2-visit-ast (js2-array-comp-loop-node-iterator n) v)
+  (js2-visit-ast (js2-array-comp-loop-node-object n) v))
+
+(defun js2-print-array-comp-loop (n i)
+  (insert "for (")
+  (js2-print-ast (js2-array-comp-loop-node-iterator n) 0)
+  (insert " in ")
+  (js2-print-ast (js2-array-comp-loop-node-object n) 0)
+  (insert ")"))
+
+(defstruct (js2-empty-expr-node
+            (:include js2-node)
+            (:constructor nil)
+            (:constructor make-js2-empty-expr-node (&key (type js2-EMPTY)
+                                                         (pos js2-token-beg)
+                                                         len)))
+  "AST node for an empty expression.")
+
+(put 'cl-struct-js2-empty-expr-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-empty-expr-node 'js2-printer 'js2-print-none)
+
+(defstruct (js2-xml-node
+            (:include js2-block-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-node (&key (type js2-XML)
+                                                  (pos js2-token-beg)
+                                                  len
+                                                  kids)))
+  "AST node for initial parse of E4X literals.
+The kids field is a list of XML fragments, each a `js2-string-node' or
+a `js2-xml-js-expr-node'.  Equivalent to Rhino's XmlLiteral node.")
+
+(put 'cl-struct-js2-xml-node 'js2-visitor 'js2-visit-block)
+(put 'cl-struct-js2-xml-node 'js2-printer 'js2-print-xml-node)
+
+(defun js2-print-xml-node (n i)
+  (dolist (kid (js2-xml-node-kids n))
+    (js2-print-ast kid i)))
+
+(defstruct (js2-xml-js-expr-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-js-expr-node (&key (type js2-XML)
+                                                          (pos js2-ts-cursor)
+                                                          len
+                                                          expr)))
+  "AST node for an embedded JavaScript {expression} in an E4X literal.
+The start and end fields correspond to the curly-braces."
+  expr)  ; a `js2-expr-node' of some sort
+
+(put 'cl-struct-js2-xml-js-expr-node 'js2-visitor 'js2-visit-xml-js-expr)
+(put 'cl-struct-js2-xml-js-expr-node 'js2-printer 'js2-print-xml-js-expr)
+
+(defun js2-visit-xml-js-expr (n v)
+  (js2-visit-ast (js2-xml-js-expr-node-expr n) v))
+
+(defun js2-print-xml-js-expr (n i)
+  (insert (js2-make-pad i))
+  (insert "{")
+  (js2-print-ast (js2-xml-js-expr-node-expr n) 0)
+  (insert "}"))
+
+(defstruct (js2-xml-dot-query-node
+            (:include js2-infix-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-dot-query-node (&key (type js2-DOTQUERY)
+                                                            (pos js2-ts-cursor)
+                                                            op-pos
+                                                            len
+                                                            left
+                                                            right
+                                                            rp)))
+  "AST node for an E4X foo.(bar) filter expression.
+Note that the left-paren is automatically the character immediately
+following the dot (.) in the operator.  No whitespace is permitted
+between the dot and the lp by the scanner."
+  rp)
+
+(put 'cl-struct-js2-xml-dot-query-node 'js2-visitor 'js2-visit-infix-node)
+(put 'cl-struct-js2-xml-dot-query-node 'js2-printer 'js2-print-xml-dot-query)
+
+(defun js2-print-xml-dot-query (n i)
+  (insert (js2-make-pad i))
+  (js2-print-ast (js2-xml-dot-query-node-left n) 0)
+  (insert ".(")
+  (js2-print-ast (js2-xml-dot-query-node-right n) 0)
+  (insert ")"))
+
+(defstruct (js2-xml-ref-node
+            (:include js2-node)
+            (:constructor nil))  ; abstract
+  "Base type for E4X XML attribute-access or property-get expressions.
+Such expressions can take a variety of forms.  The general syntax has
+three parts:
+
+  - (optional) an @ (specifying an attribute access)
+  - (optional) a namespace (a `js2-name-node') and double-colon
+  - (required) either a `js2-name-node' or a bracketed [expression]
+
+The property-name expressions (examples:  ns::name, @name) are
+represented as `js2-xml-prop-ref' nodes.  The bracketed-expression
+versions (examples:  ns::[name], @[name]) become `js2-xml-elem-ref' nodes.
+
+This node type (or more specifically, its subclasses) will sometimes
+be the right-hand child of a `js2-prop-get-node' or a
+`js2-infix-node' of type `js2-DOTDOT', the .. xml-descendants operator.
+The `js2-xml-ref-node' may also be a standalone primary expression with
+no explicit target, which is valid in certain expression contexts such as
+
+  company..employee.(@id < 100)
+
+in this case, the @id is a `js2-xml-ref' that is part of an infix '<'
+expression whose parent is a `js2-xml-dot-query-node'."
+  namespace
+  at-pos
+  colon-pos)
+
+(defsubst js2-xml-ref-node-attr-access-p (node)
+  "Return non-nil if this expression began with an @-token."
+  (and (numberp (js2-xml-ref-node-at-pos node))
+       (plusp (js2-xml-ref-node-at-pos node))))
+
+(defstruct (js2-xml-prop-ref-node
+            (:include js2-xml-ref-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-prop-ref-node (&key (type js2-REF_NAME)
+                                                           (pos js2-token-beg)
+                                                           len
+                                                           propname
+                                                           namespace
+                                                           at-pos
+                                                           colon-pos)))
+  "AST node for an E4X XML [expr] property-ref expression.
+The JavaScript syntax is an optional @, an optional ns::, and a name.
+
+  [ '@' ] [ name '::' ] name
+
+Examples include name, ns::name, ns::*, *::name, *::*, @attr, @ns::attr,
+@ns::*, @*::attr, @*::*, and @*.
+
+The node starts at the @ token, if present.  Otherwise it starts at the
+namespace name.  The node bounds extend through the closing right-bracket,
+or if it is missing due to a syntax error, through the end of the index
+expression."
+  propname)
+
+(put 'cl-struct-js2-xml-prop-ref-node 'js2-visitor 'js2-visit-xml-prop-ref-node)
+(put 'cl-struct-js2-xml-prop-ref-node 'js2-printer 'js2-print-xml-prop-ref-node)
+
+(defun js2-visit-xml-prop-ref-node (n v)
+  (if (js2-xml-prop-ref-node-namespace n)
+      (js2-visit-ast (js2-xml-prop-ref-node-namespace n) v))
+  (if (js2-xml-prop-ref-node-propname n)
+      (js2-visit-ast (js2-xml-prop-ref-node-propname n) v)))
+
+(defun js2-print-xml-prop-ref-node (n i)
+  (insert (js2-make-pad i))
+  (if (js2-xml-ref-node-attr-access-p n)
+      (insert "@"))
+  (when (js2-xml-prop-ref-node-namespace n)
+    (js2-print-ast (js2-xml-prop-ref-node-namespace n) 0)
+    (insert "::"))
+  (if (js2-xml-prop-ref-node-propname n)
+      (js2-print-ast (js2-xml-prop-ref-node-propname n) 0)))
+
+(defstruct (js2-xml-elem-ref-node
+            (:include js2-xml-ref-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-elem-ref-node (&key (type js2-REF_MEMBER)
+                                                           (pos js2-token-beg)
+                                                           len
+                                                           expr
+                                                           lb
+                                                           rb
+                                                           namespace
+                                                           at-pos
+                                                           colon-pos)))
+  "AST node for an E4X XML [expr] member-ref expression.
+Syntax:
+
+ [ '@' ] [ name '::' ] '[' expr ']'
+
+Examples include ns::[expr], @ns::[expr], @[expr], *::[expr] and @*::[expr].
+
+Note that the form [expr] (i.e. no namespace or attribute-qualifier)
+is not a legal E4X XML element-ref expression, since it's already used
+for standard JavaScript element-get array indexing.  Hence, a
+`js2-xml-elem-ref-node' always has either the attribute-qualifier, a
+non-nil namespace node, or both.
+
+The node starts at the @ token, if present.  Otherwise it starts
+at the namespace name.  The node bounds extend through the closing
+right-bracket, or if it is missing due to a syntax error, through the
+end of the index expression."
+  expr  ; the bracketed index expression
+  lb
+  rb)
+
+(put 'cl-struct-js2-xml-elem-ref-node 'js2-visitor 'js2-visit-xml-elem-ref-node)
+(put 'cl-struct-js2-xml-elem-ref-node 'js2-printer 'js2-print-xml-elem-ref-node)
+
+(defun js2-visit-xml-elem-ref-node (n v)
+  (if (js2-xml-elem-ref-node-namespace n)
+      (js2-visit-ast (js2-xml-elem-ref-node-namespace n) v))
+  (if (js2-xml-elem-ref-node-expr n)
+      (js2-visit-ast (js2-xml-elem-ref-node-expr n) v)))
+
+(defun js2-print-xml-elem-ref-node (n i)
+  (insert (js2-make-pad i))
+  (if (js2-xml-ref-node-attr-access-p n)
+      (insert "@"))
+  (when (js2-xml-elem-ref-node-namespace n)
+    (js2-print-ast (js2-xml-elem-ref-node-namespace n) 0)
+    (insert "::"))
+  (insert "[")
+  (if (js2-xml-elem-ref-node-expr n)
+      (js2-print-ast (js2-xml-elem-ref-node-expr n) 0))
+  (insert "]"))
+
+;;; Placeholder nodes for when we try parsing the XML literals structurally.
+
+(defstruct (js2-xml-start-tag-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-start-tag-node (&key (type js2-XML)
+                                                            (pos js2-ts-cursor)
+                                                            len
+                                                            name
+                                                            attrs
+                                                            kids
+                                                            empty-p)))
+  "AST node for an XML start-tag.  Not currently used.
+The `kids' field is a lisp list of child content nodes."
+  name      ; a `js2-xml-name-node'
+  attrs     ; a lisp list of `js2-xml-attr-node'
+  empty-p)  ; t if this is an empty element such as <foo bar="baz"/>
+
+(put 'cl-struct-js2-xml-start-tag-node 'js2-visitor 'js2-visit-xml-start-tag)
+(put 'cl-struct-js2-xml-start-tag-node 'js2-printer 'js2-print-xml-start-tag)
+
+(defun js2-visit-xml-start-tag (n v)
+  (js2-visit-ast (js2-xml-start-tag-node-name n) v)
+  (dolist (attr (js2-xml-start-tag-node-attrs n))
+    (js2-visit-ast attr v))
+  (js2-visit-block n v))
+
+(defun js2-print-xml-start-tag (n i)
+  (insert (js2-make-pad i) "<")
+  (js2-print-ast (js2-xml-start-tag-node-name n) 0)
+  (when (js2-xml-start-tag-node-attrs n)
+    (insert " ")
+    (js2-print-list (js2-xml-start-tag-node-attrs n) " "))
+  (insert ">"))
+
+;; I -think- I'm going to make the parent node the corresponding start-tag,
+;; and add the end-tag to the kids list of the parent as well.
+(defstruct (js2-xml-end-tag-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-end-tag-node (&key (type js2-XML)
+                                                          (pos js2-ts-cursor)
+                                                          len
+                                                          name)))
+  "AST node for an XML end-tag.  Not currently used."
+  name)  ; a `js2-xml-name-node'
+
+(put 'cl-struct-js2-xml-end-tag-node 'js2-visitor 'js2-visit-xml-end-tag)
+(put 'cl-struct-js2-xml-end-tag-node 'js2-printer 'js2-print-xml-end-tag)
+
+(defun js2-visit-xml-end-tag (n v)
+  (js2-visit-ast (js2-xml-end-tag-node-name n) v))
+
+(defun js2-print-xml-end-tag (n i)
+  (insert (js2-make-pad i))
+  (insert "</")
+  (js2-print-ast (js2-xml-end-tag-node-name n) 0)
+  (insert ">"))
+
+(defstruct (js2-xml-name-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-name-node (&key (type js2-XML)
+                                                       (pos js2-ts-cursor)
+                                                       len
+                                                       namespace
+                                                       kids)))
+  "AST node for an E4X XML name.  Not currently used.
+Any XML name can be qualified with a namespace, hence the namespace field.
+Further, any E4X name can be comprised of arbitrary JavaScript {} expressions.
+The kids field is a list of `js2-name-node' and `js2-xml-js-expr-node'.
+For a simple name, the kids list has exactly one node, a `js2-name-node'."
+  namespace)  ; a `js2-string-node'
+
+(put 'cl-struct-js2-xml-name-node 'js2-visitor 'js2-visit-xml-name-node)
+(put 'cl-struct-js2-xml-name-node 'js2-printer 'js2-print-xml-name-node)
+
+(defun js2-visit-xml-name-node (n v)
+  (js2-visit-ast (js2-xml-name-node-namespace n) v))
+
+(defun js2-print-xml-name-node (n i)
+  (insert (js2-make-pad i))
+  (when (js2-xml-name-node-namespace n)
+    (js2-print-ast (js2-xml-name-node-namespace n) 0)
+    (insert "::"))
+  (dolist (kid (js2-xml-name-node-kids n))
+    (js2-print-ast kid 0)))
+
+(defstruct (js2-xml-pi-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-pi-node (&key (type js2-XML)
+                                                     (pos js2-ts-cursor)
+                                                     len
+                                                     name
+                                                     attrs)))
+  "AST node for an E4X XML processing instruction.  Not currently used."
+  name   ; a `js2-xml-name-node'
+  attrs) ; a list of `js2-xml-attr-node'
+
+(put 'cl-struct-js2-xml-pi-node 'js2-visitor 'js2-visit-xml-pi-node)
+(put 'cl-struct-js2-xml-pi-node 'js2-printer 'js2-print-xml-pi-node)
+
+(defun js2-visit-xml-pi-node (n v)
+  (js2-visit-ast (js2-xml-pi-node-name n) v)
+  (dolist (attr (js2-xml-pi-node-attrs n))
+    (js2-visit-ast attr v)))
+
+(defun js2-print-xml-pi-node (n i)
+  (insert (js2-make-pad i) "<?")
+  (js2-print-ast (js2-xml-pi-node-name n))
+  (when (js2-xml-pi-node-attrs n)
+    (insert " ")
+    (js2-print-list (js2-xml-pi-node-attrs n)))
+  (insert "?>"))
+
+(defstruct (js2-xml-cdata-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-cdata-node (&key (type js2-XML)
+                                                        (pos js2-ts-cursor)
+                                                        len
+                                                        content)))
+  "AST node for a CDATA escape section.  Not currently used."
+  content)  ; a `js2-string-node' with node-property 'quote-type 'cdata
+
+(put 'cl-struct-js2-xml-cdata-node 'js2-visitor 'js2-visit-xml-cdata-node)
+(put 'cl-struct-js2-xml-cdata-node 'js2-printer 'js2-print-xml-cdata-node)
+
+(defun js2-visit-xml-cdata-node (n v)
+  (js2-visit-ast (js2-xml-cdata-node-content n) v))
+
+(defun js2-print-xml-cdata-node (n i)
+  (insert (js2-make-pad i))
+  (js2-print-ast (js2-xml-cdata-node-content n)))
+
+(defstruct (js2-xml-attr-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-attr-node (&key (type js2-XML)
+                                                   (pos js2-ts-cursor)
+                                                   len
+                                                   name
+                                                   value
+                                                   eq-pos
+                                                   quote-type)))
+  "AST node representing a foo='bar' XML attribute value.  Not yet used."
+  name   ; a `js2-xml-name-node'
+  value  ; a `js2-xml-name-node'
+  eq-pos ; buffer position of "=" sign
+  quote-type) ; 'single or 'double
+
+(put 'cl-struct-js2-xml-attr-node 'js2-visitor 'js2-visit-xml-attr-node)
+(put 'cl-struct-js2-xml-attr-node 'js2-printer 'js2-print-xml-attr-node)
+
+(defun js2-visit-xml-attr-node (n v)
+  (js2-visit-ast (js2-xml-attr-node-name n) v)
+  (js2-visit-ast (js2-xml-attr-node-value n) v))
+
+(defun js2-print-xml-attr-node (n i)
+  (let ((quote (if (eq (js2-xml-attr-node-quote-type n) 'single)
+                   "'"
+                 "\"")))
+    (insert (js2-make-pad i))
+    (js2-print-ast (js2-xml-attr-node-name n) 0)
+    (insert "=" quote)
+    (js2-print-ast (js2-xml-attr-node-value n) 0)
+    (insert quote)))
+
+(defstruct (js2-xml-text-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-text-node (&key (type js2-XML)
+                                                   (pos js2-ts-cursor)
+                                                   len
+                                                   content)))
+  "AST node for an E4X XML text node.  Not currently used."
+  content)  ; a lisp list of `js2-string-node' and `js2-xml-js-expr-node'
+
+(put 'cl-struct-js2-xml-text-node 'js2-visitor 'js2-visit-xml-text-node)
+(put 'cl-struct-js2-xml-text-node 'js2-printer 'js2-print-xml-text-node)
+
+(defun js2-visit-xml-text-node (n v)
+  (js2-visit-ast (js2-xml-text-node-content n) v))
+
+(defun js2-print-xml-text-node (n i)
+  (insert (js2-make-pad i))
+  (dolist (kid (js2-xml-text-node-content n))
+    (js2-print-ast kid)))
+
+(defstruct (js2-xml-comment-node
+            (:include js2-xml-node)
+            (:constructor nil)
+            (:constructor make-js2-xml-comment-node (&key (type js2-XML)
+                                                          (pos js2-ts-cursor)
+                                                          len)))
+  "AST node for E4X XML comment.  Not currently used.")
+
+(put 'cl-struct-js2-xml-comment-node 'js2-visitor 'js2-visit-none)
+(put 'cl-struct-js2-xml-comment-node 'js2-printer 'js2-print-xml-comment)
+
+(defun js2-print-xml-comment (n i)
+  (insert (js2-make-pad i)
+          (js2-node-string n)))
+
+;;; Node utilities
+
+(defsubst js2-node-line (n)
+  "Fetch the source line number at the start of node N.
+This is O(n) in the length of the source buffer; use prudently."
+  (1+ (count-lines (point-min) (js2-node-abs-pos n))))
+
+(defsubst js2-block-node-kid (n i)
+  "Return child I of node N, or nil if there aren't that many."
+  (nth i (js2-block-node-kids n)))
+
+(defsubst js2-block-node-first (n)
+  "Return first child of block node N, or nil if there is none."
+  (first (js2-block-node-kids n)))
+
+(defun js2-node-root (n)
+  "Return the root of the AST containing N.
+If N has no parent pointer, returns N."
+  (let ((parent (js2-node-parent n)))
+    (if parent
+        (js2-node-root parent)
+      n)))
+
+(defun js2-node-position-in-parent (node &optional parent)
+  "Return the position of NODE in parent's block-kids list.
+PARENT can be supplied if known.  Positioned returned is zero-indexed.
+Returns 0 if NODE is not a child of a block statement, or if NODE
+is not a statement node."
+  (let ((p (or parent (js2-node-parent node)))
+        (i 0))
+    (if (not (js2-block-node-p p))
+        i
+      (or (js2-position node (js2-block-node-kids p))
+          0))))
+
+(defsubst js2-node-short-name (n)
+  "Return the short name of node N as a string, e.g. `js2-if-node'."
+  (substring (symbol-name (aref n 0))
+             (length "cl-struct-")))
+
+(defsubst js2-node-child-list (node)
+  "Return the child list for NODE, a lisp list of nodes.
+Works for block nodes, array nodes, obj literals, funarg lists,
+var decls and try nodes (for catch clauses).  Note that you should call
+`js2-block-node-kids' on the function body for the body statements.
+Returns nil for zero-length child lists or unsupported nodes."
+  (cond
+   ((js2-function-node-p node)
+    (js2-function-node-params node))
+   ((js2-block-node-p node)
+    (js2-block-node-kids node))
+   ((js2-try-node-p node)
+    (js2-try-node-catch-clauses node))
+   ((js2-array-node-p node)
+    (js2-array-node-elems node))
+   ((js2-object-node-p node)
+    (js2-object-node-elems node))
+   ((js2-call-node-p node)
+    (js2-call-node-args node))
+   ((js2-new-node-p node)
+    (js2-new-node-args node))
+   ((js2-var-decl-node-p node)
+    (js2-var-decl-node-kids node))
+   (t
+    nil)))
+
+(defsubst js2-node-set-child-list (node kids)
+  "Set the child list for NODE to KIDS."
+   (cond
+    ((js2-function-node-p node)
+     (setf (js2-function-node-params node) kids))
+    ((js2-block-node-p node)
+     (setf (js2-block-node-kids node) kids))
+    ((js2-try-node-p node)
+     (setf (js2-try-node-catch-clauses node) kids))
+    ((js2-array-node-p node)
+     (setf (js2-array-node-elems node) kids))
+    ((js2-object-node-p node)
+     (setf (js2-object-node-elems node) kids))
+    ((js2-call-node-p node)
+     (setf (js2-call-node-args node) kids))
+    ((js2-new-node-p node)
+     (setf (js2-new-node-args node) kids))
+    ((js2-var-decl-node-p node)
+     (setf (js2-var-decl-node-kids node) kids))
+    (t
+     (error "Unsupported node type: %s" (js2-node-short-name node))))
+   kids)
+
+;; All because Common Lisp doesn't support multiple inheritance for defstructs.
+(defconst js2-paren-expr-nodes
+  '(cl-struct-js2-array-comp-loop-node
+    cl-struct-js2-array-comp-node
+    cl-struct-js2-call-node
+    cl-struct-js2-catch-node
+    cl-struct-js2-do-node
+    cl-struct-js2-elem-get-node
+    cl-struct-js2-for-in-node
+    cl-struct-js2-for-node
+    cl-struct-js2-function-node
+    cl-struct-js2-if-node
+    cl-struct-js2-let-node
+    cl-struct-js2-new-node
+    cl-struct-js2-paren-node
+    cl-struct-js2-switch-node
+    cl-struct-js2-while-node
+    cl-struct-js2-with-node
+    cl-struct-js2-xml-dot-query-node)
+  "Node types that can have a parenthesized child expression.
+In particular, nodes that respond to `js2-node-lp' and `js2-node-rp'.")
+
+(defsubst js2-paren-expr-node-p (node)
+  "Return t for nodes that typically have a parenthesized child expression.
+Useful for computing the indentation anchors for arg-lists and conditions.
+Note that it may return a false positive, for instance when NODE is
+a `js2-new-node' and there are no arguments or parentheses."
+  (memq (aref node 0) js2-paren-expr-nodes))
+
+;; Fake polymorphism... yech.
+(defsubst js2-node-lp (node)
+  "Return relative left-paren position for NODE, if applicable.
+For `js2-elem-get-node' structs, returns left-bracket position.
+Note that the position may be nil in the case of a parse error."
+  (cond
+   ((js2-elem-get-node-p node)
+    (js2-elem-get-node-lb node))
+   ((js2-loop-node-p node)
+    (js2-loop-node-lp node))
+   ((js2-function-node-p node)
+    (js2-function-node-lp node))
+   ((js2-if-node-p node)
+    (js2-if-node-lp node))
+   ((js2-new-node-p node)
+    (js2-new-node-lp node))
+   ((js2-call-node-p node)
+    (js2-call-node-lp node))
+   ((js2-paren-node-p node)
+    (js2-node-pos node))
+   ((js2-switch-node-p node)
+    (js2-switch-node-lp node))
+   ((js2-catch-node-p node)
+    (js2-catch-node-lp node))
+   ((js2-let-node-p node)
+    (js2-let-node-lp node))
+   ((js2-array-comp-node-p node)
+    (js2-array-comp-node-lp node))
+   ((js2-with-node-p node)
+    (js2-with-node-lp node))
+   ((js2-xml-dot-query-node-p node)
+    (1+ (js2-infix-node-op-pos node)))
+   (t
+    (error "Unsupported node type: %s" (js2-node-short-name node)))))
+
+;; Fake polymorphism... blech.
+(defsubst js2-node-rp (node)
+  "Return relative right-paren position for NODE, if applicable.
+For `js2-elem-get-node' structs, returns right-bracket position.
+Note that the position may be nil in the case of a parse error."
+  (cond
+   ((js2-elem-get-node-p node)
+    (js2-elem-get-node-lb node))
+   ((js2-loop-node-p node)
+    (js2-loop-node-rp node))
+   ((js2-function-node-p node)
+    (js2-function-node-rp node))
+   ((js2-if-node-p node)
+    (js2-if-node-rp node))
+   ((js2-new-node-p node)
+    (js2-new-node-rp node))
+   ((js2-call-node-p node)
+    (js2-call-node-rp node))
+   ((js2-paren-node-p node)
+    (+ (js2-node-pos node) (js2-node-len node)))
+   ((js2-switch-node-p node)
+    (js2-switch-node-rp node))
+   ((js2-catch-node-p node)
+    (js2-catch-node-rp node))
+   ((js2-let-node-p node)
+    (js2-let-node-rp node))
+   ((js2-array-comp-node-p node)
+    (js2-array-comp-node-rp node))
+   ((js2-with-node-p node)
+    (js2-with-node-rp node))
+   ((js2-xml-dot-query-node-p node)
+    (1+ (js2-xml-dot-query-node-rp node)))
+   (t
+    (error "Unsupported node type: %s" (js2-node-short-name node)))))
+
+(defsubst js2-node-first-child (node)
+  "Returns the first element of `js2-node-child-list' for NODE."
+  (car (js2-node-child-list node)))
+
+(defsubst js2-node-last-child (node)
+  "Returns the last element of `js2-node-last-child' for NODE."
+  (car (last (js2-node-child-list node))))
+
+(defun js2-node-prev-sibling (node)
+  "Return the previous statement in parent.
+Works for parents supported by `js2-node-child-list'.
+Returns nil if NODE is not in the parent, or PARENT is
+not a supported node, or if NODE is the first child."
+  (let* ((p (js2-node-parent node))
+         (kids (js2-node-child-list p))
+         (sib (car kids)))
+    (while (and kids
+                (neq node (cadr kids)))
+      (setq kids (cdr kids)
+            sib (car kids)))
+    sib))
+
+(defun js2-node-next-sibling (node)
+  "Return the next statement in parent block.
+Returns nil if NODE is not in the block, or PARENT is not
+a block node, or if NODE is the last statement."
+  (let* ((p (js2-node-parent node))
+         (kids (js2-node-child-list p)))
+    (while (and kids
+                (neq node (car kids)))
+      (setq kids (cdr kids)))
+    (cadr kids)))
+
+(defun js2-node-find-child-before (pos parent &optional after)
+  "Find the last child that starts before POS in parent.
+If AFTER is non-nil, returns first child starting after POS.
+POS is an absolute buffer position.  PARENT is any node
+supported by `js2-node-child-list'.
+Returns nil if no applicable child is found."
+  (let ((kids (if (js2-function-node-p parent)
+                  (js2-block-node-kids (js2-function-node-body parent))
+                (js2-node-child-list parent)))
+        (beg (if (js2-function-node-p parent)
+                 (js2-node-abs-pos (js2-function-node-body parent))
+               (js2-node-abs-pos parent)))
+        kid
+        result
+        fn
+        (continue t))
+    (setq fn (if after '> '<))
+    (while (and kids continue)
+      (setq kid (car kids))
+      (if (funcall fn (+ beg (js2-node-pos kid)) pos)
+          (setq result kid
+                continue (if after nil t))
+        (setq continue (if after t nil)))
+      (setq kids (cdr kids)))
+    result))
+
+(defun js2-node-find-child-after (pos parent)
+  "Find first child that starts after POS in parent.
+POS is an absolute buffer position.  PARENT is any node
+supported by `js2-node-child-list'.
+Returns nil if no applicable child is found."
+  (js2-node-find-child-before pos parent 'after))
+
+(defun js2-node-replace-child (pos parent new-node)
+  "Replace node at index POS in PARENT with NEW-NODE.
+Only works for parents supported by `js2-node-child-list'."
+  (let ((kids (js2-node-child-list parent))
+        (i 0))
+    (while (< i pos)
+      (setq kids (cdr kids)
+            i (1+ i)))
+    (setcar kids new-node)
+    (js2-node-add-children parent new-node)))
+
+(defun js2-node-buffer (n)
+  "Return the buffer associated with AST N.
+Returns nil if the buffer is not set as a property on the root
+node, or if parent links were not recorded during parsing."
+  (let ((root (js2-node-root n)))
+    (and root
+         (js2-ast-root-p root)
+         (js2-ast-root-buffer root))))
+
+(defsubst js2-block-node-push (n kid)
+  "Push js2-node KID onto the end of js2-block-node N's child list.
+KID is always added to the -end- of the kids list.
+Function also calls `js2-node-add-children' to add the parent link."
+  (let ((kids (js2-node-child-list n)))
+    (if kids
+        (setcdr kids (nconc (cdr kids) (list kid)))
+      (js2-node-set-child-list n (list kid)))
+    (js2-node-add-children n kid)))
+
+(defun js2-node-string (node)
+  (let ((buf (js2-node-buffer node))
+        pos)
+    (unless buf
+      (error "No buffer available for node %s" node))
+    (save-excursion
+      (set-buffer buf)
+      (buffer-substring-no-properties (setq pos (js2-node-abs-pos node))
+                                      (+ pos (js2-node-len node))))))
+
+;; Container for storing the node we're looking for in a traversal.
+(defvar js2-discovered-node nil)
+(make-variable-buffer-local 'js2-discovered-node)
+
+;; Keep track of absolute node position during traversals.
+(defvar js2-visitor-offset nil)
+(make-variable-buffer-local 'js2-visitor-offset)
+
+(defvar js2-node-search-point nil)
+(make-variable-buffer-local 'js2-node-search-point)
+
+(when js2-mode-dev-mode-p
+  (defun js2-find-node-at-point ()
+    (interactive)
+    (let ((node (js2-node-at-point)))
+      (message "%s" (or node "No node found at point"))))
+  (defun js2-node-name-at-point ()
+    (interactive)
+    (let ((node (js2-node-at-point)))
+      (message "%s" (if node
+                        (js2-node-short-name node)
+                      "No node found at point.")))))
+
+(defun js2-node-at-point (&optional pos skip-comments)
+  "Return AST node at POS, a buffer position, defaulting to current point.
+The `js2-mode-ast' variable must be set to the current parse tree.
+Signals an error if the AST (`js2-mode-ast') is nil.
+Always returns a node - if it can't find one, it returns the root.
+If SKIP-COMMENTS is non-nil, comment nodes are ignored."
+  (let ((ast js2-mode-ast)
+        result)
+    (unless ast
+      (error "No JavaScript AST available"))
+    ;; Look through comments first, since they may be inside nodes that
+    ;; would otherwise report a match.
+    (setq pos (or pos (point))
+          result (if (> pos (js2-node-abs-end ast))
+                     ast
+                   (if (not skip-comments)
+                       (js2-comment-at-point pos))))
+    (unless result
+      (setq js2-discovered-node nil
+            js2-visitor-offset 0
+            js2-node-search-point pos)
+      (unwind-protect
+          (catch 'js2-visit-done
+            (js2-visit-ast ast #'js2-node-at-point-visitor))
+        (setq js2-visitor-offset nil
+              js2-node-search-point nil))
+      (setq result js2-discovered-node))
+    ;; may have found a comment beyond end of last child node,
+    ;; since visiting the ast-root looks at the comment-list last.
+    (if (and skip-comments
+             (js2-comment-node-p result))
+        (setq result nil))
+    (or result js2-mode-ast)))
+
+(defun js2-node-at-point-visitor (node end-p)
+  (let ((rel-pos (js2-node-pos node))
+        abs-pos
+        abs-end
+        (point js2-node-search-point))
+    (cond
+     (end-p
+      ;; this evaluates to a non-nil return value, even if it's zero
+      (decf js2-visitor-offset rel-pos))
+     ;; we already looked for comments before visiting, and don't want them now
+     ((js2-comment-node-p node)
+      nil)
+     (t
+      (setq abs-pos (incf js2-visitor-offset rel-pos)
+            ;; we only want to use the node if the point is before
+            ;; the last character position in the node, so we decrement
+            ;; the absolute end by 1.
+            abs-end (+ abs-pos (js2-node-len node) -1))
+      (cond
+       ;; If this node starts after search-point, stop the search.
+       ((> abs-pos point)
+        (throw 'js2-visit-done nil))
+       ;; If this node ends before the search-point, don't check kids.
+       ((> point abs-end)
+        nil)
+       (t
+        ;; Otherwise point is within this node, possibly in a child.
+        (setq js2-discovered-node node)
+        t))))))  ; keep processing kids to look for more specific match
+
+(defsubst js2-block-comment-p (node)
+  "Return non-nil if NODE is a comment node of format `jsdoc' or `block'."
+  (and (js2-comment-node-p node)
+       (memq (js2-comment-node-format node) '(jsdoc block))))
+
+;; TODO:  put the comments in a vector and binary-search them instead
+(defun js2-comment-at-point (&optional pos)
+  "Look through scanned comment nodes for one containing POS.
+POS is a buffer position that defaults to current point.
+Function returns nil if POS was not in any comment node."
+  (let ((ast js2-mode-ast)
+        (x (or pos (point)))
+        beg
+        end)
+    (unless ast
+      (error "No JavaScript AST available"))
+    (catch 'done
+      ;; Comments are stored in lexical order.
+      (dolist (comment (js2-ast-root-comments ast) nil)
+        (setq beg (js2-node-abs-pos comment)
+              end (+ beg (js2-node-len comment)))
+        (if (and (>= x beg)
+                 (<= x end))
+            (throw 'done comment))))))
+
+(defun js2-mode-find-parent-fn (node)
+  "Find function enclosing NODE.
+Returns nil if NODE is not inside a function."
+  (setq node (js2-node-parent node))
+  (while (and node (not (js2-function-node-p node)))
+    (setq node (js2-node-parent node)))
+  (and (js2-function-node-p node) node))
+
+(defun js2-mode-find-enclosing-fn (node)
+  "Find function or root enclosing NODE."
+  (if (js2-ast-root-p node)
+      node
+    (setq node (js2-node-parent node))
+    (while (not (or (js2-ast-root-p node)
+                    (js2-function-node-p node)))
+      (setq node (js2-node-parent node)))
+    node))
+
+(defun js2-mode-find-enclosing-node (beg end)
+  "Find script or function fully enclosing BEG and END."
+  (let ((node (js2-node-at-point beg))
+        pos
+        (continue t))
+    (while continue
+      (if (or (js2-ast-root-p node)
+              (and (js2-function-node-p node)
+                   (<= (setq pos (js2-node-abs-pos node)) beg)
+                   (>= (+ pos (js2-node-len node)) end)))
+          (setq continue nil)
+        (setq node (js2-node-parent node))))
+    node))
+
+(defun js2-node-parent-script-or-fn (node)
+  "Find script or function immediately enclosing NODE.
+If NODE is the ast-root, returns nil."
+  (if (js2-ast-root-p node)
+      nil
+    (setq node (js2-node-parent node))
+    (while (and node (not (or (js2-function-node-p node)
+                              (js2-script-node-p node))))
+      (setq node (js2-node-parent node)))
+    node))
+
+(defsubst js2-nested-function-p (node)
+  "Return t if NODE is a nested function, or is inside a nested function."
+  (js2-function-node-p (if (js2-function-node-p node)
+                           (js2-node-parent-script-or-fn node)
+                         (js2-node-parent-script-or-fn
+                          (js2-node-parent-script-or-fn node)))))
+
+(defsubst js2-mode-shift-kids (kids start offset)
+  (dolist (kid kids)
+    (if (> (js2-node-pos kid) start)
+        (incf (js2-node-pos kid) offset))))
+
+(defsubst js2-mode-shift-children (parent start offset)
+  "Update start-positions of all children of PARENT beyond START."
+  (let ((root (js2-node-root parent)))
+    (js2-mode-shift-kids (js2-node-child-list parent) start offset)
+    (js2-mode-shift-kids (js2-ast-root-comments root) start offset)))
+
+(defsubst js2-node-is-descendant (node ancestor)
+  "Return t if NODE is a descendant of ANCESTOR."
+  (while (and node
+              (neq node ancestor))
+    (setq node (js2-node-parent node)))
+  node)
+
+;;; visitor infrastructure
+
+(defun js2-visit-none (node callback)
+  "Visitor for AST node that have no node children."
+  nil)
+
+(defun js2-print-none (node indent)
+  "Visitor for AST node with no printed representation.")
+
+(defun js2-print-body (node indent)
+  "Print a statement, or a block without braces."
+  (if (js2-block-node-p node)
+      (dolist (kid (js2-block-node-kids node))
+        (js2-print-ast kid indent))
+    (js2-print-ast node indent)))
+
+(defun js2-print-list (args &optional delimiter)
+  (loop with len = (length args)
+        for arg in args
+        for count from 1
+        do
+        (js2-print-ast arg 0)
+        (if (< count len)
+            (insert (or delimiter ", ")))))
+
+(defun js2-print-tree (ast)
+  "Prints an AST to the current buffer.
+Makes `js2-ast-parent-nodes' available to the printer functions."
+  (let ((max-lisp-eval-depth (max max-lisp-eval-depth 1500)))
+    (js2-print-ast ast)))
+
+(defun js2-print-ast (node &optional indent)
+  "Helper function for printing AST nodes.
+Requires `js2-ast-parent-nodes' to be non-nil.
+You should use `js2-print-tree' instead of this function."
+  (let ((printer (get (aref node 0) 'js2-printer))
+        (i (or indent 0))
+        (pos (js2-node-abs-pos node)))
+    ;; TODO:  wedge comments in here somewhere
+    (if printer
+        (funcall printer node i))))
+
+(defconst js2-side-effecting-tokens
+  (let ((tokens (make-bool-vector js2-num-tokens nil)))
+    (dolist (tt (list js2-ASSIGN
+                      js2-ASSIGN_ADD
+                      js2-ASSIGN_BITAND
+                      js2-ASSIGN_BITOR
+                      js2-ASSIGN_BITXOR
+                      js2-ASSIGN_DIV
+                      js2-ASSIGN_LSH
+                      js2-ASSIGN_MOD
+                      js2-ASSIGN_MUL
+                      js2-ASSIGN_RSH
+                      js2-ASSIGN_SUB
+                      js2-ASSIGN_URSH
+                      js2-BLOCK
+                      js2-BREAK
+                      js2-CALL
+                      js2-CATCH
+                      js2-CATCH_SCOPE
+                      js2-CONST
+                      js2-CONTINUE
+                      js2-DEBUGGER
+                      js2-DEC
+                      js2-DELPROP
+                      js2-DEL_REF
+                      js2-DO
+                      js2-ELSE
+                      js2-EMPTY
+                      js2-ENTERWITH
+                      js2-EXPORT
+                      js2-EXPR_RESULT
+                      js2-FINALLY
+                      js2-FOR
+                      js2-FUNCTION
+                      js2-GOTO
+                      js2-IF
+                      js2-IFEQ
+                      js2-IFNE
+                      js2-IMPORT
+                      js2-INC
+                      js2-JSR
+                      js2-LABEL
+                      js2-LEAVEWITH
+                      js2-LET
+                      js2-LETEXPR
+                      js2-LOCAL_BLOCK
+                      js2-LOOP
+                      js2-NEW
+                      js2-REF_CALL
+                      js2-RETHROW
+                      js2-RETURN
+                      js2-RETURN_RESULT
+                      js2-SEMI
+                      js2-SETELEM
+                      js2-SETELEM_OP
+                      js2-SETNAME
+                      js2-SETPROP
+                      js2-SETPROP_OP
+                      js2-SETVAR
+                      js2-SET_REF
+                      js2-SET_REF_OP
+                      js2-SWITCH
+                      js2-TARGET
+                      js2-THROW
+                      js2-TRY
+                      js2-VAR
+                      js2-WHILE
+                      js2-WITH
+                      js2-WITHEXPR
+                      js2-YIELD))
+      (aset tokens tt t))
+    (if js2-instanceof-has-side-effects
+        (aset tokens js2-INSTANCEOF t))
+    tokens))
+
+(defun js2-node-has-side-effects (node)
+  "Return t if NODE has side effects."
+  (when node  ; makes it easier to handle malformed expressions
+    (let ((tt (js2-node-type node)))
+      (cond
+       ;; This doubtless needs some work, since EXPR_VOID is used
+       ;; in several ways in Rhino, and I may not have caught them all.
+       ;; I'll wait for people to notice incorrect warnings.
+       ((and (= tt js2-EXPR_VOID)
+             (js2-expr-stmt-node-p node)) ; but not if EXPR_RESULT
+        (js2-node-has-side-effects (js2-expr-stmt-node-expr node)))
+       ((= tt js2-COMMA)
+        (js2-node-has-side-effects (js2-infix-node-right node)))
+       ((or (= tt js2-AND)
+            (= tt js2-OR))
+        (or (js2-node-has-side-effects (js2-infix-node-right node))
+            (js2-node-has-side-effects (js2-infix-node-left node))))
+       ((= tt js2-HOOK)
+        (and (js2-node-has-side-effects (js2-cond-node-true-expr node))
+             (js2-node-has-side-effects (js2-cond-node-false-expr node))))
+       ((js2-paren-node-p node)
+        (js2-node-has-side-effects (js2-paren-node-expr node)))
+       ((= tt js2-ERROR) ; avoid cascaded error messages
+        nil)
+       (t
+        (aref js2-side-effecting-tokens tt))))))
+
+(defun js2-member-expr-leftmost-name (node)
+  "For an expr such as foo.bar.baz, return leftmost node foo.
+NODE is any `js2-node' object.  If it represents a member expression,
+which is any sequence of property gets, element-gets, function calls,
+or xml descendants/filter operators, then we look at the lexically
+leftmost (first) node in the chain.  If it is a name-node we return it.
+Note that NODE can be a raw name-node and it will be returned as well.
+If NODE is not a name-node or member expression, or if it is a member
+expression whose leftmost target is not a name node, returns nil."
+  (let ((continue t)
+        result)
+    (while (and continue (not result))
+      (cond
+       ((js2-name-node-p node)
+        (setq result node))
+       ((js2-prop-get-node-p node)
+        (setq node (js2-prop-get-node-left node)))
+       ;; TODO:  handle call-nodes, xml-nodes, others?
+       (t
+        (setq continue nil))))
+    result))
+
+(defconst js2-stmt-node-types
+  (list js2-BLOCK
+        js2-BREAK
+        js2-CONTINUE
+        js2-DEFAULT  ; e4x "default xml namespace" statement
+        js2-DO
+        js2-EXPR_RESULT
+        js2-EXPR_VOID
+        js2-FOR
+        js2-IF
+        js2-RETURN
+        js2-SWITCH
+        js2-THROW
+        js2-TRY
+        js2-WHILE
+        js2-WITH)
+  "Node types that only appear in statement contexts.
+The list does not include nodes that always appear as the child
+of another specific statement type, such as switch-cases,
+catch and finally blocks, and else-clauses.  The list also excludes
+nodes like yield, let and var, which may appear in either expression
+or statement context, and in the latter context always have a
+`js2-expr-stmt-node' parent.  Finally, the list does not include
+functions or scripts, which are treated separately from statements
+by the JavaScript parser and runtime.")
+
+(defun js2-stmt-node-p (node)
+  "Heuristic for figuring out if NODE is a statement.
+Some node types can appear in either an expression context or a
+statement context, e.g. let-nodes, yield-nodes, and var-decl nodes.
+For these node types in a statement context, the parent will be a
+`js2-expr-stmt-node'.
+Functions aren't included in the check."
+  (memq (js2-node-type node) js2-stmt-node-types))
+
+(defsubst js2-mode-find-first-stmt (node)
+  "Search upward starting from NODE looking for a statement.
+For purposes of this function, a `js2-function-node' counts."
+  (while (not (or (js2-stmt-node-p node)
+                  (js2-function-node-p node)))
+    (setq node (js2-node-parent node)))
+  node)
+
+(defun js2-node-parent-stmt (node)
+  "Return the node's first ancestor that is a statement.
+Returns nil if NODE is a `js2-ast-root'.  Note that any expression
+appearing in a statement context will have a parent that is a
+`js2-expr-stmt-node' that will be returned by this function."
+  (let ((parent (js2-node-parent node)))
+    (if (or (null parent)
+            (js2-stmt-node-p parent)
+            (and (js2-function-node-p parent)
+                 (neq (js2-function-node-form parent) 'FUNCTION_EXPRESSION)))
+        parent
+      (js2-node-parent-stmt parent))))
+
+;; Roshan James writes:
+;;  Does consistent-return analysis on the function body when strict mode is
+;;  enabled.
+;;
+;;    function (x) { return (x+1) }
+;;
+;;  is ok, but
+;;
+;;    function (x) { if (x < 0) return (x+1); }
+;;
+;;  is not because the function can potentially return a value when the
+;;  condition is satisfied and if not, the function does not explicitly
+;;  return a value.
+;;
+;;  This extends to checking mismatches such as "return" and "return <value>"
+;;  used in the same function. Warnings are not emitted if inconsistent
+;;  returns exist in code that can be statically shown to be unreachable.
+;;  Ex.
+;;    function (x) { while (true) { ... if (..) { return value } ... } }
+;;
+;;  emits no warning. However if the loop had a break statement, then a
+;;  warning would be emitted.
+;;
+;;  The consistency analysis looks at control structures such as loops, ifs,
+;;  switch, try-catch-finally blocks, examines the reachable code paths and
+;;  warns the user about an inconsistent set of termination possibilities.
+;;
+;;  These flags enumerate the possible ways a statement/function can
+;;  terminate. These flags are used by endCheck() and by the Parser to
+;;  detect inconsistent return usage.
+;;
+;;  END_UNREACHED is reserved for code paths that are assumed to always be
+;;  able to execute (example: throw, continue)
+;;
+;;  END_DROPS_OFF indicates if the statement can transfer control to the
+;;  next one. Statement such as return dont. A compound statement may have
+;;  some branch that drops off control to the next statement.
+;;
+;;  END_RETURNS indicates that the statement can return with no value.
+;;  END_RETURNS_VALUE indicates that the statement can return a value.
+;;
+;;  A compound statement such as
+;;  if (condition) {
+;;    return value;
+;;  }
+;;  Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck()
+
+(defconst js2-END_UNREACHED 0)
+(defconst js2-END_DROPS_OFF 1)
+(defconst js2-END_RETURNS 2)
+(defconst js2-END_RETURNS_VALUE 4)
+(defconst js2-END_YIELDS 8)
+
+(defun js2-has-consistent-return-usage (node)
+  "Check that every return usage in a function body is consistent.
+Returns t if the function satisfies strict mode requirement."
+  (let ((n (js2-end-check node)))
+    ;; either it doesn't return a value in any branch...
+    (or (js2-flag-not-set-p n js2-END_RETURNS_VALUE)
+        ;; or it returns a value (or is unreached) at every branch
+        (js2-flag-not-set-p n (logior js2-END_DROPS_OFF
+                                      js2-END_RETURNS
+                                      js2-END_YIELDS)))))
+
+(defun js2-end-check-if (node)
+  "Returns in the then and else blocks must be consistent with each other.
+If there is no else block, then the return statement can fall through.
+Returns logical OR of END_* flags"
+  (let ((th (js2-if-node-then-part node))
+        (el (js2-if-node-else-part node)))
+    (if (null th)
+        js2-END_UNREACHED
+      (logior (js2-end-check th) (if el
+                                     (js2-end-check el)
+                                   js2-END_DROPS_OFF)))))
+
+(defun js2-end-check-switch (node)
+  "Consistency of return statements is checked between the case statements.
+If there is no default, then the switch can fall through. If there is a
+default, we check to see if all code paths in the default return or if
+there is a code path that can fall through.
+Returns logical OR of END_* flags."
+  (let ((rv js2-END_UNREACHED)
+        default-case)
+    ;; examine the cases
+    (catch 'break
+      (dolist (c (js2-switch-node-cases node))
+        (if (js2-case-node-expr c)
+            (js2-set-flag rv (js2-end-check-block c))
+          (setq default-case c)
+          (throw 'break nil))))
+    ;; we don't care how the cases drop into each other
+    (js2-clear-flag rv js2-END_DROPS_OFF)
+    ;; examine the default
+    (js2-set-flag rv (if default-case
+                         (js2-end-check default-case)
+                       js2-END_DROPS_OFF))
+    rv))
+
+(defun js2-end-check-try (node)
+ "If the block has a finally, return consistency is checked in the
+finally block. If all code paths in the finally return, then the
+returns in the try-catch blocks don't matter. If there is a code path
+that does not return or if there is no finally block, the returns
+of the try and catch blocks are checked for mismatch.
+Returns logical OR of END_* flags."
+ (let ((finally (js2-try-node-finally-block node))
+       rv)
+   ;; check the finally if it exists
+   (setq rv (if finally
+                (js2-end-check (js2-finally-node-body finally))
+              js2-END_DROPS_OFF))
+   ;; If the finally block always returns, then none of the returns
+   ;; in the try or catch blocks matter.
+   (when (js2-flag-set-p rv js2-END_DROPS_OFF)
+     (js2-clear-flag rv js2-END_DROPS_OFF)
+     ;; examine the try block
+     (js2-set-flag rv (js2-end-check (js2-try-node-try-block node)))
+     ;; check each catch block
+     (dolist (cb (js2-try-node-catch-clauses node))
+       (js2-set-flag rv (js2-end-check (js2-catch-node-block cb)))))
+   rv))
+
+(defun js2-end-check-loop (node)
+  "Return statement in the loop body must be consistent. The default
+assumption for any kind of a loop is that it will eventually terminate.
+The only exception is a loop with a constant true condition. Code that
+follows such a loop is examined only if one can statically determine
+that there is a break out of the loop.
+
+    for(... ; ... ; ...) {}
+    for(... in ... ) {}
+    while(...) { }
+    do { } while(...)
+
+Returns logical OR of END_* flags."
+  (let ((rv (js2-end-check (js2-loop-node-body node)))
+        (condition (cond
+                    ((js2-while-node-p node)
+                     (js2-while-node-condition node))
+                     ((js2-do-node-p node)
+                      (js2-do-node-condition node))
+                     ((js2-for-node-p node)
+                      (js2-for-node-condition node)))))
+
+    ;; check to see if the loop condition is always true
+    (if (and condition
+             (eq (js2-always-defined-boolean-p condition) 'ALWAYS_TRUE))
+        (js2-clear-flag rv js2-END_DROPS_OFF))
+
+    ;; look for effect of breaks
+    (js2-set-flag rv (js2-node-get-prop node
+                                        'CONTROL_BLOCK_PROP
+                                        js2-END_UNREACHED))
+    rv))
+
+(defun js2-end-check-block (node)
+  "A general block of code is examined statement by statement.
+If any statement (even a compound one) returns in all branches, then
+subsequent statements are not examined.
+Returns logical OR of END_* flags."
+  (let* ((rv js2-END_DROPS_OFF)
+         (kids (js2-block-node-kids node))
+         (n (car kids)))
+    ;; Check each statment.  If the statement can continue onto the next
+    ;; one (i.e. END_DROPS_OFF is set), then check the next statement.
+    (while (and n (js2-flag-set-p rv js2-END_DROPS_OFF))
+      (js2-clear-flag rv js2-END_DROPS_OFF)
+      (js2-set-flag rv (js2-end-check n))
+      (setq kids (cdr kids)
+            n (car kids)))
+    rv))
+
+(defun js2-end-check-label (node)
+  "A labeled statement implies that there may be a break to the label.
+The function processes the labeled statement and then checks the
+CONTROL_BLOCK_PROP property to see if there is ever a break to the
+particular label.
+Returns logical OR of END_* flags."
+  (let ((rv (js2-end-check (js2-labeled-stmt-node-stmt node))))
+    (logior rv (js2-node-get-prop node
+                                  'CONTROL_BLOCK_PROP
+                                  js2-END_UNREACHED))))
+
+(defun js2-end-check-break (node)
+  "When a break is encountered annotate the statement being broken
+out of by setting its CONTROL_BLOCK_PROP property.
+Returns logical OR of END_* flags."
+  (and (js2-break-node-target node)
+       (js2-node-set-prop (js2-break-node-target node)
+                          'CONTROL_BLOCK_PROP
+                          js2-END_DROPS_OFF))
+  js2-END_UNREACHED)
+
+(defun js2-end-check (node)
+  "Examine the body of a function, doing a basic reachability analysis.
+Returns a combination of flags END_* flags that indicate
+how the function execution can terminate. These constitute only the
+pessimistic set of termination conditions. It is possible that at
+runtime certain code paths will never be actually taken. Hence this
+analysis will flag errors in cases where there may not be errors.
+Returns logical OR of END_* flags"
+  (let (kid)
+    (cond
+     ((js2-break-node-p node)
+      (js2-end-check-break node))
+     ((js2-expr-stmt-node-p node)
+      (if (setq kid (js2-expr-stmt-node-expr node))
+          (js2-end-check kid)
+        js2-END_DROPS_OFF))
+     ((or (js2-continue-node-p node)
+          (js2-throw-node-p node))
+      js2-END_UNREACHED)
+     ((js2-return-node-p node)
+      (if (setq kid (js2-return-node-retval node))
+          js2-END_RETURNS_VALUE
+        js2-END_RETURNS))
+     ((js2-loop-node-p node)
+      (js2-end-check-loop node))
+     ((js2-switch-node-p node)
+      (js2-end-check-switch node))
+     ((js2-labeled-stmt-node-p node)
+      (js2-end-check-label node))
+     ((js2-if-node-p node)
+      (js2-end-check-if node))
+     ((js2-try-node-p node)
+      (js2-end-check-try node))
+     ((js2-block-node-p node)
+      (if (null (js2-block-node-kids node))
+          js2-END_DROPS_OFF
+        (js2-end-check-block node)))
+     ((js2-yield-node-p node)
+      js2-END_YIELDS)
+     (t
+      js2-END_DROPS_OFF))))
+
+(defun js2-always-defined-boolean-p (node)
+  "Check if NODE always evaluates to true or false in boolean context.
+Returns 'ALWAYS_TRUE, 'ALWAYS_FALSE, or nil if it's neither always true
+nor always false."
+  (let ((tt (js2-node-type node))
+        num)
+    (cond
+     ((or (= tt js2-FALSE) (= tt js2-NULL))
+      'ALWAYS_FALSE)
+     ((= tt js2-TRUE)
+      'ALWAYS_TRUE)
+     ((= tt js2-NUMBER)
+      (setq num (js2-number-node-num-value node))
+      (if (and (not (eq num 0.0e+NaN))
+               (not (zerop num)))
+          'ALWAYS_TRUE
+        'ALWAYS_FALSE))
+     (t
+      nil))))
+
+(provide 'js2-ast)
+
+;;; js2-ast.el ends here
+;;; js2-highlight.el --- JavaScript syntax coloring support
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;;; Code:
+
+
+(defsubst js2-set-face (beg end face &optional record)
+  "Fontify a region.  If RECORD is non-nil, record for later."
+  (when (plusp js2-highlight-level)
+    (setq beg (min (point-max) beg)
+          beg (max (point-min) beg)
+          end (min (point-max) end)
+          end (max (point-min) end))
+    (if record
+        (push (list beg end face) js2-mode-fontifications)
+      (put-text-property beg end 'face face))))
+
+(defsubst js2-set-kid-face (pos kid len face)
+  "Set-face on a child node.
+POS is absolute buffer position of parent.
+KID is the child node.
+LEN is the length to fontify.
+FACE is the face to fontify with."
+  (js2-set-face (+ pos (js2-node-pos kid))
+                (+ pos (js2-node-pos kid) (js2-node-len kid))
+                face))
+
+(defsubst js2-fontify-kwd (start length)
+  (js2-set-face start (+ start length) 'font-lock-keyword-face))
+
+(defsubst js2-clear-face (beg end)
+  (remove-text-properties beg end '(face nil
+                                    help-echo nil
+                                    point-entered nil
+                                    c-in-sws nil)))
+
+(defsubst js2-record-text-property (beg end prop value)
+  "Record a text property to set when parsing finishes."
+  (push (list beg end prop value) js2-mode-deferred-properties))
+
+(defconst js2-ecma-global-props
+  (concat "^"
+          (regexp-opt
+           '("Infinity" "NaN" "undefined" "arguments") t)
+          "$")
+  "Value properties of the Ecma-262 Global Object.
+Shown at or above `js2-highlight-level' 2.")
+
+;; might want to add the name "arguments" to this list?
+(defconst js2-ecma-object-props
+  (concat "^"
+          (regexp-opt
+           '("prototype" "__proto__" "__parent__") t)
+          "$")
+  "Value properties of the Ecma-262 Object constructor.
+Shown at or above `js2-highlight-level' 2.")
+
+(defconst js2-ecma-global-funcs
+  (concat
+   "^"
+   (regexp-opt
+    '("decodeURI" "decodeURIComponent" "encodeURI" "encodeURIComponent"
+      "eval" "isFinite" "isNaN" "parseFloat" "parseInt") t)
+   "$")
+  "Function properties of the Ecma-262 Global object.
+Shown at or above `js2-highlight-level' 2.")
+
+(defconst js2-ecma-number-props
+  (concat "^"
+          (regexp-opt '("MAX_VALUE" "MIN_VALUE" "NaN"
+                        "NEGATIVE_INFINITY"
+                        "POSITIVE_INFINITY") t)
+          "$")
+  "Properties of the Ecma-262 Number constructor.
+Shown at or above `js2-highlight-level' 2.")
+
+(defconst js2-ecma-date-props "^\\(parse\\|UTC\\)$"
+  "Properties of the Ecma-262 Date constructor.
+Shown at or above `js2-highlight-level' 2.")
+
+(defconst js2-ecma-math-props
+  (concat "^"
+          (regexp-opt
+           '("E" "LN10" "LN2" "LOG2E" "LOG10E" "PI" "SQRT1_2" "SQRT2")
+           t)
+          "$")
+  "Properties of the Ecma-262 Math object.
+Shown at or above `js2-highlight-level' 2.")
+
+(defconst js2-ecma-math-funcs
+  (concat "^"
+          (regexp-opt
+           '("abs" "acos" "asin" "atan" "atan2" "ceil" "cos" "exp" "floor"
+             "log" "max" "min" "pow" "random" "round" "sin" "sqrt" "tan") t)
+          "$")
+  "Function properties of the Ecma-262 Math object.
+Shown at or above `js2-highlight-level' 2.")
+
+(defconst js2-ecma-function-props
+  (concat
+   "^"
+   (regexp-opt
+    '(;; properties of the Object prototype object
+      "hasOwnProperty" "isPrototypeOf" "propertyIsEnumerable"
+      "toLocaleString" "toString" "valueOf"
+      ;; properties of the Function prototype object
+      "apply" "call"
+      ;; properties of the Array prototype object
+      "concat" "join" "pop" "push" "reverse" "shift" "slice" "sort"
+      "splice" "unshift"
+      ;; properties of the String prototype object
+      "charAt" "charCodeAt" "fromCharCode" "indexOf" "lastIndexOf"
+      "localeCompare" "match" "replace" "search" "split" "substring"
+      "toLocaleLowerCase" "toLocaleUpperCase" "toLowerCase"
+      "toUpperCase"
+      ;; properties of the Number prototype object
+      "toExponential" "toFixed" "toPrecision"
+      ;; properties of the Date prototype object
+      "getDate" "getDay" "getFullYear" "getHours" "getMilliseconds"
+      "getMinutes" "getMonth" "getSeconds" "getTime"
+      "getTimezoneOffset" "getUTCDate" "getUTCDay" "getUTCFullYear"
+      "getUTCHours" "getUTCMilliseconds" "getUTCMinutes" "getUTCMonth"
+      "getUTCSeconds" "setDate" "setFullYear" "setHours"
+      "setMilliseconds" "setMinutes" "setMonth" "setSeconds" "setTime"
+      "setUTCDate" "setUTCFullYear" "setUTCHours" "setUTCMilliseconds"
+      "setUTCMinutes" "setUTCMonth" "setUTCSeconds" "toDateString"
+      "toLocaleDateString" "toLocaleString" "toLocaleTimeString"
+      "toTimeString" "toUTCString"
+      ;; properties of the RegExp prototype object
+      "exec" "test"
+      ;; SpiderMonkey/Rhino extensions, versions 1.5+
+      "toSource" "__defineGetter__" "__defineSetter__"
+      "__lookupGetter__" "__lookupSetter__" "__noSuchMethod__"
+      "every" "filter" "forEach" "lastIndexOf" "map" "some")
+    t)
+   "$")
+  "Built-in functions defined by Ecma-262 and SpiderMonkey extensions.
+Shown at or above `js2-highlight-level' 3.")
+
+(defsubst js2-parse-highlight-prop-get (parent target prop call-p)
+  (let ((target-name (and target
+                          (js2-name-node-p target)
+                          (js2-name-node-name target)))
+        (prop-name (if prop (js2-name-node-name prop)))
+        (level1 (>= js2-highlight-level 1))
+        (level2 (>= js2-highlight-level 2))
+        (level3 (>= js2-highlight-level 3))
+        pos
+        face)
+    (when level2
+      (if call-p
+          (cond
+           ((and target prop)
+            (cond
+             ((and level3 (string-match js2-ecma-function-props prop-name))
+              (setq face 'font-lock-builtin-face))
+             ((and target-name prop)
+              (cond
+               ((string= target-name "Date")
+                (if (string-match js2-ecma-date-props prop-name)
+                    (setq face 'font-lock-builtin-face)))
+               ((string= target-name "Math")
+                (if (string-match js2-ecma-math-funcs prop-name)
+                    (setq face 'font-lock-builtin-face)))))))
+           (prop
+            (if (string-match js2-ecma-global-funcs prop-name)
+                (setq face 'font-lock-builtin-face))))
+        (cond
+         ((and target prop)
+          (cond
+           ((string= target-name "Number")
+            (if (string-match js2-ecma-number-props prop-name)
+                (setq face 'font-lock-constant-face)))
+           ((string= target-name "Math")
+            (if (string-match js2-ecma-math-props prop-name)
+                (setq face 'font-lock-constant-face)))))
+         (prop
+          (if (string-match js2-ecma-object-props prop-name)
+              (setq face 'font-lock-constant-face)))))
+      (when face
+        (js2-set-face (setq pos (+ (js2-node-pos parent) ; absolute
+                                   (js2-node-pos prop))) ; relative
+                      (+ pos (js2-node-len prop))
+                      face)))))
+
+(defun js2-parse-highlight-member-expr-node (node)
+  "Perform syntax highlighting of EcmaScript built-in properties.
+The variable `js2-highlight-level' governs this highighting."
+  (let (face target prop name pos end parent call-p callee)
+    (cond
+     ;; case 1:  simple name, e.g. foo
+     ((js2-name-node-p node)
+      (setq name (js2-name-node-name node))
+      ;; possible for name to be nil in rare cases - saw it when
+      ;; running js2-mode on an elisp buffer.  Might as well try to
+      ;; make it so js2-mode never barfs.
+      (when name
+        (setq face (if (string-match js2-ecma-global-props name)
+                       'font-lock-constant-face))
+        (when face
+          (setq pos (js2-node-pos node)
+                end (+ pos (js2-node-len node)))
+          (js2-set-face pos end face))))
+     ;; case 2:  property access or function call
+     ((or (js2-prop-get-node-p node)
+          ;; highlight function call if expr is a prop-get node
+          ;; or a plain name (i.e. unqualified function call)
+          (and (setq call-p (js2-call-node-p node))
+               (setq callee (js2-call-node-target node)) ; separate setq!
+               (or (js2-prop-get-node-p callee)
+                   (js2-name-node-p callee))))
+      (setq parent node
+            node (if call-p callee node))
+      (if (and call-p (js2-name-node-p callee))
+          (setq prop callee)
+        (setq target (js2-prop-get-node-left node)
+              prop (js2-prop-get-node-right node)))
+      (cond
+       ((js2-name-node-p target)
+        (if (js2-name-node-p prop)
+            ;; case 2a:  simple target, simple prop name, e.g. foo.bar
+            (js2-parse-highlight-prop-get parent target prop call-p)
+          ;; case 2b:  simple target, complex name, e.g. foo.x[y]
+          (js2-parse-highlight-prop-get parent target nil call-p)))
+       ((js2-name-node-p prop)
+        ;; case 2c:  complex target, simple name, e.g. x[y].bar
+        (js2-parse-highlight-prop-get parent target prop call-p)))))))
+
+(defun js2-parse-highlight-member-expr-fn-name (expr)
+  "Highlight the `baz' in function foo.bar.baz(args) {...}.
+This is experimental Rhino syntax.  EXPR is the foo.bar.baz member expr.
+We currently only handle the case where the last component is a prop-get
+of a simple name.  Called before EXPR has a parent node."
+  (let (pos
+        (name (and (js2-prop-get-node-p expr)
+                   (js2-prop-get-node-right expr))))
+    (when (js2-name-node-p name)
+      (js2-set-face (setq pos (+ (js2-node-pos expr)  ; parent is absolute
+                                 (js2-node-pos name)))
+                    (+ pos (js2-node-len name))
+                    'font-lock-function-name-face
+                    'record))))
+
+;; source:  http://jsdoc.sourceforge.net/
+;; Note - this syntax is for Google's enhanced jsdoc parser that
+;; allows type specifications, and needs work before entering the wild.
+
+(defconst js2-jsdoc-param-tag-regexp
+  (concat "^\\s-*\\*+\\s-*\\(@"
+          "\\(?:param\\|argument\\)"
+          "\\)"
+          "\\s-*\\({[^}]+}\\)?"         ; optional type
+          "\\s-*\\([a-zA-Z0-9_$]+\\)?"  ; name
+          "\\>")
+  "Matches jsdoc tags with optional type and optional param name.")
+
+(defconst js2-jsdoc-typed-tag-regexp
+  (concat "^\\s-*\\*+\\s-*\\(@\\(?:"
+          (regexp-opt
+           '("enum"
+             "extends"
+             "field"
+             "id"
+             "implements"
+             "lends"
+             "mods"
+             "requires"
+             "return"
+             "returns"
+             "throw"
+             "throws"))
+          "\\)\\)\\s-*\\({[^}]+}\\)?")
+  "Matches jsdoc tags with optional type.")
+
+(defconst js2-jsdoc-arg-tag-regexp
+  (concat "^\\s-*\\*+\\s-*\\(@\\(?:"
+          (regexp-opt
+           '("alias"
+             "augments"
+             "borrows"
+             "bug"
+             "base"
+             "config"
+             "default"
+             "define"
+             "exception"
+             "function"
+             "member"
+             "memberOf"
+             "name"
+             "namespace"
+             "property"
+             "since"
+             "suppress"
+             "this"
+             "throws"
+             "type"
+             "version"))
+          "\\)\\)\\s-+\\([^ \t]+\\)")
+  "Matches jsdoc tags with a single argument.")
+
+(defconst js2-jsdoc-empty-tag-regexp
+  (concat "^\\s-*\\*+\\s-*\\(@\\(?:"
+          (regexp-opt
+           '("addon"
+             "author"
+             "class"
+             "const"
+             "constant"
+             "constructor"
+             "constructs"
+             "deprecated"
+             "desc"
+             "description"
+             "event"
+             "example"
+             "exec"
+             "export"
+             "fileoverview"
+             "final"
+             "function"
+             "hidden"
+             "ignore"
+             "implicitCast"
+             "inheritDoc"
+             "inner"
+             "interface"
+             "license"
+             "noalias"
+             "noshadow"
+             "notypecheck"
+             "override"
+             "owner"
+             "preserve"
+             "preserveTry"
+             "private"
+             "protected"
+             "public"
+             "static"
+             "supported"
+             ))
+          "\\)\\)\\s-*")
+  "Matches empty jsdoc tags.")
+
+(defconst js2-jsdoc-link-tag-regexp
+  "{\\(@\\(?:link\\|code\\)\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?}"
+  "Matches a jsdoc link or code tag.")
+
+(defconst js2-jsdoc-see-tag-regexp
+  "^\\s-*\\*+\\s-*\\(@see\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?"
+  "Matches a jsdoc @see tag.")
+
+(defconst js2-jsdoc-html-tag-regexp
+  "\\(</?\\)\\([a-zA-Z]+\\)\\s-*\\(/?>\\)"
+  "Matches a simple (no attributes) html start- or end-tag.")
+
+(defsubst js2-jsdoc-highlight-helper ()
+  (js2-set-face (match-beginning 1)
+                (match-end 1)
+                'js2-jsdoc-tag-face)
+  (if (match-beginning 2)
+      (if (save-excursion
+            (goto-char (match-beginning 2))
+            (= (char-after) ?{))
+          (js2-set-face (1+ (match-beginning 2))
+                        (1- (match-end 2))
+                        'js2-jsdoc-type-face)
+        (js2-set-face (match-beginning 2)
+                      (match-end 2)
+                      'js2-jsdoc-value-face)))
+  (if (match-beginning 3)
+      (js2-set-face (match-beginning 3)
+                    (match-end 3)
+                    'js2-jsdoc-value-face)))
+
+(defun js2-highlight-jsdoc (ast)
+  "Highlight doc comment tags."
+  (let ((comments (js2-ast-root-comments ast))
+        beg end)
+    (save-excursion
+      (dolist (node comments)
+        (when (eq (js2-comment-node-format node) 'jsdoc)
+          (setq beg (js2-node-abs-pos node)
+                end (+ beg (js2-node-len node)))
+          (save-restriction
+            (narrow-to-region beg end)
+            (dolist (re (list js2-jsdoc-param-tag-regexp
+                              js2-jsdoc-typed-tag-regexp
+                              js2-jsdoc-arg-tag-regexp
+                              js2-jsdoc-link-tag-regexp
+                              js2-jsdoc-see-tag-regexp
+                              js2-jsdoc-empty-tag-regexp))
+              (goto-char beg)
+              (while (re-search-forward re nil t)
+                (js2-jsdoc-highlight-helper)))
+            ;; simple highlighting for html tags
+            (goto-char beg)
+            (while (re-search-forward js2-jsdoc-html-tag-regexp nil t)
+              (js2-set-face (match-beginning 1)
+                            (match-end 1)
+                            'js2-jsdoc-html-tag-delimiter-face)
+              (js2-set-face (match-beginning 2)
+                            (match-end 2)
+                            'js2-jsdoc-html-tag-name-face)
+              (js2-set-face (match-beginning 3)
+                            (match-end 3)
+                            'js2-jsdoc-html-tag-delimiter-face))))))))
+
+(defun js2-highlight-assign-targets (node left right)
+  "Highlight function properties and external variables."
+  (let (leftpos end name)
+    ;; highlight vars and props assigned function values
+    (when (js2-function-node-p right)
+      (cond
+       ;; var foo = function() {...}
+       ((js2-name-node-p left)
+        (setq name left))
+       ;; foo.bar.baz = function() {...}
+       ((and (js2-prop-get-node-p left)
+             (js2-name-node-p (js2-prop-get-node-right left)))
+        (setq name (js2-prop-get-node-right left))))
+      (when name
+        (js2-set-face (setq leftpos (js2-node-abs-pos name))
+                      (+ leftpos (js2-node-len name))
+                      'font-lock-function-name-face
+                      'record)))
+    ;; save variable assignments so we can check for undeclared later
+    ;; (can't do it here since var decls can come at end of script)
+    (when (and js2-highlight-external-variables
+               (setq name (js2-member-expr-leftmost-name left)))
+      (push (list name js2-current-scope
+                  (setq leftpos (js2-node-abs-pos name))
+                  (setq end (+ leftpos (js2-node-len name))))
+            js2-recorded-assignments))))
+
+(defun js2-highlight-undeclared-vars ()
+  "After entire parse is finished, look for undeclared variable assignments.
+We have to wait until entire buffer is parsed, since JavaScript permits var
+decls to occur after they're used.
+
+If any undeclared var name is in `js2-externs' or `js2-additional-externs',
+it is considered declared."
+  (let (name)
+    (dolist (entry js2-recorded-assignments)
+      (destructuring-bind (name-node scope pos end) entry
+        (setq name (js2-name-node-name name-node))
+        (unless (or (member name js2-global-externs)
+                    (member name js2-default-externs)
+                    (member name js2-additional-externs)
+                    (js2-get-defining-scope scope name))
+          (js2-set-face pos end 'js2-external-variable-face 'record)
+          (js2-record-text-property pos end 'help-echo "Undeclared variable")
+          (js2-record-text-property pos end 'point-entered #'js2-echo-help))))
+    (setq js2-recorded-assignments nil)))
+
+(provide 'js2-highlight)
+
+;;; js2-highlight.el ends here
+;;; js2-browse.el --- browsing/hierarchy support for js2-mode
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;; Commentary:
+;;
+;; We currently only support imenu, but eventually should support speedbar and
+;; possibly other browsing mechanisms.
+;;
+;; The basic strategy is to identify function assignment targets of the form
+;; `foo.bar.baz', convert them to (list foo bar baz <position>), and push the
+;; list into `js2-imenu-recorder'.  The lists are merged into a trie-like tree
+;; for imenu after parsing is finished.
+;;
+;; A `foo.bar.baz' assignment target may be expressed in many ways in
+;; JavaScript, and the general problem is undecidable.  However, several forms
+;; are readily recognizable at parse-time; the forms we attempt to recognize
+;; include:
+;;
+;;  function foo()  -- function declaration
+;;  foo = function()  -- function expression assigned to variable
+;;  foo.bar.baz = function()  -- function expr assigned to nested property-get
+;;  foo = {bar: function()}  -- fun prop in object literal assigned to var
+;;  foo = {bar: {baz: function()}} -- inside nested object literal
+;;  foo.bar = {baz: function()}} -- obj lit assigned to nested prop get
+;;  a.b = {c: {d: function()}} -- nested obj lit assigned to nested prop get
+;;  foo = {get bar() {...}}  -- getter/setter in obj literal
+;;  function foo() {function bar() {...}}  -- nested function
+;;  foo['a'] = function()  -- fun expr assigned to deterministic element-get
+;;
+;; This list boils down to a few forms that can be combined recursively.
+;; Top-level named function declarations include both the left-hand (name)
+;; and the right-hand (function value) expressions needed to produce an imenu
+;; entry.  The other "right-hand" forms we need to look for are:
+;;  - functions declared as props/getters/setters in object literals
+;;  - nested named function declarations
+;; The "left-hand" expressions that functions can be assigned to include:
+;;  - local/global variables
+;;  - nested property-get expressions like a.b.c.d
+;;  - element gets like foo[10] or foo['bar'] where the index
+;;    expression can be trivially converted to a property name.  They
+;;    effectively then become property gets.
+;;
+;; All the different definition types are canonicalized into the form
+;; foo.bar.baz = position-of-function-keyword
+;;
+;; We need to build a trie-like structure for imenu.  As an example,
+;; consider the following JavaScript code:
+;;
+;; a = function() {...}  // function at position 5
+;; b = function() {...}  // function at position 25
+;; foo = function() {...} // function at position 100
+;; foo.bar = function() {...} // function at position 200
+;; foo.bar.baz = function() {...} // function at position 300
+;; foo.bar.zab = function() {...} // function at position 400
+;;
+;; During parsing we accumulate an entry for each definition in
+;; the variable `js2-imenu-recorder', like so:
+;;
+;; '((a 5)
+;;   (b 25)
+;;   (foo 100)
+;;   (foo bar 200)
+;;   (foo bar baz 300)
+;;   (foo bar zab 400))
+;;
+;; After parsing these entries are merged into this alist-trie:
+;;
+;; '((a . 1)
+;;   (b . 2)
+;;   (foo (<definition> . 3)
+;;        (bar (<definition> . 6)
+;;             (baz . 100)
+;;             (zab . 200))))
+;;
+;; Note the wacky need for a <definition> name.  The token can be anything
+;; that isn't a valid JavaScript identifier, because you might make foo
+;; a function and then start setting properties on it that are also functions.
+
+;;; Code:
+
+
+(defsubst js2-prop-node-name (node)
+  "Return the name of a node that may be a property-get/property-name.
+If NODE is not a valid name-node, string-node or integral number-node,
+returns nil.  Otherwise returns the string name/value of the node."
+  (cond
+   ((js2-name-node-p node)
+    (js2-name-node-name node))
+   ((js2-string-node-p node)
+    (js2-string-node-value node))
+   ((and (js2-number-node-p node)
+         (string-match "^[0-9]+$" (js2-number-node-value node)))
+    (js2-number-node-value node))
+   ((js2-this-node-p node)
+    "this")))
+
+(defsubst js2-node-qname-component (node)
+  "Test function:  return the name of this node, if it contributes to a qname.
+Returns nil if the node doesn't contribute."
+  (copy-sequence
+   (or (js2-prop-node-name node)
+       (if (and (js2-function-node-p node)
+                (js2-function-node-name node))
+           (js2-name-node-name (js2-function-node-name node))))))
+
+(defsubst js2-record-function-qname (fn-node qname)
+  "Associate FN-NODE with its QNAME for later lookup.
+This is used in postprocessing the chain list.  When we find a chain
+whose first element is a js2-THIS keyword node, we look up the parent
+function and see (using this map) whether it is the tail of a chain.
+If so, we replace the this-node with a copy of the parent's qname."
+  (unless js2-imenu-function-map
+    (setq js2-imenu-function-map (make-hash-table :test 'eq)))
+  (puthash fn-node qname js2-imenu-function-map))
+
+(defun js2-record-imenu-functions (node &optional var)
+  "Record function definitions for imenu.
+NODE is a function node or an object literal.
+VAR, if non-nil, is the expression that NODE is being assigned to."
+  (when js2-parse-ide-mode
+    (let ((fun-p (js2-function-node-p node))
+          qname left fname-node pos)
+      (cond
+       ;; non-anonymous function declaration?
+       ((and fun-p
+             (not var)
+             (setq fname-node (js2-function-node-name node)))
+        (push (setq qname (list fname-node (js2-node-pos node)))
+              js2-imenu-recorder)
+        (js2-record-function-qname node qname))
+       ;; for remaining forms, compute left-side tree branch first
+       ((and var (setq qname (js2-compute-nested-prop-get var)))
+        (cond
+         ;; foo.bar.baz = function
+         (fun-p
+          (push (nconc qname (list (js2-node-pos node)))
+                js2-imenu-recorder)
+          (js2-record-function-qname node qname))
+         ;; foo.bar.baz = object-literal
+         ;; look for nested functions:  {a: {b: function() {...} }}
+         ((js2-object-node-p node)
+          (js2-record-object-literal node qname))))))))
+
+(defun js2-compute-nested-prop-get (node)
+  "If NODE is of form foo.bar.baz, return component nodes as a list.
+Otherwise returns nil.  Element-gets can be treated as property-gets
+if the index expression is a name, a string, or a positive integer."
+  (let (left right head)
+    (cond
+     ((or (js2-name-node-p node)
+          (js2-this-node-p node))
+      (list node))
+     ;; foo.bar.baz is parenthesized as (foo.bar).baz => right operand is a leaf
+     ((js2-prop-get-node-p node)  ; includes elem-get nodes
+      (setq left (js2-prop-get-node-left node)
+            right (js2-prop-get-node-right node))
+      (if (and (or (js2-prop-get-node-p left)     ; left == foo.bar
+                   (js2-name-node-p left)
+                   (js2-this-node-p left))        ; or left == foo
+               (or (js2-name-node-p right)        ; .bar
+                   (js2-string-node-p right)      ; ['bar']
+                   (and (js2-number-node-p right) ; [10]
+                        (string-match "^[0-9]+$"
+                                      (js2-number-node-value right)))))
+          (if (setq head (js2-compute-nested-prop-get left))
+              (nconc head (list right))))))))
+
+(defun js2-record-object-literal (node qname)
+  "Recursively process an object literal looking for functions.
+NODE is an object literal that is the right-hand child of an assignment
+expression.  QNAME is a list of nodes representing the assignment target,
+e.g. for foo.bar.baz = {...}, QNAME is (foo-node bar-node baz-node).
+We do a depth-first traversal of NODE.  Any functions we find are prefixed
+with QNAME plus the property name of the function and appended to the
+variable `js2-imenu-recorder'."
+  ;; Elements are relative to parent position, which is still absolute,
+  ;; since the parser passes the assignment target and value expressions
+  ;; to us before they are added as children of the assignment node.
+  (let ((pos (js2-node-pos node))
+        left right)
+    (dolist (e (js2-object-node-elems node))  ; e is a `js2-object-prop-node'
+      (setq left (js2-infix-node-left e))
+      (cond
+       ;; foo: function() {...}
+       ((js2-function-node-p (setq right (js2-infix-node-right e)))
+        (when (js2-prop-node-name left)
+          ;; As a policy decision, we record the position of the property,
+          ;; not the position of the `function' keyword, since the property
+          ;; is effectively the name of the function.
+          (push (append qname (list left) (list (+ pos (js2-node-pos e))))
+                js2-imenu-recorder)
+          (js2-record-function-qname right qname)))
+       ;; foo: {object-literal} -- add foo to qname and recurse
+       ((js2-object-node-p right)
+        (js2-record-object-literal right
+                                   (append qname (list (js2-infix-node-left e)))))))))
+
+(defsubst js2-node-top-level-decl-p (node)
+  "Return t if NODE's name is defined in the top-level scope.
+Also returns t if NODE's name is not defined in any scope, since it implies
+that it's an external variable, which must also be in the top-level scope."
+  (let* ((name (js2-prop-node-name node))
+         (this-scope (js2-node-get-enclosing-scope node))
+         defining-scope)
+    (cond
+     ((js2-this-node-p node)
+      nil)
+     ((null this-scope)
+      t)
+     ((setq defining-scope (js2-get-defining-scope this-scope name))
+      (js2-ast-root-p defining-scope))
+     (t t))))
+
+(defun js2-browse-postprocess-chains (chains)
+  "Modify function-declaration name chains after parsing finishes.
+Some of the information is only available after the parse tree is complete.
+For instance, following a 'this' reference requires a parent function node."
+  (let (result head fn parent-chain p elem)
+    (dolist (chain chains)
+      ;; examine the head of each node to get its defining scope
+      (setq head (car chain))
+      (cond
+       ;; if top-level/external, keep as-is
+       ((js2-node-top-level-decl-p head)
+        (push chain result))
+       ;; check for a this-reference
+       ((eq (js2-node-type head) js2-THIS)
+        (setq fn (js2-node-parent-script-or-fn head))
+        ;; if there is no parent function, or if the parent function
+        ;; is nested, discard the head node and keep the rest of the chain.
+        (if (or (null fn) (js2-nested-function-p fn))
+            (push (cdr chain) result)
+          ;; else look up parent in function-map.  If not found, discard chain.
+          (when (setq parent-chain (and js2-imenu-function-map
+                                        (gethash fn js2-imenu-function-map)))
+            ;; else discard head node and prefix parent fn qname, which is
+            ;; the parent-chain sans tail, to this chain.
+            (push (append (butlast parent-chain) (cdr chain)) result))))))
+    ;; finally replace each node in each chain with its name.
+    (dolist (chain result)
+      (setq p chain)
+      (while p
+        (if (js2-node-p (setq elem (car p)))
+            (setcar p (js2-node-qname-component elem)))
+        (setq p (cdr p))))
+    result))
+
+;; Merge name chains into a trie-like tree structure of nested lists.
+;; To simplify construction of the trie, we first build it out using the rule
+;; that the trie consists of lists of pairs.  Each pair is a 2-element array:
+;; [key, num-or-list].  The second element can be a number; if so, this key
+;; is a leaf-node with only one value.  (I.e. there is only one declaration
+;; associated with the key at this level.)  Otherwise the second element is
+;; a list of pairs, with the rule applied recursively.  This symmetry permits
+;; a simple recursive formulation.
+;;
+;; js2-mode is building the data structure for imenu.  The imenu documentation
+;; claims that it's the structure above, but in practice it wants the children
+;; at the same list level as the key for that level, which is how I've drawn
+;; the "Expected final result" above.  We'll postprocess the trie to remove the
+;; list wrapper around the children at each level.
+;;
+;; A completed nested imenu-alist entry looks like this:
+;;       '(("foo"
+;;          ("<definition>" . 7)
+;;          ("bar"
+;;           ("a" . 40)
+;;           ("b" . 60))))
+;;
+;; In particular, the documentation for `imenu--index-alist' says that
+;; a nested sub-alist element looks like (INDEX-NAME SUB-ALIST).
+;; The sub-alist entries immediately follow INDEX-NAME, the head of the list.
+
+(defsubst js2-treeify (lst)
+  "Convert (a b c d) to (a ((b ((c d)))))"
+  (if (null (cddr lst))  ; list length <= 2
+      lst
+    (list (car lst) (list (js2-treeify (cdr lst))))))
+
+(defun js2-build-alist-trie (chains trie)
+  "Merge declaration name chains into a trie-like alist structure for imenu.
+CHAINS is the qname chain list produced during parsing. TRIE is a
+list of elements built up so far."
+  (let (head tail pos branch kids)
+    (dolist (chain chains)
+      (setq head (car chain)
+            tail (cdr chain)
+            pos (if (numberp (car tail)) (car tail))
+            branch (js2-find-if (lambda (n)
+                                  (string= (car n) head))
+                                trie)
+            kids (second branch))
+      (cond
+       ;; case 1:  this key isn't in the trie yet
+       ((null branch)
+        (if trie
+            (setcdr (last trie) (list (js2-treeify chain)))
+          (setq trie (list (js2-treeify chain)))))
+       ;; case 2:  key is present with a single number entry:  replace w/ list
+       ;;  ("a1" 10)  +  ("a1" 20) => ("a1" (("<definition>" 10)
+       ;;                                    ("<definition>" 20)))
+       ((numberp kids)
+        (setcar (cdr branch)
+                (list (list "<definition-1>" kids)
+                      (if pos
+                          (list "<definition-2>" pos)
+                        (js2-treeify tail)))))
+       ;; case 3:  key is there (with kids), and we're a number entry
+       (pos
+        (setcdr (last kids)
+                (list
+                 (list (format "<definition-%d>"
+                               (1+ (loop for kid in kids
+                                         count (eq ?< (aref (car kid) 0)))))
+                       pos))))
+
+       ;; case 4:  key is there with kids, need to merge in our chain
+       (t
+        (js2-build-alist-trie (list tail) kids))))
+    trie))
+
+(defun js2-flatten-trie (trie)
+  "Convert TRIE to imenu-format.
+Recurses through nodes, and for each one whose second element is a list,
+appends the list's flattened elements to the current element.  Also
+changes the tails into conses.  For instance, this pre-flattened trie
+
+'(a ((b 20)
+     (c ((d 30)
+         (e 40)))))
+
+becomes
+
+'(a (b . 20)
+    (c (d . 30)
+       (e . 40)))
+
+Note that the root of the trie has no key, just a list of chains.
+This is also true for the value of any key with multiple children,
+e.g. key 'c' in the example above."
+  (cond
+   ((listp (car trie))
+    (mapcar #'js2-flatten-trie trie))
+   (t
+    (if (numberp (second trie))
+        (cons (car trie) (second trie))
+      ;; else pop list and append its kids
+      (apply #'append (list (car trie)) (js2-flatten-trie (cdr trie)))))))
+
+(defun js2-build-imenu-index ()
+  "Turn `js2-imenu-recorder' into an imenu data structure."
+  (unless (eq js2-imenu-recorder 'empty)
+    (let* ((chains (js2-browse-postprocess-chains js2-imenu-recorder))
+           (result (js2-build-alist-trie chains nil)))
+      (js2-flatten-trie result))))
+
+(defun js2-test-print-chains (chains)
+  "Print a list of qname chains.
+Each element of CHAINS is a list of the form (NODE [NODE *] pos);
+i.e. one or more nodes, and an integer position as the list tail."
+  (mapconcat (lambda (chain)
+               (concat "("
+                       (mapconcat (lambda (elem)
+                                    (if (js2-node-p elem)
+                                        (or (js2-node-qname-component elem)
+                                            "nil")
+                                      (number-to-string elem)))
+                                  chain
+                                  " ")
+                       ")"))
+             chains
+             "\n"))
+
+(provide 'js2-browse)
+
+;;; js2-browse.el ends here
+;;; js2-parse.el --- JavaScript parser
+
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Keywords:  javascript languages
+
+;; Commentary:
+
+;; This is based on Rhino's parser and tries to follow its code
+;; structure as closely as practical, so that changes to the Rhino
+;; parser can easily be propagated into this code.  However, Rhino
+;; does not currently generate a usable AST representation, at least
+;; from an IDE perspective, so we build our own more suitable AST.
+
+;; The AST node structures are defined in `js2-ast.el'.
+;; Every parser function that creates and returns an AST node has
+;; the following responsibilities:
+
+;;   1) set the node start to the absolute buffer start position
+;;   2) set the node length to include any closing chars (RC, SEMI)
+;;   3) fix up any child-node starts to be relative to this node
+;;   4) set any field positions (e.g. keywords) relative to this node
+;;   5) report any child nodes with `js2-node-add-children'
+;;      (note that this call fixes up start positions by default)
+
+;; The resulting AST has all node start positions relative to the
+;; parent nodes; only the root has an absolute start position.
+
+;; Note: fontification is done inline while parsing.  It used to be
+;; done in a second pass over the AST, but doing it inline is about
+;; twice as fast.  Most of the fontification happens when tokens are
+;; scanned, and the parser has a few spots that perform extra
+;; fontification.  In addition to speed, a second benefit of inline
+;; parsing is that if a long parse is interrupted, everything parsed
+;; so far is still fontified.
+
+;; The editing mode that uses this parser, `js2-mode', directs the
+;; parser to check periodically for user input.  If user input
+;; arrives, the parse is abandoned, except for the highlighting that
+;; has occurred so far, and a re-parse is rescheduled for when Emacs
+;; becomes idle again.  This works pretty well, but could be better.
+;; In particular, when the user input has not resulted in changes to
+;; the buffer (for instance, navigation input), the parse tree built
+;; so far should not be discarded, and the parse should continue where
+;; it left off.  It will be some work to create what amounts to a
+;; continuation, but it should not be unreasonably difficult.
+
+;; TODO:
+;; - make non-editing input restart parse at previous continuation
+;; - in Eclipse, sibling nodes never overlap start/end ranges
+;;   - for getters, prop name and function nodes overlap
+;;   - should write a debug tree visitor to look for overlaps
+;; - mark array and object literals as "destructuring" (node prop?)
+;;   so we can syntax-highlight them properly.
+;; - figure out a way not to store value in string/name nodes
+;;   - needs a solution for synthetic nodes
+
+;;; Code
+
+(eval-and-compile
+  (require 'cl))  ; for delete-if
+
+
+(defconst js2-version "1.8.0"
+  "Version of JavaScript supported, plus minor js2 version.")
+
+(defmacro js2-record-face (face)
+  "Record a style run of FACE for the current token."
+  `(js2-set-face js2-token-beg js2-token-end ,face 'record))
+
+(defsubst js2-node-end (n)
+  "Computes the absolute end of node N.
+Use with caution!  Assumes `js2-node-pos' is -absolute-, which
+is only true until the node is added to its parent; i.e., while parsing."
+  (+ (js2-node-pos n)
+     (js2-node-len n)))
+
+(defsubst js2-record-comment ()
+  (push (make-js2-comment-node :len (- js2-token-end js2-token-beg)
+                               :format js2-ts-comment-type)
+        js2-scanned-comments)
+  (when js2-parse-ide-mode
+    (js2-record-face (if (eq js2-ts-comment-type 'jsdoc)
+                         'font-lock-doc-face
+                       'font-lock-comment-face))
+    (when (memq js2-ts-comment-type '(html preprocessor))
+      ;; Tell cc-engine the bounds of the comment.
+      (put-text-property js2-token-beg (1- js2-token-end) 'c-in-sws t))))
+
+;; This function is called depressingly often, so it should be fast.
+;; Most of the time it's looking at the same token it peeked before.
+(defsubst js2-peek-token ()
+  "Returns the next token without consuming it.
+If previous token was consumed, calls scanner to get new token.
+If previous token was -not- consumed, returns it (idempotent).
+
+This function will not return a newline (js2-EOL) - instead, it
+gobbles newlines until it finds a non-newline token, and flags
+that token as appearing just after a newline.
+
+This function will also not return a js2-COMMENT.  Instead, it
+records comments found in `js2-scanned-comments'.  If the token
+returned by this function immediately follows a jsdoc comment,
+the token is flagged as such.
+
+Note that this function always returned the un-flagged token!
+The flags, if any, are saved in `js2-current-flagged-token'."
+  (if (/= js2-current-flagged-token js2-EOF) ; last token not consumed
+      js2-current-token  ; most common case - return already-peeked token
+    (let ((tt (js2-get-token))          ; call scanner
+          saw-eol
+          face)
+      ;; process comments and whitespace
+      (while (or (= tt js2-EOL)
+                 (= tt js2-COMMENT))
+        (if (= tt js2-EOL)
+            (setq saw-eol t)
+          (setq saw-eol nil)
+          (if js2-record-comments
+              (js2-record-comment)))
+        (setq tt (js2-get-token)))  ; call scanner
+      (setq js2-current-token tt
+            js2-current-flagged-token (if saw-eol
+                                          (logior tt js2-ti-after-eol)
+                                        tt))
+      ;; perform lexical fontification as soon as token is scanned
+      (when js2-parse-ide-mode
+        (cond
+         ((minusp tt)
+          (js2-record-face 'js2-error-face))
+         ((setq face (aref js2-kwd-tokens tt))
+          (js2-record-face face))
+         ((and (= tt js2-NAME)
+               (equal js2-ts-string "undefined"))
+          (js2-record-face 'font-lock-constant-face))))
+      tt)))  ; return unflagged token
+
+(defsubst js2-peek-flagged-token ()
+  "Returns the current token along with any flags set for it."
+  (js2-peek-token)
+  js2-current-flagged-token)
+
+(defsubst js2-consume-token ()
+  (setq js2-current-flagged-token js2-EOF))
+
+(defsubst js2-next-token ()
+  (prog1
+      (js2-peek-token)
+    (js2-consume-token)))
+
+(defsubst js2-next-flagged-token ()
+  (js2-peek-token)
+  (prog1 js2-current-flagged-token
+    (js2-consume-token)))
+
+(defsubst js2-match-token (match)
+  "Consume and return t if next token matches MATCH, a bytecode.
+Returns nil and consumes nothing if MATCH is not the next token."
+  (if (/= (js2-peek-token) match)
+      nil
+    (js2-consume-token)
+    t))
+
+(defsubst js2-valid-prop-name-token (tt)
+  (or (= tt js2-NAME)
+      (and js2-allow-keywords-as-property-names
+           (plusp tt)
+           (aref js2-kwd-tokens tt))))
+
+(defsubst js2-match-prop-name ()
+  "Consume token and return t if next token is a valid property name.
+It's valid if it's a js2-NAME, or `js2-allow-keywords-as-property-names'
+is non-nil and it's a keyword token."
+  (if (js2-valid-prop-name-token (js2-peek-token))
+      (progn
+        (js2-consume-token)
+        t)
+    nil))
+
+(defsubst js2-must-match-prop-name (msg-id &optional pos len)
+  (if (js2-match-prop-name)
+      t
+    (js2-report-error msg-id nil pos len)
+    nil))
+
+(defsubst js2-peek-token-or-eol ()
+  "Return js2-EOL if the current token immediately follows a newline.
+Else returns the current token.  Used in situations where we don't
+consider certain token types valid if they are preceded by a newline.
+One example is the postfix ++ or -- operator, which has to be on the
+same line as its operand."
+  (let ((tt (js2-peek-token)))
+    ;; Check for last peeked token flags
+    (if (js2-flag-set-p js2-current-flagged-token js2-ti-after-eol)
+        js2-EOL
+      tt)))
+
+(defsubst js2-set-check-for-label ()
+  (assert (= (logand js2-current-flagged-token js2-clear-ti-mask) js2-NAME))
+  (js2-set-flag js2-current-flagged-token js2-ti-check-label))
+
+(defsubst js2-must-match (token msg-id &optional pos len)
+  "Match next token to token code TOKEN, or record a syntax error.
+MSG-ID is the error message to report if the match fails.
+Returns t on match, nil if no match."
+  (if (js2-match-token token)
+      t
+    (js2-report-error msg-id nil pos len)
+    nil))
+
+(defsubst js2-inside-function ()
+  (plusp js2-nesting-of-function))
+
+(defsubst js2-set-requires-activation ()
+  (if (js2-function-node-p js2-current-script-or-fn)
+      (setf (js2-function-node-needs-activation js2-current-script-or-fn) t)))
+
+(defsubst js2-check-activation-name (name token)
+  (when (js2-inside-function)
+    ;; skip language-version 1.2 check from Rhino
+    (if (or (string= "arguments" name)
+            (and js2-compiler-activation-names  ; only used in codegen
+                 (gethash name js2-compiler-activation-names)))
+        (js2-set-requires-activation))))
+
+(defsubst js2-set-is-generator ()
+  (if (js2-function-node-p js2-current-script-or-fn)
+      (setf (js2-function-node-is-generator js2-current-script-or-fn) t)))
+
+(defsubst js2-must-have-xml ()
+  (unless js2-compiler-xml-available
+    (js2-report-error "msg.XML.not.available")))
+
+(defsubst js2-push-scope (scope)
+  "Push SCOPE, a `js2-scope', onto the lexical scope chain."
+  (assert (js2-scope-p scope))
+  (assert (null (js2-scope-parent-scope scope)))
+  (assert (neq js2-current-scope scope))
+  (setf (js2-scope-parent-scope scope) js2-current-scope
+        js2-current-scope scope))
+
+(defsubst js2-pop-scope ()
+  (setq js2-current-scope
+        (js2-scope-parent-scope js2-current-scope)))
+
+(defsubst js2-enter-loop (loop-node)
+  (push loop-node js2-loop-set)
+  (push loop-node js2-loop-and-switch-set)
+  (js2-push-scope loop-node)
+  ;; Tell the current labeled statement (if any) its statement,
+  ;; and set the jump target of the first label to the loop.
+  ;; These are used in `js2-parse-continue' to verify that the
+  ;; continue target is an actual labeled loop.  (And for codegen.)
+  (when js2-labeled-stmt
+    (setf (js2-labeled-stmt-node-stmt js2-labeled-stmt) loop-node
+          (js2-label-node-loop (car (js2-labeled-stmt-node-labels
+                                     js2-labeled-stmt))) loop-node)))
+
+(defsubst js2-exit-loop ()
+  (pop js2-loop-set)
+  (pop js2-loop-and-switch-set)
+  (js2-pop-scope))
+
+(defsubst js2-enter-switch (switch-node)
+  (push switch-node js2-loop-and-switch-set))
+
+(defsubst js2-exit-switch ()
+  (pop js2-loop-and-switch-set))
+
+(defun js2-parse (&optional buf cb)
+  "Tells the js2 parser to parse a region of JavaScript.
+
+BUF is a buffer or buffer name containing the code to parse.
+Call `narrow-to-region' first to parse only part of the buffer.
+
+The returned AST root node is given some additional properties:
+  `node-count' - total number of nodes in the AST
+  `buffer' - BUF.  The buffer it refers to may change or be killed,
+             so the value is not necessarily reliable.
+
+An optional callback CB can be specified to report parsing
+progress.  If `(functionp CB)' returns t, it will be called with
+the current line number once before parsing begins, then again
+each time the lexer reaches a new line number.
+
+CB can also be a list of the form `(symbol cb ...)' to specify
+multiple callbacks with different criteria.  Each symbol is a
+criterion keyword, and the following element is the callback to
+call
+
+  :line  - called whenever the line number changes
+  :token - called for each new token consumed
+
+The list of criteria could be extended to include entering or
+leaving a statement, an expression, or a function definition."
+  (if (and cb (not (functionp cb)))
+      (error "criteria callbacks not yet implemented"))
+  (let ((inhibit-point-motion-hooks t)
+        (js2-compiler-xml-available (>= js2-language-version 160))
+        ;; This is a recursive-descent parser, so give it a big stack.
+        (max-lisp-eval-depth (max max-lisp-eval-depth 3000))
+        (max-specpdl-size (max max-specpdl-size 3000))
+        (case-fold-search nil)
+        ast)
+    (or buf (setq buf (current-buffer)))
+    (message nil)  ; clear any error message from previous parse
+    (save-excursion
+      (set-buffer buf)
+      (setq js2-scanned-comments nil
+            js2-parsed-errors nil
+            js2-parsed-warnings nil
+            js2-imenu-recorder nil
+            js2-imenu-function-map nil
+            js2-label-set nil)
+      (js2-init-scanner)
+      (setq ast (js2-with-unmodifying-text-property-changes
+                  (js2-do-parse)))
+      (unless js2-ts-hit-eof
+        (js2-report-error "msg.got.syntax.errors" (length js2-parsed-errors)))
+      (setf (js2-ast-root-errors ast) js2-parsed-errors
+            (js2-ast-root-warnings ast) js2-parsed-warnings)
+      ;; if we didn't find any declarations, put a dummy in this list so we
+      ;; don't end up re-parsing the buffer in `js2-mode-create-imenu-index'
+      (unless js2-imenu-recorder
+        (setq js2-imenu-recorder 'empty))
+      (run-hooks 'js2-parse-finished-hook)
+      ast)))
+
+;; Corresponds to Rhino's Parser.parse() method.
+(defun js2-do-parse ()
+  "Parse current buffer starting from current point.
+Scanner should be initialized."
+  (let ((pos js2-ts-cursor)
+        (end js2-ts-cursor)  ; in case file is empty
+        root n tt)
+    ;; initialize buffer-local parsing vars
+    (setf root (make-js2-ast-root :buffer (buffer-name) :pos pos)
+          js2-current-script-or-fn root
+          js2-current-scope root
+          js2-current-flagged-token js2-EOF
+          js2-nesting-of-function 0
+          js2-labeled-stmt nil
+          js2-recorded-assignments nil)  ; for js2-highlight
+    (while (/= (setq tt (js2-peek-token)) js2-EOF)
+      (if (= tt js2-FUNCTION)
+          (progn
+            (js2-consume-token)
+            (setq n (js2-parse-function (if js2-called-by-compile-function
+                                            'FUNCTION_EXPRESSION
+                                          'FUNCTION_STATEMENT)))
+            (js2-record-imenu-functions n))
+        ;; not a function - parse a statement
+        (setq n (js2-parse-statement)))
+      ;; add function or statement to script
+      (setq end (js2-node-end n))
+      (js2-block-node-push root n))
+    ;; add comments to root in lexical order
+    (when js2-scanned-comments
+      ;; if we find a comment beyond end of normal kids, use its end
+      (setq end (max end (js2-node-end (first js2-scanned-comments))))
+      (dolist (comment js2-scanned-comments)
+        (push comment (js2-ast-root-comments root))
+        (js2-node-add-children root comment)))
+    (setf (js2-node-len root) (- end pos))
+    ;; Give extensions a chance to muck with things before highlighting starts.
+    (dolist (callback js2-post-parse-callbacks)
+      (funcall callback))
+    (js2-highlight-undeclared-vars)
+    root))
+
+(defun js2-function-parser ()
+  (js2-consume-token)
+  (js2-parse-function 'FUNCTION_EXPRESSION_STATEMENT))
+
+(defun js2-parse-function-closure-body (fn-node)
+  "Parse a JavaScript 1.8 function closure body."
+  (let ((js2-nesting-of-function (1+ js2-nesting-of-function)))
+    (if js2-ts-hit-eof
+        (js2-report-error "msg.no.brace.body" nil
+                          (js2-node-pos fn-node)
+                          (- js2-ts-cursor (js2-node-pos fn-node)))
+      (js2-node-add-children fn-node
+                             (setf (js2-function-node-body fn-node)
+                                   (js2-parse-expr))))))
+
+(defun js2-parse-function-body (fn-node)
+  (js2-must-match js2-LC "msg.no.brace.body"
+                  (js2-node-pos fn-node)
+                  (- js2-ts-cursor (js2-node-pos fn-node)))
+  (let ((pos js2-token-beg)         ; LC position
+        (pn (make-js2-block-node))  ; starts at LC position
+        tt
+        end)
+    (incf js2-nesting-of-function)
+    (unwind-protect
+        (while (not (or (= (setq tt (js2-peek-token)) js2-ERROR)
+                        (= tt js2-EOF)
+                        (= tt js2-RC)))
+          (js2-block-node-push pn (if (/= tt js2-FUNCTION)
+                                      (js2-parse-statement)
+                                    (js2-consume-token)
+                                    (js2-parse-function 'FUNCTION_STATEMENT))))
+      (decf js2-nesting-of-function))
+    (setq end js2-token-end)  ; assume no curly and leave at current token
+    (if (js2-must-match js2-RC "msg.no.brace.after.body" pos)
+        (setq end js2-token-end))
+    (setf (js2-node-pos pn) pos
+          (js2-node-len pn) (- end pos))
+    (setf (js2-function-node-body fn-node) pn)
+    (js2-node-add-children fn-node pn)
+    pn))
+
+(defun js2-parse-function-params (fn-node pos)
+  (if (js2-match-token js2-RP)
+      (setf (js2-function-node-rp fn-node) (- js2-token-beg pos))
+    (let (params len param)
+      (loop for tt = (js2-peek-token)
+            do
+            (cond
+             ;; destructuring param
+             ((or (= tt js2-LB) (= tt js2-LC))
+              (push (js2-parse-primary-expr) params))
+             ;; simple name
+             (t
+              (js2-must-match js2-NAME "msg.no.parm")
+              (js2-record-face 'js2-function-param-face)
+              (setq param (js2-create-name-node))
+              (js2-define-symbol js2-LP js2-ts-string param)
+              (push param params)))
+            while
+            (js2-match-token js2-COMMA))
+      (if (js2-must-match js2-RP "msg.no.paren.after.parms")
+          (setf (js2-function-node-rp fn-node) (- js2-token-beg pos)))
+      (dolist (p params)
+        (js2-node-add-children fn-node p)
+        (push p (js2-function-node-params fn-node))))))
+
+(defsubst js2-check-inconsistent-return-warning (fn-node name)
+  "Possibly show inconsistent-return warning.
+Last token scanned is the close-curly for the function body."
+  (when (and js2-mode-show-strict-warnings
+             js2-strict-inconsistent-return-warning
+             (not (js2-has-consistent-return-usage
+                   (js2-function-node-body fn-node))))
+    ;; Have it extend from close-curly to bol or beginning of block.
+    (let ((pos (save-excursion
+                 (goto-char js2-token-end)
+                 (max (js2-node-abs-pos (js2-function-node-body fn-node))
+                      (point-at-bol))))
+          (end js2-token-end))
+      (if (plusp (js2-name-node-length name))
+          (js2-add-strict-warning "msg.no.return.value"
+                                  (js2-name-node-name name) pos end)
+        (js2-add-strict-warning "msg.anon.no.return.value" nil pos end)))))
+
+(defun js2-parse-function (function-type)
+  "Function parser.  FUNCTION-TYPE is a symbol."
+  (let ((pos js2-token-beg)  ; start of 'function' keyword
+        name
+        name-beg
+        name-end
+        fn-node
+        lp
+        (synthetic-type function-type)
+        member-expr-node)
+    ;; parse function name, expression, or non-name (anonymous)
+    (cond
+     ;; function foo(...)
+     ((js2-match-token js2-NAME)
+      (setq name (js2-create-name-node t)
+            name-beg js2-token-beg
+            name-end js2-token-end)
+      (unless (js2-match-token js2-LP)
+        (when js2-allow-member-expr-as-function-name
+          ;; function foo.bar(...)
+          (setq member-expr-node name
+                name nil
+                member-expr-node (js2-parse-member-expr-tail
+                                  nil member-expr-node)))
+        (js2-must-match js2-LP "msg.no.paren.parms")))
+     ((js2-match-token js2-LP)
+      nil)  ; anonymous function:  leave name as null
+     (t
+      ;; function random-member-expr(...)
+      (when js2-allow-member-expr-as-function-name
+        ;; Note that memberExpr can not start with '(' like
+        ;; in function (1+2).toString(), because 'function (' already
+        ;; processed as anonymous function
+        (setq member-expr-node (js2-parse-member-expr)))
+      (js2-must-match js2-LP "msg.no.paren.parms")))
+    (if (= js2-current-token js2-LP)  ; eventually matched LP?
+        (setq lp js2-token-beg))
+    (if member-expr-node
+        (progn
+          (setq synthetic-type 'FUNCTION_EXPRESSION)
+          (js2-parse-highlight-member-expr-fn-name member-expr-node))
+      (if name
+          (js2-set-face name-beg name-end
+                        'font-lock-function-name-face 'record)))
+    (if (and (neq synthetic-type 'FUNCTION_EXPRESSION)
+             (plusp (js2-name-node-length name)))
+        ;; Function statements define a symbol in the enclosing scope
+        (js2-define-symbol js2-FUNCTION (js2-name-node-name name) fn-node))
+    (setf fn-node (make-js2-function-node :pos pos
+                                          :name name
+                                          :form function-type
+                                          :lp (if lp (- lp pos))))
+    (if (or (js2-inside-function) (plusp js2-nesting-of-with))
+        ;; 1. Nested functions are not affected by the dynamic scope flag
+        ;;    as dynamic scope is already a parent of their scope.
+        ;; 2. Functions defined under the with statement also immune to
+        ;;    this setup, in which case dynamic scope is ignored in favor
+        ;;    of the with object.
+        (setf (js2-function-node-ignore-dynamic fn-node) t))
+    ;; dynamically bind all the per-function variables
+    (let ((js2-current-script-or-fn fn-node)
+          (js2-current-scope fn-node)
+          (js2-nesting-of-with 0)
+          (js2-end-flags 0)
+          js2-label-set
+          js2-loop-set
+          js2-loop-and-switch-set)
+      (js2-parse-function-params fn-node pos)
+      (if (and (>= js2-language-version 180)
+               (/= (js2-peek-token) js2-LC))
+          (js2-parse-function-closure-body fn-node)
+        (js2-parse-function-body fn-node))
+      (if name
+          (js2-node-add-children fn-node name))
+      (js2-check-inconsistent-return-warning fn-node name)
+      ;; Function expressions define a name only in the body of the
+      ;; function, and only if not hidden by a parameter name
+      (if (and name
+               (eq synthetic-type 'FUNCTION_EXPRESSION)
+               (null (js2-scope-get-symbol js2-current-scope
+                                           (js2-name-node-name name))))
+          (js2-define-symbol js2-FUNCTION
+                             (js2-name-node-name name)
+                             fn-node))
+      (if (and name
+               (eq function-type 'FUNCTION_EXPRESSION_STATEMENT))
+          (js2-record-imenu-functions fn-node)))
+    (setf (js2-node-len fn-node) (- js2-ts-cursor pos)
+          (js2-function-node-member-expr fn-node) member-expr-node)  ; may be nil
+    ;; Rhino doesn't do this, but we need it for finding undeclared vars.
+    ;; We wait until after parsing the function to set its parent scope,
+    ;; since `js2-define-symbol' needs the defining-scope check to stop
+    ;; at the function boundary when checking for redeclarations.
+    (setf (js2-scope-parent-scope fn-node) js2-current-scope)
+    fn-node))
+
+(defun js2-parse-statements (&optional parent)
+  "Parse a statement list.  Last token consumed must be js2-LC.
+
+PARENT can be a `js2-block-node', in which case the statements are
+appended to PARENT.  Otherwise a new `js2-block-node' is created
+and returned.
+
+This function does not match the closing js2-RC: the caller
+matches the RC so it can provide a suitable error message if not
+matched.  This means it's up to the caller to set the length of
+the node to include the closing RC.  The node start pos is set to
+the absolute buffer start position, and the caller should fix it
+up to be relative to the parent node.  All children of this block
+node are given relative start positions and correct lengths."
+  (let ((pn (or parent (make-js2-block-node)))
+        tt)
+    (setf (js2-node-pos pn) js2-token-beg)
+    (while (and (> (setq tt (js2-peek-token)) js2-EOF)
+                (/= tt js2-RC))
+      (js2-block-node-push pn (js2-parse-statement)))
+    pn))
+
+(defun js2-parse-statement ()
+  (let (tt pn beg end)
+    ;; coarse-grained user-interrupt check - needs work
+    (and js2-parse-interruptable-p
+         (zerop (% (incf js2-parse-stmt-count)
+                   js2-statements-per-pause))
+         (input-pending-p)
+         (throw 'interrupted t))
+    (setq pn (js2-statement-helper))
+    ;; no-side-effects warning check
+    (unless (js2-node-has-side-effects pn)
+      (setq end (js2-node-end pn))
+      (save-excursion
+        (goto-char end)
+        (setq beg (max (js2-node-pos pn) (point-at-bol))))
+      (js2-add-strict-warning "msg.no.side.effects" nil beg end))
+    pn))
+
+;; These correspond to the switch cases in Parser.statementHelper
+(defconst js2-parsers
+  (let ((parsers (make-vector js2-num-tokens
+                                #'js2-parse-expr-stmt)))
+    (aset parsers js2-BREAK     #'js2-parse-break)
+    (aset parsers js2-CONST     #'js2-parse-const-var)
+    (aset parsers js2-CONTINUE  #'js2-parse-continue)
+    (aset parsers js2-DEBUGGER  #'js2-parse-debugger)
+    (aset parsers js2-DEFAULT   #'js2-parse-default-xml-namespace)
+    (aset parsers js2-DO        #'js2-parse-do)
+    (aset parsers js2-FOR       #'js2-parse-for)
+    (aset parsers js2-FUNCTION  #'js2-function-parser)
+    (aset parsers js2-IF        #'js2-parse-if)
+    (aset parsers js2-LC        #'js2-parse-block)
+    (aset parsers js2-LET       #'js2-parse-let-stmt)
+    (aset parsers js2-NAME      #'js2-parse-name-or-label)
+    (aset parsers js2-RETURN    #'js2-parse-ret-yield)
+    (aset parsers js2-SEMI      #'js2-parse-semi)
+    (aset parsers js2-SWITCH    #'js2-parse-switch)
+    (aset parsers js2-THROW     #'js2-parse-throw)
+    (aset parsers js2-TRY       #'js2-parse-try)
+    (aset parsers js2-VAR       #'js2-parse-const-var)
+    (aset parsers js2-WHILE     #'js2-parse-while)
+    (aset parsers js2-WITH      #'js2-parse-with)
+    (aset parsers js2-YIELD     #'js2-parse-ret-yield)
+    parsers)
+  "A vector mapping token types to parser functions.")
+
+(defsubst js2-parse-warn-missing-semi (beg end)
+  (and js2-mode-show-strict-warnings
+       js2-strict-missing-semi-warning
+       (js2-add-strict-warning
+        "msg.missing.semi" nil
+        ;; back up to beginning of statement or line
+        (max beg (save-excursion
+                   (goto-char end)
+                   (point-at-bol)))
+        end)))
+
+(defconst js2-no-semi-insertion
+  (list js2-IF
+        js2-SWITCH
+        js2-WHILE
+        js2-DO
+        js2-FOR
+        js2-TRY
+        js2-WITH
+        js2-LC
+        js2-ERROR
+        js2-SEMI
+        js2-FUNCTION)
+  "List of tokens that don't do automatic semicolon insertion.")
+
+(defconst js2-autoinsert-semi-and-warn
+  (list js2-ERROR js2-EOF js2-RC))
+
+(defun js2-statement-helper ()
+  (let* ((tt (js2-peek-token))
+         (first-tt tt)
+         (beg js2-token-beg)
+         (parser (if (= tt js2-ERROR)
+                     #'js2-parse-semi
+                   (aref js2-parsers tt)))
+         pn
+         tt-flagged)
+    ;; If the statement is set, then it's been told its label by now.
+    (and js2-labeled-stmt
+         (js2-labeled-stmt-node-stmt js2-labeled-stmt)
+         (setq js2-labeled-stmt nil))
+    (setq pn (funcall parser))
+    ;; Don't do auto semi insertion for certain statement types.
+    (unless (or (memq first-tt js2-no-semi-insertion)
+                (js2-labeled-stmt-node-p pn))
+      (js2-auto-insert-semicolon pn))
+    pn))
+
+(defun js2-auto-insert-semicolon (pn)
+  (let* ((tt-flagged (js2-peek-flagged-token))
+         (tt (logand tt-flagged js2-clear-ti-mask))
+         (pos (js2-node-pos pn)))
+      (cond
+       ((= tt js2-SEMI)
+        ;; Consume ';' as a part of expression
+        (js2-consume-token)
+        ;; extend the node bounds to include the semicolon.
+        (setf (js2-node-len pn) (- js2-token-end pos)))
+       ((memq tt js2-autoinsert-semi-and-warn)
+        ;; Autoinsert ;
+        (js2-parse-warn-missing-semi pos (js2-node-end pn)))
+       (t
+        (if (js2-flag-not-set-p tt-flagged js2-ti-after-eol)
+            ;; Report error if no EOL or autoinsert ';' otherwise
+            (js2-report-error "msg.no.semi.stmt")
+          (js2-parse-warn-missing-semi pos (js2-node-end pn)))))))
+
+(defun js2-parse-condition ()
+  "Parse a parenthesized boolean expression, e.g. in an if- or while-stmt.
+The parens are discarded and the expression node is returned.
+The `pos' field of the return value is set to an absolute position
+that must be fixed up by the caller.
+Return value is a list (EXPR LP RP), with absolute paren positions."
+  (let (pn lp rp)
+    (if (js2-must-match js2-LP "msg.no.paren.cond")
+        (setq lp js2-token-beg))
+    (setq pn (js2-parse-expr))
+    (if (js2-must-match js2-RP "msg.no.paren.after.cond")
+        (setq rp js2-token-beg))
+    ;; Report strict warning on code like "if (a = 7) ..."
+    (if (and js2-strict-cond-assign-warning
+             (js2-assign-node-p pn))
+        (js2-add-strict-warning "msg.equal.as.assign" nil
+                                (js2-node-pos pn)
+                                (+ (js2-node-pos pn)
+                                   (js2-node-len pn))))
+    (list pn lp rp)))
+
+(defun js2-parse-if ()
+  "Parser for if-statement.  Last matched token must be js2-IF."
+  (let ((pos js2-token-beg)
+        cond
+        if-true
+        if-false
+        else-pos
+        end
+        pn)
+    (js2-consume-token)
+    (setq cond (js2-parse-condition)
+          if-true (js2-parse-statement)
+          if-false (if (js2-match-token js2-ELSE)
+                       (progn
+                         (setq else-pos (- js2-token-beg pos))
+                         (js2-parse-statement)))
+          end (js2-node-end (or if-false if-true))
+          pn (make-js2-if-node :pos pos
+                               :len (- end pos)
+                               :condition (car cond)
+                               :then-part if-true
+                               :else-part if-false
+                               :else-pos else-pos
+                               :lp (js2-relpos (second cond) pos)
+                               :rp (js2-relpos (third cond) pos)))
+    (js2-node-add-children pn (car cond) if-true if-false)
+    pn))
+
+(defun js2-parse-switch ()
+  "Parser for if-statement.  Last matched token must be js2-SWITCH."
+  (let ((pos js2-token-beg)
+        tt
+        pn
+        discriminant
+        has-default
+        case-expr
+        case-node
+        case-pos
+        cases
+        stmt
+        lp
+        rp)
+    (js2-consume-token)
+    (if (js2-must-match js2-LP "msg.no.paren.switch")
+        (setq lp js2-token-beg))
+    (setq discriminant (js2-parse-expr)
+          pn (make-js2-switch-node :discriminant discriminant
+                                   :pos pos
+                                   :lp (js2-relpos lp pos)))
+    (js2-node-add-children pn discriminant)
+    (js2-enter-switch pn)
+    (unwind-protect
+        (progn
+          (if (js2-must-match js2-RP "msg.no.paren.after.switch")
+              (setf (js2-switch-node-rp pn) (- js2-token-beg pos)))
+          (js2-must-match js2-LC "msg.no.brace.switch")
+          (catch 'break
+            (while t
+              (setq tt (js2-next-token)
+                    case-pos js2-token-beg)
+              (cond
+               ((= tt js2-RC)
+                (setf (js2-node-len pn) (- js2-token-end pos))
+                (throw 'break nil))  ; done
+               ((= tt js2-CASE)
+                (setq case-expr (js2-parse-expr))
+                (js2-must-match js2-COLON "msg.no.colon.case"))
+               ((= tt js2-DEFAULT)
+                (if has-default
+                    (js2-report-error "msg.double.switch.default"))
+                (setq has-default t
+                      case-expr nil)
+                (js2-must-match js2-COLON "msg.no.colon.case"))
+               (t
+                (js2-report-error "msg.bad.switch")
+                (throw 'break nil)))
+              (setq case-node (make-js2-case-node :pos case-pos
+                                                  :len (- js2-token-end case-pos)
+                                                  :expr case-expr))
+              (js2-node-add-children case-node case-expr)
+              (while (and (/= (setq tt (js2-peek-token)) js2-RC)
+                          (/= tt js2-CASE)
+                          (/= tt js2-DEFAULT)
+                          (/= tt js2-EOF))
+                (setf stmt (js2-parse-statement)
+                      (js2-node-len case-node) (- (js2-node-end stmt) case-pos))
+                (js2-block-node-push case-node stmt))
+              (push case-node cases)))
+          ;; add cases last, as pushing reverses the order to be correct
+          (dolist (kid cases)
+            (js2-node-add-children pn kid)
+            (push kid (js2-switch-node-cases pn)))
+          pn)  ; return value
+      (js2-exit-switch))))
+
+(defun js2-parse-while ()
+  "Parser for while-statement.  Last matched token must be js2-WHILE."
+  (let ((pos js2-token-beg)
+        (pn (make-js2-while-node))
+        cond
+        body)
+    (js2-consume-token)
+    (js2-enter-loop pn)
+    (unwind-protect
+        (progn
+          (setf cond (js2-parse-condition)
+                (js2-while-node-condition pn) (car cond)
+                body (js2-parse-statement)
+                (js2-while-node-body pn) body
+                (js2-node-len pn) (- (js2-node-end body) pos)
+                (js2-while-node-lp pn) (js2-relpos (second cond) pos)
+                (js2-while-node-rp pn) (js2-relpos (third cond) pos))
+          (js2-node-add-children pn body (car cond)))
+      (js2-exit-loop))
+    pn))
+
+(defun js2-parse-do ()
+  "Parser for do-statement.  Last matched token must be js2-DO."
+  (let ((pos js2-token-beg)
+        (pn (make-js2-do-node))
+        cond
+        body
+        end)
+    (js2-consume-token)
+    (js2-enter-loop pn)
+    (unwind-protect
+        (progn
+          (setq body (js2-parse-statement))
+          (js2-must-match js2-WHILE "msg.no.while.do")
+          (setf (js2-do-node-while-pos pn) (- js2-token-beg pos)
+                cond (js2-parse-condition)
+                (js2-do-node-condition pn) (car cond)
+                (js2-do-node-body pn) body
+                end js2-ts-cursor
+                (js2-do-node-lp pn) (js2-relpos (second cond) pos)
+                (js2-do-node-rp pn) (js2-relpos (third cond) pos))
+          (js2-node-add-children pn (car cond) body))
+      (js2-exit-loop))
+    ;; Always auto-insert semicolon to follow SpiderMonkey:
+    ;; It is required by ECMAScript but is ignored by the rest of
+    ;; world; see bug 238945
+    (if (js2-match-token js2-SEMI)
+        (setq end js2-ts-cursor))
+    (setf (js2-node-len pn) (- end pos))
+    pn))
+
+(defun js2-parse-for ()
+  "Parser for for-statement.  Last matched token must be js2-FOR.
+Parses for, for-in, and for each-in statements."
+  (let ((for-pos js2-token-beg)
+        pn
+        is-for-each
+        is-for-in
+        in-pos
+        each-pos
+        tmp-pos
+        init  ; Node init is also foo in 'foo in object'
+        cond  ; Node cond is also object in 'foo in object'
+        incr  ; 3rd section of for-loop initializer
+        body
+        tt
+        lp
+        rp)
+    (js2-consume-token)
+    ;; See if this is a for each () instead of just a for ()
+    (when (js2-match-token js2-NAME)
+      (if (string= "each" js2-ts-string)
+          (progn
+            (setq is-for-each t
+                  each-pos (- js2-token-beg for-pos)) ; relative
+            (js2-record-face 'font-lock-keyword-face))
+        (js2-report-error "msg.no.paren.for")))
+    (if (js2-must-match js2-LP "msg.no.paren.for")
+        (setq lp (- js2-token-beg for-pos)))
+    (setq tt (js2-peek-token))
+    ;; parse init clause
+    (let ((js2-in-for-init t))  ; set as dynamic variable
+      (cond
+       ((= tt js2-SEMI)
+        (setq init (make-js2-empty-expr-node)))
+       ((or (= tt js2-VAR) (= tt js2-LET))
+        (js2-consume-token)
+        (setq init (js2-parse-variables tt js2-token-beg)))
+       (t
+        (setq init (js2-parse-expr)))))
+    (if (js2-match-token js2-IN)
+        (setq is-for-in t
+              in-pos (- js2-token-beg for-pos)
+              cond (js2-parse-expr))  ; object over which we're iterating
+      ;; else ordinary for loop - parse cond and incr
+      (js2-must-match js2-SEMI "msg.no.semi.for")
+      (setq cond (if (= (js2-peek-token) js2-SEMI)
+                     (make-js2-empty-expr-node) ; no loop condition
+                   (js2-parse-expr)))
+      (js2-must-match js2-SEMI "msg.no.semi.for.cond")
+      (setq tmp-pos js2-token-end
+            incr (if (= (js2-peek-token) js2-RP)
+                     (make-js2-empty-expr-node :pos tmp-pos)
+                   (js2-parse-expr))))
+    (if (js2-must-match js2-RP "msg.no.paren.for.ctrl")
+        (setq rp (- js2-token-beg for-pos)))
+    (if (not is-for-in)
+        (setq pn (make-js2-for-node :init init
+                                    :condition cond
+                                    :update incr
+                                    :lp lp
+                                    :rp rp))
+      ;; cond could be null if 'in obj' got eaten by the init node.
+      (if (js2-infix-node-p init)
+          ;; it was (foo in bar) instead of (var foo in bar)
+          (setq cond (js2-infix-node-right init)
+                init (js2-infix-node-left init))
+        (if (and (js2-var-decl-node-p init)
+                 (> (length (js2-var-decl-node-kids init)) 1))
+            (js2-report-error "msg.mult.index")))
+      (setq pn (make-js2-for-in-node :iterator init
+                                     :object cond
+                                     :in-pos in-pos
+                                     :foreach-p is-for-each
+                                     :each-pos each-pos
+                                     :lp lp
+                                     :rp rp)))
+    (unwind-protect
+        (progn
+          (js2-enter-loop pn)
+          ;; We have to parse the body -after- creating the loop node,
+          ;; so that the loop node appears in the js2-loop-set, allowing
+          ;; break/continue statements to find the enclosing loop.
+          (setf body (js2-parse-statement)
+                (js2-loop-node-body pn) body
+                (js2-node-pos pn) for-pos
+                (js2-node-len pn) (- (js2-node-end body) for-pos))
+          (js2-node-add-children pn init cond incr body))
+      ;; finally
+      (js2-exit-loop))
+    pn))
+
+(defun js2-parse-try ()
+  "Parser for try-statement.  Last matched token must be js2-TRY."
+  (let ((try-pos js2-token-beg)
+        try-end
+        try-block
+        catch-blocks
+        finally-block
+        saw-default-catch
+        peek
+        var-name
+        catch-cond
+        catch-node
+        guard-kwd
+        catch-pos
+        finally-pos
+        pn
+        block
+        lp
+        rp)
+    (js2-consume-token)
+    (if (/= (js2-peek-token) js2-LC)
+        (js2-report-error "msg.no.brace.try"))
+    (setq try-block (js2-parse-statement)
+          try-end (js2-node-end try-block)
+          peek (js2-peek-token))
+    (cond
+     ((= peek js2-CATCH)
+      (while (js2-match-token js2-CATCH)
+        (setq catch-pos js2-token-beg
+              guard-kwd nil
+              catch-cond nil
+              lp nil
+              rp nil)
+        (if saw-default-catch
+            (js2-report-error "msg.catch.unreachable"))
+        (if (js2-must-match js2-LP "msg.no.paren.catch")
+            (setq lp (- js2-token-beg catch-pos)))
+        (js2-must-match js2-NAME "msg.bad.catchcond")
+        (setq var-name (js2-create-name-node))
+        (if (js2-match-token js2-IF)
+            (setq guard-kwd (- js2-token-beg catch-pos)
+                  catch-cond (js2-parse-expr))
+          (setq saw-default-catch t))
+        (if (js2-must-match js2-RP "msg.bad.catchcond")
+            (setq rp (- js2-token-beg catch-pos)))
+        (js2-must-match js2-LC "msg.no.brace.catchblock")
+        (setq block (js2-parse-statements)
+              try-end (js2-node-end block)
+              catch-node (make-js2-catch-node :pos catch-pos
+                                              :var-name var-name
+                                              :guard-expr catch-cond
+                                              :guard-kwd guard-kwd
+                                              :block block
+                                              :lp lp
+                                              :rp rp))
+        (if (js2-must-match js2-RC "msg.no.brace.after.body")
+            (setq try-end js2-token-beg))
+        (setf (js2-node-len block) (- try-end (js2-node-pos block))
+              (js2-node-len catch-node) (- try-end catch-pos))
+        (js2-node-add-children catch-node var-name catch-cond block)
+        (push catch-node catch-blocks)))
+     ((/= peek js2-FINALLY)
+      (js2-must-match js2-FINALLY "msg.try.no.catchfinally"
+                      (js2-node-pos try-block)
+                      (- (setq try-end (js2-node-end try-block))
+                         (js2-node-pos try-block)))))
+    (when (js2-match-token js2-FINALLY)
+      (setq finally-pos js2-token-beg
+            block (js2-parse-statement)
+            try-end (js2-node-end block)
+            finally-block (make-js2-finally-node :pos finally-pos
+                                                 :len (- try-end finally-pos)
+                                                 :body block))
+      (js2-node-add-children finally-block block))
+    (setq pn (make-js2-try-node :pos try-pos
+                                :len (- try-end try-pos)
+                                :try-block try-block
+                                :finally-block finally-block))
+    (js2-node-add-children pn try-block finally-block)
+    ;; push them onto the try-node, which reverses and corrects their order
+    (dolist (cb catch-blocks)
+      (js2-node-add-children pn cb)
+      (push cb (js2-try-node-catch-clauses pn)))
+    pn))
+
+(defun js2-parse-throw ()
+  "Parser for throw-statement.  Last matched token must be js2-THROW."
+  (let ((pos js2-token-beg)
+        expr
+        pn)
+    (js2-consume-token)
+    (if (= (js2-peek-token-or-eol) js2-EOL)
+        ;; ECMAScript does not allow new lines before throw expression,
+        ;; see bug 256617
+        (js2-report-error "msg.bad.throw.eol"))
+    (setq expr (js2-parse-expr)
+          pn (make-js2-throw-node :pos pos
+                                  :len (- (js2-node-end expr) pos)
+                                  :expr expr))
+    (js2-node-add-children pn expr)
+    pn))
+
+(defsubst js2-match-jump-label-name (label-name)
+  "If break/continue specified a label, return that label's labeled stmt.
+Returns the corresponding `js2-labeled-stmt-node', or if LABEL-NAME
+does not match an existing label, reports an error and returns nil."
+  (let ((bundle (cdr (assoc label-name js2-label-set))))
+    (if (null bundle)
+        (js2-report-error "msg.undef.label"))
+    bundle))
+
+(defun js2-parse-break ()
+  "Parser for break-statement.  Last matched token must be js2-BREAK."
+  (let ((pos js2-token-beg)
+        (end js2-token-end)
+        break-target ; statement to break from
+        break-label  ; in "break foo", name-node representing the foo
+        labels       ; matching labeled statement to break to
+        pn)
+    (js2-consume-token)  ; `break'
+    (when (eq (js2-peek-token-or-eol) js2-NAME)
+      (js2-consume-token)
+      (setq break-label (js2-create-name-node)
+            end (js2-node-end break-label)
+            ;; matchJumpLabelName only matches if there is one
+            labels (js2-match-jump-label-name js2-ts-string)
+            break-target (if labels (car (js2-labeled-stmt-node-labels labels)))))
+    (unless (or break-target break-label)
+      ;; no break target specified - try for innermost enclosing loop/switch
+      (if (null js2-loop-and-switch-set)
+          (unless break-label
+            (js2-report-error "msg.bad.break" nil pos (length "break")))
+        (setq break-target (car js2-loop-and-switch-set))))
+    (setq pn (make-js2-break-node :pos pos
+                                  :len (- end pos)
+                                  :label break-label
+                                  :target break-target))
+    (js2-node-add-children pn break-label)  ; but not break-target
+    pn))
+
+(defun js2-parse-continue ()
+  "Parser for continue-statement.  Last matched token must be js2-CONTINUE."
+  (let ((pos js2-token-beg)
+        (end js2-token-end)
+        label   ; optional user-specified label, a `js2-name-node'
+        labels  ; current matching labeled stmt, if any
+        target  ; the `js2-loop-node' target of this continue stmt
+        pn)
+    (js2-consume-token)  ; `continue'
+    (when (= (js2-peek-token-or-eol) js2-NAME)
+      (js2-consume-token)
+      (setq label (js2-create-name-node)
+            end (js2-node-end label)
+            ;; matchJumpLabelName only matches if there is one
+            labels (js2-match-jump-label-name js2-ts-string)))
+    (cond
+     ((null labels)  ; no current label to go to
+      (if (null js2-loop-set)  ; no loop to continue to
+          (js2-report-error "msg.continue.outside" nil pos
+                            (length "continue"))
+        (setq target (car js2-loop-set))))  ; innermost enclosing loop
+     (t
+      (if (js2-loop-node-p (js2-labeled-stmt-node-stmt labels))
+          (setq target (js2-labeled-stmt-node-stmt labels))
+        (js2-report-error "msg.continue.nonloop" nil pos (- end pos)))))
+    (setq pn (make-js2-continue-node :pos pos
+                                     :len (- end pos)
+                                     :label label
+                                     :target target))
+    (js2-node-add-children pn label)  ; but not target - it's not our child
+    pn))
+
+(defun js2-parse-with ()
+  "Parser for with-statement.  Last matched token must be js2-WITH."
+  (js2-consume-token)
+  (let ((pos js2-token-beg)
+        obj body pn lp rp)
+    (if (js2-must-match js2-LP "msg.no.paren.with")
+        (setq lp js2-token-beg))
+    (setq obj (js2-parse-expr))
+    (if (js2-must-match js2-RP "msg.no.paren.after.with")
+        (setq rp js2-token-beg))
+    (let ((js2-nesting-of-with (1+ js2-nesting-of-with)))
+        (setq body (js2-parse-statement)))
+    (setq pn (make-js2-with-node :pos pos
+                                 :len (- (js2-node-end body) pos)
+                                 :object obj
+                                 :body body
+                                 :lp (js2-relpos lp pos)
+                                 :rp (js2-relpos rp pos)))
+    (js2-node-add-children pn obj body)
+    pn))
+
+(defun js2-parse-const-var ()
+  "Parser for var- or const-statement.
+Last matched token must be js2-CONST or js2-VAR."
+  (let ((tt (js2-peek-token))
+        (pos js2-token-beg)
+        expr
+        pn)
+    (js2-consume-token)
+    (setq expr (js2-parse-variables tt js2-token-beg)
+          pn (make-js2-expr-stmt-node :pos pos
+                                      :len (- (js2-node-end expr) pos)
+                                      :expr expr))
+    (js2-node-add-children pn expr)
+    pn))
+
+(defsubst js2-wrap-with-expr-stmt (pos expr &optional add-child)
+  (let ((pn (make-js2-expr-stmt-node :pos pos
+                                     :len (js2-node-len expr)
+                                     :type (if (js2-inside-function)
+                                               js2-EXPR_VOID
+                                             js2-EXPR_RESULT)
+                                     :expr expr)))
+    (if add-child
+        (js2-node-add-children pn expr))
+    pn))
+
+(defun js2-parse-let-stmt ()
+  "Parser for let-statement.  Last matched token must be js2-LET."
+  (js2-consume-token)
+  (let ((pos js2-token-beg)
+        expr
+        pn)
+    (if (= (js2-peek-token) js2-LP)
+        ;; let expression in statement context
+        (setq expr (js2-parse-let pos 'statement)
+              pn (js2-wrap-with-expr-stmt pos expr t))
+      ;; else we're looking at a statement like let x=6, y=7;
+      (setf expr (js2-parse-variables js2-LET pos)
+            pn (js2-wrap-with-expr-stmt pos expr t)
+            (js2-node-type pn) js2-EXPR_RESULT))
+    pn))
+
+(defun js2-parse-ret-yield ()
+  (js2-parse-return-or-yield (js2-peek-token) nil))
+
+(defconst js2-parse-return-stmt-enders
+  (list js2-SEMI js2-RC js2-EOF js2-EOL js2-ERROR js2-RB js2-RP js2-YIELD))
+
+(defsubst js2-now-all-set (before after mask)
+  "Return whether or not the bits in the mask have changed to all set.
+BEFORE is bits before change, AFTER is bits after change, and MASK is
+the mask for bits.  Returns t if all the bits in the mask are set in AFTER
+but not BEFORE."
+  (and (/= (logand before mask) mask)
+       (= (logand after mask) mask)))
+
+(defun js2-parse-return-or-yield (tt expr-context)
+  (let ((pos js2-token-beg)
+        (end js2-token-end)
+        (before js2-end-flags)
+        (inside-function (js2-inside-function))
+        e
+        ret
+        name)
+    (unless inside-function
+      (js2-report-error (if (eq tt js2-RETURN)
+                            "msg.bad.return"
+                          "msg.bad.yield")))
+    (js2-consume-token)
+    ;; This is ugly, but we don't want to require a semicolon.
+    (unless (memq (js2-peek-token-or-eol) js2-parse-return-stmt-enders)
+      (setq e (js2-parse-expr)
+            end (js2-node-end e)))
+    (cond
+     ((eq tt js2-RETURN)
+      (js2-set-flag js2-end-flags (if (null e)
+                                      js2-end-returns
+                                    js2-end-returns-value))
+      (setq ret (make-js2-return-node :pos pos
+                                      :len (- end pos)
+                                      :retval e))
+      (js2-node-add-children ret e)
+      ;; See if we need a strict mode warning.
+      ;; TODO:  The analysis done by `js2-has-consistent-return-usage' is
+      ;; more thorough and accurate than this before/after flag check.
+      ;; E.g. if there's a finally-block that always returns, we shouldn't
+      ;; show a warning generated by inconsistent returns in the catch blocks.
+      ;; Basically `js2-has-consistent-return-usage' needs to keep more state,
+      ;; so we know which returns/yields to highlight, and we should get rid of
+      ;; all the checking in `js2-parse-return-or-yield'.
+      (if (and js2-strict-inconsistent-return-warning
+               (js2-now-all-set before js2-end-flags
+                                (logior js2-end-returns js2-end-returns-value)))
+          (js2-add-strict-warning "msg.return.inconsistent" nil pos end)))
+     (t
+      (unless (js2-inside-function)
+        (js2-report-error "msg.bad.yield"))
+      (js2-set-flag js2-end-flags js2-end-yields)
+      (setq ret (make-js2-yield-node :pos pos
+                                     :len (- end pos)
+                                     :value e))
+      (js2-node-add-children ret e)
+      (unless expr-context
+        (setq e ret
+              ret (js2-wrap-with-expr-stmt pos e t))
+      (js2-set-requires-activation)
+      (js2-set-is-generator))))
+    ;; see if we are mixing yields and value returns.
+    (when (and inside-function
+               (js2-now-all-set before js2-end-flags
+                                (logior js2-end-yields js2-end-returns-value)))
+      (setq name (js2-function-name js2-current-script-or-fn))
+      (if (zerop (length name))
+          (js2-report-error "msg.anon.generator.returns" nil pos (- end pos))
+        (js2-report-error "msg.generator.returns" name pos (- end pos))))
+    ret))
+
+(defun js2-parse-debugger ()
+  (js2-consume-token)
+  (make-js2-keyword-node :type js2-DEBUGGER))
+
+(defun js2-parse-block ()
+  "Parser for a curly-delimited statement block.
+Last token matched must be js2-LC."
+  (let ((pos js2-token-beg)
+        (pn (make-js2-scope)))
+    (js2-consume-token)
+    (js2-push-scope pn)
+    (unwind-protect
+        (progn
+          (js2-parse-statements pn)
+          (js2-must-match js2-RC "msg.no.brace.block")
+          (setf (js2-node-len pn) (- js2-token-end pos)))
+      (js2-pop-scope))
+    pn))
+
+;; for js2-ERROR too, to have a node for error recovery to work on
+(defun js2-parse-semi ()
+  "Parse a statement or handle an error.
+Last matched token is js-SEMI or js-ERROR."
+  (let ((tt (js2-peek-token)) pos len)
+    (js2-consume-token)
+    (if (eq tt js2-SEMI)
+        (make-js2-empty-expr-node :len 1)
+      (setq pos js2-token-beg
+            len (- js2-token-beg pos))
+      (js2-report-error "msg.syntax" nil pos len)
+      (make-js2-error-node :pos pos :len len))))
+
+(defun js2-parse-default-xml-namespace ()
+  "Parse a `default xml namespace = <expr>' e4x statement."
+  (let ((pos js2-token-beg)
+        end len expr unary es)
+    (js2-consume-token)
+    (js2-must-have-xml)
+    (js2-set-requires-activation)
+    (setq len (- js2-ts-cursor pos))
+    (unless (and (js2-match-token js2-NAME)
+                 (string= js2-ts-string "xml"))
+      (js2-report-error "msg.bad.namespace" nil pos len))
+    (unless (and (js2-match-token js2-NAME)
+                 (string= js2-ts-string "namespace"))
+      (js2-report-error "msg.bad.namespace" nil pos len))
+    (unless (js2-match-token js2-ASSIGN)
+      (js2-report-error "msg.bad.namespace" nil pos len))
+    (setq expr (js2-parse-expr)
+          end (js2-node-end expr)
+          unary (make-js2-unary-node :type js2-DEFAULTNAMESPACE
+                                     :pos pos
+                                     :len (- end pos)
+                                     :operand expr))
+    (js2-node-add-children unary expr)
+    (make-js2-expr-stmt-node :pos pos
+                             :len (- end pos)
+                             :expr unary)))
+
+(defun js2-record-label (label bundle)
+  ;; current token should be colon that `js2-parse-primary-expr' left untouched
+  (js2-consume-token)
+  (let ((name (js2-label-node-name label))
+        labeled-stmt
+        dup)
+    (when (setq labeled-stmt (cdr (assoc name js2-label-set)))
+      ;; flag both labels if possible when used in editing mode
+      (if (and js2-parse-ide-mode
+               (setq dup (js2-get-label-by-name labeled-stmt name)))
+          (js2-report-error "msg.dup.label" nil
+                            (js2-node-abs-pos dup) (js2-node-len dup)))
+      (js2-report-error "msg.dup.label" nil
+                        (js2-node-pos label) (js2-node-len label)))
+    (js2-labeled-stmt-node-add-label bundle label)
+    (js2-node-add-children bundle label)
+    ;; Add one reference to the bundle per label in `js2-label-set'
+    (push (cons name bundle) js2-label-set)))
+
+(defun js2-parse-name-or-label ()
+  "Parser for identifier or label.  Last token matched must be js2-NAME.
+Called when we found a name in a statement context.  If it's a label, we gather
+up any following labels and the next non-label statement into a
+`js2-labeled-stmt-node' bundle and return that.  Otherwise we parse an
+expression and return it wrapped in a `js2-expr-stmt-node'."
+  (let ((pos js2-token-beg)
+        (end js2-token-end)
+        expr
+        stmt
+        pn
+        bundle
+        (continue t))
+    ;; set check for label and call down to `js2-parse-primary-expr'
+    (js2-set-check-for-label)
+    (setq expr (js2-parse-expr))
+    (if (/= (js2-node-type expr) js2-LABEL)
+        ;; Parsed non-label expression - wrap with expression stmt.
+        (setq pn (js2-wrap-with-expr-stmt pos expr t))
+      ;; else parsed a label
+      (setq bundle (make-js2-labeled-stmt-node :pos pos))
+      (js2-record-label expr bundle)
+      ;; look for more labels
+      (while (and continue (= (js2-peek-token) js2-NAME))
+        (js2-set-check-for-label)
+        (setq expr (js2-parse-expr))
+        (if (/= (js2-node-type expr) js2-LABEL)
+            (progn
+              (setq stmt (js2-wrap-with-expr-stmt (js2-node-pos expr) expr t)
+                    continue nil)
+              (js2-auto-insert-semicolon stmt))
+          (js2-record-label expr bundle)))
+      ;; no more labels; now parse the labeled statement
+      (unwind-protect
+            (unless stmt
+              (let ((js2-labeled-stmt bundle))  ; bind dynamically
+                (setq stmt (js2-statement-helper))))
+        ;; remove the labels for this statement from the global set
+        (dolist (label (js2-labeled-stmt-node-labels bundle))
+          (setq js2-label-set (remove label js2-label-set))))
+      (setf (js2-labeled-stmt-node-stmt bundle) stmt
+            (js2-node-len bundle) (- (js2-node-end stmt) pos))
+      (js2-node-add-children bundle stmt)
+      bundle)))
+
+(defun js2-parse-expr-stmt ()
+  "Default parser in statement context, if no recognized statement found."
+  (js2-wrap-with-expr-stmt js2-token-beg (js2-parse-expr) t))
+
+(defun js2-parse-variables (decl-type pos)
+  "Parse a comma-separated list of variable declarations.
+Could be a 'var', 'const' or 'let' expression, possibly in a for-loop initializer.
+
+DECL-TYPE is a token value: either VAR, CONST, or LET depending on context.
+For 'var' or 'const', the keyword should be the token last scanned.
+
+POS is the position where the node should start. It's sometimes the
+var/const/let keyword, and other times the beginning of the first token
+in the first variable declaration.
+
+Returns the parsed `js2-var-decl-node' expression node."
+  (let* ((result (make-js2-var-decl-node :decl-type decl-type
+                                         :pos pos))
+         destructuring
+         kid-pos
+         tt
+         init
+         name
+         end
+         nbeg nend
+         vi
+         (continue t))
+    ;; Example:
+    ;; var foo = {a: 1, b: 2}, bar = [3, 4];
+    ;; var {b: s2, a: s1} = foo, x = 6, y, [s3, s4] = bar;
+    (while continue
+      (setq destructuring nil
+            name nil
+            tt (js2-peek-token)
+            kid-pos js2-token-beg
+            end js2-token-end
+            init nil)
+      (if (or (= tt js2-LB) (= tt js2-LC))
+          ;; Destructuring assignment, e.g., var [a, b] = ...
+          (setq destructuring (js2-parse-primary-expr)
+                end (js2-node-end destructuring))
+        ;; Simple variable name
+        (when (js2-must-match js2-NAME "msg.bad.var")
+          (setq name (js2-create-name-node)
+                nbeg js2-token-beg
+                nend js2-token-end
+                end nend)
+          (js2-define-symbol decl-type js2-ts-string name js2-in-for-init)))
+      (when (js2-match-token js2-ASSIGN)
+        (setq init (js2-parse-assign-expr)
+              end (js2-node-end init))
+        (if (and js2-parse-ide-mode
+                 (or (js2-object-node-p init)
+                     (js2-function-node-p init)))
+            (js2-record-imenu-functions init name)))
+      (when name
+        (js2-set-face nbeg nend (if (js2-function-node-p init)
+                                    'font-lock-function-name-face
+                                  'font-lock-variable-name-face)
+                      'record))
+      (setq vi (make-js2-var-init-node :pos kid-pos
+                                       :len (- end kid-pos)
+                                       :type decl-type))
+      (if destructuring
+          (progn
+            (if (and (null init) (not js2-in-for-init))
+                (js2-report-error "msg.destruct.assign.no.init"))
+            (setf (js2-var-init-node-target vi) destructuring))
+        (setf (js2-var-init-node-target vi) name))
+      (setf (js2-var-init-node-initializer vi) init)
+      (js2-node-add-children vi name destructuring init)
+      (js2-block-node-push result vi)
+      (unless (js2-match-token js2-COMMA)
+        (setq continue nil)))
+    (setf (js2-node-len result) (- end pos))
+    result))
+
+(defun js2-parse-let (pos &optional stmt-p)
+  "Parse a let expression or statement.
+A let-expression is of the form `let (vars) expr'.
+A let-statment is of the form `let (vars) {statements}'.
+The third form of let is a variable declaration list, handled
+by `js2-parse-variables'."
+  (let ((pn (make-js2-let-node :pos pos))
+        beg vars body)
+    (if (js2-must-match js2-LP "msg.no.paren.after.let")
+        (setf (js2-let-node-lp pn) (- js2-token-beg pos)))
+    (js2-push-scope pn)
+    (unwind-protect
+        (progn
+          (setq vars (js2-parse-variables js2-LET js2-token-beg))
+          (if (js2-must-match js2-RP "msg.no.paren.let")
+              (setf (js2-let-node-rp pn) (- js2-token-beg pos)))
+          (if (and stmt-p (eq (js2-peek-token) js2-LC))
+              ;; let statement
+              (progn
+                (js2-consume-token)
+                (setf beg js2-token-beg  ; position stmt at LC
+                      body (js2-parse-statements))
+                (js2-must-match js2-RC "msg.no.curly.let")
+                (setf (js2-node-len body) (- js2-token-end beg)
+                      (js2-node-len pn) (- js2-token-end pos)
+                      (js2-let-node-body pn) body
+                      (js2-node-type pn) js2-LET))
+            ;; let expression
+            (setf body (js2-parse-expr)
+                  (js2-node-len pn) (- (js2-node-end body) pos)
+                  (js2-let-node-body pn) body))
+          (js2-node-add-children pn vars body))
+      (js2-pop-scope))
+    pn))
+
+(defsubst js2-define-new-symbol (decl-type name node)
+  (js2-scope-put-symbol js2-current-scope
+                        name
+                        (make-js2-symbol decl-type name node)))
+
+(defun js2-define-symbol (decl-type name &optional node ignore-not-in-block)
+  "Define a symbol in the current scope.
+If NODE is non-nil, it is the AST node associated with the symbol."
+  (let* ((defining-scope (js2-get-defining-scope js2-current-scope name))
+         (symbol (if defining-scope
+                     (js2-scope-get-symbol defining-scope name)))
+         (sdt (if symbol (js2-symbol-decl-type symbol) -1)))
+    (cond
+     ((and symbol ; already defined
+           (or (= sdt js2-CONST) ; old version is const
+               (= decl-type js2-CONST) ; new version is const
+               ;; two let-bound vars in this block have same name
+               (and (= sdt js2-LET)
+                    (eq defining-scope js2-current-scope))))
+      (js2-report-error
+       (cond
+        ((= sdt js2-CONST) "msg.const.redecl")
+        ((= sdt js2-LET) "msg.let.redecl")
+        ((= sdt js2-VAR) "msg.var.redecl")
+        ((= sdt js2-FUNCTION) "msg.function.redecl")
+        (t "msg.parm.redecl"))
+       name))
+     ((= decl-type js2-LET)
+      (if (and (not ignore-not-in-block)
+               (or (= (js2-node-type js2-current-scope) js2-IF)
+                   (js2-loop-node-p js2-current-scope)))
+          (js2-report-error "msg.let.decl.not.in.block")
+        (js2-define-new-symbol decl-type name node)))
+     ((or (= decl-type js2-VAR)
+          (= decl-type js2-CONST)
+          (= decl-type js2-FUNCTION))
+      (if symbol
+          (if (and js2-strict-var-redeclaration-warning (= sdt js2-VAR))
+              (js2-add-strict-warning "msg.var.redecl" name)
+            (if (and js2-strict-var-hides-function-arg-warning (= sdt js2-LP))
+                (js2-add-strict-warning "msg.var.hides.arg" name)))
+        (js2-define-new-symbol decl-type name node)))
+     ((= decl-type js2-LP)
+      (if symbol
+          ;; must be duplicate parameter. Second parameter hides the
+          ;; first, so go ahead and add the second pararameter
+          (js2-report-warning "msg.dup.parms" name))
+      (js2-define-new-symbol decl-type name node))
+     (t (js2-code-bug)))))
+
+(defun js2-parse-expr ()
+  (let* ((pn (js2-parse-assign-expr))
+         (pos (js2-node-pos pn))
+         left
+         right
+         op-pos)
+    (while (js2-match-token js2-COMMA)
+      (setq op-pos (- js2-token-beg pos))  ; relative
+      (if (= (js2-peek-token) js2-YIELD)
+          (js2-report-error "msg.yield.parenthesized"))
+      (setq right (js2-parse-assign-expr)
+            left pn
+            pn (make-js2-infix-node :type js2-COMMA
+                                    :pos pos
+                                    :len (- js2-ts-cursor pos)
+                                    :op-pos op-pos
+                                    :left left
+                                    :right right))
+      (js2-node-add-children pn left right))
+    pn))
+
+(defun js2-parse-assign-expr ()
+  (let ((tt (js2-peek-token))
+        (pos js2-token-beg)
+        pn
+        left
+        right
+        op-pos)
+    (if (= tt js2-YIELD)
+        (js2-parse-return-or-yield tt t)
+      ;; not yield - parse assignment expression
+      (setq pn (js2-parse-cond-expr)
+            tt (js2-peek-token))
+      (when (and (<= js2-first-assign tt)
+                 (<= tt js2-last-assign))
+        (js2-consume-token)
+        (setq op-pos (- js2-token-beg pos)  ; relative
+              left pn
+              right (js2-parse-assign-expr)
+              pn (make-js2-assign-node :type tt
+                                       :pos pos
+                                       :len (- (js2-node-end right) pos)
+                                       :op-pos op-pos
+                                       :left left
+                                       :right right))
+        (when js2-parse-ide-mode
+          (js2-highlight-assign-targets pn left right)
+          (if (or (js2-function-node-p right)
+                  (js2-object-node-p right))
+              (js2-record-imenu-functions right left)))
+        ;; do this last so ide checks above can use absolute positions
+        (js2-node-add-children pn left right))
+      pn)))
+
+(defun js2-parse-cond-expr ()
+  (let ((pos js2-token-beg)
+        (pn (js2-parse-or-expr))
+        test-expr
+        if-true
+        if-false
+        q-pos
+        c-pos)
+    (when (js2-match-token js2-HOOK)
+      (setq q-pos (- js2-token-beg pos)
+            if-true (js2-parse-assign-expr))
+      (js2-must-match js2-COLON "msg.no.colon.cond")
+      (setq c-pos (- js2-token-beg pos)
+            if-false (js2-parse-assign-expr)
+            test-expr pn
+            pn (make-js2-cond-node :pos pos
+                                   :len (- (js2-node-end if-false) pos)
+                                   :test-expr test-expr
+                                   :true-expr if-true
+                                   :false-expr if-false
+                                   :q-pos q-pos
+                                   :c-pos c-pos))
+      (js2-node-add-children pn test-expr if-true if-false))
+    pn))
+
+(defun js2-make-binary (type left parser)
+  "Helper for constructing a binary-operator AST node.
+LEFT is the left-side-expression, already parsed, and the
+binary operator should have just been matched.
+PARSER is a function to call to parse the right operand,
+or a `js2-node' struct if it has already been parsed."
+  (let* ((pos (js2-node-pos left))
+         (op-pos (- js2-token-beg pos))
+         (right (if (js2-node-p parser)
+                    parser
+                  (funcall parser)))
+         (pn (make-js2-infix-node :type type
+                                  :pos pos
+                                  :len (- (js2-node-end right) pos)
+                                  :op-pos op-pos
+                                  :left left
+                                  :right right)))
+    (js2-node-add-children pn left right)
+    pn))
+
+(defun js2-parse-or-expr ()
+  (let ((pn (js2-parse-and-expr)))
+    (when (js2-match-token js2-OR)
+      (setq pn (js2-make-binary js2-OR
+                                pn
+                                'js2-parse-or-expr)))
+    pn))
+
+(defun js2-parse-and-expr ()
+  (let ((pn (js2-parse-bit-or-expr)))
+    (when (js2-match-token js2-AND)
+      (setq pn (js2-make-binary js2-AND
+                                pn
+                                'js2-parse-and-expr)))
+    pn))
+
+(defun js2-parse-bit-or-expr ()
+  (let ((pn (js2-parse-bit-xor-expr)))
+    (while (js2-match-token js2-BITOR)
+      (setq pn (js2-make-binary js2-BITOR
+                                pn
+                                'js2-parse-bit-xor-expr)))
+    pn))
+
+(defun js2-parse-bit-xor-expr ()
+  (let ((pn (js2-parse-bit-and-expr)))
+    (while (js2-match-token js2-BITXOR)
+      (setq pn (js2-make-binary js2-BITXOR
+                                pn
+                                'js2-parse-bit-and-expr)))
+    pn))
+
+(defun js2-parse-bit-and-expr ()
+  (let ((pn (js2-parse-eq-expr)))
+    (while (js2-match-token js2-BITAND)
+      (setq pn (js2-make-binary js2-BITAND
+                                pn
+                                'js2-parse-eq-expr)))
+    pn))
+
+(defconst js2-parse-eq-ops
+  (list js2-EQ js2-NE js2-SHEQ js2-SHNE))
+
+(defun js2-parse-eq-expr ()
+  (let ((pn (js2-parse-rel-expr))
+        tt)
+    (while (memq (setq tt (js2-peek-token)) js2-parse-eq-ops)
+      (js2-consume-token)
+      (setq pn (js2-make-binary tt
+                                pn
+                                'js2-parse-rel-expr)))
+    pn))
+
+(defconst js2-parse-rel-ops
+  (list js2-IN js2-INSTANCEOF js2-LE js2-LT js2-GE js2-GT))
+
+(defun js2-parse-rel-expr ()
+  (let ((pn (js2-parse-shift-expr))
+        (continue t)
+        tt)
+    (while continue
+      (setq tt (js2-peek-token))
+      (cond
+       ((and js2-in-for-init (= tt js2-IN))
+        (setq continue nil))
+       ((memq tt js2-parse-rel-ops)
+        (js2-consume-token)
+        (setq pn (js2-make-binary tt pn 'js2-parse-shift-expr)))
+       (t
+        (setq continue nil))))
+    pn))
+
+(defconst js2-parse-shift-ops
+  (list js2-LSH js2-URSH js2-RSH))
+
+(defun js2-parse-shift-expr ()
+  (let ((pn (js2-parse-add-expr))
+        tt
+        (continue t))
+    (while continue
+      (setq tt (js2-peek-token))
+      (if (memq tt js2-parse-shift-ops)
+          (progn
+            (js2-consume-token)
+            (setq pn (js2-make-binary tt pn 'js2-parse-add-expr)))
+        (setq continue nil)))
+    pn))
+
+(defun js2-parse-add-expr ()
+  (let ((pn (js2-parse-mul-expr))
+        tt
+        (continue t))
+    (while continue
+      (setq tt (js2-peek-token))
+      (if (or (= tt js2-ADD) (= tt js2-SUB))
+          (progn
+            (js2-consume-token)
+            (setq pn (js2-make-binary tt pn 'js2-parse-mul-expr)))
+        (setq continue nil)))
+    pn))
+
+(defconst js2-parse-mul-ops
+  (list js2-MUL js2-DIV js2-MOD))
+
+(defun js2-parse-mul-expr ()
+  (let ((pn (js2-parse-unary-expr))
+        tt
+        (continue t))
+    (while continue
+      (setq tt (js2-peek-token))
+      (if (memq tt js2-parse-mul-ops)
+          (progn
+            (js2-consume-token)
+            (setq pn (js2-make-binary tt pn 'js2-parse-unary-expr)))
+        (setq continue nil)))
+    pn))
+
+(defsubst js2-make-unary (type parser &rest args)
+  "Make a unary node of type TYPE.
+PARSER is either a node (for postfix operators) or a function to call
+to parse the operand (for prefix operators)."
+  (let* ((pos js2-token-beg)
+         (postfix (js2-node-p parser))
+         (expr (if postfix
+                   parser
+                 (apply parser args)))
+         end
+         pn)
+    (if postfix  ; e.g. i++
+        (setq pos (js2-node-pos expr)
+              end js2-token-end)
+      (setq end (js2-node-end expr)))
+    (setq pn (make-js2-unary-node :type type
+                                  :pos pos
+                                  :len (- end pos)
+                                  :operand expr))
+    (js2-node-add-children pn expr)
+    pn))
+
+(defconst js2-incrementable-node-types
+  (list js2-NAME js2-GETPROP js2-GETELEM js2-GET_REF js2-CALL)
+  "Node types that can be the operand of a ++ or -- operator.")
+
+(defsubst js2-check-bad-inc-dec (tt beg end unary)
+  (unless (memq (js2-node-type (js2-unary-node-operand unary))
+                js2-incrementable-node-types)
+    (js2-report-error (if (= tt js2-INC)
+                          "msg.bad.incr"
+                        "msg.bad.decr")
+                      nil beg (- end beg))))
+
+(defun js2-parse-unary-expr ()
+  (let ((tt (js2-peek-token))
+        pn expr beg end)
+    (cond
+     ((or (= tt js2-VOID)
+          (= tt js2-NOT)
+          (= tt js2-BITNOT)
+          (= tt js2-TYPEOF))
+      (js2-consume-token)
+      (js2-make-unary tt 'js2-parse-unary-expr))
+     ((= tt js2-ADD)
+      (js2-consume-token)
+      ;; Convert to special POS token in decompiler and parse tree
+      (js2-make-unary js2-POS 'js2-parse-unary-expr))
+     ((= tt js2-SUB)
+      (js2-consume-token)
+      ;; Convert to special NEG token in decompiler and parse tree
+      (js2-make-unary js2-NEG 'js2-parse-unary-expr))
+     ((or (= tt js2-INC)
+          (= tt js2-DEC))
+      (js2-consume-token)
+      (prog1
+          (setq beg js2-token-beg
+                end js2-token-end
+                expr (js2-make-unary tt 'js2-parse-member-expr t))
+        (js2-check-bad-inc-dec tt beg end expr)))
+     ((= tt js2-DELPROP)
+      (js2-consume-token)
+      (js2-make-unary js2-DELPROP 'js2-parse-unary-expr))
+     ((= tt js2-ERROR)
+      (js2-consume-token)
+      (make-js2-error-node))  ; try to continue
+     ((and (= tt js2-LT)
+           js2-compiler-xml-available)
+      ;; XML stream encountered in expression.
+      (js2-consume-token)
+      (js2-parse-member-expr-tail t (js2-parse-xml-initializer)))
+     (t
+      (setq pn (js2-parse-member-expr t)
+            ;; Don't look across a newline boundary for a postfix incop.
+            tt (js2-peek-token-or-eol))
+      (when (or (= tt js2-INC) (= tt js2-DEC))
+        (js2-consume-token)
+        (setf expr pn
+              pn (js2-make-unary tt expr))
+        (js2-node-set-prop pn 'postfix t)
+        (js2-check-bad-inc-dec tt js2-token-beg js2-token-end pn))
+      pn))))
+
+(defun js2-parse-xml-initializer ()
+  "Parse an E4X XML initializer.
+I'm parsing it the way Rhino parses it, but without the tree-rewriting.
+Then I'll postprocess the result, depending on whether we're in IDE
+mode or codegen mode, and generate the appropriate rewritten AST.
+IDE mode uses a rich AST that models the XML structure.  Codegen mode
+just concatenates everything and makes a new XML or XMLList out of it."
+  (let ((tt (js2-get-first-xml-token))
+        pn-xml
+        pn
+        expr
+        kids
+        expr-pos
+        (continue t)
+        (first-token t))
+    (when (not (or (= tt js2-XML) (= tt js2-XMLEND)))
+      (js2-report-error "msg.syntax"))
+    (setq pn-xml (make-js2-xml-node))
+    (while continue
+      (if first-token
+          (setq first-token nil)
+        (setq tt (js2-get-next-xml-token)))
+      (cond
+       ;; js2-XML means we found a {expr} in the XML stream.
+       ;; The js2-ts-string is the XML up to the left-curly.
+       ((= tt js2-XML)
+        (push (make-js2-string-node :pos js2-token-beg
+                                    :len (- js2-ts-cursor js2-token-beg))
+              kids)
+        (js2-must-match js2-LC "msg.syntax")
+        (setq expr-pos js2-ts-cursor
+              expr (if (eq (js2-peek-token) js2-RC)
+                       (make-js2-empty-expr-node :pos expr-pos)
+                     (js2-parse-expr)))
+        (js2-must-match js2-RC "msg.syntax")
+        (setq pn (make-js2-xml-js-expr-node :pos (js2-node-pos expr)
+                                            :len (js2-node-len expr)
+                                            :expr expr))
+        (js2-node-add-children pn expr)
+        (push pn kids))
+       ;; a js2-XMLEND token means we hit the final close-tag.
+       ((= tt js2-XMLEND)
+        (push (make-js2-string-node :pos js2-token-beg
+                                    :len (- js2-ts-cursor js2-token-beg))
+              kids)
+        (dolist (kid (nreverse kids))
+          (js2-block-node-push pn-xml kid))
+        (setf (js2-node-len pn-xml) (- js2-ts-cursor
+                                       (js2-node-pos pn-xml))
+              continue nil))
+       (t
+        (js2-report-error "msg.syntax")
+        (setq continue nil))))
+    pn-xml))
+
+
+(defun js2-parse-argument-list ()
+  "Parse an argument list and return it as a lisp list of nodes.
+Returns the list in reverse order.  Consumes the right-paren token."
+  (let (result)
+    (unless (js2-match-token js2-RP)
+      (loop do
+            (if (= (js2-peek-token) js2-YIELD)
+                (js2-report-error "msg.yield.parenthesized"))
+            (push (js2-parse-assign-expr) result)
+            while
+            (js2-match-token js2-COMMA))
+      (js2-must-match js2-RP "msg.no.paren.arg")
+      result)))
+
+(defun js2-parse-member-expr (&optional allow-call-syntax)
+  (let ((tt (js2-peek-token))
+        pn
+        pos
+        target
+        args
+        beg
+        end
+        init
+        tail)
+    (if (/= tt js2-NEW)
+        (setq pn (js2-parse-primary-expr))
+      ;; parse a 'new' expression
+      (js2-consume-token)
+      (setq pos js2-token-beg
+            beg pos
+            target (js2-parse-member-expr)
+            end (js2-node-end target)
+            pn (make-js2-new-node :pos pos
+                                  :target target
+                                  :len (- end pos)))
+      (js2-node-add-children pn target)
+      (when (js2-match-token js2-LP)
+        ;; Add the arguments to pn, if any are supplied.
+        (setf beg pos  ; start of "new" keyword
+              pos js2-token-beg
+              args (nreverse (js2-parse-argument-list))
+              (js2-new-node-args pn) args
+              end js2-token-end
+              (js2-new-node-lp pn) (- pos beg)
+              (js2-new-node-rp pn) (- end 1 beg))
+        (apply #'js2-node-add-children pn args))
+      (when (and js2-allow-rhino-new-expr-initializer
+                 (js2-match-token js2-LC))
+        (setf init (js2-parse-object-literal)
+              end (js2-node-end init)
+              (js2-new-node-initializer pn) init)
+        (js2-node-add-children pn init))
+        (setf (js2-node-len pn) (- beg pos)))  ; end outer if
+    (js2-parse-member-expr-tail allow-call-syntax pn)))
+
+(defun js2-parse-member-expr-tail (allow-call-syntax pn)
+  "Parse a chain of property/array accesses or function calls.
+Includes parsing for E4X operators like `..' and `.@'.
+If ALLOW-CALL-SYNTAX is nil, stops when we encounter a left-paren.
+Returns an expression tree that includes PN, the parent node."
+  (let ((beg (js2-node-pos pn))
+        tt
+        (continue t))
+    (while continue
+      (setq tt (js2-peek-token))
+      (cond
+       ((or (= tt js2-DOT) (= tt js2-DOTDOT))
+        (setq pn (js2-parse-property-access tt pn)))
+       ((= tt js2-DOTQUERY)
+        (setq pn (js2-parse-dot-query pn)))
+       ((= tt js2-LB)
+        (setq pn (js2-parse-element-get pn)))
+       ((= tt js2-LP)
+        (if allow-call-syntax
+            (setq pn (js2-parse-function-call pn))
+          (setq continue nil)))
+       (t
+        (setq continue nil))))
+    (if (>= js2-highlight-level 2)
+        (js2-parse-highlight-member-expr-node pn))
+    pn))
+
+(defun js2-parse-dot-query (pn)
+  "Parse a dot-query expression, e.g. foo.bar.(@name == 2)
+Last token parsed must be `js2-DOTQUERY'."
+  (let ((pos (js2-node-pos pn))
+        op-pos
+        expr
+        end)
+    (js2-consume-token)
+    (js2-must-have-xml)
+    (js2-set-requires-activation)
+    (setq op-pos js2-token-beg
+          expr (js2-parse-expr)
+          end (js2-node-end expr)
+          pn (make-js2-xml-dot-query-node :left pn
+                                          :pos pos
+                                          :op-pos op-pos
+                                          :right expr))
+    (js2-node-add-children pn
+                           (js2-xml-dot-query-node-left pn)
+                           (js2-xml-dot-query-node-right pn))
+    (if (js2-must-match js2-RP "msg.no.paren")
+        (setf (js2-xml-dot-query-node-rp pn) js2-token-beg
+              end js2-token-end))
+    (setf (js2-node-len pn) (- end pos))
+    pn))
+
+(defun js2-parse-element-get (pn)
+  "Parse an element-get expression, e.g. foo[bar].
+Last token parsed must be `js2-RB'."
+  (let ((lb js2-token-beg)
+        (pos (js2-node-pos pn))
+        rb
+        expr)
+    (js2-consume-token)
+    (setq expr (js2-parse-expr))
+    (if (js2-must-match js2-RB "msg.no.bracket.index")
+        (setq rb js2-token-beg))
+    (setq pn (make-js2-elem-get-node :target pn
+                                     :pos pos
+                                     :element expr
+                                     :lb (js2-relpos lb pos)
+                                     :rb (js2-relpos rb pos)
+                                     :len (- js2-token-end pos)))
+    (js2-node-add-children pn
+                           (js2-elem-get-node-target pn)
+                           (js2-elem-get-node-element pn))
+    pn))
+
+(defun js2-parse-function-call (pn)
+  (let (args
+        (pos (js2-node-pos pn)))
+    (js2-consume-token)
+    (setq pn (make-js2-call-node :pos pos
+                                 :target pn
+                                 :lp (- js2-token-beg pos)))
+    (js2-node-add-children pn (js2-call-node-target pn))
+    ;; Add the arguments to pn, if any are supplied.
+    (setf args (nreverse (js2-parse-argument-list))
+          (js2-call-node-rp pn) (- js2-token-beg pos)
+          (js2-call-node-args pn) args)
+    (apply #'js2-node-add-children pn args)
+    (setf (js2-node-len pn) (- js2-ts-cursor pos))
+    pn))
+
+(defun js2-parse-property-access (tt pn)
+  "Parse a property access, XML descendants access, or XML attr access."
+  (let ((member-type-flags 0)
+        (dot-pos js2-token-beg)
+        (dot-len (if (= tt js2-DOTDOT) 2 1))
+        name
+        ref  ; right side of . or .. operator
+        result)
+    (js2-consume-token)
+    (when (= tt js2-DOTDOT)
+      (js2-must-have-xml)
+      (setq member-type-flags js2-descendants-flag))
+    (if (not js2-compiler-xml-available)
+        (progn
+          (js2-must-match-prop-name "msg.no.name.after.dot")
+          (setq name (js2-create-name-node t js2-GETPROP)
+                result (make-js2-prop-get-node :left pn
+                                               :pos js2-token-beg
+                                               :right name
+                                               :len (- js2-token-end
+                                                       js2-token-beg)))
+          (js2-node-add-children result pn name)
+          result)
+      ;; otherwise look for XML operators
+      (setf result (if (= tt js2-DOT)
+                       (make-js2-prop-get-node)
+                     (make-js2-infix-node :type js2-DOTDOT))
+            (js2-node-pos result) (js2-node-pos pn)
+            (js2-infix-node-op-pos result) dot-pos
+            (js2-infix-node-left result) pn  ; do this after setting position
+            tt (js2-next-token))
+      (cond
+       ;; needed for generator.throw()
+       ((= tt js2-THROW)
+        (js2-save-name-token-data js2-token-beg "throw")
+        (setq ref (js2-parse-property-name nil js2-ts-string member-type-flags)))
+       ;; handles: name, ns::name, ns::*, ns::[expr]
+       ((js2-valid-prop-name-token tt)
+        (setq ref (js2-parse-property-name -1 js2-ts-string member-type-flags)))
+       ;; handles: *, *::name, *::*, *::[expr]
+       ((= tt js2-MUL)
+        (js2-save-name-token-data js2-token-beg "*")
+        (setq ref (js2-parse-property-name nil "*" member-type-flags)))
+       ;; handles: '@attr', '@ns::attr', '@ns::*', '@ns::[expr]', etc.
+       ((= tt js2-XMLATTR)
+        (setq result (js2-parse-attribute-access)))
+       (t
+        (js2-report-error "msg.no.name.after.dot" nil dot-pos dot-len)))
+      (if ref
+          (setf (js2-node-len result) (- (js2-node-end ref)
+                                         (js2-node-pos result))
+                (js2-infix-node-right result) ref))
+      (if (js2-infix-node-p result)
+          (js2-node-add-children result
+                                 (js2-infix-node-left result)
+                                 (js2-infix-node-right result)))
+      result)))
+
+(defun js2-parse-attribute-access ()
+  "Parse an E4X XML attribute expression.
+This includes expressions of the forms:
+
+  @attr      @ns::attr     @ns::*
+  @*         @*::attr      @*::*
+  @[expr]    @*::[expr]    @ns::[expr]
+
+Called if we peeked an '@' token."
+  (let ((tt (js2-next-token))
+        (at-pos js2-token-beg))
+    (cond
+     ;; handles: @name, @ns::name, @ns::*, @ns::[expr]
+     ((js2-valid-prop-name-token tt)
+      (js2-parse-property-name at-pos js2-ts-string 0))
+     ;; handles: @*, @*::name, @*::*, @*::[expr]
+     ((= tt js2-MUL)
+      (js2-save-name-token-data js2-token-beg "*")
+      (js2-parse-property-name js2-token-beg "*" 0))
+     ;; handles @[expr]
+     ((= tt js2-LB)
+      (js2-parse-xml-elem-ref at-pos))
+     (t
+      (js2-report-error "msg.no.name.after.xmlAttr")
+      ;; Avoid cascaded errors that happen if we make an error node here.
+      (js2-save-name-token-data js2-token-beg "")
+      (js2-parse-property-name js2-token-beg "" 0)))))
+
+(defun js2-parse-property-name (at-pos s member-type-flags)
+  "Check if :: follows name in which case it becomes qualified name.
+
+AT-POS is a natural number if we just read an '@' token, else nil.
+S is the name or string that was matched:  an identifier, 'throw' or '*'.
+MEMBER-TYPE-FLAGS is a bit set tracking whether we're a '.' or '..' child.
+
+Returns a `js2-xml-ref-node' if it's an attribute access, a child of a '..'
+operator, or the name is followed by ::.  For a plain name, returns a
+`js2-name-node'.  Returns a `js2-error-node' for malformed XML expressions."
+  (let ((pos (or at-pos js2-token-beg))
+        colon-pos
+        (name (js2-create-name-node t js2-current-token))
+        ns
+        tt
+        ref
+        pn)
+    (catch 'return
+      (when (js2-match-token js2-COLONCOLON)
+        (setq ns name
+              colon-pos js2-token-beg
+              tt (js2-next-token))
+        (cond
+         ;; handles name::name
+         ((js2-valid-prop-name-token tt)
+          (setq name (js2-create-name-node)))
+         ;; handles name::*
+         ((= tt js2-MUL)
+          (js2-save-name-token-data js2-token-beg "*")
+          (setq name (js2-create-name-node)))
+         ;; handles name::[expr]
+         ((= tt js2-LB)
+          (throw 'return (js2-parse-xml-elem-ref at-pos ns colon-pos)))
+         (t
+          (js2-report-error "msg.no.name.after.coloncolon"))))
+      (if (and (null ns) (zerop member-type-flags))
+          name
+        (prog1
+            (setq pn
+                  (make-js2-xml-prop-ref-node :pos pos
+                                              :len (- (js2-node-end name) pos)
+                                              :at-pos at-pos
+                                              :colon-pos colon-pos
+                                              :propname name))
+          (js2-node-add-children pn name))))))
+
+(defun js2-parse-xml-elem-ref (at-pos &optional namespace colon-pos)
+  "Parse the [expr] portion of an xml element reference.
+For instance, @[expr], @*::[expr], or ns::[expr]."
+  (let* ((lb js2-token-beg)
+         (pos (or at-pos lb))
+         rb
+         (expr (js2-parse-expr))
+         (end (js2-node-end expr))
+         pn)
+    (if (js2-must-match js2-RB "msg.no.bracket.index")
+        (setq rb js2-token-beg
+              end js2-token-end))
+    (prog1
+        (setq pn
+              (make-js2-xml-elem-ref-node :pos pos
+                                          :len (- end pos)
+                                          :namespace namespace
+                                          :colon-pos colon-pos
+                                          :at-pos at-pos
+                                          :expr expr
+                                          :lb (js2-relpos lb pos)
+                                          :rb (js2-relpos rb pos)))
+      (js2-node-add-children pn namespace expr))))
+
+(defun js2-parse-primary-expr ()
+  "Parses a literal (leaf) expression of some sort.
+Includes complex literals such as functions, object-literals,
+array-literals, array comprehensions and regular expressions."
+  (let ((tt-flagged (js2-next-flagged-token))
+        pn      ; parent node  (usually return value)
+        tt
+        px-pos  ; paren-expr pos
+        len
+        flags   ; regexp flags
+        expr)
+    (setq tt js2-current-token)
+    (cond
+     ((= tt js2-FUNCTION)
+      (js2-parse-function 'FUNCTION_EXPRESSION))
+     ((= tt js2-LB)
+      (js2-parse-array-literal))
+     ((= tt js2-LC)
+      (js2-parse-object-literal))
+     ((= tt js2-LET)
+      (js2-parse-let js2-token-beg))
+     ((= tt js2-LP)
+      (setq px-pos js2-token-beg
+            expr (js2-parse-expr))
+      (js2-must-match js2-RP "msg.no.paren")
+      (setq pn (make-js2-paren-node :pos px-pos
+                                    :expr expr
+                                    :len (- js2-token-end px-pos)))
+      (js2-node-add-children pn (js2-paren-node-expr pn))
+      pn)
+     ((= tt js2-XMLATTR)
+      (js2-must-have-xml)
+      (js2-parse-attribute-access))
+     ((= tt js2-NAME)
+      (js2-parse-name tt-flagged tt))
+     ((= tt js2-NUMBER)
+      (make-js2-number-node))
+     ((= tt js2-STRING)
+      (prog1
+          (make-js2-string-node)
+        (js2-record-face 'font-lock-string-face)))
+     ((or (= tt js2-DIV) (= tt js2-ASSIGN_DIV))
+      ;; Got / or /= which in this context means a regexp literal
+      (setq px-pos js2-token-beg)
+      (js2-read-regexp tt)
+      (setq flags js2-ts-regexp-flags
+            js2-ts-regexp-flags nil)
+      (prog1
+          (make-js2-regexp-node :pos px-pos
+                                :len (- js2-ts-cursor px-pos)
+                                :value js2-ts-string
+                                :flags flags)
+        (js2-set-face px-pos js2-ts-cursor 'font-lock-string-face 'record)
+        (put-text-property px-pos js2-ts-cursor 'syntax-table '(2))))
+     ((or (= tt js2-NULL)
+          (= tt js2-THIS)
+          (= tt js2-FALSE)
+          (= tt js2-TRUE))
+      (make-js2-keyword-node :type tt))
+     ((= tt js2-RESERVED)
+      (js2-report-error "msg.reserved.id")
+      (make-js2-name-node))
+     ((= tt js2-ERROR)
+      ;; the scanner or one of its subroutines reported the error.
+      (make-js2-error-node))
+     ((= tt js2-EOF)
+      (setq px-pos (point-at-bol)
+            len (- js2-ts-cursor px-pos))
+      (js2-report-error "msg.unexpected.eof" nil px-pos len)
+      (make-js2-error-node :pos px-pos :len len))
+     (t
+      (js2-report-error "msg.syntax")
+      (make-js2-error-node)))))
+
+(defun js2-parse-name (tt-flagged tt)
+  (let ((name js2-ts-string)
+        (name-pos js2-token-beg))
+      (if (and (js2-flag-set-p tt-flagged js2-ti-check-label)
+               (= (js2-peek-token) js2-COLON))
+          (prog1
+            ;; Do not consume colon, it is used as unwind indicator
+            ;; to return to statementHelper.
+            (make-js2-label-node :pos name-pos
+                                 :len (- js2-token-end name-pos)
+                                 :name name)
+            (js2-set-face name-pos
+                          js2-token-end
+                          'font-lock-variable-name-face 'record))
+        ;; Otherwise not a label, just a name.  Unfortunately peeking
+        ;; the next token to check for a colon has biffed js2-token-beg
+        ;; and js2-token-end.  We store the name's bounds in buffer vars
+        ;; and `js2-create-name-node' uses them.
+        (js2-save-name-token-data name-pos name)
+        (if js2-compiler-xml-available
+            (js2-parse-property-name nil name 0)
+          (js2-create-name-node 'check-activation)))))
+
+(defsubst js2-parse-warn-trailing-comma (msg pos elems comma-pos)
+  (js2-add-strict-warning
+   msg nil
+   ;; back up from comma to beginning of line or array/objlit
+   (max (if elems
+            (js2-node-pos (car elems))
+          pos)
+        (save-excursion
+          (goto-char comma-pos)
+          (back-to-indentation)
+          (point)))
+   comma-pos))
+
+(defun js2-parse-array-literal ()
+  (let ((pos js2-token-beg)
+        (end js2-token-end)
+        (after-lb-or-comma t)
+        after-comma
+        tt
+        elems
+        pn
+        (continue t))
+    (while continue
+      (setq tt (js2-peek-token))
+      (cond
+       ;; comma
+       ((= tt js2-COMMA)
+        (js2-consume-token)
+        (setq after-comma js2-token-end)
+        (if (not after-lb-or-comma)
+            (setq after-lb-or-comma t)
+          (push nil elems)))
+       ;; end of array
+       ((or (= tt js2-RB)
+            (= tt js2-EOF))  ; prevent infinite loop
+        (if (= tt js2-EOF)
+            (js2-report-error "msg.no.bracket.arg" nil pos)
+          (js2-consume-token))
+        (setq continue nil
+              end js2-token-end
+              pn (make-js2-array-node :pos pos
+                                      :len (- js2-ts-cursor pos)
+                                      :elems (nreverse elems)))
+        (apply #'js2-node-add-children pn (js2-array-node-elems pn))
+        (when after-comma
+          (js2-parse-warn-trailing-comma "msg.array.trailing.comma"
+                                         pos elems after-comma)))
+       ;; array comp
+       ((and (>= js2-language-version 170)
+             (= tt js2-FOR)          ; check for array comprehension
+             (not after-lb-or-comma) ; "for" can't follow a comma
+             elems                   ; must have at least 1 element
+             (not (cdr elems)))      ; but no 2nd element
+        (setf continue nil
+              pn (js2-parse-array-comprehension (car elems) pos)))
+       ;; another element
+       (t
+        (unless after-lb-or-comma
+          (js2-report-error "msg.no.bracket.arg"))
+        (push (js2-parse-assign-expr) elems)
+        (setq after-lb-or-comma nil
+              after-comma nil))))
+    pn))
+
+(defun js2-parse-array-comprehension (expr pos)
+  "Parse a JavaScript 1.7 Array Comprehension.
+EXPR is the first expression after the opening left-bracket.
+POS is the beginning of the LB token preceding EXPR.
+We should have just parsed the 'for' keyword before calling this function."
+  (let (loops
+        filter
+        if-pos
+        result)
+    (while (= (js2-peek-token) js2-FOR)
+      (push (js2-parse-array-comp-loop) loops))
+    (when (= (js2-peek-token) js2-IF)
+      (js2-consume-token)
+      (setq if-pos (- js2-token-beg pos)  ; relative
+            filter (js2-parse-condition)))
+    (js2-must-match js2-RB "msg.no.bracket.arg" pos)
+    (setq result (make-js2-array-comp-node :pos pos
+                                           :len (- js2-ts-cursor pos)
+                                           :result expr
+                                           :loops (nreverse loops)
+                                           :filter (car filter)
+                                           :lp (js2-relpos (second filter) pos)
+                                           :rp (js2-relpos (third filter) pos)
+                                           :if-pos if-pos))
+    (apply #'js2-node-add-children result expr (car filter)
+           (js2-array-comp-node-loops result))
+    result))
+
+(defun js2-parse-array-comp-loop ()
+  "Parse a 'for [each] (foo in bar)' expression in an Array comprehension.
+Last token peeked should be the initial FOR."
+  (let ((pos js2-token-beg)
+        (pn (make-js2-array-comp-loop-node))
+        tt
+        iter
+        obj
+        foreach-p
+        in-pos
+        each-pos
+        lp
+        rp)
+    (assert (= (js2-next-token) js2-FOR))  ; consumes token
+    (js2-push-scope pn)
+    (unwind-protect
+        (progn
+          (when (js2-match-token js2-NAME)
+            (if (string= js2-ts-string "each")
+                (progn
+                  (setq foreach-p t
+                        each-pos (- js2-token-beg pos)) ; relative
+                  (js2-record-face 'font-lock-keyword-face))
+              (js2-report-error "msg.no.paren.for")))
+          (if (js2-must-match js2-LP "msg.no.paren.for")
+              (setq lp (- js2-token-beg pos)))
+          (setq tt (js2-peek-token))
+          (cond
+           ((or (= tt js2-LB)
+                (= tt js2-LC))
+            ;; handle destructuring assignment
+            (setq iter (js2-parse-primary-expr)))
+           ((js2-valid-prop-name-token tt)
+            (js2-consume-token)
+            (setq iter (js2-create-name-node)))
+           (t
+            (js2-report-error "msg.bad.var")))
+          ;; Define as a let since we want the scope of the variable to
+          ;; be restricted to the array comprehension
+          (if (js2-name-node-p iter)
+              (js2-define-symbol js2-LET (js2-name-node-name iter) pn t))
+          (if (js2-must-match js2-IN "msg.in.after.for.name")
+              (setq in-pos (- js2-token-beg pos)))
+          (setq obj (js2-parse-expr))
+          (if (js2-must-match js2-RP "msg.no.paren.for.ctrl")
+              (setq rp (- js2-token-beg pos)))
+          (setf (js2-node-pos pn) pos
+                (js2-node-len pn) (- js2-ts-cursor pos)
+                (js2-array-comp-loop-node-iterator pn) iter
+                (js2-array-comp-loop-node-object pn) obj
+                (js2-array-comp-loop-node-in-pos pn) in-pos
+                (js2-array-comp-loop-node-each-pos pn) each-pos
+                (js2-array-comp-loop-node-foreach-p pn) foreach-p
+                (js2-array-comp-loop-node-lp pn) lp
+                (js2-array-comp-loop-node-rp pn) rp)
+          (js2-node-add-children pn iter obj))
+      (js2-pop-scope))
+    pn))
+
+(defun js2-parse-object-literal ()
+  (let ((pos js2-token-beg)
+        tt
+        elems
+        result
+        after-comma
+        (continue t))
+    (while continue
+      (setq tt (js2-peek-token))
+      (cond
+       ;; {foo: ...}, {'foo': ...}, {get foo() {...}}, or {set foo(x) {...}}
+       ((or (js2-valid-prop-name-token tt)
+            (= tt js2-STRING))
+        (setq after-comma nil
+              result (js2-parse-named-prop tt))
+        (if (and (null result)
+                 (not js2-recover-from-parse-errors))
+            (setq continue nil)
+          (push result elems)))
+       ;; {12: x} or {10.7: x}
+       ((= tt js2-NUMBER)
+        (js2-consume-token)
+        (setq after-comma nil)
+        (push (js2-parse-plain-property (make-js2-number-node)) elems))
+       ;; trailing comma
+       ((= tt js2-RC)
+        (setq continue nil)
+        (if after-comma
+            (js2-parse-warn-trailing-comma "msg.extra.trailing.comma"
+                                           pos elems after-comma)))
+       (t
+        (js2-report-error "msg.bad.prop")
+        (unless js2-recover-from-parse-errors
+          (setq continue nil))))         ; end switch
+      (if (js2-match-token js2-COMMA)
+          (setq after-comma js2-token-end)
+        (setq continue nil)))           ; end loop
+    (js2-must-match js2-RC "msg.no.brace.prop")
+    (setq result (make-js2-object-node :pos pos
+                                       :len (- js2-ts-cursor pos)
+                                       :elems (nreverse elems)))
+    (apply #'js2-node-add-children result (js2-object-node-elems result))
+    result))
+
+(defun js2-parse-named-prop (tt)
+  "Parse a name, string, or getter/setter object property."
+  (js2-consume-token)
+  (let ((string-prop (and (= tt js2-STRING)
+                          (make-js2-string-node)))
+        expr
+        (ppos js2-token-beg)
+        (pend js2-token-end)
+        (name (js2-create-name-node))
+        (prop js2-ts-string))
+    (if (and (= tt js2-NAME)
+             (= (js2-peek-token) js2-NAME)
+             (or (string= prop "get")
+                 (string= prop "set")))
+        (progn
+          ;; getter/setter prop
+          (js2-consume-token)
+          (js2-set-face ppos pend 'font-lock-keyword-face 'record)  ; get/set
+          (js2-record-face 'font-lock-function-name-face)      ; for peeked name
+          (setq name (js2-create-name-node)) ; discard get/set & use peeked name
+          (js2-parse-getter-setter-prop ppos name (string= prop "get")))
+      ;; regular prop
+      (prog1
+          (setq expr (js2-parse-plain-property (or string-prop name)))
+        (js2-set-face ppos pend
+                      (if (js2-function-node-p
+                           (js2-object-prop-node-right expr))
+                          'font-lock-function-name-face
+                        'font-lock-variable-name-face)
+                      'record)))))
+
+(defun js2-parse-plain-property (prop)
+  "Parse a non-getter/setter property in an object literal.
+PROP is the node representing the property:  a number, name or string."
+  (js2-must-match js2-COLON "msg.no.colon.prop")
+  (let* ((pos (js2-node-pos prop))
+        (colon (- js2-token-beg pos))
+        (expr (js2-parse-assign-expr))
+        (result (make-js2-object-prop-node
+                 :pos pos
+                 ;; don't include last consumed token in length
+                 :len (- (+ (js2-node-pos expr)
+                            (js2-node-len expr))
+                         pos)
+                 :left prop
+                 :right expr
+                 :op-pos colon)))
+    (js2-node-add-children result prop expr)
+    result))
+
+(defun js2-parse-getter-setter-prop (pos prop get-p)
+  "Parse getter or setter property in an object literal.
+JavaScript syntax is:
+
+  { get foo() {...}, set foo(x) {...} }
+
+POS is the start position of the `get' or `set' keyword.
+PROP is the `js2-name-node' representing the property name.
+GET-P is non-nil if the keyword was `get'."
+  (let ((type (if get-p js2-GET js2-SET))
+        result
+        end
+        (fn (js2-parse-function 'FUNCTION_EXPRESSION)))
+    ;; it has to be an anonymous function, as we already parsed the name
+    (if (/= (js2-node-type fn) js2-FUNCTION)
+        (js2-report-error "msg.bad.prop")
+      (if (plusp (length (js2-function-name fn)))
+          (js2-report-error "msg.bad.prop")))
+    (js2-node-set-prop fn 'GETTER_SETTER type)  ; for codegen
+    (setq end (js2-node-end fn)
+          result (make-js2-getter-setter-node :type type
+                                              :pos pos
+                                              :len (- end pos)
+                                              :left prop
+                                              :right fn))
+    (js2-node-add-children result prop fn)
+    result))
+
+(defun js2-create-name-node (&optional check-activation-p token)
+  "Create a name node using the token info from last scanned name.
+In some cases we need to either synthesize a name node, or we lost
+the name token information by peeking.  If the TOKEN parameter is
+not `js2-NAME', then we use the token info saved in instance vars."
+  (let ((beg js2-token-beg)
+        (s js2-ts-string)
+        name)
+    (when (/= js2-current-token js2-NAME)
+      (setq beg (or js2-prev-name-token-start js2-ts-cursor)
+            s js2-prev-name-token-string
+            js2-prev-name-token-start nil
+            js2-prev-name-token-string nil))
+    (setq name (make-js2-name-node :pos beg
+                                   :name s
+                                   :len (length s)))
+    (if check-activation-p
+        (js2-check-activation-name s (or token js2-NAME)))
+    name))
+
+(provide 'js2-parse)
+
+;;; js2-parse.el ends here
+;;; js2-indent.el --- indentation for js2-mode
+
+;; Copyright (C) 2008 Steve Yegge
+;; Author:  Steve Yegge (steve.yegge@gmail.com)
+;; Maintainer:  Steve Yegge (steve.yegge@gmail.com)
+
+;;; Commentary:
+
+;; This indenter is based on Karl Landström's "javascript.el" indenter.
+;; Karl cleverly deduces that the desired indentation level is often a
+;; function of paren/bracket/brace nesting depth, which can be determined
+;; quickly via the built-in `parse-partial-sexp' function.  His indenter
+;; then does some equally clever checks to see if we're in the context of a
+;; substatement of a possibly braceless statement keyword such as if, while,
+;; or finally.  This approach yields pretty good results.
+
+;; The indenter is often "wrong", however, and needs to be overridden.
+;; The right long-term solution is probably to emulate (or modify)
+;; cc-engine, but it's thousands upon thousands of lines of code.  Even
+;; if you were to assume the accurate parse tree from `js2-parse' is
+;; present, indentation is still thousands of lines of code (I've been
+;; down that path) to handle every possible syntactic edge case, and in
+;; any case, relying on the parse tree is undesirable because parsing is
+;; slow.  So you might as well go the cc-engine approach, but it's a
+;; huge pile of work that I'm just not up for any time soon.
+
+;; In the meantime, the compromise solution is that we offer a
+;; "bounce indenter", configured with `js2-bounce-indent-p', which
+;; cycles the current line indent among various likely guess points.
+;; This approach is far from perfect, but should at least make it
+;; slightly easier to move the line towards its desired indentation
+;; when manually overriding Karl's heuristic nesting guesser.
+
+;; I've made miscellaneous tweaks to Karl's code to handle some Ecma
+;; extensions such as `let' and Array comprehensions, and will likely
+;; make further tweaks to it, but major kudos to Karl for coming up with
+;; the initial approach, which packs a lot of punch for so little code.
+
+;;; Code:
+
+(defconst js-possibly-braceless-keyword-re
+  (regexp-opt
+   '("catch" "do" "else" "finally" "for" "if" "try" "while" "with" "let")
+   'words)
+  "Regular expression matching keywords that are optionally
+followed by an opening brace.")
+
+(defconst js-indent-operator-re
+  (concat "[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|"
+          (regexp-opt '("in" "instanceof") 'words))
+  "Regular expression matching operators that affect indentation
+of continued expressions.")
+
+;; This function has horrible results if you're typing an array
+;; such as [[1, 2], [3, 4], [5, 6]].  Bounce indenting -really- sucks
+;; in conjunction with electric-indent, so just disabling it.
+(defsubst js2-code-at-bol-p ()
+  "Return t if the first character on line is non-whitespace."
+  nil)
+
+(defun js2-insert-and-indent (key)
+  "Run command bound to key and indent current line. Runs the command
+bound to KEY in the global keymap and indents the current line."
+  (interactive (list (this-command-keys)))
+  (let ((cmd (lookup-key (current-global-map) key)))
+    (if (commandp cmd)
+        (call-interactively cmd)))
+  ;; don't do the electric keys inside comments or strings,
+  ;; and don't do bounce-indent with them.
+  (let ((parse-state (parse-partial-sexp (point-min) (point)))
+        (js2-bounce-indent-p (js2-code-at-bol-p)))
+    (unless (or (nth 3 parse-state)
+                (nth 4 parse-state))
+      (indent-according-to-mode))))
+
+(defun js-re-search-forward-inner (regexp &optional bound count)
+  "Auxiliary function for `js-re-search-forward'."
+  (let ((parse)
+        (saved-point (point-min)))
+    (while (> count 0)
+      (re-search-forward regexp bound)
+      (setq parse (parse-partial-sexp saved-point (point)))
+      (cond ((nth 3 parse)
+             (re-search-forward
+              (concat "\\([^\\]\\|^\\)" (string (nth 3 parse)))
+              (save-excursion (end-of-line) (point)) t))
+            ((nth 7 parse)
+             (forward-line))
+            ((or (nth 4 parse)
+                 (and (eq (char-before) ?\/) (eq (char-after) ?\*)))
+             (re-search-forward "\\*/"))
+            (t
+             (setq count (1- count))))
+      (setq saved-point (point))))
+  (point))
+
+(defun js-re-search-forward (regexp &optional bound noerror count)
+  "Search forward but ignore strings and comments. Invokes
+`re-search-forward' but treats the buffer as if strings and
+comments have been removed."
+  (let ((saved-point (point))
+        (search-expr
+         (cond ((null count)
+                '(js-re-search-forward-inner regexp bound 1))
+               ((< count 0)
+                '(js-re-search-backward-inner regexp bound (- count)))
+               ((> count 0)
+                '(js-re-search-forward-inner regexp bound count)))))
+    (condition-case err
+        (eval search-expr)
+      (search-failed
+       (goto-char saved-point)
+       (unless noerror
+         (error (error-message-string err)))))))
+
+(defun js-re-search-backward-inner (regexp &optional bound count)
+  "Auxiliary function for `js-re-search-backward'."
+  (let ((parse)
+        (saved-point (point-min)))
+    (while (> count 0)
+      (re-search-backward regexp bound)
+      (setq parse (parse-partial-sexp saved-point (point)))
+      (cond ((nth 3 parse)
+             (re-search-backward
+              (concat "\\([^\\]\\|^\\)" (string (nth 3 parse)))
+              (save-excursion (beginning-of-line) (point)) t))
+            ((nth 7 parse)
+             (goto-char (nth 8 parse)))
+            ((or (nth 4 parse)
+                 (and (eq (char-before) ?/) (eq (char-after) ?*)))
+             (re-search-backward "/\\*"))
+            (t
+             (setq count (1- count))))))
+  (point))
+
+(defun js-re-search-backward (regexp &optional bound noerror count)
+  "Search backward but ignore strings and comments. Invokes
+`re-search-backward' but treats the buffer as if strings and
+comments have been removed."
+  (let ((saved-point (point))
+        (search-expr
+         (cond ((null count)
+                '(js-re-search-backward-inner regexp bound 1))
+               ((< count 0)
+                '(js-re-search-forward-inner regexp bound (- count)))
+               ((> count 0)
+                '(js-re-search-backward-inner regexp bound count)))))
+    (condition-case err
+        (eval search-expr)
+      (search-failed
+       (goto-char saved-point)
+       (unless noerror
+         (error (error-message-string err)))))))
+
+(defun js-looking-at-operator-p ()
+  "Return non-nil if text after point is an operator (that is not
+a comma)."
+  (save-match-data
+    (and (looking-at js-indent-operator-re)
+         (or (not (looking-at ":"))
+             (save-excursion
+               (and (js-re-search-backward "[?:{]\\|\\<case\\>" nil t)
+                    (looking-at "?")))))))
+
+(defun js-continued-expression-p ()
+  "Returns non-nil if the current line continues an expression."
+  (save-excursion
+    (back-to-indentation)
+    (or (js-looking-at-operator-p)
+        (and (js-re-search-backward "\n" nil t)
+	     (progn
+	       (skip-chars-backward " \t")
+	       (backward-char)
+	       (and (js-looking-at-operator-p)
+		    (and (progn (backward-char)
+				(not (looking-at "\\*\\|++\\|--\\|/[/*]"))))))))))
+
+(defun js-end-of-do-while-loop-p ()
+  "Returns non-nil if word after point is `while' of a do-while
+statement, else returns nil. A braceless do-while statement
+spanning several lines requires that the start of the loop is
+indented to the same column as the current line."
+  (interactive)
+  (save-excursion
+    (save-match-data
+      (when (looking-at "\\s-*\\<while\\>")
+	(if (save-excursion
+	      (skip-chars-backward "[ \t\n]*}")
+	      (looking-at "[ \t\n]*}"))
+	    (save-excursion
+	      (backward-list) (backward-word 1) (looking-at "\\<do\\>"))
+	  (js-re-search-backward "\\<do\\>" (point-at-bol) t)
+	  (or (looking-at "\\<do\\>")
+	      (let ((saved-indent (current-indentation)))
+		(while (and (js-re-search-backward "^[ \t]*\\<" nil t)
+			    (/= (current-indentation) saved-indent)))
+		(and (looking-at "[ \t]*\\<do\\>")
+		     (not (js-re-search-forward
+			   "\\<while\\>" (point-at-eol) t))
+		     (= (current-indentation) saved-indent)))))))))
+
+(defun js-ctrl-statement-indentation ()
+  "Returns the proper indentation of the current line if it
+starts the body of a control statement without braces, else
+returns nil."
+  (let (forward-sexp-function)  ; temporarily unbind it
+    (save-excursion
+      (back-to-indentation)
+      (when (save-excursion
+              (and (not (js2-same-line (point-min)))
+                   (not (looking-at "{"))
+                   (js-re-search-backward "[[:graph:]]" nil t)
+                   (not (looking-at "[{([]"))
+                   (progn
+                     (forward-char)
+                     ;; scan-sexps sometimes throws an error
+                     (ignore-errors (backward-sexp))
+                     (when (looking-at "(") (backward-word 1))
+                     (and (save-excursion
+                            (skip-chars-backward " \t}" (point-at-bol))
+                            (bolp))
+                          (looking-at js-possibly-braceless-keyword-re)
+                          (not (js-end-of-do-while-loop-p))))))
+        (save-excursion
+          (goto-char (match-beginning 0))
+          (+ (current-indentation) js2-basic-offset))))))
+
+(defun js2-indent-in-array-comp (parse-status)
+  "Return non-nil if we think we're in an array comprehension.
+In particular, return the buffer position of the first `for' kwd."
+  (let ((end (point)))
+    (when (nth 1 parse-status)
+      (save-excursion
+        (goto-char (nth 1 parse-status))
+        (when (looking-at "\\[")
+          (forward-char 1)
+          (js2-forward-sws)
+          (if (looking-at "[[{]")
+              (let (forward-sexp-function) ; use lisp version
+                (forward-sexp)             ; skip destructuring form
+                (js2-forward-sws)
+                (if (and (/= (char-after) ?,) ; regular array
+                         (looking-at "for"))
+                    (match-beginning 0)))
+            ;; to skip arbitrary expressions we need the parser,
+            ;; so we'll just guess at it.
+            (if (re-search-forward "[^,]* \\(for\\) " end t)
+                (match-beginning 1))))))))
+
+(defun js2-array-comp-indentation (parse-status for-kwd)
+  (if (js2-same-line for-kwd)
+      ;; first continuation line
+      (save-excursion
+        (goto-char (nth 1 parse-status))
+        (forward-char 1)
+        (skip-chars-forward " \t")
+        (current-column))
+    (save-excursion
+      (goto-char for-kwd)
+      (current-column))))
+
+(defun js-proper-indentation (parse-status)
+  "Return the proper indentation for the current line."
+  (save-excursion
+    (back-to-indentation)
+    (let ((ctrl-stmt-indent (js-ctrl-statement-indentation))
+          (same-indent-p (looking-at "[]})]\\|\\<case\\>\\|\\<default\\>"))
+          (continued-expr-p (js-continued-expression-p))
+          (bracket (nth 1 parse-status))
+          beg)
+      (cond
+       ;; indent array comprehension continuation lines specially
+       ((and bracket
+             (not (js2-same-line bracket))
+             (setq beg (js2-indent-in-array-comp parse-status))
+             (>= (point) (save-excursion
+                           (goto-char beg)
+                           (point-at-bol)))) ; at or after first loop?
+        (js2-array-comp-indentation parse-status beg))
+
+       (ctrl-stmt-indent)
+
+       (bracket
+        (goto-char bracket)
+        (cond
+         ((looking-at "[({[][ \t]*\\(/[/*]\\|$\\)")
+          (let ((p (parse-partial-sexp (point-at-bol) (point))))
+            (when (save-excursion (skip-chars-backward " \t)")
+                                  (looking-at ")"))
+              (backward-list))
+            (if (nth 1 p)
+                (progn (goto-char (1+ (nth 1 p)))
+                       (skip-chars-forward " \t"))
+              (back-to-indentation))
+            (cond (same-indent-p
+                   (current-column))
+                  (continued-expr-p
+                   (+ (current-column) (* 2 js2-basic-offset)))
+                  (t
+                   (+ (current-column) js2-basic-offset)))))
+         (t
+          (unless same-indent-p
+            (forward-char)
+            (skip-chars-forward " \t"))
+          (current-column))))
+
+       (continued-expr-p js2-basic-offset)
+       (t 0)))))
+
+(defun js2-lineup-comment (parse-status)
+  "Indent a multi-line block comment continuation line."
+  (let* ((beg (nth 8 parse-status))
+         (first-line (js2-same-line beg))
+         (offset (save-excursion
+                   (goto-char beg)
+                   (if (looking-at "/\\*")
+                       (+ 1 (current-column))
+                     0))))
+    (unless first-line
+      (indent-line-to offset))))
+
+(defun js2-backward-sws ()
+  "Move backward through whitespace and comments."
+  (interactive)
+  (while (forward-comment -1)))
+
+(defun js2-forward-sws ()
+  "Move forward through whitespace and comments."
+  (interactive)
+  (while (forward-comment 1)))
+
+(defsubst js2-current-indent (&optional pos)
+  "Return column of indentation on current line.
+If POS is non-nil, go to that point and return indentation for that line."
+  (save-excursion
+    (if pos
+        (goto-char pos))
+    (back-to-indentation)
+    (current-column)))
+
+(defsubst js2-arglist-close ()
+  "Return non-nil if we're on a line beginning with a close-paren/brace."
+  (save-match-data
+    (save-excursion
+      (goto-char (point-at-bol))
+      (js2-forward-sws)
+      (looking-at "[])}]"))))
+
+(defsubst js2-indent-looks-like-label-p ()
+  (goto-char (point-at-bol))
+  (js2-forward-sws)
+  (looking-at (concat js2-mode-identifier-re ":")))
+
+(defun js2-indent-in-objlit-p (parse-status)
+  "Return non-nil if this looks like an object-literal entry."
+  (let ((start (nth 1 parse-status)))
+    (and
+     start
+     (save-excursion
+       (and (zerop (forward-line -1))
+            (not (< (point) start))     ; crossed a {} boundary
+            (js2-indent-looks-like-label-p)))
+     (save-excursion
+       (js2-indent-looks-like-label-p)))))
+
+;; if prev line looks like foobar({ then we're passing an object
+;; literal to a function call, and people pretty much always want to
+;; de-dent back to the previous line, so move the 'basic-offset'
+;; position to the front.
+(defsubst js2-indent-objlit-arg-p (parse-status)
+  (save-excursion
+    (back-to-indentation)
+    (js2-backward-sws)
+    (and (eq (1- (point)) (nth 1 parse-status))
+         (eq (char-before) ?{)
+         (progn
+           (forward-char -1)
+           (skip-chars-backward " \t")
+           (eq (char-before) ?\()))))
+
+(defsubst js2-indent-case-block-p ()
+  (save-excursion
+    (back-to-indentation)
+    (js2-backward-sws)
+    (goto-char (point-at-bol))
+    (skip-chars-forward " \t")
+    (save-match-data
+      (looking-at "case\\s-.+:"))))
+
+(defsubst js2-syntax-bol ()
+  "Return the point at the first non-whitespace char on the line.
+Returns `point-at-bol' if the line is empty."
+  (save-excursion
+    (beginning-of-line)
+    (skip-chars-forward " \t")
+    (point)))
+
+(defun js2-bounce-indent (normal-col parse-status)
+  "Cycle among alternate computed indentation positions.
+PARSE-STATUS is the result of `parse-partial-sexp' from the beginning
+of the buffer to the current point.  NORMAL-COL is the indentation
+column computed by the heuristic guesser based on current paren,
+bracket, brace and statement nesting."
+  (let ((cur-indent (js2-current-indent))
+        (old-buffer-undo-list buffer-undo-list)
+        ;; Emacs 21 only has `count-lines', not `line-number-at-pos'
+        (current-line (save-excursion
+                        (forward-line 0)  ; move to bol
+                        (1+ (count-lines (point-min) (point)))))
+        positions
+        pos
+        anchor
+        arglist-cont
+        same-indent
+        prev-line-col
+        basic-offset
+        computed-pos)
+    ;; temporarily don't record undo info, if user requested this
+    (if js2-mode-indent-inhibit-undo
+        (setq buffer-undo-list t))
+    (unwind-protect
+        (progn
+          ;; first likely point:  indent from beginning of previous code line
+          (push (setq basic-offset
+                      (+ (save-excursion
+                           (back-to-indentation)
+                           (js2-backward-sws)
+                           (back-to-indentation)
+                           (setq prev-line-col (current-column)))
+                         js2-basic-offset))
+                positions)
+
+          ;; (first + epsilon) likely point:  indent 2x from beginning of
+          ;; previous code line.  Some companies like this approach.  Ahem.
+          ;; Seriously, though -- 4-space indent for expression continuation
+          ;; lines isn't a bad idea.  We should eventually implement it
+          ;; that way.
+          (push (setq basic-offset
+                      (+ (save-excursion
+                           (back-to-indentation)
+                           (js2-backward-sws)
+                           (back-to-indentation)
+                           (setq prev-line-col (current-column)))
+                         (* 2 js2-basic-offset)))
+                positions)
+
+          ;; second likely point:  indent from assign-expr RHS.  This
+          ;; is just a crude guess based on finding " = " on the previous
+          ;; line containing actual code.
+          (setq pos (save-excursion
+                      (save-match-data
+                        (forward-line -1)
+                        (goto-char (point-at-bol))
+                        (when (re-search-forward "\\s-+\\(=\\)\\s-+"
+                                                 (point-at-eol) t)
+                          (goto-char (match-end 1))
+                          (skip-chars-forward " \t\r\n")
+                          (current-column)))))
+          (when pos
+            (incf pos js2-basic-offset)
+            (unless (member pos positions)
+              (push pos positions)))
+
+          ;; third likely point:  same indent as previous line of code.
+          ;; Make it the first likely point if we're not on an
+          ;; arglist-close line and previous line ends in a comma, or
+          ;; both this line and prev line look like object-literal
+          ;; elements.
+          (setq pos (save-excursion
+                      (goto-char (point-at-bol))
+                      (js2-backward-sws)
+                      (back-to-indentation)
+                      (prog1
+                          (current-column)
+                        ;; while we're here, look for trailing comma
+                        (if (save-excursion
+                              (goto-char (point-at-eol))
+                              (js2-backward-sws)
+                              (eq (char-before) ?,))
+                            (setq arglist-cont (1- (point)))))))
+          (when pos
+            (if (and (or arglist-cont
+                         (js2-indent-in-objlit-p parse-status))
+                     (not (js2-arglist-close)))
+                (setq same-indent pos))
+            (unless (member pos positions)
+              (push pos positions)))
+
+          ;; fourth likely point:  first preceding code with less indentation
+          ;; than the immediately preceding code line.
+          (setq pos (save-excursion
+                      (js2-backward-sws)
+                      (back-to-indentation)
+                      (setq anchor (current-column))
+                      (while (and (zerop (forward-line -1))
+                                  (>= (progn
+                                        (back-to-indentation)
+                                        (current-column))
+                                      anchor)))
+                      (setq pos (current-column))))
+          (unless (member pos positions)
+            (push pos positions))
+
+          ;; put nesting-heuristic position first in list, sort rest
+          (setq positions (nreverse (sort positions '<)))
+          (setq positions (cons normal-col (delete normal-col positions)))
+
+          ;; comma-list continuation lines:  prev line indent takes precedence
+          (if same-indent
+              (setq positions
+                    (cons same-indent
+                          (sort (delete same-indent positions) '<))))
+
+          ;; common special cases where we want to indent in from previous line
+          (if (or (js2-indent-case-block-p)
+                  (js2-indent-objlit-arg-p parse-status))
+              (setq positions
+                    (cons basic-offset
+                          (delete basic-offset positions))))
+
+          ;; record whether we're already sitting on one of the alternatives
+          (setq pos (member cur-indent positions))
+          (cond
+           ;; case 0:  we're one one of the alternatives and this is the
+           ;; first time they've pressed TAB on this line (best-guess).
+           ((and js2-mode-indent-ignore-first-tab
+                 pos
+                 ;; first time pressing TAB on this line?
+                 (not (eq js2-mode-last-indented-line current-line)))
+            ;; do nothing
+            (setq computed-pos nil))
+           ;; case 1:  only one computed position => use it
+           ((null (cdr positions))
+            (setq computed-pos 0))
+           ;; case 2:  not on any of the computed spots => use main spot
+           ((not pos)
+            (setq computed-pos 0))
+           ;; case 3:  on last position:  cycle to first position
+           ((null (cdr pos))
+            (setq computed-pos 0))
+           ;; case 4:  on intermediate position:  cycle to next position
+           (t
+            (setq computed-pos (js2-position (second pos) positions))))
+
+          ;; see if any hooks want to indent; otherwise we do it
+          (loop with result = nil
+                for hook in js2-indent-hook
+                while (null result)
+                do
+                (setq result (funcall hook positions computed-pos))
+                finally do
+                (unless (or result (null computed-pos))
+                  (indent-line-to (nth computed-pos positions)))))
+
+      ;; finally
+      (if js2-mode-indent-inhibit-undo
+          (setq buffer-undo-list old-buffer-undo-list))
+      ;; see commentary for `js2-mode-last-indented-line'
+      (setq js2-mode-last-indented-line current-line))))
+
+(defsubst js2-1-line-comment-continuation-p ()
+  "Return t if we're in a 1-line comment continuation.
+If so, we don't ever want to use bounce-indent."
+  (save-excursion
+    (save-match-data
+      (and (progn
+             (forward-line 0)
+             (looking-at "\\s-*//"))
+           (progn
+             (forward-line -1)
+             (forward-line 0)
+             (when (looking-at "\\s-*$")
+               (js2-backward-sws)
+               (forward-line 0))
+             (looking-at "\\s-*//"))))))
+
+(defun js2-indent-line ()
+  "Indent the current line as JavaScript source text."
+  (interactive)
+  (let (parse-status
+        current-indent
+        offset
+        indent-col
+        moved
+        ;; don't whine about errors/warnings when we're indenting.
+        ;; This has to be set before calling parse-partial-sexp below.
+        (inhibit-point-motion-hooks t))
+    (setq parse-status (save-excursion
+                          (parse-partial-sexp (point-min)
+                                              (point-at-bol)))
+          offset (- (point) (save-excursion
+                               (back-to-indentation)
+                               (setq current-indent (current-column))
+                               (point))))
+    (js2-with-underscore-as-word-syntax
+     (if (nth 4 parse-status)
+         (js2-lineup-comment parse-status)
+       (setq indent-col (js-proper-indentation parse-status))
+       ;; see comments below about js2-mode-last-indented-line
+       (when
+           (cond
+            ;; bounce-indenting is disabled during electric-key indent.
+            ;; It doesn't work well on first line of buffer.
+            ((and js2-bounce-indent-p
+                  (not (js2-same-line (point-min)))
+                  (not (js2-1-line-comment-continuation-p)))
+             (js2-bounce-indent indent-col parse-status)
+             (setq moved t))
+            ;; just indent to the guesser's likely spot
+            ((/= current-indent indent-col)
+             (indent-line-to indent-col)
+             (setq moved t)))
+         (when (and moved (plusp offset))
+           (forward-char offset)))))))
+
+(defun js2-indent-region (start end)
+  "Indent the region, but don't use bounce indenting."
+  (let ((js2-bounce-indent-p nil)
+        (indent-region-function nil))
+    (indent-region start end nil)))  ; nil for byte-compiler
+
+(provide 'js2-indent)
+
+;;; js2-indent.el ends here
+
+(eval-when-compile
+  (require 'cl))
+
+(require 'imenu)
+(require 'cc-cmds)  ; for `c-fill-paragraph'
+
+
+;;;###autoload (add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
+
+;;;###autoload
+(defun js2-mode ()
+  "Major mode for editing JavaScript code."
+  (interactive)
+  (js2-mode-check-compat)
+  (kill-all-local-variables)
+  (set-syntax-table js2-mode-syntax-table)
+  (use-local-map js2-mode-map)
+  (setq major-mode 'js2-mode
+        mode-name "JavaScript-IDE"
+        comment-start "//"  ; used by comment-region; don't change it
+        comment-end "")
+  (setq local-abbrev-table js2-mode-abbrev-table)
+  (set (make-local-variable 'max-lisp-eval-depth)
+       (max max-lisp-eval-depth 3000))
+  (set (make-local-variable 'indent-line-function) #'js2-indent-line)
+  (set (make-local-variable 'indent-region-function) #'js2-indent-region)
+
+  ;; I tried an "improvement" to `c-fill-paragraph' that worked out badly
+  ;; on most platforms other than the one I originally wrote it on.  So it's
+  ;; back to `c-fill-paragraph'.  Still not perfect, though -- something to do
+  ;; with our binding of the RET key inside comments:  short lines stay short.
+  (set (make-local-variable 'fill-paragraph-function) #'c-fill-paragraph)
+
+  (set (make-local-variable 'before-save-hook) #'js2-before-save)
+  (set (make-local-variable 'next-error-function) #'js2-next-error)
+  (set (make-local-variable 'beginning-of-defun-function) #'js2-beginning-of-defun)
+  (set (make-local-variable 'end-of-defun-function) #'js2-end-of-defun)
+  ;; We un-confuse `parse-partial-sexp' by setting syntax-table properties
+  ;; for characters inside regexp literals.
+  (set (make-local-variable 'parse-sexp-lookup-properties) t)
+  ;; this is necessary to make `show-paren-function' work properly
+  (set (make-local-variable 'parse-sexp-ignore-comments) t)
+  ;; needed for M-x rgrep, among other things
+  (put 'js2-mode 'find-tag-default-function #'js2-mode-find-tag)
+
+  ;; some variables needed by cc-engine for paragraph-fill, etc.
+  (setq c-buffer-is-cc-mode t
+        c-comment-prefix-regexp js2-comment-prefix-regexp
+        c-comment-start-regexp "/[*/]\\|\\s|"
+        c-paragraph-start js2-paragraph-start
+        c-paragraph-separate "$"
+        comment-start-skip js2-comment-start-skip
+        c-syntactic-ws-start js2-syntactic-ws-start
+        c-syntactic-ws-end js2-syntactic-ws-end
+        c-syntactic-eol js2-syntactic-eol)
+  (if js2-emacs22
+      (c-setup-paragraph-variables))
+
+  (setq js2-default-externs
+        (append js2-ecma-262-externs
+                (if js2-include-browser-externs
+                    js2-browser-externs)
+                (if js2-include-gears-externs
+                    js2-gears-externs)
+                (if js2-include-rhino-externs
+                     js2-rhino-externs)))
+
+  ;; We do our own syntax highlighting based on the parse tree.
+  ;; However, we want minor modes that add keywords to highlight properly
+  ;; (examples:  doxymacs, column-marker).  We do this by not letting
+  ;; font-lock unfontify anything, and telling it to fontify after we
+  ;; re-parse and re-highlight the buffer.  (We currently don't do any
+  ;; work with regions other than the whole buffer.)
+  (dolist (var '(font-lock-unfontify-buffer-function
+                 font-lock-unfontify-region-function))
+    (set (make-local-variable var) (lambda (&rest args) t)))
+
+  ;; Don't let font-lock do syntactic (string/comment) fontification.
+  (set (make-local-variable #'font-lock-syntactic-face-function)
+       (lambda (state) nil))
+
+  ;; Experiment:  make reparse-delay longer for longer files.
+  (if (plusp js2-dynamic-idle-timer-adjust)
+      (setq js2-idle-timer-delay
+            (* js2-idle-timer-delay
+               (/ (point-max) js2-dynamic-idle-timer-adjust))))
+
+  (add-hook 'change-major-mode-hook #'js2-mode-exit nil t)
+  (add-hook 'after-change-functions #'js2-mode-edit nil t)
+  (setq imenu-create-index-function #'js2-mode-create-imenu-index)
+  (imenu-add-to-menubar (concat "IM-" mode-name))
+  (when js2-mirror-mode
+    (js2-enter-mirror-mode))
+  (add-to-invisibility-spec '(js2-outline . t))
+  (set (make-local-variable 'line-move-ignore-invisible) t)
+  (set (make-local-variable 'forward-sexp-function) #'js2-mode-forward-sexp)
+  (setq js2-mode-functions-hidden nil
+        js2-mode-comments-hidden nil
+        js2-mode-buffer-dirty-p t
+        js2-mode-parsing nil)
+  (js2-reparse)
+  (run-hooks 'js2-mode-hook))
+
+(defun js2-mode-check-compat ()
+  "Signal an error if we can't run with this version of Emacs."
+  (if (and js2-mode-must-byte-compile
+           (not (byte-code-function-p (symbol-function 'js2-mode))))
+      (error "You must byte-compile js2-mode before using it."))
+  (if (and (boundp 'running-xemacs) running-xemacs)
+      (error "js2-mode is not compatible with XEmacs"))
+  (unless (>= emacs-major-version 21)
+    (error "js2-mode requires GNU Emacs version 21 or higher")))
+
+(defun js2-mode-exit ()
+  (interactive)
+  (when js2-mode-node-overlay
+    (delete-overlay js2-mode-node-overlay)
+    (setq js2-mode-node-overlay nil))
+  (js2-remove-overlays)
+  (setq js2-mode-ast nil)
+  (remove-hook 'change-major-mode-hook #'js2-mode-exit t)
+  (remove-from-invisibility-spec '(js2-outline . t))
+  (js2-mode-show-all)
+  (js2-with-unmodifying-text-property-changes
+    (js2-clear-face (point-min) (point-max))))
+
+(defun js2-before-save ()
+  "Clean up whitespace before saving file.
+You can disable this by customizing `js2-cleanup-whitespace'."
+  (when js2-cleanup-whitespace
+    (let ((col (current-column)))
+      (delete-trailing-whitespace)
+      ;; don't change trailing whitespace on current line
+      (unless (eq (current-column) col)
+        (indent-to col)))))
+
+(defsubst js2-mode-reset-timer ()
+  (if js2-mode-parse-timer
+      (cancel-timer js2-mode-parse-timer))
+  (setq js2-mode-parsing nil)
+  (setq js2-mode-parse-timer
+        (run-with-idle-timer js2-idle-timer-delay nil #'js2-reparse)))
+
+(defun js2-mode-edit (beg end len)
+  "Schedule a new parse after buffer is edited.
+Also clears the `js2-magic' bit on autoinserted parens/brackets
+if the edit occurred on a line different from the magic paren."
+  (let* ((magic-pos (next-single-property-change (point-min) 'js2-magic))
+         (line (if magic-pos (line-number-at-pos magic-pos))))
+    (and line
+         (or (/= (line-number-at-pos beg) line)
+             (and (> 0 len)
+                  (/= (line-number-at-pos end) line)))
+         (js2-mode-mundanify-parens)))
+  (setq js2-mode-buffer-dirty-p t)
+  (js2-mode-hide-overlay)
+  (js2-mode-reset-timer))
+
+(defun js2-mode-run-font-lock ()
+  "Run `font-lock-fontify-buffer' after parsing/highlighting.
+This is intended to allow modes that install their own font-lock keywords
+to work with js2-mode.  In practice it never seems to work for long.
+Hopefully the Emacs maintainers can help figure out a way to make it work."
+  (when (and (boundp 'font-lock-keywords)
+             font-lock-keywords
+             (boundp 'font-lock-mode)
+             font-lock-mode)
+    ;; TODO:  font-lock and jit-lock really really REALLY don't want to
+    ;; play nicely with js2-mode.  They go out of their way to fail to
+    ;; provide any option for saying "look, fontify the goddamn buffer
+    ;; with just the keywords already".  Argh.
+    (setq font-lock-defaults (list font-lock-keywords 'keywords-only))
+    (let (font-lock-verbose)
+      (font-lock-default-fontify-buffer))))
+
+(defun js2-reparse (&optional force)
+  "Re-parse current buffer after user finishes some data entry.
+If we get any user input while parsing, including cursor motion,
+we discard the parse and reschedule it.  If FORCE is nil, then the
+buffer will only rebuild its `js2-mode-ast' if the buffer is dirty."
+  (let (time
+        interrupted-p
+        (js2-compiler-strict-mode js2-mode-show-strict-warnings))
+    (unless js2-mode-parsing
+      (setq js2-mode-parsing t)
+      (unwind-protect
+          (when (or js2-mode-buffer-dirty-p force)
+            (js2-remove-overlays)
+            (js2-with-unmodifying-text-property-changes
+              (remove-text-properties (point-min) (point-max) '(syntax-table))
+              (setq js2-mode-buffer-dirty-p nil
+                    js2-mode-fontifications nil
+                    js2-mode-deferred-properties nil
+                    js2-additional-externs nil)
+              (if js2-mode-verbose-parse-p
+                  (message "parsing..."))
+              (setq time
+                    (js2-time
+                     (setq interrupted-p
+                           (catch 'interrupted
+                             (setq js2-mode-ast (js2-parse))
+                             (js2-mode-fontify-regions)
+                             (js2-mode-remove-suppressed-warnings)
+                             (js2-mode-show-warnings)
+                             (js2-mode-show-errors)
+                             (js2-mode-run-font-lock)  ; note:  doesn't work
+                             (js2-mode-highlight-magic-parens)
+                             (if (>= js2-highlight-level 1)
+                                 (js2-highlight-jsdoc js2-mode-ast))
+                             nil))))
+              (if interrupted-p
+                  (progn
+                    ;; unfinished parse => try again
+                    (setq js2-mode-buffer-dirty-p t)
+                    (js2-mode-reset-timer))
+                (if js2-mode-verbose-parse-p
+                    (message "Parse time: %s" time)))))
+        ;; finally
+        (setq js2-mode-parsing nil)
+        (unless interrupted-p
+          (setq js2-mode-parse-timer nil))))))
+
+(defun js2-mode-show-node ()
+  "Debugging aid:  highlight selected AST node on mouse click."
+  (interactive)
+  (let ((node (js2-node-at-point))
+        beg
+        end)
+    (when js2-mode-show-overlay
+      (if (null node)
+          (message "No node found at location %s" (point))
+        (setq beg (js2-node-abs-pos node)
+              end (+ beg (js2-node-len node)))
+        (if js2-mode-node-overlay
+            (move-overlay js2-mode-node-overlay beg end)
+          (setq js2-mode-node-overlay (make-overlay beg end))
+          (overlay-put js2-mode-node-overlay 'face 'highlight))
+        (js2-with-unmodifying-text-property-changes
+          (put-text-property beg end 'point-left #'js2-mode-hide-overlay))
+        (message "%s, parent: %s"
+                 (js2-node-short-name node)
+                 (if (js2-node-parent node)
+                     (js2-node-short-name (js2-node-parent node))
+                   "nil"))))))
+
+(defun js2-mode-hide-overlay (&optional p1 p2)
+  "Remove the debugging overlay when the point moves."
+  (when js2-mode-node-overlay
+    (let ((beg (overlay-start js2-mode-node-overlay))
+          (end (overlay-end js2-mode-node-overlay)))
+      ;; Sometimes we're called spuriously.
+      (unless (and p2
+                   (>= p2 beg)
+                   (<= p2 end))
+        (js2-with-unmodifying-text-property-changes
+          (remove-text-properties beg end '(point-left nil)))
+        (delete-overlay js2-mode-node-overlay)
+        (setq js2-mode-node-overlay nil)))))
+
+(defun js2-mode-reset ()
+  "Debugging helper; resets everything."
+  (interactive)
+  (js2-mode-exit)
+  (js2-mode))
+
+(defsubst js2-mode-show-warn-or-err (e face)
+  "Highlight a warning or error E with FACE.
+E is a list of ((MSG-KEY MSG-ARG) BEG END)."
+  (let* ((key (first e))
+         (beg (second e))
+         (end (+ beg (third e)))
+         ;; Don't inadvertently go out of bounds.
+         (beg (max (point-min) (min beg (point-max))))
+         (end (max (point-min) (min end (point-max))))
+         (js2-highlight-level 3)    ; so js2-set-face is sure to fire
+         (ovl (make-overlay beg end)))
+    (overlay-put ovl 'face face)
+    (overlay-put ovl 'js2-error t)
+    (put-text-property beg end 'help-echo (js2-get-msg key))
+    (put-text-property beg end 'point-entered #'js2-echo-error)))
+
+(defun js2-remove-overlays ()
+  "Remove overlays from buffer that have a `js2-error' property."
+  (let ((beg (point-min))
+        (end (point-max)))
+    (save-excursion
+      (dolist (o (overlays-in beg end))
+        (when (overlay-get o 'js2-error)
+          (delete-overlay o))))))
+
+(defun js2-error-at-point (&optional pos)
+  "Return non-nil if there's an error overlay at POS.
+Defaults to point."
+  (loop with pos = (or pos (point))
+        for o in (overlays-at pos)
+        thereis (overlay-get o 'js2-error)))
+
+(defun js2-mode-fontify-regions ()
+  "Apply fontifications recorded during parsing."
+  ;; We defer clearing faces as long as possible to eliminate flashing.
+  (js2-clear-face (point-min) (point-max))
+  ;; have to reverse the recorded fontifications so that errors and
+  ;; warnings overwrite the normal fontifications
+  (dolist (f (nreverse js2-mode-fontifications))
+    (put-text-property (first f) (second f) 'face (third f)))
+  (setq js2-mode-fontifications nil)
+  (dolist (p js2-mode-deferred-properties)
+    (apply #'put-text-property p))
+  (setq js2-mode-deferred-properties nil))
+
+(defun js2-mode-show-errors ()
+  "Highlight syntax errors."
+  (when js2-mode-show-parse-errors
+    (dolist (e (js2-ast-root-errors js2-mode-ast))
+      (js2-mode-show-warn-or-err e 'js2-error-face))))
+
+(defun js2-mode-remove-suppressed-warnings ()
+  "Take suppressed warnings out of the AST warnings list.
+This ensures that the counts and `next-error' are correct."
+  (setf (js2-ast-root-warnings js2-mode-ast)
+        (js2-delete-if
+         (lambda (e)
+           (let ((key (caar e)))
+             (or
+              (and (not js2-strict-trailing-comma-warning)
+                   (string-match "trailing\\.comma" key))
+              (and (not js2-strict-cond-assign-warning)
+                   (string= key "msg.equal.as.assign"))
+              (and js2-missing-semi-one-line-override
+                   (string= key "msg.missing.semi")
+                   (let* ((beg (second e))
+                          (node (js2-node-at-point beg))
+                          (fn (js2-mode-find-parent-fn node))
+                          (body (and fn (js2-function-node-body fn)))
+                          (lc (and body (js2-node-abs-pos body)))
+                          (rc (and lc (+ lc (js2-node-len body)))))
+                     (and fn
+                          (or (null body)
+                              (save-excursion
+                                (goto-char beg)
+                                (and (js2-same-line lc)
+                                     (js2-same-line rc))))))))))
+         (js2-ast-root-warnings js2-mode-ast))))
+
+(defun js2-mode-show-warnings ()
+  "Highlight strict-mode warnings."
+  (when js2-mode-show-strict-warnings
+    (dolist (e (js2-ast-root-warnings js2-mode-ast))
+      (js2-mode-show-warn-or-err e 'js2-warning-face))))
+
+(defun js2-echo-error (old-point new-point)
+  "Called by point-motion hooks."
+  (let ((msg (get-text-property new-point 'help-echo)))
+    (if msg
+        (message msg))))
+
+(defalias #'js2-echo-help #'js2-echo-error)
+
+(defun js2-enter-key ()
+  "Handle user pressing the Enter key."
+  (interactive)
+  (let ((parse-status (save-excursion
+                        (parse-partial-sexp (point-min) (point)))))
+    (cond
+     ;; check if we're inside a string
+     ((nth 3 parse-status)
+      (js2-mode-split-string parse-status))
+     ;; check if inside a block comment
+     ((nth 4 parse-status)
+      (js2-mode-extend-comment))
+     (t
+      ;; should probably figure out what the mode-map says we should do
+      (if js2-indent-on-enter-key
+          (let ((js2-bounce-indent-p nil))
+            (js2-indent-line)))
+      (insert "\n")
+      (if js2-enter-indents-newline
+          (let ((js2-bounce-indent-p nil))
+            (js2-indent-line)))))))
+
+(defun js2-mode-split-string (parse-status)
+  "Turn a newline in mid-string into a string concatenation."
+  (let* ((col (current-column))
+         (quote-char (nth 3 parse-status))
+         (quote-string (string quote-char))
+         (string-beg (nth 8 parse-status))
+         (indent (save-match-data
+                   (or
+                    (save-excursion
+                      (back-to-indentation)
+                      (if (looking-at "\\+")
+                          (current-column)))
+                    (save-excursion
+                      (goto-char string-beg)
+                      (if (looking-back "\\+\\s-+")
+                          (goto-char (match-beginning 0)))
+                      (current-column))))))
+    (insert quote-char "\n")
+    (indent-to indent)
+    (insert "+ " quote-string)
+    (when (eolp)
+      (insert quote-string)
+      (backward-char 1))))
+
+(defun js2-mode-extend-comment ()
+  "When inside a comment block, add comment prefix."
+  (let (star single col first-line needs-close)
+    (save-excursion
+      (back-to-indentation)
+      (cond
+       ((looking-at "\\*[^/]")
+        (setq star t
+              col (current-column)))
+       ((looking-at "/\\*")
+        (setq star t
+              first-line t
+              col (1+ (current-column))))
+       ((looking-at "//")
+        (setq single t
+              col (current-column)))))
+    ;; Heuristic for whether we need to close the comment:
+    ;; if we've got a parse error here, assume it's an unterminated
+    ;; comment.
+    (setq needs-close
+          (or
+           (eq (get-text-property (1- (point)) 'point-entered)
+               'js2-echo-error)
+           ;; The heuristic above doesn't work well when we're
+           ;; creating a comment and there's another one downstream,
+           ;; as our parser thinks this one ends at the end of the
+           ;; next one.  (You can have a /* inside a js block comment.)
+           ;; So just close it if the next non-ws char isn't a *.
+           (and first-line
+                (eolp)
+                (save-excursion
+                  (skip-chars-forward " \t\r\n")
+                  (not (eq (char-after) ?*))))))
+    (insert "\n")
+    (cond
+     (star
+      (indent-to col)
+      (insert "* ")
+      (if (and first-line needs-close)
+          (save-excursion
+            (insert "\n")
+            (indent-to col)
+            (insert "*/"))))
+     (single
+      (when (save-excursion
+              (and (zerop (forward-line 1))
+                   (looking-at "\\s-*//")))
+        (indent-to col)
+        (insert "// "))))))
+
+(defun js2-fill-string (beg quote)
+  "Line-wrap a single-line string into a multi-line string.
+BEG is the string beginning, QUOTE is the quote char."
+  (let* ((squote (string quote))
+         (end (if (re-search-forward (concat "[^\\]" squote)
+                                     (point-at-eol) t)
+                  (1+ (match-beginning 0))
+                (point-at-eol)))
+         (tag (make-marker))
+         (fill-column (- fill-column 4)))  ; make room
+    (unwind-protect
+        (progn
+          (move-marker tag end)
+          (fill-paragraph nil)
+          (goto-char beg)
+          (while (not (js2-same-line tag))
+            (goto-char (point-at-eol))
+            (insert squote)
+            (when (zerop (forward-line 1))
+              (back-to-indentation)
+              (if (looking-at (concat squote "\\s-*$"))
+                  (progn
+                    (setq end (point-at-eol))
+                    (forward-line -1)
+                    (delete-region (point-at-eol) end))
+                (insert "+ " squote)))))
+      (move-marker tag nil))))
+
+(defun js2-fill-comment (parse-status arg)
+  "Fill-paragraph in a block comment."
+  (let* ((beg (nth 8 parse-status))
+         (end (save-excursion
+                (goto-char beg)
+                (re-search-forward "[^\\]\\*/" nil t)))
+         indent
+         end-marker)
+    (when end
+      (setq end-marker (make-marker))
+      (move-marker end-marker end))
+    (when (and end js2-mode-squeeze-spaces)
+      (save-excursion
+        (save-restriction
+          (narrow-to-region beg end)
+          (goto-char (point-min))
+          (while (re-search-forward "[ \t][ \t]+" nil t)
+            (replace-match " ")))))
+    ;; `c-fill-paragraph' doesn't indent the continuation stars properly
+    ;; if the comment isn't left-justified.  They align to the first star
+    ;; on the first continuation line after the comment-open, so we make
+    ;; sure the first continuation line has the proper indentation.
+    (save-excursion
+      (goto-char beg)
+      (setq indent (1+ (current-column)))
+      (goto-char (point-at-eol))
+      (skip-chars-forward " \t\r\n")
+      (indent-line-to indent)
+
+      ;; Invoke `c-fill-paragraph' from the first continuation line,
+      ;; since it provides better results.  Otherwise if you're on the
+      ;; last line, it doesn't prefix with stars the way you'd expect.
+      ;; TODO:  write our own fill function that works in Emacs 21
+      (let ((fill-paragraph-function 'c-fill-paragraph))
+        (c-fill-paragraph arg)))
+
+    ;; last line is typically indented wrong, so fix it
+    (when end-marker
+      (save-excursion
+        (goto-char end-marker)
+        (js2-indent-line)))))
+
+(defun js2-beginning-of-line ()
+  "Toggles point between bol and first non-whitespace char in line.
+Also moves past comment delimiters when inside comments."
+  (interactive)
+  (let (node beg)
+    (cond
+     ((bolp)
+      (back-to-indentation))
+     ((looking-at "//")
+      (skip-chars-forward "/ \t"))
+     ((and (eq (char-after) ?*)
+           (setq node (js2-comment-at-point))
+           (memq (js2-comment-node-format node) '(jsdoc block))
+           (save-excursion
+             (skip-chars-backward " \t")
+             (bolp)))
+      (skip-chars-forward "\* \t"))
+     (t
+      (goto-char (point-at-bol))))))
+
+(defun js2-end-of-line ()
+  "Toggles point between eol and last non-whitespace char in line."
+  (interactive)
+  (if (eolp)
+      (skip-chars-backward " \t")
+    (goto-char (point-at-eol))))
+
+(defun js2-enter-mirror-mode()
+  "Turns on mirror mode, where quotes, brackets etc are mirrored automatically
+  on insertion."
+  (interactive)
+  (define-key js2-mode-map (read-kbd-macro "{")  'js2-mode-match-curly)
+  (define-key js2-mode-map (read-kbd-macro "}")  'js2-mode-magic-close-paren)
+  (define-key js2-mode-map (read-kbd-macro "\"") 'js2-mode-match-double-quote)
+  (define-key js2-mode-map (read-kbd-macro "'")  'js2-mode-match-single-quote)
+  (define-key js2-mode-map (read-kbd-macro "(")  'js2-mode-match-paren)
+  (define-key js2-mode-map (read-kbd-macro ")")  'js2-mode-magic-close-paren)
+  (define-key js2-mode-map (read-kbd-macro "[")  'js2-mode-match-bracket)
+  (define-key js2-mode-map (read-kbd-macro "]")  'js2-mode-magic-close-paren))
+
+(defun js2-leave-mirror-mode()
+  "Turns off mirror mode."
+  (interactive)
+  (dolist (key '("{" "\"" "'" "(" ")" "[" "]"))
+    (define-key js2-mode-map (read-kbd-macro key) 'self-insert-command)))
+
+(defsubst js2-mode-inside-string ()
+  "Return non-nil if inside a string.
+Actually returns the quote character that begins the string."
+   (let ((parse-state (save-excursion
+                        (parse-partial-sexp (point-min) (point)))))
+      (nth 3 parse-state)))
+
+(defsubst js2-mode-inside-comment-or-string ()
+  "Return non-nil if inside a comment or string."
+  (or
+   (let ((comment-start
+          (save-excursion
+            (goto-char (point-at-bol))
+            (if (re-search-forward "//" (point-at-eol) t)
+                (match-beginning 0)))))
+     (and comment-start
+          (<= comment-start (point))))
+   (let ((parse-state (save-excursion
+                        (parse-partial-sexp (point-min) (point)))))
+     (or (nth 3 parse-state)
+         (nth 4 parse-state)))))
+
+(defsubst js2-make-magic-delimiter (delim &optional pos)
+  "Add `js2-magic' and `js2-magic-paren-face' to DELIM, a string.
+Sets value of `js2-magic' text property to line number at POS."
+  (propertize delim
+              'js2-magic (line-number-at-pos pos)
+              'face 'js2-magic-paren-face))
+
+(defun js2-mode-match-delimiter (open close)
+  "Insert OPEN (a string) and possibly matching delimiter CLOSE.
+The rule we use, which as far as we can tell is how Eclipse works,
+is that we insert the match if we're not in a comment or string,
+and the next non-whitespace character is either punctuation or
+occurs on another line."
+  (insert open)
+  (when (and (looking-at "\\s-*\\([[:punct:]]\\|$\\)")
+             (not (js2-mode-inside-comment-or-string)))
+    (save-excursion
+      (insert (js2-make-magic-delimiter close)))
+    (when js2-auto-indent-p
+      (let ((js2-bounce-indent-p (js2-code-at-bol-p)))
+        (js2-indent-line)))))
+
+(defun js2-mode-match-bracket ()
+  "Insert matching bracket."
+  (interactive)
+  (js2-mode-match-delimiter "[" "]"))
+
+(defun js2-mode-match-paren ()
+  "Insert matching paren unless already inserted."
+  (interactive)
+  (js2-mode-match-delimiter "(" ")"))
+
+(defun js2-mode-match-curly (arg)
+  "Insert matching curly-brace.
+With prefix arg, no formatting or indentation will occur -- the close-brace
+is simply inserted directly at the point."
+  (interactive "p")
+  (let (try-pos)
+    (cond
+     (current-prefix-arg
+      (js2-mode-match-delimiter "{" "}"))
+     ((and js2-auto-insert-catch-block
+           (setq try-pos (if (looking-back "\\s-*\\(try\\)\\s-*"
+                                           (point-at-bol))
+                             (match-beginning 1))))
+      (js2-insert-catch-skel try-pos))
+     (t
+      ;; Otherwise try to do something smarter.
+      (insert "{")
+      (unless (or (not (looking-at "\\s-*$"))
+                  (save-excursion
+                    (skip-chars-forward " \t\r\n")
+                    (and (looking-at "}")
+                         (js2-error-at-point)))
+                  (js2-mode-inside-comment-or-string))
+        (undo-boundary)
+        ;; absolutely mystifying bug:  when inserting the next "\n",
+        ;; the buffer-undo-list is given two new entries:  the inserted range,
+        ;; and the incorrect position of the point.  It's recorded incorrectly
+        ;; as being before the opening "{", not after it.  But it's recorded
+        ;; as the correct value if you're debugging `js2-mode-match-curly'
+        ;; in edebug.  I have no idea why it's doing this, but incrementing
+        ;; the inserted position fixes the problem, so that the undo takes us
+        ;; back to just after the user-inserted "{".
+        (insert "\n")
+        (ignore-errors
+          (incf (cadr buffer-undo-list)))
+        (js2-indent-line)
+        (save-excursion
+          (insert "\n}")
+          (let ((js2-bounce-indent-p (js2-code-at-bol-p)))
+            (js2-indent-line))))))))
+
+(defun js2-insert-catch-skel (try-pos)
+  "Complete a try/catch block after inserting a { following a try keyword.
+Rationale is that a try always needs a catch or a finally, and the catch is
+the more likely of the two.
+
+TRY-POS is the buffer position of the try keyword.  The open-curly should
+already have been inserted."
+  (insert "{")
+  (let ((try-col (save-excursion
+                   (goto-char try-pos)
+                   (current-column))))
+    (insert "\n")
+    (undo-boundary)
+    (js2-indent-line) ;; indent the blank line where cursor will end up
+    (save-excursion
+      (insert "\n")
+      (indent-to try-col)
+      (insert "} catch (x) {\n\n")
+      (indent-to try-col)
+      (insert "}"))))
+
+(defun js2-mode-highlight-magic-parens ()
+  "Re-highlight magic parens after parsing nukes the 'face prop."
+  (let ((beg (point-min))
+        end)
+    (while (setq beg (next-single-property-change beg 'js2-magic))
+      (setq end (next-single-property-change (1+ beg) 'js2-magic))
+      (if (get-text-property beg 'js2-magic)
+          (js2-with-unmodifying-text-property-changes
+            (put-text-property beg (or end (1+ beg))
+                               'face 'js2-magic-paren-face))))))
+
+(defun js2-mode-mundanify-parens ()
+  "Clear all magic parens and brackets."
+  (let ((beg (point-min))
+        end)
+    (while (setq beg (next-single-property-change beg 'js2-magic))
+      (setq end (next-single-property-change (1+ beg) 'js2-magic))
+      (remove-text-properties beg (or end (1+ beg))
+                              '(js2-magic face)))))
+
+(defsubst js2-match-quote (quote-string)
+  (let ((start-quote (js2-mode-inside-string)))
+    (cond
+     ;; inside a comment - don't do quote-matching, since we can't
+     ;; reliably figure out if we're in a string inside the comment
+     ((js2-comment-at-point)
+      (insert quote-string))
+     ((not start-quote)
+      ;; not in string => insert matched quotes
+      (insert quote-string)
+      ;; exception:  if we're just before a word, don't double it.
+      (unless (looking-at "[^ \t\r\n]")
+        (save-excursion
+          (insert quote-string))))
+     ((looking-at quote-string)
+      (if (looking-back "[^\\]\\\\")
+          (insert quote-string)
+        (forward-char 1)))
+     ((and js2-mode-escape-quotes
+           (save-excursion
+             (save-match-data
+               (re-search-forward quote-string (point-at-eol) t))))
+      ;; inside terminated string, escape quote (unless already escaped)
+      (insert (if (looking-back "[^\\]\\\\")
+                  quote-string
+                (concat "\\" quote-string))))
+     (t
+      (insert quote-string)))))        ; else terminate the string
+
+(defun js2-mode-match-single-quote ()
+  "Insert matching single-quote."
+  (interactive)
+  (let ((parse-status (parse-partial-sexp (point-min) (point))))
+    ;; don't match inside comments, since apostrophe is more common
+    (if (nth 4 parse-status)
+        (insert "'")
+      (js2-match-quote "'"))))
+
+(defun js2-mode-match-double-quote ()
+  "Insert matching double-quote."
+  (interactive)
+  (js2-match-quote "\""))
+
+;; Eclipse works as follows:
+;;  * type an open-paren and it auto-inserts close-paren
+;;    - auto-inserted paren gets a green bracket
+;;    - green bracket means typing close-paren there will skip it
+;;  * if you insert any text on a different line, it turns off
+(defun js2-mode-magic-close-paren ()
+  "Skip over close-paren rather than inserting, where appropriate."
+  (interactive)
+  (let* ((here (point))
+         (parse-status (parse-partial-sexp (point-min) here))
+         (open-pos (nth 1 parse-status))
+         (close last-input-event)
+         (open (cond
+                ((eq close ?\))
+                 ?\()
+                ((eq close ?\])
+                 ?\[)
+                ((eq close ?})
+                 ?{)
+                (t nil))))
+    (if (and (eq (char-after) close)
+             (eq open (char-after open-pos))
+             (js2-same-line open-pos)
+             (get-text-property here 'js2-magic))
+        (progn
+          (remove-text-properties here (1+ here) '(js2-magic face))
+          (forward-char 1))
+      (insert-char close 1))
+    (blink-matching-open)))
+
+(defun js2-mode-wait-for-parse (callback)
+  "Invoke CALLBACK when parsing is finished.
+If parsing is already finished, calls CALLBACK immediately."
+  (if (not js2-mode-buffer-dirty-p)
+      (funcall callback)
+    (push callback js2-mode-pending-parse-callbacks)
+    (add-hook 'js2-parse-finished-hook #'js2-mode-parse-finished)))
+
+(defun js2-mode-parse-finished ()
+  "Invoke callbacks in `js2-mode-pending-parse-callbacks'."
+  ;; We can't let errors propagate up, since it prevents the
+  ;; `js2-parse' method from completing normally and returning
+  ;; the ast, which makes things mysteriously not work right.
+  (unwind-protect
+      (dolist (cb js2-mode-pending-parse-callbacks)
+        (condition-case err
+            (funcall cb)
+          (error (message "%s" err))))
+    (setq js2-mode-pending-parse-callbacks nil)))
+
+(defun js2-mode-flag-region (from to flag)
+  "Hide or show text from FROM to TO, according to FLAG.
+If FLAG is nil then text is shown, while if FLAG is t the text is hidden.
+Returns the created overlay if FLAG is non-nil."
+  (remove-overlays from to 'invisible 'js2-outline)
+  (when flag
+    (let ((o (make-overlay from to)))
+      (overlay-put o 'invisible 'js2-outline)
+      (overlay-put o 'isearch-open-invisible
+                   'js2-isearch-open-invisible)
+      o)))
+
+;; Function to be set as an outline-isearch-open-invisible' property
+;; to the overlay that makes the outline invisible (see
+;; `js2-mode-flag-region').
+(defun js2-isearch-open-invisible (overlay)
+  ;; We rely on the fact that isearch places point on the matched text.
+  (js2-mode-show-element))
+
+(defun js2-mode-invisible-overlay-bounds (&optional pos)
+  "Return cons cell of bounds of folding overlay at POS.
+Returns nil if not found."
+  (let ((overlays (overlays-at (or pos (point))))
+        o)
+    (while (and overlays
+                (not o))
+      (if (overlay-get (car overlays) 'invisible)
+          (setq o (car overlays))
+        (setq overlays (cdr overlays))))
+    (if o
+        (cons (overlay-start o) (overlay-end o)))))
+
+(defun js2-mode-function-at-point (&optional pos)
+  "Return the innermost function node enclosing current point.
+Returns nil if point is not in a function."
+  (let ((node (js2-node-at-point pos)))
+    (while (and node (not (js2-function-node-p node)))
+      (setq node (js2-node-parent node)))
+    (if (js2-function-node-p node)
+        node)))
+
+(defun js2-mode-toggle-element ()
+  "Hide or show the foldable element at the point."
+  (interactive)
+  (let (comment fn pos)
+    (save-excursion
+      (save-match-data
+        (cond
+         ;; /* ... */ comment?
+         ((js2-block-comment-p (setq comment (js2-comment-at-point)))
+          (if (js2-mode-invisible-overlay-bounds
+               (setq pos (+ 3 (js2-node-abs-pos comment))))
+              (progn
+                (goto-char pos)
+                (js2-mode-show-element))
+            (js2-mode-hide-element)))
+
+         ;; //-comment?
+         ((save-excursion
+            (back-to-indentation)
+            (looking-at js2-mode-//-comment-re))
+          (js2-mode-toggle-//-comment))
+
+         ;; function?
+         ((setq fn (js2-mode-function-at-point))
+          (setq pos (and (js2-function-node-body fn)
+                         (js2-node-abs-pos (js2-function-node-body fn))))
+          (goto-char (1+ pos))
+          (if (js2-mode-invisible-overlay-bounds)
+              (js2-mode-show-element)
+            (js2-mode-hide-element)))
+         (t
+          (message "Nothing at point to hide or show")))))))
+
+(defun js2-mode-hide-element ()
+  "Fold/hide contents of a block, showing ellipses.
+Show the hidden text with \\[js2-mode-show-element]."
+  (interactive)
+  (if js2-mode-buffer-dirty-p
+      (js2-mode-wait-for-parse #'js2-mode-hide-element))
+  (let (node body beg end)
+    (cond
+     ((js2-mode-invisible-overlay-bounds)
+      (message "already hidden"))
+     (t
+      (setq node (js2-node-at-point))
+      (cond
+       ((js2-block-comment-p node)
+        (js2-mode-hide-comment node))
+       (t
+        (while (and node (not (js2-function-node-p node)))
+          (setq node (js2-node-parent node)))
+        (if (and node
+                 (setq body (js2-function-node-body node)))
+            (progn
+              (setq beg (js2-node-abs-pos body)
+                    end (+ beg (js2-node-len body)))
+              (js2-mode-flag-region (1+ beg) (1- end) 'hide))
+          (message "No collapsable element found at point"))))))))
+
+(defun js2-mode-show-element ()
+  "Show the hidden element at current point."
+  (interactive)
+  (let ((bounds (js2-mode-invisible-overlay-bounds)))
+    (if bounds
+        (js2-mode-flag-region (car bounds) (cdr bounds) nil)
+      (message "Nothing to un-hide"))))
+
+(defun js2-mode-show-all ()
+  "Show all of the text in the buffer."
+  (interactive)
+  (js2-mode-flag-region (point-min) (point-max) nil))
+
+(defun js2-mode-toggle-hide-functions ()
+  (interactive)
+  (if js2-mode-functions-hidden
+      (js2-mode-show-functions)
+    (js2-mode-hide-functions)))
+
+(defun js2-mode-hide-functions ()
+  "Hides all non-nested function bodies in the buffer.
+Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element]
+to open an individual entry."
+  (interactive)
+  (if js2-mode-buffer-dirty-p
+      (js2-mode-wait-for-parse #'js2-mode-hide-functions))
+  (if (null js2-mode-ast)
+      (message "Oops - parsing failed")
+    (setq js2-mode-functions-hidden t)
+    (js2-visit-ast js2-mode-ast #'js2-mode-function-hider)))
+
+(defun js2-mode-function-hider (n endp)
+  (when (not endp)
+    (let ((tt (js2-node-type n))
+          body beg end)
+      (cond
+       ((and (= tt js2-FUNCTION)
+             (setq body (js2-function-node-body n)))
+        (setq beg (js2-node-abs-pos body)
+              end (+ beg (js2-node-len body)))
+        (js2-mode-flag-region (1+ beg) (1- end) 'hide)
+        nil)   ; don't process children of function
+       (t
+        t))))) ; keep processing other AST nodes
+
+(defun js2-mode-show-functions ()
+  "Un-hide any folded function bodies in the buffer."
+  (interactive)
+  (setq js2-mode-functions-hidden nil)
+  (save-excursion
+    (goto-char (point-min))
+    (while (/= (goto-char (next-overlay-change (point)))
+               (point-max))
+      (dolist (o (overlays-at (point)))
+        (when (and (overlay-get o 'invisible)
+                   (not (overlay-get o 'comment)))
+          (js2-mode-flag-region (overlay-start o) (overlay-end o) nil))))))
+
+(defun js2-mode-hide-comment (n)
+  (let* ((head (if (eq (js2-comment-node-format n) 'jsdoc)
+                   3                    ; /**
+                 2))                    ; /*
+         (beg (+ (js2-node-abs-pos n) head))
+         (end (- (+ beg (js2-node-len n)) head 2))
+         (o (js2-mode-flag-region beg end 'hide)))
+    (overlay-put o 'comment t)))
+
+(defun js2-mode-toggle-hide-comments ()
+  "Folds all block comments in the buffer.
+Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element]
+to open an individual entry."
+  (interactive)
+  (if js2-mode-comments-hidden
+      (js2-mode-show-comments)
+    (js2-mode-hide-comments)))
+
+(defun js2-mode-hide-comments ()
+  (interactive)
+  (if js2-mode-buffer-dirty-p
+      (js2-mode-wait-for-parse #'js2-mode-hide-comments))
+  (if (null js2-mode-ast)
+      (message "Oops - parsing failed")
+    (setq js2-mode-comments-hidden t)
+    (dolist (n (js2-ast-root-comments js2-mode-ast))
+      (let ((format (js2-comment-node-format n)))
+        (when (js2-block-comment-p n)
+          (js2-mode-hide-comment n))))
+    (js2-mode-hide-//-comments)))
+
+(defsubst js2-mode-extend-//-comment (direction)
+  "Find start or end of a block of similar //-comment lines.
+DIRECTION is -1 to look back, 1 to look forward.
+INDENT is the indentation level to match.
+Returns the end-of-line position of the furthest adjacent
+//-comment line with the same indentation as the current line.
+If there is no such matching line, returns current end of line."
+  (let ((pos (point-at-eol))
+        (indent (current-indentation)))
+    (save-excursion
+      (save-match-data
+        (while (and (zerop (forward-line direction))
+                    (looking-at js2-mode-//-comment-re)
+                    (eq indent (length (match-string 1))))
+          (setq pos (point-at-eol)))
+      pos))))
+
+(defun js2-mode-hide-//-comments ()
+  "Fold adjacent 1-line comments, showing only snippet of first one."
+  (let (beg end)
+    (save-excursion
+      (save-match-data
+        (goto-char (point-min))
+        (while (re-search-forward js2-mode-//-comment-re nil t)
+          (setq beg (point)
+                end (js2-mode-extend-//-comment 1))
+          (unless (eq beg end)
+            (overlay-put (js2-mode-flag-region beg end 'hide)
+                         'comment t))
+          (goto-char end)
+          (forward-char 1))))))
+
+(defun js2-mode-toggle-//-comment ()
+  "Fold or un-fold any multi-line //-comment at point.
+Caller should have determined that this line starts with a //-comment."
+  (let* ((beg (point-at-eol))
+         (end beg))
+    (save-excursion
+      (goto-char end)
+      (if (js2-mode-invisible-overlay-bounds)
+          (js2-mode-show-element)
+        ;; else hide the comment
+        (setq beg (js2-mode-extend-//-comment -1)
+              end (js2-mode-extend-//-comment 1))
+        (unless (eq beg end)
+          (overlay-put (js2-mode-flag-region beg end 'hide)
+                       'comment t))))))
+
+(defun js2-mode-show-comments ()
+  "Un-hide any hidden comments, leaving other hidden elements alone."
+  (interactive)
+  (setq js2-mode-comments-hidden nil)
+  (save-excursion
+    (goto-char (point-min))
+    (while (/= (goto-char (next-overlay-change (point)))
+               (point-max))
+      (dolist (o (overlays-at (point)))
+        (when (overlay-get o 'comment)
+          (js2-mode-flag-region (overlay-start o) (overlay-end o) nil))))))
+
+(defun js2-mode-display-warnings-and-errors ()
+  "Turn on display of warnings and errors."
+  (interactive)
+  (setq js2-mode-show-parse-errors t
+        js2-mode-show-strict-warnings t)
+  (js2-reparse 'force))
+
+(defun js2-mode-hide-warnings-and-errors ()
+  "Turn off display of warnings and errors."
+  (interactive)
+  (setq js2-mode-show-parse-errors nil
+        js2-mode-show-strict-warnings nil)
+  (js2-reparse 'force))
+
+(defun js2-mode-toggle-warnings-and-errors ()
+  "Toggle the display of warnings and errors.
+Some users don't like having warnings/errors reported while they type."
+  (interactive)
+  (setq js2-mode-show-parse-errors (not js2-mode-show-parse-errors)
+        js2-mode-show-strict-warnings (not js2-mode-show-strict-warnings))
+  (if (interactive-p)
+      (message "warnings and errors %s"
+               (if js2-mode-show-parse-errors
+                   "enabled"
+                 "disabled")))
+  (js2-reparse 'force))
+
+(defun js2-mode-customize ()
+  (interactive)
+  (customize-group 'js2-mode))
+
+(defun js2-mode-forward-sexp (&optional arg)
+  "Move forward across one statement or balanced expression.
+With ARG, do it that many times.  Negative arg -N means
+move backward across N balanced expressions."
+  (interactive "p")
+  (setq arg (or arg 1))
+  (if js2-mode-buffer-dirty-p
+      (js2-mode-wait-for-parse #'js2-mode-forward-sexp))
+  (let (node end (start (point)))
+    (cond
+     ;; backward-sexp
+     ;; could probably make this "better" for some cases:
+     ;;  - if in statement block (e.g. function body), go to parent
+     ;;  - infix exprs like (foo in bar) - maybe go to beginning
+     ;;    of infix expr if in the right-side expression?
+     ((and arg (minusp arg))
+      (dotimes (i (- arg))
+        (js2-backward-sws)
+        (forward-char -1)  ; enter the node we backed up to
+        (setq node (js2-node-at-point (point) t))
+        (goto-char (if node
+                       (js2-node-abs-pos node)
+                     (point-min)))))
+    (t
+     ;; forward-sexp
+     (js2-forward-sws)
+     (dotimes (i arg)
+       (js2-forward-sws)
+       (setq node (js2-node-at-point (point) t)
+             end (if node (+ (js2-node-abs-pos node)
+                             (js2-node-len node))))
+       (goto-char (or end (point-max))))))))
+
+(defun js2-next-error (&optional arg reset)
+  "Move to next parse error.
+Typically invoked via \\[next-error].
+ARG is the number of errors, forward or backward, to move.
+RESET means start over from the beginning."
+  (interactive "p")
+  (if (or (null js2-mode-ast)
+          (and (null (js2-ast-root-errors js2-mode-ast))
+               (null (js2-ast-root-warnings js2-mode-ast))))
+      (message "No errors")
+    (when reset
+      (goto-char (point-min)))
+    (let* ((errs (copy-sequence
+                  (append (js2-ast-root-errors js2-mode-ast)
+                          (js2-ast-root-warnings js2-mode-ast))))
+           (continue t)
+           (start (point))
+           (count (or arg 1))
+           (backward (minusp count))
+           (sorter (if backward '> '<))
+           (stopper (if backward '< '>))
+           (count (abs count))
+           all-errs
+           err)
+      ;; sort by start position
+      (setq errs (sort errs (lambda (e1 e2)
+                              (funcall sorter (second e1) (second e2))))
+            all-errs errs)
+      ;; find nth error with pos > start
+      (while (and errs continue)
+        (when (funcall stopper (cadar errs) start)
+          (setq err (car errs))
+          (if (zerop (decf count))
+              (setq continue nil)))
+        (setq errs (cdr errs)))
+      (if err
+          (goto-char (second err))
+        ;; wrap around to first error
+        (goto-char (second (car all-errs)))
+        ;; if we were already on it, echo msg again
+        (if (= (point) start)
+            (js2-echo-error (point) (point)))))))
+
+(defun js2-down-mouse-3 ()
+  "Make right-click move the point to the click location.
+This makes right-click context menu operations a bit more intuitive.
+The point will not move if the region is active, however, to avoid
+destroying the region selection."
+  (interactive)
+  (when (and js2-move-point-on-right-click
+             (not mark-active))
+    (let ((e last-input-event))
+      (ignore-errors
+        (goto-char (cadadr e))))))
+
+(defun js2-mode-create-imenu-index ()
+  "Return an alist for `imenu--index-alist'."
+  ;; This is built up in `js2-parse-record-imenu' during parsing.
+  (when js2-mode-ast
+    ;; if we have an ast but no recorder, they're requesting a rescan
+    (unless js2-imenu-recorder
+      (js2-reparse 'force))
+    (prog1
+        (js2-build-imenu-index)
+      (setq js2-imenu-recorder nil
+            js2-imenu-function-map nil))))
+
+(defun js2-mode-find-tag ()
+  "Replacement for `find-tag-default'.
+`find-tag-default' returns a ridiculous answer inside comments."
+  (let (beg end)
+    (js2-with-underscore-as-word-syntax
+      (save-excursion
+        (if (and (not (looking-at "[A-Za-z0-9_$]"))
+                 (looking-back "[A-Za-z0-9_$]"))
+            (setq beg (progn (forward-word -1) (point))
+                  end (progn (forward-word 1) (point)))
+          (setq beg (progn (forward-word 1) (point))
+                end (progn (forward-word -1) (point))))
+        (replace-regexp-in-string
+         "[\"']" ""
+         (buffer-substring-no-properties beg end))))))
+
+(defun js2-mode-forward-sibling ()
+  "Move to the end of the sibling following point in parent.
+Returns non-nil if successful, or nil if there was no following sibling."
+  (let* ((node (js2-node-at-point))
+         (parent (js2-mode-find-enclosing-fn node))
+         sib)
+    (when (setq sib (js2-node-find-child-after (point) parent))
+      (goto-char (+ (js2-node-abs-pos sib)
+                    (js2-node-len sib))))))
+
+(defun js2-mode-backward-sibling ()
+  "Move to the beginning of the sibling node preceding point in parent.
+Parent is defined as the enclosing script or function."
+  (let* ((node (js2-node-at-point))
+         (parent (js2-mode-find-enclosing-fn node))
+         sib)
+    (when (setq sib (js2-node-find-child-before (point) parent))
+      (goto-char (js2-node-abs-pos sib)))))
+
+(defun js2-beginning-of-defun ()
+  "Go to line on which current function starts, and return non-nil.
+If we're not in a function, go to beginning of previous script-level element."
+  (interactive)
+  (let ((parent (js2-node-parent-script-or-fn (js2-node-at-point)))
+        pos sib)
+    (cond
+     ((and (js2-function-node-p parent)
+           (not (eq (point) (setq pos (js2-node-abs-pos parent)))))
+      (goto-char pos))
+     (t
+      (js2-mode-backward-sibling)))))
+
+(defun js2-end-of-defun ()
+  "Go to the char after the last position of the current function.
+If we're not in a function, skips over the next script-level element."
+  (interactive)
+  (let ((parent (js2-node-parent-script-or-fn (js2-node-at-point))))
+    (if (not (js2-function-node-p parent))
+        ;; punt:  skip over next script-level element beyond point
+        (js2-mode-forward-sibling)
+      (goto-char (+ 1 (+ (js2-node-abs-pos parent)
+                         (js2-node-len parent)))))))
+
+(defun js2-mark-defun (&optional allow-extend)
+  "Put mark at end of this function, point at beginning.
+The function marked is the one that contains point.
+
+Interactively, if this command is repeated,
+or (in Transient Mark mode) if the mark is active,
+it marks the next defun after the ones already marked."
+  (interactive "p")
+  (let (extended)
+    (when (and allow-extend
+               (or (and (eq last-command this-command) (mark t))
+                   (and transient-mark-mode mark-active)))
+      (let ((sib (save-excursion
+                   (goto-char (mark))
+                   (if (js2-mode-forward-sibling)
+                       (point))))
+            node)
+        (if sib
+            (progn
+              (set-mark sib)
+              (setq extended t))
+          ;; no more siblings - try extending to enclosing node
+          (goto-char (mark t)))))
+   (when (not extended)
+     (let ((node (js2-node-at-point (point) t)) ; skip comments
+           ast fn stmt parent beg end)
+       (when (js2-ast-root-p node)
+         (setq ast node
+               node (or (js2-node-find-child-after (point) node)
+                        (js2-node-find-child-before (point) node))))
+       ;; only mark whole buffer if we can't find any children
+       (if (null node)
+           (setq node ast))
+       (if (js2-function-node-p node)
+           (setq parent node)
+         (setq fn (js2-mode-find-enclosing-fn node)
+               stmt (if (or (null fn)
+                            (js2-ast-root-p fn))
+                        (js2-mode-find-first-stmt node))
+               parent (or stmt fn)))
+       (setq beg (js2-node-abs-pos parent)
+             end (+ beg (js2-node-len parent)))
+       (push-mark beg)
+       (goto-char end)
+       (exchange-point-and-mark)))))
+
+(defun js2-narrow-to-defun ()
+  "Narrow to the function enclosing point."
+  (interactive)
+  (let* ((node (js2-node-at-point (point) t))  ; skip comments
+         (fn (if (js2-script-node-p node)
+                 node
+               (js2-mode-find-enclosing-fn node)))
+         (beg (js2-node-abs-pos fn)))
+    (unless (js2-ast-root-p fn)
+      (narrow-to-region beg (+ beg (js2-node-len fn))))))
+
+(defalias 'js2r 'js2-mode-reset)
+
+(provide 'js2-mode)
+
+;;; js2-mode.el ends here
+
+
+;;; js2.el ends here
diff --git a/emacs.d/js2-mode.elc b/emacs.d/js2-mode.elc
new file mode 100644
index 0000000000000000000000000000000000000000..c47e57e0e0a96ae017c83462014fdf2c529e8ea7
GIT binary patch
literal 1484001
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%0D61Wsj!#3sMmdt=BD%b}h@qcf?GQk0rum!L
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
z%0D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%0A3hz(D%jw@{eT1ftZ3dmyK9b850UxI~FY{
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

literal 0
HcmV?d00001