-;;; js2-mode.el --- an improved JavaScript editing mode
+;;; js2-mode.el --- Improved JavaScript editing mode
-;; Copyright (C) 2009 Free Software Foundation, Inc.
+;; Copyright (C) 2009, 2012 Free Software Foundation, Inc.
;; Author: Steve Yegge <steve.yegge@gmail.com>
;; Contributors: mooz <stillpedant@gmail.com>
;; - typing helpers such as automatic insertion of matching braces/parens
;; - many customization options
+;; Installation:
+;;
+;; To install it as your major mode for JavaScript editing:
+
+;; (add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
+
+;; Alternately, to install it as a minor mode just for JavaScript linting,
+;; you must add it to the appropriate major-mode hook. Normally this would be:
+
+;; (add-hook 'js-mode-hook 'js2-minor-mode)
+
;; To customize how it works:
;; M-x customize-group RET js2-mode RET
(require 'cc-langs) ; it's here in Emacs 21...
(require 'cc-engine)) ; for `c-paragraph-start' et. al.
+(defvar electric-layout-rules)
+
;;; Externs (variables presumed to be defined by the host system)
(defvar js2-ecma-262-externs
(defvar js2-rhino-externs
(mapcar 'symbol-name
'(Packages importClass importPackage com org java
- ;; Global object (shell) externs
+ ;; Global object (shell) externs.
defineClass deserialize doctest gc help load
loadClass print quit readFile readUrl runCommand seal
serialize spawn sync toint32 version))
;;; Variables
-(defvar js2-emacs22 (>= emacs-major-version 22))
+(defun js2-mark-safe-local (name pred)
+ "Make the variable NAME buffer-local and mark it as safe file-local
+variable with predicate PRED."
+ (make-variable-buffer-local name)
+ (put name 'safe-local-variable pred))
(defcustom js2-highlight-level 2
"Amount of syntax highlighting to perform.
-0 or a negative value means do no highlighting.
+0 or a negative value 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."
Similar to `c-basic-offset'."
:group 'js2-mode
:type 'integer)
-(make-variable-buffer-local 'js2-basic-offset)
+(js2-mark-safe-local 'js2-basic-offset 'integerp)
-;; TODO(stevey): move this code into a separate minor mode.
-(defcustom js2-mirror-mode nil
- "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.
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."
+See the function `js2-bounce-indent' for details. When it is non-nil,
+js2-mode also binds `js2-bounce-indent-backwards' to Shift-Tab."
:type 'boolean
:group 'js2-mode)
-(defcustom js2-consistent-level-indent-inner-bracket-p t
- "Non-nil to make indentation level inner bracket consistent,
-regardless of the beginning bracket position."
- :group 'js2-mode
- :type 'boolean)
+(defcustom js2-pretty-multiline-declarations t
+ "Non-nil to line up multiline declarations vertically:
+
+ var a = 10,
+ b = 20,
+ c = 30;
+
+If the value is not `all', and the first assigned value in
+declaration is a function/array/object literal spanning several
+lines, it won't be indented additionally:
-(defcustom js2-use-ast-for-indentation-p nil
- "Non-nil to use AST for indentation and make it more robust."
+ var o = { var bar = 2,
+ foo: 3 vs. o = {
+ }, foo: 3
+ bar = 2; };"
:group 'js2-mode
- :type 'boolean)
+ :type 'symbol)
+(js2-mark-safe-local 'js2-pretty-multiline-declarations 'symbolp)
(defcustom js2-indent-on-enter-key nil
"Non-nil to have Enter/Return key indent the line.
: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 'boolean
:group 'js2-mode)
+(defcustom js2-concat-multiline-strings t
+ "Non-nil to automatically turn a newline in mid-string into a
+string concatenation. When `eol', the '+' will be inserted at the
+end of the line, otherwise, at the beginning of the next line."
+ :type '(choice (const t) (const eol) (const nil))
+ :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-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
:type 'boolean
:group 'js2-mode)
-(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.
+move, so cut/copy/paste can work properly.
Note that IntelliJ moves the point, and Eclipse leaves it alone,
so this behavior is customizable."
:type 'boolean
:group 'js2-mode)
-(defvar js2-mode-version 20101228
+(defvar js2-mode-version 20120416
"Release number for `js2-mode'.")
;; scanner variables
(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.
+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',
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
+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.
called after the new parse tree is built. This can take some time
in large files.")
-(defface js2-warning-face
+(defface js2-warning
`((((class color) (background light))
(:underline "orange"))
(((class color) (background dark))
"Face for JavaScript warnings."
:group 'js2-mode)
-(defface js2-error-face
+(defface js2-error
`((((class color) (background light))
(:foreground "red"))
(((class color) (background dark))
"Face for JavaScript errors."
:group 'js2-mode)
-(defface js2-jsdoc-tag-face
+(defface js2-jsdoc-tag
'((t :foreground "SlateGray"))
"Face used to highlight @whatever tags in jsdoc comments."
:group 'js2-mode)
-(defface js2-jsdoc-type-face
+(defface js2-jsdoc-type
'((t :foreground "SteelBlue"))
"Face used to highlight {FooBar} types in jsdoc comments."
:group 'js2-mode)
-(defface js2-jsdoc-value-face
+(defface js2-jsdoc-value
'((t :foreground "PeachPuff3"))
"Face used to highlight tag values in jsdoc comments."
:group 'js2-mode)
-(defface js2-function-param-face
+(defface js2-function-param
'((t :foreground "SeaGreen"))
"Face used to highlight function parameters in javascript."
:group 'js2-mode)
-(defface js2-instance-member-face
+(defface js2-instance-member
'((t :foreground "DarkOrchid"))
"Face used to highlight instance variables in javascript.
Not currently used."
:group 'js2-mode)
-(defface js2-private-member-face
+(defface js2-private-member
'((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
+(defface js2-private-function-call
'((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"))))
+(defface js2-jsdoc-html-tag-name
+ '((((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")))
"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"))))
+(defface js2-jsdoc-html-tag-delimiter
+ '((((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")))
"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.
:type 'list
:group 'js2-mode)
-(defface js2-external-variable-face
- '((t :foreground "orange"))
- "Face used to highlight undeclared variable identifiers.
+(defcustom js2-highlight-external-variables t
+ "Non-nil to highlight undeclared variable identifiers.
An undeclared variable is any variable not declared with var or let
in the current scope or any lexically enclosing scope. If you use
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 highlight undeclared variable identifiers."
:type 'boolean
:group 'js2-mode)
(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-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))
+ (when js2-bounce-indent-p
+ (define-key map (kbd "<backtab>") #'js2-indent-bounce-backwards))
(define-key map [menu-bar javascript]
(cons "JavaScript" (make-sparse-keymap "JavaScript")))
'("--"))
(define-key map [menu-bar javascript next-error]
- '(menu-item "Next warning or error" js2-next-error
+ '(menu-item "Next warning or error" next-error
:enabled (and js2-mode-ast
(or (js2-ast-root-errors js2-mode-ast)
(js2-ast-root-warnings js2-mode-ast)))
(js2-deflocal js2-mode-deferred-properties nil "Private variable")
(js2-deflocal js2-imenu-recorder nil "Private variable")
(js2-deflocal js2-imenu-function-map nil "Private variable")
-(js2-deflocal js2-imenu-fn-type-map nil "Private variable")
(defvar js2-paragraph-start
"\\(@[a-zA-Z]+\\>\\|$\\)")
(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-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.")
+ "Syntax table used in `js2-mode' buffers.")
(defvar js2-mode-abbrev-table nil
"Abbrev table in use in `js2-mode' buffers.")
(defvar js2-message-table
(make-hash-table :test 'equal :size 250)
- "Contains localized messages for js2-mode.")
+ "Contains localized messages for `js2-mode'.")
;; TODO(stevey): construct this table at compile-time.
(defmacro js2-msg (key &rest strings)
(js2-msg "msg.assn.create.strict"
"Assignment to undeclared variable %s")
+(js2-msg "msg.undeclared.variable" ; added by js2-mode
+ "Undeclared variable or function '%s'")
+
(js2-msg "msg.ref.undefined.prop"
"Reference to undefined property '%s'")
result))
(defmacro js2-time (form)
- "Evaluate FORM, discard result, and return elapsed time in sec"
+ "Evaluate FORM, discard result, and return elapsed time in sec."
(declare (debug t))
(let ((beg (make-symbol "--js2-time-beg--"))
(delta (make-symbol "--js2-time-end--")))
(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."
+(defun 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)))
;; 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)
+(defun 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)
+(defun 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)
(current-column))
js2-ts-hit-eof))))
-(defsubst js2-report-warning (msg &optional msg-arg pos len)
+(defun 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 len (- js2-token-end js2-token-beg)))
js2-parsed-warnings)))
-(defsubst js2-add-strict-warning (msg-id &optional msg-arg beg end)
+(defun 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)))))
(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."
- (declare (indent 0) (debug t))
- (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))))))
-
(defmacro js2-with-underscore-as-word-syntax (&rest body)
"Evaluate BODY with the _ character set to be word-syntax."
(declare (indent 0) (debug t))
;;; AST struct and function definitions
;; 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")
+(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)
+(defun js2-make-pad (indent)
(if (zerop indent)
""
(make-string (* indent js2-basic-offset) ? )))
-(defsubst js2-visit-ast (node callback)
+(defun 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
The node traversal is approximately lexical-order, although there
are currently no guarantees around this."
- (if node
+ (when node
(let ((vfunc (get (aref node 0) 'js2-visitor)))
;; visit the node
(when (funcall callback node nil)
(setf (js2-node-props node)
(cons (list prop value) (js2-node-props node))))
-(defsubst js2-fixup-starts (n nodes)
+(defun 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)
(setf (js2-node-pos node) (- (js2-node-pos node)
(js2-node-pos n))))))
-(defsubst js2-node-add-children (parent &rest nodes)
+(defun 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."
(setf (js2-node-parent node) parent))))
;; Non-recursive since it's called a frightening number of times.
-(defsubst js2-node-abs-pos (n)
+(defun 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))))
"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
+;; 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.
props
kids)))
"A block of statements."
- kids) ; a lisp list of the child statement nodes
+ 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)
+(defun 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)))
(setq scope (js2-scope-parent-scope scope))))
result))
-(defsubst js2-scope-get-symbol (scope name)
+(defun 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)
(intern name))
(js2-scope-symbol-table scope)))))
-(defsubst js2-scope-put-symbol (scope name symbol)
+(defun 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'."
+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)))
len
var-decls
fun-decls)))
- functions ; lisp list of nested functions
- regexps ; lisp list of (string . flags)
+ 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
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
+ 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)
expr)
(defsubst js2-expr-stmt-node-set-has-result (node)
- "Change the node type to `js2-EXPR_RESULT'. Used for code generation."
+ "Change 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)
(:constructor nil)
(:constructor make-js2-while-node (&key (type js2-WHILE)
(pos js2-token-beg)
- len
- body
- condition
- lp
+ len body
+ condition lp
rp)))
"AST node for while-loop."
condition) ; while-condition
(:constructor nil)
(:constructor make-js2-for-node (&key (type js2-FOR)
(pos js2-ts-cursor)
- len
- body
- init
+ len body init
condition
- update
- lp
- rp)))
+ update lp rp)))
"AST node for a C-style for-loop."
init ; initialization expression
condition ; loop condition
(:constructor nil)
(:constructor make-js2-for-in-node (&key (type js2-FOR)
(pos js2-ts-cursor)
- len
- body
+ len body
iterator
object
in-pos
each-pos
- foreach-p
- lp
+ foreach-p lp
rp)))
"AST node for a for..in loop."
iterator ; [var] foo in ...
(:constructor nil)
(:constructor make-js2-if-node (&key (type js2-IF)
(pos js2-ts-cursor)
- len
- condition
+ len condition
then-part
else-pos
- else-part
- lp
+ else-part lp
rp)))
"AST node for an if-statement."
condition ; expression
finally-block)))
"AST node for a try-statement."
try-block
- catch-clauses ; a lisp list of `js2-catch-node'
+ 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)
param
guard-kwd
guard-expr
- block
- lp
+ block lp
rp)))
"AST node for a catch clause."
param ; destructuring form or simple name node
(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)
+ (js2-print-ast (js2-catch-node-param n) 0)
(when guard-kwd
(insert " if ")
(js2-print-ast guard-expr 0))
(:constructor nil)
(:constructor make-js2-finally-node (&key (type js2-FINALLY)
(pos js2-ts-cursor)
- len
- body)))
+ len body)))
"AST node for a finally clause."
body) ; a `js2-node', often but not always a block node
(pos js2-ts-cursor)
len
discriminant
- cases
- lp
+ cases lp
rp)))
"AST node for a switch statement."
discriminant ; a `js2-node' (switch expression)
- cases ; a lisp list of `js2-case-node'
+ 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
(:constructor nil)
(:constructor make-js2-case-node (&key (type js2-CASE)
(pos js2-ts-cursor)
- len
- kids
- expr)))
+ len kids expr)))
"AST node for a case clause of a switch statement."
expr) ; the case expression (nil for default)
(:constructor nil)
(:constructor make-js2-throw-node (&key (type js2-THROW)
(pos js2-ts-cursor)
- len
- expr)))
+ len expr)))
"AST node for a throw statement."
expr) ; the expression to throw
(:constructor nil)
(:constructor make-js2-with-node (&key (type js2-WITH)
(pos js2-ts-cursor)
- len
- object
- body
- lp
- rp)))
+ len object
+ body lp rp)))
"AST node for a with-statement."
object
body
(:constructor nil)
(:constructor make-js2-label-node (&key (type js2-LABEL)
(pos js2-ts-cursor)
- len
- name)))
+ len name)))
"AST node for a statement label or case label."
name ; a string
loop) ; for validating and code-generating continue-to-label
;; 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)))
+ 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'
+ 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)
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.
(js2-visit-ast (js2-jump-node-label n) v))
(defstruct (js2-break-node
(:constructor nil)
(:constructor make-js2-break-node (&key (type js2-BREAK)
(pos js2-ts-cursor)
- len
- label
- target)))
+ 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
(:constructor nil)
(:constructor make-js2-continue-node (&key (type js2-CONTINUE)
(pos js2-ts-cursor)
- len
- label
- target)))
+ 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:
(ftype 'FUNCTION)
(form 'FUNCTION_STATEMENT)
(name "")
- params
- body
- lp
- rp)))
+ 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
+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
+ 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
(unless expr
(insert "\n"))))
-(defsubst js2-function-name (node)
+(defun 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))))
(:constructor nil)
(:constructor make-js2-var-decl-node (&key (type js2-VAR)
(pos js2-token-beg)
- len
- kids
+ 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.
+ 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)
(insert pad)
(insert (cond
((= tt js2-VAR) "var ")
- ((= tt js2-LET) "") ; handled by parent let-{expr/stmt}
+ ((= tt js2-LET) "let ")
((= tt js2-CONST) "const ")
(t
(error "malformed var-decl node"))))
(:constructor nil)
(:constructor make-js2-var-init-node (&key (type js2-VAR)
(pos js2-ts-cursor)
- len
- target
+ len target
initializer)))
"AST node for a variable declaration.
The type field will be js2-CONST for a const decl."
test-expr
true-expr
false-expr
- q-pos
- c-pos)))
+ q-pos c-pos)))
"AST node for the ternary operator"
test-expr
true-expr
(:constructor nil)
(:constructor make-js2-infix-node (&key type
(pos js2-ts-cursor)
- len
- op-pos
- left
- right)))
+ 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."
(:constructor nil)
(:constructor make-js2-assign-node (&key type
(pos js2-ts-cursor)
- len
- op-pos
- left
- right)))
+ len op-pos
+ left right)))
"Represents any assignment.
The type field holds the actual assignment operator.")
(:constructor nil)
(:constructor make-js2-unary-node (&key type ; required
(pos js2-ts-cursor)
- len
- operand)))
+ 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
(:constructor nil)
(:constructor make-js2-let-node (&key (type js2-LETEXPR)
(pos js2-token-beg)
- len
- vars
- body
- lp
- rp)))
+ 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'
(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."
+ "Return t if NODE is a `js2-literal-node' of type js2-THIS."
(eq (js2-node-type node) js2-THIS))
(defstruct (js2-new-node
(:constructor nil)
(:constructor make-js2-new-node (&key (type js2-NEW)
(pos js2-token-beg)
- len
- target
- args
- initializer
- lp
- rp)))
+ 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
+ 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'
(pos js2-token-beg)
(len (- js2-ts-cursor
js2-token-beg))
- value
- flags)))
+ value flags)))
"AST node for a regular expression literal."
value ; the regexp string, without // delimiters
flags) ; a string of flags, e.g. `mi'.
(:constructor nil)
(:constructor make-js2-array-node (&key (type js2-ARRAYLIT)
(pos js2-ts-cursor)
- len
- elems)))
+ len elems)))
"AST node for an array literal."
elems) ; list of expressions. [foo,,bar] yields a nil middle element.
(defun js2-visit-array-node (n v)
(dolist (e (js2-array-node-elems n))
- (js2-visit-ast e v)))
+ (js2-visit-ast e v))) ; Can be nil; e.g. [a, ,b].
(defun js2-print-array-node (n i)
(insert (js2-make-pad i) "[")
len
elems)))
"AST node for an object literal expression.
-`elems' is a list of either `js2-object-prop-node' or `js2-name-node',
-the latter represents abbreviation in destructuring expressions."
+`elems' is a list of either `js2-object-prop-node' or `js2-name-node'.
+The latter represents abbreviation in destructuring expressions."
elems)
(put 'cl-struct-js2-object-node 'js2-visitor 'js2-visit-object-node)
(:constructor nil)
(:constructor make-js2-object-prop-node (&key (type js2-COLON)
(pos js2-ts-cursor)
- len
- left
- right
- op-pos)))
+ 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.")
(:constructor nil)
(:constructor make-js2-getter-setter-node (&key type ; GET or SET
(pos js2-ts-cursor)
- len
- left
- right)))
+ 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
(:constructor nil)
(:constructor make-js2-prop-get-node (&key (type js2-GETPROP)
(pos js2-ts-cursor)
- len
- left
- right)))
+ 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)
(:constructor nil)
(:constructor make-js2-elem-get-node (&key (type js2-GETELEM)
(pos js2-ts-cursor)
- len
- target
- element
- lb
- rb)))
+ 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
(:constructor nil)
(:constructor make-js2-call-node (&key (type js2-CALL)
(pos js2-ts-cursor)
- len
- target
- args
- lp
- rp)))
+ 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
+ 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
(:constructor nil)
(:constructor make-js2-yield-node (&key (type js2-YIELD)
(pos js2-ts-cursor)
- len
- value)))
+ len value)))
"AST node for yield statement or expression."
value) ; optional: value to be yielded
(:constructor nil)
(:constructor make-js2-paren-node (&key (type js2-LP)
(pos js2-ts-cursor)
- len
- expr)))
+ 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."
(:constructor nil)
(:constructor make-js2-array-comp-node (&key (type js2-ARRAYCOMP)
(pos js2-ts-cursor)
- len
- result
- loops
- filter
- if-pos
- lp
- rp)))
+ 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'
+ 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
(js2-print-ast l 0))
(when filter
(insert " if (")
- (js2-print-ast filter 0))
- (insert ")]")))
+ (js2-print-ast filter 0)
+ (insert ")"))
+ (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
+ len iterator
+ object in-pos
foreach-p
each-pos
- lp
- rp)))
+ 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)
(js2-visit-ast (js2-array-comp-loop-node-object n) v))
(defun js2-print-array-comp-loop (n i)
- (insert "for (")
+ (insert "for ")
+ (when (js2-array-comp-loop-node-foreach-p n) (insert "each "))
+ (insert "(")
(js2-print-ast (js2-array-comp-loop-node-iterator n) 0)
(insert " in ")
(js2-print-ast (js2-array-comp-loop-node-object n) 0)
(:constructor nil)
(:constructor make-js2-xml-node (&key (type js2-XML)
(pos js2-token-beg)
- len
- kids)))
+ 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.")
(:constructor nil)
(:constructor make-js2-xml-js-expr-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- expr)))
+ 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
(:constructor nil)
(:constructor make-js2-xml-dot-query-node (&key (type js2-DOTQUERY)
(pos js2-ts-cursor)
- op-pos
- len
- left
- right
- rp)))
+ 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
(:constructor nil)
(:constructor make-js2-xml-prop-ref-node (&key (type js2-REF_NAME)
(pos js2-token-beg)
- len
- propname
- namespace
- at-pos
+ 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.
(: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
+ len expr lb rb
+ namespace at-pos
colon-pos)))
"AST node for an E4X XML [expr] member-ref expression.
Syntax:
(:constructor nil)
(:constructor make-js2-xml-start-tag-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- name
- attrs
- kids
+ 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."
+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'
+ 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)
(:constructor nil)
(:constructor make-js2-xml-end-tag-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- name)))
+ len name)))
"AST node for an XML end-tag. Not currently used."
name) ; a `js2-xml-name-node'
(:constructor nil)
(:constructor make-js2-xml-name-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- namespace
- kids)))
+ 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.
(:constructor nil)
(:constructor make-js2-xml-pi-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- name
- attrs)))
+ 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'
(:constructor nil)
(:constructor make-js2-xml-cdata-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- content)))
+ len content)))
"AST node for a CDATA escape section. Not currently used."
content) ; a `js2-string-node' with node-property 'quote-type 'cdata
(:constructor nil)
(:constructor make-js2-attr-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- name
- value
- eq-pos
- quote-type)))
+ 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'
(:constructor nil)
(:constructor make-js2-text-node (&key (type js2-XML)
(pos js2-ts-cursor)
- len
- content)))
+ 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'
+ 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)
(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.
+(defun 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.
(t
nil)))
-(defsubst js2-node-set-child-list (node kids)
+(defun js2-node-set-child-list (node kids)
"Set the child list for NODE to KIDS."
(cond
((js2-function-node-p node)
(memq (aref node 0) js2-paren-expr-nodes))
;; Fake polymorphism... yech.
-(defsubst js2-node-lp (node)
+(defun 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."
(error "Unsupported node type: %s" (js2-node-short-name node)))))
;; Fake polymorphism... blech.
-(defsubst js2-node-rp (node)
+(defun 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."
(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."
+ "Return 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."
+ "Return the last element of `js2-node-last-child' for NODE."
(car (last (js2-node-child-list node))))
(defun js2-node-prev-sibling (node)
(beg (if (js2-function-node-p parent)
(js2-node-abs-pos (js2-function-node-body parent))
(js2-node-abs-pos parent)))
- kid
- result
- fn
+ kid result fn
(continue t))
- (setq fn (if after '> '<))
+ (setq fn (if after '>= '<))
(while (and kids continue)
(setq kid (car kids))
(if (funcall fn (+ beg (js2-node-pos kid)) pos)
(js2-ast-root-p root)
(js2-ast-root-buffer root))))
-(defsubst js2-block-node-push (n kid)
+(defun 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."
(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))))))
+ (with-current-buffer (or (js2-node-buffer node)
+ (error "No buffer available for node %s" node))
+ (let ((pos (js2-node-abs-pos node)))
+ (buffer-substring-no-properties pos (+ pos (js2-node-len node))))))
;; Container for storing the node we're looking for in a traversal.
(js2-deflocal js2-discovered-node nil)
Function returns nil if POS was not in any comment node."
(let ((ast js2-mode-ast)
(x (or pos (point)))
- beg
- end)
+ beg end)
(unless ast
(error "No JavaScript AST available"))
(catch 'done
(setq node (js2-node-parent node)))
node))
-(defsubst js2-nested-function-p (node)
+(defun js2-nested-function-p (node)
"Return t if NODE is a nested function, or is inside a nested function."
(unless (js2-ast-root-p node)
(js2-function-node-p (if (js2-function-node-p node)
(js2-node-parent-script-or-fn
(js2-node-parent-script-or-fn node))))))
-(defsubst js2-function-param-node-p (node)
- "Return non-nil if NODE is a param node of a `js2-function-node'."
- (let ((parent (js2-node-parent node)))
- (and parent
- (js2-function-node-p parent)
- (memq node (js2-function-node-params parent)))))
-
-(defsubst js2-mode-shift-kids (kids start offset)
+(defun 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)
+(defun 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)
+(defun js2-node-is-descendant (node ancestor)
"Return t if NODE is a descendant of ANCESTOR."
(while (and node
(not (eq node ancestor)))
for arg in args
for count from 1
do
- (js2-print-ast arg 0)
+ (when arg (js2-print-ast arg 0))
(if (< count len)
(insert (or delimiter ", ")))))
(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.
+ ;; 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)))
+ (let ((expr (js2-expr-stmt-node-expr node)))
+ (or (js2-node-has-side-effects expr)
+ (when (js2-string-node-p expr)
+ (string= "use strict" (js2-string-node-value expr))))))
((= tt js2-COMMA)
(js2-node-has-side-effects (js2-infix-node-right node)))
((or (= tt js2-AND)
Functions aren't included in the check."
(memq (js2-node-type node) js2-stmt-node-types))
-(defsubst js2-mode-find-first-stmt (node)
+(defun 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-END_YIELDS)))))
(defun js2-end-check-if (node)
- "Returns in the then and else blocks must be consistent with each other.
+ "Ensure that return usage in then/else blocks is consistent.
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))
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.
+ "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 determine
+statically that there is a break out of the loop.
for(... ; ... ; ...) {}
for(... in ... ) {}
(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)
+(defun 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)
(unless no-throw
(throw 'return js2-ERROR)))
-(defsubst js2-get-string-from-buffer ()
+(defun 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
;; 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 ()
+(defun 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.
;; TODO: skip over format characters
c)))
-(defsubst js2-read-unicode-escape ()
+(defun 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.
(if (string-match "[a-zA-Z0-9]\\{4\\}" s)
(read (concat "?\\u" s))))))
-(defsubst js2-match-char (test)
+(defun 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)))
(js2-unget-char)
nil)))
-(defsubst js2-peek-char ()
+(defun js2-peek-char ()
(prog1
(js2-get-char)
(js2-unget-char)))
-(defsubst js2-java-identifier-start-p (c)
+(defun js2-java-identifier-start-p (c)
(or
(memq c '(?$ ?_))
(js2-char-uppercase-p c)
(js2-char-lowercase-p c)))
-(defsubst js2-java-identifier-part-p (c)
- "Implementation of java.lang.Character.isJavaIdentifierPart()"
+(defun js2-java-identifier-part-p (c)
+ "Implementation of java.lang.Character.isJavaIdentifierPart()."
;; TODO: make me Unicode-friendly. See comments above.
(or
(memq c '(?$ ?_))
(js2-char-lowercase-p c)
(and (>= c ?0) (<= c ?9))))
-(defsubst js2-alpha-p (c)
+(defun 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)
+(defun js2-js-space-p (c)
(if (<= c 127)
(memq c '(#x20 #x9 #xB #xC #xD))
(or
(defconst js2-eol-chars (list js2-EOF_CHAR ?\n ?\r))
-(defsubst js2-skip-line ()
- "Skip to end of line"
+(defun js2-skip-line ()
+ "Skip to end of line."
(let (c)
(while (not (memq (setq c (js2-get-char)) js2-eol-chars)))
(js2-unget-char)
(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.
+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))
+ (with-current-buffer (or buf (current-buffer))
(setq js2-ts-dirty-line nil
js2-ts-regexp-flags nil
js2-ts-string ""
table)
"JavaScript reserved words by name, mapped to 'js2-RESERVED.")
-(defsubst js2-collect-string (buf)
+(defun js2-collect-string (buf)
"Convert BUF, a list of chars, to a string.
Reverses BUF before converting."
(cond
(setq js2-token-end js2-ts-cursor)
(throw 'return token))
-(defsubst js2-x-digit-to-int (c accumulator)
+(defun 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."
(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)
+ (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.
(defun js2-read-regexp (start-token)
"Called by parser when it gets / or /= in literal context."
- (let (c
- err
+ (let (c err
in-class ; inside a '[' .. ']' character-class
flags
(continue t))
(js2-unget-char)
(js2-get-next-xml-token))
-(defsubst js2-xml-discard-string ()
+(defun 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)
(throw 'return js2-ERROR)))
(t
(unless (js2-read-entity)
- (throw 'return js2-ERROR)))))
+ (throw 'return js2-ERROR))))
+ ;; Allow bare CDATA section, e.g.:
+ ;; let xml = <![CDATA[ foo bar baz ]]>;
+ (when (zerop js2-ts-xml-open-tags-count)
+ (throw 'return js2-XMLEND)))
(??
(setq c (js2-get-char)) ;; skip ?
(js2-add-to-string c)
;;; Highlighting
-(defsubst js2-set-face (beg end face &optional record)
+(defun 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)
end (max (point-min) end))
(if record
(push (list beg end face) js2-mode-fontifications)
- (put-text-property beg end 'face face))))
+ (put-text-property beg end 'font-lock-face face))))
-(defsubst js2-set-kid-face (pos kid len face)
+(defun 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.
(js2-set-face start (+ start length) 'font-lock-keyword-face))
(defsubst js2-clear-face (beg end)
- (remove-text-properties beg end '(face nil
+ (remove-text-properties beg end '(font-lock-face nil
help-echo nil
point-entered nil
c-in-sws nil)))
"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)
+(defun 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)))
(level1 (>= js2-highlight-level 1))
(level2 (>= js2-highlight-level 2))
(level3 (>= js2-highlight-level 3))
- pos
- face)
+ pos face)
(when level2
(if call-p
(cond
"\\(?:param\\|argument\\)"
"\\)"
"\\s-*\\({[^}]+}\\)?" ; optional type
- "\\s-*\\([a-zA-Z0-9_$]+\\)?" ; name
+ "\\s-*\\[?\\([a-zA-Z0-9_$\.]+\\)?\\]?" ; name
"\\>")
"Matches jsdoc tags with optional type and optional param name.")
"\\(</?\\)\\([a-zA-Z]+\\)\\s-*\\(/?>\\)"
"Matches a simple (no attributes) html start- or end-tag.")
-(defsubst js2-jsdoc-highlight-helper ()
+(defun js2-jsdoc-highlight-helper ()
(js2-set-face (match-beginning 1)
(match-end 1)
- 'js2-jsdoc-tag-face)
+ 'js2-jsdoc-tag)
(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-jsdoc-type)
(js2-set-face (match-beginning 2)
(match-end 2)
- 'js2-jsdoc-value-face)))
+ 'js2-jsdoc-value)))
(if (match-beginning 3)
(js2-set-face (match-beginning 3)
(match-end 3)
- 'js2-jsdoc-value-face)))
+ 'js2-jsdoc-value)))
(defun js2-highlight-jsdoc (ast)
"Highlight doc comment tags."
(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-jsdoc-html-tag-delimiter)
(js2-set-face (match-beginning 2)
(match-end 2)
- 'js2-jsdoc-html-tag-name-face)
+ 'js2-jsdoc-html-tag-name)
(js2-set-face (match-beginning 3)
(match-end 3)
- 'js2-jsdoc-html-tag-delimiter-face))))))))
+ 'js2-jsdoc-html-tag-delimiter))))))))
(defun js2-highlight-assign-targets (node left right)
"Highlight function properties and external variables."
(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))))
+ (js2-report-warning "msg.undeclared.variable" name pos (- end pos)))))
(setq js2-recorded-identifiers nil)))
;;; IMenu support
;; 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
+;; `foo.bar.baz', convert them to (list fn 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.
;; 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))
+;; '((fn a 5)
+;; (fn b 25)
+;; (fn foo 100)
+;; (fn foo bar 200)
+;; (fn foo bar baz 300)
+;; (fn foo bar zab 400))
+;; Where 'fn' is the respective function node.
;; After parsing these entries are merged into this alist-trie:
;; '((a . 1)
;; 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.
-(defsubst js2-prop-node-name (node)
+(defun 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."
((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.
+(defun js2-node-qname-component (node)
+ "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)
(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."
+(defun js2-record-imenu-entry (fn-node qname pos)
+ "Add an entry to `js2-imenu-recorder'.
+FN-NODE should be the current item's function node.
+
+Associate FN-NODE with its QNAME for later lookup.
+This is used in postprocessing the chain list. For each chain, we find
+the parent function, look up its qname, then prepend a copy of it to the chain."
+ (push (cons fn-node (append qname (list pos))) js2-imenu-recorder)
(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."
+VAR, if non-nil, is the expression that NODE is being assigned to.
+When passed arguments of wrong type, does nothing."
(when js2-parse-ide-mode
(let ((fun-p (js2-function-node-p node))
qname left fname-node pos)
((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))
+ (js2-record-imenu-entry node (list fname-node) (js2-node-pos node)))
;; 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))
+ (js2-record-imenu-entry node qname (js2-node-pos node)))
;; foo.bar.baz = object-literal
;; look for nested functions: {a: {b: function() {...} }}
((js2-object-node-p node)
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).
POS is the absolute position of the 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'."
- (let (left right)
+We do a depth-first traversal of NODE. For any functions we find,
+we append the property name to QNAME, then call `js2-record-imenu-entry'."
+ (let (left right prop-qname)
(dolist (e (js2-object-node-elems node)) ; e is a `js2-object-prop-node'
(let ((left (js2-infix-node-left e))
;; Element positions are relative to the parent position.
;; 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 pos))
- js2-imenu-recorder)
- (js2-record-function-qname right qname)))
+ (js2-record-imenu-entry right (append qname (list left)) pos)))
;; foo: {object-literal} -- add foo to qname, offset position, and recurse
((js2-object-node-p right)
(js2-record-object-literal right
(append qname (list (js2-infix-node-left e)))
(+ pos (js2-node-pos right)))))))))
-(defsubst js2-node-top-level-decl-p (node)
+(defun 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."
(js2-ast-root-p defining-scope))
(t t))))
-(defsubst js2-anonymous-wrapper-fn-p (node)
- "Returns t if NODE is an anonymous function that's invoked immediately.
+(defun js2-wrapper-function-p (node)
+ "Returns t if NODE is a function expression that's immediately invoked.
NODE must be `js2-function-node'."
(let ((parent (js2-node-parent node)))
- (and (js2-paren-node-p parent)
- ;; (function(){...})();
- (or (js2-call-node-p (setq parent (js2-node-parent parent)))
- ;; (function(){...}).call(this);
- (and (js2-prop-get-node-p parent)
- (member (js2-name-node-name (js2-prop-get-node-right parent))
- '("call" "apply"))
- (js2-call-node-p (js2-node-parent parent)))))))
-
-(defun js2-browse-postprocess-chains (chains)
+ (or
+ ;; function(){...}();
+ (js2-call-node-p parent)
+ (and (js2-paren-node-p parent)
+ ;; (function(){...})();
+ (or (js2-call-node-p (setq parent (js2-node-parent parent)))
+ ;; (function(){...}).call(this);
+ (and (js2-prop-get-node-p parent)
+ (member (js2-name-node-name (js2-prop-get-node-right parent))
+ '("call" "apply"))
+ (js2-call-node-p (js2-node-parent parent))))))))
+
+(defun js2-browse-postprocess-chains (entries)
"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 fn-type parent-chain p elem parent)
- (dolist (chain chains)
- ;; examine the head of each node to get its defining scope
- (setq head (car chain))
- ;; if top-level/external, keep as-is
- (if (js2-node-top-level-decl-p head)
- (push chain result)
- (cond
- ;; starts with this-reference
- ((js2-this-node-p head)
- (setq fn (js2-node-parent-script-or-fn head)
- chain (cdr chain))) ; discard this-node
- ;; nested named function
- ((js2-function-node-p (setq parent (js2-node-parent head)))
- (setq fn (js2-node-parent-script-or-fn parent)))
- ;; variable assigned a function expression
- (t (setq fn (js2-node-parent-script-or-fn head))))
- (when fn
- (if js2-imenu-fn-type-map
- (setq fn-type (gethash fn js2-imenu-fn-type-map))
- (setq js2-imenu-fn-type-map (make-hash-table :test 'eq)))
- (unless fn-type
- (setq fn-type
- (cond ((js2-nested-function-p fn) 'skip)
- ((setq parent-chain
- (gethash fn js2-imenu-function-map))
- 'named)
- ((js2-anonymous-wrapper-fn-p fn) 'anon)
- (t 'skip)))
- (puthash fn fn-type js2-imenu-fn-type-map))
- (case fn-type
- ('anon (push chain result)) ; anonymous top-level wrapper
- ('named ; top-level named function
- ;; prefix parent fn qname, which is
- ;; parent-chain sans last elem, to this chain.
- (push (append (butlast parent-chain) chain) result))))))
+For instance, processing a nested scope requires a parent function node."
+ (let (result head fn current-fn parent-qname qname p elem)
+ (dolist (entry entries)
+ ;; function node goes first
+ (destructuring-bind (current-fn &rest (&whole chain head &rest)) entry
+ ;; Examine head's defining scope:
+ ;; Pre-processed chain, or top-level/external, keep as-is.
+ (if (or (stringp head) (js2-node-top-level-decl-p head))
+ (push chain result)
+ (when (js2-this-node-p head)
+ (setq chain (cdr chain))) ; discard this-node
+ (when (setq fn (js2-node-parent-script-or-fn current-fn))
+ (setq parent-qname (gethash fn js2-imenu-function-map 'not-found))
+ (when (eq parent-qname 'not-found)
+ ;; anonymous function expressions are not recorded
+ ;; during the parse, so we need to handle this case here
+ (setq parent-qname
+ (if (js2-wrapper-function-p fn)
+ (let ((grandparent (js2-node-parent-script-or-fn fn)))
+ (if (js2-ast-root-p grandparent)
+ nil
+ (gethash grandparent js2-imenu-function-map 'skip)))
+ 'skip))
+ (puthash fn parent-qname js2-imenu-function-map))
+ (unless (eq parent-qname 'skip)
+ ;; prefix parent fn qname to this chain.
+ (let ((qname (append parent-qname chain)))
+ (puthash current-fn (butlast qname) js2-imenu-function-map)
+ (push qname result)))))))
;; finally replace each node in each chain with its name.
(dolist (chain result)
(setq p chain)
;; 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)))))"
+(defun 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))))))
(+ (js2-node-pos n)
(js2-node-len n)))
-(defsubst js2-record-comment ()
+(defun js2-record-comment ()
"Record a comment in `js2-scanned-comments'."
(push (make-js2-comment-node :len (- js2-token-end js2-token-beg)
:format js2-ts-comment-type)
;; 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.
+(defun js2-peek-token ()
+ "Return 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).
(when js2-parse-ide-mode
(cond
((minusp tt)
- (js2-record-face 'js2-error-face))
+ (js2-record-face 'js2-error))
((setq face (aref js2-kwd-tokens tt))
(js2-record-face face))
((and (= tt js2-NAME)
(js2-record-face 'font-lock-constant-face))))
tt))) ; return unflagged token
-(defsubst js2-peek-flagged-token ()
+(defun 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 ()
+(defun js2-next-token ()
(prog1
(js2-peek-token)
(js2-consume-token)))
-(defsubst js2-next-flagged-token ()
+(defun js2-next-flagged-token ()
(js2-peek-token)
(prog1 js2-current-flagged-token
(js2-consume-token)))
-(defsubst js2-match-token (match)
+(defun 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)
(js2-consume-token)
t))
-(defsubst js2-valid-prop-name-token (tt)
+(defun 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 ()
+(defun 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."
t)
nil))
-(defsubst js2-must-match-prop-name (msg-id &optional pos len)
+(defun 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 ()
+(defun 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.
js2-EOL
tt)))
-(defsubst js2-set-check-for-label ()
+(defun 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)
+(defun 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."
(defsubst js2-inside-function ()
(plusp js2-nesting-of-function))
-(defsubst js2-set-requires-activation ()
+(defun 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)
+(defun js2-check-activation-name (name token)
(when (js2-inside-function)
;; skip language-version 1.2 check from Rhino
(if (or (string= "arguments" name)
(gethash name js2-compiler-activation-names)))
(js2-set-requires-activation))))
-(defsubst js2-set-is-generator ()
+(defun 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 ()
+(defun js2-must-have-xml ()
(unless js2-compiler-xml-available
(js2-report-error "msg.XML.not.available")))
-(defsubst js2-push-scope (scope)
+(defun 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)))
(setq js2-current-scope
(js2-scope-parent-scope js2-current-scope)))
-(defsubst js2-enter-loop (loop-node)
+(defun js2-enter-loop (loop-node)
(push loop-node js2-loop-set)
(push loop-node js2-loop-and-switch-set)
(js2-push-scope loop-node)
(js2-label-node-loop (car (js2-labeled-stmt-node-labels
js2-labeled-stmt))) loop-node)))
-(defsubst js2-exit-loop ()
+(defun js2-exit-loop ()
(pop js2-loop-set)
(pop js2-loop-and-switch-set)
(js2-pop-scope))
(pop js2-loop-and-switch-set))
(defun js2-parse (&optional buf cb)
- "Tells the js2 parser to parse a region of JavaScript.
+ "Tell 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.
(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)
+ (with-current-buffer (or buf (current-buffer))
(setq js2-scanned-comments nil
js2-parsed-errors nil
js2-parsed-warnings nil
js2-imenu-recorder nil
js2-imenu-function-map nil
- js2-imenu-fn-type-map nil
js2-label-set nil)
(js2-init-scanner)
- (setq ast (js2-with-unmodifying-text-property-changes
+ (setq ast (with-silent-modifications
(js2-do-parse)))
(unless js2-ts-hit-eof
(js2-report-error "msg.got.syntax.errors" (length js2-parsed-errors)))
(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)
+ (let ((js2-additional-externs js2-additional-externs))
+ (dolist (callback js2-post-parse-callbacks)
+ (funcall callback))
+ (js2-highlight-undeclared-vars))
root))
(defun js2-function-parser ()
(setq param (js2-parse-primary-expr-lhs))
(js2-define-destruct-symbols param
js2-LP
- 'js2-function-param-face)
+ 'js2-function-param)
(push param params))
;; simple name
(t
(js2-must-match js2-NAME "msg.no.parm")
- (js2-record-face 'js2-function-param-face)
+ (js2-record-face 'js2-function-param)
(setq param (js2-create-name-node))
(js2-define-symbol js2-LP js2-ts-string param)
(push param 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)
+(defun 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
(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
+ name name-beg name-end fn-node lp
(synthetic-type function-type)
member-expr-node)
;; parse function name, expression, or non-name (anonymous)
parsers)
"A vector mapping token types to parser functions.")
-(defsubst js2-parse-warn-missing-semi (beg end)
+(defun js2-parse-warn-missing-semi (beg end)
(and js2-mode-show-strict-warnings
js2-strict-missing-semi-warning
(js2-add-strict-warning
(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)
+ cond if-true if-false else-pos end pn)
(js2-consume-token)
(setq cond (js2-parse-condition)
if-true (js2-parse-statement)
(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)
+ 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))
"Parser for while-statement. Last matched token must be js2-WHILE."
(let ((pos js2-token-beg)
(pn (make-js2-while-node))
- cond
- body)
+ cond body)
(js2-consume-token)
(js2-enter-loop pn)
(unwind-protect
"Parser for do-statement. Last matched token must be js2-DO."
(let ((pos js2-token-beg)
(pn (make-js2-do-node))
- cond
- body
- end)
+ cond body end)
(js2-consume-token)
(js2-enter-loop pn)
(unwind-protect
"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
+ 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)
+ 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 (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)))
+ ;; 'for' makes local scope
+ (js2-push-scope (make-js2-scope))
(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))
+ ;; 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)
+ ;; scope of iteration target object is not the scope we've created above.
+ ;; stash current scope temporary.
+ cond (let ((js2-current-scope (js2-scope-parent-scope js2-current-scope)))
+ (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))
+ (js2-pop-scope))
pn))
(defun js2-parse-try ()
(defun js2-parse-throw ()
"Parser for throw-statement. Last matched token must be js2-THROW."
(let ((pos js2-token-beg)
- expr
- pn)
+ expr pn)
(js2-consume-token)
(if (= (js2-peek-token-or-eol) js2-EOL)
;; ECMAScript does not allow new lines before throw expression,
(js2-node-add-children pn expr)
pn))
-(defsubst js2-match-jump-label-name (label-name)
+(defun 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."
Last matched token must be js2-CONST or js2-VAR."
(let ((tt (js2-peek-token))
(pos js2-token-beg)
- expr
- pn)
+ expr pn)
(js2-consume-token)
(setq expr (js2-parse-variables tt js2-token-beg)
pn (make-js2-expr-stmt-node :pos pos
(js2-node-add-children pn expr)
pn))
-(defsubst js2-wrap-with-expr-stmt (pos expr &optional add-child)
+(defun 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)
"Parser for let-statement. Last matched token must be js2-LET."
(js2-consume-token)
(let ((pos js2-token-beg)
- expr
- pn)
+ expr pn)
(if (= (js2-peek-token) js2-LP)
;; let expression in statement context
(setq expr (js2-parse-let pos 'statement)
(end js2-token-end)
(before js2-end-flags)
(inside-function (js2-inside-function))
- e
- ret
- name)
+ e ret name)
(unless inside-function
(js2-report-error (if (eq tt js2-RETURN)
"msg.bad.return"
(defun js2-parse-block ()
"Parser for a curly-delimited statement block.
-Last token matched must be js2-LC."
+Last token matched must be `js2-LC'."
(let ((pos js2-token-beg)
(pn (make-js2-scope)))
(js2-consume-token)
(js2-pop-scope))
pn))
-;; for js2-ERROR too, to have a node for error recovery to work on
+;; 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."
+Last matched token is `js2-SEMI' or `js2-ERROR'."
(let ((tt (js2-peek-token)) pos len)
(js2-consume-token)
(if (eq tt js2-SEMI)
expression and return it wrapped in a `js2-expr-stmt-node'."
(let ((pos js2-token-beg)
(end js2-token-end)
- expr
- stmt
- pn
- bundle
+ expr stmt pn bundle
(continue t))
;; set check for label and call down to `js2-parse-primary-expr'
(js2-set-check-for-label)
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
+ destructuring kid-pos tt init name end nbeg nend vi
(continue t))
;; Example:
;; var foo = {a: 1, b: 2}, bar = [3, 4];
(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)))
+ (js2-record-imenu-functions init name))
(when name
(js2-set-face nbeg nend (if (js2-function-node-p init)
'font-lock-function-name-face
(js2-pop-scope))
pn))
-(defsubst js2-define-new-symbol (decl-type name node)
- (js2-scope-put-symbol js2-current-scope
+(defun js2-define-new-symbol (decl-type name node &optional scope)
+ (js2-scope-put-symbol (or scope js2-current-scope)
name
(make-js2-symbol decl-type name node)))
(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)))
+ (js2-define-new-symbol decl-type name node
+ js2-current-script-or-fn)))
((= decl-type js2-LP)
(if symbol
;; must be duplicate parameter. Second parameter hides the
(defun js2-parse-assign-expr ()
(let ((tt (js2-peek-token))
(pos js2-token-beg)
- pn
- left
- right
- op-pos)
+ pn left right op-pos)
(if (= tt js2-YIELD)
(js2-parse-return-or-yield tt t)
;; not yield - parse assignment expression
: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)))
+ (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)))
(setq continue nil)))
pn))
-(defsubst js2-make-unary (type parser &rest args)
+(defun 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)."
(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)
+(defun 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)
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
+ pn-xml pn expr kids expr-pos
(continue t)
(first-token t))
(when (not (or (= tt js2-XML) (= tt js2-XMLEND)))
(defun js2-parse-argument-list ()
- "Parse an argument list and return it as a lisp list of nodes.
+ "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)
(defun js2-parse-member-expr (&optional allow-call-syntax)
(let ((tt (js2-peek-token))
- pn
- pos
- target
- args
- beg
- end
- init
- tail)
+ pn pos target args beg end init tail)
(if (/= tt js2-NEW)
(setq pn (js2-parse-primary-expr))
;; parse a 'new' expression
"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)
+ op-pos expr end)
(js2-consume-token)
(js2-must-have-xml)
(js2-set-requires-activation)
Last token parsed must be `js2-RB'."
(let ((lb js2-token-beg)
(pos (js2-node-pos pn))
- rb
- expr)
+ rb expr)
(js2-consume-token)
(setq expr (js2-parse-expr))
(if (js2-must-match js2-RB "msg.no.bracket.index")
(let ((pos (or at-pos js2-token-beg))
colon-pos
(name (js2-create-name-node t js2-current-token))
- ns
- tt
- ref
- pn)
+ ns tt ref pn)
(catch 'return
(when (js2-match-token js2-COLONCOLON)
(setq ns name
:rb (js2-relpos rb pos)))
(js2-node-add-children pn namespace expr))))
-(defsubst js2-parse-primary-expr-lhs ()
+(defun js2-parse-primary-expr-lhs ()
(let ((js2-is-in-lhs t))
(js2-parse-primary-expr)))
(defun js2-parse-primary-expr ()
- "Parses a literal (leaf) expression of some sort.
+ "Parse 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))
(js2-record-name-node node))
node)))
-(defsubst js2-parse-warn-trailing-comma (msg pos elems comma-pos)
+(defun 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
(let ((pos js2-token-beg)
(end js2-token-end)
(after-lb-or-comma t)
- after-comma
- tt
- elems
- pn
+ after-comma tt elems pn
(continue t))
(unless js2-is-in-lhs
(js2-push-scope (make-js2-scope))) ; for array comp
:len (- js2-ts-cursor pos)
:elems (nreverse elems)))
(apply #'js2-node-add-children pn (js2-array-node-elems pn))
- (when after-comma
+ (when (and after-comma (not js2-is-in-lhs))
(js2-parse-warn-trailing-comma "msg.array.trailing.comma"
pos elems after-comma)))
;; destructuring binding
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
- loop
- first
- prev
- filter
- if-pos
- result)
+ (let (loops loop first prev filter if-pos result)
(while (= (js2-peek-token) js2-FOR)
(let ((prev (car loops))) ; rearrange scope chain
(push (setq loop (js2-parse-array-comp-loop)) loops)
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)
+ 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
(defun js2-parse-object-literal ()
(let ((pos js2-token-beg)
- tt
- elems
- result
- after-comma
+ tt elems result after-comma
(continue t))
(while continue
(setq tt (js2-peek-token))
(cond
- ;; {foo: ...}, {'foo': ...}, {foo, bar, ...}, {get foo() {...}}, or {set foo(x) {...}}
+ ;; {foo: ...}, {'foo': ...}, {foo, bar, ...},
+ ;; {get foo() {...}}, or {set foo(x) {...}}
((or (js2-valid-prop-name-token tt)
(= tt js2-STRING))
(setq after-comma nil
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
+ 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)
;; Karl for coming up with the initial approach, which packs a lot of
;; punch for so little code.
-(defconst js-possibly-braceless-keyword-re
- (regexp-opt
- '("catch" "do" "else" "finally" "for" "if" "each" "try" "while" "with" "let")
- 'words)
+(defconst js2-possibly-braceless-keywords-re
+ (concat "else[ \t]+if\\|for[ \t]+each\\|"
+ (regexp-opt '("catch" "do" "else" "finally" "for" "if"
+ "try" "while" "with" "let")))
"Regular expression matching keywords that are optionally
followed by an opening brace.")
-(defconst js-possibly-braceless-keywords-re
- "\\([ \t}]*else[ \t]+if\\|[ \t}]*for[ \t]+each\\)"
- "Regular expression which matches the keywords which are consist of more than 2 words
-like 'if else' and 'for each', and optionally followed by an opening brace.")
-
-(defconst js-indent-operator-re
+(defconst js2-indent-operator-re
(concat "[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|"
(regexp-opt '("in" "instanceof") 'words))
"Regular expression matching operators that affect indentation
of continued expressions.")
+(defconst js2-declaration-keyword-re
+ (regexp-opt '("var" "let" "const") 'words)
+ "Regular expression matching variable declaration keywords.")
+
;; 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.
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."
+ "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)))
+ (let ((parse-state (syntax-ppss (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)))
+(defun js2-re-search-forward-inner (regexp &optional bound count)
+ "Auxiliary function for `js2-re-search-forward'."
+ (let (parse saved-point)
(while (> count 0)
(re-search-forward regexp bound)
- (setq parse (parse-partial-sexp saved-point (point)))
+ (setq parse (if saved-point
+ (parse-partial-sexp saved-point (point))
+ (syntax-ppss (point))))
(cond ((nth 3 parse)
(re-search-forward
(concat "\\([^\\]\\|^\\)" (string (nth 3 parse)))
(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."
+(defun js2-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))
+ '(js2-re-search-forward-inner regexp bound 1))
((< count 0)
- '(js-re-search-backward-inner regexp bound (- count)))
+ '(js2-re-search-backward-inner regexp bound (- count)))
((> count 0)
- '(js-re-search-forward-inner regexp bound count)))))
+ '(js2-re-search-forward-inner regexp bound count)))))
(condition-case err
(eval search-expr)
(search-failed
(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)))
+(defun js2-re-search-backward-inner (regexp &optional bound count)
+ "Auxiliary function for `js2-re-search-backward'."
+ (let (parse)
(while (> count 0)
(re-search-backward regexp bound)
- (setq parse (parse-partial-sexp saved-point (point)))
+ (setq parse (syntax-ppss (point)))
(cond ((nth 3 parse)
(re-search-backward
(concat "\\([^\\]\\|^\\)" (string (nth 3 parse)))
- (save-excursion (beginning-of-line) (point)) t))
+ (line-beginning-position) t))
((nth 7 parse)
(goto-char (nth 8 parse)))
((or (nth 4 parse)
(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."
+(defun js2-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))
+ '(js2-re-search-backward-inner regexp bound 1))
((< count 0)
- '(js-re-search-forward-inner regexp bound (- count)))
+ '(js2-re-search-forward-inner regexp bound (- count)))
((> count 0)
- '(js-re-search-backward-inner regexp bound count)))))
+ '(js2-re-search-backward-inner regexp bound count)))))
(condition-case err
(eval search-expr)
(search-failed
(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."
+(defun js2-looking-at-operator-p ()
+ "Return non-nil if text after point is a non-comma operator."
+ (and (looking-at js2-indent-operator-re)
+ (or (not (looking-at ":"))
+ (save-excursion
+ (and (js2-re-search-backward "[?:{]\\|\\<case\\>" nil t)
+ (looking-at "?"))))))
+
+(defun js2-continued-expression-p ()
+ "Return non-nil if the current line continues an expression."
(save-excursion
(back-to-indentation)
- (or (js-looking-at-operator-p)
- ;; comment
- (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
+ (or (js2-looking-at-operator-p)
+ (when (js2-re-search-backward "\n" nil t) ;; skip comments
+ (skip-chars-backward " \t")
+ (unless (bolp) ;; previous line is empty
+ (backward-char)
+ (when (js2-looking-at-operator-p)
+ (backward-char)
+ (not (looking-at "\\*\\|++\\|--\\|/[/*]"))))))))
+
+(defun js2-end-of-do-while-loop-p ()
+ "Return 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-get-multiline-declaration-offset ()
- "Returns offset (> 0) if the current line is part of
- multi-line variable declaration like below example, and
- returns 0 otherwise.
-
- var a = 10,
- b = 20,
- c = 30;
-
-"
- (let* ((node (js2-node-at-point))
- (pnode (and node (js2-node-parent node)))
- (pnode-type (and pnode (js2-node-type pnode))))
- (if (and node
- (= js2-NAME (js2-node-type node))
- (or
- (= js2-VAR pnode-type)
- (= js2-LET pnode-type)
- (= js2-CONST pnode-type)))
- (if (= js2-CONST pnode-type)
- 6
- 4)
- 0)))
-
-(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
+ (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\\>"))
+ (js2-re-search-backward "\\<do\\>" (point-at-bol) t)
+ (or (looking-at "\\<do\\>")
+ (let ((saved-indent (current-indentation)))
+ (while (and (js2-re-search-backward "^[ \t]*\\<" nil t)
+ (/= (current-indentation) saved-indent)))
+ (and (looking-at "[ \t]*\\<do\\>")
+ (not (js2-re-search-forward
+ "\\<while\\>" (point-at-eol) t))
+ (= (current-indentation) saved-indent))))))))
+
+(defun js2-multiline-decl-indentation ()
+ "Returns the declaration indentation column if the current line belongs
+to a multiline declaration statement. See `js2-pretty-multiline-declarations'."
+ (let (forward-sexp-function ; use Lisp version
+ at-opening-bracket)
+ (save-excursion
+ (back-to-indentation)
+ (when (not (looking-at js2-declaration-keyword-re))
+ (when (looking-at js2-indent-operator-re)
+ (goto-char (match-end 0))) ; continued expressions are ok
+ (while (and (not at-opening-bracket)
+ (not (bobp))
+ (let ((pos (point)))
+ (save-excursion
+ (js2-backward-sws)
+ (or (eq (char-before) ?,)
+ (and (not (eq (char-before) ?\;))
+ (and
+ (prog2 (skip-chars-backward "[[:punct:]]")
+ (looking-at js2-indent-operator-re)
+ (js2-backward-sws))
+ (not (eq (char-before) ?\;))))
+ (js2-same-line pos)))))
+ (condition-case err
+ (backward-sexp)
+ (scan-error (setq at-opening-bracket t))))
+ (when (looking-at js2-declaration-keyword-re)
+ (- (1+ (match-end 0)) (point-at-bol)))))))
+
+(defun js2-ctrl-statement-indentation ()
+ "Return the proper indentation of current line if it is a control statement.
+Returns an indentation if this line starts the body of a control
+statement without braces, else returns nil."
+ (let (forward-sexp-function)
(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)
+ (when (and (not (js2-same-line (point-min)))
+ (not (looking-at "{"))
+ (js2-re-search-backward "[[:graph:]]" nil t)
+ (not (looking-at "[{([]"))
+ (progn
+ (forward-char)
+ (when (= (char-before) ?\))
;; 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))
- (or (bolp)
- (and (backward-word 1)
- (skip-chars-backward " \t}" (point-at-bol))
- (bolp)
- (looking-at js-possibly-braceless-keywords-re))))
- (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))))))
+ (skip-chars-backward " \t" (point-at-bol)))
+ (let ((pt (point)))
+ (back-to-indentation)
+ (and (looking-at js2-possibly-braceless-keywords-re)
+ (= (match-end 0) pt)
+ (not (js2-end-of-do-while-loop-p))))))
+ (+ (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)
+ (let ((bracket (nth 1 parse-status))
+ (end (point)))
+ (when bracket
(save-excursion
- (goto-char (nth 1 parse-status))
+ (goto-char bracket)
(when (looking-at "\\[")
(forward-char 1)
(js2-forward-sws)
(if (looking-at "[[{]")
- (let (forward-sexp-function) ; use lisp version
+ (let (forward-sexp-function) ; use Lisp version
(forward-sexp) ; skip destructuring form
(js2-forward-sws)
(if (and (/= (char-after) ?,) ; regular array
(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)
+ (if (and (> end (point)) ; not empty literal
+ (re-search-forward "[^,]]* \\(for\\) " end t)
+ ;; not inside comment or string literal
+ (let ((state (parse-partial-sexp bracket (point))))
+ (not (or (nth 3 state) (nth 4 state)))))
(match-beginning 1))))))))
(defun js2-array-comp-indentation (parse-status for-kwd)
(goto-char for-kwd)
(current-column))))
-(defun js-proper-indentation (parse-status)
+(defun js2-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))
+ (let ((ctrl-stmt-indent (js2-ctrl-statement-indentation))
(same-indent-p (looking-at "[]})]\\|\\<case\\>\\|\\<default\\>"))
- (continued-expr-p (js-continued-expression-p))
- (multiline-declaration-offset (or (and js2-use-ast-for-indentation-p
- (js-get-multiline-declaration-offset))
- 0))
+ (continued-expr-p (js2-continued-expression-p))
+ (declaration-indent (and js2-pretty-multiline-declarations
+ (js2-multiline-decl-indentation)))
(bracket (nth 1 parse-status))
beg)
(cond
;; indent array comprehension continuation lines specially
((and bracket
+ (>= js2-language-version 170)
(not (js2-same-line bracket))
(setq beg (js2-indent-in-array-comp parse-status))
(>= (point) (save-excursion
(ctrl-stmt-indent)
+ ((and declaration-indent continued-expr-p)
+ (+ declaration-indent js2-basic-offset))
+
+ (declaration-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 (and (nth 1 p)
- (not js2-consistent-level-indent-inner-bracket-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)))
- ((> multiline-declaration-offset 0)
- (+ (current-column) js2-basic-offset multiline-declaration-offset))
- (t
- (+ (current-column) js2-basic-offset)))))
+ (when (save-excursion (skip-chars-backward " \t)")
+ (looking-at ")"))
+ (backward-list))
+ (back-to-indentation)
+ (and (eq js2-pretty-multiline-declarations 'all)
+ (looking-at js2-declaration-keyword-re)
+ (goto-char (1+ (match-end 0))))
+ (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)
(continued-expr-p js2-basic-offset)
- ((> multiline-declaration-offset 0)
- (+ multiline-declaration-offset))
-
(t 0)))))
(defun js2-lineup-comment (parse-status)
(interactive)
(while (forward-comment 1)))
-(defsubst js2-current-indent (&optional pos)
+(defun 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
(back-to-indentation)
(current-column)))
-(defsubst js2-arglist-close ()
+(defun 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 "[])}]"))))
+ (save-excursion
+ (goto-char (point-at-bol))
+ (js2-forward-sws)
+ (looking-at "[])}]")))
-(defsubst js2-indent-looks-like-label-p ()
+(defun js2-indent-looks-like-label-p ()
(goto-char (point-at-bol))
(js2-forward-sws)
(looking-at (concat js2-mode-identifier-re ":")))
(save-excursion
(js2-indent-looks-like-label-p)))))
-;; if prev line looks like foobar({ then we're passing an object
+;; 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)
+(defun js2-indent-objlit-arg-p (parse-status)
(save-excursion
(back-to-indentation)
(js2-backward-sws)
(skip-chars-backward " \t")
(eq (char-before) ?\()))))
-(defsubst js2-indent-case-block-p ()
+(defun 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-.+:"))))
+ (looking-at "case\\s-.+:")))
-(defsubst js2-syntax-bol ()
+(defun 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
(skip-chars-forward " \t")
(point)))
-(defun js2-bounce-indent (normal-col parse-status)
+(defun js2-bounce-indent (normal-col parse-status &optional backwards)
"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."
+bracket, brace and statement nesting. If BACKWARDS, cycle positions
+in reverse."
(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)
+ positions pos main-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))
+ (when js2-mode-indent-inhibit-undo
+ (setq buffer-undo-list t))
(unwind-protect
(progn
- ;; first likely point: indent from beginning of previous code line
+ ;; First likely point: indent from beginning of previous code line
(push (setq basic-offset
(+ (save-excursion
(back-to-indentation)
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.
+ ;; (First + epsilon) likely point: indent 2x from beginning of
+ ;; previous code line. Google does it this way.
(push (setq basic-offset
(+ (save-excursion
(back-to-indentation)
(* 2 js2-basic-offset)))
positions)
- ;; second likely point: indent from assign-expr RHS. This
+ ;; 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)))))
+ (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)))
+ (push pos positions))
- ;; third likely point: same indent as previous line of code.
+ ;; 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
(js2-indent-in-objlit-p parse-status))
(not (js2-arglist-close)))
(setq same-indent pos))
- (unless (member pos positions)
- (push pos positions)))
+ (push pos positions))
- ;; fourth likely point: first preceding code with less indentation
+ ;; Fourth likely point: first preceding code with less indentation.
;; than the immediately preceding code line.
(setq pos (save-excursion
+ (back-to-indentation)
(js2-backward-sws)
(back-to-indentation)
(setq anchor (current-column))
(current-column))
anchor)))
(setq pos (current-column))))
- (unless (member pos positions)
- (push pos positions))
+ (push pos positions)
+
+ ;; nesting-heuristic position, main by default
+ (push (setq main-pos normal-col) positions)
- ;; put nesting-heuristic position first in list, sort rest
- (setq positions (nreverse (sort positions '<)))
- (setq positions (cons normal-col (delete normal-col positions)))
+ ;; delete duplicates and sort positions list
+ (setq positions (sort (delete-dups positions) '<))
;; comma-list continuation lines: prev line indent takes precedence
(if same-indent
- (setq positions
- (cons same-indent
- (sort (delete same-indent positions) '<))))
+ (setq main-pos same-indent))
;; 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))))
+ (setq main-pos basic-offset))
+
+ ;; if bouncing backwards, reverse positions list
+ (if backwards
+ (setq positions (reverse 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).
(setq computed-pos 0))
;; case 2: not on any of the computed spots => use main spot
((not pos)
- (setq computed-pos 0))
+ (setq computed-pos (js2-position main-pos positions)))
;; case 3: on last position: cycle to first position
((null (cdr pos))
(setq computed-pos 0))
;; see commentary for `js2-mode-last-indented-line'
(setq js2-mode-last-indented-line current-line))))
-(defsubst js2-1-line-comment-continuation-p ()
+(defun js2-indent-bounce-backwards ()
+ "Calls `js2-indent-line'. When `js2-bounce-indent-p',
+cycles between the computed indentation positions in reverse order."
+ (interactive)
+ (js2-indent-line t))
+
+(defun 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 ()
+ (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 (&optional bounce-backwards)
"Indent the current line as JavaScript source text."
(interactive)
- (when js2-use-ast-for-indentation-p
- (js2-reparse))
- (let (parse-status
- current-indent
- offset
- indent-col
- moved
- ;; don't whine about errors/warnings when we're indenting.
+ (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)))
+ (syntax-ppss (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)))))))
+ (setq indent-col (js2-proper-indentation parse-status))
+ ;; See comments below about `js2-mode-last-indented-line'.
+ (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 bounce-backwards))
+ ;; just indent to the guesser's likely spot
+ (t (indent-line-to indent-col)))
+ (when (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
+ (indent-region-function nil)
+ (after-change-functions (remq 'js2-mode-edit
+ after-change-functions)))
+ (indent-region start end nil) ; nil for byte-compiler
+ (js2-mode-edit start end (- end start))))
+
+(defvar js2-minor-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map (kbd "C-c C-`") #'js2-next-error)
+ (define-key map [mouse-1] #'js2-mode-show-node)
+ map)
+ "Keymap used when `js2-minor-mode' is active.")
-;;;###autoload (add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
+;;;###autoload
+(define-minor-mode js2-minor-mode
+ "Minor mode for running js2 as a background linter.
+This allows you to use a different major mode for JavaScript editing,
+such as `espresso-mode', while retaining the asynchronous error/warning
+highlighting features of `js2-mode'."
+ :group 'js2-mode
+ :lighter " js-lint"
+ (if js2-minor-mode
+ (js2-minor-mode-enter)
+ (js2-minor-mode-exit)))
+
+(defun js2-minor-mode-enter ()
+ "Initialization for `js2-minor-mode'."
+ (set (make-local-variable 'max-lisp-eval-depth)
+ (max max-lisp-eval-depth 3000))
+ (setq next-error-function #'js2-next-error)
+ (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)))
+ ;; 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))))
+ (setq js2-mode-buffer-dirty-p t
+ js2-mode-parsing nil)
+ (set (make-local-variable 'js2-highlight-level) 0) ; no syntax highlighting
+ (add-hook 'after-change-functions #'js2-minor-mode-edit nil t)
+ (add-hook 'change-major-mode-hook #'js2-minor-mode-exit nil t)
+ (js2-reparse))
+
+(defun js2-minor-mode-exit ()
+ "Turn off `js2-minor-mode'."
+ (setq next-error-function nil)
+ (remove-hook 'after-change-functions #'js2-mode-edit t)
+ (remove-hook 'change-major-mode-hook #'js2-minor-mode-exit t)
+ (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))
+
+(defvar js2-source-buffer nil "Linked source buffer for diagnostics view")
+(make-variable-buffer-local 'js2-source-buffer)
+
+(defun* js2-display-error-list ()
+ "Display a navigable buffer listing parse errors/warnings."
+ (interactive)
+ (unless (js2-have-errors-p)
+ (message "No errors")
+ (return-from js2-display-error-list))
+ (labels ((annotate-list
+ (lst type)
+ "Add diagnostic TYPE and line number to errs list"
+ (mapcar (lambda (err)
+ (append err (list type
+ (line-number-at-pos (nth 1 err)))))
+ lst)))
+ (let* ((srcbuf (current-buffer))
+ (errbuf (get-buffer-create "*js-lint*"))
+ (errors (annotate-list
+ (when js2-mode-ast (js2-ast-root-errors js2-mode-ast))
+ 'js2-error)) ; must be a valid face name
+ (warnings (annotate-list
+ (when js2-mode-ast (js2-ast-root-warnings js2-mode-ast))
+ 'js2-warning)) ; must be a valid face name
+ (all-errs (sort (append errors warnings)
+ (lambda (e1 e2)
+ (funcall '< (nth 1 e1) (nth 1 e2))))))
+ (with-current-buffer errbuf
+ (let ((inhibit-read-only t))
+ (erase-buffer)
+ (dolist (err all-errs)
+ (destructuring-bind (msg-key beg end type line) err
+ (insert-text-button
+ (format "line %d: %s" line (js2-get-msg msg-key))
+ 'face type
+ 'follow-link "\C-m"
+ 'action 'js2-error-buffer-jump
+ 'js2-msg (js2-get-msg msg-key)
+ 'js2-pos beg)
+ (insert "\n"))))
+ (js2-error-buffer-mode)
+ (setq js2-source-buffer srcbuf)
+ (pop-to-buffer errbuf)
+ (goto-char (point-min))
+ (unless (eobp)
+ (js2-error-buffer-view))))))
+
+(defvar js2-error-buffer-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "n" #'js2-error-buffer-next)
+ (define-key map "p" #'js2-error-buffer-prev)
+ (define-key map (kbd "RET") #'js2-error-buffer-jump)
+ (define-key map "o" #'js2-error-buffer-view)
+ (define-key map "q" #'js2-error-buffer-quit)
+ map)
+ "Keymap used for js2 diagnostics buffers.")
+
+(defun js2-error-buffer-mode ()
+ "Major mode for js2 diagnostics buffers.
+Selecting an error will jump it to the corresponding source-buffer error.
+\\{js2-error-buffer-mode-map}"
+ (interactive)
+ (setq major-mode 'js2-error-buffer-mode
+ mode-name "JS Lint Diagnostics")
+ (use-local-map js2-error-buffer-mode-map)
+ (setq truncate-lines t)
+ (set-buffer-modified-p nil)
+ (setq buffer-read-only t)
+ (run-hooks 'js2-error-buffer-mode-hook))
+
+(defun js2-error-buffer-next ()
+ "Move to next error and view it."
+ (interactive)
+ (when (zerop (forward-line 1))
+ (js2-error-buffer-view)))
+
+(defun js2-error-buffer-prev ()
+ "Move to previous error and view it."
+ (interactive)
+ (when (zerop (forward-line -1))
+ (js2-error-buffer-view)))
+
+(defun js2-error-buffer-quit ()
+ "Kill the current buffer."
+ (interactive)
+ (kill-buffer))
+
+(defun js2-error-buffer-jump (&rest ignored)
+ "Jump cursor to current error in source buffer."
+ (interactive)
+ (when (js2-error-buffer-view)
+ (pop-to-buffer js2-source-buffer)))
+
+(defun js2-error-buffer-view ()
+ "Scroll source buffer to show error at current line."
+ (interactive)
+ (cond
+ ((not (eq major-mode 'js2-error-buffer-mode))
+ (message "Not in a js2 errors buffer"))
+ ((not (buffer-live-p js2-source-buffer))
+ (message "Source buffer has been killed"))
+ ((not (wholenump (get-text-property (point) 'js2-pos)))
+ (message "There does not seem to be an error here"))
+ (t
+ (let ((pos (get-text-property (point) 'js2-pos))
+ (msg (get-text-property (point) 'js2-msg)))
+ (save-selected-window
+ (pop-to-buffer js2-source-buffer)
+ (goto-char pos)
+ (message msg))))))
;;;###autoload
-(defun js2-mode ()
+(define-derived-mode js2-mode prog-mode "Javascript-IDE"
+ ;; FIXME: Should derive from js-mode.
"Major mode for editing JavaScript code."
- (interactive)
- (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
+ (setq 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 'comment-line-break-function) #'js2-line-break)
(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
+ ;; 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
;; needed for M-x rgrep, among other things
(put 'js2-mode 'find-tag-default-function #'js2-mode-find-tag)
+ (set (make-local-variable 'electric-indent-chars)
+ (append '("{" "}" "(" ")" "[" "]" ":" ";" "," "*")
+ electric-indent-chars))
+ (set (make-local-variable 'electric-layout-rules)
+ '((?\; . after) (?\{ . after) (?\} . before)))
+
;; 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
+ (setq c-comment-prefix-regexp js2-comment-prefix-regexp
c-comment-start-regexp "/[*/]\\|\\s|"
+ c-line-comment-starter "//"
c-paragraph-start js2-paragraph-start
c-paragraph-separate "$"
comment-start-skip js2-comment-start-skip
c-syntactic-ws-end js2-syntactic-ws-end
c-syntactic-eol js2-syntactic-eol)
+ (let ((c-buffer-is-cc-mode t))
+ ;; Copied from `js-mode'. Also see Bug#6071.
+ (make-local-variable 'paragraph-start)
+ (make-local-variable 'paragraph-separate)
+ (make-local-variable 'paragraph-ignore-fill-prefix)
+ (make-local-variable 'adaptive-fill-mode)
+ (make-local-variable 'adaptive-fill-regexp)
+ (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))
+ (if js2-include-browser-externs js2-browser-externs)
+ (if js2-include-gears-externs js2-gears-externs)
+ (if js2-include-rhino-externs js2-rhino-externs)))
+
+ (setq font-lock-defaults '(nil t))
;; 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))))
+ (when (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)
+ (setq next-error-function #'js2-next-error)
(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)
+
+ (if (fboundp 'run-mode-hooks)
+ (run-mode-hooks 'js2-mode-hook)
+ (run-hooks 'js2-mode-hook))
+
(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))
+ (js2-reparse))
(defun js2-mode-exit ()
"Exit `js2-mode' and clean up."
(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
+ (with-silent-modifications
(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 ()
+(defun js2-mode-reset-timer ()
"Cancel any existing parse timer and schedule a new one."
(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)))
+ (run-with-idle-timer js2-idle-timer-delay nil
+ #'js2-mode-idle-reparse (current-buffer))))
+
+(defun js2-mode-idle-reparse (buffer)
+ "Run `js2-reparse' if BUFFER is the current buffer, or schedule
+it to be reparsed when the buffer is selected."
+ (if (eq buffer (current-buffer))
+ (js2-reparse)
+ ;; reparse when the buffer is selected again
+ (with-current-buffer buffer
+ (add-hook 'window-configuration-change-hook
+ #'js2-mode-idle-reparse-inner
+ nil t))))
+
+(defun js2-mode-idle-reparse-inner ()
+ (remove-hook 'window-configuration-change-hook
+ #'js2-mode-idle-reparse-inner
+ t)
+ (js2-reparse))
(defun js2-mode-edit (beg end len)
"Schedule a new parse after buffer is edited.
-Buffer edit spans from BEG to END and is of length LEN.
-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)))
+Buffer edit spans from BEG to END and is of length LEN."
(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 farging buffer
- ;; with just the keywords already". Argh.
- (setq font-lock-defaults (list font-lock-keywords 'keywords-only))
- (let (font-lock-verbose)
- (font-lock-fontify-buffer))))
+(defun js2-minor-mode-edit (beg end len)
+ "Callback for buffer edits in `js2-mode'.
+Schedules a new parse after buffer is edited.
+Buffer edit spans from BEG to END and is of length LEN."
+ (setq js2-mode-buffer-dirty-p t)
+ (js2-mode-hide-overlay)
+ (js2-mode-reset-timer))
(defun js2-reparse (&optional force)
"Re-parse current buffer after user finishes some data entry.
(unwind-protect
(when (or js2-mode-buffer-dirty-p force)
(js2-remove-overlays)
- (js2-with-unmodifying-text-property-changes
+ (with-silent-modifications
(setq js2-mode-buffer-dirty-p nil
js2-mode-fontifications nil
- js2-mode-deferred-properties nil
- js2-additional-externs nil)
+ js2-mode-deferred-properties nil)
(if js2-mode-verbose-parse-p
(message "parsing..."))
(setq time
(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))))
"Debugging aid: highlight selected AST node on mouse click."
(interactive)
(let ((node (js2-node-at-point))
- beg
- end)
+ beg end)
(when js2-mode-show-overlay
(if (null node)
(message "No node found at location %s" (point))
(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
+ (overlay-put js2-mode-node-overlay 'font-lock-face 'highlight))
+ (with-silent-modifications
(put-text-property beg end 'point-left #'js2-mode-hide-overlay))
(message "%s, parent: %s"
(js2-node-short-name node)
(unless (and p2
(>= p2 beg)
(<= p2 end))
- (js2-with-unmodifying-text-property-changes
+ (with-silent-modifications
(remove-text-properties beg end '(point-left nil)))
(delete-overlay js2-mode-node-overlay)
(setq js2-mode-node-overlay nil)))))
(js2-mode-exit)
(js2-mode))
-(defsubst js2-mode-show-warn-or-err (e face)
+(defun 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))
(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 'font-lock-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)))
;; Have to reverse the recorded fontifications list 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)))
+ (put-text-property (first f) (second f) 'font-lock-face (third f)))
(setq js2-mode-fontifications nil))
(dolist (p js2-mode-deferred-properties)
(apply #'put-text-property p))
"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))))
+ (js2-mode-show-warn-or-err e 'js2-error))))
(defun js2-mode-remove-suppressed-warnings ()
"Take suppressed warnings out of the AST warnings list.
"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))))
+ (js2-mode-show-warn-or-err e 'js2-warning))))
(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))))
+ (when (and (stringp msg) (or (not (current-message))
+ (string= (current-message) "Quit")))
+ (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)))))
+(defun js2-line-break (&optional soft)
+ "Break line at point."
+ (let ((parse-status (syntax-ppss)))
(cond
- ;; check if we're inside a string
+ ;; Check if we're inside a string.
((nth 3 parse-status)
- (js2-mode-split-string parse-status))
- ;; check if inside a block comment
+ (if js2-concat-multiline-strings
+ (js2-mode-split-string parse-status)
+ (insert "\n")))
+ ;; 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)))))))
+ (newline)))))
(defun js2-mode-split-string (parse-status)
"Turn a newline in mid-string into a string concatenation.
(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")
+ (at-eol (eq js2-concat-multiline-strings 'eol))
+ (indent (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)
+ (if at-eol
+ (insert " +\n")
+ (insert "\n"))
+ ;; FIXME: This does not match the behavior of `js2-indent-line'.
(indent-to indent)
- (insert "+ " quote-string)
+ (unless at-eol
+ (insert "+ "))
+ (insert quote-string)
(when (eolp)
(insert quote-string)
(backward-char 1))))
(defun js2-mode-extend-comment ()
- "When inside a comment block, add comment prefix."
+ "Indent the line and, when inside a comment block, add comment prefix."
(let (star single col first-line needs-close)
(save-excursion
(back-to-indentation)
(insert "\n")
(indent-to col)
(insert "*/"))))
- (single
- (when (save-excursion
+ ((and single
+ (save-excursion
(and (zerop (forward-line 1))
- (looking-at "\\s-*//")))
- (indent-to col)
- (insert "// "))))))
+ (looking-at "\\s-*//"))))
+ (indent-to col)
+ (insert "// "))
+ ;; don't need to extend the comment after all
+ (js2-enter-indents-newline
+ (js2-indent-line)))))
(defun js2-beginning-of-line ()
"Toggles point between bol and first non-whitespace char in line.
(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)))
+ (nth 3 (syntax-ppss)))
-(defsubst js2-mode-inside-comment-or-string ()
+(defun js2-mode-inside-comment-or-string ()
"Return non-nil if inside a comment or string."
(or
(let ((comment-start
(match-beginning 0)))))
(and comment-start
(<= comment-start (point))))
- (let ((parse-state (save-excursion
- (parse-partial-sexp (point-min) (point)))))
+ (let ((parse-state (syntax-ppss)))
(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.
(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.
(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")))))))
+ (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.
(js2-mode-hide-comment n))))
(js2-mode-hide-//-comments)))
-(defsubst js2-mode-extend-//-comment (direction)
+(defun 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.
(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)))
+ (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))))))
+ (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.
(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)
+ (if (called-interactively-p 'any)
(message "warnings and errors %s"
(if js2-mode-show-parse-errors
"enabled"
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
(js2-node-len node))))
(goto-char (or end (point-max))))))))
+(defun js2-errors ()
+ "Return a list of errors found."
+ (and js2-mode-ast
+ (js2-ast-root-errors js2-mode-ast)))
+
+(defun js2-warnings ()
+ "Return a list of warnings found."
+ (and js2-mode-ast
+ (js2-ast-root-warnings js2-mode-ast)))
+
+(defun js2-have-errors-p ()
+ "Return non-nil if any parse errors or warnings were found."
+ (or (js2-errors) (js2-warnings)))
+
+(defun js2-errors-and-warnings ()
+ "Return a copy of the concatenated errors and warnings lists.
+They are appended: first the errors, then the warnings.
+Entries are of the form (MSG BEG END)."
+ (when js2-mode-ast
+ (append (js2-ast-root-errors js2-mode-ast)
+ (copy-sequence (js2-ast-root-warnings js2-mode-ast)))))
+
(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))))
+ (if (not (or (js2-errors) (js2-warnings)))
(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))))
+ (let* ((errs (js2-errors-and-warnings))
(continue t)
(start (point))
(count (or arg 1))
(sorter (if backward '> '<))
(stopper (if backward '< '>))
(count (abs count))
- all-errs
- err)
- ;; sort by start position
+ 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
+ ;; Find nth error with pos > start.
(while (and errs continue)
(when (funcall stopper (cadar errs) start)
(setq err (car errs))
(setq errs (cdr errs)))
(if err
(goto-char (second err))
- ;; wrap around to first error
+ ;; Wrap around to first error.
(goto-char (second (car all-errs)))
- ;; if we were already on it, echo msg again
+ ;; If we were already on it, echo msg again.
(if (= (point) start)
(js2-echo-error (point) (point)))))))
(prog1
(js2-build-imenu-index)
(setq js2-imenu-recorder nil
- js2-imenu-function-map nil
- js2-imenu-fn-type-map nil))))
+ js2-imenu-function-map nil))))
(defun js2-mode-find-tag ()
"Replacement for `find-tag-default'.
(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-beginning-of-defun (&optional arg)
+ "Go to line on which current function starts, and return t on success.
+If we're not in a function or already at the beginning of one, go
+to beginning of previous script-level element.
+With ARG N, do that N times. If N is negative, move forward."
+ (setq arg (or arg 1))
+ (if (plusp arg)
+ (let ((parent (js2-node-parent-script-or-fn (js2-node-at-point))))
+ (when (cond
+ ((js2-function-node-p parent)
+ (goto-char (js2-node-abs-pos parent)))
+ (t
+ (js2-mode-backward-sibling)))
+ (if (> arg 1)
+ (js2-beginning-of-defun (1- arg))
+ t)))
+ (when (js2-end-of-defun)
+ (if (>= arg -1)
+ (js2-beginning-of-defun 1)
+ (js2-beginning-of-defun (1+ arg))))))
(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)))))))
+ "Go to the char after the last position of the current function
+or script-level element."
+ (let* ((node (js2-node-at-point))
+ (parent (or (and (js2-function-node-p node) node)
+ (js2-node-parent-script-or-fn node)))
+ script)
+ (unless (js2-function-node-p parent)
+ ;; Use current script-level node, or, if none, the next one.
+ (setq script (or parent node)
+ parent (js2-node-find-child-before (point) script))
+ (when (or (null parent)
+ (>= (point) (+ (js2-node-abs-pos parent)
+ (js2-node-len parent))))
+ (setq parent (js2-node-find-child-after (point) script))))
+ (when parent
+ (goto-char (+ (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.