diff options
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801')
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.el | 349 | ||||
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.elc | bin | 17167 -> 0 bytes | |||
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-autoloads.el | 68 | ||||
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-pkg.el | 15 | ||||
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.el | 12856 | ||||
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.elc | bin | 1136343 -> 0 bytes | |||
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.el | 712 | ||||
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.elc | bin | 15906 -> 0 bytes |
8 files changed, 0 insertions, 14000 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.el b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.el deleted file mode 100644 index dfdedc8ee086..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.el +++ /dev/null @@ -1,349 +0,0 @@ -;;; js2-imenu-extras.el --- Imenu support for additional constructs - -;; Copyright (C) 2012-2014 Free Software Foundation, Inc. - -;; Author: Dmitry Gutov <dgutov@yandex.ru> -;; Keywords: languages, javascript, imenu - -;; This file is part of GNU Emacs. - -;; GNU Emacs is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; GNU Emacs is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. - -;;; Commentary: - -;; This package adds Imenu support for additional framework constructs and -;; structural patterns to `js2-mode'. - -;; Usage: - -;; (add-hook 'js2-mode-hook 'js2-imenu-extras-mode) - -;; To customize how it works: -;; M-x customize-group RET js2-imenu RET - -(eval-when-compile - (require 'cl)) - -(require 'js2-mode) - -(defvar js2-imenu-extension-styles - `((:framework jquery - :call-re "\\_<\\(?:jQuery\\|\\$\\|_\\)\\.extend\\s-*(" - :recorder js2-imenu-record-jquery-extend) - - (:framework jquery-ui - :call-re "^\\s-*\\(?:jQuery\\|\\$\\)\\.widget\\s-*(" - :recorder js2-imenu-record-string-declare) - - (:framework dojo - :call-re "^\\s-*dojo.declare\\s-*(" - :recorder js2-imenu-record-string-declare) - - (:framework backbone - :call-re ,(concat "\\_<" js2-mode-identifier-re "\\.extend\\s-*(") - :recorder js2-imenu-record-backbone-extend) - - (:framework enyo - :call-re "\\_<enyo\\.kind\\s-*(" - :recorder js2-imenu-record-enyo-kind) - - (:framework react - :call-re "\\_<React\\.createClass\\s-*(" - :recorder js2-imenu-record-react-class) - - (:framework sencha - :call-re "^\\s-*Ext\\.define\\s-*(" - :recorder js2-imenu-record-sencha-class)) - "List of JavaScript class definition or extension styles. - -:framework is a valid value in `js2-imenu-enabled-frameworks'. - -:call-re is a regular expression that has no capturing groups. - -:recorder is a function name that will be called when the regular -expression matches some text in the buffer. When it's called, point will be -at the end of the match. The function must keep the point position.") - -(defconst js2-imenu-available-frameworks - (mapcar (lambda (style) (plist-get style :framework)) js2-imenu-extension-styles) - "List of available JavaScript framework symbols.") - -(defcustom js2-imenu-enabled-frameworks js2-imenu-available-frameworks - "Frameworks to be recognized by `js2-mode'." - :type (cons 'set (mapcar (lambda (x) (list 'const x)) - js2-imenu-available-frameworks)) - :group 'js2-imenu) - -(defcustom js2-imenu-show-other-functions t - "Non-nil to show functions not recognized by other mechanisms, -in a shared namespace." - :type 'boolean - :group 'js2-imenu) - -(defcustom js2-imenu-other-functions-ns "?" - "Namespace name to use for other functions." - :type 'string - :group 'js2-imenu) - -(defcustom js2-imenu-show-module-pattern t - "Non-nil to recognize the module pattern: - -var foobs = (function(a) { - return {fib: function() {}, fub: function() {}}; -})(b); - -We record the returned hash as belonging to the named module, and -prefix any functions defined inside the IIFE with the module name." - :type 'boolean - :group 'js2-imenu) - -(defcustom js2-imenu-split-string-identifiers t - "When non-nil, split string identifiers on dots. -Currently used for jQuery widgets, Dojo and Enyo declarations." - :type 'boolean - :group 'js2-imenu) - -;;;###autoload -(defun js2-imenu-extras-setup () - (when js2-imenu-enabled-frameworks - (add-hook 'js2-build-imenu-callbacks 'js2-imenu-record-declarations t t)) - (when (or js2-imenu-show-other-functions js2-imenu-show-module-pattern) - (add-hook 'js2-build-imenu-callbacks 'js2-imenu-walk-ast t t))) - -(defun js2-imenu-extras-remove () - (remove-hook 'js2-build-imenu-callbacks 'js2-imenu-record-declarations t) - (remove-hook 'js2-build-imenu-callbacks 'js2-imenu-walk-ast t)) - -(defun js2-imenu-record-declarations () - (let* ((styles (loop for style in js2-imenu-extension-styles - when (memq (plist-get style :framework) - js2-imenu-enabled-frameworks) - collect style)) - (re (mapconcat (lambda (style) - (concat "\\(" (plist-get style :call-re) "\\)")) - styles "\\|"))) - (goto-char (point-min)) - (while (js2-re-search-forward re nil t) - (loop for i from 0 to (1- (length styles)) - when (match-beginning (1+ i)) - return (funcall (plist-get (nth i styles) :recorder)))))) - -(defun js2-imenu-record-jquery-extend () - (let ((pred (lambda (subject) - (and - (js2-prop-get-node-p subject) - (string= (js2-name-node-name (js2-prop-get-node-right subject)) - "prototype"))))) - (js2-imenu-record-extend-first-arg (1- (point)) pred - 'js2-compute-nested-prop-get))) - -(defun js2-imenu-record-string-declare () - (js2-imenu-record-extend-first-arg - (1- (point)) 'js2-string-node-p - (lambda (node) - (if js2-imenu-split-string-identifiers - (split-string (js2-string-node-value node) "\\." t) - (list (js2-string-node-value node)))))) - -(defun js2-imenu-record-extend-first-arg (point pred qname-fn) - (let* ((node (js2-node-at-point point)) - (args (js2-call-node-args node)) - (subject (first args))) - (when (funcall pred subject) - (loop for arg in (cdr args) - when (js2-object-node-p arg) - do (js2-record-object-literal - arg (funcall qname-fn subject) (js2-node-abs-pos arg)))))) - -(defun js2-imenu-record-backbone-or-react () - (let* ((node (js2-node-at-point (1- (point)))) - (args (js2-call-node-args node)) - (methods (first args)) - (parent (js2-node-parent node))) - (when (js2-object-node-p methods) - (let ((subject (cond ((js2-var-init-node-p parent) - (js2-var-init-node-target parent)) - ((js2-assign-node-p parent) - (js2-assign-node-left parent))))) - (when subject - (js2-record-object-literal methods - (js2-compute-nested-prop-get subject) - (js2-node-abs-pos methods))))))) - -(defalias 'js2-imenu-record-backbone-extend 'js2-imenu-record-backbone-or-react) - -(defalias 'js2-imenu-record-react-class 'js2-imenu-record-backbone-or-react) - -(defun js2-imenu-record-enyo-kind () - (let* ((node (js2-node-at-point (1- (point)))) - (args (js2-call-node-args node)) - (options (first args))) - (when (js2-object-node-p options) - (let ((name-value - (loop for elem in (js2-object-node-elems options) - thereis - (let ((key (js2-object-prop-node-left elem)) - (value (js2-object-prop-node-right elem))) - (when (and (equal - (cond ((js2-name-node-p key) - (js2-name-node-name key)) - ((js2-string-node-p key) - (js2-string-node-value key))) - "name") - (js2-string-node-p value)) - (js2-string-node-value value)))))) - (when name-value - (js2-record-object-literal options - (if js2-imenu-split-string-identifiers - (split-string name-value "\\.") - (list name-value)) - (js2-node-abs-pos options))))))) - -(defun js2-imenu-record-sencha-class () - (let* ((node (js2-node-at-point (1- (point)))) - (args (js2-call-node-args node)) - (name (first args)) - (methods (second args))) - (when (and (js2-string-node-p name) (js2-object-node-p methods)) - (let ((name-value (js2-string-node-value name))) - (js2-record-object-literal methods - (if js2-imenu-split-string-identifiers - (split-string name-value "\\." t) - (list name-value)) - (js2-node-abs-pos methods)))))) - -(defun js2-imenu-walk-ast () - (js2-visit-ast - js2-mode-ast - (lambda (node end-p) - (unless end-p - (cond - ((and js2-imenu-show-other-functions - (js2-object-prop-node-p node)) - (js2-imenu-record-orphan-prop-node-function node)) - ((js2-assign-node-p node) - (cond - ((and js2-imenu-show-other-functions - (js2-function-node-p - (js2-assign-node-right node))) - (js2-imenu-record-orphan-assign-node-function - (js2-assign-node-left node) - (js2-assign-node-right node))) - ((and js2-imenu-show-module-pattern - (js2-call-node-p - (js2-assign-node-right node))) - (js2-imenu-record-module-pattern - (js2-assign-node-left node) - (js2-assign-node-right node))))) - ((js2-var-init-node-p node) - (cond - ((and js2-imenu-show-other-functions - (js2-function-node-p - (js2-var-init-node-initializer node))) - (js2-imenu-record-orphan-assign-node-function - (js2-var-init-node-target node) - (js2-var-init-node-initializer node))) - ((and js2-imenu-show-module-pattern - (js2-call-node-p - (js2-var-init-node-initializer node))) - (js2-imenu-record-module-pattern - (js2-var-init-node-target node) - (js2-var-init-node-initializer node)))))) - t)))) - -(defun js2-imenu-parent-key-names (node) - "Get the list of parent key names of NODE. - -For example, for code - - {rules: {password: {required: function() {}}}} - -when NODE is the inner `js2-object-prop-mode', -it returns `(\"rules\" \"password\")'." - (let (rlt (n node)) - (while (setq n (js2-imenu-parent-prop-node n)) - (push (js2-prop-node-name (js2-object-prop-node-left n)) rlt)) - rlt)) - -(defun js2-imenu-parent-prop-node (node) - "When the parent of NODE is `js2-object-node', -and the grandparent is `js2-object-prop-node', -return the grandparent." - ;; Suppose the code is: - ;; {parent-key: {required: function() {}}} - ;; NODE is `required: function() {}'. - (let (p2 p3) - ;; Parent is `{required: function() {}}'. - (setq p2 (js2-node-parent node)) - ;; GP is `parent-key: {required: function() {}}'. - (when (and p2 (js2-object-node-p p2)) - (setq p3 (js2-node-parent p2)) - (if (and p3 (js2-object-prop-node-p p3)) p3)))) - -(defun js2-imenu-record-orphan-prop-node-function (node) - "Record orphan function when it's the value of NODE. -NODE must be `js2-object-prop-node'." - (when (js2-function-node-p (js2-object-prop-node-right node)) - (let ((fn-node (js2-object-prop-node-right node))) - (unless (and js2-imenu-function-map - (gethash fn-node js2-imenu-function-map)) - (let ((key-node (js2-object-prop-node-left node)) - (parent-prop-node (js2-imenu-parent-prop-node node)) - chain) - (setq chain (nconc (js2-imenu-parent-key-names node) - (list (js2-prop-node-name key-node)))) - (push js2-imenu-other-functions-ns chain) - (js2-record-imenu-entry fn-node chain - (js2-node-abs-pos key-node))))))) - -(defun js2-imenu-record-orphan-assign-node-function (target-node fn-node) - "Record orphan function FN-NODE assigned to node TARGET." - (when (or (not js2-imenu-function-map) - (eq 'skip - (gethash fn-node js2-imenu-function-map 'skip))) - (let ((chain (js2-compute-nested-prop-get target-node))) - (when chain - (push js2-imenu-other-functions-ns chain) - (js2-record-imenu-entry fn-node chain (js2-node-abs-pos fn-node)))))) - -(defun js2-imenu-record-module-pattern (target init) - "Recognize and record module pattern use instance. -INIT must be `js2-call-node'." - (let ((callt (js2-call-node-target init))) - ;; Just basic call form: (function() {...})(); - ;; TODO: Handle variations without duplicating `js2-wrapper-function-p'? - (when (and (js2-paren-node-p callt) - (js2-function-node-p (js2-paren-node-expr callt))) - (let* ((fn (js2-paren-node-expr callt)) - (blk (js2-function-node-body fn)) - (ret (car (last (js2-block-node-kids blk))))) - (when (and (js2-return-node-p ret) - (js2-object-node-p (js2-return-node-retval ret))) - ;; TODO: Map function names when revealing module pattern is used. - (let ((retval (js2-return-node-retval ret)) - (target-qname (js2-compute-nested-prop-get target))) - (js2-record-object-literal retval target-qname - (js2-node-abs-pos retval)) - (js2-record-imenu-entry fn target-qname - (js2-node-abs-pos target)))))))) - -;;;###autoload -(define-minor-mode js2-imenu-extras-mode - "Toggle Imenu support for frameworks and structural patterns." - :lighter "" - (if js2-imenu-extras-mode - (js2-imenu-extras-setup) - (js2-imenu-extras-remove))) - -(provide 'js2-imenu-extras) diff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.elc b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.elc deleted file mode 100644 index 1f24421d0e69..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-imenu-extras.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-autoloads.el b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-autoloads.el deleted file mode 100644 index 33f5a4d8ed92..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-autoloads.el +++ /dev/null @@ -1,68 +0,0 @@ -;;; js2-mode-autoloads.el --- automatically extracted autoloads -;; -;;; Code: -(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) - -;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (23450 -;;;;;; 31848 558336 533000)) -;;; Generated autoloads from js2-imenu-extras.el - -(autoload 'js2-imenu-extras-setup "js2-imenu-extras" "\ - - -\(fn)" nil nil) - -(autoload 'js2-imenu-extras-mode "js2-imenu-extras" "\ -Toggle Imenu support for frameworks and structural patterns. - -\(fn &optional ARG)" t nil) - -;;;*** - -;;;### (autoloads nil "js2-mode" "js2-mode.el" (23450 31848 556277 -;;;;;; 900000)) -;;; Generated autoloads from js2-mode.el - -(autoload 'js2-highlight-unused-variables-mode "js2-mode" "\ -Toggle highlight of unused variables. - -\(fn &optional ARG)" t nil) - -(autoload 'js2-minor-mode "js2-mode" "\ -Minor mode for running js2 as a background linter. -This allows you to use a different major mode for JavaScript editing, -such as `js-mode', while retaining the asynchronous error/warning -highlighting features of `js2-mode'. - -\(fn &optional ARG)" t nil) - -(autoload 'js2-mode "js2-mode" "\ -Major mode for editing JavaScript code. - -\(fn)" t nil) - -(autoload 'js2-jsx-mode "js2-mode" "\ -Major mode for editing JSX code. - -To customize the indentation for this mode, set the SGML offset -variables (`sgml-basic-offset' et al) locally, like so: - - (defun set-jsx-indentation () - (setq-local sgml-basic-offset js2-basic-offset)) - (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation) - -\(fn)" t nil) - -;;;*** - -;;;### (autoloads nil nil ("js2-mode-pkg.el" "js2-old-indent.el") -;;;;;; (23450 31848 560354 261000)) - -;;;*** - -;; Local Variables: -;; version-control: never -;; no-byte-compile: t -;; no-update-autoloads: t -;; End: -;;; js2-mode-autoloads.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-pkg.el b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-pkg.el deleted file mode 100644 index cc2a3fa22e99..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode-pkg.el +++ /dev/null @@ -1,15 +0,0 @@ -(define-package "js2-mode" "20180724.801" "Improved JavaScript editing mode" - '((emacs "24.1") - (cl-lib "0.5")) - :keywords - '("languages" "javascript") - :authors - '(("Steve Yegge" . "steve.yegge@gmail.com") - ("mooz" . "stillpedant@gmail.com") - ("Dmitry Gutov" . "dgutov@yandex.ru")) - :maintainer - '("Steve Yegge" . "steve.yegge@gmail.com") - :url "https://github.com/mooz/js2-mode/") -;; Local Variables: -;; no-byte-compile: t -;; End: diff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.el b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.el deleted file mode 100644 index 6aca8266c45f..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.el +++ /dev/null @@ -1,12856 +0,0 @@ -;;; js2-mode.el --- Improved JavaScript editing mode -*- lexical-binding: t -*- - -;; Copyright (C) 2009, 2011-2018 Free Software Foundation, Inc. - -;; Author: Steve Yegge <steve.yegge@gmail.com> -;; mooz <stillpedant@gmail.com> -;; Dmitry Gutov <dgutov@yandex.ru> -;; URL: https://github.com/mooz/js2-mode/ -;; http://code.google.com/p/js2-mode/ -;; Version: 20180301 -;; Keywords: languages, javascript -;; Package-Requires: ((emacs "24.1") (cl-lib "0.5")) - -;; This file is part of GNU Emacs. - -;; GNU Emacs is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; GNU Emacs is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. - -;;; Commentary: - -;; This JavaScript editing mode supports: - -;; - strict recognition of the Ecma-262 language standard -;; - support for most Rhino and SpiderMonkey extensions from 1.5 and up -;; - parsing support for ECMAScript for XML (E4X, ECMA-357) -;; - accurate syntax highlighting using a recursive-descent parser -;; - on-the-fly reporting of syntax errors and strict-mode warnings -;; - undeclared-variable warnings using a configurable externs framework -;; - "bouncing" line indentation to choose among alternate indentation points -;; - smart line-wrapping within comments and strings -;; - code folding: -;; - show some or all function bodies as {...} -;; - show some or all block comments as /*...*/ -;; - context-sensitive menu bar and popup menus -;; - code browsing using the `imenu' package -;; - many customization options - -;; Installation: -;; -;; To install it as your major mode for JavaScript editing: - -;; (add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode)) - -;; Alternatively, 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) - -;; You may also want to hook it in for shell scripts running via node.js: - -;; (add-to-list 'interpreter-mode-alist '("node" . js2-mode)) - -;; Support for JSX is available via the derived mode `js2-jsx-mode'. If you -;; also want JSX support, use that mode instead: - -;; (add-to-list 'auto-mode-alist '("\\.jsx?\\'" . js2-jsx-mode)) -;; (add-to-list 'interpreter-mode-alist '("node" . js2-jsx-mode)) - -;; To customize how it works: -;; M-x customize-group RET js2-mode RET - -;; Notes: - -;; This mode includes a port of Mozilla Rhino's scanner, parser and -;; symbol table. Ideally it should stay in sync with Rhino, keeping -;; `js2-mode' current as the EcmaScript language standard evolves. - -;; Unlike cc-engine based language modes, js2-mode's line-indentation is not -;; customizable. It is a surprising amount of work to support customizable -;; indentation. The current compromise is that the tab key lets you cycle among -;; various likely indentation points, similar to the behavior of python-mode. - -;; This mode does not yet work with "multi-mode" modes such as `mmm-mode' -;; and `mumamo', although it could be made to do so with some effort. -;; This means that `js2-mode' is currently only useful for editing JavaScript -;; files, and not for editing JavaScript within <script> tags or templates. - -;; The project page on GitHub is used for development and issue tracking. -;; The original homepage at Google Code has outdated information and is mostly -;; unmaintained. - -;;; Code: - -(require 'cl-lib) -(require 'imenu) -(require 'js) -(require 'etags) - -(eval-and-compile - (if (version< emacs-version "25.0") - (require 'js2-old-indent) - (defvaralias 'js2-basic-offset 'js-indent-level nil) - (defalias 'js2-proper-indentation 'js--proper-indentation) - (defalias 'js2-jsx-indent-line 'js-jsx-indent-line) - (defalias 'js2-indent-line 'js-indent-line) - (defalias 'js2-re-search-forward 'js--re-search-forward))) - -;;; Externs (variables presumed to be defined by the host system) - -(defvar js2-ecma-262-externs - (mapcar 'symbol-name - '(Array Boolean Date Error EvalError Function Infinity JSON - Math NaN Number Object RangeError ReferenceError RegExp - String SyntaxError TypeError URIError - decodeURI decodeURIComponent encodeURI - encodeURIComponent escape eval isFinite isNaN - parseFloat parseInt undefined unescape)) -"Ecma-262 externs. Never highlighted as undeclared variables.") - -(defvar js2-browser-externs - (mapcar 'symbol-name - '(;; DOM level 1 - Attr CDATASection CharacterData Comment DOMException - DOMImplementation Document DocumentFragment - DocumentType Element Entity EntityReference - ExceptionCode NamedNodeMap Node NodeList Notation - ProcessingInstruction Text - - ;; DOM level 2 - HTMLAnchorElement HTMLAppletElement HTMLAreaElement - HTMLBRElement HTMLBaseElement HTMLBaseFontElement - HTMLBodyElement HTMLButtonElement HTMLCollection - HTMLDListElement HTMLDirectoryElement HTMLDivElement - HTMLDocument HTMLElement HTMLFieldSetElement - HTMLFontElement HTMLFormElement HTMLFrameElement - HTMLFrameSetElement HTMLHRElement HTMLHeadElement - HTMLHeadingElement HTMLHtmlElement HTMLIFrameElement - HTMLImageElement HTMLInputElement HTMLIsIndexElement - HTMLLIElement HTMLLabelElement HTMLLegendElement - HTMLLinkElement HTMLMapElement HTMLMenuElement - HTMLMetaElement HTMLModElement HTMLOListElement - HTMLObjectElement HTMLOptGroupElement - HTMLOptionElement HTMLOptionsCollection - HTMLParagraphElement HTMLParamElement HTMLPreElement - HTMLQuoteElement HTMLScriptElement HTMLSelectElement - HTMLStyleElement HTMLTableCaptionElement - HTMLTableCellElement HTMLTableColElement - HTMLTableElement HTMLTableRowElement - HTMLTableSectionElement HTMLTextAreaElement - HTMLTitleElement HTMLUListElement - - ;; DOM level 3 - DOMConfiguration DOMError DOMException - DOMImplementationList DOMImplementationSource - DOMLocator DOMStringList NameList TypeInfo - UserDataHandler - - ;; Window - window alert confirm document java navigator prompt screen - self top requestAnimationFrame cancelAnimationFrame - - ;; W3C CSS - CSSCharsetRule CSSFontFace CSSFontFaceRule - CSSImportRule CSSMediaRule CSSPageRule - CSSPrimitiveValue CSSProperties CSSRule CSSRuleList - CSSStyleDeclaration CSSStyleRule CSSStyleSheet - CSSValue CSSValueList Counter DOMImplementationCSS - DocumentCSS DocumentStyle ElementCSSInlineStyle - LinkStyle MediaList RGBColor Rect StyleSheet - StyleSheetList ViewCSS - - ;; W3C Event - EventListener EventTarget Event DocumentEvent UIEvent - MouseEvent MutationEvent KeyboardEvent - - ;; W3C Range - DocumentRange Range RangeException - - ;; W3C XML - XPathResult XMLHttpRequest - - ;; console object. Provided by at least Chrome and Firefox. - console)) - "Browser externs. -You can cause these to be included or excluded with the custom -variable `js2-include-browser-externs'.") - -(defvar js2-rhino-externs - (mapcar 'symbol-name - '(Packages importClass importPackage com org java - ;; Global object (shell) externs. - defineClass deserialize doctest gc help load - loadClass print quit readFile readUrl runCommand seal - serialize spawn sync toint32 version)) - "Mozilla Rhino externs. -Set `js2-include-rhino-externs' to t to include them.") - -(defvar js2-node-externs - (mapcar 'symbol-name - '(__dirname __filename Buffer clearInterval clearTimeout require - console exports global module process setInterval setTimeout - querystring setImmediate clearImmediate)) - "Node.js externs. -Set `js2-include-node-externs' to t to include them.") - -(defvar js2-typed-array-externs - (mapcar 'symbol-name - '(ArrayBuffer Uint8ClampedArray DataView - Int8Array Uint8Array Int16Array Uint16Array Int32Array Uint32Array - Float32Array Float64Array)) - "Khronos typed array externs. Available in most modern browsers and -in node.js >= 0.6. If `js2-include-node-externs' or `js2-include-browser-externs' -are enabled, these will also be included.") - -(defvar js2-harmony-externs - (mapcar 'symbol-name - '(Map Promise Proxy Reflect Set Symbol WeakMap WeakSet)) - "ES6 externs. If `js2-include-browser-externs' is enabled and -`js2-language-version' is sufficiently high, these will be included.") - -;;; Variables - -(defcustom js2-ignored-warnings nil - "A list of warning message types that will not be reported. - -Possible values are the keys of `js2-message-table'." - :group 'js2-mode - :type '(repeat string)) - -(defcustom js2-highlight-level 2 - "Amount of syntax highlighting to perform. -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." - :group 'js2-mode - :type '(choice (const :tag "None" 0) - (const :tag "Basic" 1) - (const :tag "Include Properties" 2) - (const :tag "Include Functions" 3))) - -(defvar js2-mode-dev-mode-p nil - "Non-nil if running in development mode. Normally nil.") - -(defgroup js2-mode nil - "An improved JavaScript mode." - :group 'languages) - -(defcustom js2-idle-timer-delay 0.2 - "Delay in secs before re-parsing after user makes changes. -Multiplied by `js2-dynamic-idle-timer-adjust', which see." - :type 'number - :group 'js2-mode) -(make-variable-buffer-local 'js2-idle-timer-delay) - -(defcustom js2-dynamic-idle-timer-adjust 0 - "Positive to adjust `js2-idle-timer-delay' based on file size. -The idea is that for short files, parsing is faster so we can be -more responsive to user edits without interfering with editing. -The buffer length in characters (typically bytes) is divided by -this value and used to multiply `js2-idle-timer-delay' for the -buffer. For example, a 21k file and 10k adjust yields 21k/10k -== 2, so js2-idle-timer-delay is multiplied by 2. -If `js2-dynamic-idle-timer-adjust' is 0 or negative, -`js2-idle-timer-delay' is not dependent on the file size." - :type 'number - :group 'js2-mode) - -(defcustom js2-concat-multiline-strings t - "When non-nil, `js2-line-break' in mid-string will make it 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-show-parse-errors t - "True to highlight parse errors." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-mode-assume-strict nil - "Non-nil to start files in strict mode automatically." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-mode-show-strict-warnings t - "Non-nil to emit Ecma strict-mode warnings. -Some of the warnings can be individually disabled by other flags, -even if this flag is non-nil." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-strict-trailing-comma-warning nil - "Non-nil to warn about trailing commas in array literals. -Ecma-262-5.1 allows them, but older versions of IE raise an error." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-strict-missing-semi-warning t - "Non-nil to warn about semicolon auto-insertion after statement. -Technically this is legal per Ecma-262, but some style guides disallow -depending on it." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-missing-semi-one-line-override nil - "Non-nil to permit missing semicolons in one-line functions. -In one-liner functions such as `function identity(x) {return x}' -people often omit the semicolon for a cleaner look. If you are -such a person, you can suppress the missing-semicolon warning -by setting this variable to t." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-strict-inconsistent-return-warning t - "Non-nil to warn about mixing returns with value-returns. -It's perfectly legal to have a `return' and a `return foo' in the -same function, but it's often an indicator of a bug, and it also -interferes with type inference (in systems that support it.)" - :type 'boolean - :group 'js2-mode) - -(defcustom js2-strict-cond-assign-warning t - "Non-nil to warn about expressions like if (a = b). -This often should have been '==' instead of '='. If the warning -is enabled, you can suppress it on a per-expression basis by -parenthesizing the expression, e.g. if ((a = b)) ..." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-strict-var-redeclaration-warning t - "Non-nil to warn about redeclaring variables in a script or function." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-strict-var-hides-function-arg-warning t - "Non-nil to warn about a var decl hiding a function argument." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-skip-preprocessor-directives nil - "Non-nil to treat lines beginning with # as comments. -Useful for viewing Mozilla JavaScript source code." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-language-version 200 - "Configures what JavaScript language version to recognize. -Currently versions 150, 160, 170, 180 and 200 are supported, -corresponding to JavaScript 1.5, 1.6, 1.7, 1.8 and 2.0 (Harmony), -respectively. In a nutshell, 1.6 adds E4X support, 1.7 adds let, -yield, and Array comprehensions, and 1.8 adds function closures." - :type 'integer - :group 'js2-mode) - -(defcustom js2-instanceof-has-side-effects nil - "If non-nil, treats the instanceof operator as having side effects. -This is useful for xulrunner apps." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-getprop-has-side-effects nil - "If non-nil, treats the getprop operator as having side effects. -This is useful for testing libraries with nontrivial getters and for -compilers that use empty getprops to declare interface properties." - :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 can work properly. - -Note that IntelliJ moves the point, and Eclipse leaves it alone, -so this behavior is customizable." - :group 'js2-mode - :type 'boolean) - -(defcustom js2-allow-rhino-new-expr-initializer t - "Non-nil to support a Rhino's experimental syntactic construct. - -Rhino supports the ability to follow a `new' expression with an object -literal, which is used to set additional properties on the new object -after calling its constructor. Syntax: - - new <expr> [ ( arglist ) ] [initializer] - -Hence, this expression: - - new Object {a: 1, b: 2} - -results in an Object with properties a=1 and b=2. This syntax is -apparently not configurable in Rhino - it's currently always enabled, -as of Rhino version 1.7R2." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-allow-member-expr-as-function-name nil - "Non-nil to support experimental Rhino syntax for function names. - -Rhino supports an experimental syntax configured via the Rhino Context -setting `allowMemberExprAsFunctionName'. The experimental syntax is: - - function <member-expr> ( [ arg-list ] ) { <body> } - -Where member-expr is a non-parenthesized 'member expression', which -is anything at the grammar level of a new-expression or lower, meaning -any expression that does not involve infix or unary operators. - -When <member-expr> is not a simple identifier, then it is syntactic -sugar for assigning the anonymous function to the <member-expr>. Hence, -this code: - - function a.b().c[2] (x, y) { ... } - -is rewritten as: - - a.b().c[2] = function(x, y) {...} - -which doesn't seem particularly useful, but Rhino permits it." - :type 'boolean - :group 'js2-mode) - -;; scanner variables - -(defmacro js2-deflocal (name value &optional comment) - "Define a buffer-local variable NAME with VALUE and COMMENT." - (declare (debug defvar) (doc-string 3)) - `(progn - (defvar ,name ,value ,comment) - (make-variable-buffer-local ',name))) - -(defvar js2-EOF_CHAR -1 - "Represents end of stream. Distinct from js2-EOF token type.") - -;; I originally used symbols to represent tokens, but Rhino uses -;; ints and then sets various flag bits in them, so ints it is. -;; The upshot is that we need a `js2-' prefix in front of each name. -(defvar js2-ERROR -1) -(defvar js2-EOF 0) -(defvar js2-EOL 1) -(defvar js2-ENTERWITH 2) ; begin interpreter bytecodes -(defvar js2-LEAVEWITH 3) -(defvar js2-RETURN 4) -(defvar js2-GOTO 5) -(defvar js2-IFEQ 6) -(defvar js2-IFNE 7) -(defvar js2-SETNAME 8) -(defvar js2-BITOR 9) -(defvar js2-BITXOR 10) -(defvar js2-BITAND 11) -(defvar js2-EQ 12) -(defvar js2-NE 13) -(defvar js2-LT 14) -(defvar js2-LE 15) -(defvar js2-GT 16) -(defvar js2-GE 17) -(defvar js2-LSH 18) -(defvar js2-RSH 19) -(defvar js2-URSH 20) -(defvar js2-ADD 21) ; infix plus -(defvar js2-SUB 22) ; infix minus -(defvar js2-MUL 23) -(defvar js2-DIV 24) -(defvar js2-MOD 25) -(defvar js2-NOT 26) -(defvar js2-BITNOT 27) -(defvar js2-POS 28) ; unary plus -(defvar js2-NEG 29) ; unary minus -(defvar js2-NEW 30) -(defvar js2-DELPROP 31) -(defvar js2-TYPEOF 32) -(defvar js2-GETPROP 33) -(defvar js2-GETPROPNOWARN 34) -(defvar js2-SETPROP 35) -(defvar js2-GETELEM 36) -(defvar js2-SETELEM 37) -(defvar js2-CALL 38) -(defvar js2-NAME 39) ; an identifier -(defvar js2-NUMBER 40) -(defvar js2-STRING 41) -(defvar js2-NULL 42) -(defvar js2-THIS 43) -(defvar js2-FALSE 44) -(defvar js2-TRUE 45) -(defvar js2-SHEQ 46) ; shallow equality (===) -(defvar js2-SHNE 47) ; shallow inequality (!==) -(defvar js2-REGEXP 48) -(defvar js2-BINDNAME 49) -(defvar js2-THROW 50) -(defvar js2-RETHROW 51) ; rethrow caught exception: catch (e if ) uses it -(defvar js2-IN 52) -(defvar js2-INSTANCEOF 53) -(defvar js2-LOCAL_LOAD 54) -(defvar js2-GETVAR 55) -(defvar js2-SETVAR 56) -(defvar js2-CATCH_SCOPE 57) -(defvar js2-ENUM_INIT_KEYS 58) ; FIXME: what are these? -(defvar js2-ENUM_INIT_VALUES 59) -(defvar js2-ENUM_INIT_ARRAY 60) -(defvar js2-ENUM_NEXT 61) -(defvar js2-ENUM_ID 62) -(defvar js2-THISFN 63) -(defvar js2-RETURN_RESULT 64) ; to return previously stored return result -(defvar js2-ARRAYLIT 65) ; array literal -(defvar js2-OBJECTLIT 66) ; object literal -(defvar js2-GET_REF 67) ; *reference -(defvar js2-SET_REF 68) ; *reference = something -(defvar js2-DEL_REF 69) ; delete reference -(defvar js2-REF_CALL 70) ; f(args) = something or f(args)++ -(defvar js2-REF_SPECIAL 71) ; reference for special properties like __proto -(defvar js2-YIELD 72) ; JS 1.7 yield pseudo keyword - -;; XML support -(defvar js2-DEFAULTNAMESPACE 73) -(defvar js2-ESCXMLATTR 74) -(defvar js2-ESCXMLTEXT 75) -(defvar js2-REF_MEMBER 76) ; Reference for x.@y, x..y etc. -(defvar js2-REF_NS_MEMBER 77) ; Reference for x.ns::y, x..ns::y etc. -(defvar js2-REF_NAME 78) ; Reference for @y, @[y] etc. -(defvar js2-REF_NS_NAME 79) ; Reference for ns::y, @ns::y@[y] etc. - -(defvar js2-first-bytecode js2-ENTERWITH) -(defvar js2-last-bytecode js2-REF_NS_NAME) - -(defvar js2-TRY 80) -(defvar js2-SEMI 81) ; semicolon -(defvar js2-LB 82) ; left and right brackets -(defvar js2-RB 83) -(defvar js2-LC 84) ; left and right curly-braces -(defvar js2-RC 85) -(defvar js2-LP 86) ; left and right parens -(defvar js2-RP 87) -(defvar js2-COMMA 88) ; comma operator - -(defvar js2-ASSIGN 89) ; simple assignment (=) -(defvar js2-ASSIGN_BITOR 90) ; |= -(defvar js2-ASSIGN_BITXOR 91) ; ^= -(defvar js2-ASSIGN_BITAND 92) ; &= -(defvar js2-ASSIGN_LSH 93) ; <<= -(defvar js2-ASSIGN_RSH 94) ; >>= -(defvar js2-ASSIGN_URSH 95) ; >>>= -(defvar js2-ASSIGN_ADD 96) ; += -(defvar js2-ASSIGN_SUB 97) ; -= -(defvar js2-ASSIGN_MUL 98) ; *= -(defvar js2-ASSIGN_DIV 99) ; /= -(defvar js2-ASSIGN_MOD 100) ; %= -(defvar js2-ASSIGN_EXPON 101) - -(defvar js2-first-assign js2-ASSIGN) -(defvar js2-last-assign js2-ASSIGN_EXPON) - -(defvar js2-COLON 102) -(defvar js2-OR 103) ; logical or (||) -(defvar js2-AND 104) ; logical and (&&) -(defvar js2-INC 105) ; increment/decrement (++ --) -(defvar js2-DEC 106) -(defvar js2-DOT 107) ; member operator (.) -(defvar js2-FUNCTION 108) ; function keyword -(defvar js2-EXPORT 109) ; export keyword -(defvar js2-IMPORT 110) ; import keyword -(defvar js2-IF 111) ; if keyword -(defvar js2-ELSE 112) ; else keyword -(defvar js2-SWITCH 113) ; switch keyword -(defvar js2-CASE 114) ; case keyword -(defvar js2-DEFAULT 115) ; default keyword -(defvar js2-WHILE 116) ; while keyword -(defvar js2-DO 117) ; do keyword -(defvar js2-FOR 118) ; for keyword -(defvar js2-BREAK 119) ; break keyword -(defvar js2-CONTINUE 120) ; continue keyword -(defvar js2-VAR 121) ; var keyword -(defvar js2-WITH 122) ; with keyword -(defvar js2-CATCH 123) ; catch keyword -(defvar js2-FINALLY 124) ; finally keyword -(defvar js2-VOID 125) ; void keyword -(defvar js2-RESERVED 126) ; reserved keywords - -(defvar js2-EMPTY 127) - -;; Types used for the parse tree - never returned by scanner. - -(defvar js2-BLOCK 128) ; statement block -(defvar js2-LABEL 129) ; label -(defvar js2-TARGET 130) -(defvar js2-LOOP 131) -(defvar js2-EXPR_VOID 132) ; expression statement in functions -(defvar js2-EXPR_RESULT 133) ; expression statement in scripts -(defvar js2-JSR 134) -(defvar js2-SCRIPT 135) ; top-level node for entire script -(defvar js2-TYPEOFNAME 136) ; for typeof(simple-name) -(defvar js2-USE_STACK 137) -(defvar js2-SETPROP_OP 138) ; x.y op= something -(defvar js2-SETELEM_OP 139) ; x[y] op= something -(defvar js2-LOCAL_BLOCK 140) -(defvar js2-SET_REF_OP 141) ; *reference op= something - -;; For XML support: -(defvar js2-DOTDOT 142) ; member operator (..) -(defvar js2-COLONCOLON 143) ; namespace::name -(defvar js2-XML 144) ; XML type -(defvar js2-DOTQUERY 145) ; .() -- e.g., x.emps.emp.(name == "terry") -(defvar js2-XMLATTR 146) ; @ -(defvar js2-XMLEND 147) - -;; Optimizer-only tokens -(defvar js2-TO_OBJECT 148) -(defvar js2-TO_DOUBLE 149) - -(defvar js2-GET 150) ; JS 1.5 get pseudo keyword -(defvar js2-SET 151) ; JS 1.5 set pseudo keyword -(defvar js2-LET 152) ; JS 1.7 let pseudo keyword -(defvar js2-CONST 153) -(defvar js2-SETCONST 154) -(defvar js2-SETCONSTVAR 155) -(defvar js2-ARRAYCOMP 156) -(defvar js2-LETEXPR 157) -(defvar js2-WITHEXPR 158) -(defvar js2-DEBUGGER 159) - -(defvar js2-COMMENT 160) -(defvar js2-TRIPLEDOT 161) ; for rest parameter -(defvar js2-ARROW 162) ; function arrow (=>) -(defvar js2-CLASS 163) -(defvar js2-EXTENDS 164) -(defvar js2-SUPER 165) -(defvar js2-TEMPLATE_HEAD 166) ; part of template literal before substitution -(defvar js2-NO_SUBS_TEMPLATE 167) ; template literal without substitutions -(defvar js2-TAGGED_TEMPLATE 168) ; tagged template literal - -(defvar js2-AWAIT 169) ; await (pseudo keyword) - -(defvar js2-HOOK 170) ; conditional (?:) -(defvar js2-EXPON 171) - -(defconst js2-num-tokens (1+ js2-EXPON)) - -(defconst js2-debug-print-trees nil) - -;; Rhino accepts any string or stream as input. Emacs character -;; processing works best in buffers, so we'll assume the input is a -;; buffer. JavaScript strings can be copied into temp buffers before -;; scanning them. - -;; Buffer-local variables yield much cleaner code than using `defstruct'. -;; They're the Emacs equivalent of instance variables, more or less. - -(js2-deflocal js2-ts-dirty-line nil - "Token stream buffer-local variable. -Indicates stuff other than whitespace since start of line.") - -(js2-deflocal js2-ts-hit-eof nil - "Token stream buffer-local variable.") - -;; FIXME: Unused. -(js2-deflocal js2-ts-line-start 0 - "Token stream buffer-local variable.") - -(js2-deflocal js2-ts-lineno 1 - "Token stream buffer-local variable.") - -;; FIXME: Unused. -(js2-deflocal js2-ts-line-end-char -1 - "Token stream buffer-local variable.") - -(js2-deflocal js2-ts-cursor 1 ; emacs buffers are 1-indexed - "Token stream buffer-local variable. -Current scan position.") - -;; FIXME: Unused. -(js2-deflocal js2-ts-is-xml-attribute nil - "Token stream buffer-local variable.") - -(js2-deflocal js2-ts-xml-is-tag-content nil - "Token stream buffer-local variable.") - -(js2-deflocal js2-ts-xml-open-tags-count 0 - "Token stream buffer-local variable.") - -(js2-deflocal js2-ts-string-buffer nil - "Token stream buffer-local variable. -List of chars built up while scanning various tokens.") - -(cl-defstruct (js2-token - (:constructor make-js2-token (beg))) - "Value returned from the token stream." - (type js2-EOF) - (beg 1) - (end -1) - (string "") - number - number-base - number-legacy-octal-p - regexp-flags - comment-type - follows-eol-p) - -;; Have to call `js2-init-scanner' to initialize the values. -(js2-deflocal js2-ti-tokens nil) -(js2-deflocal js2-ti-tokens-cursor nil) -(js2-deflocal js2-ti-lookahead nil) - -(cl-defstruct (js2-ts-state - (:constructor make-js2-ts-state (&key (lineno js2-ts-lineno) - (cursor js2-ts-cursor) - (tokens (copy-sequence js2-ti-tokens)) - (tokens-cursor js2-ti-tokens-cursor) - (lookahead js2-ti-lookahead)))) - lineno - cursor - tokens - tokens-cursor - lookahead) - -;;; Parser variables - -(js2-deflocal js2-parsed-errors nil - "List of errors produced during scanning/parsing.") - -(js2-deflocal js2-parsed-warnings nil - "List of warnings produced during scanning/parsing.") - -(js2-deflocal js2-recover-from-parse-errors t - "Non-nil to continue parsing after a syntax error. - -In recovery mode, the AST will be built in full, and any error -nodes will be flagged with appropriate error information. If -this flag is nil, a syntax error will result in an error being -signaled. - -The variable is automatically buffer-local, because different -modes that use the parser will need different settings.") - -(js2-deflocal js2-parse-hook nil - "List of callbacks for receiving parsing progress.") - -(defvar js2-parse-finished-hook nil - "List of callbacks to notify when parsing finishes. -Not called if parsing was interrupted.") - -(js2-deflocal js2-is-eval-code nil - "True if we're evaluating code in a string. -If non-nil, the tokenizer will record the token text, and the AST nodes -will record their source text. Off by default for IDE modes, since the -text is available in the buffer.") - -(defvar js2-parse-ide-mode t - "Non-nil if the parser is being used for `js2-mode'. -If non-nil, the parser will set text properties for fontification -and the syntax table. The value should be nil when using the -parser as a frontend to an interpreter or byte compiler.") - -;;; Parser instance variables (buffer-local vars for js2-parse) - -(defconst js2-ti-after-eol (lsh 1 16) - "Flag: first token of the source line.") - -;; Inline Rhino's CompilerEnvirons vars as buffer-locals. - -(js2-deflocal js2-compiler-generate-debug-info t) -(js2-deflocal js2-compiler-use-dynamic-scope nil) -(js2-deflocal js2-compiler-reserved-keywords-as-identifier nil) -(js2-deflocal js2-compiler-xml-available t) -(js2-deflocal js2-compiler-optimization-level 0) -(js2-deflocal js2-compiler-generating-source t) -(js2-deflocal js2-compiler-strict-mode nil) -(js2-deflocal js2-compiler-report-warning-as-error nil) -(js2-deflocal js2-compiler-generate-observer-count nil) -(js2-deflocal js2-compiler-activation-names nil) - -;; SKIP: sourceURI - -;; There's a compileFunction method in Context.java - may need it. -(js2-deflocal js2-called-by-compile-function nil - "True if `js2-parse' was called by `js2-compile-function'. -Will only be used when we finish implementing the interpreter.") - -;; SKIP: ts (we just call `js2-init-scanner' and use its vars) - -;; SKIP: node factory - we're going to just call functions directly, -;; and eventually go to a unified AST format. - -(js2-deflocal js2-nesting-of-function 0) - -(js2-deflocal js2-recorded-identifiers nil - "Tracks identifiers found during parsing.") - -(js2-deflocal js2-is-in-destructuring nil - "True while parsing destructuring expression.") - -(js2-deflocal js2-in-use-strict-directive nil - "True while inside a script or function under strict mode.") - -(defcustom js2-global-externs nil - "A list of any extern names you'd like to consider always declared. -This list is global and is used by all `js2-mode' files. -You can create buffer-local externs list using `js2-additional-externs'." - :type 'list - :group 'js2-mode) - -(defcustom js2-include-browser-externs t - "Non-nil to include browser externs in the master externs list. -If you work on JavaScript files that are not intended for browsers, -such as Mozilla Rhino server-side JavaScript, set this to nil. -See `js2-additional-externs' for more information about externs." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-include-rhino-externs nil - "Non-nil to include Mozilla Rhino externs in the master externs list. -See `js2-additional-externs' for more information about externs." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-include-node-externs nil - "Non-nil to include Node.js externs in the master externs list. -See `js2-additional-externs' for more information about externs." - :type 'boolean - :group 'js2-mode) - -(js2-deflocal js2-additional-externs nil - "A buffer-local list of additional external declarations. -It is used to decide whether variables are considered undeclared -for purposes of highlighting. See `js2-highlight-undeclared-vars'. - -Each entry is a Lisp string. The string should be the fully qualified -name of an external entity. All externs should be added to this list, -so that as js2-mode's processing improves it can take advantage of them. - -You may want to declare your externs in three ways. -First, you can add externs that are valid for all your JavaScript files. -You should probably do this by adding them to `js2-global-externs', which -is a global list used for all js2-mode files. - -Next, you can add a function to `js2-init-hook' that adds additional -externs appropriate for the specific file, perhaps based on its path. -These should go in `js2-additional-externs', which is buffer-local. - -Third, you can use JSLint's global declaration, as long as -`js2-include-jslint-globals' is non-nil, which see. - -Finally, you can add a function to `js2-post-parse-callbacks', -which is called after parsing completes, and `js2-mode-ast' is bound to -the root of the parse tree. At this stage you can set up an AST -node visitor using `js2-visit-ast' and examine the parse tree -for specific import patterns that may imply the existence of -other externs, possibly tied to your build system. These should also -be added to `js2-additional-externs'. - -Your post-parse callback may of course also use the simpler and -faster (but perhaps less robust) approach of simply scanning the -buffer text for your imports, using regular expressions.") - -(put 'js2-additional-externs 'safe-local-variable - (lambda (val) (cl-every #'stringp val))) - -;; SKIP: decompiler -;; SKIP: encoded-source - -;;; The following variables are per-function and should be saved/restored -;;; during function parsing... - -(js2-deflocal js2-current-script-or-fn nil) -(js2-deflocal js2-current-scope nil) -(js2-deflocal js2-nesting-of-with 0) -(js2-deflocal js2-label-set nil - "An alist mapping label names to nodes.") - -(js2-deflocal js2-loop-set nil) -(js2-deflocal js2-loop-and-switch-set nil) -(js2-deflocal js2-has-return-value nil) -(js2-deflocal js2-end-flags 0) - -;;; ...end of per function variables - -;; These flags enumerate the possible ways a statement/function can -;; terminate. These flags are used by endCheck() and by the Parser to -;; detect inconsistent return usage. -;; -;; END_UNREACHED is reserved for code paths that are assumed to always be -;; able to execute (example: throw, continue) -;; -;; END_DROPS_OFF indicates if the statement can transfer control to the -;; next one. Statement such as return dont. A compound statement may have -;; some branch that drops off control to the next statement. -;; -;; END_RETURNS indicates that the statement can return (without arguments) -;; END_RETURNS_VALUE indicates that the statement can return a value. -;; -;; A compound statement such as -;; if (condition) { -;; return value; -;; } -;; Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck() - -(defconst js2-end-unreached #x0) -(defconst js2-end-drops-off #x1) -(defconst js2-end-returns #x2) -(defconst js2-end-returns-value #x4) - -;; Rhino awkwardly passes a statementLabel parameter to the -;; statementHelper() function, the main statement parser, which -;; is then used by quite a few of the sub-parsers. We just make -;; it a buffer-local variable and make sure it's cleaned up properly. -(js2-deflocal js2-labeled-stmt nil) ; type `js2-labeled-stmt-node' - -;; Similarly, Rhino passes an inForInit boolean through about half -;; the expression parsers. We use a dynamically-scoped variable, -;; which makes it easier to funcall the parsers individually without -;; worrying about whether they take the parameter or not. -(js2-deflocal js2-in-for-init nil) -(js2-deflocal js2-temp-name-counter 0) -(js2-deflocal js2-parse-stmt-count 0) - -(defsubst js2-get-next-temp-name () - (format "$%d" (cl-incf js2-temp-name-counter))) - -(defvar js2-parse-interruptable-p t - "Set this to nil to force parse to continue until finished. -This will mostly be useful for interpreters.") - -(defvar js2-statements-per-pause 50 - "Pause after this many statements to check for user input. -If user input is pending, stop the parse and discard the tree. -This makes for a smoother user experience for large files. -You may have to wait a second or two before the highlighting -and error-reporting appear, but you can always type ahead if -you wish. This appears to be more or less how Eclipse, IntelliJ -and other editors work.") - -(js2-deflocal js2-record-comments t - "Instructs the scanner to record comments in `js2-scanned-comments'.") - -(js2-deflocal js2-scanned-comments nil - "List of all comments from the current parse.") - -(defcustom js2-mode-indent-inhibit-undo nil - "Non-nil to disable collection of Undo information when indenting lines. -Some users have requested this behavior. It's nil by default because -other Emacs modes don't work this way." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-mode-indent-ignore-first-tab nil - "If non-nil, ignore first TAB keypress if we look indented properly. -It's fairly common for users to navigate to an already-indented line -and press TAB for reassurance that it's been indented. For this class -of users, we want the first TAB press on a line to be ignored if the -line is already indented to one of the precomputed alternatives. - -This behavior is only partly implemented. If you TAB-indent a line, -navigate to another line, and then navigate back, it fails to clear -the last-indented variable, so it thinks you've already hit TAB once, -and performs the indent. A full solution would involve getting on the -point-motion hooks for the entire buffer. If we come across another -use cases that requires watching point motion, I'll consider doing it. - -If you set this variable to nil, then the TAB key will always change -the indentation of the current line, if more than one alternative -indentation spot exists." - :type 'boolean - :group 'js2-mode) - -(defvar js2-indent-hook nil - "A hook for user-defined indentation rules. - -Functions on this hook should expect two arguments: (LIST INDEX) -The LIST argument is the list of computed indentation points for -the current line. INDEX is the list index of the indentation point -that `js2-bounce-indent' plans to use. If INDEX is nil, then the -indent function is not going to change the current line indentation. - -If a hook function on this list returns a non-nil value, then -`js2-bounce-indent' assumes the hook function has performed its own -indentation, and will do nothing. If all hook functions on the list -return nil, then `js2-bounce-indent' will use its computed indentation -and reindent the line. - -When hook functions on this hook list are called, the variable -`js2-mode-ast' may or may not be set, depending on whether the -parse tree is available. If the variable is nil, you can pass a -callback to `js2-mode-wait-for-parse', and your callback will be -called after the new parse tree is built. This can take some time -in large files.") - -(defface js2-warning - `((((class color) (background light)) - (:underline "orange")) - (((class color) (background dark)) - (:underline "orange")) - (t (:underline t))) - "Face for JavaScript warnings." - :group 'js2-mode) - -(defface js2-error - `((((class color) (background light)) - (:foreground "red")) - (((class color) (background dark)) - (:foreground "red")) - (t (:foreground "red"))) - "Face for JavaScript errors." - :group 'js2-mode) - -(defface js2-jsdoc-tag - '((t :foreground "SlateGray")) - "Face used to highlight @whatever tags in jsdoc comments." - :group 'js2-mode) - -(defface js2-jsdoc-type - '((t :foreground "SteelBlue")) - "Face used to highlight {FooBar} types in jsdoc comments." - :group 'js2-mode) - -(defface js2-jsdoc-value - '((t :foreground "PeachPuff3")) - "Face used to highlight tag values in jsdoc comments." - :group 'js2-mode) - -(defface js2-function-param - '((t :foreground "SeaGreen")) - "Face used to highlight function parameters in javascript." - :group 'js2-mode) - -(defface js2-function-call - '((t :inherit default)) - "Face used to highlight function name in calls." - :group 'js2-mode) - -(defface js2-object-property - '((t :inherit default)) - "Face used to highlight named property in object literal." - :group 'js2-mode) - -(defface js2-object-property-access - '((t :inherit js2-object-property)) - "Face used to highlight property access with dot on an object." - :group 'js2-mode) - -(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 - '((t :foreground "PeachPuff3")) - "Face used to highlight calls to private methods in javascript. -Not currently used." - :group 'js2-mode) - -(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 - '((((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 - '((((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-external-variable - '((t :foreground "orange")) - "Face used to highlight undeclared variable identifiers.") - -(defcustom js2-init-hook nil - ;; FIXME: We don't really need this anymore. - "List of functions to be called after `js2-mode' or -`js2-minor-mode' has initialized all variables, before parsing -the buffer for the first time." - :type 'hook - :group 'js2-mode - :version "20130608") - -(defcustom js2-post-parse-callbacks nil - "List of callback functions invoked after parsing finishes. -Currently, the main use for this function is to add synthetic -declarations to `js2-recorded-identifiers', which see." - :type 'hook - :group 'js2-mode) - -(defcustom js2-build-imenu-callbacks nil - "List of functions called during Imenu index generation. -It's a good place to add additional entries to it, using -`js2-record-imenu-entry'." - :type 'hook - :group 'js2-mode) - -(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." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-warn-about-unused-function-arguments nil - "Non-nil to treat function arguments like declared-but-unused variables." - :type 'booleanp - :group 'js2-mode) - -(defcustom js2-include-jslint-globals t - "Non-nil to include the identifiers from JSLint global -declaration (see http://www.jslint.com/help.html#global) in the -buffer-local externs list. See `js2-additional-externs' for more -information." - :type 'boolean - :group 'js2-mode) - -(defcustom js2-include-jslint-declaration-externs t - "Non-nil to include the identifiers JSLint assumes to be there -under certain declarations in the buffer-local externs list. See -`js2-additional-externs' for more information." - :type 'boolean - :group 'js2-mode) - -(defvar js2-mode-map - (let ((map (make-sparse-keymap))) - (define-key map [remap indent-new-comment-line] #'js2-line-break) - (define-key map (kbd "C-c C-e") #'js2-mode-hide-element) - (define-key map (kbd "C-c C-s") #'js2-mode-show-element) - (define-key map (kbd "C-c C-a") #'js2-mode-show-all) - (define-key map (kbd "C-c C-f") #'js2-mode-toggle-hide-functions) - (define-key map (kbd "C-c C-t") #'js2-mode-toggle-hide-comments) - (define-key map (kbd "C-c C-o") #'js2-mode-toggle-element) - (define-key map (kbd "C-c C-w") #'js2-mode-toggle-warnings-and-errors) - (define-key map [down-mouse-3] #'js2-down-mouse-3) - (define-key map [remap js-find-symbol] #'js2-jump-to-definition) - - (define-key map [menu-bar javascript] - (cons "JavaScript" (make-sparse-keymap "JavaScript"))) - - (define-key map [menu-bar javascript customize-js2-mode] - '(menu-item "Customize js2-mode" js2-mode-customize - :help "Customize the behavior of this mode")) - - (define-key map [menu-bar javascript js2-force-refresh] - '(menu-item "Force buffer refresh" js2-mode-reset - :help "Re-parse the buffer from scratch")) - - (define-key map [menu-bar javascript separator-2] - '("--")) - - (define-key map [menu-bar javascript next-error] - '(menu-item "Next warning or error" next-error - :enabled (and js2-mode-ast - (or (js2-ast-root-errors js2-mode-ast) - (js2-ast-root-warnings js2-mode-ast))) - :help "Move to next warning or error")) - - (define-key map [menu-bar javascript display-errors] - '(menu-item "Show errors and warnings" js2-mode-display-warnings-and-errors - :visible (not js2-mode-show-parse-errors) - :help "Turn on display of warnings and errors")) - - (define-key map [menu-bar javascript hide-errors] - '(menu-item "Hide errors and warnings" js2-mode-hide-warnings-and-errors - :visible js2-mode-show-parse-errors - :help "Turn off display of warnings and errors")) - - (define-key map [menu-bar javascript separator-1] - '("--")) - - (define-key map [menu-bar javascript js2-toggle-function] - '(menu-item "Show/collapse element" js2-mode-toggle-element - :help "Hide or show function body or comment")) - - (define-key map [menu-bar javascript show-comments] - '(menu-item "Show block comments" js2-mode-toggle-hide-comments - :visible js2-mode-comments-hidden - :help "Expand all hidden block comments")) - - (define-key map [menu-bar javascript hide-comments] - '(menu-item "Hide block comments" js2-mode-toggle-hide-comments - :visible (not js2-mode-comments-hidden) - :help "Show block comments as /*...*/")) - - (define-key map [menu-bar javascript show-all-functions] - '(menu-item "Show function bodies" js2-mode-toggle-hide-functions - :visible js2-mode-functions-hidden - :help "Expand all hidden function bodies")) - - (define-key map [menu-bar javascript hide-all-functions] - '(menu-item "Hide function bodies" js2-mode-toggle-hide-functions - :visible (not js2-mode-functions-hidden) - :help "Show {...} for all top-level function bodies")) - - map) - "Keymap used in `js2-mode' buffers.") - -(defcustom js2-bounce-indent-p nil - "Non-nil to bind `js2-indent-bounce' and `js2-indent-bounce-backward'. -They will augment the default indent-line behavior with cycling -among several computed alternatives. See the function -`js2-bounce-indent' for details. The above commands will be -bound to TAB and backtab." - :type 'boolean - :group 'js2-mode - :set (lambda (sym value) - (set-default sym value) - (let ((map js2-mode-map)) - (if (not value) - (progn - (define-key map "\t" nil) - (define-key map (kbd "<backtab>") nil)) - (define-key map "\t" #'js2-indent-bounce) - (define-key map (kbd "<backtab>") #'js2-indent-bounce-backward))))) - -(defconst js2-mode-identifier-re "[[:alpha:]_$][[:alnum:]_$]*") - -(defvar js2-mode-//-comment-re "^\\(\\s-*\\)//.+" - "Matches a //-comment line. Must be first non-whitespace on line. -First match-group is the leading whitespace.") - -(defvar js2-mode-hook nil) - -(js2-deflocal js2-mode-ast nil "Private variable.") -(js2-deflocal js2-mode-parse-timer nil "Private variable.") -(js2-deflocal js2-mode-buffer-dirty-p nil "Private variable.") -(js2-deflocal js2-mode-parsing nil "Private variable.") -(js2-deflocal js2-mode-node-overlay nil) - -(defvar js2-mode-show-overlay js2-mode-dev-mode-p - "Debug: Non-nil to highlight AST nodes on mouse-down.") - -(js2-deflocal js2-mode-fontifications nil "Private variable") -(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") - -(defvar js2-mode-verbose-parse-p js2-mode-dev-mode-p - "Non-nil to emit status messages during parsing.") - -(defvar js2-mode-functions-hidden nil "Private variable.") -(defvar js2-mode-comments-hidden nil "Private variable.") - -(defvar js2-mode-syntax-table - (let ((table (make-syntax-table))) - (c-populate-syntax-table table) - (modify-syntax-entry ?` "\"" table) - table) - "Syntax table used in `js2-mode' buffers.") - -(defvar js2-mode-abbrev-table nil - "Abbrev table in use in `js2-mode' buffers.") -(define-abbrev-table 'js2-mode-abbrev-table ()) - -(defvar js2-mode-pending-parse-callbacks nil - "List of functions waiting to be notified that parse is finished.") - -(defvar js2-mode-last-indented-line -1) - -;;; Localizable error and warning messages - -;; Messages are copied from Rhino's Messages.properties. -;; Many of the Java-specific messages have been elided. -;; Add any js2-specific ones at the end, so we can keep -;; this file synced with changes to Rhino's. - -(defvar js2-message-table - (make-hash-table :test 'equal :size 250) - "Contains localized messages for `js2-mode'.") - -;; TODO(stevey): construct this table at compile-time. -(defmacro js2-msg (key &rest strings) - `(puthash ,key (concat ,@strings) - js2-message-table)) - -(defun js2-get-msg (msg-key) - "Look up a localized message. -MSG-KEY is a list of (MSG ARGS). If the message takes parameters, -the correct number of ARGS must be provided." - (let* ((key (if (listp msg-key) (car msg-key) msg-key)) - (args (if (listp msg-key) (cdr msg-key))) - (msg (gethash key js2-message-table))) - (if msg - (apply #'format msg args) - key))) ; default to showing the key - -(js2-msg "msg.dup.parms" - "Duplicate parameter name '%s'.") - -(js2-msg "msg.too.big.jump" - "Program too complex: jump offset too big.") - -(js2-msg "msg.too.big.index" - "Program too complex: internal index exceeds 64K limit.") - -(js2-msg "msg.while.compiling.fn" - "Encountered code generation error while compiling function '%s': %s") - -(js2-msg "msg.while.compiling.script" - "Encountered code generation error while compiling script: %s") - -;; Context -(js2-msg "msg.ctor.not.found" - "Constructor for '%s' not found.") - -(js2-msg "msg.not.ctor" - "'%s' is not a constructor.") - -;; FunctionObject -(js2-msg "msg.varargs.ctor" - "Method or constructor '%s' must be static " - "with the signature (Context cx, Object[] args, " - "Function ctorObj, boolean inNewExpr) " - "to define a variable arguments constructor.") - -(js2-msg "msg.varargs.fun" - "Method '%s' must be static with the signature " - "(Context cx, Scriptable thisObj, Object[] args, Function funObj) " - "to define a variable arguments function.") - -(js2-msg "msg.incompat.call" - "Method '%s' called on incompatible object.") - -(js2-msg "msg.bad.parms" - "Unsupported parameter type '%s' in method '%s'.") - -(js2-msg "msg.bad.method.return" - "Unsupported return type '%s' in method '%s'.") - -(js2-msg "msg.bad.ctor.return" - "Construction of objects of type '%s' is not supported.") - -(js2-msg "msg.no.overload" - "Method '%s' occurs multiple times in class '%s'.") - -(js2-msg "msg.method.not.found" - "Method '%s' not found in '%s'.") - -;; IRFactory - -(js2-msg "msg.bad.for.in.lhs" - "Invalid left-hand side of for..in loop.") - -(js2-msg "msg.mult.index" - "Only one variable allowed in for..in loop.") - -(js2-msg "msg.bad.for.in.destruct" - "Left hand side of for..in loop must be an array of " - "length 2 to accept key/value pair.") - -(js2-msg "msg.cant.convert" - "Can't convert to type '%s'.") - -(js2-msg "msg.bad.assign.left" - "Invalid assignment left-hand side.") - -(js2-msg "msg.bad.decr" - "Invalid decrement operand.") - -(js2-msg "msg.bad.incr" - "Invalid increment operand.") - -(js2-msg "msg.bad.yield" - "yield must be in a function.") - -(js2-msg "msg.bad.await" - "await must be in async functions.") - -;; NativeGlobal -(js2-msg "msg.cant.call.indirect" - "Function '%s' must be called directly, and not by way of a " - "function of another name.") - -(js2-msg "msg.eval.nonstring" - "Calling eval() with anything other than a primitive " - "string value will simply return the value. " - "Is this what you intended?") - -(js2-msg "msg.eval.nonstring.strict" - "Calling eval() with anything other than a primitive " - "string value is not allowed in strict mode.") - -(js2-msg "msg.bad.destruct.op" - "Invalid destructuring assignment operator") - -;; NativeCall -(js2-msg "msg.only.from.new" - "'%s' may only be invoked from a `new' expression.") - -(js2-msg "msg.deprec.ctor" - "The '%s' constructor is deprecated.") - -;; NativeFunction -(js2-msg "msg.no.function.ref.found" - "no source found to decompile function reference %s") - -(js2-msg "msg.arg.isnt.array" - "second argument to Function.prototype.apply must be an array") - -;; NativeGlobal -(js2-msg "msg.bad.esc.mask" - "invalid string escape mask") - -;; NativeRegExp -(js2-msg "msg.bad.quant" - "Invalid quantifier %s") - -(js2-msg "msg.overlarge.backref" - "Overly large back reference %s") - -(js2-msg "msg.overlarge.min" - "Overly large minimum %s") - -(js2-msg "msg.overlarge.max" - "Overly large maximum %s") - -(js2-msg "msg.zero.quant" - "Zero quantifier %s") - -(js2-msg "msg.max.lt.min" - "Maximum %s less than minimum") - -(js2-msg "msg.unterm.quant" - "Unterminated quantifier %s") - -(js2-msg "msg.unterm.paren" - "Unterminated parenthetical %s") - -(js2-msg "msg.unterm.class" - "Unterminated character class %s") - -(js2-msg "msg.bad.range" - "Invalid range in character class.") - -(js2-msg "msg.trail.backslash" - "Trailing \\ in regular expression.") - -(js2-msg "msg.re.unmatched.right.paren" - "unmatched ) in regular expression.") - -(js2-msg "msg.no.regexp" - "Regular expressions are not available.") - -(js2-msg "msg.bad.backref" - "back-reference exceeds number of capturing parentheses.") - -(js2-msg "msg.bad.regexp.compile" - "Only one argument may be specified if the first " - "argument to RegExp.prototype.compile is a RegExp object.") - -;; Parser -(js2-msg "msg.got.syntax.errors" - "Compilation produced %s syntax errors.") - -(js2-msg "msg.var.redecl" - "Redeclaration of var %s.") - -(js2-msg "msg.const.redecl" - "TypeError: redeclaration of const %s.") - -(js2-msg "msg.let.redecl" - "TypeError: redeclaration of variable %s.") - -(js2-msg "msg.parm.redecl" - "TypeError: redeclaration of formal parameter %s.") - -(js2-msg "msg.fn.redecl" - "TypeError: redeclaration of function %s.") - -(js2-msg "msg.let.decl.not.in.block" - "SyntaxError: let declaration not directly within block") - -(js2-msg "msg.mod.import.decl.at.top.level" - "SyntaxError: import declarations may only appear at the top level") - -(js2-msg "msg.mod.as.after.reserved.word" - "SyntaxError: missing keyword 'as' after reserved word %s") - -(js2-msg "msg.mod.rc.after.import.spec.list" - "SyntaxError: missing '}' after module specifier list") - -(js2-msg "msg.mod.from.after.import.spec.set" - "SyntaxError: missing keyword 'from' after import specifier set") - -(js2-msg "msg.mod.declaration.after.import" - "SyntaxError: missing declaration after 'import' keyword") - -(js2-msg "msg.mod.spec.after.from" - "SyntaxError: missing module specifier after 'from' keyword") - -(js2-msg "msg.mod.export.decl.at.top.level" - "SyntaxError: export declarations may only appear at top level") - -(js2-msg "msg.mod.rc.after.export.spec.list" - "SyntaxError: missing '}' after export specifier list") - -;; NodeTransformer -(js2-msg "msg.dup.label" - "duplicated label") - -(js2-msg "msg.undef.label" - "undefined label") - -(js2-msg "msg.bad.break" - "unlabelled break must be inside loop or switch") - -(js2-msg "msg.continue.outside" - "continue must be inside loop") - -(js2-msg "msg.continue.nonloop" - "continue can only use labels of iteration statements") - -(js2-msg "msg.bad.throw.eol" - "Line terminator is not allowed between the throw " - "keyword and throw expression.") - -(js2-msg "msg.unnamed.function.stmt" ; added by js2-mode - "function statement requires a name") - -(js2-msg "msg.no.paren.parms" - "missing ( before function parameters.") - -(js2-msg "msg.no.parm" - "missing formal parameter") - -(js2-msg "msg.no.paren.after.parms" - "missing ) after formal parameters") - -(js2-msg "msg.no.default.after.default.param" ; added by js2-mode - "parameter without default follows parameter with default") - -(js2-msg "msg.param.after.rest" ; added by js2-mode - "parameter after rest parameter") - -(js2-msg "msg.bad.arrow.args" ; added by js2-mode - "invalid arrow-function arguments (parentheses around the arrow-function may help)") - -(js2-msg "msg.no.brace.body" - "missing '{' before function body") - -(js2-msg "msg.no.brace.after.body" - "missing } after function body") - -(js2-msg "msg.no.paren.cond" - "missing ( before condition") - -(js2-msg "msg.no.paren.after.cond" - "missing ) after condition") - -(js2-msg "msg.no.semi.stmt" - "missing ; before statement") - -(js2-msg "msg.missing.semi" - "missing ; after statement") - -(js2-msg "msg.no.name.after.dot" - "missing name after . operator") - -(js2-msg "msg.no.name.after.coloncolon" - "missing name after :: operator") - -(js2-msg "msg.no.name.after.dotdot" - "missing name after .. operator") - -(js2-msg "msg.no.name.after.xmlAttr" - "missing name after .@") - -(js2-msg "msg.no.bracket.index" - "missing ] in index expression") - -(js2-msg "msg.no.paren.switch" - "missing ( before switch expression") - -(js2-msg "msg.no.paren.after.switch" - "missing ) after switch expression") - -(js2-msg "msg.no.brace.switch" - "missing '{' before switch body") - -(js2-msg "msg.bad.switch" - "invalid switch statement") - -(js2-msg "msg.no.colon.case" - "missing : after case expression") - -(js2-msg "msg.double.switch.default" - "double default label in the switch statement") - -(js2-msg "msg.no.while.do" - "missing while after do-loop body") - -(js2-msg "msg.no.paren.for" - "missing ( after for") - -(js2-msg "msg.no.semi.for" - "missing ; after for-loop initializer") - -(js2-msg "msg.no.semi.for.cond" - "missing ; after for-loop condition") - -(js2-msg "msg.in.after.for.name" - "missing in or of after for") - -(js2-msg "msg.no.paren.for.ctrl" - "missing ) after for-loop control") - -(js2-msg "msg.no.paren.with" - "missing ( before with-statement object") - -(js2-msg "msg.no.paren.after.with" - "missing ) after with-statement object") - -(js2-msg "msg.no.with.strict" - "with statements not allowed in strict mode") - -(js2-msg "msg.no.paren.after.let" - "missing ( after let") - -(js2-msg "msg.no.paren.let" - "missing ) after variable list") - -(js2-msg "msg.no.curly.let" - "missing } after let statement") - -(js2-msg "msg.bad.return" - "invalid return") - -(js2-msg "msg.no.brace.block" - "missing } in compound statement") - -(js2-msg "msg.bad.label" - "invalid label") - -(js2-msg "msg.bad.var" - "missing variable name") - -(js2-msg "msg.bad.var.init" - "invalid variable initialization") - -(js2-msg "msg.no.colon.cond" - "missing : in conditional expression") - -(js2-msg "msg.no.paren.arg" - "missing ) after argument list") - -(js2-msg "msg.no.bracket.arg" - "missing ] after element list") - -(js2-msg "msg.bad.prop" - "invalid property id") - -(js2-msg "msg.no.colon.prop" - "missing : after property id") - -(js2-msg "msg.no.brace.prop" - "missing } after property list") - -(js2-msg "msg.no.paren" - "missing ) in parenthetical") - -(js2-msg "msg.reserved.id" - "'%s' is a reserved identifier") - -(js2-msg "msg.no.paren.catch" - "missing ( before catch-block condition") - -(js2-msg "msg.bad.catchcond" - "invalid catch block condition") - -(js2-msg "msg.catch.unreachable" - "any catch clauses following an unqualified catch are unreachable") - -(js2-msg "msg.no.brace.try" - "missing '{' before try block") - -(js2-msg "msg.no.brace.catchblock" - "missing '{' before catch-block body") - -(js2-msg "msg.try.no.catchfinally" - "'try' without 'catch' or 'finally'") - -(js2-msg "msg.no.return.value" - "function %s does not always return a value") - -(js2-msg "msg.anon.no.return.value" - "anonymous function does not always return a value") - -(js2-msg "msg.return.inconsistent" - "return statement is inconsistent with previous usage") - -(js2-msg "msg.generator.returns" - "TypeError: legacy generator function '%s' returns a value") - -(js2-msg "msg.anon.generator.returns" - "TypeError: anonymous legacy generator function returns a value") - -(js2-msg "msg.syntax" - "syntax error") - -(js2-msg "msg.unexpected.eof" - "Unexpected end of file") - -(js2-msg "msg.XML.bad.form" - "illegally formed XML syntax") - -(js2-msg "msg.XML.not.available" - "XML runtime not available") - -(js2-msg "msg.too.deep.parser.recursion" - "Too deep recursion while parsing") - -(js2-msg "msg.no.side.effects" - "Code has no side effects") - -(js2-msg "msg.extra.trailing.comma" - "Trailing comma is not supported in some browsers") - -(js2-msg "msg.array.trailing.comma" - "Trailing comma yields different behavior across browsers") - -(js2-msg "msg.equal.as.assign" - (concat "Test for equality (==) mistyped as assignment (=)?" - " (parenthesize to suppress warning)")) - -(js2-msg "msg.var.hides.arg" - "Variable %s hides argument") - -(js2-msg "msg.destruct.assign.no.init" - "Missing = in destructuring declaration") - -(js2-msg "msg.init.no.destruct" - "Binding initializer not in destructuring assignment") - -(js2-msg "msg.no.octal.strict" - "Octal numbers prohibited in strict mode.") - -(js2-msg "msg.dup.obj.lit.prop.strict" - "Property '%s' already defined in this object literal.") - -(js2-msg "msg.dup.param.strict" - "Parameter '%s' already declared in this function.") - -(js2-msg "msg.bad.id.strict" - "'%s' is not a valid identifier for this use in strict mode.") - -;; ScriptRuntime -(js2-msg "msg.no.properties" - "%s has no properties.") - -(js2-msg "msg.invalid.iterator" - "Invalid iterator value") - -(js2-msg "msg.iterator.primitive" - "__iterator__ returned a primitive value") - -(js2-msg "msg.assn.create.strict" - "Assignment to undeclared variable %s") - -(js2-msg "msg.undeclared.variable" ; added by js2-mode - "Undeclared variable or function '%s'") - -(js2-msg "msg.unused.variable" ; added by js2-mode - "Unused variable or function '%s'") - -(js2-msg "msg.uninitialized.variable" ; added by js2-mode - "Variable '%s' referenced but never initialized") - -(js2-msg "msg.ref.undefined.prop" - "Reference to undefined property '%s'") - -(js2-msg "msg.prop.not.found" - "Property %s not found.") - -(js2-msg "msg.invalid.type" - "Invalid JavaScript value of type %s") - -(js2-msg "msg.primitive.expected" - "Primitive type expected (had %s instead)") - -(js2-msg "msg.namespace.expected" - "Namespace object expected to left of :: (found %s instead)") - -(js2-msg "msg.null.to.object" - "Cannot convert null to an object.") - -(js2-msg "msg.undef.to.object" - "Cannot convert undefined to an object.") - -(js2-msg "msg.cyclic.value" - "Cyclic %s value not allowed.") - -(js2-msg "msg.is.not.defined" - "'%s' is not defined.") - -(js2-msg "msg.undef.prop.read" - "Cannot read property '%s' from %s") - -(js2-msg "msg.undef.prop.write" - "Cannot set property '%s' of %s to '%s'") - -(js2-msg "msg.undef.prop.delete" - "Cannot delete property '%s' of %s") - -(js2-msg "msg.undef.method.call" - "Cannot call method '%s' of %s") - -(js2-msg "msg.undef.with" - "Cannot apply 'with' to %s") - -(js2-msg "msg.isnt.function" - "%s is not a function, it is %s.") - -(js2-msg "msg.isnt.function.in" - "Cannot call property %s in object %s. " - "It is not a function, it is '%s'.") - -(js2-msg "msg.function.not.found" - "Cannot find function %s.") - -(js2-msg "msg.function.not.found.in" - "Cannot find function %s in object %s.") - -(js2-msg "msg.isnt.xml.object" - "%s is not an xml object.") - -(js2-msg "msg.no.ref.to.get" - "%s is not a reference to read reference value.") - -(js2-msg "msg.no.ref.to.set" - "%s is not a reference to set reference value to %s.") - -(js2-msg "msg.no.ref.from.function" - "Function %s can not be used as the left-hand " - "side of assignment or as an operand of ++ or -- operator.") - -(js2-msg "msg.bad.default.value" - "Object's getDefaultValue() method returned an object.") - -(js2-msg "msg.instanceof.not.object" - "Can't use instanceof on a non-object.") - -(js2-msg "msg.instanceof.bad.prototype" - "'prototype' property of %s is not an object.") - -(js2-msg "msg.bad.radix" - "illegal radix %s.") - -;; ScriptableObject -(js2-msg "msg.default.value" - "Cannot find default value for object.") - -(js2-msg "msg.zero.arg.ctor" - "Cannot load class '%s' which has no zero-parameter constructor.") - -(js2-msg "msg.ctor.multiple.parms" - "Can't define constructor or class %s since more than " - "one constructor has multiple parameters.") - -(js2-msg "msg.extend.scriptable" - "%s must extend ScriptableObject in order to define property %s.") - -(js2-msg "msg.bad.getter.parms" - "In order to define a property, getter %s must have zero " - "parameters or a single ScriptableObject parameter.") - -(js2-msg "msg.obj.getter.parms" - "Expected static or delegated getter %s to take " - "a ScriptableObject parameter.") - -(js2-msg "msg.getter.static" - "Getter and setter must both be static or neither be static.") - -(js2-msg "msg.setter.return" - "Setter must have void return type: %s") - -(js2-msg "msg.setter2.parms" - "Two-parameter setter must take a ScriptableObject as " - "its first parameter.") - -(js2-msg "msg.setter1.parms" - "Expected single parameter setter for %s") - -(js2-msg "msg.setter2.expected" - "Expected static or delegated setter %s to take two parameters.") - -(js2-msg "msg.setter.parms" - "Expected either one or two parameters for setter.") - -(js2-msg "msg.setter.bad.type" - "Unsupported parameter type '%s' in setter '%s'.") - -(js2-msg "msg.add.sealed" - "Cannot add a property to a sealed object: %s.") - -(js2-msg "msg.remove.sealed" - "Cannot remove a property from a sealed object: %s.") - -(js2-msg "msg.modify.sealed" - "Cannot modify a property of a sealed object: %s.") - -(js2-msg "msg.modify.readonly" - "Cannot modify readonly property: %s.") - -;; TokenStream -(js2-msg "msg.missing.exponent" - "missing exponent") - -(js2-msg "msg.caught.nfe" - "number format error") - -(js2-msg "msg.unterminated.string.lit" - "unterminated string literal") - -(js2-msg "msg.unterminated.comment" - "unterminated comment") - -(js2-msg "msg.unterminated.re.lit" - "unterminated regular expression literal") - -(js2-msg "msg.invalid.re.flag" - "invalid flag after regular expression") - -(js2-msg "msg.no.re.input.for" - "no input for %s") - -(js2-msg "msg.illegal.character" - "illegal character") - -(js2-msg "msg.invalid.escape" - "invalid Unicode escape sequence") - -(js2-msg "msg.bad.namespace" - "not a valid default namespace statement. " - "Syntax is: default xml namespace = EXPRESSION;") - -;; TokensStream warnings -(js2-msg "msg.bad.octal.literal" - "illegal octal literal digit %s; " - "interpreting it as a decimal digit") - -(js2-msg "msg.missing.hex.digits" - "missing hexadecimal digits after '0x'") - -(js2-msg "msg.missing.binary.digits" - "missing binary digits after '0b'") - -(js2-msg "msg.missing.octal.digits" - "missing octal digits after '0o'") - -(js2-msg "msg.script.is.not.constructor" - "Script objects are not constructors.") - -;; Arrays -(js2-msg "msg.arraylength.bad" - "Inappropriate array length.") - -;; Arrays -(js2-msg "msg.arraylength.too.big" - "Array length %s exceeds supported capacity limit.") - -;; URI -(js2-msg "msg.bad.uri" - "Malformed URI sequence.") - -;; Number -(js2-msg "msg.bad.precision" - "Precision %s out of range.") - -;; NativeGenerator -(js2-msg "msg.send.newborn" - "Attempt to send value to newborn generator") - -(js2-msg "msg.already.exec.gen" - "Already executing generator") - -(js2-msg "msg.StopIteration.invalid" - "StopIteration may not be changed to an arbitrary object.") - -;; Interpreter -(js2-msg "msg.yield.closing" - "Yield from closing generator") - -;; Classes -(js2-msg "msg.unnamed.class.stmt" ; added by js2-mode - "class statement requires a name") - -(js2-msg "msg.class.unexpected.comma" ; added by js2-mode - "unexpected ',' between class properties") - -(js2-msg "msg.unexpected.static" ; added by js2-mode - "unexpected 'static'") - -(js2-msg "msg.missing.extends" ; added by js2-mode - "name is required after extends") - -(js2-msg "msg.no.brace.class" ; added by js2-mode - "missing '{' before class body") - -(js2-msg "msg.missing.computed.rb" ; added by js2-mode - "missing ']' after computed property expression") - -;;; Tokens Buffer - -(defconst js2-ti-max-lookahead 2) -(defconst js2-ti-ntokens (1+ js2-ti-max-lookahead)) - -(defun js2-new-token (offset) - (let ((token (make-js2-token (+ offset js2-ts-cursor)))) - (setq js2-ti-tokens-cursor (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens)) - (aset js2-ti-tokens js2-ti-tokens-cursor token) - token)) - -(defsubst js2-current-token () - (aref js2-ti-tokens js2-ti-tokens-cursor)) - -(defsubst js2-current-token-string () - (js2-token-string (js2-current-token))) - -(defsubst js2-current-token-type () - (js2-token-type (js2-current-token))) - -(defsubst js2-current-token-beg () - (js2-token-beg (js2-current-token))) - -(defsubst js2-current-token-end () - (js2-token-end (js2-current-token))) - -(defun js2-current-token-len () - (let ((token (js2-current-token))) - (- (js2-token-end token) - (js2-token-beg token)))) - -(defun js2-ts-seek (state) - (setq js2-ts-lineno (js2-ts-state-lineno state) - js2-ts-cursor (js2-ts-state-cursor state) - js2-ti-tokens (js2-ts-state-tokens state) - js2-ti-tokens-cursor (js2-ts-state-tokens-cursor state) - js2-ti-lookahead (js2-ts-state-lookahead state))) - -;;; Utilities - -(defun js2-delete-if (predicate list) - "Remove all items satisfying PREDICATE in LIST." - (cl-loop for item in list - if (not (funcall predicate item)) - collect item)) - -(defun js2-position (element list) - "Find 0-indexed position of ELEMENT in LIST comparing with `eq'. -Returns nil if element is not found in the list." - (let ((count 0) - found) - (while (and list (not found)) - (if (eq element (car list)) - (setq found t) - (setq count (1+ count) - list (cdr list)))) - (if found count))) - -(defun js2-find-if (predicate list) - "Find first item satisfying PREDICATE in LIST." - (let (result) - (while (and list (not result)) - (if (funcall predicate (car list)) - (setq result (car list))) - (setq list (cdr list))) - result)) - -(defmacro js2-time (form) - "Evaluate FORM, discard result, and return elapsed time in sec." - (declare (debug t)) - (let ((beg (make-symbol "--js2-time-beg--"))) - `(let ((,beg (current-time))) - ,form - (/ (truncate (* (- (float-time (current-time)) - (float-time ,beg)) - 10000)) - 10000.0)))) - -(defsubst js2-same-line (pos) - "Return t if POS is on the same line as current point." - (and (>= pos (point-at-bol)) - (<= pos (point-at-eol)))) - -(defun js2-code-bug () - "Signal an error when we encounter an unexpected code path." - (error "failed assertion")) - -(defsubst js2-record-text-property (beg end prop value) - "Record a text property to set when parsing finishes." - (push (list beg end prop value) js2-mode-deferred-properties)) - -;; 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. -(defun js2-record-parse-error (msg &optional arg pos len) - (push (list (list msg arg) - (or pos (js2-current-token-beg)) - (or len (js2-current-token-len))) - js2-parsed-errors)) - -(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) - (signal 'js2-syntax-error - (list msg - js2-ts-lineno - (save-excursion - (goto-char js2-ts-cursor) - (current-column)) - js2-ts-hit-eof)))) - -(defun js2-report-warning (msg &optional msg-arg pos len face) - (if js2-compiler-report-warning-as-error - (js2-report-error msg msg-arg pos len) - (push (list (list msg msg-arg) - (or pos (js2-current-token-beg)) - (or len (js2-current-token-len)) - face) - js2-parsed-warnings))) - -(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))))) - -(put 'js2-syntax-error 'error-conditions - '(error syntax-error js2-syntax-error)) -(put 'js2-syntax-error 'error-message "Syntax error") - -(put 'js2-parse-error 'error-conditions - '(error parse-error js2-parse-error)) -(put 'js2-parse-error 'error-message "Parse error") - -(defmacro js2-clear-flag (flags flag) - `(setq ,flags (logand ,flags (lognot ,flag)))) - -(defmacro js2-set-flag (flags flag) - "Logical-or FLAG into FLAGS." - `(setq ,flags (logior ,flags ,flag))) - -(defsubst js2-flag-set-p (flags flag) - (/= 0 (logand flags flag))) - -(defsubst js2-flag-not-set-p (flags flag) - (zerop (logand flags flag))) - -;;; 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.") - -(defsubst js2-relpos (pos anchor) - "Convert POS to be relative to ANCHOR. -If POS is nil, returns nil." - (and pos (- pos anchor))) - -(defun js2-make-pad (indent) - (if (zerop indent) - "" - (make-string (* indent js2-basic-offset) ? ))) - -(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 -called twice: once to visit the node, and again after all the node's -children have been processed. The END-P argument is nil on the first -call and non-nil on the second call. The return value of the callback -affects the traversal: if non-nil, the children of NODE are processed. -If the callback returns nil, or if the node has no children, then the -callback is called immediately with a non-nil END-P argument. - -The node traversal is approximately lexical-order, although there -are currently no guarantees around this." - (when node - (let ((vfunc (get (aref node 0) 'js2-visitor))) - ;; visit the node - (when (funcall callback node nil) - ;; visit the kids - (cond - ((eq vfunc 'js2-visit-none) - nil) ; don't even bother calling it - ;; Each AST node type has to define a `js2-visitor' function - ;; that takes a node and a callback, and calls `js2-visit-ast' - ;; on each child of the node. - (vfunc - (funcall vfunc node callback)) - (t - (error "%s does not define a visitor-traversal function" - (aref node 0))))) - ;; call the end-visit - (funcall callback node t)))) - -(cl-defstruct (js2-node - (:constructor nil)) ; abstract - "Base AST node type." - (type -1) ; token type - (pos -1) ; start position of this AST node in parsed input - (len 1) ; num characters spanned by the node - props ; optional node property list (an alist) - parent) ; link to parent node; null for root - -(defsubst js2-node-get-prop (node prop &optional default) - (or (cadr (assoc prop (js2-node-props node))) default)) - -(defsubst js2-node-set-prop (node prop value) - (setf (js2-node-props node) - (cons (list prop value) (js2-node-props node)))) - -(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) - (when node - (setf (js2-node-pos node) (- (js2-node-pos node) - (js2-node-pos n)))))) - -(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." - (js2-fixup-starts parent nodes) - (dolist (node nodes) - (and node - (setf (js2-node-parent node) parent)))) - -;; Non-recursive since it's called a frightening number of times. -(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)))) - pos)) - -(defsubst js2-node-abs-end (n) - "Return absolute buffer position of end of N." - (+ (js2-node-abs-pos n) (js2-node-len n))) - -(defun js2--struct-put (name key value) - (put name key value) - (put (intern (format "cl-struct-%s" name)) key value)) - -;; 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. - -(cl-defstruct (js2-block-node - (:include js2-node) - (:constructor make-js2-block-node (&key (type js2-BLOCK) - (pos (js2-current-token-beg)) - len - props - kids))) - "A block of statements." - kids) ; a Lisp list of the child statement nodes - -(js2--struct-put 'js2-block-node 'js2-visitor 'js2-visit-block) -(js2--struct-put 'js2-block-node 'js2-printer 'js2-print-block) - -(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))) - -(defun js2-print-block (n i) - (let ((pad (js2-make-pad i))) - (insert pad "{\n") - (dolist (kid (js2-block-node-kids n)) - (js2-print-ast kid (1+ i))) - (insert pad "}"))) - -(cl-defstruct (js2-scope - (:include js2-block-node) - (:constructor make-js2-scope (&key (type js2-BLOCK) - (pos (js2-current-token-beg)) - len - kids))) - ;; The symbol-table is a LinkedHashMap<String,Symbol> in Rhino. - ;; I don't have one of those handy, so I'll use an alist for now. - ;; It's as fast as an emacs hashtable for up to about 50 elements, - ;; and is much lighter-weight to construct (both CPU and mem). - ;; The keys are interned strings (symbols) for faster lookup. - ;; Should switch to hybrid alist/hashtable eventually. - symbol-table ; an alist of (symbol . js2-symbol) - parent-scope ; a `js2-scope' - top) ; top-level `js2-scope' (script/function) - -(js2--struct-put 'js2-scope 'js2-visitor 'js2-visit-block) -(js2--struct-put 'js2-scope 'js2-printer 'js2-print-none) - -(defun js2-node-get-enclosing-scope (node) - "Return the innermost `js2-scope' node surrounding NODE. -Returns nil if there is no enclosing scope node." - (while (and (setq node (js2-node-parent node)) - (not (js2-scope-p node)))) - node) - -(defun js2-get-defining-scope (scope name &optional point) - "Search up scope chain from SCOPE looking for NAME, a string or symbol. -Returns `js2-scope' in which NAME is defined, or nil if not found. - -If POINT is non-nil, and if the found declaration type is -`js2-LET', also check that the declaration node is before POINT." - (let ((sym (if (symbolp name) - name - (intern name))) - result - (continue t)) - (while (and scope continue) - (if (or - (let ((entry (cdr (assq sym (js2-scope-symbol-table scope))))) - (and entry - (or (not point) - (not (eq js2-LET (js2-symbol-decl-type entry))) - (>= point - (js2-node-abs-pos (js2-symbol-ast-node entry)))))) - (and (eq sym 'arguments) - (js2-function-node-p scope))) - (setq continue nil - result scope) - (setq scope (js2-scope-parent-scope scope)))) - result)) - -(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) - (cdr (assq (if (symbolp name) - name - (intern name)) - (js2-scope-symbol-table scope))))) - -(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'." - (let* ((table (js2-scope-symbol-table scope)) - (sym (if (symbolp name) name (intern name))) - (entry (assq sym table))) - (if entry - (setcdr entry symbol) - (push (cons sym symbol) - (js2-scope-symbol-table scope))))) - -(cl-defstruct (js2-symbol - (:constructor make-js2-symbol (decl-type name &optional ast-node))) - "A symbol table entry." - ;; One of js2-FUNCTION, js2-LP (for parameters), js2-VAR, - ;; js2-LET, or js2-CONST - decl-type - name ; string - ast-node) ; a `js2-node' - -(cl-defstruct (js2-error-node - (:include js2-node) - (:constructor make-js2-error-node (&key (type js2-ERROR) - (pos (js2-current-token-beg)) - len))) - "AST node representing a parse error.") - -(js2--struct-put 'js2-error-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-error-node 'js2-printer 'js2-print-none) - -(cl-defstruct (js2-script-node - (:include js2-scope) - (:constructor make-js2-script-node (&key (type js2-SCRIPT) - (pos (js2-current-token-beg)) - len))) - functions ; Lisp list of nested functions - regexps ; Lisp list of (string . flags) - symbols ; alist (every symbol gets unique index) - (param-count 0) - var-names ; vector of string names - consts ; bool-vector matching var-decls - (temp-number 0)) ; for generating temp variables - -(js2--struct-put 'js2-script-node 'js2-visitor 'js2-visit-block) -(js2--struct-put 'js2-script-node 'js2-printer 'js2-print-script) - -(defun js2-print-script (node indent) - (dolist (kid (js2-block-node-kids node)) - (js2-print-ast kid indent))) - -(cl-defstruct (js2-ast-root - (:include js2-script-node) - (:constructor make-js2-ast-root (&key (type js2-SCRIPT) - (pos (js2-current-token-beg)) - len - buffer))) - "The root node of a js2 AST." - buffer ; the source buffer from which the code was parsed - comments ; a Lisp list of comments, ordered by start position - errors ; a Lisp list of errors found during parsing - warnings ; a Lisp list of warnings found during parsing - node-count) ; number of nodes in the tree, including the root - -(js2--struct-put 'js2-ast-root 'js2-visitor 'js2-visit-ast-root) -(js2--struct-put 'js2-ast-root 'js2-printer 'js2-print-script) - -(defun js2-visit-ast-root (ast callback) - (dolist (kid (js2-ast-root-kids ast)) - (js2-visit-ast kid callback)) - (dolist (comment (js2-ast-root-comments ast)) - (js2-visit-ast comment callback))) - -(cl-defstruct (js2-comment-node - (:include js2-node) - (:constructor make-js2-comment-node (&key (type js2-COMMENT) - (pos (js2-current-token-beg)) - len - format))) - format) ; 'line, 'block, 'jsdoc or 'html - -(js2--struct-put 'js2-comment-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-comment-node 'js2-printer 'js2-print-comment) - -(defun js2-print-comment (n i) - ;; We really ought to link end-of-line comments to their nodes. - ;; Or maybe we could add a new comment type, 'endline. - (insert (js2-make-pad i) - (js2-node-string n))) - -(cl-defstruct (js2-expr-stmt-node - (:include js2-node) - (:constructor make-js2-expr-stmt-node (&key (type js2-EXPR_VOID) - (pos js2-ts-cursor) - len - expr))) - "An expression statement." - expr) - -(defsubst js2-expr-stmt-node-set-has-result (node) - "Change NODE type to `js2-EXPR_RESULT'. Used for code generation." - (setf (js2-node-type node) js2-EXPR_RESULT)) - -(js2--struct-put 'js2-expr-stmt-node 'js2-visitor 'js2-visit-expr-stmt-node) -(js2--struct-put 'js2-expr-stmt-node 'js2-printer 'js2-print-expr-stmt-node) - -(defun js2-visit-expr-stmt-node (n v) - (js2-visit-ast (js2-expr-stmt-node-expr n) v)) - -(defun js2-print-expr-stmt-node (n indent) - (js2-print-ast (js2-expr-stmt-node-expr n) indent) - (insert ";\n")) - -(cl-defstruct (js2-loop-node - (:include js2-scope) - (:constructor nil)) - "Abstract supertype of loop nodes." - body ; a `js2-block-node' - lp ; position of left-paren, nil if omitted - rp) ; position of right-paren, nil if omitted - -(cl-defstruct (js2-do-node - (:include js2-loop-node) - (:constructor make-js2-do-node (&key (type js2-DO) - (pos (js2-current-token-beg)) - len - body - condition - while-pos - lp - rp))) - "AST node for do-loop." - condition ; while (expression) - while-pos) ; buffer position of 'while' keyword - -(js2--struct-put 'js2-do-node 'js2-visitor 'js2-visit-do-node) -(js2--struct-put 'js2-do-node 'js2-printer 'js2-print-do-node) - -(defun js2-visit-do-node (n v) - (js2-visit-ast (js2-do-node-body n) v) - (js2-visit-ast (js2-do-node-condition n) v)) - -(defun js2-print-do-node (n i) - (let ((pad (js2-make-pad i))) - (insert pad "do {\n") - (dolist (kid (js2-block-node-kids (js2-do-node-body n))) - (js2-print-ast kid (1+ i))) - (insert pad "} while (") - (js2-print-ast (js2-do-node-condition n) 0) - (insert ");\n"))) - -(cl-defstruct (js2-export-node - (:include js2-node) - (:constructor make-js2-export-node (&key (type js2-EXPORT) - (pos (js2-current-token-beg)) - len - exports-list - from-clause - declaration - default))) - "AST node for an export statement. There are many things that can be exported, -so many of its properties will be nil. -" - exports-list ; lisp list of js2-export-binding-node to export - from-clause ; js2-from-clause-node for re-exporting symbols from another module - declaration ; js2-var-decl-node (var, let, const) or js2-class-node - default) ; js2-function-node or js2-assign-node - -(js2--struct-put 'js2-export-node 'js2-visitor 'js2-visit-export-node) -(js2--struct-put 'js2-export-node 'js2-printer 'js2-print-export-node) - -(defun js2-visit-export-node (n v) - (let ((exports-list (js2-export-node-exports-list n)) - (from (js2-export-node-from-clause n)) - (declaration (js2-export-node-declaration n)) - (default (js2-export-node-default n))) - (when exports-list - (dolist (export exports-list) - (js2-visit-ast export v))) - (when from - (js2-visit-ast from v)) - (when declaration - (js2-visit-ast declaration v)) - (when default - (js2-visit-ast default v)))) - -(defun js2-print-export-node (n i) - (let ((pad (js2-make-pad i)) - (exports-list (js2-export-node-exports-list n)) - (from (js2-export-node-from-clause n)) - (declaration (js2-export-node-declaration n)) - (default (js2-export-node-default n))) - (insert pad "export ") - (cond - (default - (insert "default ") - (js2-print-ast default i)) - (declaration - (js2-print-ast declaration i)) - ((and exports-list from) - (js2-print-named-imports exports-list) - (insert " ") - (js2-print-from-clause from)) - (from - (insert "* ") - (js2-print-from-clause from)) - (exports-list - (js2-print-named-imports exports-list))) - (unless (or (and default (not (js2-assign-node-p default))) - (and declaration (or (js2-function-node-p declaration) - (js2-class-node-p declaration)))) - (insert ";\n")))) - -(cl-defstruct (js2-while-node - (:include js2-loop-node) - (:constructor make-js2-while-node (&key (type js2-WHILE) - (pos (js2-current-token-beg)) - len body - condition lp - rp))) - "AST node for while-loop." - condition) ; while-condition - -(js2--struct-put 'js2-while-node 'js2-visitor 'js2-visit-while-node) -(js2--struct-put 'js2-while-node 'js2-printer 'js2-print-while-node) - -(defun js2-visit-while-node (n v) - (js2-visit-ast (js2-while-node-condition n) v) - (js2-visit-ast (js2-while-node-body n) v)) - -(defun js2-print-while-node (n i) - (let ((pad (js2-make-pad i))) - (insert pad "while (") - (js2-print-ast (js2-while-node-condition n) 0) - (insert ") {\n") - (js2-print-body (js2-while-node-body n) (1+ i)) - (insert pad "}\n"))) - -(cl-defstruct (js2-for-node - (:include js2-loop-node) - (:constructor make-js2-for-node (&key (type js2-FOR) - (pos js2-ts-cursor) - len body init - condition - update lp rp))) - "AST node for a C-style for-loop." - init ; initialization expression - condition ; loop condition - update) ; update clause - -(js2--struct-put 'js2-for-node 'js2-visitor 'js2-visit-for-node) -(js2--struct-put 'js2-for-node 'js2-printer 'js2-print-for-node) - -(defun js2-visit-for-node (n v) - (js2-visit-ast (js2-for-node-init n) v) - (js2-visit-ast (js2-for-node-condition n) v) - (js2-visit-ast (js2-for-node-update n) v) - (js2-visit-ast (js2-for-node-body n) v)) - -(defun js2-print-for-node (n i) - (let ((pad (js2-make-pad i))) - (insert pad "for (") - (js2-print-ast (js2-for-node-init n) 0) - (insert "; ") - (js2-print-ast (js2-for-node-condition n) 0) - (insert "; ") - (js2-print-ast (js2-for-node-update n) 0) - (insert ") {\n") - (js2-print-body (js2-for-node-body n) (1+ i)) - (insert pad "}\n"))) - -(cl-defstruct (js2-for-in-node - (:include js2-loop-node) - (:constructor make-js2-for-in-node (&key (type js2-FOR) - (pos js2-ts-cursor) - len body - iterator - object - in-pos - each-pos - foreach-p forof-p - lp rp))) - "AST node for a for..in loop." - iterator ; [var] foo in ... - object ; object over which we're iterating - in-pos ; buffer position of 'in' keyword - each-pos ; buffer position of 'each' keyword, if foreach-p - foreach-p ; t if it's a for-each loop - forof-p) ; t if it's a for-of loop - -(js2--struct-put 'js2-for-in-node 'js2-visitor 'js2-visit-for-in-node) -(js2--struct-put 'js2-for-in-node 'js2-printer 'js2-print-for-in-node) - -(defun js2-visit-for-in-node (n v) - (js2-visit-ast (js2-for-in-node-iterator n) v) - (js2-visit-ast (js2-for-in-node-object n) v) - (js2-visit-ast (js2-for-in-node-body n) v)) - -(defun js2-print-for-in-node (n i) - (let ((pad (js2-make-pad i)) - (foreach (js2-for-in-node-foreach-p n)) - (forof (js2-for-in-node-forof-p n))) - (insert pad "for ") - (if foreach - (insert "each ")) - (insert "(") - (js2-print-ast (js2-for-in-node-iterator n) 0) - (insert (if forof " of " " in ")) - (js2-print-ast (js2-for-in-node-object n) 0) - (insert ") {\n") - (js2-print-body (js2-for-in-node-body n) (1+ i)) - (insert pad "}\n"))) - -(cl-defstruct (js2-return-node - (:include js2-node) - (:constructor make-js2-return-node (&key (type js2-RETURN) - (pos js2-ts-cursor) - len - retval))) - "AST node for a return statement." - retval) ; expression to return, or 'undefined - -(js2--struct-put 'js2-return-node 'js2-visitor 'js2-visit-return-node) -(js2--struct-put 'js2-return-node 'js2-printer 'js2-print-return-node) - -(defun js2-visit-return-node (n v) - (js2-visit-ast (js2-return-node-retval n) v)) - -(defun js2-print-return-node (n i) - (insert (js2-make-pad i) "return") - (when (js2-return-node-retval n) - (insert " ") - (js2-print-ast (js2-return-node-retval n) 0)) - (insert ";\n")) - -(cl-defstruct (js2-if-node - (:include js2-node) - (:constructor make-js2-if-node (&key (type js2-IF) - (pos js2-ts-cursor) - len condition - then-part - else-pos - else-part lp - rp))) - "AST node for an if-statement." - condition ; expression - then-part ; statement or block - else-pos ; optional buffer position of 'else' keyword - else-part ; optional statement or block - lp ; position of left-paren, nil if omitted - rp) ; position of right-paren, nil if omitted - -(js2--struct-put 'js2-if-node 'js2-visitor 'js2-visit-if-node) -(js2--struct-put 'js2-if-node 'js2-printer 'js2-print-if-node) - -(defun js2-visit-if-node (n v) - (js2-visit-ast (js2-if-node-condition n) v) - (js2-visit-ast (js2-if-node-then-part n) v) - (js2-visit-ast (js2-if-node-else-part n) v)) - -(defun js2-print-if-node (n i) - (let ((pad (js2-make-pad i)) - (then-part (js2-if-node-then-part n)) - (else-part (js2-if-node-else-part n))) - (insert pad "if (") - (js2-print-ast (js2-if-node-condition n) 0) - (insert ") {\n") - (js2-print-body then-part (1+ i)) - (insert pad "}") - (cond - ((not else-part) - (insert "\n")) - ((js2-if-node-p else-part) - (insert " else ") - (js2-print-body else-part i)) - (t - (insert " else {\n") - (js2-print-body else-part (1+ i)) - (insert pad "}\n"))))) - -(cl-defstruct (js2-export-binding-node - (:include js2-node) - (:constructor make-js2-export-binding-node (&key (type -1) - pos - len - local-name - extern-name))) - "AST node for an external symbol binding. -It contains a local-name node which is the name of the value in the -current scope, and extern-name which is the name of the value in the -imported or exported scope. By default these are the same, but if the -name is aliased as in {foo as bar}, it would have an extern-name node -containing 'foo' and a local-name node containing 'bar'." - local-name ; js2-name-node with the variable name in this scope - extern-name) ; js2-name-node with the value name in the exporting module - -(js2--struct-put 'js2-export-binding-node 'js2-printer 'js2-print-extern-binding) -(js2--struct-put 'js2-export-binding-node 'js2-visitor 'js2-visit-extern-binding) - -(defun js2-visit-extern-binding (n v) - "Visit an extern binding node. First visit the local-name, and, if -different, visit the extern-name." - (let ((local-name (js2-export-binding-node-local-name n)) - (extern-name (js2-export-binding-node-extern-name n))) - (when local-name - (js2-visit-ast local-name v)) - (when (not (equal local-name extern-name)) - (js2-visit-ast extern-name v)))) - -(defun js2-print-extern-binding (n _i) - "Print a representation of a single extern binding. E.g. 'foo' or -'foo as bar'." - (let ((local-name (js2-export-binding-node-local-name n)) - (extern-name (js2-export-binding-node-extern-name n))) - (insert (js2-name-node-name extern-name)) - (when (not (equal local-name extern-name)) - (insert " as ") - (insert (js2-name-node-name local-name))))) - - -(cl-defstruct (js2-import-node - (:include js2-node) - (:constructor make-js2-import-node (&key (type js2-IMPORT) - (pos (js2-current-token-beg)) - len - import - from - module-id))) - "AST node for an import statement. It follows the form - -import ModuleSpecifier; -import ImportClause FromClause;" - import ; js2-import-clause-node specifying which names are to imported. - from ; js2-from-clause-node indicating the module from which to import. - module-id) ; module-id of the import. E.g. 'src/mylib'. - -(js2--struct-put 'js2-import-node 'js2-printer 'js2-print-import) -(js2--struct-put 'js2-import-node 'js2-visitor 'js2-visit-import) - -(defun js2-visit-import (n v) - (let ((import-clause (js2-import-node-import n)) - (from-clause (js2-import-node-from n))) - (when import-clause - (js2-visit-ast import-clause v)) - (when from-clause - (js2-visit-ast from-clause v)))) - -(defun js2-print-import (n i) - "Prints a representation of the import node" - (let ((pad (js2-make-pad i)) - (import-clause (js2-import-node-import n)) - (from-clause (js2-import-node-from n)) - (module-id (js2-import-node-module-id n))) - (insert pad "import ") - (if import-clause - (progn - (js2-print-import-clause import-clause) - (insert " ") - (js2-print-from-clause from-clause)) - (insert "'") - (insert module-id) - (insert "'")) - (insert ";\n"))) - -(cl-defstruct (js2-import-clause-node - (:include js2-node) - (:constructor make-js2-import-clause-node (&key (type -1) - pos - len - namespace-import - named-imports - default-binding))) - "AST node corresponding to the import clause of an import statement. This is -the portion of the import that bindings names from the external context to the -local context." - namespace-import ; js2-namespace-import-node. E.g. '* as lib' - named-imports ; lisp list of js2-export-binding-node for all named imports. - default-binding) ; js2-export-binding-node for the default import binding - -(js2--struct-put 'js2-import-clause-node 'js2-visitor 'js2-visit-import-clause) -(js2--struct-put 'js2-import-clause-node 'js2-printer 'js2-print-import-clause) - -(defun js2-visit-import-clause (n v) - (let ((ns-import (js2-import-clause-node-namespace-import n)) - (named-imports (js2-import-clause-node-named-imports n)) - (default (js2-import-clause-node-default-binding n))) - (when default - (js2-visit-ast default v)) - (when ns-import - (js2-visit-ast ns-import v)) - (when named-imports - (dolist (import named-imports) - (js2-visit-ast import v))))) - -(defun js2-print-import-clause (n) - (let ((ns-import (js2-import-clause-node-namespace-import n)) - (named-imports (js2-import-clause-node-named-imports n)) - (default (js2-import-clause-node-default-binding n))) - (cond - ((and default ns-import) - (js2-print-ast default) - (insert ", ") - (js2-print-namespace-import ns-import)) - ((and default named-imports) - (js2-print-ast default) - (insert ", ") - (js2-print-named-imports named-imports)) - (default - (js2-print-ast default)) - (ns-import - (js2-print-namespace-import ns-import)) - (named-imports - (js2-print-named-imports named-imports))))) - -(defun js2-print-namespace-import (node) - (insert "* as ") - (insert (js2-name-node-name (js2-namespace-import-node-name node)))) - -(defun js2-print-named-imports (imports) - (insert "{") - (let ((len (length imports)) - (n 0)) - (while (< n len) - (js2-print-extern-binding (nth n imports) 0) - (unless (= n (- len 1)) - (insert ", ")) - (setq n (+ n 1)))) - (insert "}")) - -(cl-defstruct (js2-namespace-import-node - (:include js2-node) - (:constructor make-js2-namespace-import-node (&key (type -1) - pos - len - name))) - "AST node for a complete namespace import. -E.g. the '* as lib' expression in: - -import * as lib from 'src/lib' - -It contains a single name node referring to the bound name." - name) ; js2-name-node of the bound name. - -(defun js2-visit-namespace-import (n v) - (js2-visit-ast (js2-namespace-import-node-name n) v)) - -(js2--struct-put 'js2-namespace-import-node 'js2-visitor 'js2-visit-namespace-import) -(js2--struct-put 'js2-namespace-import-node 'js2-printer 'js2-print-namespace-import) - -(cl-defstruct (js2-from-clause-node - (:include js2-node) - (:constructor make-js2-from-clause-node (&key (type js2-NAME) - pos - len - module-id - metadata-p))) - "AST node for the from clause in an import or export statement. -E.g. from 'my/module'. It can refere to either an external module, or to the -modules metadata itself." - module-id ; string containing the module specifier. - metadata-p) ; true if this clause refers to the module's metadata - -(js2--struct-put 'js2-from-clause-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-from-clause-node 'js2-printer 'js2-print-from-clause) - -(defun js2-print-from-clause (n) - (insert "from ") - (if (js2-from-clause-node-metadata-p n) - (insert "this module") - (insert "'") - (insert (js2-from-clause-node-module-id n)) - (insert "'"))) - -(cl-defstruct (js2-try-node - (:include js2-node) - (:constructor make-js2-try-node (&key (type js2-TRY) - (pos js2-ts-cursor) - len - try-block - catch-clauses - finally-block))) - "AST node for a try-statement." - try-block - catch-clauses ; a Lisp list of `js2-catch-node' - finally-block) ; a `js2-finally-node' - -(js2--struct-put 'js2-try-node 'js2-visitor 'js2-visit-try-node) -(js2--struct-put 'js2-try-node 'js2-printer 'js2-print-try-node) - -(defun js2-visit-try-node (n v) - (js2-visit-ast (js2-try-node-try-block n) v) - (dolist (clause (js2-try-node-catch-clauses n)) - (js2-visit-ast clause v)) - (js2-visit-ast (js2-try-node-finally-block n) v)) - -(defun js2-print-try-node (n i) - (let ((pad (js2-make-pad i)) - (catches (js2-try-node-catch-clauses n)) - (finally (js2-try-node-finally-block n))) - (insert pad "try {\n") - (js2-print-body (js2-try-node-try-block n) (1+ i)) - (insert pad "}") - (when catches - (dolist (catch catches) - (js2-print-ast catch i))) - (if finally - (js2-print-ast finally i) - (insert "\n")))) - -(cl-defstruct (js2-catch-node - (:include js2-scope) - (:constructor make-js2-catch-node (&key (type js2-CATCH) - (pos js2-ts-cursor) - len - param - guard-kwd - guard-expr - lp rp))) - "AST node for a catch clause." - param ; destructuring form or simple name node - guard-kwd ; relative buffer position of "if" in "catch (x if ...)" - guard-expr ; catch condition, a `js2-node' - lp ; buffer position of left-paren, nil if omitted - rp) ; buffer position of right-paren, nil if omitted - -(js2--struct-put 'js2-catch-node 'js2-visitor 'js2-visit-catch-node) -(js2--struct-put 'js2-catch-node 'js2-printer 'js2-print-catch-node) - -(defun js2-visit-catch-node (n v) - (js2-visit-ast (js2-catch-node-param n) v) - (when (js2-catch-node-guard-kwd n) - (js2-visit-ast (js2-catch-node-guard-expr n) v)) - (js2-visit-block n v)) - -(defun js2-print-catch-node (n i) - (let ((pad (js2-make-pad i)) - (guard-kwd (js2-catch-node-guard-kwd n)) - (guard-expr (js2-catch-node-guard-expr n))) - (insert " catch (") - (js2-print-ast (js2-catch-node-param n) 0) - (when guard-kwd - (insert " if ") - (js2-print-ast guard-expr 0)) - (insert ") {\n") - (js2-print-body n (1+ i)) - (insert pad "}"))) - -(cl-defstruct (js2-finally-node - (:include js2-node) - (:constructor make-js2-finally-node (&key (type js2-FINALLY) - (pos js2-ts-cursor) - len body))) - "AST node for a finally clause." - body) ; a `js2-node', often but not always a block node - -(js2--struct-put 'js2-finally-node 'js2-visitor 'js2-visit-finally-node) -(js2--struct-put 'js2-finally-node 'js2-printer 'js2-print-finally-node) - -(defun js2-visit-finally-node (n v) - (js2-visit-ast (js2-finally-node-body n) v)) - -(defun js2-print-finally-node (n i) - (let ((pad (js2-make-pad i))) - (insert " finally {\n") - (js2-print-body (js2-finally-node-body n) (1+ i)) - (insert pad "}\n"))) - -(cl-defstruct (js2-switch-node - (:include js2-scope) - (:constructor make-js2-switch-node (&key (type js2-SWITCH) - (pos js2-ts-cursor) - len - discriminant - cases lp - rp))) - "AST node for a switch statement." - discriminant ; a `js2-node' (switch expression) - cases ; a Lisp list of `js2-case-node' - lp ; position of open-paren for discriminant, nil if omitted - rp) ; position of close-paren for discriminant, nil if omitted - -(js2--struct-put 'js2-switch-node 'js2-visitor 'js2-visit-switch-node) -(js2--struct-put 'js2-switch-node 'js2-printer 'js2-print-switch-node) - -(defun js2-visit-switch-node (n v) - (js2-visit-ast (js2-switch-node-discriminant n) v) - (dolist (c (js2-switch-node-cases n)) - (js2-visit-ast c v))) - -(defun js2-print-switch-node (n i) - (let ((pad (js2-make-pad i)) - (cases (js2-switch-node-cases n))) - (insert pad "switch (") - (js2-print-ast (js2-switch-node-discriminant n) 0) - (insert ") {\n") - (dolist (case cases) - (js2-print-ast case i)) - (insert pad "}\n"))) - -(cl-defstruct (js2-case-node - (:include js2-block-node) - (:constructor make-js2-case-node (&key (type js2-CASE) - (pos js2-ts-cursor) - len kids expr))) - "AST node for a case clause of a switch statement." - expr) ; the case expression (nil for default) - -(js2--struct-put 'js2-case-node 'js2-visitor 'js2-visit-case-node) -(js2--struct-put 'js2-case-node 'js2-printer 'js2-print-case-node) - -(defun js2-visit-case-node (n v) - (js2-visit-ast (js2-case-node-expr n) v) - (js2-visit-block n v)) - -(defun js2-print-case-node (n i) - (let ((pad (js2-make-pad i)) - (expr (js2-case-node-expr n))) - (insert pad) - (if (null expr) - (insert "default:\n") - (insert "case ") - (js2-print-ast expr 0) - (insert ":\n")) - (dolist (kid (js2-case-node-kids n)) - (js2-print-ast kid (1+ i))))) - -(cl-defstruct (js2-throw-node - (:include js2-node) - (:constructor make-js2-throw-node (&key (type js2-THROW) - (pos js2-ts-cursor) - len expr))) - "AST node for a throw statement." - expr) ; the expression to throw - -(js2--struct-put 'js2-throw-node 'js2-visitor 'js2-visit-throw-node) -(js2--struct-put 'js2-throw-node 'js2-printer 'js2-print-throw-node) - -(defun js2-visit-throw-node (n v) - (js2-visit-ast (js2-throw-node-expr n) v)) - -(defun js2-print-throw-node (n i) - (insert (js2-make-pad i) "throw ") - (js2-print-ast (js2-throw-node-expr n) 0) - (insert ";\n")) - -(cl-defstruct (js2-with-node - (:include js2-node) - (:constructor make-js2-with-node (&key (type js2-WITH) - (pos js2-ts-cursor) - len object - body lp rp))) - "AST node for a with-statement." - object - body - lp ; buffer position of left-paren around object, nil if omitted - rp) ; buffer position of right-paren around object, nil if omitted - -(js2--struct-put 'js2-with-node 'js2-visitor 'js2-visit-with-node) -(js2--struct-put 'js2-with-node 'js2-printer 'js2-print-with-node) - -(defun js2-visit-with-node (n v) - (js2-visit-ast (js2-with-node-object n) v) - (js2-visit-ast (js2-with-node-body n) v)) - -(defun js2-print-with-node (n i) - (let ((pad (js2-make-pad i))) - (insert pad "with (") - (js2-print-ast (js2-with-node-object n) 0) - (insert ") {\n") - (js2-print-body (js2-with-node-body n) (1+ i)) - (insert pad "}\n"))) - -(cl-defstruct (js2-label-node - (:include js2-node) - (:constructor make-js2-label-node (&key (type js2-LABEL) - (pos js2-ts-cursor) - len name))) - "AST node for a statement label or case label." - name ; a string - loop) ; for validating and code-generating continue-to-label - -(js2--struct-put 'js2-label-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-label-node 'js2-printer 'js2-print-label) - -(defun js2-print-label (n i) - (insert (js2-make-pad i) - (js2-label-node-name n) - ":\n")) - -(cl-defstruct (js2-labeled-stmt-node - (:include js2-node) - ;; type needs to be in `js2-side-effecting-tokens' to avoid spurious - ;; no-side-effects warnings, hence js2-EXPR_RESULT. - (:constructor make-js2-labeled-stmt-node (&key (type js2-EXPR_RESULT) - (pos js2-ts-cursor) - len labels stmt))) - "AST node for a statement with one or more labels. -Multiple labels for a statement are collapsed into the labels field." - labels ; Lisp list of `js2-label-node' - stmt) ; the statement these labels are for - -(js2--struct-put 'js2-labeled-stmt-node 'js2-visitor 'js2-visit-labeled-stmt) -(js2--struct-put 'js2-labeled-stmt-node 'js2-printer 'js2-print-labeled-stmt) - -(defun js2-get-label-by-name (lbl-stmt name) - "Return a `js2-label-node' by NAME from LBL-STMT's labels list. -Returns nil if no such label is in the list." - (let ((label-list (js2-labeled-stmt-node-labels lbl-stmt)) - result) - (while (and label-list (not result)) - (if (string= (js2-label-node-name (car label-list)) name) - (setq result (car label-list)) - (setq label-list (cdr label-list)))) - result)) - -(defun js2-visit-labeled-stmt (n v) - (dolist (label (js2-labeled-stmt-node-labels n)) - (js2-visit-ast label v)) - (js2-visit-ast (js2-labeled-stmt-node-stmt n) v)) - -(defun js2-print-labeled-stmt (n i) - (dolist (label (js2-labeled-stmt-node-labels n)) - (js2-print-ast label i)) - (js2-print-ast (js2-labeled-stmt-node-stmt n) i)) - -(defun js2-labeled-stmt-node-contains (node label) - "Return t if NODE contains LABEL in its label set. -NODE is a `js2-labels-node'. LABEL is an identifier." - (cl-loop for nl in (js2-labeled-stmt-node-labels node) - if (string= label (js2-label-node-name nl)) - return t - finally return nil)) - -(defsubst js2-labeled-stmt-node-add-label (node label) - "Add a `js2-label-node' to the label set for this statement." - (setf (js2-labeled-stmt-node-labels node) - (nconc (js2-labeled-stmt-node-labels node) (list label)))) - -(cl-defstruct (js2-jump-node - (:include js2-node) - (:constructor nil)) - "Abstract supertype of break and continue nodes." - label ; `js2-name-node' for location of label identifier, if present - target) ; target js2-labels-node or loop/switch statement - -(defun js2-visit-jump-node (n v) - ;; We don't visit the target, since it's a back-link. - (js2-visit-ast (js2-jump-node-label n) v)) - -(cl-defstruct (js2-break-node - (:include js2-jump-node) - (:constructor make-js2-break-node (&key (type js2-BREAK) - (pos js2-ts-cursor) - len label target))) - "AST node for a break statement. -The label field is a `js2-name-node', possibly nil, for the named label -if provided. E.g. in 'break foo', it represents 'foo'. The target field -is the target of the break - a label node or enclosing loop/switch statement.") - -(js2--struct-put 'js2-break-node 'js2-visitor 'js2-visit-jump-node) -(js2--struct-put 'js2-break-node 'js2-printer 'js2-print-break-node) - -(defun js2-print-break-node (n i) - (insert (js2-make-pad i) "break") - (when (js2-break-node-label n) - (insert " ") - (js2-print-ast (js2-break-node-label n) 0)) - (insert ";\n")) - -(cl-defstruct (js2-continue-node - (:include js2-jump-node) - (:constructor make-js2-continue-node (&key (type js2-CONTINUE) - (pos js2-ts-cursor) - len label target))) - "AST node for a continue statement. -The label field is the user-supplied enclosing label name, a `js2-name-node'. -It is nil if continue specifies no label. The target field is the jump target: -a `js2-label-node' or the innermost enclosing loop.") - -(js2--struct-put 'js2-continue-node 'js2-visitor 'js2-visit-jump-node) -(js2--struct-put 'js2-continue-node 'js2-printer 'js2-print-continue-node) - -(defun js2-print-continue-node (n i) - (insert (js2-make-pad i) "continue") - (when (js2-continue-node-label n) - (insert " ") - (js2-print-ast (js2-continue-node-label n) 0)) - (insert ";\n")) - -(cl-defstruct (js2-function-node - (:include js2-script-node) - (:constructor make-js2-function-node (&key (type js2-FUNCTION) - (pos js2-ts-cursor) - len - (ftype 'FUNCTION) - (form 'FUNCTION_STATEMENT) - (name "") - params rest-p - body - generator-type - async - lp rp))) - "AST node for a function declaration. -The `params' field is a Lisp list of nodes. Each node is either a simple -`js2-name-node', or if it's a destructuring-assignment parameter, a -`js2-array-node' or `js2-object-node'." - ftype ; FUNCTION, GETTER or SETTER - form ; FUNCTION_{STATEMENT|EXPRESSION|ARROW} - name ; function name (a `js2-name-node', or nil if anonymous) - params ; a Lisp list of destructuring forms or simple name nodes - rest-p ; if t, the last parameter is rest parameter - body ; a `js2-block-node' or expression node (1.8 only) - lp ; position of arg-list open-paren, or nil if omitted - rp ; position of arg-list close-paren, or nil if omitted - ignore-dynamic ; ignore value of the dynamic-scope flag (interpreter only) - needs-activation ; t if we need an activation object for this frame - generator-type ; STAR, LEGACY, COMPREHENSION or nil - async ; t if the function is defined as `async function` - member-expr) ; nonstandard Ecma extension from Rhino - -(js2--struct-put 'js2-function-node 'js2-visitor 'js2-visit-function-node) -(js2--struct-put 'js2-function-node 'js2-printer 'js2-print-function-node) - -(defun js2-visit-function-node (n v) - (js2-visit-ast (js2-function-node-name n) v) - (dolist (p (js2-function-node-params n)) - (js2-visit-ast p v)) - (js2-visit-ast (js2-function-node-body n) v)) - -(defun js2-print-function-node (n i) - (let* ((pad (js2-make-pad i)) - (method (js2-node-get-prop n 'METHOD_TYPE)) - (name (or (js2-function-node-name n) - (js2-function-node-member-expr n))) - (params (js2-function-node-params n)) - (arrow (eq (js2-function-node-form n) 'FUNCTION_ARROW)) - (rest-p (js2-function-node-rest-p n)) - (body (js2-function-node-body n)) - (expr (not (eq (js2-function-node-form n) 'FUNCTION_STATEMENT)))) - (unless method - (insert pad) - (when (js2-function-node-async n) (insert "async ")) - (unless arrow (insert "function")) - (when (eq (js2-function-node-generator-type n) 'STAR) - (insert "*"))) - (when name - (insert " ") - (js2-print-ast name 0)) - (insert "(") - (cl-loop with len = (length params) - for param in params - for count from 1 - do - (when (and rest-p (= count len)) - (insert "...")) - (js2-print-ast param 0) - (when (< count len) - (insert ", "))) - (insert ") ") - (when arrow - (insert "=> ")) - (insert "{") - ;; TODO: fix this to be smarter about indenting, etc. - (unless expr - (insert "\n")) - (if (js2-block-node-p body) - (js2-print-body body (1+ i)) - (js2-print-ast body 0)) - (insert pad "}") - (unless expr - (insert "\n")))) - -(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)))) - -;; Having this be an expression node makes it more flexible. -;; There are IDE contexts, such as indentation in a for-loop initializer, -;; that work better if you assume it's an expression. Whenever we have -;; a standalone var/const declaration, we just wrap with an expr stmt. -;; Eclipse apparently screwed this up and now has two versions, expr and stmt. -(cl-defstruct (js2-var-decl-node - (:include js2-node) - (:constructor make-js2-var-decl-node (&key (type js2-VAR) - (pos (js2-current-token-beg)) - len kids - decl-type))) - "AST node for a variable declaration list (VAR, CONST or LET). -The node bounds differ depending on the declaration type. For VAR or -CONST declarations, the bounds include the var/const keyword. For LET -declarations, the node begins at the position of the first child." - kids ; a Lisp list of `js2-var-init-node' structs. - decl-type) ; js2-VAR, js2-CONST or js2-LET - -(js2--struct-put 'js2-var-decl-node 'js2-visitor 'js2-visit-var-decl) -(js2--struct-put 'js2-var-decl-node 'js2-printer 'js2-print-var-decl) - -(defun js2-visit-var-decl (n v) - (dolist (kid (js2-var-decl-node-kids n)) - (js2-visit-ast kid v))) - -(defun js2-print-var-decl (n i) - (let ((pad (js2-make-pad i)) - (tt (js2-var-decl-node-decl-type n))) - (insert pad) - (insert (cond - ((= tt js2-VAR) "var ") - ((= tt js2-LET) "let ") - ((= tt js2-CONST) "const ") - (t - (error "malformed var-decl node")))) - (cl-loop with kids = (js2-var-decl-node-kids n) - with len = (length kids) - for kid in kids - for count from 1 - do - (js2-print-ast kid 0) - (if (< count len) - (insert ", "))))) - -(cl-defstruct (js2-var-init-node - (:include js2-node) - (:constructor make-js2-var-init-node (&key (type js2-VAR) - (pos js2-ts-cursor) - len target - initializer))) - "AST node for a variable declaration. -The type field will be js2-CONST for a const decl." - target ; `js2-name-node', `js2-object-node', or `js2-array-node' - initializer) ; initializer expression, a `js2-node' - -(js2--struct-put 'js2-var-init-node 'js2-visitor 'js2-visit-var-init-node) -(js2--struct-put 'js2-var-init-node 'js2-printer 'js2-print-var-init-node) - -(defun js2-visit-var-init-node (n v) - (js2-visit-ast (js2-var-init-node-target n) v) - (js2-visit-ast (js2-var-init-node-initializer n) v)) - -(defun js2-print-var-init-node (n i) - (let ((pad (js2-make-pad i)) - (name (js2-var-init-node-target n)) - (init (js2-var-init-node-initializer n))) - (insert pad) - (js2-print-ast name 0) - (when init - (insert " = ") - (js2-print-ast init 0)))) - -(cl-defstruct (js2-cond-node - (:include js2-node) - (:constructor make-js2-cond-node (&key (type js2-HOOK) - (pos js2-ts-cursor) - len - test-expr - true-expr - false-expr - q-pos c-pos))) - "AST node for the ternary operator" - test-expr - true-expr - false-expr - q-pos ; buffer position of ? - c-pos) ; buffer position of : - -(js2--struct-put 'js2-cond-node 'js2-visitor 'js2-visit-cond-node) -(js2--struct-put 'js2-cond-node 'js2-printer 'js2-print-cond-node) - -(defun js2-visit-cond-node (n v) - (js2-visit-ast (js2-cond-node-test-expr n) v) - (js2-visit-ast (js2-cond-node-true-expr n) v) - (js2-visit-ast (js2-cond-node-false-expr n) v)) - -(defun js2-print-cond-node (n i) - (let ((pad (js2-make-pad i))) - (insert pad) - (js2-print-ast (js2-cond-node-test-expr n) 0) - (insert " ? ") - (js2-print-ast (js2-cond-node-true-expr n) 0) - (insert " : ") - (js2-print-ast (js2-cond-node-false-expr n) 0))) - -(cl-defstruct (js2-infix-node - (:include js2-node) - (:constructor make-js2-infix-node (&key type - (pos js2-ts-cursor) - len op-pos - left right))) - "Represents infix expressions. -Includes assignment ops like `|=', and the comma operator. -The type field inherited from `js2-node' holds the operator." - op-pos ; buffer position where operator begins - left ; any `js2-node' - right) ; any `js2-node' - -(js2--struct-put 'js2-infix-node 'js2-visitor 'js2-visit-infix-node) -(js2--struct-put 'js2-infix-node 'js2-printer 'js2-print-infix-node) - -(defun js2-visit-infix-node (n v) - (js2-visit-ast (js2-infix-node-left n) v) - (js2-visit-ast (js2-infix-node-right n) v)) - -(defconst js2-operator-tokens - (let ((table (make-hash-table :test 'eq)) - (tokens - (list (cons js2-IN "in") - (cons js2-TYPEOF "typeof") - (cons js2-INSTANCEOF "instanceof") - (cons js2-DELPROP "delete") - (cons js2-AWAIT "await") - (cons js2-VOID "void") - (cons js2-COMMA ",") - (cons js2-COLON ":") - (cons js2-OR "||") - (cons js2-AND "&&") - (cons js2-INC "++") - (cons js2-DEC "--") - (cons js2-BITOR "|") - (cons js2-BITXOR "^") - (cons js2-BITAND "&") - (cons js2-EQ "==") - (cons js2-NE "!=") - (cons js2-LT "<") - (cons js2-LE "<=") - (cons js2-GT ">") - (cons js2-GE ">=") - (cons js2-LSH "<<") - (cons js2-RSH ">>") - (cons js2-URSH ">>>") - (cons js2-ADD "+") ; infix plus - (cons js2-SUB "-") ; infix minus - (cons js2-MUL "*") - (cons js2-EXPON "**") - (cons js2-DIV "/") - (cons js2-MOD "%") - (cons js2-NOT "!") - (cons js2-BITNOT "~") - (cons js2-POS "+") ; unary plus - (cons js2-NEG "-") ; unary minus - (cons js2-TRIPLEDOT "...") - (cons js2-SHEQ "===") ; shallow equality - (cons js2-SHNE "!==") ; shallow inequality - (cons js2-ASSIGN "=") - (cons js2-ASSIGN_BITOR "|=") - (cons js2-ASSIGN_BITXOR "^=") - (cons js2-ASSIGN_BITAND "&=") - (cons js2-ASSIGN_LSH "<<=") - (cons js2-ASSIGN_RSH ">>=") - (cons js2-ASSIGN_URSH ">>>=") - (cons js2-ASSIGN_ADD "+=") - (cons js2-ASSIGN_SUB "-=") - (cons js2-ASSIGN_MUL "*=") - (cons js2-ASSIGN_EXPON "**=") - (cons js2-ASSIGN_DIV "/=") - (cons js2-ASSIGN_MOD "%=")))) - (cl-loop for (k . v) in tokens do - (puthash k v table)) - table)) - -(defun js2-print-infix-node (n i) - (let* ((tt (js2-node-type n)) - (op (gethash tt js2-operator-tokens))) - (unless op - (error "unrecognized infix operator %s" (js2-node-type n))) - (insert (js2-make-pad i)) - (js2-print-ast (js2-infix-node-left n) 0) - (unless (= tt js2-COMMA) - (insert " ")) - (insert op) - (insert " ") - (js2-print-ast (js2-infix-node-right n) 0))) - -(cl-defstruct (js2-assign-node - (:include js2-infix-node) - (:constructor make-js2-assign-node (&key type - (pos js2-ts-cursor) - len op-pos - left right))) - "Represents any assignment. -The type field holds the actual assignment operator.") - -(js2--struct-put 'js2-assign-node 'js2-visitor 'js2-visit-infix-node) -(js2--struct-put 'js2-assign-node 'js2-printer 'js2-print-infix-node) - -(cl-defstruct (js2-unary-node - (:include js2-node) - (:constructor make-js2-unary-node (&key type ; required - (pos js2-ts-cursor) - len operand))) - "AST node type for unary operator nodes. -The type field can be NOT, BITNOT, POS, NEG, INC, DEC, -TYPEOF, DELPROP, TRIPLEDOT or AWAIT. For INC or DEC, a 'postfix node -property is added if the operator follows the operand." - operand) ; a `js2-node' expression - -(js2--struct-put 'js2-unary-node 'js2-visitor 'js2-visit-unary-node) -(js2--struct-put 'js2-unary-node 'js2-printer 'js2-print-unary-node) - -(defun js2-visit-unary-node (n v) - (js2-visit-ast (js2-unary-node-operand n) v)) - -(defun js2-print-unary-node (n i) - (let* ((tt (js2-node-type n)) - (op (gethash tt js2-operator-tokens)) - (postfix (js2-node-get-prop n 'postfix))) - (unless op - (error "unrecognized unary operator %s" tt)) - (insert (js2-make-pad i)) - (unless postfix - (insert op)) - (if (or (= tt js2-TYPEOF) - (= tt js2-DELPROP) - (= tt js2-AWAIT) - (= tt js2-VOID)) - (insert " ")) - (js2-print-ast (js2-unary-node-operand n) 0) - (when postfix - (insert op)))) - -(cl-defstruct (js2-let-node - (:include js2-scope) - (:constructor make-js2-let-node (&key (type js2-LETEXPR) - (pos (js2-current-token-beg)) - len vars body - lp rp))) - "AST node for a let expression or a let statement. -Note that a let declaration such as let x=6, y=7 is a `js2-var-decl-node'." - vars ; a `js2-var-decl-node' - body ; a `js2-node' representing the expression or body block - lp - rp) - -(js2--struct-put 'js2-let-node 'js2-visitor 'js2-visit-let-node) -(js2--struct-put 'js2-let-node 'js2-printer 'js2-print-let-node) - -(defun js2-visit-let-node (n v) - (js2-visit-ast (js2-let-node-vars n) v) - (js2-visit-ast (js2-let-node-body n) v)) - -(defun js2-print-let-node (n i) - (insert (js2-make-pad i) "let (") - (let ((p (point))) - (js2-print-ast (js2-let-node-vars n) 0) - (delete-region p (+ p 4))) - (insert ") ") - (js2-print-ast (js2-let-node-body n) i)) - -(cl-defstruct (js2-keyword-node - (:include js2-node) - (:constructor make-js2-keyword-node (&key type - (pos (js2-current-token-beg)) - (len (- js2-ts-cursor pos))))) - "AST node representing a literal keyword such as `null'. -Used for `null', `this', `true', `false' and `debugger'. -The node type is set to js2-NULL, js2-THIS, etc.") - -(js2--struct-put 'js2-keyword-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-keyword-node 'js2-printer 'js2-print-keyword-node) - -(defun js2-print-keyword-node (n i) - (insert (js2-make-pad i) - (let ((tt (js2-node-type n))) - (cond - ((= tt js2-THIS) "this") - ((= tt js2-SUPER) "super") - ((= tt js2-NULL) "null") - ((= tt js2-TRUE) "true") - ((= tt js2-FALSE) "false") - ((= tt js2-DEBUGGER) "debugger") - (t (error "Invalid keyword literal type: %d" tt)))))) - -(defsubst js2-this-or-super-node-p (node) - "Return t if NODE is a `js2-literal-node' of type js2-THIS or js2-SUPER." - (let ((type (js2-node-type node))) - (or (eq type js2-THIS) (eq type js2-SUPER)))) - -(cl-defstruct (js2-new-node - (:include js2-node) - (:constructor make-js2-new-node (&key (type js2-NEW) - (pos (js2-current-token-beg)) - len target - args initializer - lp rp))) - "AST node for new-expression such as new Foo()." - target ; an identifier or reference - args ; a Lisp list of argument nodes - lp ; position of left-paren, nil if omitted - rp ; position of right-paren, nil if omitted - initializer) ; experimental Rhino syntax: optional `js2-object-node' - -(js2--struct-put 'js2-new-node 'js2-visitor 'js2-visit-new-node) -(js2--struct-put 'js2-new-node 'js2-printer 'js2-print-new-node) - -(defun js2-visit-new-node (n v) - (js2-visit-ast (js2-new-node-target n) v) - (dolist (arg (js2-new-node-args n)) - (js2-visit-ast arg v)) - (js2-visit-ast (js2-new-node-initializer n) v)) - -(defun js2-print-new-node (n i) - (insert (js2-make-pad i) "new ") - (js2-print-ast (js2-new-node-target n)) - (insert "(") - (js2-print-list (js2-new-node-args n)) - (insert ")") - (when (js2-new-node-initializer n) - (insert " ") - (js2-print-ast (js2-new-node-initializer n)))) - -(cl-defstruct (js2-name-node - (:include js2-node) - (:constructor make-js2-name-node (&key (type js2-NAME) - (pos (js2-current-token-beg)) - (len (- js2-ts-cursor - (js2-current-token-beg))) - (name (js2-current-token-string))))) - "AST node for a JavaScript identifier" - name ; a string - scope) ; a `js2-scope' (optional, used for codegen) - -(js2--struct-put 'js2-name-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-name-node 'js2-printer 'js2-print-name-node) - -(defun js2-print-name-node (n i) - (insert (js2-make-pad i) - (js2-name-node-name n))) - -(defsubst js2-name-node-length (node) - "Return identifier length of NODE, a `js2-name-node'. -Returns 0 if NODE is nil or its identifier field is nil." - (if node - (length (js2-name-node-name node)) - 0)) - -(cl-defstruct (js2-number-node - (:include js2-node) - (:constructor make-js2-number-node (&key (type js2-NUMBER) - (pos (js2-current-token-beg)) - (len (- js2-ts-cursor - (js2-current-token-beg))) - (value (js2-current-token-string)) - (num-value (js2-token-number - (js2-current-token))) - (num-base (js2-token-number-base - (js2-current-token))) - (legacy-octal-p (js2-token-number-legacy-octal-p - (js2-current-token)))))) - "AST node for a number literal." - value ; the original string, e.g. "6.02e23" - num-value ; the parsed number value - num-base ; the number's base - legacy-octal-p) ; whether the number is a legacy octal (0123 instead of 0o123) - -(js2--struct-put 'js2-number-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-number-node 'js2-printer 'js2-print-number-node) - -(defun js2-print-number-node (n i) - (insert (js2-make-pad i) - (number-to-string (js2-number-node-num-value n)))) - -(cl-defstruct (js2-regexp-node - (:include js2-node) - (:constructor make-js2-regexp-node (&key (type js2-REGEXP) - (pos (js2-current-token-beg)) - (len (- js2-ts-cursor - (js2-current-token-beg))) - value flags))) - "AST node for a regular expression literal." - value ; the regexp string, without // delimiters - flags) ; a string of flags, e.g. `mi'. - -(js2--struct-put 'js2-regexp-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-regexp-node 'js2-printer 'js2-print-regexp) - -(defun js2-print-regexp (n i) - (insert (js2-make-pad i) - "/" - (js2-regexp-node-value n) - "/") - (if (js2-regexp-node-flags n) - (insert (js2-regexp-node-flags n)))) - -(cl-defstruct (js2-string-node - (:include js2-node) - (:constructor make-js2-string-node (&key (type js2-STRING) - (pos (js2-current-token-beg)) - (len (- js2-ts-cursor - (js2-current-token-beg))) - (value (js2-current-token-string))))) - "String literal. -Escape characters are not evaluated; e.g. \n is 2 chars in value field. -You can tell the quote type by looking at the first character." - value) ; the characters of the string, including the quotes - -(js2--struct-put 'js2-string-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-string-node 'js2-printer 'js2-print-string-node) - -(defun js2-print-string-node (n i) - (insert (js2-make-pad i) - (js2-node-string n))) - -(cl-defstruct (js2-template-node - (:include js2-node) - (:constructor make-js2-template-node (&key (type js2-TEMPLATE_HEAD) - pos len kids))) - "Template literal." - kids) ; `js2-string-node' is used for string segments, other nodes - ; for substitutions inside. - -(js2--struct-put 'js2-template-node 'js2-visitor 'js2-visit-template) -(js2--struct-put 'js2-template-node 'js2-printer 'js2-print-template) - -(defun js2-visit-template (n callback) - (dolist (kid (js2-template-node-kids n)) - (js2-visit-ast kid callback))) - -(defun js2-print-template (n i) - (insert (js2-make-pad i)) - (dolist (kid (js2-template-node-kids n)) - (if (js2-string-node-p kid) - (insert (js2-node-string kid)) - (js2-print-ast kid)))) - -(cl-defstruct (js2-tagged-template-node - (:include js2-node) - (:constructor make-js2-tagged-template-node (&key (type js2-TAGGED_TEMPLATE) - pos len tag template))) - "Tagged template literal." - tag ; `js2-node' with the tag expression. - template) ; `js2-template-node' with the template. - -(js2--struct-put 'js2-tagged-template-node 'js2-visitor 'js2-visit-tagged-template) -(js2--struct-put 'js2-tagged-template-node 'js2-printer 'js2-print-tagged-template) - -(defun js2-visit-tagged-template (n callback) - (js2-visit-ast (js2-tagged-template-node-tag n) callback) - (js2-visit-ast (js2-tagged-template-node-template n) callback)) - -(defun js2-print-tagged-template (n i) - (insert (js2-make-pad i)) - (js2-print-ast (js2-tagged-template-node-tag n)) - (js2-print-ast (js2-tagged-template-node-template n))) - -(cl-defstruct (js2-array-node - (:include js2-node) - (:constructor make-js2-array-node (&key (type js2-ARRAYLIT) - (pos js2-ts-cursor) - len elems))) - "AST node for an array literal." - elems) ; list of expressions. [foo,,bar] yields a nil middle element. - -(js2--struct-put 'js2-array-node 'js2-visitor 'js2-visit-array-node) -(js2--struct-put 'js2-array-node 'js2-printer 'js2-print-array-node) - -(defun js2-visit-array-node (n v) - (dolist (e (js2-array-node-elems n)) - (js2-visit-ast e v))) ; Can be nil; e.g. [a, ,b]. - -(defun js2-print-array-node (n i) - (insert (js2-make-pad i) "[") - (let ((elems (js2-array-node-elems n))) - (js2-print-list elems) - (when (and elems (null (car (last elems)))) - (insert ","))) - (insert "]")) - -(cl-defstruct (js2-object-node - (:include js2-node) - (:constructor make-js2-object-node (&key (type js2-OBJECTLIT) - (pos js2-ts-cursor) - len - elems))) - "AST node for an object literal expression. -`elems' is a list of `js2-object-prop-node'." - elems) - -(js2--struct-put 'js2-object-node 'js2-visitor 'js2-visit-object-node) -(js2--struct-put 'js2-object-node 'js2-printer 'js2-print-object-node) - -(defun js2-visit-object-node (n v) - (dolist (e (js2-object-node-elems n)) - (js2-visit-ast e v))) - -(defun js2-print-object-node (n i) - (insert (js2-make-pad i) "{") - (js2-print-list (js2-object-node-elems n)) - (insert "}")) - -(cl-defstruct (js2-class-node - (:include js2-object-node) - (:constructor make-js2-class-node (&key (type js2-CLASS) - (pos js2-ts-cursor) - (form 'CLASS_STATEMENT) - (name "") - extends len elems))) - "AST node for an class expression. -`elems' is a list of `js2-object-prop-node', and `extends' is an -optional `js2-expr-node'" - form ; CLASS_{STATEMENT|EXPRESSION} - name ; class name (a `js2-node-name', or nil if anonymous) - extends ; class heritage (a `js2-expr-node', or nil if none) - ) - -(js2--struct-put 'js2-class-node 'js2-visitor 'js2-visit-class-node) -(js2--struct-put 'js2-class-node 'js2-printer 'js2-print-class-node) - -(defun js2-visit-class-node (n v) - (js2-visit-ast (js2-class-node-name n) v) - (js2-visit-ast (js2-class-node-extends n) v) - (dolist (e (js2-class-node-elems n)) - (js2-visit-ast e v))) - -(defun js2-print-class-node (n i) - (let* ((pad (js2-make-pad i)) - (name (js2-class-node-name n)) - (extends (js2-class-node-extends n)) - (elems (js2-class-node-elems n))) - (insert pad "class") - (when name - (insert " ") - (js2-print-ast name 0)) - (when extends - (insert " extends ") - (js2-print-ast extends)) - (insert " {") - (dolist (elem elems) - (insert "\n") - (if (js2-node-get-prop elem 'STATIC) - (progn (insert (js2-make-pad (1+ i)) "static ") - (js2-print-ast elem 0)) ;; TODO(sdh): indentation isn't quite right - (js2-print-ast elem (1+ i)))) - (insert "\n" pad "}"))) - -(cl-defstruct (js2-computed-prop-name-node - (:include js2-node) - (:constructor make-js2-computed-prop-name-node - (&key - (type js2-LB) - expr - (pos (js2-current-token-beg)) - (len (- js2-ts-cursor - (js2-current-token-beg)))))) - "AST node for a `ComputedPropertyName'." - expr) - -(js2--struct-put 'js2-computed-prop-name-node 'js2-visitor 'js2-visit-computed-prop-name-node) -(js2--struct-put 'js2-computed-prop-name-node 'js2-printer 'js2-print-computed-prop-name-node) - -(defun js2-visit-computed-prop-name-node (n v) - (js2-visit-ast (js2-computed-prop-name-node-expr n) v)) - -(defun js2-print-computed-prop-name-node (n i) - (insert (js2-make-pad i) "[") - (js2-print-ast (js2-computed-prop-name-node-expr n) 0) - (insert "]")) - -(cl-defstruct (js2-object-prop-node - (:include js2-infix-node) - (:constructor make-js2-object-prop-node (&key (type js2-COLON) - (pos js2-ts-cursor) - len left - right op-pos))) - "AST node for an object literal prop:value entry. -The `left' field is the property: a name node, string node, -number node or expression node. The `right' field is a -`js2-node' representing the initializer value. If the property -is abbreviated, the node's `SHORTHAND' property is non-nil and -both fields have the same value.") - -(js2--struct-put 'js2-object-prop-node 'js2-visitor 'js2-visit-infix-node) -(js2--struct-put 'js2-object-prop-node 'js2-printer 'js2-print-object-prop-node) - -(defun js2-print-object-prop-node (n i) - (let* ((left (js2-object-prop-node-left n)) - (right (js2-object-prop-node-right n))) - (js2-print-ast left i) - (if (not (js2-node-get-prop n 'SHORTHAND)) - (progn - (insert ": ") - (js2-print-ast right 0))))) - -(cl-defstruct (js2-method-node - (:include js2-infix-node) - (:constructor make-js2-method-node (&key (pos js2-ts-cursor) - len left right))) - "AST node for a method in an object literal or a class body. -The `left' field is the `js2-name-node' naming the method. -The `right' field is always an anonymous `js2-function-node' with a node -property `METHOD_TYPE' set to 'GET or 'SET. ") - -(js2--struct-put 'js2-method-node 'js2-visitor 'js2-visit-infix-node) -(js2--struct-put 'js2-method-node 'js2-printer 'js2-print-method) - -(defun js2-print-method (n i) - (let* ((pad (js2-make-pad i)) - (left (js2-method-node-left n)) - (right (js2-method-node-right n)) - (type (js2-node-get-prop right 'METHOD_TYPE))) - (insert pad) - (when type - (insert (cdr (assoc type '((GET . "get ") - (SET . "set ") - (ASYNC . "async ") - (FUNCTION . "")))))) - (when (and (js2-function-node-p right) - (eq 'STAR (js2-function-node-generator-type right))) - (insert "*")) - (js2-print-ast left 0) - (js2-print-ast right 0))) - -(cl-defstruct (js2-prop-get-node - (:include js2-infix-node) - (:constructor make-js2-prop-get-node (&key (type js2-GETPROP) - (pos js2-ts-cursor) - len left right))) - "AST node for a dotted property reference, e.g. foo.bar or foo().bar") - -(js2--struct-put 'js2-prop-get-node 'js2-visitor 'js2-visit-prop-get-node) -(js2--struct-put 'js2-prop-get-node 'js2-printer 'js2-print-prop-get-node) - -(defun js2-visit-prop-get-node (n v) - (js2-visit-ast (js2-prop-get-node-left n) v) - (js2-visit-ast (js2-prop-get-node-right n) v)) - -(defun js2-print-prop-get-node (n i) - (insert (js2-make-pad i)) - (js2-print-ast (js2-prop-get-node-left n) 0) - (insert ".") - (js2-print-ast (js2-prop-get-node-right n) 0)) - -(cl-defstruct (js2-elem-get-node - (:include js2-node) - (:constructor make-js2-elem-get-node (&key (type js2-GETELEM) - (pos js2-ts-cursor) - len target element - lb rb))) - "AST node for an array index expression such as foo[bar]." - target ; a `js2-node' - the expression preceding the "." - element ; a `js2-node' - the expression in brackets - lb ; position of left-bracket, nil if omitted - rb) ; position of right-bracket, nil if omitted - -(js2--struct-put 'js2-elem-get-node 'js2-visitor 'js2-visit-elem-get-node) -(js2--struct-put 'js2-elem-get-node 'js2-printer 'js2-print-elem-get-node) - -(defun js2-visit-elem-get-node (n v) - (js2-visit-ast (js2-elem-get-node-target n) v) - (js2-visit-ast (js2-elem-get-node-element n) v)) - -(defun js2-print-elem-get-node (n i) - (insert (js2-make-pad i)) - (js2-print-ast (js2-elem-get-node-target n) 0) - (insert "[") - (js2-print-ast (js2-elem-get-node-element n) 0) - (insert "]")) - -(cl-defstruct (js2-call-node - (:include js2-node) - (:constructor make-js2-call-node (&key (type js2-CALL) - (pos js2-ts-cursor) - len target args - lp rp))) - "AST node for a JavaScript function call." - target ; a `js2-node' evaluating to the function to call - args ; a Lisp list of `js2-node' arguments - lp ; position of open-paren, or nil if missing - rp) ; position of close-paren, or nil if missing - -(js2--struct-put 'js2-call-node 'js2-visitor 'js2-visit-call-node) -(js2--struct-put 'js2-call-node 'js2-printer 'js2-print-call-node) - -(defun js2-visit-call-node (n v) - (js2-visit-ast (js2-call-node-target n) v) - (dolist (arg (js2-call-node-args n)) - (js2-visit-ast arg v))) - -(defun js2-print-call-node (n i) - (insert (js2-make-pad i)) - (js2-print-ast (js2-call-node-target n) 0) - (insert "(") - (js2-print-list (js2-call-node-args n)) - (insert ")")) - -(cl-defstruct (js2-yield-node - (:include js2-node) - (:constructor make-js2-yield-node (&key (type js2-YIELD) - (pos js2-ts-cursor) - len value star-p))) - "AST node for yield statement or expression." - star-p ; whether it's yield* - value) ; optional: value to be yielded - -(js2--struct-put 'js2-yield-node 'js2-visitor 'js2-visit-yield-node) -(js2--struct-put 'js2-yield-node 'js2-printer 'js2-print-yield-node) - -(defun js2-visit-yield-node (n v) - (js2-visit-ast (js2-yield-node-value n) v)) - -(defun js2-print-yield-node (n i) - (insert (js2-make-pad i)) - (insert "yield") - (when (js2-yield-node-star-p n) - (insert "*")) - (when (js2-yield-node-value n) - (insert " ") - (js2-print-ast (js2-yield-node-value n) 0))) - -(cl-defstruct (js2-paren-node - (:include js2-node) - (:constructor make-js2-paren-node (&key (type js2-LP) - (pos js2-ts-cursor) - len expr))) - "AST node for a parenthesized expression. -In particular, used when the parens are syntactically optional, -as opposed to required parens such as those enclosing an if-conditional." - expr) ; `js2-node' - -(js2--struct-put 'js2-paren-node 'js2-visitor 'js2-visit-paren-node) -(js2--struct-put 'js2-paren-node 'js2-printer 'js2-print-paren-node) - -(defun js2-visit-paren-node (n v) - (js2-visit-ast (js2-paren-node-expr n) v)) - -(defun js2-print-paren-node (n i) - (insert (js2-make-pad i)) - (insert "(") - (js2-print-ast (js2-paren-node-expr n) 0) - (insert ")")) - -(cl-defstruct (js2-comp-node - (:include js2-scope) - (:constructor make-js2-comp-node (&key (type js2-ARRAYCOMP) - (pos js2-ts-cursor) - len result - loops filters - form))) - "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-comp-loop-node' - filters ; a Lisp list of guard/filter expressions - form ; ARRAY, LEGACY_ARRAY or STAR_GENERATOR - ; SpiderMonkey also supports "legacy generator expressions", but we dont. - ) - -(js2--struct-put 'js2-comp-node 'js2-visitor 'js2-visit-comp-node) -(js2--struct-put 'js2-comp-node 'js2-printer 'js2-print-comp-node) - -(defun js2-visit-comp-node (n v) - (js2-visit-ast (js2-comp-node-result n) v) - (dolist (l (js2-comp-node-loops n)) - (js2-visit-ast l v)) - (dolist (f (js2-comp-node-filters n)) - (js2-visit-ast f v))) - -(defun js2-print-comp-node (n i) - (let ((pad (js2-make-pad i)) - (result (js2-comp-node-result n)) - (loops (js2-comp-node-loops n)) - (filters (js2-comp-node-filters n)) - (legacy-p (eq (js2-comp-node-form n) 'LEGACY_ARRAY)) - (gen-p (eq (js2-comp-node-form n) 'STAR_GENERATOR))) - (insert pad (if gen-p "(" "[")) - (when legacy-p - (js2-print-ast result 0)) - (dolist (l loops) - (when legacy-p - (insert " ")) - (js2-print-ast l 0) - (unless legacy-p - (insert " "))) - (dolist (f filters) - (when legacy-p - (insert " ")) - (insert "if (") - (js2-print-ast f 0) - (insert ")") - (unless legacy-p - (insert " "))) - (unless legacy-p - (js2-print-ast result 0)) - (insert (if gen-p ")" "]")))) - -(cl-defstruct (js2-comp-loop-node - (:include js2-for-in-node) - (:constructor make-js2-comp-loop-node (&key (type js2-FOR) - (pos js2-ts-cursor) - len iterator - object in-pos - foreach-p - each-pos - forof-p - lp rp))) - "AST subtree for each 'for (foo in bar)' loop in an array comprehension.") - -(js2--struct-put 'js2-comp-loop-node 'js2-visitor 'js2-visit-comp-loop) -(js2--struct-put 'js2-comp-loop-node 'js2-printer 'js2-print-comp-loop) - -(defun js2-visit-comp-loop (n v) - (js2-visit-ast (js2-comp-loop-node-iterator n) v) - (js2-visit-ast (js2-comp-loop-node-object n) v)) - -(defun js2-print-comp-loop (n _i) - (insert "for ") - (when (js2-comp-loop-node-foreach-p n) (insert "each ")) - (insert "(") - (js2-print-ast (js2-comp-loop-node-iterator n) 0) - (insert (if (js2-comp-loop-node-forof-p n) - " of " " in ")) - (js2-print-ast (js2-comp-loop-node-object n) 0) - (insert ")")) - -(cl-defstruct (js2-empty-expr-node - (:include js2-node) - (:constructor make-js2-empty-expr-node (&key (type js2-EMPTY) - (pos (js2-current-token-beg)) - len))) - "AST node for an empty expression.") - -(js2--struct-put 'js2-empty-expr-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-empty-expr-node 'js2-printer 'js2-print-none) - -(cl-defstruct (js2-xml-node - (:include js2-block-node) - (:constructor make-js2-xml-node (&key (type js2-XML) - (pos (js2-current-token-beg)) - len kids))) - "AST node for initial parse of E4X literals. -The kids field is a list of XML fragments, each a `js2-string-node' or -a `js2-xml-js-expr-node'. Equivalent to Rhino's XmlLiteral node.") - -(js2--struct-put 'js2-xml-node 'js2-visitor 'js2-visit-block) -(js2--struct-put 'js2-xml-node 'js2-printer 'js2-print-xml-node) - -(defun js2-print-xml-node (n i) - (dolist (kid (js2-xml-node-kids n)) - (js2-print-ast kid i))) - -(cl-defstruct (js2-xml-js-expr-node - (:include js2-xml-node) - (:constructor make-js2-xml-js-expr-node (&key (type js2-XML) - (pos js2-ts-cursor) - len expr))) - "AST node for an embedded JavaScript {expression} in an E4X literal. -The start and end fields correspond to the curly-braces." - expr) ; a `js2-expr-node' of some sort - -(js2--struct-put 'js2-xml-js-expr-node 'js2-visitor 'js2-visit-xml-js-expr) -(js2--struct-put 'js2-xml-js-expr-node 'js2-printer 'js2-print-xml-js-expr) - -(defun js2-visit-xml-js-expr (n v) - (js2-visit-ast (js2-xml-js-expr-node-expr n) v)) - -(defun js2-print-xml-js-expr (n i) - (insert (js2-make-pad i)) - (insert "{") - (js2-print-ast (js2-xml-js-expr-node-expr n) 0) - (insert "}")) - -(cl-defstruct (js2-xml-dot-query-node - (:include js2-infix-node) - (:constructor make-js2-xml-dot-query-node (&key (type js2-DOTQUERY) - (pos js2-ts-cursor) - op-pos len left - right rp))) - "AST node for an E4X foo.(bar) filter expression. -Note that the left-paren is automatically the character immediately -following the dot (.) in the operator. No whitespace is permitted -between the dot and the lp by the scanner." - rp) - -(js2--struct-put 'js2-xml-dot-query-node 'js2-visitor 'js2-visit-infix-node) -(js2--struct-put 'js2-xml-dot-query-node 'js2-printer 'js2-print-xml-dot-query) - -(defun js2-print-xml-dot-query (n i) - (insert (js2-make-pad i)) - (js2-print-ast (js2-xml-dot-query-node-left n) 0) - (insert ".(") - (js2-print-ast (js2-xml-dot-query-node-right n) 0) - (insert ")")) - -(cl-defstruct (js2-xml-ref-node - (:include js2-node) - (:constructor nil)) ; abstract - "Base type for E4X XML attribute-access or property-get expressions. -Such expressions can take a variety of forms. The general syntax has -three parts: - - - (optional) an @ (specifying an attribute access) - - (optional) a namespace (a `js2-name-node') and double-colon - - (required) either a `js2-name-node' or a bracketed [expression] - -The property-name expressions (examples: ns::name, @name) are -represented as `js2-xml-prop-ref' nodes. The bracketed-expression -versions (examples: ns::[name], @[name]) become `js2-xml-elem-ref' nodes. - -This node type (or more specifically, its subclasses) will sometimes -be the right-hand child of a `js2-prop-get-node' or a -`js2-infix-node' of type `js2-DOTDOT', the .. xml-descendants operator. -The `js2-xml-ref-node' may also be a standalone primary expression with -no explicit target, which is valid in certain expression contexts such as - - company..employee.(@id < 100) - -in this case, the @id is a `js2-xml-ref' that is part of an infix '<' -expression whose parent is a `js2-xml-dot-query-node'." - namespace - at-pos - colon-pos) - -(defsubst js2-xml-ref-node-attr-access-p (node) - "Return non-nil if this expression began with an @-token." - (and (numberp (js2-xml-ref-node-at-pos node)) - (cl-plusp (js2-xml-ref-node-at-pos node)))) - -(cl-defstruct (js2-xml-prop-ref-node - (:include js2-xml-ref-node) - (:constructor make-js2-xml-prop-ref-node (&key (type js2-REF_NAME) - (pos (js2-current-token-beg)) - len propname - namespace at-pos - colon-pos))) - "AST node for an E4X XML [expr] property-ref expression. -The JavaScript syntax is an optional @, an optional ns::, and a name. - - [ '@' ] [ name '::' ] name - -Examples include name, ns::name, ns::*, *::name, *::*, @attr, @ns::attr, -@ns::*, @*::attr, @*::*, and @*. - -The node starts at the @ token, if present. Otherwise it starts at the -namespace name. The node bounds extend through the closing right-bracket, -or if it is missing due to a syntax error, through the end of the index -expression." - propname) - -(js2--struct-put 'js2-xml-prop-ref-node 'js2-visitor 'js2-visit-xml-prop-ref-node) -(js2--struct-put 'js2-xml-prop-ref-node 'js2-printer 'js2-print-xml-prop-ref-node) - -(defun js2-visit-xml-prop-ref-node (n v) - (js2-visit-ast (js2-xml-prop-ref-node-namespace n) v) - (js2-visit-ast (js2-xml-prop-ref-node-propname n) v)) - -(defun js2-print-xml-prop-ref-node (n i) - (insert (js2-make-pad i)) - (if (js2-xml-ref-node-attr-access-p n) - (insert "@")) - (when (js2-xml-prop-ref-node-namespace n) - (js2-print-ast (js2-xml-prop-ref-node-namespace n) 0) - (insert "::")) - (if (js2-xml-prop-ref-node-propname n) - (js2-print-ast (js2-xml-prop-ref-node-propname n) 0))) - -(cl-defstruct (js2-xml-elem-ref-node - (:include js2-xml-ref-node) - (:constructor make-js2-xml-elem-ref-node (&key (type js2-REF_MEMBER) - (pos (js2-current-token-beg)) - len expr lb rb - namespace at-pos - colon-pos))) - "AST node for an E4X XML [expr] member-ref expression. -Syntax: - - [ '@' ] [ name '::' ] '[' expr ']' - -Examples include ns::[expr], @ns::[expr], @[expr], *::[expr] and @*::[expr]. - -Note that the form [expr] (i.e. no namespace or attribute-qualifier) -is not a legal E4X XML element-ref expression, since it's already used -for standard JavaScript element-get array indexing. Hence, a -`js2-xml-elem-ref-node' always has either the attribute-qualifier, a -non-nil namespace node, or both. - -The node starts at the @ token, if present. Otherwise it starts -at the namespace name. The node bounds extend through the closing -right-bracket, or if it is missing due to a syntax error, through the -end of the index expression." - expr ; the bracketed index expression - lb - rb) - -(js2--struct-put 'js2-xml-elem-ref-node 'js2-visitor 'js2-visit-xml-elem-ref-node) -(js2--struct-put 'js2-xml-elem-ref-node 'js2-printer 'js2-print-xml-elem-ref-node) - -(defun js2-visit-xml-elem-ref-node (n v) - (js2-visit-ast (js2-xml-elem-ref-node-namespace n) v) - (js2-visit-ast (js2-xml-elem-ref-node-expr n) v)) - -(defun js2-print-xml-elem-ref-node (n i) - (insert (js2-make-pad i)) - (if (js2-xml-ref-node-attr-access-p n) - (insert "@")) - (when (js2-xml-elem-ref-node-namespace n) - (js2-print-ast (js2-xml-elem-ref-node-namespace n) 0) - (insert "::")) - (insert "[") - (if (js2-xml-elem-ref-node-expr n) - (js2-print-ast (js2-xml-elem-ref-node-expr n) 0)) - (insert "]")) - -;;; Placeholder nodes for when we try parsing the XML literals structurally. - -(cl-defstruct (js2-xml-start-tag-node - (:include js2-xml-node) - (:constructor make-js2-xml-start-tag-node (&key (type js2-XML) - (pos js2-ts-cursor) - len name attrs kids - empty-p))) - "AST node for an XML start-tag. Not currently used. -The `kids' field is a Lisp list of child content nodes." - name ; a `js2-xml-name-node' - attrs ; a Lisp list of `js2-xml-attr-node' - empty-p) ; t if this is an empty element such as <foo bar="baz"/> - -(js2--struct-put 'js2-xml-start-tag-node 'js2-visitor 'js2-visit-xml-start-tag) -(js2--struct-put 'js2-xml-start-tag-node 'js2-printer 'js2-print-xml-start-tag) - -(defun js2-visit-xml-start-tag (n v) - (js2-visit-ast (js2-xml-start-tag-node-name n) v) - (dolist (attr (js2-xml-start-tag-node-attrs n)) - (js2-visit-ast attr v)) - (js2-visit-block n v)) - -(defun js2-print-xml-start-tag (n i) - (insert (js2-make-pad i) "<") - (js2-print-ast (js2-xml-start-tag-node-name n) 0) - (when (js2-xml-start-tag-node-attrs n) - (insert " ") - (js2-print-list (js2-xml-start-tag-node-attrs n) " ")) - (insert ">")) - -;; I -think- I'm going to make the parent node the corresponding start-tag, -;; and add the end-tag to the kids list of the parent as well. -(cl-defstruct (js2-xml-end-tag-node - (:include js2-xml-node) - (:constructor make-js2-xml-end-tag-node (&key (type js2-XML) - (pos js2-ts-cursor) - len name))) - "AST node for an XML end-tag. Not currently used." - name) ; a `js2-xml-name-node' - -(js2--struct-put 'js2-xml-end-tag-node 'js2-visitor 'js2-visit-xml-end-tag) -(js2--struct-put 'js2-xml-end-tag-node 'js2-printer 'js2-print-xml-end-tag) - -(defun js2-visit-xml-end-tag (n v) - (js2-visit-ast (js2-xml-end-tag-node-name n) v)) - -(defun js2-print-xml-end-tag (n i) - (insert (js2-make-pad i)) - (insert "</") - (js2-print-ast (js2-xml-end-tag-node-name n) 0) - (insert ">")) - -(cl-defstruct (js2-xml-name-node - (:include js2-xml-node) - (:constructor make-js2-xml-name-node (&key (type js2-XML) - (pos js2-ts-cursor) - len namespace kids))) - "AST node for an E4X XML name. Not currently used. -Any XML name can be qualified with a namespace, hence the namespace field. -Further, any E4X name can be comprised of arbitrary JavaScript {} expressions. -The kids field is a list of `js2-name-node' and `js2-xml-js-expr-node'. -For a simple name, the kids list has exactly one node, a `js2-name-node'." - namespace) ; a `js2-string-node' - -(js2--struct-put 'js2-xml-name-node 'js2-visitor 'js2-visit-xml-name-node) -(js2--struct-put 'js2-xml-name-node 'js2-printer 'js2-print-xml-name-node) - -(defun js2-visit-xml-name-node (n v) - (js2-visit-ast (js2-xml-name-node-namespace n) v)) - -(defun js2-print-xml-name-node (n i) - (insert (js2-make-pad i)) - (when (js2-xml-name-node-namespace n) - (js2-print-ast (js2-xml-name-node-namespace n) 0) - (insert "::")) - (dolist (kid (js2-xml-name-node-kids n)) - (js2-print-ast kid 0))) - -(cl-defstruct (js2-xml-pi-node - (:include js2-xml-node) - (:constructor make-js2-xml-pi-node (&key (type js2-XML) - (pos js2-ts-cursor) - len name attrs))) - "AST node for an E4X XML processing instruction. Not currently used." - name ; a `js2-xml-name-node' - attrs) ; a list of `js2-xml-attr-node' - -(js2--struct-put 'js2-xml-pi-node 'js2-visitor 'js2-visit-xml-pi-node) -(js2--struct-put 'js2-xml-pi-node 'js2-printer 'js2-print-xml-pi-node) - -(defun js2-visit-xml-pi-node (n v) - (js2-visit-ast (js2-xml-pi-node-name n) v) - (dolist (attr (js2-xml-pi-node-attrs n)) - (js2-visit-ast attr v))) - -(defun js2-print-xml-pi-node (n i) - (insert (js2-make-pad i) "<?") - (js2-print-ast (js2-xml-pi-node-name n)) - (when (js2-xml-pi-node-attrs n) - (insert " ") - (js2-print-list (js2-xml-pi-node-attrs n))) - (insert "?>")) - -(cl-defstruct (js2-xml-cdata-node - (:include js2-xml-node) - (:constructor make-js2-xml-cdata-node (&key (type js2-XML) - (pos js2-ts-cursor) - len content))) - "AST node for a CDATA escape section. Not currently used." - content) ; a `js2-string-node' with node-property 'quote-type 'cdata - -(js2--struct-put 'js2-xml-cdata-node 'js2-visitor 'js2-visit-xml-cdata-node) -(js2--struct-put 'js2-xml-cdata-node 'js2-printer 'js2-print-xml-cdata-node) - -(defun js2-visit-xml-cdata-node (n v) - (js2-visit-ast (js2-xml-cdata-node-content n) v)) - -(defun js2-print-xml-cdata-node (n i) - (insert (js2-make-pad i)) - (js2-print-ast (js2-xml-cdata-node-content n))) - -(cl-defstruct (js2-xml-attr-node - (:include js2-xml-node) - (:constructor make-js2-attr-node (&key (type js2-XML) - (pos js2-ts-cursor) - len name value - eq-pos quote-type))) - "AST node representing a foo='bar' XML attribute value. Not yet used." - name ; a `js2-xml-name-node' - value ; a `js2-xml-name-node' - eq-pos ; buffer position of "=" sign - quote-type) ; 'single or 'double - -(js2--struct-put 'js2-xml-attr-node 'js2-visitor 'js2-visit-xml-attr-node) -(js2--struct-put 'js2-xml-attr-node 'js2-printer 'js2-print-xml-attr-node) - -(defun js2-visit-xml-attr-node (n v) - (js2-visit-ast (js2-xml-attr-node-name n) v) - (js2-visit-ast (js2-xml-attr-node-value n) v)) - -(defun js2-print-xml-attr-node (n i) - (let ((quote (if (eq (js2-xml-attr-node-quote-type n) 'single) - "'" - "\""))) - (insert (js2-make-pad i)) - (js2-print-ast (js2-xml-attr-node-name n) 0) - (insert "=" quote) - (js2-print-ast (js2-xml-attr-node-value n) 0) - (insert quote))) - -(cl-defstruct (js2-xml-text-node - (:include js2-xml-node) - (:constructor make-js2-text-node (&key (type js2-XML) - (pos js2-ts-cursor) - len content))) - "AST node for an E4X XML text node. Not currently used." - content) ; a Lisp list of `js2-string-node' and `js2-xml-js-expr-node' - -(js2--struct-put 'js2-xml-text-node 'js2-visitor 'js2-visit-xml-text-node) -(js2--struct-put 'js2-xml-text-node 'js2-printer 'js2-print-xml-text-node) - -(defun js2-visit-xml-text-node (n v) - (js2-visit-ast (js2-xml-text-node-content n) v)) - -(defun js2-print-xml-text-node (n i) - (insert (js2-make-pad i)) - (dolist (kid (js2-xml-text-node-content n)) - (js2-print-ast kid))) - -(cl-defstruct (js2-xml-comment-node - (:include js2-xml-node) - (:constructor make-js2-xml-comment-node (&key (type js2-XML) - (pos js2-ts-cursor) - len))) - "AST node for E4X XML comment. Not currently used.") - -(js2--struct-put 'js2-xml-comment-node 'js2-visitor 'js2-visit-none) -(js2--struct-put 'js2-xml-comment-node 'js2-printer 'js2-print-xml-comment) - -(defun js2-print-xml-comment (n i) - (insert (js2-make-pad i) - (js2-node-string n))) - -;;; Node utilities - -(defsubst js2-node-line (n) - "Fetch the source line number at the start of node N. -This is O(n) in the length of the source buffer; use prudently." - (1+ (count-lines (point-min) (js2-node-abs-pos n)))) - -(defsubst js2-block-node-kid (n i) - "Return child I of node N, or nil if there aren't that many." - (nth i (js2-block-node-kids n))) - -(defsubst js2-block-node-first (n) - "Return first child of block node N, or nil if there is none." - (cl-first (js2-block-node-kids n))) - -(defun js2-node-root (n) - "Return the root of the AST containing N. -If N has no parent pointer, returns N." - (let ((parent (js2-node-parent n))) - (if parent - (js2-node-root parent) - n))) - -(defsubst js2-node-short-name (n) - "Return the short name of node N as a string, e.g. `js2-if-node'." - (let ((name (symbol-name (aref n 0)))) - (if (string-prefix-p "cl-struct-" name) - (substring (symbol-name (aref n 0)) - (length "cl-struct-")) - name))) - -(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. -Returns nil for zero-length child lists or unsupported nodes." - (cond - ((js2-function-node-p node) - (js2-function-node-params node)) - ((js2-block-node-p node) - (js2-block-node-kids node)) - ((js2-try-node-p node) - (js2-try-node-catch-clauses node)) - ((js2-array-node-p node) - (js2-array-node-elems node)) - ((js2-object-node-p node) - (js2-object-node-elems node)) - ((js2-call-node-p node) - (js2-call-node-args node)) - ((js2-new-node-p node) - (js2-new-node-args node)) - ((js2-var-decl-node-p node) - (js2-var-decl-node-kids node)) - (t - nil))) - -(defun js2-node-set-child-list (node kids) - "Set the child list for NODE to KIDS." - (cond - ((js2-function-node-p node) - (setf (js2-function-node-params node) kids)) - ((js2-block-node-p node) - (setf (js2-block-node-kids node) kids)) - ((js2-try-node-p node) - (setf (js2-try-node-catch-clauses node) kids)) - ((js2-array-node-p node) - (setf (js2-array-node-elems node) kids)) - ((js2-object-node-p node) - (setf (js2-object-node-elems node) kids)) - ((js2-call-node-p node) - (setf (js2-call-node-args node) kids)) - ((js2-new-node-p node) - (setf (js2-new-node-args node) kids)) - ((js2-var-decl-node-p node) - (setf (js2-var-decl-node-kids node) kids)) - (t - (error "Unsupported node type: %s" (js2-node-short-name node)))) - kids) - -;; All because Common Lisp doesn't support multiple inheritance for defstructs. -(defconst js2-paren-expr-nodes - '(cl-struct-js2-comp-loop-node - cl-struct-js2-comp-node - cl-struct-js2-call-node - cl-struct-js2-catch-node - cl-struct-js2-do-node - cl-struct-js2-elem-get-node - cl-struct-js2-for-in-node - cl-struct-js2-for-node - cl-struct-js2-function-node - cl-struct-js2-if-node - cl-struct-js2-let-node - cl-struct-js2-new-node - cl-struct-js2-paren-node - cl-struct-js2-switch-node - cl-struct-js2-while-node - cl-struct-js2-with-node - cl-struct-js2-xml-dot-query-node) - "Node types that can have a parenthesized child expression. -In particular, nodes that respond to `js2-node-lp' and `js2-node-rp'.") - -(defsubst js2-paren-expr-node-p (node) - "Return t for nodes that typically have a parenthesized child expression. -Useful for computing the indentation anchors for arg-lists and conditions. -Note that it may return a false positive, for instance when NODE is -a `js2-new-node' and there are no arguments or parentheses." - (memq (aref node 0) js2-paren-expr-nodes)) - -;; Fake polymorphism... yech. -(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." - (cond - ((js2-elem-get-node-p node) - (js2-elem-get-node-lb node)) - ((js2-loop-node-p node) - (js2-loop-node-lp node)) - ((js2-function-node-p node) - (js2-function-node-lp node)) - ((js2-if-node-p node) - (js2-if-node-lp node)) - ((js2-new-node-p node) - (js2-new-node-lp node)) - ((js2-call-node-p node) - (js2-call-node-lp node)) - ((js2-paren-node-p node) - 0) - ((js2-switch-node-p node) - (js2-switch-node-lp node)) - ((js2-catch-node-p node) - (js2-catch-node-lp node)) - ((js2-let-node-p node) - (js2-let-node-lp node)) - ((js2-comp-node-p node) - 0) - ((js2-with-node-p node) - (js2-with-node-lp node)) - ((js2-xml-dot-query-node-p node) - (1+ (js2-infix-node-op-pos node))) - (t - (error "Unsupported node type: %s" (js2-node-short-name node))))) - -;; Fake polymorphism... blech. -(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." - (cond - ((js2-elem-get-node-p node) - (js2-elem-get-node-rb node)) - ((js2-loop-node-p node) - (js2-loop-node-rp node)) - ((js2-function-node-p node) - (js2-function-node-rp node)) - ((js2-if-node-p node) - (js2-if-node-rp node)) - ((js2-new-node-p node) - (js2-new-node-rp node)) - ((js2-call-node-p node) - (js2-call-node-rp node)) - ((js2-paren-node-p node) - (1- (js2-node-len node))) - ((js2-switch-node-p node) - (js2-switch-node-rp node)) - ((js2-catch-node-p node) - (js2-catch-node-rp node)) - ((js2-let-node-p node) - (js2-let-node-rp node)) - ((js2-comp-node-p node) - (1- (js2-node-len node))) - ((js2-with-node-p node) - (js2-with-node-rp node)) - ((js2-xml-dot-query-node-p node) - (1+ (js2-xml-dot-query-node-rp node))) - (t - (error "Unsupported node type: %s" (js2-node-short-name node))))) - -(defsubst js2-node-first-child (node) - "Return the first element of `js2-node-child-list' for NODE." - (car (js2-node-child-list node))) - -(defsubst js2-node-last-child (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) - "Return the previous statement in parent. -Works for parents supported by `js2-node-child-list'. -Returns nil if NODE is not in the parent, or PARENT is -not a supported node, or if NODE is the first child." - (let* ((p (js2-node-parent node)) - (kids (js2-node-child-list p)) - (sib (car kids))) - (while (and kids - (not (eq node (cadr kids)))) - (setq kids (cdr kids) - sib (car kids))) - sib)) - -(defun js2-node-next-sibling (node) - "Return the next statement in parent block. -Returns nil if NODE is not in the block, or PARENT is not -a block node, or if NODE is the last statement." - (let* ((p (js2-node-parent node)) - (kids (js2-node-child-list p))) - (while (and kids - (not (eq node (car kids)))) - (setq kids (cdr kids))) - (cadr kids))) - -(defun js2-node-find-child-before (pos parent &optional after) - "Find the last child that starts before POS in parent. -If AFTER is non-nil, returns first child starting after POS. -POS is an absolute buffer position. PARENT is any node -supported by `js2-node-child-list'. -Returns nil if no applicable child is found." - (let ((kids (if (js2-function-node-p parent) - (js2-block-node-kids (js2-function-node-body parent)) - (js2-node-child-list parent))) - (beg (js2-node-abs-pos (if (js2-function-node-p parent) - (js2-function-node-body parent) - parent))) - kid result fn - (continue t)) - (setq fn (if after '>= '<)) - (while (and kids continue) - (setq kid (car kids)) - (if (funcall fn (+ beg (js2-node-pos kid)) pos) - (setq result kid - continue (not after)) - (setq continue after)) - (setq kids (cdr kids))) - result)) - -(defun js2-node-find-child-after (pos parent) - "Find first child that starts after POS in parent. -POS is an absolute buffer position. PARENT is any node -supported by `js2-node-child-list'. -Returns nil if no applicable child is found." - (js2-node-find-child-before pos parent 'after)) - -(defun js2-node-replace-child (pos parent new-node) - "Replace node at index POS in PARENT with NEW-NODE. -Only works for parents supported by `js2-node-child-list'." - (let ((kids (js2-node-child-list parent)) - (i 0)) - (while (< i pos) - (setq kids (cdr kids) - i (1+ i))) - (setcar kids new-node) - (js2-node-add-children parent new-node))) - -(defun js2-node-buffer (n) - "Return the buffer associated with AST N. -Returns nil if the buffer is not set as a property on the root -node, or if parent links were not recorded during parsing." - (let ((root (js2-node-root n))) - (and root - (js2-ast-root-p root) - (js2-ast-root-buffer root)))) - -(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." - (let ((kids (js2-node-child-list n))) - (if kids - (setcdr kids (nconc (cdr kids) (list kid))) - (js2-node-set-child-list n (list kid))) - (js2-node-add-children n kid))) - -(defun js2-node-string (node) - (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) - -;; Keep track of absolute node position during traversals. -(js2-deflocal js2-visitor-offset nil) - -(js2-deflocal js2-node-search-point nil) - -(when js2-mode-dev-mode-p - (defun js2-find-node-at-point () - (interactive) - (let ((node (js2-node-at-point))) - (message "%s" (or node "No node found at point")))) - (defun js2-node-name-at-point () - (interactive) - (let ((node (js2-node-at-point))) - (message "%s" (if node - (js2-node-short-name node) - "No node found at point."))))) - -(defun js2-node-at-point (&optional pos skip-comments) - "Return AST node at POS, a buffer position, defaulting to current point. -The `js2-mode-ast' variable must be set to the current parse tree. -Signals an error if the AST (`js2-mode-ast') is nil. -Always returns a node - if it can't find one, it returns the root. -If SKIP-COMMENTS is non-nil, comment nodes are ignored." - (let ((ast js2-mode-ast) - result) - (unless ast - (error "No JavaScript AST available")) - ;; Look through comments first, since they may be inside nodes that - ;; would otherwise report a match. - (setq pos (or pos (point)) - result (if (> pos (js2-node-abs-end ast)) - ast - (if (not skip-comments) - (js2-comment-at-point pos)))) - (unless result - (setq js2-discovered-node nil - js2-visitor-offset 0 - js2-node-search-point pos) - (unwind-protect - (catch 'js2-visit-done - (js2-visit-ast ast #'js2-node-at-point-visitor)) - (setq js2-visitor-offset nil - js2-node-search-point nil)) - (setq result js2-discovered-node)) - ;; may have found a comment beyond end of last child node, - ;; since visiting the ast-root looks at the comment-list last. - (if (and skip-comments - (js2-comment-node-p result)) - (setq result nil)) - (or result js2-mode-ast))) - -(defun js2-node-at-point-visitor (node end-p) - (let ((rel-pos (js2-node-pos node)) - abs-pos - abs-end - (point js2-node-search-point)) - (cond - (end-p - ;; this evaluates to a non-nil return value, even if it's zero - (cl-decf js2-visitor-offset rel-pos)) - ;; we already looked for comments before visiting, and don't want them now - ((js2-comment-node-p node) - nil) - (t - (setq abs-pos (cl-incf js2-visitor-offset rel-pos) - ;; we only want to use the node if the point is before - ;; the last character position in the node, so we decrement - ;; the absolute end by 1. - abs-end (+ abs-pos (js2-node-len node) -1)) - (cond - ;; If this node starts after search-point, stop the search. - ((> abs-pos point) - (throw 'js2-visit-done nil)) - ;; If this node ends before the search-point, don't check kids. - ((> point abs-end) - nil) - (t - ;; Otherwise point is within this node, possibly in a child. - (setq js2-discovered-node node) - t)))))) ; keep processing kids to look for more specific match - -(defsubst js2-block-comment-p (node) - "Return non-nil if NODE is a comment node of format `jsdoc' or `block'." - (and (js2-comment-node-p node) - (memq (js2-comment-node-format node) '(jsdoc block)))) - -;; TODO: put the comments in a vector and binary-search them instead -(defun js2-comment-at-point (&optional pos) - "Look through scanned comment nodes for one containing POS. -POS is a buffer position that defaults to current point. -Function returns nil if POS was not in any comment node." - (let ((ast js2-mode-ast) - (x (or pos (point))) - beg end) - (unless ast - (error "No JavaScript AST available")) - (catch 'done - ;; Comments are stored in lexical order. - (dolist (comment (js2-ast-root-comments ast) nil) - (setq beg (js2-node-abs-pos comment) - end (+ beg (js2-node-len comment))) - (if (and (>= x beg) - (<= x end)) - (throw 'done comment)))))) - -(defun js2-comments-between (start end comments-list) - "Return comment nodes between START and END, nil if not found. -START and END are absolute positions in current buffer. -COMMENTS-LIST is the comments list to check." - (let (comments c-start c-end) - (nreverse - (dolist (comment comments-list comments) - (setq c-start (js2-node-abs-pos comment) - c-end (1- (+ c-start (js2-node-len comment)))) - (unless (or (< c-end start) - (> c-start end)) - (push comment comments)))))) - -(defun js2-mode-find-parent-fn (node) - "Find function enclosing NODE. -Returns nil if NODE is not inside a function." - (setq node (js2-node-parent node)) - (while (and node (not (js2-function-node-p node))) - (setq node (js2-node-parent node))) - (and (js2-function-node-p node) node)) - -(defun js2-mode-find-enclosing-fn (node) - "Find function or root enclosing NODE." - (if (js2-ast-root-p node) - node - (setq node (js2-node-parent node)) - (while (not (or (js2-ast-root-p node) - (js2-function-node-p node))) - (setq node (js2-node-parent node))) - node)) - - (defun js2-mode-find-enclosing-node (beg end) - "Find node fully enclosing BEG and END." - (let ((node (js2-node-at-point beg)) - pos - (continue t)) - (while continue - (if (or (js2-ast-root-p node) - (and - (<= (setq pos (js2-node-abs-pos node)) beg) - (>= (+ pos (js2-node-len node)) end))) - (setq continue nil) - (setq node (js2-node-parent node)))) - node)) - -(defun js2-node-parent-script-or-fn (node) - "Find script or function immediately enclosing NODE. -If NODE is the ast-root, returns nil." - (if (js2-ast-root-p node) - nil - (setq node (js2-node-parent node)) - (while (and node (not (or (js2-function-node-p node) - (js2-script-node-p node)))) - (setq node (js2-node-parent node))) - node)) - -(defun js2-node-is-descendant (node ancestor) - "Return t if NODE is a descendant of ANCESTOR." - (while (and node - (not (eq node ancestor))) - (setq node (js2-node-parent node))) - node) - -;;; visitor infrastructure - -(defun js2-visit-none (_node _callback) - "Visitor for AST node that have no node children." - nil) - -(defun js2-print-none (_node _indent) - "Visitor for AST node with no printed representation.") - -(defun js2-print-body (node indent) - "Print a statement, or a block without braces." - (if (js2-block-node-p node) - (dolist (kid (js2-block-node-kids node)) - (js2-print-ast kid indent)) - (js2-print-ast node indent))) - -(defun js2-print-list (args &optional delimiter) - (cl-loop with len = (length args) - for arg in args - for count from 1 - do - (when arg (js2-print-ast arg 0)) - (if (< count len) - (insert (or delimiter ", "))))) - -(defun js2-print-tree (ast) - "Prints an AST to the current buffer. -Makes `js2-ast-parent-nodes' available to the printer functions." - (let ((max-lisp-eval-depth (max max-lisp-eval-depth 1500))) - (js2-print-ast ast))) - -(defun js2-print-ast (node &optional indent) - "Helper function for printing AST nodes. -Requires `js2-ast-parent-nodes' to be non-nil. -You should use `js2-print-tree' instead of this function." - (let ((printer (get (aref node 0) 'js2-printer)) - (i (or indent 0))) - ;; TODO: wedge comments in here somewhere - (if printer - (funcall printer node i)))) - -(defconst js2-side-effecting-tokens - (let ((tokens (make-bool-vector js2-num-tokens nil))) - (dolist (tt (list js2-ASSIGN - js2-ASSIGN_ADD - js2-ASSIGN_BITAND - js2-ASSIGN_BITOR - js2-ASSIGN_BITXOR - js2-ASSIGN_DIV - js2-ASSIGN_LSH - js2-ASSIGN_MOD - js2-ASSIGN_MUL - js2-ASSIGN_RSH - js2-ASSIGN_SUB - js2-ASSIGN_URSH - js2-ASSIGN_EXPON - js2-BLOCK - js2-BREAK - js2-CALL - js2-CATCH - js2-CATCH_SCOPE - js2-CLASS - js2-CONST - js2-CONTINUE - js2-DEBUGGER - js2-DEC - js2-DELPROP - js2-DEL_REF - js2-DO - js2-ELSE - js2-EMPTY - js2-ENTERWITH - js2-EXPORT - js2-EXPR_RESULT - js2-FINALLY - js2-FOR - js2-FUNCTION - js2-GOTO - js2-IF - js2-IFEQ - js2-IFNE - js2-IMPORT - js2-INC - js2-JSR - js2-LABEL - js2-LEAVEWITH - js2-LET - js2-LETEXPR - js2-LOCAL_BLOCK - js2-LOOP - js2-NEW - js2-REF_CALL - js2-RETHROW - js2-RETURN - js2-RETURN_RESULT - js2-SEMI - js2-SETELEM - js2-SETELEM_OP - js2-SETNAME - js2-SETPROP - js2-SETPROP_OP - js2-SETVAR - js2-SET_REF - js2-SET_REF_OP - js2-SWITCH - js2-TARGET - js2-THROW - js2-TRY - js2-VAR - js2-WHILE - js2-WITH - js2-WITHEXPR - js2-YIELD)) - (aset tokens tt t)) - tokens)) - -(defun js2-node-has-side-effects (node) - "Return t if NODE has side effects." - (when node ; makes it easier to handle malformed expressions - (let ((tt (js2-node-type node))) - (cond - ;; This doubtless needs some work, since EXPR_VOID is used - ;; in several ways in Rhino and I may not have caught them all. - ;; I'll wait for people to notice incorrect warnings. - ((and (= tt js2-EXPR_VOID) - (js2-expr-stmt-node-p node)) ; but not if EXPR_RESULT - (let ((expr (js2-expr-stmt-node-expr node))) - (or (js2-node-has-side-effects expr) - (when (js2-string-node-p expr) - (member (js2-string-node-value expr) '("use strict" "use asm")))))) - ((= tt js2-AWAIT) t) - ((= tt js2-COMMA) - (js2-node-has-side-effects (js2-infix-node-right node))) - ((or (= tt js2-AND) - (= tt js2-OR)) - (or (js2-node-has-side-effects (js2-infix-node-right node)) - (js2-node-has-side-effects (js2-infix-node-left node)))) - ((= tt js2-HOOK) - (and (js2-node-has-side-effects (js2-cond-node-true-expr node)) - (js2-node-has-side-effects (js2-cond-node-false-expr node)))) - ((js2-paren-node-p node) - (js2-node-has-side-effects (js2-paren-node-expr node))) - ((= tt js2-ERROR) ; avoid cascaded error messages - nil) - ((or (and js2-instanceof-has-side-effects (= tt js2-INSTANCEOF)) - (and js2-getprop-has-side-effects (= tt js2-GETPROP))) - t) - (t - (aref js2-side-effecting-tokens tt)))))) - -(defconst js2-stmt-node-types - (list js2-BLOCK - js2-BREAK - js2-CONTINUE - js2-DEFAULT ; e4x "default xml namespace" statement - js2-DO - js2-EXPORT - js2-EXPR_RESULT - js2-EXPR_VOID - js2-FOR - js2-IF - js2-IMPORT - js2-RETURN - js2-SWITCH - js2-THROW - js2-TRY - js2-WHILE - js2-WITH) - "Node types that only appear in statement contexts. -The list does not include nodes that always appear as the child -of another specific statement type, such as switch-cases, -catch and finally blocks, and else-clauses. The list also excludes -nodes like yield, let and var, which may appear in either expression -or statement context, and in the latter context always have a -`js2-expr-stmt-node' parent. Finally, the list does not include -functions or scripts, which are treated separately from statements -by the JavaScript parser and runtime.") - -(defun js2-stmt-node-p (node) - "Heuristic for figuring out if NODE is a statement. -Some node types can appear in either an expression context or a -statement context, e.g. let-nodes, yield-nodes, and var-decl nodes. -For these node types in a statement context, the parent will be a -`js2-expr-stmt-node'. -Functions aren't included in the check." - (memq (js2-node-type node) js2-stmt-node-types)) - -(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-function-node-p node))) - (setq node (js2-node-parent node))) - node) - -(defun js2-node-parent-stmt (node) - "Return the node's first ancestor that is a statement. -Returns nil if NODE is a `js2-ast-root'. Note that any expression -appearing in a statement context will have a parent that is a -`js2-expr-stmt-node' that will be returned by this function." - (let ((parent (js2-node-parent node))) - (if (or (null parent) - (js2-stmt-node-p parent) - (and (js2-function-node-p parent) - (eq (js2-function-node-form parent) 'FUNCTION_STATEMENT))) - parent - (js2-node-parent-stmt parent)))) - -;; In the Mozilla Rhino sources, Roshan James writes: -;; Does consistent-return analysis on the function body when strict mode is -;; enabled. -;; -;; function (x) { return (x+1) } -;; -;; is ok, but -;; -;; function (x) { if (x < 0) return (x+1); } -;; -;; is not because the function can potentially return a value when the -;; condition is satisfied and if not, the function does not explicitly -;; return a value. -;; -;; This extends to checking mismatches such as "return" and "return <value>" -;; used in the same function. Warnings are not emitted if inconsistent -;; returns exist in code that can be statically shown to be unreachable. -;; Ex. -;; function (x) { while (true) { ... if (..) { return value } ... } } -;; -;; emits no warning. However if the loop had a break statement, then a -;; warning would be emitted. -;; -;; The consistency analysis looks at control structures such as loops, ifs, -;; switch, try-catch-finally blocks, examines the reachable code paths and -;; warns the user about an inconsistent set of termination possibilities. -;; -;; These flags enumerate the possible ways a statement/function can -;; terminate. These flags are used by endCheck() and by the Parser to -;; detect inconsistent return usage. -;; -;; END_UNREACHED is reserved for code paths that are assumed to always be -;; able to execute (example: throw, continue) -;; -;; END_DROPS_OFF indicates if the statement can transfer control to the -;; next one. Statement such as return dont. A compound statement may have -;; some branch that drops off control to the next statement. -;; -;; END_RETURNS indicates that the statement can return with no value. -;; END_RETURNS_VALUE indicates that the statement can return a value. -;; -;; A compound statement such as -;; if (condition) { -;; return value; -;; } -;; Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck() - -(defconst js2-END_UNREACHED 0) -(defconst js2-END_DROPS_OFF 1) -(defconst js2-END_RETURNS 2) -(defconst js2-END_RETURNS_VALUE 4) -(defconst js2-END_YIELDS 8) - -(defun js2-has-consistent-return-usage (node) - "Check that every return usage in a function body is consistent. -Returns t if the function satisfies strict mode requirement." - (let ((n (js2-end-check node))) - ;; either it doesn't return a value in any branch... - (or (js2-flag-not-set-p n js2-END_RETURNS_VALUE) - ;; or it returns a value (or is unreached) at every branch - (js2-flag-not-set-p n (logior js2-END_DROPS_OFF - js2-END_RETURNS - js2-END_YIELDS))))) - -(defun js2-end-check-if (node) - "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)) - (el (js2-if-node-else-part node))) - (if (null th) - js2-END_UNREACHED - (logior (js2-end-check th) (if el - (js2-end-check el) - js2-END_DROPS_OFF))))) - -(defun js2-end-check-switch (node) - "Consistency of return statements is checked between the case statements. -If there is no default, then the switch can fall through. If there is a -default, we check to see if all code paths in the default return or if -there is a code path that can fall through. -Returns logical OR of END_* flags." - (let ((rv js2-END_UNREACHED) - default-case) - ;; examine the cases - (catch 'break - (dolist (c (js2-switch-node-cases node)) - (if (js2-case-node-expr c) - (js2-set-flag rv (js2-end-check-block c)) - (setq default-case c) - (throw 'break nil)))) - ;; we don't care how the cases drop into each other - (js2-clear-flag rv js2-END_DROPS_OFF) - ;; examine the default - (js2-set-flag rv (if default-case - (js2-end-check default-case) - js2-END_DROPS_OFF)) - rv)) - -(defun js2-end-check-try (node) - "If the block has a finally, return consistency is checked in the -finally block. If all code paths in the finally return, then the -returns in the try-catch blocks don't matter. If there is a code path -that does not return or if there is no finally block, the returns -of the try and catch blocks are checked for mismatch. -Returns logical OR of END_* flags." - (let ((finally (js2-try-node-finally-block node)) - rv) - ;; check the finally if it exists - (setq rv (if finally - (js2-end-check (js2-finally-node-body finally)) - js2-END_DROPS_OFF)) - ;; If the finally block always returns, then none of the returns - ;; in the try or catch blocks matter. - (when (js2-flag-set-p rv js2-END_DROPS_OFF) - (js2-clear-flag rv js2-END_DROPS_OFF) - ;; examine the try block - (js2-set-flag rv (js2-end-check (js2-try-node-try-block node))) - ;; check each catch block - (dolist (cb (js2-try-node-catch-clauses node)) - (js2-set-flag rv (js2-end-check cb)))) - rv)) - -(defun js2-end-check-loop (node) - "Return statement in the loop body must be consistent. -The default assumption for any kind of a loop is that it will eventually -terminate. The only exception is a loop with a constant true condition. -Code that follows such a loop is examined only if one can determine -statically that there is a break out of the loop. - - for(... ; ... ; ...) {} - for(... in ... ) {} - while(...) { } - do { } while(...) - -Returns logical OR of END_* flags." - (let ((rv (js2-end-check (js2-loop-node-body node))) - (condition (cond - ((js2-while-node-p node) - (js2-while-node-condition node)) - ((js2-do-node-p node) - (js2-do-node-condition node)) - ((js2-for-node-p node) - (js2-for-node-condition node))))) - - ;; check to see if the loop condition is always true - (if (and condition - (eq (js2-always-defined-boolean-p condition) 'ALWAYS_TRUE)) - (js2-clear-flag rv js2-END_DROPS_OFF)) - - ;; look for effect of breaks - (js2-set-flag rv (js2-node-get-prop node - 'CONTROL_BLOCK_PROP - js2-END_UNREACHED)) - rv)) - -(defun js2-end-check-block (node) - "A general block of code is examined statement by statement. -If any statement (even a compound one) returns in all branches, then -subsequent statements are not examined. -Returns logical OR of END_* flags." - (let* ((rv js2-END_DROPS_OFF) - (kids (js2-block-node-kids node)) - (n (car kids))) - ;; Check each statement. If the statement can continue onto the next - ;; one (i.e. END_DROPS_OFF is set), then check the next statement. - (while (and n (js2-flag-set-p rv js2-END_DROPS_OFF)) - (js2-clear-flag rv js2-END_DROPS_OFF) - (js2-set-flag rv (js2-end-check n)) - (setq kids (cdr kids) - n (car kids))) - rv)) - -(defun js2-end-check-label (node) - "A labeled statement implies that there may be a break to the label. -The function processes the labeled statement and then checks the -CONTROL_BLOCK_PROP property to see if there is ever a break to the -particular label. -Returns logical OR of END_* flags." - (let ((rv (js2-end-check (js2-labeled-stmt-node-stmt node)))) - (logior rv (js2-node-get-prop node - 'CONTROL_BLOCK_PROP - js2-END_UNREACHED)))) - -(defun js2-end-check-break (node) - "When a break is encountered annotate the statement being broken -out of by setting its CONTROL_BLOCK_PROP property. -Returns logical OR of END_* flags." - (and (js2-break-node-target node) - (js2-node-set-prop (js2-break-node-target node) - 'CONTROL_BLOCK_PROP - js2-END_DROPS_OFF)) - js2-END_UNREACHED) - -(defun js2-end-check (node) - "Examine the body of a function, doing a basic reachability analysis. -Returns a combination of flags END_* flags that indicate -how the function execution can terminate. These constitute only the -pessimistic set of termination conditions. It is possible that at -runtime certain code paths will never be actually taken. Hence this -analysis will flag errors in cases where there may not be errors. -Returns logical OR of END_* flags" - (let (kid) - (cond - ((js2-break-node-p node) - (js2-end-check-break node)) - ((js2-expr-stmt-node-p node) - (if (setq kid (js2-expr-stmt-node-expr node)) - (js2-end-check kid) - js2-END_DROPS_OFF)) - ((or (js2-continue-node-p node) - (js2-throw-node-p node)) - js2-END_UNREACHED) - ((js2-return-node-p node) - (if (setq kid (js2-return-node-retval node)) - js2-END_RETURNS_VALUE - js2-END_RETURNS)) - ((js2-loop-node-p node) - (js2-end-check-loop node)) - ((js2-switch-node-p node) - (js2-end-check-switch node)) - ((js2-labeled-stmt-node-p node) - (js2-end-check-label node)) - ((js2-if-node-p node) - (js2-end-check-if node)) - ((js2-try-node-p node) - (js2-end-check-try node)) - ((js2-block-node-p node) - (if (null (js2-block-node-kids node)) - js2-END_DROPS_OFF - (js2-end-check-block node))) - ((js2-yield-node-p node) - js2-END_YIELDS) - (t - js2-END_DROPS_OFF)))) - -(defun js2-always-defined-boolean-p (node) - "Check if NODE always evaluates to true or false in boolean context. -Returns 'ALWAYS_TRUE, 'ALWAYS_FALSE, or nil if it's neither always true -nor always false." - (let ((tt (js2-node-type node)) - num) - (cond - ((or (= tt js2-FALSE) (= tt js2-NULL)) - 'ALWAYS_FALSE) - ((= tt js2-TRUE) - 'ALWAYS_TRUE) - ((= tt js2-NUMBER) - (setq num (js2-number-node-num-value node)) - (if (and (not (eq num 0.0e+NaN)) - (not (zerop num))) - 'ALWAYS_TRUE - 'ALWAYS_FALSE)) - (t - nil)))) - -;;; Scanner -- a port of Mozilla Rhino's lexer. -;; Corresponds to Rhino files Token.java and TokenStream.java. - -(defvar js2-tokens nil - "List of all defined token names.") ; initialized in `js2-token-names' - -(defconst js2-token-names - (let* ((names (make-vector js2-num-tokens -1)) - (case-fold-search nil) ; only match js2-UPPER_CASE - (syms (apropos-internal "^js2-\\(?:[[:upper:]_]+\\)"))) - (cl-loop for sym in syms - for i from 0 - do - (unless (or (memq sym '(js2-EOF_CHAR js2-ERROR)) - (not (boundp sym))) - (aset names (symbol-value sym) ; code, e.g. 152 - (downcase - (substring (symbol-name sym) 4))) ; name, e.g. "let" - (push sym js2-tokens))) - names) - "Vector mapping int values to token string names, sans `js2-' prefix.") - -(defun js2-tt-name (tok) - "Return a string name for TOK, a token symbol or code. -Signals an error if it's not a recognized token." - (let ((code tok)) - (if (symbolp tok) - (setq code (symbol-value tok))) - (if (eq code -1) - "ERROR" - (if (and (numberp code) - (not (cl-minusp code)) - (< code js2-num-tokens)) - (aref js2-token-names code) - (error "Invalid token: %s" code))))) - -(defsubst js2-tt-sym (tok) - "Return symbol for TOK given its code, e.g. 'js2-LP for code 86." - (intern (js2-tt-name tok))) - -(defconst js2-token-codes - (let ((table (make-hash-table :test 'eq :size 256))) - (cl-loop for name across js2-token-names - for sym = (intern (concat "js2-" (upcase name))) - do - (puthash sym (symbol-value sym) table)) - ;; clean up a few that are "wrong" in Rhino's token codes - (puthash 'js2-DELETE js2-DELPROP table) - table) - "Hashtable mapping token type symbols to their bytecodes.") - -(defsubst js2-tt-code (sym) - "Return code for token symbol SYM, e.g. 86 for 'js2-LP." - (or (gethash sym js2-token-codes) - (error "Invalid token symbol: %s " sym))) ; signal code bug - -(defun js2-report-scan-error (msg &optional no-throw beg len) - (setf (js2-token-end (js2-current-token)) js2-ts-cursor) - (js2-report-error msg nil - (or beg (js2-current-token-beg)) - (or len (js2-current-token-len))) - (unless no-throw - (throw 'return js2-ERROR))) - -(defun js2-set-string-from-buffer (token) - "Set `string' and `end' slots for TOKEN, return the string." - (setf (js2-token-end token) js2-ts-cursor - (js2-token-string token) (js2-collect-string js2-ts-string-buffer))) - -;; TODO: could potentially avoid a lot of consing by allocating a -;; char buffer the way Rhino does. -(defsubst js2-add-to-string (c) - (push c js2-ts-string-buffer)) - -;; Note that when we "read" the end-of-file, we advance js2-ts-cursor -;; to (1+ (point-max)), which lets the scanner treat end-of-file like -;; any other character: when it's not part of the current token, we -;; unget it, allowing it to be read again by the following call. -(defsubst js2-unget-char () - (cl-decf js2-ts-cursor)) - -;; Rhino distinguishes \r and \n line endings. We don't need to -;; because we only scan from Emacs buffers, which always use \n. -(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. -Returns `js2-EOF_CHAR' if we hit the end of the buffer. -Also updates `js2-ts-hit-eof' and `js2-ts-line-start' as needed." - (let (c) - ;; check for end of buffer - (if (>= js2-ts-cursor (point-max)) - (setq js2-ts-hit-eof t - js2-ts-cursor (1+ js2-ts-cursor) - c js2-EOF_CHAR) ; return value - ;; otherwise read next char - (setq c (char-before (cl-incf js2-ts-cursor))) - ;; if we read a newline, update counters - (if (= c ?\n) - (setq js2-ts-line-start js2-ts-cursor - js2-ts-lineno (1+ js2-ts-lineno))) - ;; TODO: skip over format characters - c))) - -(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. -Doesn't change the values of any scanner variables." - ;; I really wish I knew a better way to do this, but I can't - ;; find the Emacs function that takes a 16-bit int and converts - ;; it to a Unicode/utf-8 character. So I basically eval it with (read). - ;; Have to first check that it's 4 hex characters or it may stop - ;; the read early. - (ignore-errors - (let ((s (buffer-substring-no-properties js2-ts-cursor - (+ 4 js2-ts-cursor)))) - (if (string-match "[0-9a-fA-F]\\{4\\}" s) - (read (concat "?\\u" s)))))) - -(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))) - (if (eq c test) - t - (js2-unget-char) - nil))) - -(defun js2-peek-char () - (prog1 - (js2-get-char) - (js2-unget-char))) - -(defun js2-identifier-start-p (c) - "Is C a valid start to an ES5 Identifier? -See http://es5.github.io/#x7.6" - (or - (memq c '(?$ ?_)) - (memq (get-char-code-property c 'general-category) - ;; Letters - '(Lu Ll Lt Lm Lo Nl)))) - -(defun js2-identifier-part-p (c) - "Is C a valid part of an ES5 Identifier? -See http://es5.github.io/#x7.6" - (or - (memq c '(?$ ?_ ?\u200c ?\u200d)) - (memq (get-char-code-property c 'general-category) - '(;; Letters - Lu Ll Lt Lm Lo Nl - ;; Combining Marks - Mn Mc - ;; Digits - Nd - ;; Connector Punctuation - Pc)))) - -(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))) - -(defun js2-js-space-p (c) - (if (<= c 127) - (memq c '(#x20 #x9 #xB #xC #xD)) - (or - (eq c #xA0) - ;; TODO: change this nil to check for Unicode space character - nil))) - -(defconst js2-eol-chars (list js2-EOF_CHAR ?\n ?\r)) - -(defun js2-skip-line () - "Skip to end of line." - (while (not (memq (js2-get-char) js2-eol-chars))) - (js2-unget-char) - (setf (js2-token-end (js2-current-token)) js2-ts-cursor)) - -(defun js2-init-scanner (&optional buf line) - "Create token stream for BUF starting on LINE. -BUF defaults to `current-buffer' and LINE defaults to 1. - -A buffer can only have one scanner active at a time, which yields -dramatically simpler code than using a defstruct. If you need to -have simultaneous scanners in a buffer, copy the regions to scan -into temp buffers." - (with-current-buffer (or buf (current-buffer)) - (setq js2-ts-dirty-line nil - js2-ts-hit-eof nil - js2-ts-line-start 0 - js2-ts-lineno (or line 1) - js2-ts-line-end-char -1 - js2-ts-cursor (point-min) - js2-ti-tokens (make-vector js2-ti-ntokens nil) - js2-ti-tokens-cursor 0 - js2-ti-lookahead 0 - js2-ts-is-xml-attribute nil - js2-ts-xml-is-tag-content nil - js2-ts-xml-open-tags-count 0 - js2-ts-string-buffer nil))) - -;; This function uses the cached op, string and number fields in -;; TokenStream; if getToken has been called since the passed token -;; was scanned, the op or string printed may be incorrect. -(defun js2-token-to-string (token) - ;; Not sure where this function is used in Rhino. Not tested. - (if (not js2-debug-print-trees) - "" - (let ((name (js2-tt-name token))) - (cond - ((memq token '(js2-STRING js2-REGEXP js2-NAME - js2-TEMPLATE_HEAD js2-NO_SUBS_TEMPLATE)) - (concat name " `" (js2-current-token-string) "'")) - ((eq token js2-NUMBER) - (format "NUMBER %g" (js2-token-number (js2-current-token)))) - (t - name))))) - -(defconst js2-keywords - '(break - case catch class const continue - debugger default delete do - else extends export - false finally for function - if in instanceof import - let - new null - return - super switch - this throw true try typeof - var void - while with - yield)) - -;; Token names aren't exactly the same as the keywords, unfortunately. -;; E.g. delete is js2-DELPROP. -(defconst js2-kwd-tokens - (let ((table (make-vector js2-num-tokens nil)) - (tokens - (list js2-BREAK - js2-CASE js2-CATCH js2-CLASS js2-CONST js2-CONTINUE - js2-DEBUGGER js2-DEFAULT js2-DELPROP js2-DO - js2-ELSE js2-EXPORT - js2-ELSE js2-EXTENDS js2-EXPORT - js2-FALSE js2-FINALLY js2-FOR js2-FUNCTION - js2-IF js2-IN js2-INSTANCEOF js2-IMPORT - js2-LET - js2-NEW js2-NULL - js2-RETURN - js2-SUPER js2-SWITCH - js2-THIS js2-THROW js2-TRUE js2-TRY js2-TYPEOF - js2-VAR - js2-WHILE js2-WITH - js2-YIELD))) - (dolist (i tokens) - (aset table i 'font-lock-keyword-face)) - (aset table js2-STRING 'font-lock-string-face) - (aset table js2-REGEXP 'font-lock-string-face) - (aset table js2-NO_SUBS_TEMPLATE 'font-lock-string-face) - (aset table js2-TEMPLATE_HEAD 'font-lock-string-face) - (aset table js2-COMMENT 'font-lock-comment-face) - (aset table js2-THIS 'font-lock-builtin-face) - (aset table js2-SUPER 'font-lock-builtin-face) - (aset table js2-VOID 'font-lock-constant-face) - (aset table js2-NULL 'font-lock-constant-face) - (aset table js2-TRUE 'font-lock-constant-face) - (aset table js2-FALSE 'font-lock-constant-face) - (aset table js2-NOT 'font-lock-negation-char-face) - table) - "Vector whose values are non-nil for tokens that are keywords. -The values are default faces to use for highlighting the keywords.") - -;; FIXME: Support strict mode-only future reserved words, after we know -;; which parts scopes are in strict mode, and which are not. -(defconst js2-reserved-words '(class enum export extends import static super) - "Future reserved keywords in ECMAScript 5.1.") - -(defconst js2-keyword-names - (let ((table (make-hash-table :test 'equal))) - (cl-loop for k in js2-keywords - do (puthash - (symbol-name k) ; instanceof - (intern (concat "js2-" - (upcase (symbol-name k)))) ; js2-INSTANCEOF - table)) - table) - "JavaScript keywords by name, mapped to their symbols.") - -(defconst js2-reserved-word-names - (let ((table (make-hash-table :test 'equal))) - (cl-loop for k in js2-reserved-words - do - (puthash (symbol-name k) 'js2-RESERVED table)) - table) - "JavaScript reserved words by name, mapped to 'js2-RESERVED.") - -(defun js2-collect-string (buf) - "Convert BUF, a list of chars, to a string. -Reverses BUF before converting." - (if buf - (apply #'string (nreverse buf)) - "")) - -(defun js2-string-to-keyword (s) - "Return token for S, a string, if S is a keyword or reserved word. -Returns a symbol such as 'js2-BREAK, or nil if not keyword/reserved." - (or (gethash s js2-keyword-names) - (gethash s js2-reserved-word-names))) - -(defsubst js2-ts-set-char-token-bounds (token) - "Used when next token is one character." - (setf (js2-token-beg token) (1- js2-ts-cursor) - (js2-token-end token) js2-ts-cursor)) - -(defsubst js2-ts-return (token type) - "Update the `end' and `type' slots of TOKEN, -then throw `return' with value TYPE." - (setf (js2-token-end token) js2-ts-cursor - (js2-token-type token) type) - (throw 'return type)) - -(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." - (catch 'return - (catch 'check - ;; Use 0..9 < A..Z < a..z - (cond - ((<= c ?9) - (cl-decf c ?0) - (if (<= 0 c) - (throw 'check nil))) - ((<= c ?F) - (when (<= ?A c) - (cl-decf c (- ?A 10)) - (throw 'check nil))) - ((<= c ?f) - (when (<= ?a c) - (cl-decf c (- ?a 10)) - (throw 'check nil)))) - (throw 'return -1)) - (logior c (lsh accumulator 4)))) - -(defun js2-get-token (&optional modifier) - "If `js2-ti-lookahead' is zero, call scanner to get new token. -Otherwise, move `js2-ti-tokens-cursor' and return the type of -next saved token. - -This function will not return a newline (js2-EOL) - instead, it -gobbles newlines until it finds a non-newline token. Call -`js2-peek-token-or-eol' when you care about newlines. - -This function will also not return a js2-COMMENT. Instead, it -records comments found in `js2-scanned-comments'. If the token -returned by this function immediately follows a jsdoc comment, -the token is flagged as such." - (if (zerop js2-ti-lookahead) - (js2-get-token-internal modifier) - (cl-decf js2-ti-lookahead) - (setq js2-ti-tokens-cursor (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens)) - (let ((tt (js2-current-token-type))) - (cl-assert (not (= tt js2-EOL))) - tt))) - -(defun js2-unget-token () - (cl-assert (< js2-ti-lookahead js2-ti-max-lookahead)) - (cl-incf js2-ti-lookahead) - (setq js2-ti-tokens-cursor (mod (1- js2-ti-tokens-cursor) js2-ti-ntokens))) - -(defun js2-get-token-internal (modifier) - (let* ((token (js2-get-token-internal-1 modifier)) ; call scanner - (tt (js2-token-type token)) - saw-eol - face) - ;; process comments - (while (or (= tt js2-EOL) (= tt js2-COMMENT)) - (if (= tt js2-EOL) - (setq saw-eol t) - (setq saw-eol nil) - (when js2-record-comments - (js2-record-comment token))) - (setq js2-ti-tokens-cursor (mod (1- js2-ti-tokens-cursor) js2-ti-ntokens)) - (setq token (js2-get-token-internal-1 modifier) ; call scanner again - tt (js2-token-type token))) - - (when saw-eol - (setf (js2-token-follows-eol-p token) t)) - - ;; perform lexical fontification as soon as token is scanned - (when js2-parse-ide-mode - (cond - ((cl-minusp tt) - (js2-record-face 'js2-error token)) - ((setq face (aref js2-kwd-tokens tt)) - (js2-record-face face token)) - ((and (= tt js2-NAME) - (equal (js2-token-string token) "undefined")) - (js2-record-face 'font-lock-constant-face token)))) - tt)) - -(defsubst js2-string-to-number (str base) - ;; TODO: Maybe port ScriptRuntime.stringToNumber. - (condition-case nil - (string-to-number str base) - (overflow-error -1))) - -(defun js2-get-token-internal-1 (modifier) - "Return next JavaScript token type, an int such as js2-RETURN. -During operation, creates an instance of `js2-token' struct, sets -its relevant fields and puts it into `js2-ti-tokens'." - (let (identifier-start - is-unicode-escape-start c - contains-escape escape-val str result base - look-for-slash continue tt legacy-octal - (token (js2-new-token 0))) - (setq - tt - (catch 'return - (when (eq modifier 'TEMPLATE_TAIL) - (setf (js2-token-beg token) (1- js2-ts-cursor)) - (throw 'return (js2-get-string-or-template-token ?` token))) - (while t - ;; Eat whitespace, possibly sensitive to newlines. - (setq continue t) - (while continue - (setq c (js2-get-char)) - (cond - ((eq c js2-EOF_CHAR) - (js2-unget-char) - (js2-ts-set-char-token-bounds token) - (throw 'return js2-EOF)) - ((eq c ?\n) - (js2-ts-set-char-token-bounds token) - (setq js2-ts-dirty-line nil) - (throw 'return js2-EOL)) - ((not (js2-js-space-p c)) - (if (/= c ?-) ; in case end of HTML comment - (setq js2-ts-dirty-line t)) - (setq continue nil)))) - ;; Assume the token will be 1 char - fixed up below. - (js2-ts-set-char-token-bounds token) - (when (eq c ?@) - (throw 'return js2-XMLATTR)) - ;; identifier/keyword/instanceof? - ;; watch out for starting with a <backslash> - (cond - ((eq c ?\\) - (setq c (js2-get-char)) - (if (eq c ?u) - (setq identifier-start t - is-unicode-escape-start t - js2-ts-string-buffer nil) - (setq identifier-start nil) - (js2-unget-char) - (setq c ?\\))) - (t - (when (setq identifier-start (js2-identifier-start-p c)) - (setq js2-ts-string-buffer nil) - (js2-add-to-string c)))) - (when identifier-start - (setq contains-escape is-unicode-escape-start) - (catch 'break - (while t - (if is-unicode-escape-start - ;; strictly speaking we should probably push-back - ;; all the bad characters if the <backslash>uXXXX - ;; sequence is malformed. But since there isn't a - ;; correct context(is there?) for a bad Unicode - ;; escape sequence in an identifier, we can report - ;; an error here. - (progn - (setq escape-val 0) - (dotimes (_ 4) - (setq c (js2-get-char) - escape-val (js2-x-digit-to-int c escape-val)) - ;; Next check takes care of c < 0 and bad escape - (if (cl-minusp escape-val) - (throw 'break nil))) - (if (cl-minusp escape-val) - (js2-report-scan-error "msg.invalid.escape" t)) - (js2-add-to-string escape-val) - (setq is-unicode-escape-start nil)) - (setq c (js2-get-char)) - (cond - ((eq c ?\\) - (setq c (js2-get-char)) - (if (eq c ?u) - (setq is-unicode-escape-start t - contains-escape t) - (js2-report-scan-error "msg.illegal.character" t))) - (t - (if (or (eq c js2-EOF_CHAR) - (not (js2-identifier-part-p c))) - (throw 'break nil)) - (js2-add-to-string c)))))) - (js2-unget-char) - (setf str (js2-collect-string js2-ts-string-buffer) - (js2-token-end token) js2-ts-cursor) - ;; FIXME: Invalid in ES5 and ES6, see - ;; https://bugzilla.mozilla.org/show_bug.cgi?id=694360 - ;; Probably should just drop this conditional. - (unless contains-escape - ;; OPT we shouldn't have to make a string (object!) to - ;; check if it's a keyword. - ;; Return the corresponding token if it's a keyword - (when (and (not (eq modifier 'KEYWORD_IS_NAME)) - (setq result (js2-string-to-keyword str))) - (if (and (< js2-language-version 170) - (memq result '(js2-LET js2-YIELD))) - ;; LET and YIELD are tokens only in 1.7 and later - (setq result 'js2-NAME)) - (when (eq result 'js2-RESERVED) - (setf (js2-token-string token) str)) - (throw 'return (js2-tt-code result)))) - ;; If we want to intern these as Rhino does, just use (intern str) - (setf (js2-token-string token) str) - (throw 'return js2-NAME)) ; end identifier/kwd check - ;; is it a number? - (when (or (js2-digit-p c) - (and (eq c ?.) (js2-digit-p (js2-peek-char)))) - (setq js2-ts-string-buffer nil - base 10) - (when (eq c ?0) - (setq c (js2-get-char)) - (cond - ((or (eq c ?x) (eq c ?X)) - (setq base 16) - (setq c (js2-get-char))) - ((and (or (eq c ?b) (eq c ?B)) - (>= js2-language-version 200)) - (setq base 2) - (setq c (js2-get-char))) - ((and (or (eq c ?o) (eq c ?O)) - (>= js2-language-version 200)) - (setq base 8) - (setq legacy-octal nil) - (setq c (js2-get-char))) - ((js2-digit-p c) - (setq base 'maybe-8)) - (t - (js2-add-to-string ?0)))) - (cond - ((eq base 16) - (if (> 0 (js2-x-digit-to-int c 0)) - (js2-report-scan-error "msg.missing.hex.digits") - (while (<= 0 (js2-x-digit-to-int c 0)) - (js2-add-to-string c) - (setq c (js2-get-char))))) - ((eq base 2) - (if (not (memq c '(?0 ?1))) - (js2-report-scan-error "msg.missing.binary.digits") - (while (memq c '(?0 ?1)) - (js2-add-to-string c) - (setq c (js2-get-char))))) - ((eq base 8) - (if (or (> ?0 c) (< ?7 c)) - (js2-report-scan-error "msg.missing.octal.digits") - (while (and (<= ?0 c) (>= ?7 c)) - (js2-add-to-string c) - (setq c (js2-get-char))))) - (t - (while (and (<= ?0 c) (<= c ?9)) - ;; We permit 08 and 09 as decimal numbers, which - ;; makes our behavior a superset of the ECMA - ;; numeric grammar. We might not always be so - ;; permissive, so we warn about it. - (when (and (eq base 'maybe-8) (>= c ?8)) - (js2-report-warning "msg.bad.octal.literal" - (if (eq c ?8) "8" "9")) - (setq base 10)) - (js2-add-to-string c) - (setq c (js2-get-char))) - (when (eq base 'maybe-8) - (setq base 8 - legacy-octal t)))) - (when (and (eq base 10) (memq c '(?. ?e ?E))) - (when (eq c ?.) - (cl-loop do - (js2-add-to-string c) - (setq c (js2-get-char)) - while (js2-digit-p c))) - (when (memq c '(?e ?E)) - (js2-add-to-string c) - (setq c (js2-get-char)) - (when (memq c '(?+ ?-)) - (js2-add-to-string c) - (setq c (js2-get-char))) - (unless (js2-digit-p c) - (js2-report-scan-error "msg.missing.exponent" t)) - (cl-loop do - (js2-add-to-string c) - (setq c (js2-get-char)) - while (js2-digit-p c)))) - (js2-unget-char) - (let ((str (js2-set-string-from-buffer token))) - (setf (js2-token-number token) (js2-string-to-number str base) - (js2-token-number-base token) base - (js2-token-number-legacy-octal-p token) (and (= base 8) legacy-octal))) - (throw 'return js2-NUMBER)) - ;; is it a string? - (when (or (memq c '(?\" ?\')) - (and (>= js2-language-version 200) - (= c ?`))) - (throw 'return - (js2-get-string-or-template-token c token))) - (js2-ts-return token - (cl-case c - (?\; - (throw 'return js2-SEMI)) - (?\[ - (throw 'return js2-LB)) - (?\] - (throw 'return js2-RB)) - (?{ - (throw 'return js2-LC)) - (?} - (throw 'return js2-RC)) - (?\( - (throw 'return js2-LP)) - (?\) - (throw 'return js2-RP)) - (?, - (throw 'return js2-COMMA)) - (?? - (throw 'return js2-HOOK)) - (?: - (if (js2-match-char ?:) - js2-COLONCOLON - (throw 'return js2-COLON))) - (?. - (if (js2-match-char ?.) - (if (js2-match-char ?.) - js2-TRIPLEDOT js2-DOTDOT) - (if (js2-match-char ?\() - js2-DOTQUERY - (throw 'return js2-DOT)))) - (?| - (if (js2-match-char ?|) - (throw 'return js2-OR) - (if (js2-match-char ?=) - js2-ASSIGN_BITOR - (throw 'return js2-BITOR)))) - (?^ - (if (js2-match-char ?=) - js2-ASSIGN_BITOR - (throw 'return js2-BITXOR))) - (?& - (if (js2-match-char ?&) - (throw 'return js2-AND) - (if (js2-match-char ?=) - js2-ASSIGN_BITAND - (throw 'return js2-BITAND)))) - (?= - (if (js2-match-char ?=) - (if (js2-match-char ?=) - js2-SHEQ - (throw 'return js2-EQ)) - (if (js2-match-char ?>) - (js2-ts-return token js2-ARROW) - (throw 'return js2-ASSIGN)))) - (?! - (if (js2-match-char ?=) - (if (js2-match-char ?=) - js2-SHNE - js2-NE) - (throw 'return js2-NOT))) - (?< - ;; NB:treat HTML begin-comment as comment-till-eol - (when (js2-match-char ?!) - (when (js2-match-char ?-) - (when (js2-match-char ?-) - (js2-skip-line) - (setf (js2-token-comment-type (js2-current-token)) 'html) - (throw 'return js2-COMMENT))) - (js2-unget-char)) - (if (js2-match-char ?<) - (if (js2-match-char ?=) - js2-ASSIGN_LSH - js2-LSH) - (if (js2-match-char ?=) - js2-LE - (throw 'return js2-LT)))) - (?> - (if (js2-match-char ?>) - (if (js2-match-char ?>) - (if (js2-match-char ?=) - js2-ASSIGN_URSH - js2-URSH) - (if (js2-match-char ?=) - js2-ASSIGN_RSH - js2-RSH)) - (if (js2-match-char ?=) - js2-GE - (throw 'return js2-GT)))) - (?* - (if (js2-match-char ?=) - js2-ASSIGN_MUL - (if (js2-match-char ?*) - (if (js2-match-char ?=) - js2-ASSIGN_EXPON - js2-EXPON) - (throw 'return js2-MUL)))) - (?/ - ;; is it a // comment? - (when (js2-match-char ?/) - (setf (js2-token-beg token) (- js2-ts-cursor 2)) - (js2-skip-line) - (setf (js2-token-comment-type token) 'line) - ;; include newline so highlighting goes to end of - ;; window, if there actually is a newline; if we - ;; hit eof, then implicitly there isn't - (unless js2-ts-hit-eof - (cl-incf (js2-token-end token))) - (throw 'return js2-COMMENT)) - ;; is it a /* comment? - (when (js2-match-char ?*) - (setf look-for-slash nil - (js2-token-beg token) (- js2-ts-cursor 2) - (js2-token-comment-type token) - (if (js2-match-char ?*) - (progn - (setq look-for-slash t) - 'jsdoc) - 'block)) - (while t - (setq c (js2-get-char)) - (cond - ((eq c js2-EOF_CHAR) - (setf (js2-token-end token) (1- js2-ts-cursor)) - (js2-report-error "msg.unterminated.comment") - (throw 'return js2-COMMENT)) - ((eq c ?*) - (setq look-for-slash t)) - ((eq c ?/) - (if look-for-slash - (js2-ts-return token js2-COMMENT))) - (t - (setf look-for-slash nil - (js2-token-end token) js2-ts-cursor))))) - (if (js2-match-char ?=) - js2-ASSIGN_DIV - (throw 'return js2-DIV))) - (?# - (when js2-skip-preprocessor-directives - (js2-skip-line) - (setf (js2-token-comment-type token) 'preprocessor - (js2-token-end token) js2-ts-cursor) - (throw 'return js2-COMMENT)) - (throw 'return js2-ERROR)) - (?% - (if (js2-match-char ?=) - js2-ASSIGN_MOD - (throw 'return js2-MOD))) - (?~ - (throw 'return js2-BITNOT)) - (?+ - (if (js2-match-char ?=) - js2-ASSIGN_ADD - (if (js2-match-char ?+) - js2-INC - (throw 'return js2-ADD)))) - (?- - (cond - ((js2-match-char ?=) - (setq c js2-ASSIGN_SUB)) - ((js2-match-char ?-) - (unless js2-ts-dirty-line - ;; treat HTML end-comment after possible whitespace - ;; after line start as comment-until-eol - (when (js2-match-char ?>) - (js2-skip-line) - (setf (js2-token-comment-type (js2-current-token)) 'html) - (throw 'return js2-COMMENT))) - (setq c js2-DEC)) - (t - (setq c js2-SUB))) - (setq js2-ts-dirty-line t) - c) - (otherwise - (js2-report-scan-error "msg.illegal.character"))))))) - (setf (js2-token-type token) tt) - token)) - -(defun js2-get-string-or-template-token (quote-char token) - ;; We attempt to accumulate a string the fast way, by - ;; building it directly out of the reader. But if there - ;; are any escaped characters in the string, we revert to - ;; building it out of a string buffer. - (let ((c (js2-get-char)) - js2-ts-string-buffer - nc c1 val escape-val) - (catch 'break - (while (/= c quote-char) - (catch 'continue - (when (eq c js2-EOF_CHAR) - (js2-unget-char) - (js2-report-error "msg.unterminated.string.lit") - (throw 'break nil)) - (when (and (eq c ?\n) (not (eq quote-char ?`))) - (js2-unget-char) - (js2-report-error "msg.unterminated.string.lit") - (throw 'break nil)) - (when (eq c ?\\) - ;; We've hit an escaped character - (setq c (js2-get-char)) - (cl-case c - (?b (setq c ?\b)) - (?f (setq c ?\f)) - (?n (setq c ?\n)) - (?r (setq c ?\r)) - (?t (setq c ?\t)) - (?v (setq c ?\v)) - (?u - (setq c1 (js2-read-unicode-escape)) - (if js2-parse-ide-mode - (if c1 - (progn - ;; just copy the string in IDE-mode - (js2-add-to-string ?\\) - (js2-add-to-string ?u) - (dotimes (_ 3) - (js2-add-to-string (js2-get-char))) - (setq c (js2-get-char))) ; added at end of loop - ;; flag it as an invalid escape - (js2-report-warning "msg.invalid.escape" - nil (- js2-ts-cursor 2) 6)) - ;; Get 4 hex digits; if the u escape is not - ;; followed by 4 hex digits, use 'u' + the - ;; literal character sequence that follows. - (js2-add-to-string ?u) - (setq escape-val 0) - (dotimes (_ 4) - (setq c (js2-get-char) - escape-val (js2-x-digit-to-int c escape-val)) - (if (cl-minusp escape-val) - (throw 'continue nil)) - (js2-add-to-string c)) - ;; prepare for replace of stored 'u' sequence by escape value - (setq js2-ts-string-buffer (nthcdr 5 js2-ts-string-buffer) - c escape-val))) - (?x - ;; Get 2 hex digits, defaulting to 'x'+literal - ;; sequence, as above. - (setq c (js2-get-char) - escape-val (js2-x-digit-to-int c 0)) - (if (cl-minusp escape-val) - (progn - (js2-add-to-string ?x) - (throw 'continue nil)) - (setq c1 c - c (js2-get-char) - escape-val (js2-x-digit-to-int c escape-val)) - (if (cl-minusp escape-val) - (progn - (js2-add-to-string ?x) - (js2-add-to-string c1) - (throw 'continue nil)) - ;; got 2 hex digits - (setq c escape-val)))) - (?\n - ;; Remove line terminator after escape to follow - ;; SpiderMonkey and C/C++ - (setq c (js2-get-char)) - (throw 'continue nil)) - (t - (when (and (<= ?0 c) (< c ?8)) - (setq val (- c ?0) - c (js2-get-char)) - (when (and (<= ?0 c) (< c ?8)) - (setq val (- (+ (* 8 val) c) ?0) - c (js2-get-char)) - (when (and (<= ?0 c) - (< c ?8) - (< val #o37)) - ;; c is 3rd char of octal sequence only - ;; if the resulting val <= 0377 - (setq val (- (+ (* 8 val) c) ?0) - c (js2-get-char)))) - (js2-unget-char) - (setq c val))))) - (when (and (eq quote-char ?`) (eq c ?$)) - (when (eq (setq nc (js2-get-char)) ?\{) - (throw 'break nil)) - (js2-unget-char)) - (js2-add-to-string c) - (setq c (js2-get-char))))) - (js2-set-string-from-buffer token) - (if (not (eq quote-char ?`)) - js2-STRING - (if (and (eq c ?$) (eq nc ?\{)) - js2-TEMPLATE_HEAD - js2-NO_SUBS_TEMPLATE)))) - -(defun js2-read-regexp (start-tt start-pos) - "Called by parser when it gets / or /= in literal context." - (let (c err - in-class ; inside a '[' .. ']' character-class - flags - (continue t) - (token (js2-new-token 0))) - (js2-record-text-property start-pos (1+ start-pos) - 'syntax-table (string-to-syntax "\"/")) - (setq js2-ts-string-buffer nil) - (if (eq start-tt js2-ASSIGN_DIV) - ;; mis-scanned /= - (js2-add-to-string ?=) - (if (not (eq start-tt js2-DIV)) - (error "failed assertion"))) - (while (and (not err) - (or (/= (setq c (js2-get-char)) ?/) - in-class)) - (cond - ((or (= c ?\n) - (= c js2-EOF_CHAR)) - (setf (js2-token-end token) (1- js2-ts-cursor) - err t - (js2-token-string token) (js2-collect-string js2-ts-string-buffer)) - (js2-report-error "msg.unterminated.re.lit")) - (t (cond - ((= c ?\\) - (js2-add-to-string c) - (setq c (js2-get-char))) - ((= c ?\[) - (setq in-class t)) - ((= c ?\]) - (setq in-class nil))) - (js2-add-to-string c)))) - (unless err - (js2-record-text-property (1- js2-ts-cursor) js2-ts-cursor - 'syntax-table (string-to-syntax "\"/")) - (while continue - (cond - ((js2-match-char ?g) - (push ?g flags)) - ((js2-match-char ?i) - (push ?i flags)) - ((js2-match-char ?m) - (push ?m flags)) - ((and (js2-match-char ?u) - (>= js2-language-version 200)) - (push ?u flags)) - ((and (js2-match-char ?y) - (>= js2-language-version 200)) - (push ?y flags)) - (t - (setq continue nil)))) - (if (js2-alpha-p (js2-peek-char)) - (js2-report-scan-error "msg.invalid.re.flag" t - js2-ts-cursor 1)) - (js2-set-string-from-buffer token)) - (js2-collect-string flags))) - -(defun js2-get-first-xml-token () - (setq js2-ts-xml-open-tags-count 0 - js2-ts-is-xml-attribute nil - js2-ts-xml-is-tag-content nil) - (js2-unget-char) - (js2-get-next-xml-token)) - -(defun js2-xml-discard-string (token) - "Throw away the string in progress and flag an XML parse error." - (setf js2-ts-string-buffer nil - (js2-token-string token) nil) - (js2-report-scan-error "msg.XML.bad.form" t)) - -(defun js2-get-next-xml-token () - (setq js2-ts-string-buffer nil) ; for recording the XML - (let ((token (js2-new-token 0)) - c result) - (setq result - (catch 'return - (while t - (setq c (js2-get-char)) - (cond - ((= c js2-EOF_CHAR) - (throw 'return js2-ERROR)) - (js2-ts-xml-is-tag-content - (cl-case c - (?> - (js2-add-to-string c) - (setq js2-ts-xml-is-tag-content nil - js2-ts-is-xml-attribute nil)) - (?/ - (js2-add-to-string c) - (when (eq ?> (js2-peek-char)) - (setq c (js2-get-char)) - (js2-add-to-string c) - (setq js2-ts-xml-is-tag-content nil) - (cl-decf js2-ts-xml-open-tags-count))) - (?{ - (js2-unget-char) - (js2-set-string-from-buffer token) - (throw 'return js2-XML)) - ((?\' ?\") - (js2-add-to-string c) - (unless (js2-read-quoted-string c token) - (throw 'return js2-ERROR))) - (?= - (js2-add-to-string c) - (setq js2-ts-is-xml-attribute t)) - ((? ?\t ?\r ?\n) - (js2-add-to-string c)) - (t - (js2-add-to-string c) - (setq js2-ts-is-xml-attribute nil))) - (when (and (not js2-ts-xml-is-tag-content) - (zerop js2-ts-xml-open-tags-count)) - (js2-set-string-from-buffer token) - (throw 'return js2-XMLEND))) - (t - ;; else not tag content - (cl-case c - (?< - (js2-add-to-string c) - (setq c (js2-peek-char)) - (cl-case c - (?! - (setq c (js2-get-char)) ;; skip ! - (js2-add-to-string c) - (setq c (js2-peek-char)) - (cl-case c - (?- - (setq c (js2-get-char)) ;; skip - - (js2-add-to-string c) - (if (eq c ?-) - (progn - (js2-add-to-string c) - (unless (js2-read-xml-comment token) - (throw 'return js2-ERROR))) - (js2-xml-discard-string token) - (throw 'return js2-ERROR))) - (?\[ - (setq c (js2-get-char)) ;; skip [ - (js2-add-to-string c) - (if (and (= (js2-get-char) ?C) - (= (js2-get-char) ?D) - (= (js2-get-char) ?A) - (= (js2-get-char) ?T) - (= (js2-get-char) ?A) - (= (js2-get-char) ?\[)) - (progn - (js2-add-to-string ?C) - (js2-add-to-string ?D) - (js2-add-to-string ?A) - (js2-add-to-string ?T) - (js2-add-to-string ?A) - (js2-add-to-string ?\[) - (unless (js2-read-cdata token) - (throw 'return js2-ERROR))) - (js2-xml-discard-string token) - (throw 'return js2-ERROR))) - (t - (unless (js2-read-entity token) - (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) - (unless (js2-read-PI token) - (throw 'return js2-ERROR))) - (?/ - ;; end tag - (setq c (js2-get-char)) ;; skip / - (js2-add-to-string c) - (when (zerop js2-ts-xml-open-tags-count) - (js2-xml-discard-string token) - (throw 'return js2-ERROR)) - (setq js2-ts-xml-is-tag-content t) - (cl-decf js2-ts-xml-open-tags-count)) - (t - ;; start tag - (setq js2-ts-xml-is-tag-content t) - (cl-incf js2-ts-xml-open-tags-count)))) - (?{ - (js2-unget-char) - (js2-set-string-from-buffer token) - (throw 'return js2-XML)) - (t - (js2-add-to-string c)))))))) - (setf (js2-token-end token) js2-ts-cursor) - (setf (js2-token-type token) result) - result)) - -(defun js2-read-quoted-string (quote token) - (let (c) - (catch 'return - (while (/= (setq c (js2-get-char)) js2-EOF_CHAR) - (js2-add-to-string c) - (if (eq c quote) - (throw 'return t))) - (js2-xml-discard-string token) ;; throw away string in progress - nil))) - -(defun js2-read-xml-comment (token) - (let ((c (js2-get-char))) - (catch 'return - (while (/= c js2-EOF_CHAR) - (catch 'continue - (js2-add-to-string c) - (when (and (eq c ?-) (eq ?- (js2-peek-char))) - (setq c (js2-get-char)) - (js2-add-to-string c) - (if (eq (js2-peek-char) ?>) - (progn - (setq c (js2-get-char)) ;; skip > - (js2-add-to-string c) - (throw 'return t)) - (throw 'continue nil))) - (setq c (js2-get-char)))) - (js2-xml-discard-string token) - nil))) - -(defun js2-read-cdata (token) - (let ((c (js2-get-char))) - (catch 'return - (while (/= c js2-EOF_CHAR) - (catch 'continue - (js2-add-to-string c) - (when (and (eq c ?\]) (eq (js2-peek-char) ?\])) - (setq c (js2-get-char)) - (js2-add-to-string c) - (if (eq (js2-peek-char) ?>) - (progn - (setq c (js2-get-char)) ;; Skip > - (js2-add-to-string c) - (throw 'return t)) - (throw 'continue nil))) - (setq c (js2-get-char)))) - (js2-xml-discard-string token) - nil))) - -(defun js2-read-entity (token) - (let ((decl-tags 1) - c) - (catch 'return - (while (/= js2-EOF_CHAR (setq c (js2-get-char))) - (js2-add-to-string c) - (cl-case c - (?< - (cl-incf decl-tags)) - (?> - (cl-decf decl-tags) - (if (zerop decl-tags) - (throw 'return t))))) - (js2-xml-discard-string token) - nil))) - -(defun js2-read-PI (token) - "Scan an XML processing instruction." - (let (c) - (catch 'return - (while (/= js2-EOF_CHAR (setq c (js2-get-char))) - (js2-add-to-string c) - (when (and (eq c ??) (eq (js2-peek-char) ?>)) - (setq c (js2-get-char)) ;; Skip > - (js2-add-to-string c) - (throw 'return t))) - (js2-xml-discard-string token) - nil))) - -;;; Highlighting - -(defun js2-set-face (beg end face &optional record) - "Fontify a region. If RECORD is non-nil, record for later." - (when (cl-plusp js2-highlight-level) - (setq beg (min (point-max) beg) - beg (max (point-min) beg) - end (min (point-max) end) - end (max (point-min) end)) - (if record - (push (list beg end face) js2-mode-fontifications) - (put-text-property beg end 'font-lock-face face)))) - -(defsubst js2-clear-face (beg end) - (remove-text-properties beg end '(font-lock-face nil - help-echo nil - point-entered nil - cursor-sensor-functions nil - c-in-sws nil))) - -(defconst js2-ecma-global-props - (concat "^" - (regexp-opt - '("Infinity" "NaN" "undefined" "arguments") t) - "$") - "Value properties of the Ecma-262 Global Object. -Shown at or above `js2-highlight-level' 2.") - -;; might want to add the name "arguments" to this list? -(defconst js2-ecma-object-props - (concat "^" - (regexp-opt - '("prototype" "__proto__" "__parent__") t) - "$") - "Value properties of the Ecma-262 Object constructor. -Shown at or above `js2-highlight-level' 2.") - -(defconst js2-ecma-global-funcs - (concat - "^" - (regexp-opt - '("decodeURI" "decodeURIComponent" "encodeURI" "encodeURIComponent" - "eval" "isFinite" "isNaN" "parseFloat" "parseInt") t) - "$") - "Function properties of the Ecma-262 Global object. -Shown at or above `js2-highlight-level' 2.") - -(defconst js2-ecma-number-props - (concat "^" - (regexp-opt '("MAX_VALUE" "MIN_VALUE" "NaN" - "NEGATIVE_INFINITY" - "POSITIVE_INFINITY") t) - "$") - "Properties of the Ecma-262 Number constructor. -Shown at or above `js2-highlight-level' 2.") - -(defconst js2-ecma-date-props "^\\(parse\\|UTC\\)$" - "Properties of the Ecma-262 Date constructor. -Shown at or above `js2-highlight-level' 2.") - -(defconst js2-ecma-math-props - (concat "^" - (regexp-opt - '("E" "LN10" "LN2" "LOG2E" "LOG10E" "PI" "SQRT1_2" "SQRT2") - t) - "$") - "Properties of the Ecma-262 Math object. -Shown at or above `js2-highlight-level' 2.") - -(defconst js2-ecma-math-funcs - (concat "^" - (regexp-opt - '("abs" "acos" "asin" "atan" "atan2" "ceil" "cos" "exp" "floor" - "log" "max" "min" "pow" "random" "round" "sin" "sqrt" "tan") t) - "$") - "Function properties of the Ecma-262 Math object. -Shown at or above `js2-highlight-level' 2.") - -(defconst js2-ecma-function-props - (concat - "^" - (regexp-opt - '(;; properties of the Object prototype object - "hasOwnProperty" "isPrototypeOf" "propertyIsEnumerable" - "toLocaleString" "toString" "valueOf" - ;; properties of the Function prototype object - "apply" "call" - ;; properties of the Array prototype object - "concat" "join" "pop" "push" "reverse" "shift" "slice" "sort" - "splice" "unshift" - ;; properties of the String prototype object - "charAt" "charCodeAt" "fromCharCode" "indexOf" "lastIndexOf" - "localeCompare" "match" "replace" "search" "split" "substring" - "toLocaleLowerCase" "toLocaleUpperCase" "toLowerCase" - "toUpperCase" - ;; properties of the Number prototype object - "toExponential" "toFixed" "toPrecision" - ;; properties of the Date prototype object - "getDate" "getDay" "getFullYear" "getHours" "getMilliseconds" - "getMinutes" "getMonth" "getSeconds" "getTime" - "getTimezoneOffset" "getUTCDate" "getUTCDay" "getUTCFullYear" - "getUTCHours" "getUTCMilliseconds" "getUTCMinutes" "getUTCMonth" - "getUTCSeconds" "setDate" "setFullYear" "setHours" - "setMilliseconds" "setMinutes" "setMonth" "setSeconds" "setTime" - "setUTCDate" "setUTCFullYear" "setUTCHours" "setUTCMilliseconds" - "setUTCMinutes" "setUTCMonth" "setUTCSeconds" "toDateString" - "toLocaleDateString" "toLocaleString" "toLocaleTimeString" - "toTimeString" "toUTCString" - ;; properties of the RegExp prototype object - "exec" "test" - ;; properties of the JSON prototype object - "parse" "stringify" - ;; SpiderMonkey/Rhino extensions, versions 1.5+ - "toSource" "__defineGetter__" "__defineSetter__" - "__lookupGetter__" "__lookupSetter__" "__noSuchMethod__" - "every" "filter" "forEach" "lastIndexOf" "map" "some") - t) - "$") - "Built-in functions defined by Ecma-262 and SpiderMonkey extensions. -Shown at or above `js2-highlight-level' 3.") - -(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))) - (prop-name (if prop (js2-name-node-name prop))) - (level2 (>= js2-highlight-level 2)) - (level3 (>= js2-highlight-level 3))) - (when level2 - (let ((face - (if call-p - (cond - ((and target prop) - (cond - ((and level3 (string-match js2-ecma-function-props prop-name)) - 'font-lock-builtin-face) - ((and target-name prop) - (cond - ((string= target-name "Date") - (if (string-match js2-ecma-date-props prop-name) - 'font-lock-builtin-face)) - ((string= target-name "Math") - (if (string-match js2-ecma-math-funcs prop-name) - 'font-lock-builtin-face)))))) - (prop - (if (string-match js2-ecma-global-funcs prop-name) - 'font-lock-builtin-face))) - (cond - ((and target prop) - (cond - ((string= target-name "Number") - (if (string-match js2-ecma-number-props prop-name) - 'font-lock-constant-face)) - ((string= target-name "Math") - (if (string-match js2-ecma-math-props prop-name) - 'font-lock-constant-face)))) - (prop - (if (string-match js2-ecma-object-props prop-name) - 'font-lock-constant-face)))))) - (when (and (not face) target (not call-p) prop-name) - (setq face 'js2-object-property-access)) - (when face - (let ((pos (+ (js2-node-pos parent) ; absolute - (js2-node-pos prop)))) ; relative - (js2-set-face pos - (+ pos (js2-node-len prop)) - face 'record))))))) - -(defun js2-parse-highlight-member-expr-node (node) - "Perform syntax highlighting of EcmaScript built-in properties. -The variable `js2-highlight-level' governs this highlighting." - (let (face target prop name pos end parent call-p callee) - (cond - ;; case 1: simple name, e.g. foo - ((js2-name-node-p node) - (setq name (js2-name-node-name node)) - ;; possible for name to be nil in rare cases - saw it when - ;; running js2-mode on an elisp buffer. Might as well try to - ;; make it so js2-mode never barfs. - (when name - (setq face (if (string-match js2-ecma-global-props name) - 'font-lock-constant-face)) - (when face - (setq pos (js2-node-pos node) - end (+ pos (js2-node-len node))) - (js2-set-face pos end face 'record)))) - ;; case 2: property access or function call - ((or (js2-prop-get-node-p node) - ;; highlight function call if expr is a prop-get node - ;; or a plain name (i.e. unqualified function call) - (and (setq call-p (js2-call-node-p node)) - (setq callee (js2-call-node-target node)) ; separate setq! - (or (js2-prop-get-node-p callee) - (js2-name-node-p callee)))) - (setq parent node - node (if call-p callee node)) - (if (and call-p (js2-name-node-p callee)) - (setq prop callee) - (setq target (js2-prop-get-node-left node) - prop (js2-prop-get-node-right node))) - (cond - ((js2-name-node-p prop) - ;; case 2(a&c): simple or complex target, simple name, e.g. x[y].bar - (js2-parse-highlight-prop-get parent target prop call-p)) - ((js2-name-node-p target) - ;; case 2b: simple target, complex name, e.g. foo.x[y] - (js2-parse-highlight-prop-get parent target nil call-p))))))) - -(defun js2-parse-highlight-member-expr-fn-name (expr) - "Highlight the `baz' in function foo.bar.baz(args) {...}. -This is experimental Rhino syntax. EXPR is the foo.bar.baz member expr. -We currently only handle the case where the last component is a prop-get -of a simple name. Called before EXPR has a parent node." - (let (pos - (name (and (js2-prop-get-node-p expr) - (js2-prop-get-node-right expr)))) - (when (js2-name-node-p name) - (js2-set-face (setq pos (+ (js2-node-pos expr) ; parent is absolute - (js2-node-pos name))) - (+ pos (js2-node-len name)) - 'font-lock-function-name-face - 'record)))) - -;; source: http://jsdoc.sourceforge.net/ -;; Note - this syntax is for Google's enhanced jsdoc parser that -;; allows type specifications, and needs work before entering the wild. - -(defconst js2-jsdoc-param-tag-regexp - (concat "^\\s-*\\*+\\s-*\\(@" - (regexp-opt '("param" "arg" "argument" "prop" "property" "typedef")) - "\\)" - "\\s-*\\({[^}]+}\\)?" ; optional type - "\\s-*\\[?\\([[:alnum:]_$\.]+\\)?\\]?" ; name - "\\_>") - "Matches jsdoc tags with optional type and optional param name.") - -(defconst js2-jsdoc-typed-tag-regexp - (concat "^\\s-*\\*+\\s-*\\(@\\(?:" - (regexp-opt - '("enum" - "extends" - "field" - "id" - "implements" - "lends" - "mods" - "requires" - "return" - "returns" - "yield" - "yields" - "type" - "throw" - "throws")) - "\\)\\)\\s-*\\({[^}]+}\\)?") - "Matches jsdoc tags with optional type.") - -(defconst js2-jsdoc-arg-tag-regexp - (concat "^\\s-*\\*+\\s-*\\(@\\(?:" - (regexp-opt - '("alias" - "augments" - "borrows" - "callback" - "bug" - "base" - "config" - "default" - "define" - "exception" - "func" - "function" - "member" - "memberOf" - "method" - "module" - "name" - "namespace" - "since" - "suppress" - "this" - "throws" - "version")) - "\\)\\)\\s-+\\([^ \t\n]+\\)") - "Matches jsdoc tags with a single argument.") - -(defconst js2-jsdoc-empty-tag-regexp - (concat "^\\s-*\\*+\\s-*\\(@\\(?:" - (regexp-opt - '("abstract" - "addon" - "author" - "class" - "const" - "constant" - "constructor" - "constructs" - "deprecated" - "desc" - "description" - "event" - "example" - "exec" - "export" - "fileoverview" - "final" - "func" - "function" - "hidden" - "ignore" - "implicitCast" - "inheritDoc" - "inner" - "interface" - "license" - "method" - "noalias" - "noshadow" - "notypecheck" - "override" - "owner" - "preserve" - "preserveTry" - "private" - "protected" - "public" - "static" - "supported" - "virtual" - )) - "\\)\\)\\s-*") - "Matches empty jsdoc tags.") - -(defconst js2-jsdoc-link-tag-regexp - "{\\(@\\(?:link\\|code\\)\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?}" - "Matches a jsdoc link or code tag.") - -(defconst js2-jsdoc-see-tag-regexp - "^\\s-*\\*+\\s-*\\(@see\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?" - "Matches a jsdoc @see tag.") - -(defconst js2-jsdoc-html-tag-regexp - "\\(</?\\)\\([[:alpha:]]+\\)\\s-*\\(/?>\\)" - "Matches a simple (no attributes) html start- or end-tag.") - -(defun js2-jsdoc-highlight-helper () - (js2-set-face (match-beginning 1) - (match-end 1) - '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) - (js2-set-face (match-beginning 2) - (match-end 2) - 'js2-jsdoc-value))) - (if (match-beginning 3) - (js2-set-face (match-beginning 3) - (match-end 3) - 'js2-jsdoc-value))) - -(defun js2-highlight-jsdoc (ast) - "Highlight doc comment tags." - (let ((comments (js2-ast-root-comments ast)) - beg end) - (save-excursion - (dolist (node comments) - (when (eq (js2-comment-node-format node) 'jsdoc) - ;; Slice off the leading /* and trailing */ in case there - ;; are tags on the first line - (setq beg (+ 2 (js2-node-abs-pos node)) - end (+ beg -4 (js2-node-len node))) - (save-restriction - (narrow-to-region beg end) - (dolist (re (list js2-jsdoc-param-tag-regexp - js2-jsdoc-typed-tag-regexp - js2-jsdoc-arg-tag-regexp - js2-jsdoc-link-tag-regexp - js2-jsdoc-see-tag-regexp - js2-jsdoc-empty-tag-regexp)) - (goto-char beg) - (while (re-search-forward re nil t) - (js2-jsdoc-highlight-helper))) - ;; simple highlighting for html tags - (goto-char beg) - (while (re-search-forward js2-jsdoc-html-tag-regexp nil t) - (js2-set-face (match-beginning 1) - (match-end 1) - 'js2-jsdoc-html-tag-delimiter) - (js2-set-face (match-beginning 2) - (match-end 2) - 'js2-jsdoc-html-tag-name) - (js2-set-face (match-beginning 3) - (match-end 3) - 'js2-jsdoc-html-tag-delimiter)))))))) - -(defun js2-highlight-assign-targets (_node left right) - "Highlight function properties and external variables." - (let (leftpos name) - ;; highlight vars and props assigned function values - (when (or (js2-function-node-p right) - (js2-class-node-p right)) - (cond - ;; var foo = function() {...} - ((js2-name-node-p left) - (setq name left)) - ;; foo.bar.baz = function() {...} - ((and (js2-prop-get-node-p left) - (js2-name-node-p (js2-prop-get-node-right left))) - (setq name (js2-prop-get-node-right left)))) - (when name - (js2-set-face (setq leftpos (js2-node-abs-pos name)) - (+ leftpos (js2-node-len name)) - 'font-lock-function-name-face - 'record))))) - -(defun js2-record-name-node (node) - "Saves NODE to `js2-recorded-identifiers' to check for undeclared variables -later. NODE must be a name node." - (let ((leftpos (js2-node-abs-pos node))) - (push (list node js2-current-scope - leftpos - (+ leftpos (js2-node-len node))) - js2-recorded-identifiers))) - -(defun js2-highlight-undeclared-vars () - "After entire parse is finished, look for undeclared variable references. -We have to wait until entire buffer is parsed, since JavaScript permits var -declarations to occur after they're used. - -Some identifiers may be assumed to be externally defined. -These externs are not highlighted, even if there is no declaration -for them in the source code (in the current file). - -The list of externs consists of the following: - - - `js2-ecma262-externs' for basic names from the ECMAScript language standard. - - Depending on the buffer-local variables `js2-include-*-externs' - the corresponding `js2-*-externs' to add names for certain environments - like the browser, Node or Rhino. - - Two customizable lists `js2-global-externs' and `js2-additional-externs', - the latter of which should be set per-buffer. - -See especially `js2-additional-externs' for further details about externs." - (let ((default-externs - (append js2-ecma-262-externs - (if (and js2-include-browser-externs - (>= js2-language-version 200)) js2-harmony-externs) - (if js2-include-rhino-externs js2-rhino-externs) - (if js2-include-node-externs js2-node-externs) - (if (or js2-include-browser-externs js2-include-node-externs) - js2-typed-array-externs) - (if js2-include-browser-externs js2-browser-externs))) - name) - (dolist (entry js2-recorded-identifiers) - (cl-destructuring-bind (name-node scope pos end) entry - (setq name (js2-name-node-name name-node)) - (unless (or (member name js2-global-externs) - (member name default-externs) - (member name js2-additional-externs) - (js2-get-defining-scope scope name pos)) - (js2-report-warning "msg.undeclared.variable" name pos (- end pos) - 'js2-external-variable)))))) - -(defun js2--add-or-update-symbol (symbol inition used vars) - "Add or update SYMBOL entry in VARS, an hash table. -SYMBOL is a js2-name-node, INITION either nil, t, or ?P, -respectively meaning that SYMBOL is a mere declaration, an -assignment or a function parameter; when USED is t, the symbol -node is assumed to be an usage and thus added to the list stored -in the cdr of the entry. -" - (let* ((nm (js2-name-node-name symbol)) - (es (js2-node-get-enclosing-scope symbol)) - (ds (js2-get-defining-scope es nm))) - (when (and ds (not (equal nm "arguments"))) - (let* ((sym (js2-scope-get-symbol ds nm)) - (var (gethash sym vars)) - (err-var-p (js2-catch-node-p ds))) - (unless inition - (setq inition err-var-p)) - (if var - (progn - (when (and inition (not (equal (car var) ?P))) - (setcar var inition)) - (when (and used (not (memq symbol (cdr var)))) - (push symbol (cdr var)))) - ;; do not consider the declaration of catch parameter as an usage - (when (and err-var-p used) - (setq used nil)) - (puthash sym (cons inition (if used (list symbol))) vars)))))) - -(defun js2--collect-target-symbols (node strict) - "Collect the `js-name-node' symbols declared in NODE and return a list of them. -NODE is either `js2-array-node', `js2-object-node', or `js2-name-node'. -When STRICT, signal an error if NODE is not one of the expected types." - (let (targets) - (cond - ((js2-name-node-p node) - (push node targets)) - ((js2-array-node-p node) - (dolist (elt (js2-array-node-elems node)) - (when elt - (setq elt (cond ((js2-infix-node-p elt) ;; default (=) - (js2-infix-node-left elt)) - ((js2-unary-node-p elt) ;; rest (...) - (js2-unary-node-operand elt)) - (t elt))) - (setq targets (append (js2--collect-target-symbols elt strict) - targets))))) - ((js2-object-node-p node) - (dolist (elt (js2-object-node-elems node)) - (let ((subexpr (cond - ((and (js2-infix-node-p elt) - (= js2-ASSIGN (js2-infix-node-type elt))) - ;; Destructuring with default argument. - (js2-infix-node-left elt)) - ((and (js2-infix-node-p elt) - (= js2-COLON (js2-infix-node-type elt))) - ;; In regular destructuring {a: aa, b: bb}, - ;; the var is on the right. In abbreviated - ;; destructuring {a, b}, right == left. - (js2-infix-node-right elt)) - ((and (js2-unary-node-p elt) - (= js2-TRIPLEDOT (js2-unary-node-type elt))) - ;; Destructuring with spread. - (js2-unary-node-operand elt))))) - (when subexpr - (setq targets (append - (js2--collect-target-symbols subexpr strict) - targets)))))) - ((js2-assign-node-p node) - (setq targets (append (js2--collect-target-symbols - (js2-assign-node-left node) strict) - targets))) - (strict - (js2-report-error "msg.no.parm" nil (js2-node-abs-pos node) - (js2-node-len node)) - nil)) - targets)) - -(defun js2--examine-variable (parent node var-init-node) - "Examine the usage of the variable NODE, a js2-name-node. -PARENT is its direct ancestor and VAR-INIT-NODE is the node to be -examined: return a list of three values, respectively if the -variable is declared and/or assigned or whether it is simply a -key of a literal object." - (let ((target (js2-var-init-node-target var-init-node)) - declared assigned object-key) - (setq declared (memq node (js2--collect-target-symbols target nil))) - ;; Is there an initializer for the declared variable? - (when (js2-var-init-node-initializer var-init-node) - (setq assigned declared) - ;; Determine if the name is actually a literal object key that we shall - ;; ignore later - (when (and (not declared) - (js2-object-prop-node-p parent) - (eq node (js2-object-prop-node-left parent))) - (setq object-key t))) - ;; Maybe this is a for loop and the variable is one of its iterators? - (unless assigned - (let* ((gp (js2-node-parent parent)) - (ggp (if gp (js2-node-parent gp)))) - (when (and ggp (js2-for-in-node-p ggp)) - (setq assigned (memq node - (cl-loop - for kid in (js2-var-decl-node-kids - (js2-for-in-node-iterator ggp)) - with syms = '() - do - (setq syms (append syms - (js2--collect-target-symbols - (js2-var-init-node-target kid) - nil))) - finally return syms)))))) - (list declared assigned object-key))) - -(defun js2--classify-variable (parent node vars) - "Classify the single variable NODE, a js2-name-node." - (let ((function-param (and (js2-function-node-p parent) - (memq node (js2-function-node-params parent))))) - (if (js2-prop-get-node-p parent) - ;; If we are within a prop-get, e.g. the "bar" in "foo.bar", - ;; just mark "foo" as used - (let ((left (js2-prop-get-node-left parent))) - (when (js2-name-node-p left) - (js2--add-or-update-symbol left nil t vars))) - ;; If the node is the external name of an export-binding-node, and - ;; it is different from the local name, ignore it - (when (or (not (js2-export-binding-node-p parent)) - (not (and (eq (js2-export-binding-node-extern-name parent) node) - (not (eq (js2-export-binding-node-local-name parent) node))))) - (let ((granparent parent) - var-init-node - assign-node - object-key ; is name actually an object prop key? - declared ; is it declared in narrowest scope? - assigned ; does it get assigned or initialized? - (used (null function-param))) - ;; Determine the closest var-init-node and assign-node: this - ;; is needed because the name may be within a "destructured" - ;; declaration/assignment, so we cannot just take its parent - (while (and granparent (not (js2-scope-p granparent))) - (cond - ((js2-var-init-node-p granparent) - (when (null var-init-node) - (setq var-init-node granparent))) - ((js2-assign-node-p granparent) - (when (null assign-node) - (setq assign-node granparent)))) - (setq granparent (js2-node-parent granparent))) - - ;; If we are within a var-init-node, determine if the name is - ;; declared and initialized - (when var-init-node - (let ((result (js2--examine-variable parent node var-init-node))) - (setq declared (car result) - assigned (cadr result) - object-key (car (cddr result))))) - - ;; Ignore literal object keys, which are not really variables - (unless object-key - (when function-param - (setq assigned ?P)) - - (when (null assigned) - (cond - ((js2-for-in-node-p parent) - (setq assigned (eq node (js2-for-in-node-iterator parent)) - used (not assigned))) - ((js2-function-node-p parent) - (setq assigned t - used (js2-wrapper-function-p parent))) - ((js2-export-binding-node-p parent) - (if (js2-import-clause-node-p (js2-node-parent parent)) - (setq declared t - assigned t) - (setq used t))) - ((js2-namespace-import-node-p parent) - (setq assigned t - used nil)) - (assign-node - (setq assigned (memq node - (js2--collect-target-symbols - (js2-assign-node-left assign-node) - nil)) - used (not assigned))))) - - (when declared - (setq used nil)) - - (js2--add-or-update-symbol node assigned used vars))))))) - -(defun js2--classify-variables () - "Collect and classify variables declared or used within js2-mode-ast. -Traverse the whole ast tree returning a summary of the variables -usage as an hash-table, keyed by their corresponding symbol table -entry. -Each variable is described by a tuple where the car is a flag -indicating whether the variable has been initialized and the cdr -is a possibly empty list of name nodes where it is used. External -symbols, i.e. those not present in the whole scopes hierarchy, -are ignored." - (let ((vars (make-hash-table :test #'eq :size 100))) - (js2-visit-ast - js2-mode-ast - (lambda (node end-p) - (when (and (null end-p) (js2-name-node-p node)) - (let ((parent (js2-node-parent node))) - (when parent - (js2--classify-variable parent node vars)))) - t)) - vars)) - -(defun js2--get-name-node (node) - (cond - ((js2-name-node-p node) node) - ((js2-function-node-p node) - (js2-function-node-name node)) - ((js2-class-node-p node) - (js2-class-node-name node)) - ((js2-comp-loop-node-p node) - (js2-comp-loop-node-iterator node)) - (t node))) - -(defun js2--highlight-unused-variable (symbol info) - (let ((name (js2-symbol-name symbol)) - (inited (car info)) - (refs (cdr info)) - pos len) - (unless (and inited refs) - (if refs - (dolist (ref refs) - (setq pos (js2-node-abs-pos ref)) - (setq len (js2-name-node-len ref)) - (js2-report-warning "msg.uninitialized.variable" name pos len - 'js2-warning)) - (when (or js2-warn-about-unused-function-arguments - (not (eq inited ?P))) - (let* ((symn (js2-symbol-ast-node symbol)) - (namen (js2--get-name-node symn))) - (unless (js2-node-top-level-decl-p namen) - (setq pos (js2-node-abs-pos namen)) - (setq len (js2-name-node-len namen)) - (js2-report-warning "msg.unused.variable" name pos len - 'js2-warning)))))))) - -(defun js2-highlight-unused-variables () - "Highlight unused variables." - (let ((vars (js2--classify-variables))) - (maphash #'js2--highlight-unused-variable vars))) - -;;;###autoload -(define-minor-mode js2-highlight-unused-variables-mode - "Toggle highlight of unused variables." - :lighter "" - (if js2-highlight-unused-variables-mode - (add-hook 'js2-post-parse-callbacks - #'js2-highlight-unused-variables nil t) - (remove-hook 'js2-post-parse-callbacks - #'js2-highlight-unused-variables t))) - -(defun js2-add-additional-externs (externs) - (setq js2-additional-externs - (nconc externs - js2-additional-externs))) - -(defun js2-get-jslint-comment-identifiers (comment) - (js2-reparse) - (cl-loop for node in (js2-ast-root-comments js2-mode-ast) - when (and (eq 'block (js2-comment-node-format node)) - (save-excursion - (goto-char (js2-node-abs-pos node)) - (looking-at (concat "/\\* *" comment "\\(?: \\|$\\)")))) - append (js2-get-jslint-comment-identifiers-in - (match-end 0) - (js2-node-abs-end node)))) - -(defun js2-get-jslint-comment-identifiers-in (beg end) - (let (res) - (save-excursion - (goto-char beg) - (while (re-search-forward js2-mode-identifier-re end t) - (let ((match (match-string 0))) - (unless (member match '("true" "false")) - (push match res))))) - (nreverse res))) - -(defun js2-apply-jslint-globals () - (js2-add-additional-externs (js2-get-jslint-globals))) - -(defun js2-get-jslint-globals () - (js2-get-jslint-comment-identifiers "global")) - -(defun js2-apply-jslint-declaration-externs () - (js2-add-additional-externs (js2-get-jslint-declaration-externs))) - -(defvar js2-jslint-declaration-externs - `(("browser" . ,(mapcar 'symbol-name - '(Audio clearInterval clearTimeout document - event history Image location name - navigator Option screen setInterval - setTimeout XMLHttpRequest))) - ("node" . ,(mapcar 'symbol-name - '(Buffer clearImmediate clearInterval - clearTimeout console exports global module - process querystring require setImmediate - setInterval setTimeout __dirname - __filename))) - ("es6" . ,(mapcar 'symbol-name - '(ArrayBuffer DataView Float32Array - Float64Array Int8Array Int16Array Int32Array - Intl Map Promise Proxy Reflect Set Symbol - System Uint8Array Uint8ClampedArray - Uint16Array Uint32Array WeakMap WeakSet))) - ("couch" . ,(mapcar 'symbol-name - '(emit getRow isArray log provides - registerType require send start sum - toJSON))) - ("devel" . ,(mapcar 'symbol-name - '(alert confirm console Debug opera prompt - WSH))))) - -(defun js2-get-jslint-declaration-externs () - (apply 'append - (mapcar (lambda (identifier) - (cdr (assoc identifier - js2-jslint-declaration-externs))) - (js2-get-jslint-comment-identifiers "jslint")))) - -;;; IMenu support - -;; We currently only support imenu, but eventually should support speedbar and -;; possibly other browsing mechanisms. - -;; The basic strategy is to identify function assignment targets of the form -;; `foo.bar.baz', convert them to (list 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. - -;; A `foo.bar.baz' assignment target may be expressed in many ways in -;; JavaScript, and the general problem is undecidable. However, several forms -;; are readily recognizable at parse-time; the forms we attempt to recognize -;; include: - -;; function foo() -- function declaration -;; foo = function() -- function expression assigned to variable -;; foo.bar.baz = function() -- function expr assigned to nested property-get -;; foo = {bar: function()} -- fun prop in object literal assigned to var -;; foo = {bar: {baz: function()}} -- inside nested object literal -;; foo.bar = {baz: function()}} -- obj lit assigned to nested prop get -;; a.b = {c: {d: function()}} -- nested obj lit assigned to nested prop get -;; foo = {get bar() {...}} -- getter/setter in obj literal -;; function foo() {function bar() {...}} -- nested function -;; foo['a'] = function() -- fun expr assigned to deterministic element-get - -;; This list boils down to a few forms that can be combined recursively. -;; Top-level named function declarations include both the left-hand (name) -;; and the right-hand (function value) expressions needed to produce an imenu -;; entry. The other "right-hand" forms we need to look for are: -;; - functions declared as props/getters/setters in object literals -;; - nested named function declarations -;; The "left-hand" expressions that functions can be assigned to include: -;; - local/global variables -;; - nested property-get expressions like a.b.c.d -;; - element gets like foo[10] or foo['bar'] where the index -;; expression can be trivially converted to a property name. They -;; effectively then become property gets. - -;; All the different definition types are canonicalized into the form -;; foo.bar.baz = position-of-function-keyword - -;; We need to build a trie-like structure for imenu. As an example, -;; consider the following JavaScript code: - -;; a = function() {...} // function at position 5 -;; b = function() {...} // function at position 25 -;; foo = function() {...} // function at position 100 -;; foo.bar = function() {...} // function at position 200 -;; foo.bar.baz = function() {...} // function at position 300 -;; foo.bar.zab = function() {...} // function at position 400 - -;; During parsing we accumulate an entry for each definition in -;; the variable `js2-imenu-recorder', like so: - -;; '((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) -;; (b . 2) -;; (foo (<definition> . 3) -;; (bar (<definition> . 6) -;; (baz . 100) -;; (zab . 200)))) - -;; Note the wacky need for a <definition> name. The token can be anything -;; that isn't a valid JavaScript identifier, because you might make foo -;; a function and then start setting properties on it that are also functions. - -(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." - (cond - ((js2-name-node-p node) - (js2-name-node-name node)) - ((js2-string-node-p node) - (js2-string-node-value node)) - ((and (js2-number-node-p node) - (string-match "^[0-9]+$" (js2-number-node-value node))) - (js2-number-node-value node)) - ((eq (js2-node-type node) js2-THIS) - "this") - ((eq (js2-node-type node) js2-SUPER) - "super"))) - -(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) - (cond - ((and (js2-function-node-p node) - (js2-function-node-name node)) - (js2-name-node-name (js2-function-node-name node))) - ((js2-computed-prop-name-node-p node) - "[computed]"))))) - -(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. -When passed arguments of wrong type, does nothing." - (when js2-parse-ide-mode - (let ((fun-p (js2-function-node-p node)) - qname fname-node) - (cond - ;; non-anonymous function declaration? - ((and fun-p - (not var) - (setq fname-node (js2-function-node-name node))) - (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 - (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) - ;; Node position here is still absolute, since the parser - ;; passes the assignment target and value expressions - ;; to us before they are added as children of the assignment node. - (js2-record-object-literal node qname (js2-node-pos node))))))))) - -(defun js2-compute-nested-prop-get (node) - "If NODE is of form foo.bar, foo['bar'], or any nested combination, return -component nodes as a list. Otherwise return nil. Element-gets are treated -as property-gets if the index expression is a string, or a positive integer." - (let (left right head) - (cond - ((or (js2-name-node-p node) - (js2-this-or-super-node-p node)) - (list node)) - ;; foo.bar.baz is parenthesized as (foo.bar).baz => right operand is a leaf - ((js2-prop-get-node-p node) ; foo.bar - (setq left (js2-prop-get-node-left node) - right (js2-prop-get-node-right node)) - (if (setq head (js2-compute-nested-prop-get left)) - (nconc head (list right)))) - ((js2-elem-get-node-p node) ; foo['bar'] or foo[101] - (setq left (js2-elem-get-node-target node) - right (js2-elem-get-node-element node)) - (if (or (js2-string-node-p right) ; ['bar'] - (and (js2-number-node-p right) ; [10] - (string-match "^[0-9]+$" - (js2-number-node-value right)))) - (if (setq head (js2-compute-nested-prop-get left)) - (nconc head (list right)))))))) - -(defun js2-record-object-literal (node qname pos) - "Recursively process an object literal looking for functions. -NODE is an object literal that is the right-hand child of an assignment -expression. QNAME is a list of nodes representing the assignment target, -e.g. for foo.bar.baz = {...}, QNAME is (foo-node bar-node baz-node). -POS is the absolute position of the node. -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 (right) - (dolist (e (js2-object-node-elems node)) ; e is a `js2-object-prop-node' - (when (js2-infix-node-p e) - (let ((left (js2-infix-node-left e)) - ;; Element positions are relative to the parent position. - (pos (+ pos (js2-node-pos e)))) - (cond - ;; foo: function() {...} - ((js2-function-node-p (setq right (js2-infix-node-right e))) - (when (js2-prop-node-name left) - ;; As a policy decision, we record the position of the property, - ;; not the position of the `function' keyword, since the property - ;; is effectively the name of the function. - (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)))))))))) - -(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." - (let* ((name (js2-prop-node-name node)) - (this-scope (js2-node-get-enclosing-scope node)) - defining-scope) - (cond - ((js2-this-or-super-node-p node) - nil) - ((null this-scope) - t) - ((setq defining-scope (js2-get-defining-scope this-scope name)) - (js2-ast-root-p defining-scope)) - (t t)))) - -(defun js2-wrapper-function-p (node) - "Return t if NODE is a function expression that's immediately invoked. -NODE must be `js2-function-node'." - (let ((parent (js2-node-parent node))) - (or - ;; function(){...}(); - (and (js2-call-node-p parent) - (eq node (js2-call-node-target 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 () - "Modify function-declaration name chains after parsing finishes. -Some of the information is only available after the parse tree is complete. -For instance, processing a nested scope requires a parent function node." - (let (result fn parent-qname p elem) - (dolist (entry js2-imenu-recorder) - ;; function node goes first - (cl-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-or-super-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)) - (if (eq parent-qname 'skip) - ;; We don't show it, let's record that fact. - (remhash current-fn js2-imenu-function-map) - ;; Prepend parent fn qname to this chain. - (let ((qname (append parent-qname chain))) - (puthash current-fn (butlast qname) js2-imenu-function-map) - (push qname result))))))) - ;; Collect chains obtained by third-party code. - (let (js2-imenu-recorder) - (run-hooks 'js2-build-imenu-callbacks) - (dolist (entry js2-imenu-recorder) - (push (cdr entry) result))) - ;; Finally replace each node in each chain with its name. - (dolist (chain result) - (setq p chain) - (while p - (if (js2-node-p (setq elem (car p))) - (setcar p (js2-node-qname-component elem))) - (setq p (cdr p)))) - result)) - -;; Merge name chains into a trie-like tree structure of nested lists. -;; To simplify construction of the trie, we first build it out using the rule -;; that the trie consists of lists of pairs. Each pair is a 2-element array: -;; [key, num-or-list]. The second element can be a number; if so, this key -;; is a leaf-node with only one value. (I.e. there is only one declaration -;; associated with the key at this level.) Otherwise the second element is -;; a list of pairs, with the rule applied recursively. This symmetry permits -;; a simple recursive formulation. -;; -;; js2-mode is building the data structure for imenu. The imenu documentation -;; claims that it's the structure above, but in practice it wants the children -;; at the same list level as the key for that level, which is how I've drawn -;; the "Expected final result" above. We'll postprocess the trie to remove the -;; list wrapper around the children at each level. -;; -;; A completed nested imenu-alist entry looks like this: -;; '(("foo" -;; ("<definition>" . 7) -;; ("bar" -;; ("a" . 40) -;; ("b" . 60)))) -;; -;; In particular, the documentation for `imenu--index-alist' says that -;; a nested sub-alist element looks like (INDEX-NAME SUB-ALIST). -;; The sub-alist entries immediately follow INDEX-NAME, the head of the list. - -(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)))))) - -(defun js2-build-alist-trie (chains trie) - "Merge declaration name chains into a trie-like alist structure for imenu. -CHAINS is the qname chain list produced during parsing. TRIE is a -list of elements built up so far." - (let (head tail pos branch kids) - (dolist (chain chains) - (setq head (car chain) - tail (cdr chain) - pos (if (numberp (car tail)) (car tail)) - branch (js2-find-if (lambda (n) - (string= (car n) head)) - trie) - kids (cl-second branch)) - (cond - ;; case 1: this key isn't in the trie yet - ((null branch) - (if trie - (setcdr (last trie) (list (js2-treeify chain))) - (setq trie (list (js2-treeify chain))))) - ;; case 2: key is present with a single number entry: replace w/ list - ;; ("a1" 10) + ("a1" 20) => ("a1" (("<definition>" 10) - ;; ("<definition>" 20))) - ((numberp kids) - (setcar (cdr branch) - (list (list "<definition-1>" kids) - (if pos - (list "<definition-2>" pos) - (js2-treeify tail))))) - ;; case 3: key is there (with kids), and we're a number entry - (pos - (setcdr (last kids) - (list - (list (format "<definition-%d>" - (1+ (cl-loop for kid in kids - count (eq ?< (aref (car kid) 0))))) - pos)))) - ;; case 4: key is there with kids, need to merge in our chain - (t - (js2-build-alist-trie (list tail) kids)))) - trie)) - -(defun js2-flatten-trie (trie) - "Convert TRIE to imenu-format. -Recurses through nodes, and for each one whose second element is a list, -appends the list's flattened elements to the current element. Also -changes the tails into conses. For instance, this pre-flattened trie - -'(a ((b 20) - (c ((d 30) - (e 40))))) - -becomes - -'(a (b . 20) - (c (d . 30) - (e . 40))) - -Note that the root of the trie has no key, just a list of chains. -This is also true for the value of any key with multiple children, -e.g. key 'c' in the example above." - (cond - ((listp (car trie)) - (mapcar #'js2-flatten-trie trie)) - (t - (if (numberp (cl-second trie)) - (cons (car trie) (cl-second trie)) - ;; else pop list and append its kids - (apply #'append (list (car trie)) (js2-flatten-trie (cdr trie))))))) - -(defun js2-build-imenu-index () - "Turn `js2-imenu-recorder' into an imenu data structure." - (when (eq js2-imenu-recorder 'empty) - (setq js2-imenu-recorder nil)) - (let* ((chains (js2-browse-postprocess-chains)) - (result (js2-build-alist-trie chains nil))) - (js2-flatten-trie result))) - -(defun js2-test-print-chains (chains) - "Print a list of qname chains. -Each element of CHAINS is a list of the form (NODE [NODE *] pos); -i.e. one or more nodes, and an integer position as the list tail." - (mapconcat (lambda (chain) - (concat "(" - (mapconcat (lambda (elem) - (if (js2-node-p elem) - (or (js2-node-qname-component elem) - "nil") - (number-to-string elem))) - chain - " ") - ")")) - chains - "\n")) - -;;; Parser - -(defconst js2-version "1.8.5" - "Version of JavaScript supported.") - -(defun js2-record-face (face &optional token) - "Record a style run of FACE for TOKEN or the current token." - (unless token (setq token (js2-current-token))) - (js2-set-face (js2-token-beg token) (js2-token-end token) face 'record)) - -(defsubst js2-node-end (n) - "Computes the absolute end of node N. -Use with caution! Assumes `js2-node-pos' is -absolute-, which -is only true until the node is added to its parent; i.e., while parsing." - (+ (js2-node-pos n) - (js2-node-len n))) - -(defun js2-record-comment (token) - "Record a comment in `js2-scanned-comments'." - (let ((ct (js2-token-comment-type token)) - (beg (js2-token-beg token)) - (end (js2-token-end token))) - (push (make-js2-comment-node :len (- end beg) - :format ct) - js2-scanned-comments) - (when js2-parse-ide-mode - (js2-record-face (if (eq ct 'jsdoc) - 'font-lock-doc-face - 'font-lock-comment-face) - token) - (when (memq ct '(html preprocessor)) - ;; Tell cc-engine the bounds of the comment. - (js2-record-text-property beg (1- end) 'c-in-sws t))))) - -(defun js2-peek-token (&optional modifier) - "Return the next token type without consuming it. -If `js2-ti-lookahead' is positive, return the type of next token -from `js2-ti-tokens'. Otherwise, call `js2-get-token'." - (if (not (zerop js2-ti-lookahead)) - (js2-token-type - (aref js2-ti-tokens (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens))) - (let ((tt (js2-get-token-internal modifier))) - (js2-unget-token) - tt))) - -(defalias 'js2-next-token 'js2-get-token) - -(defun js2-match-token (match &optional dont-unget) - "Get next token and return t if it matches MATCH, a bytecode. -Returns nil and consumes nothing if MATCH is not the next token." - (if (/= (js2-get-token) match) - (ignore (unless dont-unget (js2-unget-token))) - t)) - -(defun js2-match-contextual-kwd (name) - "Consume and return t if next token is `js2-NAME', and its -string is NAME. Returns nil and keeps current token otherwise." - (if (js2-contextual-kwd-p (progn (js2-get-token) - (js2-current-token)) - name) - (progn (js2-record-face 'font-lock-keyword-face) t) - (js2-unget-token) - nil)) - -(defun js2-contextual-kwd-p (token name) - "Return t if TOKEN is `js2-NAME', and its string is NAME." - (and (= (js2-token-type token) js2-NAME) - (string= (js2-token-string token) name))) - -(defun js2-match-async-function () - (when (and (js2-contextual-kwd-p (js2-current-token) "async") - (= (js2-peek-token) js2-FUNCTION)) - (js2-record-face 'font-lock-keyword-face) - (js2-get-token) - t)) - -(defun js2-match-async-arrow-function () - (and (js2-contextual-kwd-p (js2-current-token) "async") - (/= (js2-peek-token) js2-FUNCTION))) - -(defsubst js2-inside-function () - (cl-plusp js2-nesting-of-function)) - -(defsubst js2-inside-async-function () - (and (js2-inside-function) - (js2-function-node-async js2-current-script-or-fn))) - -(defun js2-parse-await-maybe (tt) - "Parse \"await\" as an AwaitExpression, if it is one." - (and (= tt js2-NAME) - (js2-contextual-kwd-p (js2-current-token) "await") - ;; Per the proposal, AwaitExpression consists of "await" - ;; followed by a UnaryExpression. So look ahead for one. - (let ((ts-state (make-js2-ts-state)) - (recorded-identifiers js2-recorded-identifiers) - (parsed-errors js2-parsed-errors) - (current-token (js2-current-token)) - (beg (js2-current-token-beg)) - (end (js2-current-token-end)) - pn) - (js2-get-token) - (setq pn (js2-make-unary beg js2-AWAIT 'js2-parse-unary-expr)) - (if (= (js2-node-type (js2-unary-node-operand pn)) js2-ERROR) - ;; The parse failed, so pretend like nothing happened and restore - ;; the previous parsing state. - (progn - (js2-ts-seek ts-state) - (setq js2-recorded-identifiers recorded-identifiers - js2-parsed-errors parsed-errors) - ;; And ensure the caller knows about the failure. - nil) - ;; The parse was successful, so process and return the "await". - (js2-record-face 'font-lock-keyword-face current-token) - (unless (js2-inside-async-function) - (js2-report-error "msg.bad.await" nil - beg (- end beg))) - pn)))) - -(defun js2-get-prop-name-token () - (js2-get-token (and (>= js2-language-version 170) 'KEYWORD_IS_NAME))) - -(defun js2-match-prop-name () - "Consume token and return t if next token is a valid property name. -If `js2-language-version' is >= 180, a keyword or reserved word -is considered valid name as well." - (if (eq js2-NAME (js2-get-prop-name-token)) - t - (js2-unget-token) - nil)) - -(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)) - -(defun js2-peek-token-or-eol () - "Return js2-EOL if the next token immediately follows a newline. -Else returns the next token. Used in situations where we don't -consider certain token types valid if they are preceded by a newline. -One example is the postfix ++ or -- operator, which has to be on the -same line as its operand." - (let ((tt (js2-get-token)) - (follows-eol (js2-token-follows-eol-p (js2-current-token)))) - (js2-unget-token) - (if follows-eol - js2-EOL - tt))) - -(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." - (if (js2-match-token token t) - t - (js2-report-error msg-id nil pos len) - (js2-unget-token) - nil)) - -(defun js2-must-match-name (msg-id) - (if (js2-match-token js2-NAME t) - t - (if (eq (js2-current-token-type) js2-RESERVED) - (js2-report-error "msg.reserved.id" (js2-current-token-string)) - (js2-report-error msg-id) - (js2-unget-token)) - nil)) - -(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))) - -(defun js2-check-activation-name (name _token) - (when (js2-inside-function) - ;; skip language-version 1.2 check from Rhino - (if (or (string= "arguments" name) - (and js2-compiler-activation-names ; only used in codegen - (gethash name js2-compiler-activation-names))) - (js2-set-requires-activation)))) - -(defun js2-set-is-generator () - (let ((fn-node js2-current-script-or-fn)) - (when (and (js2-function-node-p fn-node) - (not (js2-function-node-generator-type fn-node))) - (setf (js2-function-node-generator-type js2-current-script-or-fn) 'LEGACY)))) - -(defun js2-must-have-xml () - (unless js2-compiler-xml-available - (js2-report-error "msg.XML.not.available"))) - -(defun js2-push-scope (scope) - "Push SCOPE, a `js2-scope', onto the lexical scope chain." - (cl-assert (js2-scope-p scope)) - (cl-assert (null (js2-scope-parent-scope scope))) - (cl-assert (not (eq js2-current-scope scope))) - (setf (js2-scope-parent-scope scope) js2-current-scope - js2-current-scope scope)) - -(defsubst js2-pop-scope () - (setq js2-current-scope - (js2-scope-parent-scope js2-current-scope))) - -(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) - ;; Tell the current labeled statement (if any) its statement, - ;; and set the jump target of the first label to the loop. - ;; These are used in `js2-parse-continue' to verify that the - ;; continue target is an actual labeled loop. (And for codegen.) - (when js2-labeled-stmt - (setf (js2-labeled-stmt-node-stmt js2-labeled-stmt) loop-node - (js2-label-node-loop (car (js2-labeled-stmt-node-labels - js2-labeled-stmt))) loop-node))) - -(defun js2-exit-loop () - (pop js2-loop-set) - (pop js2-loop-and-switch-set) - (js2-pop-scope)) - -(defsubst js2-enter-switch (switch-node) - (js2-push-scope switch-node) - (push switch-node js2-loop-and-switch-set)) - -(defsubst js2-exit-switch () - (js2-pop-scope) - (pop js2-loop-and-switch-set)) - -(defsubst js2-get-directive (node) - "Return NODE's value if it is a directive, nil otherwise. - -A directive is an otherwise-meaningless expression statement -consisting of a string literal, such as \"use strict\"." - (and (js2-expr-stmt-node-p node) - (js2-string-node-p (setq node (js2-expr-stmt-node-expr node))) - (js2-string-node-value node))) - -(defun js2-parse (&optional buf cb) - "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. - -The returned AST root node is given some additional properties: - `node-count' - total number of nodes in the AST - `buffer' - BUF. The buffer it refers to may change or be killed, - so the value is not necessarily reliable. - -An optional callback CB can be specified to report parsing -progress. If `(functionp CB)' returns t, it will be called with -the current line number once before parsing begins, then again -each time the lexer reaches a new line number. - -CB can also be a list of the form `(symbol cb ...)' to specify -multiple callbacks with different criteria. Each symbol is a -criterion keyword, and the following element is the callback to -call - - :line - called whenever the line number changes - :token - called for each new token consumed - -The list of criteria could be extended to include entering or -leaving a statement, an expression, or a function definition." - (if (and cb (not (functionp cb))) - (error "criteria callbacks not yet implemented")) - (let ((inhibit-point-motion-hooks t) - (js2-compiler-xml-available (>= js2-language-version 160)) - ;; This is a recursive-descent parser, so give it a big stack. - (max-lisp-eval-depth (max max-lisp-eval-depth 3000)) - (max-specpdl-size (max max-specpdl-size 3000)) - (case-fold-search nil) - ast) - (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-label-set nil) - (js2-init-scanner) - (setq ast (js2-do-parse)) - (unless js2-ts-hit-eof - (js2-report-error "msg.got.syntax.errors" (length js2-parsed-errors))) - (setf (js2-ast-root-errors ast) js2-parsed-errors - (js2-ast-root-warnings ast) js2-parsed-warnings) - ;; if we didn't find any declarations, put a dummy in this list so we - ;; don't end up re-parsing the buffer in `js2-mode-create-imenu-index' - (unless js2-imenu-recorder - (setq js2-imenu-recorder 'empty)) - (run-hooks 'js2-parse-finished-hook) - ast))) - -;; Corresponds to Rhino's Parser.parse() method. -(defun js2-do-parse () - "Parse current buffer starting from current point. -Scanner should be initialized." - (let ((pos js2-ts-cursor) - (end js2-ts-cursor) ; in case file is empty - root n tt - (in-directive-prologue t) - (js2-in-use-strict-directive js2-in-use-strict-directive) - directive) - ;; initialize buffer-local parsing vars - (setf root (make-js2-ast-root :buffer (buffer-name) :pos pos) - js2-current-script-or-fn root - js2-current-scope root - js2-nesting-of-function 0 - js2-labeled-stmt nil - js2-recorded-identifiers nil ; for js2-highlight - js2-in-use-strict-directive js2-mode-assume-strict) - (while (/= (setq tt (js2-get-token)) js2-EOF) - (if (= tt js2-FUNCTION) - (progn - (setq n (if js2-called-by-compile-function - (js2-parse-function-expr) - (js2-parse-function-stmt)))) - ;; not a function - parse a statement - (js2-unget-token) - (setq n (js2-parse-statement)) - (when in-directive-prologue - (setq directive (js2-get-directive n)) - (cond - ((null directive) - (setq in-directive-prologue nil)) - ((string= directive "use strict") - (setq js2-in-use-strict-directive t))))) - ;; add function or statement to script - (setq end (js2-node-end n)) - (js2-block-node-push root n)) - ;; add comments to root in lexical order - (when js2-scanned-comments - ;; if we find a comment beyond end of normal kids, use its end - (setq end (max end (js2-node-end (cl-first js2-scanned-comments)))) - (dolist (comment js2-scanned-comments) - (push comment (js2-ast-root-comments root)) - (js2-node-add-children root comment))) - (setf (js2-node-len root) (- end pos)) - (setq js2-mode-ast root) ; Make sure this is available for callbacks. - ;; Give extensions a chance to muck with things before highlighting starts. - (let ((js2-additional-externs js2-additional-externs)) - (js2-filter-parsed-warnings) - (save-excursion - (run-hooks 'js2-post-parse-callbacks)) - (js2-highlight-undeclared-vars)) - root)) - -(defun js2-filter-parsed-warnings () - "Remove `js2-parsed-warnings' elements that match `js2-ignored-warnings'." - (when js2-ignored-warnings - (setq js2-parsed-warnings - (cl-remove-if - (lambda (warning) - (let ((msg (caar warning))) - (member msg js2-ignored-warnings))) - js2-parsed-warnings))) - js2-parsed-warnings) - -(defun js2-parse-function-closure-body (fn-node) - "Parse a JavaScript 1.8 function closure body." - (let ((js2-nesting-of-function (1+ js2-nesting-of-function))) - (if js2-ts-hit-eof - (js2-report-error "msg.no.brace.body" nil - (js2-node-pos fn-node) - (- js2-ts-cursor (js2-node-pos fn-node))) - (js2-node-add-children fn-node - (setf (js2-function-node-body fn-node) - (js2-parse-expr t)))))) - -(defun js2-parse-function-body (fn-node) - (js2-must-match js2-LC "msg.no.brace.body" - (js2-node-pos fn-node) - (- js2-ts-cursor (js2-node-pos fn-node))) - (let ((pos (js2-current-token-beg)) ; LC position - (pn (make-js2-block-node)) ; starts at LC position - tt - end - not-in-directive-prologue - node - directive) - (cl-incf js2-nesting-of-function) - (unwind-protect - (while (not (or (= (setq tt (js2-peek-token)) js2-ERROR) - (= tt js2-EOF) - (= tt js2-RC))) - (js2-block-node-push - pn - (if (/= tt js2-FUNCTION) - (if not-in-directive-prologue - (js2-parse-statement) - (setq node (js2-parse-statement) - directive (js2-get-directive node)) - (cond - ((null directive) - (setq not-in-directive-prologue t)) - ((string= directive "use strict") - ;; Back up and reparse the function, because new rules apply - ;; to the function name and parameters. - (when (not js2-in-use-strict-directive) - (setq js2-in-use-strict-directive t) - (throw 'reparse t)))) - node) - (js2-get-token) - (js2-parse-function-stmt)))) - (cl-decf js2-nesting-of-function)) - (setq end (js2-current-token-end)) ; assume no curly and leave at current token - (if (js2-must-match js2-RC "msg.no.brace.after.body" pos) - (setq end (js2-current-token-end))) - (setf (js2-node-pos pn) pos - (js2-node-len pn) (- end pos)) - (setf (js2-function-node-body fn-node) pn) - (js2-node-add-children fn-node pn) - pn)) - -(defun js2-define-destruct-symbols (node decl-type face &optional ignore-not-in-block) - "Declare and fontify destructuring parameters inside NODE. -NODE is either `js2-array-node', `js2-object-node', or `js2-name-node'. - -Return a list of `js2-name-node' nodes representing the symbols -declared; probably to check them for errors." - (let ((name-nodes (js2--collect-target-symbols node t))) - (dolist (node name-nodes) - (let (leftpos) - (js2-define-symbol decl-type (js2-name-node-name node) - node ignore-not-in-block) - (when face - (js2-set-face (setq leftpos (js2-node-abs-pos node)) - (+ leftpos (js2-node-len node)) - face 'record)))) - name-nodes)) - -(defvar js2-illegal-strict-identifiers - '("eval" "arguments") - "Identifiers not allowed as variables in strict mode.") - -(defun js2-check-strict-identifier (name-node) - "Check that NAME-NODE makes a legal strict mode identifier." - (when js2-in-use-strict-directive - (let ((param-name (js2-name-node-name name-node))) - (when (member param-name js2-illegal-strict-identifiers) - (js2-report-error "msg.bad.id.strict" param-name - (js2-node-abs-pos name-node) (js2-node-len name-node)))))) - -(defun js2-check-strict-function-params (preceding-params params) - "Given PRECEDING-PARAMS in a function's parameter list, check -for strict mode errors caused by PARAMS." - (when js2-in-use-strict-directive - (dolist (param params) - (let ((param-name (js2-name-node-name param))) - (js2-check-strict-identifier param) - (when (cl-some (lambda (param) - (string= (js2-name-node-name param) param-name)) - preceding-params) - (js2-report-error "msg.dup.param.strict" param-name - (js2-node-abs-pos param) (js2-node-len param))))))) - -(defun js2-parse-function-params (function-type fn-node pos) - "Parse the parameters of a function of FUNCTION-TYPE -represented by FN-NODE at POS." - (if (js2-match-token js2-RP) - (setf (js2-function-node-rp fn-node) (- (js2-current-token-beg) pos)) - (let ((paren-free-arrow (and (eq function-type 'FUNCTION_ARROW) - (eq (js2-current-token-type) js2-NAME))) - params param - param-name-nodes new-param-name-nodes - rest-param-at) - (when paren-free-arrow - (js2-unget-token)) - (cl-loop for tt = (js2-peek-token) - do - (cond - ;; destructuring param - ((and (not paren-free-arrow) - (or (= tt js2-LB) (= tt js2-LC))) - (js2-get-token) - (setq param (js2-parse-destruct-primary-expr) - new-param-name-nodes (js2-define-destruct-symbols - param js2-LP 'js2-function-param)) - (js2-check-strict-function-params param-name-nodes new-param-name-nodes) - (setq param-name-nodes (append param-name-nodes new-param-name-nodes))) - ;; variable name - (t - (when (and (>= js2-language-version 200) - (not paren-free-arrow) - (js2-match-token js2-TRIPLEDOT) - (not rest-param-at)) - ;; to report errors if there are more parameters - (setq rest-param-at (length params))) - (js2-must-match-name "msg.no.parm") - (js2-record-face 'js2-function-param) - (setq param (js2-create-name-node)) - (js2-define-symbol js2-LP (js2-current-token-string) param) - (js2-check-strict-function-params param-name-nodes (list param)) - (setq param-name-nodes (append param-name-nodes (list param))))) - ;; default parameter value - (when (and (not rest-param-at) - (>= js2-language-version 200) - (js2-match-token js2-ASSIGN)) - (cl-assert (not paren-free-arrow)) - (let* ((pos (js2-node-pos param)) - (tt (js2-current-token-type)) - (op-pos (- (js2-current-token-beg) pos)) - (left param) - (right (js2-parse-assign-expr)) - (len (- (js2-node-end right) pos))) - (setq param (make-js2-assign-node - :type tt :pos pos :len len :op-pos op-pos - :left left :right right)) - (js2-node-add-children param left right))) - (push param params) - (when (and rest-param-at (> (length params) (1+ rest-param-at))) - (js2-report-error "msg.param.after.rest" nil - (js2-node-pos param) (js2-node-len param))) - while - (and (js2-match-token js2-COMMA) - (or (< js2-language-version 200) - (not (= js2-RP (js2-peek-token)))))) - (when (and (not paren-free-arrow) - (js2-must-match js2-RP "msg.no.paren.after.parms")) - (setf (js2-function-node-rp fn-node) (- (js2-current-token-beg) pos))) - (when rest-param-at - (setf (js2-function-node-rest-p fn-node) t)) - (dolist (p params) - (js2-node-add-children fn-node p) - (push p (js2-function-node-params fn-node)))))) - -(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 - js2-strict-inconsistent-return-warning - (not (js2-has-consistent-return-usage - (js2-function-node-body fn-node)))) - ;; Have it extend from close-curly to bol or beginning of block. - (let ((pos (save-excursion - (goto-char (js2-current-token-end)) - (max (js2-node-abs-pos (js2-function-node-body fn-node)) - (point-at-bol)))) - (end (js2-current-token-end))) - (if (cl-plusp (js2-name-node-length name)) - (js2-add-strict-warning "msg.no.return.value" - (js2-name-node-name name) pos end) - (js2-add-strict-warning "msg.anon.no.return.value" nil pos end))))) - -(defun js2-parse-function-stmt (&optional async-p) - (let ((pos (js2-current-token-beg)) - (star-p (js2-match-token js2-MUL))) - (js2-must-match-name "msg.unnamed.function.stmt") - (let ((name (js2-create-name-node t)) - pn member-expr) - (cond - ((js2-match-token js2-LP) - (js2-parse-function 'FUNCTION_STATEMENT pos star-p async-p name)) - (js2-allow-member-expr-as-function-name - (setq member-expr (js2-parse-member-expr-tail nil name)) - (js2-parse-highlight-member-expr-fn-name member-expr) - (js2-must-match js2-LP "msg.no.paren.parms") - (setf pn (js2-parse-function 'FUNCTION_STATEMENT pos star-p async-p) - (js2-function-node-member-expr pn) member-expr) - pn) - (t - (js2-report-error "msg.no.paren.parms") - (make-js2-error-node)))))) - -(defun js2-parse-async-function-stmt () - (js2-parse-function-stmt t)) - -(defun js2-parse-function-expr (&optional async-p) - (let ((pos (js2-current-token-beg)) - (star-p (js2-match-token js2-MUL)) - name) - (when (js2-match-token js2-NAME) - (setq name (js2-create-name-node t))) - (js2-must-match js2-LP "msg.no.paren.parms") - (js2-parse-function 'FUNCTION_EXPRESSION pos star-p async-p name))) - -(defun js2-parse-function-internal (function-type pos star-p &optional async-p name) - (let (fn-node lp) - (if (= (js2-current-token-type) js2-LP) ; eventually matched LP? - (setq lp (js2-current-token-beg))) - (setf fn-node (make-js2-function-node :pos pos - :name name - :form function-type - :lp (if lp (- lp pos)) - :generator-type (and star-p 'STAR) - :async async-p)) - (when name - (js2-set-face (js2-node-pos name) (js2-node-end name) - 'font-lock-function-name-face 'record) - (when (and (eq function-type 'FUNCTION_STATEMENT) - (cl-plusp (js2-name-node-length name))) - ;; Function statements define a symbol in the enclosing scope - (js2-define-symbol js2-FUNCTION (js2-name-node-name name) fn-node)) - (when js2-in-use-strict-directive - (js2-check-strict-identifier name))) - (if (or (js2-inside-function) (cl-plusp js2-nesting-of-with)) - ;; 1. Nested functions are not affected by the dynamic scope flag - ;; as dynamic scope is already a parent of their scope. - ;; 2. Functions defined under the with statement also immune to - ;; this setup, in which case dynamic scope is ignored in favor - ;; of the with object. - (setf (js2-function-node-ignore-dynamic fn-node) t)) - ;; dynamically bind all the per-function variables - (let ((js2-current-script-or-fn fn-node) - (js2-current-scope fn-node) - (js2-nesting-of-with 0) - (js2-end-flags 0) - js2-label-set - js2-loop-set - js2-loop-and-switch-set) - (js2-parse-function-params function-type fn-node pos) - (when (eq function-type 'FUNCTION_ARROW) - (js2-must-match js2-ARROW "msg.bad.arrow.args")) - (if (and (>= js2-language-version 180) - (/= (js2-peek-token) js2-LC)) - (js2-parse-function-closure-body fn-node) - (js2-parse-function-body fn-node)) - (js2-check-inconsistent-return-warning fn-node name) - - (when name - (js2-node-add-children fn-node name) - ;; Function expressions define a name only in the body of the - ;; function, and only if not hidden by a parameter name - (when (and (eq function-type 'FUNCTION_EXPRESSION) - (null (js2-scope-get-symbol js2-current-scope - (js2-name-node-name name)))) - (js2-define-symbol js2-FUNCTION - (js2-name-node-name name) - fn-node)) - (when (eq function-type 'FUNCTION_STATEMENT) - (js2-record-imenu-functions fn-node)))) - - (setf (js2-node-len fn-node) (- (js2-current-token-end) pos)) - ;; Rhino doesn't do this, but we need it for finding undeclared vars. - ;; We wait until after parsing the function to set its parent scope, - ;; since `js2-define-symbol' needs the defining-scope check to stop - ;; at the function boundary when checking for redeclarations. - (setf (js2-scope-parent-scope fn-node) js2-current-scope) - fn-node)) - -(defun js2-parse-function (function-type pos star-p &optional async-p name) - "Function parser. FUNCTION-TYPE is a symbol, POS is the -beginning of the first token (function keyword, unless it's an -arrow function), NAME is js2-name-node." - (let ((continue t) - ts-state - fn-node - ;; Preserve strict state outside this function. - (js2-in-use-strict-directive js2-in-use-strict-directive)) - ;; Parse multiple times if a new strict mode directive is discovered in the - ;; function body, as new rules will be retroactively applied to the legality - ;; of function names and parameters. - (while continue - (setq ts-state (make-js2-ts-state)) - (setq continue (catch 'reparse - (setq fn-node (js2-parse-function-internal - function-type pos star-p async-p name)) - ;; Don't continue. - nil)) - (when continue - (js2-ts-seek ts-state))) - fn-node)) - -(defun js2-parse-statements (&optional parent) - "Parse a statement list. Last token consumed must be js2-LC. - -PARENT can be a `js2-block-node', in which case the statements are -appended to PARENT. Otherwise a new `js2-block-node' is created -and returned. - -This function does not match the closing js2-RC: the caller -matches the RC so it can provide a suitable error message if not -matched. This means it's up to the caller to set the length of -the node to include the closing RC. The node start pos is set to -the absolute buffer start position, and the caller should fix it -up to be relative to the parent node. All children of this block -node are given relative start positions and correct lengths." - (let ((pn (or parent (make-js2-block-node))) - tt) - (while (and (> (setq tt (js2-peek-token)) js2-EOF) - (/= tt js2-RC)) - (js2-block-node-push pn (js2-parse-statement))) - pn)) - -(defun js2-parse-statement () - (let (pn beg end) - ;; coarse-grained user-interrupt check - needs work - (and js2-parse-interruptable-p - (zerop (% (cl-incf js2-parse-stmt-count) - js2-statements-per-pause)) - (input-pending-p) - (throw 'interrupted t)) - (setq pn (js2-statement-helper)) - ;; no-side-effects warning check - (unless (js2-node-has-side-effects pn) - (setq end (js2-node-end pn)) - (save-excursion - (goto-char end) - (setq beg (max (js2-node-pos pn) (point-at-bol)))) - (js2-add-strict-warning "msg.no.side.effects" nil beg end)) - pn)) - -;; These correspond to the switch cases in Parser.statementHelper -(defconst js2-parsers - (let ((parsers (make-vector js2-num-tokens - #'js2-parse-expr-stmt))) - (aset parsers js2-BREAK #'js2-parse-break) - (aset parsers js2-CLASS #'js2-parse-class-stmt) - (aset parsers js2-CONST #'js2-parse-const-var) - (aset parsers js2-CONTINUE #'js2-parse-continue) - (aset parsers js2-DEBUGGER #'js2-parse-debugger) - (aset parsers js2-DEFAULT #'js2-parse-default-xml-namespace) - (aset parsers js2-DO #'js2-parse-do) - (aset parsers js2-EXPORT #'js2-parse-export) - (aset parsers js2-FOR #'js2-parse-for) - (aset parsers js2-FUNCTION #'js2-parse-function-stmt) - (aset parsers js2-IF #'js2-parse-if) - (aset parsers js2-IMPORT #'js2-parse-import) - (aset parsers js2-LC #'js2-parse-block) - (aset parsers js2-LET #'js2-parse-let-stmt) - (aset parsers js2-NAME #'js2-parse-name-or-label) - (aset parsers js2-RETURN #'js2-parse-ret-yield) - (aset parsers js2-SEMI #'js2-parse-semi) - (aset parsers js2-SWITCH #'js2-parse-switch) - (aset parsers js2-THROW #'js2-parse-throw) - (aset parsers js2-TRY #'js2-parse-try) - (aset parsers js2-VAR #'js2-parse-const-var) - (aset parsers js2-WHILE #'js2-parse-while) - (aset parsers js2-WITH #'js2-parse-with) - (aset parsers js2-YIELD #'js2-parse-ret-yield) - parsers) - "A vector mapping token types to parser functions.") - -(defun js2-parse-warn-missing-semi (beg end) - (and js2-mode-show-strict-warnings - js2-strict-missing-semi-warning - (js2-add-strict-warning - "msg.missing.semi" nil - ;; back up to beginning of statement or line - (max beg (save-excursion - (goto-char end) - (point-at-bol))) - end))) - -(defconst js2-no-semi-insertion - (list js2-IF - js2-SWITCH - js2-WHILE - js2-DO - js2-FOR - js2-TRY - js2-WITH - js2-LC - js2-ERROR - js2-SEMI - js2-CLASS - js2-FUNCTION - js2-EXPORT) - "List of tokens that don't do automatic semicolon insertion.") - -(defconst js2-autoinsert-semi-and-warn - (list js2-ERROR js2-EOF js2-RC)) - -(defun js2-statement-helper () - (let* ((tt (js2-get-token)) - (first-tt tt) - (async-stmt (js2-match-async-function)) - (parser (if (= tt js2-ERROR) - #'js2-parse-semi - (if async-stmt - #'js2-parse-async-function-stmt - (aref js2-parsers tt)))) - pn) - ;; If the statement is set, then it's been told its label by now. - (and js2-labeled-stmt - (js2-labeled-stmt-node-stmt js2-labeled-stmt) - (setq js2-labeled-stmt nil)) - (setq pn (funcall parser)) - ;; Don't do auto semi insertion for certain statement types. - (unless (or (memq first-tt js2-no-semi-insertion) - (js2-labeled-stmt-node-p pn) - async-stmt) - (js2-auto-insert-semicolon pn)) - pn)) - -(defun js2-auto-insert-semicolon (pn) - (let* ((tt (js2-get-token)) - (pos (js2-node-pos pn))) - (cond - ((= tt js2-SEMI) - ;; extend the node bounds to include the semicolon. - (setf (js2-node-len pn) (- (js2-current-token-end) pos))) - ((memq tt js2-autoinsert-semi-and-warn) - (js2-unget-token) ; Not ';', do not consume. - ;; Autoinsert ; - (js2-parse-warn-missing-semi pos (js2-node-end pn))) - (t - (if (not (js2-token-follows-eol-p (js2-current-token))) - ;; Report error if no EOL or autoinsert ';' otherwise - (js2-report-error "msg.no.semi.stmt") - (js2-parse-warn-missing-semi pos (js2-node-end pn))) - (js2-unget-token) ; Not ';', do not consume. - )))) - -(defun js2-parse-condition () - "Parse a parenthesized boolean expression, e.g. in an if- or while-stmt. -The parens are discarded and the expression node is returned. -The `pos' field of the return value is set to an absolute position -that must be fixed up by the caller. -Return value is a list (EXPR LP RP), with absolute paren positions." - (let (pn lp rp) - (if (js2-must-match js2-LP "msg.no.paren.cond") - (setq lp (js2-current-token-beg))) - (setq pn (js2-parse-expr)) - (if (js2-must-match js2-RP "msg.no.paren.after.cond") - (setq rp (js2-current-token-beg))) - ;; Report strict warning on code like "if (a = 7) ..." - (if (and js2-strict-cond-assign-warning - (js2-assign-node-p pn)) - (js2-add-strict-warning "msg.equal.as.assign" nil - (js2-node-pos pn) - (+ (js2-node-pos pn) - (js2-node-len pn)))) - (list pn lp rp))) - -(defun js2-parse-if () - "Parser for if-statement. Last matched token must be js2-IF." - (let ((pos (js2-current-token-beg)) - cond if-true if-false else-pos end pn) - (setq cond (js2-parse-condition) - if-true (js2-parse-statement) - if-false (if (js2-match-token js2-ELSE) - (progn - (setq else-pos (- (js2-current-token-beg) pos)) - (js2-parse-statement))) - end (js2-node-end (or if-false if-true)) - pn (make-js2-if-node :pos pos - :len (- end pos) - :condition (car cond) - :then-part if-true - :else-part if-false - :else-pos else-pos - :lp (js2-relpos (cl-second cond) pos) - :rp (js2-relpos (cl-third cond) pos))) - (js2-node-add-children pn (car cond) if-true if-false) - pn)) - -(defun js2-parse-import () - "Parse import statement. The current token must be js2-IMPORT." - (unless (js2-ast-root-p js2-current-scope) - (js2-report-error "msg.mod.import.decl.at.top.level")) - (let ((beg (js2-current-token-beg))) - (cond ((js2-match-token js2-STRING) - (make-js2-import-node - :pos beg - :len (- (js2-current-token-end) beg) - :module-id (js2-current-token-string))) - (t - (let* ((import-clause (js2-parse-import-clause)) - (from-clause (and import-clause (js2-parse-from-clause))) - (module-id (when from-clause (js2-from-clause-node-module-id from-clause))) - (node (make-js2-import-node - :pos beg - :len (- (js2-current-token-end) beg) - :import import-clause - :from from-clause - :module-id module-id))) - (when import-clause - (js2-node-add-children node import-clause)) - (when from-clause - (js2-node-add-children node from-clause)) - node))))) - -(defun js2-parse-import-clause () - "Parse the bindings in an import statement. -This can take many forms: - -ImportedDefaultBinding -> 'foo' -NameSpaceImport -> '* as lib' -NamedImports -> '{foo as bar, bang}' -ImportedDefaultBinding , NameSpaceImport -> 'foo, * as lib' -ImportedDefaultBinding , NamedImports -> 'foo, {bar, baz as bif}' - -Try to match namespace imports and named imports first because nothing can -come after them. If it is an imported default binding, then it could have named -imports or a namespace import that follows it. -" - (let* ((beg (js2-current-token-beg)) - (clause (make-js2-import-clause-node - :pos beg)) - (children (list))) - (cond - ((js2-match-token js2-MUL) - (let ((ns-import (js2-parse-namespace-import))) - (when ns-import - (let ((name-node (js2-namespace-import-node-name ns-import))) - (js2-define-symbol - js2-LET (js2-name-node-name name-node) name-node t)) - (setf (js2-import-clause-node-namespace-import clause) ns-import) - (push ns-import children)))) - ((js2-match-token js2-LC) - (let ((imports (js2-parse-export-bindings t))) - (setf (js2-import-clause-node-named-imports clause) imports) - (dolist (import imports) - (push import children) - (let ((name-node (js2-export-binding-node-local-name import))) - (when name-node - (js2-define-symbol - js2-LET (js2-name-node-name name-node) name-node t)))))) - ((= (js2-peek-token) js2-NAME) - (let ((binding (js2-maybe-parse-export-binding t))) - (let ((node-name (js2-export-binding-node-local-name binding))) - (js2-define-symbol js2-LET (js2-name-node-name node-name) node-name t)) - (setf (js2-import-clause-node-default-binding clause) binding) - (push binding children)) - (when (js2-match-token js2-COMMA) - (cond - ((js2-match-token js2-MUL) - (let ((ns-import (js2-parse-namespace-import))) - (let ((name-node (js2-namespace-import-node-name ns-import))) - (js2-define-symbol - js2-LET (js2-name-node-name name-node) name-node t)) - (setf (js2-import-clause-node-namespace-import clause) ns-import) - (push ns-import children))) - ((js2-match-token js2-LC) - (let ((imports (js2-parse-export-bindings t))) - (setf (js2-import-clause-node-named-imports clause) imports) - (dolist (import imports) - (push import children) - (let ((name-node (js2-export-binding-node-local-name import))) - (when name-node - (js2-define-symbol - js2-LET (js2-name-node-name name-node) name-node t)))))) - (t (js2-report-error "msg.syntax"))))) - (t (js2-report-error "msg.mod.declaration.after.import"))) - (setf (js2-node-len clause) (- (js2-current-token-end) beg)) - (apply #'js2-node-add-children clause children) - clause)) - -(defun js2-parse-namespace-import () - "Parse a namespace import expression such as '* as bar'. -The current token must be js2-MUL." - (let ((beg (js2-current-token-beg))) - (cond - ((js2-match-contextual-kwd "as") - (when (js2-must-match-prop-name "msg.syntax") - (let ((node (make-js2-namespace-import-node - :pos beg - :len (- (js2-current-token-end) beg) - :name (make-js2-name-node - :pos (js2-current-token-beg) - :len (- (js2-current-token-end) - (js2-current-token-beg)) - :name (js2-current-token-string))))) - (js2-node-add-children node (js2-namespace-import-node-name node)) - node))) - (t - (js2-unget-token) - (js2-report-error "msg.syntax") - nil)))) - - -(defun js2-parse-from-clause () - "Parse the from clause in an import or export statement. E.g. from 'src/lib'" - (if (js2-match-contextual-kwd "from") - (let ((beg (js2-current-token-beg))) - (cond - ((js2-match-token js2-STRING) - (make-js2-from-clause-node - :pos beg - :len (- (js2-current-token-end) beg) - :module-id (js2-current-token-string) - :metadata-p nil)) - ((js2-match-token js2-THIS) - (when (js2-must-match-name "msg.mod.spec.after.from") - (if (equal "module" (js2-current-token-string)) - (make-js2-from-clause-node - :pos beg - :len (- (js2-current-token-end) beg) - :module-id "this" - :metadata-p t) - (js2-unget-token) - (js2-unget-token) - (js2-report-error "msg.mod.spec.after.from") - nil))) - (t (js2-report-error "msg.mod.spec.after.from") nil))) - (js2-report-error "msg.mod.from.after.import.spec.set") - nil)) - -(defun js2-parse-export-bindings (&optional import-p) - "Parse a list of export binding expressions such as {}, {foo, bar}, and -{foo as bar, baz as bang}. The current token must be -js2-LC. Return a lisp list of js2-export-binding-node" - (let ((bindings (list))) - (while - (let ((binding (js2-maybe-parse-export-binding import-p))) - (when binding - (push binding bindings)) - (js2-match-token js2-COMMA))) - (when (js2-must-match js2-RC (if import-p - "msg.mod.rc.after.import.spec.list" - "msg.mod.rc.after.export.spec.list")) - (reverse bindings)))) - -(defun js2-maybe-parse-export-binding (&optional import-p) - "Attempt to parse a binding expression found inside an import/export statement. -This can take the form of either as single js2-NAME token as in 'foo' or as in a -rebinding expression 'bar as foo'. If it matches, it will return an instance of -js2-export-binding-node and consume all the tokens. If it does not match, it -consumes no tokens." - (let ((extern-name (when (js2-match-prop-name) (js2-current-token-string))) - (beg (js2-current-token-beg)) - (extern-name-len (js2-current-token-len)) - (is-reserved-name (or (= (js2-current-token-type) js2-RESERVED) - (aref js2-kwd-tokens (js2-current-token-type))))) - (if extern-name - (if (js2-match-contextual-kwd "as") - (let ((name - (or - (and (js2-match-token js2-DEFAULT) "default") - (and (js2-match-token js2-NAME) (js2-current-token-string))))) - (if name - (let ((node (make-js2-export-binding-node - :pos beg - :len (- (js2-current-token-end) beg) - :local-name (make-js2-name-node - :name name - :pos (js2-current-token-beg) - :len (js2-current-token-len)) - :extern-name (make-js2-name-node - :name extern-name - :pos beg - :len extern-name-len)))) - (js2-node-add-children - node - (js2-export-binding-node-local-name node) - (js2-export-binding-node-extern-name node)) - (if import-p - (js2-set-face (js2-current-token-beg) (js2-current-token-end) - 'font-lock-variable-name-face 'record)) - node) - (js2-unget-token) - nil)) - (let* ((name-node (make-js2-name-node - :name (js2-current-token-string) - :pos (js2-current-token-beg) - :len (js2-current-token-len))) - (node (make-js2-export-binding-node - :pos (js2-current-token-beg) - :len (js2-current-token-len) - :local-name name-node - :extern-name name-node))) - (when is-reserved-name - (js2-report-error "msg.mod.as.after.reserved.word" extern-name)) - (js2-node-add-children node name-node) - (if import-p - (js2-set-face (js2-current-token-beg) (js2-current-token-end) - 'font-lock-variable-name-face 'record)) - node)) - nil))) - -(defun js2-parse-switch () - "Parser for switch-statement. Last matched token must be js2-SWITCH." - (let ((pos (js2-current-token-beg)) - tt pn discriminant has-default case-expr case-node - case-pos cases stmt lp) - (if (js2-must-match js2-LP "msg.no.paren.switch") - (setq lp (js2-current-token-beg))) - (setq discriminant (js2-parse-expr) - pn (make-js2-switch-node :discriminant discriminant - :pos pos - :lp (js2-relpos lp pos))) - (js2-node-add-children pn discriminant) - (js2-enter-switch pn) - (unwind-protect - (progn - (if (js2-must-match js2-RP "msg.no.paren.after.switch") - (setf (js2-switch-node-rp pn) (- (js2-current-token-beg) pos))) - (js2-must-match js2-LC "msg.no.brace.switch") - (catch 'break - (while t - (setq tt (js2-next-token) - case-pos (js2-current-token-beg)) - (cond - ((= tt js2-RC) - (setf (js2-node-len pn) (- (js2-current-token-end) pos)) - (throw 'break nil)) ; done - ((= tt js2-CASE) - (setq case-expr (js2-parse-expr)) - (js2-must-match js2-COLON "msg.no.colon.case")) - ((= tt js2-DEFAULT) - (if has-default - (js2-report-error "msg.double.switch.default")) - (setq has-default t - case-expr nil) - (js2-must-match js2-COLON "msg.no.colon.case")) - (t - (js2-report-error "msg.bad.switch") - (throw 'break nil))) - (setq case-node (make-js2-case-node :pos case-pos - :len (- (js2-current-token-end) case-pos) - :expr case-expr)) - (js2-node-add-children case-node case-expr) - (while (and (/= (setq tt (js2-peek-token)) js2-RC) - (/= tt js2-CASE) - (/= tt js2-DEFAULT) - (/= tt js2-EOF)) - (setf stmt (js2-parse-statement) - (js2-node-len case-node) (- (js2-node-end stmt) case-pos)) - (js2-block-node-push case-node stmt)) - (push case-node cases))) - ;; add cases last, as pushing reverses the order to be correct - (dolist (kid cases) - (js2-node-add-children pn kid) - (push kid (js2-switch-node-cases pn))) - pn) ; return value - (js2-exit-switch)))) - -(defun js2-parse-while () - "Parser for while-statement. Last matched token must be js2-WHILE." - (let ((pos (js2-current-token-beg)) - (pn (make-js2-while-node)) - cond body) - (js2-enter-loop pn) - (unwind-protect - (progn - (setf cond (js2-parse-condition) - (js2-while-node-condition pn) (car cond) - body (js2-parse-statement) - (js2-while-node-body pn) body - (js2-node-len pn) (- (js2-node-end body) pos) - (js2-while-node-lp pn) (js2-relpos (cl-second cond) pos) - (js2-while-node-rp pn) (js2-relpos (cl-third cond) pos)) - (js2-node-add-children pn body (car cond))) - (js2-exit-loop)) - pn)) - -(defun js2-parse-do () - "Parser for do-statement. Last matched token must be js2-DO." - (let ((pos (js2-current-token-beg)) - (pn (make-js2-do-node)) - cond body end) - (js2-enter-loop pn) - (unwind-protect - (progn - (setq body (js2-parse-statement)) - (js2-must-match js2-WHILE "msg.no.while.do") - (setf (js2-do-node-while-pos pn) (- (js2-current-token-beg) pos) - cond (js2-parse-condition) - (js2-do-node-condition pn) (car cond) - (js2-do-node-body pn) body - end js2-ts-cursor - (js2-do-node-lp pn) (js2-relpos (cl-second cond) pos) - (js2-do-node-rp pn) (js2-relpos (cl-third cond) pos)) - (js2-node-add-children pn (car cond) body)) - (js2-exit-loop)) - ;; Always auto-insert semicolon to follow SpiderMonkey: - ;; It is required by ECMAScript but is ignored by the rest of - ;; world; see bug 238945 - (if (js2-match-token js2-SEMI) - (setq end js2-ts-cursor)) - (setf (js2-node-len pn) (- end pos)) - pn)) - -(defun js2-parse-export () - "Parse an export statement. -The Last matched token must be js2-EXPORT. Currently, the 'default' and 'expr' -expressions should only be either hoistable expressions (function or generator) -or assignment expressions, but there is no checking to enforce that and so it -will parse without error a small subset of -invalid export statements." - (unless (js2-ast-root-p js2-current-scope) - (js2-report-error "msg.mod.export.decl.at.top.level")) - (let ((beg (js2-current-token-beg)) - (children (list)) - exports-list from-clause declaration default) - (cond - ((js2-match-token js2-MUL) - (setq from-clause (js2-parse-from-clause)) - (when from-clause - (push from-clause children))) - ((js2-match-token js2-LC) - (setq exports-list (js2-parse-export-bindings)) - (when exports-list - (dolist (export exports-list) - (push export children))) - (when (js2-match-contextual-kwd "from") - (js2-unget-token) - (setq from-clause (js2-parse-from-clause)))) - ((js2-match-token js2-DEFAULT) - (setq default (cond ((js2-match-token js2-CLASS) - (if (eq (js2-peek-token) js2-NAME) - (js2-parse-class-stmt) - (js2-parse-class-expr))) - ((js2-match-token js2-NAME) - (if (js2-match-async-function) - (if (eq (js2-peek-token) js2-NAME) - (js2-parse-async-function-stmt) - (js2-parse-function-expr t)) - (js2-unget-token) - (js2-parse-expr))) - ((js2-match-token js2-FUNCTION) - (if (eq (js2-peek-token) js2-NAME) - (js2-parse-function-stmt) - (js2-parse-function-expr))) - (t (js2-parse-expr))))) - ((or (js2-match-token js2-VAR) (js2-match-token js2-CONST) (js2-match-token js2-LET)) - (setq declaration (js2-parse-variables (js2-current-token-type) (js2-current-token-beg)))) - ((js2-match-token js2-CLASS) - (setq declaration (js2-parse-class-stmt))) - ((js2-match-token js2-NAME) - (setq declaration - (if (js2-match-async-function) - (js2-parse-async-function-stmt) - (js2-unget-token) - (js2-parse-expr)))) - ((js2-match-token js2-FUNCTION) - (setq declaration (js2-parse-function-stmt))) - (t - (setq declaration (js2-parse-expr)))) - (when from-clause - (push from-clause children)) - (when declaration - (push declaration children) - (when (not (or (js2-function-node-p declaration) - (js2-class-node-p declaration))) - (js2-auto-insert-semicolon declaration))) - (when default - (push default children) - (when (not (or (js2-function-node-p default) - (js2-class-node-p default))) - (js2-auto-insert-semicolon default))) - (let ((node (make-js2-export-node - :pos beg - :len (- (js2-current-token-end) beg) - :exports-list exports-list - :from-clause from-clause - :declaration declaration - :default default))) - (apply #'js2-node-add-children node children) - node))) - -(defun js2-parse-for () - "Parse a for, for-in or for each-in statement. -Last matched token must be js2-FOR." - (let ((for-pos (js2-current-token-beg)) - (tmp-scope (make-js2-scope)) - pn is-for-each is-for-in-or-of is-for-of - 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) - ;; See if this is a for each () instead of just a for () - (when (js2-match-token js2-NAME) - (if (string= "each" (js2-current-token-string)) - (progn - (setq is-for-each t - each-pos (- (js2-current-token-beg) for-pos)) ; relative - (js2-record-face 'font-lock-keyword-face)) - (js2-report-error "msg.no.paren.for"))) - (if (js2-must-match js2-LP "msg.no.paren.for") - (setq lp (- (js2-current-token-beg) for-pos))) - (setq tt (js2-get-token)) - ;; Capture identifiers inside parens. We can't create the node - ;; (and use it as the current scope) until we know its type. - (js2-push-scope tmp-scope) - (unwind-protect - (progn - ;; parse init clause - (let ((js2-in-for-init t)) ; set as dynamic variable - (cond - ((= tt js2-SEMI) - (js2-unget-token) - (setq init (make-js2-empty-expr-node))) - ((or (= tt js2-VAR) (= tt js2-LET) (= tt js2-CONST)) - (setq init (js2-parse-variables tt (js2-current-token-beg)))) - (t - (js2-unget-token) - (setq init (js2-parse-expr))))) - (if (or (js2-match-token js2-IN) - (and (>= js2-language-version 200) - (js2-match-contextual-kwd "of") - (setq is-for-of t))) - (setq is-for-in-or-of t - in-pos (- (js2-current-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-current-token-end) - incr (if (= (js2-peek-token) js2-RP) - (make-js2-empty-expr-node :pos tmp-pos) - (js2-parse-expr))))) - (js2-pop-scope)) - (if (js2-must-match js2-RP "msg.no.paren.for.ctrl") - (setq rp (- (js2-current-token-beg) for-pos))) - (if (not is-for-in-or-of) - (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 - :forof-p is-for-of - :lp lp - :rp rp))) - ;; Transplant the declarations. - (setf (js2-scope-symbol-table pn) - (js2-scope-symbol-table tmp-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)) - pn)) - -(defun js2-parse-try () - "Parse a try statement. Last matched token must be js2-TRY." - (let ((try-pos (js2-current-token-beg)) - try-end - try-block - catch-blocks - finally-block - saw-default-catch - peek) - (if (/= (js2-peek-token) js2-LC) - (js2-report-error "msg.no.brace.try")) - (setq try-block (js2-parse-statement) - try-end (js2-node-end try-block) - peek (js2-peek-token)) - (cond - ((= peek js2-CATCH) - (while (js2-match-token js2-CATCH) - (let* ((catch-pos (js2-current-token-beg)) - (catch-node (make-js2-catch-node :pos catch-pos)) - param - guard-kwd - catch-cond - lp rp) - (if saw-default-catch - (js2-report-error "msg.catch.unreachable")) - (if (js2-must-match js2-LP "msg.no.paren.catch") - (setq lp (- (js2-current-token-beg) catch-pos))) - (js2-push-scope catch-node) - (let ((tt (js2-peek-token))) - (cond - ;; Destructuring pattern: - ;; catch ({ message, file }) { ... } - ((or (= tt js2-LB) (= tt js2-LC)) - (js2-get-token) - (setq param (js2-parse-destruct-primary-expr)) - (js2-define-destruct-symbols param js2-LET nil)) - ;; Simple name. - (t - (js2-must-match-name "msg.bad.catchcond") - (setq param (js2-create-name-node)) - (js2-define-symbol js2-LET (js2-current-token-string) param) - (js2-check-strict-identifier param)))) - ;; Catch condition. - (if (js2-match-token js2-IF) - (setq guard-kwd (- (js2-current-token-beg) catch-pos) - catch-cond (js2-parse-expr)) - (setq saw-default-catch t)) - (if (js2-must-match js2-RP "msg.bad.catchcond") - (setq rp (- (js2-current-token-beg) catch-pos))) - (js2-must-match js2-LC "msg.no.brace.catchblock") - (js2-parse-statements catch-node) - (if (js2-must-match js2-RC "msg.no.brace.after.body") - (setq try-end (js2-current-token-end))) - (js2-pop-scope) - (setf (js2-node-len catch-node) (- try-end catch-pos) - (js2-catch-node-param catch-node) param - (js2-catch-node-guard-expr catch-node) catch-cond - (js2-catch-node-guard-kwd catch-node) guard-kwd - (js2-catch-node-lp catch-node) lp - (js2-catch-node-rp catch-node) rp) - (js2-node-add-children catch-node param catch-cond) - (push catch-node catch-blocks)))) - ((/= peek js2-FINALLY) - (js2-must-match js2-FINALLY "msg.try.no.catchfinally" - (js2-node-pos try-block) - (- (setq try-end (js2-node-end try-block)) - (js2-node-pos try-block))))) - (when (js2-match-token js2-FINALLY) - (let ((finally-pos (js2-current-token-beg)) - (block (js2-parse-statement))) - (setq try-end (js2-node-end block) - finally-block (make-js2-finally-node :pos finally-pos - :len (- try-end finally-pos) - :body block)) - (js2-node-add-children finally-block block))) - (let ((pn (make-js2-try-node :pos try-pos - :len (- try-end try-pos) - :try-block try-block - :finally-block finally-block))) - (js2-node-add-children pn try-block finally-block) - ;; Push them onto the try-node, which reverses and corrects their order. - (dolist (cb catch-blocks) - (js2-node-add-children pn cb) - (push cb (js2-try-node-catch-clauses pn))) - pn))) - -(defun js2-parse-throw () - "Parser for throw-statement. Last matched token must be js2-THROW." - (let ((pos (js2-current-token-beg)) - expr pn) - (if (= (js2-peek-token-or-eol) js2-EOL) - ;; ECMAScript does not allow new lines before throw expression, - ;; see bug 256617 - (js2-report-error "msg.bad.throw.eol")) - (setq expr (js2-parse-expr) - pn (make-js2-throw-node :pos pos - :len (- (js2-node-end expr) pos) - :expr expr)) - (js2-node-add-children pn expr) - pn)) - -(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." - (let ((bundle (cdr (assoc label-name js2-label-set)))) - (if (null bundle) - (js2-report-error "msg.undef.label")) - bundle)) - -(defun js2-parse-break () - "Parser for break-statement. Last matched token must be js2-BREAK." - (let ((pos (js2-current-token-beg)) - (end (js2-current-token-end)) - break-target ; statement to break from - break-label ; in "break foo", name-node representing the foo - labels ; matching labeled statement to break to - pn) - (when (eq (js2-peek-token-or-eol) js2-NAME) - (js2-get-token) - (setq break-label (js2-create-name-node) - end (js2-node-end break-label) - ;; matchJumpLabelName only matches if there is one - labels (js2-match-jump-label-name (js2-current-token-string)) - break-target (if labels (car (js2-labeled-stmt-node-labels labels))))) - (unless (or break-target break-label) - ;; no break target specified - try for innermost enclosing loop/switch - (if (null js2-loop-and-switch-set) - (unless break-label - (js2-report-error "msg.bad.break" nil pos (length "break"))) - (setq break-target (car js2-loop-and-switch-set)))) - (setq pn (make-js2-break-node :pos pos - :len (- end pos) - :label break-label - :target break-target)) - (js2-node-add-children pn break-label) ; but not break-target - pn)) - -(defun js2-parse-continue () - "Parser for continue-statement. Last matched token must be js2-CONTINUE." - (let ((pos (js2-current-token-beg)) - (end (js2-current-token-end)) - label ; optional user-specified label, a `js2-name-node' - labels ; current matching labeled stmt, if any - target ; the `js2-loop-node' target of this continue stmt - pn) - (when (= (js2-peek-token-or-eol) js2-NAME) - (js2-get-token) - (setq label (js2-create-name-node) - end (js2-node-end label) - ;; matchJumpLabelName only matches if there is one - labels (js2-match-jump-label-name (js2-current-token-string)))) - (cond - ((null labels) ; no current label to go to - (if (null js2-loop-set) ; no loop to continue to - (js2-report-error "msg.continue.outside" nil pos - (length "continue")) - (setq target (car js2-loop-set)))) ; innermost enclosing loop - (t - (if (js2-loop-node-p (js2-labeled-stmt-node-stmt labels)) - (setq target (js2-labeled-stmt-node-stmt labels)) - (js2-report-error "msg.continue.nonloop" nil pos (- end pos))))) - (setq pn (make-js2-continue-node :pos pos - :len (- end pos) - :label label - :target target)) - (js2-node-add-children pn label) ; but not target - it's not our child - pn)) - -(defun js2-parse-with () - "Parser for with-statement. Last matched token must be js2-WITH." - (when js2-in-use-strict-directive - (js2-report-error "msg.no.with.strict")) - (let ((pos (js2-current-token-beg)) - obj body pn lp rp) - (if (js2-must-match js2-LP "msg.no.paren.with") - (setq lp (js2-current-token-beg))) - (setq obj (js2-parse-expr)) - (if (js2-must-match js2-RP "msg.no.paren.after.with") - (setq rp (js2-current-token-beg))) - (let ((js2-nesting-of-with (1+ js2-nesting-of-with))) - (setq body (js2-parse-statement))) - (setq pn (make-js2-with-node :pos pos - :len (- (js2-node-end body) pos) - :object obj - :body body - :lp (js2-relpos lp pos) - :rp (js2-relpos rp pos))) - (js2-node-add-children pn obj body) - pn)) - -(defun js2-parse-const-var () - "Parser for var- or const-statement. -Last matched token must be js2-CONST or js2-VAR." - (let ((tt (js2-current-token-type)) - (pos (js2-current-token-beg)) - expr pn) - (setq expr (js2-parse-variables tt (js2-current-token-beg)) - pn (make-js2-expr-stmt-node :pos pos - :len (- (js2-node-end expr) pos) - :expr expr)) - (js2-node-add-children pn expr) - pn)) - -(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) - js2-EXPR_VOID - js2-EXPR_RESULT) - :expr expr))) - (if add-child - (js2-node-add-children pn expr)) - pn)) - -(defun js2-parse-let-stmt () - "Parser for let-statement. Last matched token must be js2-LET." - (let ((pos (js2-current-token-beg)) - expr pn) - (if (= (js2-peek-token) js2-LP) - ;; let expression in statement context - (setq expr (js2-parse-let pos 'statement) - pn (js2-wrap-with-expr-stmt pos expr t)) - ;; else we're looking at a statement like let x=6, y=7; - (setf expr (js2-parse-variables js2-LET pos) - pn (js2-wrap-with-expr-stmt pos expr t) - (js2-node-type pn) js2-EXPR_RESULT)) - pn)) - -(defun js2-parse-ret-yield () - (js2-parse-return-or-yield (js2-current-token-type) nil)) - -(defconst js2-parse-return-stmt-enders - (list js2-SEMI js2-RC js2-EOF js2-EOL js2-ERROR js2-RB js2-RP)) - -(defsubst js2-now-all-set (before after mask) - "Return whether or not the bits in the mask have changed to all set. -BEFORE is bits before change, AFTER is bits after change, and MASK is -the mask for bits. Returns t if all the bits in the mask are set in AFTER -but not BEFORE." - (and (/= (logand before mask) mask) - (= (logand after mask) mask))) - -(defun js2-parse-return-or-yield (tt expr-context) - (let* ((pos (js2-current-token-beg)) - (end (js2-current-token-end)) - (before js2-end-flags) - (inside-function (js2-inside-function)) - (gen-type (and inside-function (js2-function-node-generator-type - js2-current-script-or-fn))) - e ret name yield-star-p) - (unless inside-function - (js2-report-error (if (eq tt js2-RETURN) - "msg.bad.return" - "msg.bad.yield"))) - (when (and inside-function - (eq gen-type 'STAR) - (js2-match-token js2-MUL)) - (setq yield-star-p t)) - ;; This is ugly, but we don't want to require a semicolon. - (unless (memq (js2-peek-token-or-eol) js2-parse-return-stmt-enders) - (setq e (if (eq gen-type 'STAR) - (js2-parse-assign-expr) - (js2-parse-expr)) - end (js2-node-end e))) - (cond - ((eq tt js2-RETURN) - (js2-set-flag js2-end-flags (if (null e) - js2-end-returns - js2-end-returns-value)) - (setq ret (make-js2-return-node :pos pos - :len (- end pos) - :retval e)) - (js2-node-add-children ret e) - ;; See if we need a strict mode warning. - ;; TODO: The analysis done by `js2-has-consistent-return-usage' is - ;; more thorough and accurate than this before/after flag check. - ;; E.g. if there's a finally-block that always returns, we shouldn't - ;; show a warning generated by inconsistent returns in the catch blocks. - ;; Basically `js2-has-consistent-return-usage' needs to keep more state, - ;; so we know which returns/yields to highlight, and we should get rid of - ;; all the checking in `js2-parse-return-or-yield'. - (if (and js2-strict-inconsistent-return-warning - (js2-now-all-set before js2-end-flags - (logior js2-end-returns js2-end-returns-value))) - (js2-add-strict-warning "msg.return.inconsistent" nil pos end))) - ((eq gen-type 'COMPREHENSION) - ;; FIXME: We should probably switch to saving and using lastYieldOffset, - ;; like SpiderMonkey does. - (js2-report-error "msg.syntax" nil pos 5)) - (t - (setq ret (make-js2-yield-node :pos pos - :len (- end pos) - :value e - :star-p yield-star-p)) - (js2-node-add-children ret e) - (unless expr-context - (setq e ret - ret (js2-wrap-with-expr-stmt pos e t)) - (js2-set-requires-activation) - (js2-set-is-generator)))) - ;; see if we are mixing yields and value returns. - (when (and inside-function - (js2-flag-set-p js2-end-flags js2-end-returns-value) - (eq (js2-function-node-generator-type js2-current-script-or-fn) - 'LEGACY)) - (setq name (js2-function-name js2-current-script-or-fn)) - (if (zerop (length name)) - (js2-report-error "msg.anon.generator.returns" nil pos (- end pos)) - (js2-report-error "msg.generator.returns" name pos (- end pos)))) - ret)) - -(defun js2-parse-debugger () - (make-js2-keyword-node :type js2-DEBUGGER)) - -(defun js2-parse-block () - "Parser for a curly-delimited statement block. -Last token matched must be `js2-LC'." - (let ((pos (js2-current-token-beg)) - (pn (make-js2-scope))) - (js2-push-scope pn) - (unwind-protect - (progn - (js2-parse-statements pn) - (js2-must-match js2-RC "msg.no.brace.block") - (setf (js2-node-len pn) (- (js2-current-token-end) pos))) - (js2-pop-scope)) - pn)) - -;; For `js2-ERROR' too, to have a node for error recovery to work on. -(defun js2-parse-semi () - "Parse a statement or handle an error. -Current token type is `js2-SEMI' or `js2-ERROR'." - (let ((tt (js2-current-token-type)) pos len) - (if (eq tt js2-SEMI) - (make-js2-empty-expr-node :len 1) - (setq pos (js2-current-token-beg) - len (- (js2-current-token-end) pos)) - (js2-report-error "msg.syntax" nil pos len) - (make-js2-error-node :pos pos :len len)))) - -(defun js2-parse-default-xml-namespace () - "Parse a `default xml namespace = <expr>' e4x statement." - (let ((pos (js2-current-token-beg)) - end len expr unary) - (js2-must-have-xml) - (js2-set-requires-activation) - (setq len (- js2-ts-cursor pos)) - (unless (and (js2-match-token js2-NAME) - (string= (js2-current-token-string) "xml")) - (js2-report-error "msg.bad.namespace" nil pos len)) - (unless (and (js2-match-token js2-NAME) - (string= (js2-current-token-string) "namespace")) - (js2-report-error "msg.bad.namespace" nil pos len)) - (unless (js2-match-token js2-ASSIGN) - (js2-report-error "msg.bad.namespace" nil pos len)) - (setq expr (js2-parse-expr) - end (js2-node-end expr) - unary (make-js2-unary-node :type js2-DEFAULTNAMESPACE - :pos pos - :len (- end pos) - :operand expr)) - (js2-node-add-children unary expr) - (make-js2-expr-stmt-node :pos pos - :len (- end pos) - :expr unary))) - -(defun js2-record-label (label bundle) - ;; current token should be colon that `js2-parse-primary-expr' left untouched - (js2-get-token) - (let ((name (js2-label-node-name label)) - labeled-stmt - dup) - (when (setq labeled-stmt (cdr (assoc name js2-label-set))) - ;; flag both labels if possible when used in editing mode - (if (and js2-parse-ide-mode - (setq dup (js2-get-label-by-name labeled-stmt name))) - (js2-report-error "msg.dup.label" nil - (js2-node-abs-pos dup) (js2-node-len dup))) - (js2-report-error "msg.dup.label" nil - (js2-node-pos label) (js2-node-len label))) - (js2-labeled-stmt-node-add-label bundle label) - (js2-node-add-children bundle label) - ;; Add one reference to the bundle per label in `js2-label-set' - (push (cons name bundle) js2-label-set))) - -(defun js2-parse-name-or-label () - "Parser for identifier or label. Last token matched must be js2-NAME. -Called when we found a name in a statement context. If it's a label, we gather -up any following labels and the next non-label statement into a -`js2-labeled-stmt-node' bundle and return that. Otherwise we parse an -expression and return it wrapped in a `js2-expr-stmt-node'." - (let ((pos (js2-current-token-beg)) - expr stmt bundle - (continue t)) - ;; set check for label and call down to `js2-parse-primary-expr' - (setq expr (js2-maybe-parse-label)) - (if (null expr) - ;; Parse the non-label expression and wrap with expression stmt. - (js2-wrap-with-expr-stmt pos (js2-parse-expr) t) - ;; else parsed a label - (setq bundle (make-js2-labeled-stmt-node :pos pos)) - (js2-record-label expr bundle) - ;; look for more labels - (while (and continue (= (js2-get-token) js2-NAME)) - (if (setq expr (js2-maybe-parse-label)) - (js2-record-label expr bundle) - (setq expr (js2-parse-expr) - stmt (js2-wrap-with-expr-stmt (js2-node-pos expr) expr t) - continue nil) - (js2-auto-insert-semicolon stmt))) - ;; no more labels; now parse the labeled statement - (unwind-protect - (unless stmt - (let ((js2-labeled-stmt bundle)) ; bind dynamically - (js2-unget-token) - (setq stmt (js2-statement-helper)))) - ;; remove the labels for this statement from the global set - (dolist (label (js2-labeled-stmt-node-labels bundle)) - (setq js2-label-set (remove label js2-label-set)))) - (setf (js2-labeled-stmt-node-stmt bundle) stmt - (js2-node-len bundle) (- (js2-node-end stmt) pos)) - (js2-node-add-children bundle stmt) - bundle))) - -(defun js2-maybe-parse-label () - (cl-assert (= (js2-current-token-type) js2-NAME)) - (let (label-pos - (next-tt (js2-get-token)) - (label-end (js2-current-token-end))) - ;; Do not consume colon, it is used as unwind indicator - ;; to return to statementHelper. - (js2-unget-token) - (if (= next-tt js2-COLON) - (prog2 - (setq label-pos (js2-current-token-beg)) - (make-js2-label-node :pos label-pos - :len (- label-end label-pos) - :name (js2-current-token-string)) - (js2-set-face label-pos - label-end - 'font-lock-variable-name-face 'record)) - ;; Backtrack from the name token, too. - (js2-unget-token) - nil))) - -(defun js2-parse-expr-stmt () - "Default parser in statement context, if no recognized statement found." - (js2-wrap-with-expr-stmt (js2-current-token-beg) - (progn - (js2-unget-token) - (js2-parse-expr)) t)) - -(defun js2-parse-variables (decl-type pos) - "Parse a comma-separated list of variable declarations. -Could be a 'var', 'const' or 'let' expression, possibly in a for-loop initializer. - -DECL-TYPE is a token value: either VAR, CONST, or LET depending on context. -For 'var' or 'const', the keyword should be the token last scanned. - -POS is the position where the node should start. It's sometimes the -var/const/let keyword, and other times the beginning of the first token -in the first variable declaration. - -Returns the parsed `js2-var-decl-node' expression node." - (let* ((result (make-js2-var-decl-node :decl-type decl-type - :pos pos)) - destructuring kid-pos tt init name end nbeg nend vi - (continue t)) - ;; Example: - ;; var foo = {a: 1, b: 2}, bar = [3, 4]; - ;; var {b: s2, a: s1} = foo, x = 6, y, [s3, s4] = bar; - ;; var {a, b} = baz; - (while continue - (setq destructuring nil - name nil - tt (js2-get-token) - kid-pos (js2-current-token-beg) - end (js2-current-token-end) - init nil) - (if (or (= tt js2-LB) (= tt js2-LC)) - ;; Destructuring assignment, e.g., var [a, b] = ... - (setq destructuring (js2-parse-destruct-primary-expr) - end (js2-node-end destructuring)) - ;; Simple variable name - (js2-unget-token) - (when (js2-must-match-name "msg.bad.var") - (setq name (js2-create-name-node) - nbeg (js2-current-token-beg) - nend (js2-current-token-end) - end nend) - (js2-define-symbol decl-type (js2-current-token-string) name js2-in-for-init) - (js2-check-strict-identifier name))) - (when (js2-match-token js2-ASSIGN) - (setq init (js2-parse-assign-expr) - end (js2-node-end init)) - (js2-record-imenu-functions init name)) - (when name - (js2-set-face nbeg nend (if (js2-function-node-p init) - 'font-lock-function-name-face - 'font-lock-variable-name-face) - 'record)) - (setq vi (make-js2-var-init-node :pos kid-pos - :len (- end kid-pos) - :type decl-type)) - (if destructuring - (progn - (if (and (null init) (not js2-in-for-init)) - (js2-report-error "msg.destruct.assign.no.init")) - (js2-define-destruct-symbols destructuring - decl-type - 'font-lock-variable-name-face) - (setf (js2-var-init-node-target vi) destructuring)) - (setf (js2-var-init-node-target vi) name)) - (setf (js2-var-init-node-initializer vi) init) - (js2-node-add-children vi name destructuring init) - (js2-block-node-push result vi) - (unless (js2-match-token js2-COMMA) - (setq continue nil))) - (setf (js2-node-len result) (- end pos)) - result)) - -(defun js2-parse-let (pos &optional stmt-p) - "Parse a let expression or statement. -A let-expression is of the form `let (vars) expr'. -A let-statement is of the form `let (vars) {statements}'. -The third form of let is a variable declaration list, handled -by `js2-parse-variables'." - (let ((pn (make-js2-let-node :pos pos)) - beg vars body) - (if (js2-must-match js2-LP "msg.no.paren.after.let") - (setf (js2-let-node-lp pn) (- (js2-current-token-beg) pos))) - (js2-push-scope pn) - (unwind-protect - (progn - (setq vars (js2-parse-variables js2-LET (js2-current-token-beg))) - (if (js2-must-match js2-RP "msg.no.paren.let") - (setf (js2-let-node-rp pn) (- (js2-current-token-beg) pos))) - (if (and stmt-p (js2-match-token js2-LC)) - ;; let statement - (progn - (setf beg (js2-current-token-beg) ; position stmt at LC - body (js2-parse-statements)) - (js2-must-match js2-RC "msg.no.curly.let") - (setf (js2-node-len body) (- (js2-current-token-end) beg) - (js2-node-len pn) (- (js2-current-token-end) pos) - (js2-let-node-body pn) body - (js2-node-type pn) js2-LET)) - ;; let expression - (setf body (js2-parse-expr) - (js2-node-len pn) (- (js2-node-end body) pos) - (js2-let-node-body pn) body)) - (setf (js2-let-node-vars pn) vars) - (js2-node-add-children pn vars body)) - (js2-pop-scope)) - pn)) - -(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))) - -(defun js2-define-symbol (decl-type name &optional node ignore-not-in-block) - "Define a symbol in the current scope. -If NODE is non-nil, it is the AST node associated with the symbol." - (let* ((defining-scope (js2-get-defining-scope js2-current-scope name)) - (symbol (if defining-scope - (js2-scope-get-symbol defining-scope name))) - (sdt (if symbol (js2-symbol-decl-type symbol) -1)) - (pos (if node (js2-node-abs-pos node))) - (len (if node (js2-node-len node)))) - (cond - ((and symbol ; already defined in this block - (or (= sdt js2-LET) - (= sdt js2-CONST)) - (eq defining-scope js2-current-scope)) - (js2-report-error - (cond - ((= sdt js2-CONST) "msg.const.redecl") - ((= sdt js2-LET) "msg.let.redecl") - ((= sdt js2-VAR) "msg.var.redecl") - ((= sdt js2-FUNCTION) "msg.function.redecl") - (t "msg.parm.redecl")) - name pos len)) - ((or (= decl-type js2-LET) - (= decl-type js2-CONST)) - (if (and (= decl-type js2-LET) - (not ignore-not-in-block) - (or (= (js2-node-type js2-current-scope) js2-IF) - (js2-loop-node-p js2-current-scope))) - (js2-report-error "msg.let.decl.not.in.block") - (js2-define-new-symbol decl-type name node))) - ((or (= decl-type js2-VAR) - (= decl-type js2-FUNCTION)) - (if symbol - (if (and js2-strict-var-redeclaration-warning (= sdt js2-VAR)) - (js2-add-strict-warning "msg.var.redecl" name) - (if (and js2-strict-var-hides-function-arg-warning (= sdt js2-LP)) - (js2-add-strict-warning "msg.var.hides.arg" name))) - (js2-define-new-symbol decl-type name node - js2-current-script-or-fn))) - ((= decl-type js2-LP) - (if symbol - ;; must be duplicate parameter. Second parameter hides the - ;; first, so go ahead and add the second pararameter - (js2-report-warning "msg.dup.parms" name)) - (js2-define-new-symbol decl-type name node)) - (t (js2-code-bug))))) - -(defun js2-parse-paren-expr-or-generator-comp () - (let ((px-pos (js2-current-token-beg))) - (cond - ((and (>= js2-language-version 200) - (js2-match-token js2-FOR)) - (js2-parse-generator-comp px-pos)) - ((and (>= js2-language-version 200) - (js2-match-token js2-RP)) - ;; Not valid expression syntax, but this is valid in an arrow - ;; function with no params: () => body. - (if (eq (js2-peek-token) js2-ARROW) - ;; Return whatever, it will hopefully be rewinded and - ;; reparsed when we reach the =>. - (make-js2-keyword-node :type js2-NULL) - (js2-report-error "msg.syntax") - (make-js2-error-node))) - (t - (let* ((js2-in-for-init nil) - (expr (js2-parse-expr)) - (pn (make-js2-paren-node :pos px-pos - :expr expr))) - (js2-node-add-children pn (js2-paren-node-expr pn)) - (js2-must-match js2-RP "msg.no.paren") - (setf (js2-node-len pn) (- (js2-current-token-end) px-pos)) - pn))))) - -(defun js2-parse-expr (&optional oneshot) - (let* ((pn (js2-parse-assign-expr)) - (pos (js2-node-pos pn)) - left - right - op-pos) - (while (and (not oneshot) - (js2-match-token js2-COMMA)) - (setq op-pos (- (js2-current-token-beg) pos)) ; relative - (setq right (js2-parse-assign-expr) - left pn - pn (make-js2-infix-node :type js2-COMMA - :pos pos - :len (- js2-ts-cursor pos) - :op-pos op-pos - :left left - :right right)) - (js2-node-add-children pn left right)) - pn)) - -(defun js2-parse-assign-expr () - (let ((tt (js2-get-token)) - (pos (js2-current-token-beg)) - pn left right op-pos - ts-state recorded-identifiers parsed-errors - async-p) - (if (= tt js2-YIELD) - (js2-parse-return-or-yield tt t) - ;; TODO(mooz): Bit confusing. - ;; If we meet `async` token and it's not part of `async - ;; function`, then this `async` is for a succeeding async arrow - ;; function. - ;; Since arrow function parsing doesn't rely on neither - ;; `js2-parse-function-stmt' nor `js2-parse-function-expr' that - ;; interpret `async` token, we trash `async` and just remember - ;; we met `async` keyword to `async-p'. - (when (js2-match-async-arrow-function) - (setq async-p t)) - ;; Save the tokenizer state in case we find an arrow function - ;; and have to rewind. - (setq ts-state (make-js2-ts-state) - recorded-identifiers js2-recorded-identifiers - parsed-errors js2-parsed-errors) - ;; not yield - parse assignment expression - (setq pn (js2-parse-cond-expr) - tt (js2-get-token)) - (cond - ((and (<= js2-first-assign tt) - (<= tt js2-last-assign)) - ;; tt express assignment (=, |=, ^=, ..., %=) - (setq op-pos (- (js2-current-token-beg) pos) ; relative - left pn) - ;; The assigned node could be a js2-prop-get-node (foo.bar = 0), we only - ;; care about assignment to strict variable names. - (when (js2-name-node-p left) - (js2-check-strict-identifier left)) - (setq right (js2-parse-assign-expr) - pn (make-js2-assign-node :type tt - :pos pos - :len (- (js2-node-end right) pos) - :op-pos op-pos - :left left - :right right)) - (when js2-parse-ide-mode - (js2-highlight-assign-targets pn left right) - (js2-record-imenu-functions right left)) - ;; do this last so ide checks above can use absolute positions - (js2-node-add-children pn left right)) - ((and (>= js2-language-version 200) - (or - (= tt js2-ARROW) - (and async-p - (= (js2-peek-token) js2-ARROW)))) - (js2-ts-seek ts-state) - (when async-p - (js2-record-face 'font-lock-keyword-face) - (js2-get-token)) - (setq js2-recorded-identifiers recorded-identifiers - js2-parsed-errors parsed-errors) - (setq pn (js2-parse-function 'FUNCTION_ARROW (js2-current-token-beg) nil async-p))) - (t - (js2-unget-token))) - pn))) - -(defun js2-parse-cond-expr () - (let ((pos (js2-current-token-beg)) - (pn (js2-parse-or-expr)) - test-expr - if-true - if-false - q-pos - c-pos) - (when (js2-match-token js2-HOOK) - (setq q-pos (- (js2-current-token-beg) pos) - if-true (let (js2-in-for-init) (js2-parse-assign-expr))) - (js2-must-match js2-COLON "msg.no.colon.cond") - (setq c-pos (- (js2-current-token-beg) pos) - if-false (js2-parse-assign-expr) - test-expr pn - pn (make-js2-cond-node :pos pos - :len (- (js2-node-end if-false) pos) - :test-expr test-expr - :true-expr if-true - :false-expr if-false - :q-pos q-pos - :c-pos c-pos)) - (js2-node-add-children pn test-expr if-true if-false)) - pn)) - -(defun js2-make-binary (type left parser &optional no-get) - "Helper for constructing a binary-operator AST node. -LEFT is the left-side-expression, already parsed, and the -binary operator should have just been matched. -PARSER is a function to call to parse the right operand, -or a `js2-node' struct if it has already been parsed. -FIXME: The latter option is unused?" - (let* ((pos (js2-node-pos left)) - (op-pos (- (js2-current-token-beg) pos)) - (right (if (js2-node-p parser) - parser - (unless no-get (js2-get-token)) - (funcall parser))) - (pn (make-js2-infix-node :type type - :pos pos - :len (- (js2-node-end right) pos) - :op-pos op-pos - :left left - :right right))) - (js2-node-add-children pn left right) - pn)) - -(defun js2-parse-or-expr () - (let ((pn (js2-parse-and-expr))) - (when (js2-match-token js2-OR) - (setq pn (js2-make-binary js2-OR - pn - 'js2-parse-or-expr))) - pn)) - -(defun js2-parse-and-expr () - (let ((pn (js2-parse-bit-or-expr))) - (when (js2-match-token js2-AND) - (setq pn (js2-make-binary js2-AND - pn - 'js2-parse-and-expr))) - pn)) - -(defun js2-parse-bit-or-expr () - (let ((pn (js2-parse-bit-xor-expr))) - (while (js2-match-token js2-BITOR) - (setq pn (js2-make-binary js2-BITOR - pn - 'js2-parse-bit-xor-expr))) - pn)) - -(defun js2-parse-bit-xor-expr () - (let ((pn (js2-parse-bit-and-expr))) - (while (js2-match-token js2-BITXOR) - (setq pn (js2-make-binary js2-BITXOR - pn - 'js2-parse-bit-and-expr))) - pn)) - -(defun js2-parse-bit-and-expr () - (let ((pn (js2-parse-eq-expr))) - (while (js2-match-token js2-BITAND) - (setq pn (js2-make-binary js2-BITAND - pn - 'js2-parse-eq-expr))) - pn)) - -(defconst js2-parse-eq-ops - (list js2-EQ js2-NE js2-SHEQ js2-SHNE)) - -(defun js2-parse-eq-expr () - (let ((pn (js2-parse-rel-expr)) - tt) - (while (memq (setq tt (js2-get-token)) js2-parse-eq-ops) - (setq pn (js2-make-binary tt - pn - 'js2-parse-rel-expr))) - (js2-unget-token) - pn)) - -(defconst js2-parse-rel-ops - (list js2-IN js2-INSTANCEOF js2-LE js2-LT js2-GE js2-GT)) - -(defun js2-parse-rel-expr () - (let ((pn (js2-parse-shift-expr)) - (continue t) - tt) - (while continue - (setq tt (js2-get-token)) - (cond - ((and js2-in-for-init (= tt js2-IN)) - (js2-unget-token) - (setq continue nil)) - ((memq tt js2-parse-rel-ops) - (setq pn (js2-make-binary tt pn 'js2-parse-shift-expr))) - (t - (js2-unget-token) - (setq continue nil)))) - pn)) - -(defconst js2-parse-shift-ops - (list js2-LSH js2-URSH js2-RSH)) - -(defun js2-parse-shift-expr () - (let ((pn (js2-parse-add-expr)) - tt - (continue t)) - (while continue - (setq tt (js2-get-token)) - (if (memq tt js2-parse-shift-ops) - (setq pn (js2-make-binary tt pn 'js2-parse-add-expr)) - (js2-unget-token) - (setq continue nil))) - pn)) - -(defun js2-parse-add-expr () - (let ((pn (js2-parse-mul-expr)) - tt - (continue t)) - (while continue - (setq tt (js2-get-token)) - (if (or (= tt js2-ADD) (= tt js2-SUB)) - (setq pn (js2-make-binary tt pn 'js2-parse-mul-expr)) - (js2-unget-token) - (setq continue nil))) - pn)) - -(defconst js2-parse-mul-ops - (list js2-MUL js2-DIV js2-MOD)) - -(defun js2-parse-mul-expr () - (let ((pn (js2-parse-expon-expr)) - tt - (continue t)) - (while continue - (setq tt (js2-get-token)) - (if (memq tt js2-parse-mul-ops) - (setq pn (js2-make-binary tt pn 'js2-parse-expon-expr)) - (js2-unget-token) - (setq continue nil))) - pn)) - -(defun js2-parse-expon-expr () - (let ((pn (js2-parse-unary-expr))) - (when (>= js2-language-version 200) - (while (js2-match-token js2-EXPON) - (when (and (js2-unary-node-p pn) - (not (memq (js2-node-type pn) '(js2-INC js2-DEC)))) - (js2-report-error "msg.syntax" nil - (js2-node-abs-pos pn) (js2-node-len pn))) - ;; Make it right-associative. - (setq pn (js2-make-binary js2-EXPON pn 'js2-parse-expon-expr)))) - pn)) - -(defun js2-make-unary (beg type parser &rest args) - "Make a unary node starting at BEG of type TYPE. -If BEG is nil, `(js2-current-token-beg)' is used for the node -start position. PARSER is either a node (for postfix operators) -or a function to call to parse the operand (for prefix -operators)." - (let* ((pos (or beg (js2-current-token-beg))) - (postfix (js2-node-p parser)) - (expr (if postfix - parser - (apply parser args))) - end - pn) - (if postfix ; e.g. i++ - (setq pos (js2-node-pos expr) - end (js2-current-token-end)) - (setq end (js2-node-end expr))) - (setq pn (make-js2-unary-node :type type - :pos pos - :len (- end pos) - :operand expr)) - (js2-node-add-children pn expr) - pn)) - -(defconst js2-incrementable-node-types - (list js2-NAME js2-GETPROP js2-GETELEM js2-GET_REF js2-CALL) - "Node types that can be the operand of a ++ or -- operator.") - -(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) - "msg.bad.incr" - "msg.bad.decr") - nil beg (- end beg)))) - -(defun js2-parse-unary-expr () - (let ((tt (js2-current-token-type)) - (beg (js2-current-token-beg))) - (cond - ((or (= tt js2-VOID) - (= tt js2-NOT) - (= tt js2-BITNOT) - (= tt js2-TYPEOF)) - (js2-get-token) - (js2-make-unary beg tt 'js2-parse-unary-expr)) - ((= tt js2-ADD) - (js2-get-token) - ;; Convert to special POS token in decompiler and parse tree - (js2-make-unary beg js2-POS 'js2-parse-unary-expr)) - ((= tt js2-SUB) - (js2-get-token) - ;; Convert to special NEG token in decompiler and parse tree - (js2-make-unary beg js2-NEG 'js2-parse-unary-expr)) - ((or (= tt js2-INC) - (= tt js2-DEC)) - (js2-get-token) - (let ((beg2 (js2-current-token-beg)) - (end (js2-current-token-end)) - (expr (js2-make-unary beg tt 'js2-parse-member-expr t))) - (js2-check-bad-inc-dec tt beg2 end expr) - expr)) - ((= tt js2-DELPROP) - (js2-get-token) - (js2-make-unary beg js2-DELPROP 'js2-parse-unary-expr)) - ((js2-parse-await-maybe tt)) - ((= tt js2-ERROR) - (js2-get-token) - (make-js2-error-node)) ; try to continue - ((and (= tt js2-LT) - js2-compiler-xml-available) - ;; XML stream encountered in expression. - (js2-parse-member-expr-tail t (js2-parse-xml-initializer))) - (t - (let ((pn (js2-parse-member-expr t)) - ;; Don't look across a newline boundary for a postfix incop. - (tt (js2-peek-token-or-eol)) - expr) - (when (or (= tt js2-INC) (= tt js2-DEC)) - (js2-get-token) - (setf expr pn - pn (js2-make-unary (js2-node-pos expr) tt expr)) - (js2-node-set-prop pn 'postfix t) - (js2-check-bad-inc-dec tt (js2-current-token-beg) (js2-current-token-end) pn)) - pn))))) - -(defun js2-parse-xml-initializer () - "Parse an E4X XML initializer. -I'm parsing it the way Rhino parses it, but without the tree-rewriting. -Then I'll postprocess the result, depending on whether we're in IDE -mode or codegen mode, and generate the appropriate rewritten AST. -IDE mode uses a rich AST that models the XML structure. Codegen mode -just concatenates everything and makes a new XML or XMLList out of it." - (let ((tt (js2-get-first-xml-token)) - pn-xml pn expr kids expr-pos - (continue t) - (first-token t)) - (when (not (or (= tt js2-XML) (= tt js2-XMLEND))) - (js2-report-error "msg.syntax")) - (setq pn-xml (make-js2-xml-node)) - (while continue - (if first-token - (setq first-token nil) - (setq tt (js2-get-next-xml-token))) - (cond - ;; js2-XML means we found a {expr} in the XML stream. - ;; The token string is the XML up to the left-curly. - ((= tt js2-XML) - (push (make-js2-string-node :pos (js2-current-token-beg) - :len (- js2-ts-cursor (js2-current-token-beg))) - kids) - (js2-must-match js2-LC "msg.syntax") - (setq expr-pos js2-ts-cursor - expr (if (eq (js2-peek-token) js2-RC) - (make-js2-empty-expr-node :pos expr-pos) - (js2-parse-expr))) - (js2-must-match js2-RC "msg.syntax") - (setq pn (make-js2-xml-js-expr-node :pos (js2-node-pos expr) - :len (js2-node-len expr) - :expr expr)) - (js2-node-add-children pn expr) - (push pn kids)) - ;; a js2-XMLEND token means we hit the final close-tag. - ((= tt js2-XMLEND) - (push (make-js2-string-node :pos (js2-current-token-beg) - :len (- js2-ts-cursor (js2-current-token-beg))) - kids) - (dolist (kid (nreverse kids)) - (js2-block-node-push pn-xml kid)) - (setf (js2-node-len pn-xml) (- js2-ts-cursor - (js2-node-pos pn-xml)) - continue nil)) - (t - (js2-report-error "msg.syntax") - (setq continue nil)))) - pn-xml)) - - -(defun js2-parse-argument-list () - "Parse an argument list and return it as a Lisp list of nodes. -Returns the list in reverse order. Consumes the right-paren token." - (let (result) - (unless (js2-match-token js2-RP) - (cl-loop do - (let ((tt (js2-get-token)) - (beg (js2-current-token-beg))) - (if (and (= tt js2-TRIPLEDOT) - (>= js2-language-version 200)) - (push (js2-make-unary beg tt 'js2-parse-assign-expr) result) - (js2-unget-token) - (push (js2-parse-assign-expr) result))) - while - (and (js2-match-token js2-COMMA) - (or (< js2-language-version 200) - (not (= js2-RP (js2-peek-token)))))) - (js2-must-match js2-RP "msg.no.paren.arg") - result))) - -(defun js2-parse-member-expr (&optional allow-call-syntax) - (let ((tt (js2-current-token-type)) - pn pos target args beg end init) - (if (/= tt js2-NEW) - (setq pn (js2-parse-primary-expr)) - ;; parse a 'new' expression - (js2-get-token) - (setq pos (js2-current-token-beg) - beg pos - target (js2-parse-member-expr) - end (js2-node-end target) - pn (make-js2-new-node :pos pos - :target target - :len (- end pos))) - (js2-highlight-function-call (js2-current-token)) - (js2-node-add-children pn target) - (when (js2-match-token js2-LP) - ;; Add the arguments to pn, if any are supplied. - (setf beg pos ; start of "new" keyword - pos (js2-current-token-beg) - args (nreverse (js2-parse-argument-list)) - (js2-new-node-args pn) args - end (js2-current-token-end) - (js2-new-node-lp pn) (- pos beg) - (js2-new-node-rp pn) (- end 1 beg)) - (apply #'js2-node-add-children pn args)) - (when (and js2-allow-rhino-new-expr-initializer - (js2-match-token js2-LC)) - (setf init (js2-parse-object-literal) - end (js2-node-end init) - (js2-new-node-initializer pn) init) - (js2-node-add-children pn init)) - (setf (js2-node-len pn) (- end beg))) ; end outer if - (js2-parse-member-expr-tail allow-call-syntax pn))) - -(defun js2-parse-member-expr-tail (allow-call-syntax pn) - "Parse a chain of property/array accesses or function calls. -Includes parsing for E4X operators like `..' and `.@'. -If ALLOW-CALL-SYNTAX is nil, stops when we encounter a left-paren. -Returns an expression tree that includes PN, the parent node." - (let (tt - (continue t)) - (while continue - (setq tt (js2-get-token)) - (cond - ((or (= tt js2-DOT) (= tt js2-DOTDOT)) - (setq pn (js2-parse-property-access tt pn))) - ((= tt js2-DOTQUERY) - (setq pn (js2-parse-dot-query pn))) - ((= tt js2-LB) - (setq pn (js2-parse-element-get pn))) - ((= tt js2-LP) - (js2-unget-token) - (if allow-call-syntax - (setq pn (js2-parse-function-call pn)) - (setq continue nil))) - ((= tt js2-TEMPLATE_HEAD) - (setq pn (js2-parse-tagged-template pn (js2-parse-template-literal)))) - ((= tt js2-NO_SUBS_TEMPLATE) - (setq pn (js2-parse-tagged-template pn (make-js2-string-node :type tt)))) - (t - (js2-unget-token) - (setq continue nil))) - (if (>= js2-highlight-level 2) - (js2-parse-highlight-member-expr-node pn))) - pn)) - -(defun js2-parse-tagged-template (tag-node tpl-node) - "Parse tagged template expression." - (let* ((pos (js2-node-pos tag-node)) - (pn (make-js2-tagged-template-node :pos pos - :len (- (js2-current-token-end) pos) - :tag tag-node - :template tpl-node))) - (js2-node-add-children pn tag-node tpl-node) - pn)) - -(defun js2-parse-dot-query (pn) - "Parse a dot-query expression, e.g. foo.bar.(@name == 2) -Last token parsed must be `js2-DOTQUERY'." - (let ((pos (js2-node-pos pn)) - op-pos expr end) - (js2-must-have-xml) - (js2-set-requires-activation) - (setq op-pos (js2-current-token-beg) - expr (js2-parse-expr) - end (js2-node-end expr) - pn (make-js2-xml-dot-query-node :left pn - :pos pos - :op-pos op-pos - :right expr)) - (js2-node-add-children pn - (js2-xml-dot-query-node-left pn) - (js2-xml-dot-query-node-right pn)) - (if (js2-must-match js2-RP "msg.no.paren") - (setf (js2-xml-dot-query-node-rp pn) (js2-current-token-beg) - end (js2-current-token-end))) - (setf (js2-node-len pn) (- end pos)) - pn)) - -(defun js2-parse-element-get (pn) - "Parse an element-get expression, e.g. foo[bar]. -Last token parsed must be `js2-RB'." - (let ((lb (js2-current-token-beg)) - (pos (js2-node-pos pn)) - rb expr) - (setq expr (js2-parse-expr)) - (if (js2-must-match js2-RB "msg.no.bracket.index") - (setq rb (js2-current-token-beg))) - (setq pn (make-js2-elem-get-node :target pn - :pos pos - :element expr - :lb (js2-relpos lb pos) - :rb (js2-relpos rb pos) - :len (- (js2-current-token-end) pos))) - (js2-node-add-children pn - (js2-elem-get-node-target pn) - (js2-elem-get-node-element pn)) - pn)) - -(defun js2-highlight-function-call (token) - (when (eq (js2-token-type token) js2-NAME) - (js2-record-face 'js2-function-call token))) - -(defun js2-parse-function-call (pn) - (js2-highlight-function-call (js2-current-token)) - (js2-get-token) - (let (args - (pos (js2-node-pos pn))) - (setq pn (make-js2-call-node :pos pos - :target pn - :lp (- (js2-current-token-beg) pos))) - (js2-node-add-children pn (js2-call-node-target pn)) - ;; Add the arguments to pn, if any are supplied. - (setf args (nreverse (js2-parse-argument-list)) - (js2-call-node-rp pn) (- (js2-current-token-beg) pos) - (js2-call-node-args pn) args) - (apply #'js2-node-add-children pn args) - (setf (js2-node-len pn) (- js2-ts-cursor pos)) - pn)) - -(defun js2-parse-property-access (tt pn) - "Parse a property access, XML descendants access, or XML attr access." - (let ((member-type-flags 0) - (dot-pos (js2-current-token-beg)) - (dot-len (if (= tt js2-DOTDOT) 2 1)) - name - ref ; right side of . or .. operator - result) - (when (= tt js2-DOTDOT) - (js2-must-have-xml) - (setq member-type-flags js2-descendants-flag)) - (if (not js2-compiler-xml-available) - (progn - (js2-must-match-prop-name "msg.no.name.after.dot") - (setq name (js2-create-name-node t js2-GETPROP) - result (make-js2-prop-get-node :left pn - :pos (js2-current-token-beg) - :right name - :len (js2-current-token-len))) - (js2-node-add-children result pn name) - result) - ;; otherwise look for XML operators - (setf result (if (= tt js2-DOT) - (make-js2-prop-get-node) - (make-js2-infix-node :type js2-DOTDOT)) - (js2-node-pos result) (js2-node-pos pn) - (js2-infix-node-op-pos result) dot-pos - (js2-infix-node-left result) pn ; do this after setting position - tt (js2-get-prop-name-token)) - (cond - ;; handles: name, ns::name, ns::*, ns::[expr] - ((= tt js2-NAME) - (setq ref (js2-parse-property-name -1 nil member-type-flags))) - ;; handles: *, *::name, *::*, *::[expr] - ((= tt js2-MUL) - (setq ref (js2-parse-property-name nil "*" member-type-flags))) - ;; handles: '@attr', '@ns::attr', '@ns::*', '@ns::[expr]', etc. - ((= tt js2-XMLATTR) - (setq result (js2-parse-attribute-access))) - (t - (js2-report-error "msg.no.name.after.dot" nil dot-pos dot-len))) - (if ref - (setf (js2-node-len result) (- (js2-node-end ref) - (js2-node-pos result)) - (js2-infix-node-right result) ref)) - (if (js2-infix-node-p result) - (js2-node-add-children result - (js2-infix-node-left result) - (js2-infix-node-right result))) - result))) - -(defun js2-parse-attribute-access () - "Parse an E4X XML attribute expression. -This includes expressions of the forms: - - @attr @ns::attr @ns::* - @* @*::attr @*::* - @[expr] @*::[expr] @ns::[expr] - -Called if we peeked an '@' token." - (let ((tt (js2-get-prop-name-token)) - (at-pos (js2-current-token-beg))) - (cond - ;; handles: @name, @ns::name, @ns::*, @ns::[expr] - ((= tt js2-NAME) - (js2-parse-property-name at-pos nil 0)) - ;; handles: @*, @*::name, @*::*, @*::[expr] - ((= tt js2-MUL) - (js2-parse-property-name (js2-current-token-beg) "*" 0)) - ;; handles @[expr] - ((= tt js2-LB) - (js2-parse-xml-elem-ref at-pos)) - (t - (js2-report-error "msg.no.name.after.xmlAttr") - ;; Avoid cascaded errors that happen if we make an error node here. - (js2-parse-property-name (js2-current-token-beg) "" 0))))) - -(defun js2-parse-property-name (at-pos s member-type-flags) - "Check if :: follows name in which case it becomes qualified name. - -AT-POS is a natural number if we just read an '@' token, else nil. -S is the name or string that was matched: an identifier, 'throw' or '*'. -MEMBER-TYPE-FLAGS is a bit set tracking whether we're a '.' or '..' child. - -Returns a `js2-xml-ref-node' if it's an attribute access, a child of a '..' -operator, or the name is followed by ::. For a plain name, returns a -`js2-name-node'. Returns a `js2-error-node' for malformed XML expressions." - (let ((pos (or at-pos (js2-current-token-beg))) - colon-pos - (name (js2-create-name-node t (js2-current-token-type) s)) - ns tt pn) - (catch 'return - (when (js2-match-token js2-COLONCOLON) - (setq ns name - colon-pos (js2-current-token-beg) - tt (js2-get-prop-name-token)) - (cond - ;; handles name::name - ((= tt js2-NAME) - (setq name (js2-create-name-node))) - ;; handles name::* - ((= tt js2-MUL) - (setq name (js2-create-name-node nil nil "*"))) - ;; handles name::[expr] - ((= tt js2-LB) - (throw 'return (js2-parse-xml-elem-ref at-pos ns colon-pos))) - (t - (js2-report-error "msg.no.name.after.coloncolon")))) - (if (and (null ns) (zerop member-type-flags)) - name - (prog1 - (setq pn - (make-js2-xml-prop-ref-node :pos pos - :len (- (js2-node-end name) pos) - :at-pos at-pos - :colon-pos colon-pos - :propname name)) - (js2-node-add-children pn name)))))) - -(defun js2-parse-xml-elem-ref (at-pos &optional namespace colon-pos) - "Parse the [expr] portion of an xml element reference. -For instance, @[expr], @*::[expr], or ns::[expr]." - (let* ((lb (js2-current-token-beg)) - (pos (or at-pos lb)) - rb - (expr (js2-parse-expr)) - (end (js2-node-end expr)) - pn) - (if (js2-must-match js2-RB "msg.no.bracket.index") - (setq rb (js2-current-token-beg) - end (js2-current-token-end))) - (prog1 - (setq pn - (make-js2-xml-elem-ref-node :pos pos - :len (- end pos) - :namespace namespace - :colon-pos colon-pos - :at-pos at-pos - :expr expr - :lb (js2-relpos lb pos) - :rb (js2-relpos rb pos))) - (js2-node-add-children pn namespace expr)))) - -(defun js2-parse-destruct-primary-expr () - (let ((js2-is-in-destructuring t)) - (js2-parse-primary-expr))) - -(defun js2-parse-primary-expr () - "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 node) - (setq tt (js2-current-token-type)) - (cond - ((= tt js2-CLASS) - (js2-parse-class-expr)) - ((= tt js2-FUNCTION) - (js2-parse-function-expr)) - ((js2-match-async-function) - (js2-parse-function-expr t)) - ((= tt js2-LB) - (js2-parse-array-comp-or-literal)) - ((= tt js2-LC) - (js2-parse-object-literal)) - ((= tt js2-LET) - (js2-parse-let (js2-current-token-beg))) - ((= tt js2-LP) - (js2-parse-paren-expr-or-generator-comp)) - ((= tt js2-XMLATTR) - (js2-must-have-xml) - (js2-parse-attribute-access)) - ((= tt js2-NAME) - (js2-parse-name tt)) - ((= tt js2-NUMBER) - (setq node (make-js2-number-node)) - (when (and js2-in-use-strict-directive - (= (js2-number-node-num-base node) 8) - (js2-number-node-legacy-octal-p node)) - (js2-report-error "msg.no.octal.strict")) - node) - ((or (= tt js2-STRING) (= tt js2-NO_SUBS_TEMPLATE)) - (make-js2-string-node :type tt)) - ((= tt js2-TEMPLATE_HEAD) - (js2-parse-template-literal)) - ((or (= tt js2-DIV) (= tt js2-ASSIGN_DIV)) - ;; Got / or /= which in this context means a regexp literal - (let* ((px-pos (js2-current-token-beg)) - (flags (js2-read-regexp tt px-pos)) - (end (js2-current-token-end))) - (prog1 - (make-js2-regexp-node :pos px-pos - :len (- end px-pos) - :value (js2-current-token-string) - :flags flags) - (js2-set-face px-pos end 'font-lock-string-face 'record)))) - ((or (= tt js2-NULL) - (= tt js2-THIS) - (= tt js2-SUPER) - (= tt js2-FALSE) - (= tt js2-TRUE)) - (make-js2-keyword-node :type tt)) - ((= tt js2-TRIPLEDOT) - ;; Likewise, only valid in an arrow function with a rest param. - (if (and (js2-match-token js2-NAME) - (js2-match-token js2-RP) - (eq (js2-peek-token) js2-ARROW)) - (progn - (js2-unget-token) ; Put back the right paren. - ;; See the previous case. - (make-js2-keyword-node :type js2-NULL)) - (js2-report-error "msg.syntax") - (make-js2-error-node))) - ((= tt js2-RESERVED) - (js2-report-error "msg.reserved.id") - (make-js2-name-node)) - ((= tt js2-ERROR) - ;; the scanner or one of its subroutines reported the error. - (make-js2-error-node)) - ((= tt js2-EOF) - (let* ((px-pos (point-at-bol)) - (len (- js2-ts-cursor px-pos))) - (js2-report-error "msg.unexpected.eof" nil px-pos len)) - (make-js2-error-node :pos (1- js2-ts-cursor))) - (t - (js2-report-error "msg.syntax") - (make-js2-error-node))))) - -(defun js2-parse-template-literal () - (let ((beg (js2-current-token-beg)) - (kids (list (make-js2-string-node :type js2-TEMPLATE_HEAD))) - (tt js2-TEMPLATE_HEAD)) - (while (eq tt js2-TEMPLATE_HEAD) - (push (js2-parse-expr) kids) - (js2-must-match js2-RC "msg.syntax") - (setq tt (js2-get-token 'TEMPLATE_TAIL)) - (push (make-js2-string-node :type tt) kids)) - (setq kids (nreverse kids)) - (let ((tpl (make-js2-template-node :pos beg - :len (- (js2-current-token-end) beg) - :kids kids))) - (apply #'js2-node-add-children tpl kids) - tpl))) - -(defun js2-parse-name (_tt) - (let ((name (js2-current-token-string)) - node) - (setq node (if js2-compiler-xml-available - (js2-parse-property-name nil name 0) - (js2-create-name-node 'check-activation nil name))) - (if (and js2-highlight-external-variables - ;; FIXME: What's TRT for `js2-xml-ref-node'? - (js2-name-node-p node)) - (js2-record-name-node node)) - node)) - -(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 - (max (if elems - (js2-node-pos (car elems)) - pos) - (save-excursion - (goto-char comma-pos) - (back-to-indentation) - (point))) - comma-pos)) - -(defun js2-parse-array-comp-or-literal () - (let ((pos (js2-current-token-beg))) - (if (and (>= js2-language-version 200) - (js2-match-token js2-FOR)) - (js2-parse-array-comp pos) - (js2-parse-array-literal pos)))) - -(defun js2-parse-array-literal (pos) - (let ((after-lb-or-comma t) - after-comma tt elems pn was-rest - (continue t)) - (unless js2-is-in-destructuring - (js2-push-scope (make-js2-scope))) ; for the legacy array comp - (while continue - (setq tt (js2-get-token)) - (cond - ;; end of array - ((or (= tt js2-RB) - (= tt js2-EOF)) ; prevent infinite loop - (if (= tt js2-EOF) - (js2-report-error "msg.no.bracket.arg" nil pos)) - (when (and after-comma (< js2-language-version 170)) - (js2-parse-warn-trailing-comma "msg.array.trailing.comma" - pos (remove nil elems) after-comma)) - (setq continue nil - pn (make-js2-array-node :pos pos - :len (- js2-ts-cursor pos) - :elems (nreverse elems))) - (apply #'js2-node-add-children pn (js2-array-node-elems pn))) - ;; anything after rest element (...foo) - (was-rest - (js2-report-error "msg.param.after.rest")) - ;; comma - ((= tt js2-COMMA) - (setq after-comma (js2-current-token-end)) - (if (not after-lb-or-comma) - (setq after-lb-or-comma t) - (push nil elems))) - ;; array comp - ((and (>= js2-language-version 170) - (not js2-is-in-destructuring) - (= tt js2-FOR) ; check for array comprehension - (not after-lb-or-comma) ; "for" can't follow a comma - elems ; must have at least 1 element - (not (cdr elems))) ; but no 2nd element - (js2-unget-token) - (setf continue nil - pn (js2-parse-legacy-array-comp (car elems) pos))) - ;; another element - (t - (unless after-lb-or-comma - (js2-report-error "msg.no.bracket.arg")) - (if (and (= tt js2-TRIPLEDOT) - (>= js2-language-version 200)) - ;; rest/spread operator - (progn - (push (js2-make-unary nil tt 'js2-parse-assign-expr) - elems) - (if js2-is-in-destructuring - (setq was-rest t))) - (js2-unget-token) - (push (js2-parse-assign-expr) elems)) - (setq after-lb-or-comma nil - after-comma nil)))) - (unless js2-is-in-destructuring - (js2-pop-scope)) - pn)) - -(defun js2-parse-legacy-array-comp (expr pos) - "Parse a legacy array comprehension (JavaScript 1.7). -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 ((current-scope js2-current-scope) - loops first filter result) - (unwind-protect - (progn - (while (js2-match-token js2-FOR) - (let ((loop (make-js2-comp-loop-node))) - (js2-push-scope loop) - (push loop loops) - (js2-parse-comp-loop loop))) - ;; First loop takes expr scope's parent. - (setf (js2-scope-parent-scope (setq first (car (last loops)))) - (js2-scope-parent-scope current-scope)) - ;; Set expr scope's parent to the last loop. - (setf (js2-scope-parent-scope current-scope) (car loops)) - (if (/= (js2-get-token) js2-IF) - (js2-unget-token) - (setq filter (js2-parse-condition)))) - (dotimes (_ (1- (length loops))) - (js2-pop-scope))) - (js2-must-match js2-RB "msg.no.bracket.arg" pos) - (setq result (make-js2-comp-node :pos pos - :len (- js2-ts-cursor pos) - :result expr - :loops (nreverse loops) - :filters (and filter (list (car filter))) - :form 'LEGACY_ARRAY)) - ;; Set comp loop's parent to the last loop. - ;; TODO: Get rid of the bogus expr scope. - (setf (js2-scope-parent-scope result) first) - (apply #'js2-node-add-children result expr (car filter) - (js2-comp-node-loops result)) - result)) - -(defun js2-parse-array-comp (pos) - "Parse an ES6 array comprehension. -POS is the beginning of the LB token. -We should have just parsed the 'for' keyword before calling this function." - (let ((pn (js2-parse-comprehension pos 'ARRAY))) - (js2-must-match js2-RB "msg.no.bracket.arg" pos) - pn)) - -(defun js2-parse-generator-comp (pos) - (let* ((js2-nesting-of-function (1+ js2-nesting-of-function)) - (js2-current-script-or-fn - (make-js2-function-node :generator-type 'COMPREHENSION)) - (pn (js2-parse-comprehension pos 'STAR_GENERATOR))) - (js2-must-match js2-RP "msg.no.paren" pos) - pn)) - -(defun js2-parse-comprehension (pos form) - (let (loops filters expr result last) - (unwind-protect - (progn - (js2-unget-token) - (while (js2-match-token js2-FOR) - (let ((loop (make-js2-comp-loop-node))) - (js2-push-scope loop) - (push loop loops) - (js2-parse-comp-loop loop))) - (while (js2-match-token js2-IF) - (push (car (js2-parse-condition)) filters)) - (setq expr (js2-parse-assign-expr)) - (setq last (car loops))) - (dolist (_ loops) - (js2-pop-scope))) - (setq result (make-js2-comp-node :pos pos - :len (- js2-ts-cursor pos) - :result expr - :loops (nreverse loops) - :filters (nreverse filters) - :form form)) - (apply #'js2-node-add-children result (js2-comp-node-loops result)) - (apply #'js2-node-add-children result expr (js2-comp-node-filters result)) - (setf (js2-scope-parent-scope result) last) - result)) - -(defun js2-parse-comp-loop (pn &optional only-of-p) - "Parse a 'for [each] (foo [in|of] bar)' expression in an Array comprehension. -The current token should be the initial FOR. -If ONLY-OF-P is non-nil, only the 'for (foo of bar)' form is allowed." - (let ((pos (js2-comp-loop-node-pos pn)) - tt iter obj foreach-p forof-p in-pos each-pos lp rp) - (when (and (not only-of-p) (js2-match-token js2-NAME)) - (if (string= (js2-current-token-string) "each") - (progn - (setq foreach-p t - each-pos (- (js2-current-token-beg) pos)) ; relative - (js2-record-face 'font-lock-keyword-face)) - (js2-report-error "msg.no.paren.for"))) - (if (js2-must-match js2-LP "msg.no.paren.for") - (setq lp (- (js2-current-token-beg) pos))) - (setq tt (js2-peek-token)) - (cond - ((or (= tt js2-LB) - (= tt js2-LC)) - (js2-get-token) - (setq iter (js2-parse-destruct-primary-expr)) - (js2-define-destruct-symbols iter js2-LET - 'font-lock-variable-name-face t)) - ((js2-match-token js2-NAME) - (setq iter (js2-create-name-node))) - (t - (js2-report-error "msg.bad.var"))) - ;; Define as a let since we want the scope of the variable to - ;; be restricted to the array comprehension - (if (js2-name-node-p iter) - (js2-define-symbol js2-LET (js2-name-node-name iter) pn t)) - (if (or (and (not only-of-p) (js2-match-token js2-IN)) - (and (>= js2-language-version 200) - (js2-match-contextual-kwd "of") - (setq forof-p t))) - (setq in-pos (- (js2-current-token-beg) pos)) - (js2-report-error "msg.in.after.for.name")) - (setq obj (js2-parse-expr)) - (if (js2-must-match js2-RP "msg.no.paren.for.ctrl") - (setq rp (- (js2-current-token-beg) pos))) - (setf (js2-node-pos pn) pos - (js2-node-len pn) (- js2-ts-cursor pos) - (js2-comp-loop-node-iterator pn) iter - (js2-comp-loop-node-object pn) obj - (js2-comp-loop-node-in-pos pn) in-pos - (js2-comp-loop-node-each-pos pn) each-pos - (js2-comp-loop-node-foreach-p pn) foreach-p - (js2-comp-loop-node-forof-p pn) forof-p - (js2-comp-loop-node-lp pn) lp - (js2-comp-loop-node-rp pn) rp) - (js2-node-add-children pn iter obj) - pn)) - -(defun js2-parse-class-stmt () - (let ((pos (js2-current-token-beg)) - (_ (js2-must-match-name "msg.unnamed.class.stmt")) - (name (js2-create-name-node t))) - (js2-set-face (js2-node-pos name) (js2-node-end name) - 'font-lock-function-name-face 'record) - (let ((node (js2-parse-class pos 'CLASS_STATEMENT name))) - (js2-record-imenu-functions node name) - (js2-define-symbol js2-FUNCTION - (js2-name-node-name name) - node) - node))) - -(defun js2-parse-class-expr () - (let ((pos (js2-current-token-beg)) - name) - (when (js2-match-token js2-NAME) - (setq name (js2-create-name-node t))) - (js2-parse-class pos 'CLASS_EXPRESSION name))) - -(defun js2-parse-class (pos form name) - ;; class X [extends ...] { - (let (pn elems extends) - (if (js2-match-token js2-EXTENDS) - (if (= (js2-peek-token) js2-LC) - (js2-report-error "msg.missing.extends") - ;; TODO(sdh): this should be left-hand-side-expr, not assign-expr - (setq extends (js2-parse-assign-expr)) - (if (not extends) - (js2-report-error "msg.bad.extends")))) - (js2-must-match js2-LC "msg.no.brace.class") - (setq elems (js2-parse-object-literal-elems t) - pn (make-js2-class-node :pos pos - :len (- js2-ts-cursor pos) - :form form - :name name - :extends extends - :elems elems)) - (apply #'js2-node-add-children - pn name extends (js2-class-node-elems pn)) - pn)) - -(defun js2-parse-object-literal () - (let* ((pos (js2-current-token-beg)) - (elems (js2-parse-object-literal-elems)) - (result (make-js2-object-node :pos pos - :len (- js2-ts-cursor pos) - :elems elems))) - (apply #'js2-node-add-children result (js2-object-node-elems result)) - result)) - -(defun js2-property-key-string (property-node) - "Return the key of PROPERTY-NODE (a `js2-object-prop-node' or -`js2-method-node') as a string, or nil if it can't be -represented as a string (e.g., the key is computed by an -expression)." - (cond - ((js2-unary-node-p property-node) nil) ;; {...foo} - (t - (let ((key (js2-infix-node-left property-node))) - (when (js2-computed-prop-name-node-p key) - (setq key (js2-computed-prop-name-node-expr key))) - (cond - ((js2-name-node-p key) - (js2-name-node-name key)) - ((js2-string-node-p key) - (js2-string-node-value key)) - ((js2-number-node-p key) - (js2-number-node-value key))))))) - -(defun js2-parse-object-literal-elems (&optional class-p) - (let ((pos (js2-current-token-beg)) - (static nil) - (continue t) - tt elems elem - elem-key-string previous-elem-key-string - after-comma previous-token) - (while continue - (setq tt (js2-get-prop-name-token) - static nil - elem nil - previous-token nil) - ;; Handle 'static' keyword only if we're in a class - (when (and class-p (= js2-NAME tt) - (string= "static" (js2-current-token-string))) - (js2-record-face 'font-lock-keyword-face) - (setq static t - tt (js2-get-prop-name-token))) - ;; Handle generator * before the property name for in-line functions - (when (and (>= js2-language-version 200) - (= js2-MUL tt)) - (setq previous-token (js2-current-token) - tt (js2-get-prop-name-token))) - ;; Handle getter, setter and async methods - (let ((prop (js2-current-token-string))) - (when (and (>= js2-language-version 200) - (= js2-NAME tt) - (member prop '("get" "set" "async")) - (member (js2-peek-token 'KEYWORD_IS_NAME) - (list js2-NAME js2-STRING js2-NUMBER js2-LB))) - (setq previous-token (js2-current-token) - tt (js2-get-prop-name-token)))) - (cond - ;; Rest/spread (...expr) - ((and (>= js2-language-version 200) - (not class-p) (not static) (not previous-token) - (= js2-TRIPLEDOT tt)) - (setq after-comma nil - elem (js2-make-unary nil js2-TRIPLEDOT 'js2-parse-assign-expr))) - ;; Found a key/value property (of any sort) - ((member tt (list js2-NAME js2-STRING js2-NUMBER js2-LB)) - (setq after-comma nil - elem (js2-parse-named-prop tt previous-token class-p)) - (if (and (null elem) - (not js2-recover-from-parse-errors)) - (setq continue nil))) - ;; Break out of loop, and handle trailing commas. - ((or (= tt js2-RC) - (= tt js2-EOF)) - (js2-unget-token) - (setq continue nil) - (if after-comma - (js2-parse-warn-trailing-comma "msg.extra.trailing.comma" - pos elems after-comma))) - ;; Skip semicolons in a class body - ((and class-p - (= tt js2-SEMI)) - nil) - (t - (js2-report-error "msg.bad.prop") - (unless js2-recover-from-parse-errors - (setq continue nil)))) ; end switch - ;; Handle static for classes' codegen. - (if static - (if elem (js2-node-set-prop elem 'STATIC t) - (js2-report-error "msg.unexpected.static"))) - ;; Handle commas, depending on class-p. - (let ((tok (js2-get-prop-name-token))) - (if (eq tok js2-COMMA) - (if class-p - (js2-report-error "msg.class.unexpected.comma") - (setq after-comma (js2-current-token-end))) - (js2-unget-token) - (unless class-p (setq continue nil)))) - (when elem - (when (and js2-in-use-strict-directive - (setq elem-key-string (js2-property-key-string elem)) - (cl-some - (lambda (previous-elem) - (and (setq previous-elem-key-string - (js2-property-key-string previous-elem)) - ;; Check if the property is a duplicate. - (string= previous-elem-key-string elem-key-string) - ;; But make an exception for getter / setter pairs. - (not (and (js2-method-node-p elem) - (js2-method-node-p previous-elem) - (let ((type (js2-node-get-prop (js2-method-node-right elem) 'METHOD_TYPE)) - (previous-type (js2-node-get-prop (js2-method-node-right previous-elem) 'METHOD_TYPE))) - (and (member type '(GET SET)) - (member previous-type '(GET SET)) - (not (eq type previous-type)))))))) - elems)) - (js2-report-error "msg.dup.obj.lit.prop.strict" - elem-key-string - (js2-node-abs-pos (js2-infix-node-left elem)) - (js2-node-len (js2-infix-node-left elem)))) - ;; Append any parsed element. - (push elem elems))) ; end loop - (js2-must-match js2-RC "msg.no.brace.prop") - (nreverse elems))) - -(defun js2-parse-named-prop (tt previous-token &optional class-p) - "Parse a name, string, or getter/setter object property. -When `js2-is-in-destructuring' is t, forms like {a, b, c} will be permitted." - (let ((key (js2-parse-prop-name tt)) - (prop (and previous-token (js2-token-string previous-token))) - (property-type (when previous-token - (if (= (js2-token-type previous-token) js2-MUL) - "*" - (js2-token-string previous-token)))) - pos) - (when (member prop '("get" "set" "async")) - (setq pos (js2-token-beg previous-token)) - (js2-set-face (js2-token-beg previous-token) - (js2-token-end previous-token) - 'font-lock-keyword-face 'record)) ; get/set/async - (cond - ;; method definition: {f() {...}} - ((and (= (js2-peek-token) js2-LP) - (>= js2-language-version 200)) - (when (or (js2-name-node-p key) (js2-string-node-p key)) - ;; highlight function name properties - (js2-record-face 'font-lock-function-name-face)) - (js2-parse-method-prop pos key property-type)) - ;; class field or binding element with initializer - ((and (= (js2-peek-token) js2-ASSIGN) - (>= js2-language-version 200)) - (if (not (or class-p - js2-is-in-destructuring)) - (js2-report-error "msg.init.no.destruct")) - (js2-parse-initialized-binding key)) - ;; regular prop - (t - (let ((beg (js2-current-token-beg)) - (end (js2-current-token-end)) - (expr (js2-parse-plain-property key class-p))) - (when (and (= tt js2-NAME) - (not js2-is-in-destructuring) - js2-highlight-external-variables - (js2-node-get-prop expr 'SHORTHAND)) - (js2-record-name-node key)) - (js2-set-face beg end - (if (js2-function-node-p - (js2-object-prop-node-right expr)) - 'font-lock-function-name-face - 'js2-object-property) - 'record) - expr))))) - -(defun js2-parse-initialized-binding (name) - "Parse a `SingleNameBinding' with initializer. - -`name' is the `BindingIdentifier'." - (when (js2-match-token js2-ASSIGN) - (js2-make-binary js2-ASSIGN name 'js2-parse-assign-expr t))) - -(defun js2-parse-prop-name (tt) - (cond - ;; Literal string keys: {'foo': 'bar'} - ((= tt js2-STRING) - (make-js2-string-node)) - ;; Handle computed keys: {[Symbol.iterator]: ...}, *[1+2]() {...}}, - ;; {[foo + bar]() { ... }}, {[get ['x' + 1]() {...}} - ((and (= tt js2-LB) - (>= js2-language-version 200)) - (make-js2-computed-prop-name-node - :expr (prog1 (js2-parse-assign-expr) - (js2-must-match js2-RB "msg.missing.computed.rb")))) - ;; Numeric keys: {12: 'foo'}, {10.7: 'bar'} - ((= tt js2-NUMBER) - (make-js2-number-node)) - ;; Unquoted names: {foo: 12} - ((= tt js2-NAME) - (js2-create-name-node)) - ;; Anything else is an error - (t (js2-report-error "msg.bad.prop")))) - -(defun js2-parse-plain-property (prop &optional class-p) - "Parse a non-getter/setter property in an object literal. -PROP is the node representing the property: a number, name, -string or expression." - (let* (tt - (pos (js2-node-pos prop)) - colon expr result) - (cond - ;; Abbreviated property, as in {foo, bar} or class {a; b} - ((and (>= js2-language-version 200) - (if class-p - (and (setq tt (js2-peek-token-or-eol)) - (member tt (list js2-EOL js2-RC js2-SEMI))) - (and (setq tt (js2-peek-token)) - (member tt (list js2-COMMA js2-RC)) - (js2-name-node-p prop)))) - (setq result (make-js2-object-prop-node - :pos pos - :len (js2-node-len prop) - :left prop - :right prop - :op-pos (- (js2-current-token-beg) pos))) - (js2-node-add-children result prop) - (js2-node-set-prop result 'SHORTHAND t) - result) - ;; Normal property - (t - (setq tt (js2-get-token)) - (if (= tt js2-COLON) - (setq colon (- (js2-current-token-beg) pos) - expr (js2-parse-assign-expr)) - (js2-report-error "msg.no.colon.prop") - (setq expr (make-js2-error-node))) - (setq result (make-js2-object-prop-node - :pos pos - ;; don't include last consumed token in length - :len (- (+ (js2-node-pos expr) - (js2-node-len expr)) - pos) - :left prop - :right expr - :op-pos colon)) - (js2-node-add-children result prop expr) - result)))) - -(defun js2-parse-method-prop (pos prop type-string) - "Parse method property in an object literal or a class body. -JavaScript syntax is: - - { foo(...) {...}, get foo() {...}, set foo(x) {...}, *foo(...) {...}, - async foo(...) {...} } - -and expression closure style is also supported - - { get foo() x, set foo(x) _x = x } - -POS is the start position of the `get' or `set' keyword, if any. -PROP is the `js2-name-node' representing the property name. -TYPE-STRING is a string `get', `set', `*', or nil, indicating a found keyword." - (let* ((type (or (cdr (assoc type-string '(("get" . GET) - ("set" . SET) - ("async" . ASYNC)))) - 'FUNCTION)) - result end - (pos (or pos (js2-current-token-beg))) - (_ (js2-must-match js2-LP "msg.no.paren.parms")) - (fn (js2-parse-function 'FUNCTION_EXPRESSION pos - (string= type-string "*") - (eq type 'ASYNC) - nil))) - (js2-node-set-prop fn 'METHOD_TYPE type) ; for codegen - (unless pos (setq pos (js2-node-pos prop))) - (setq end (js2-node-end fn) - result (make-js2-method-node :pos pos - :len (- end pos) - :left prop - :right fn)) - (js2-node-add-children result prop fn) - result)) - -(defun js2-create-name-node (&optional check-activation-p token string) - "Create a name node using the current token and, optionally, STRING. -And, if CHECK-ACTIVATION-P is non-nil, use the value of TOKEN." - (let* ((beg (js2-current-token-beg)) - (tt (js2-current-token-type)) - (s (or string - (if (= js2-NAME tt) - (js2-current-token-string) - (js2-tt-name tt)))) - name) - (setq name (make-js2-name-node :pos beg - :name s - :len (length s))) - (if check-activation-p - (js2-check-activation-name s (or token js2-NAME))) - name)) - -;;; Use AST to extract semantic information - -(defun js2-get-element-index-from-array-node (elem array-node &optional hardcoded-array-index) - "Get index of ELEM from ARRAY-NODE or 0 and return it as string." - (let ((idx 0) elems (rlt hardcoded-array-index)) - (setq elems (js2-array-node-elems array-node)) - (if (and elem (not hardcoded-array-index)) - (setq rlt (catch 'nth-elt - (dolist (x elems) - ;; We know the ELEM does belong to ARRAY-NODE, - (if (eq elem x) (throw 'nth-elt idx)) - (setq idx (1+ idx))) - 0))) - (format "[%s]" rlt))) - -(defun js2-print-json-path (&optional hardcoded-array-index) - "Print the path to the JSON value under point, and save it in the kill ring. -If HARDCODED-ARRAY-INDEX provided, array index in JSON path is replaced with it." - (interactive "P") - (js2-reparse) - (let (previous-node current-node - key-name - rlt) - - ;; The `js2-node-at-point' starts scanning from AST root node. - ;; So there is no way to optimize it. - (setq current-node (js2-node-at-point)) - - (while (not (js2-ast-root-p current-node)) - (cond - ;; JSON property node - ((js2-object-prop-node-p current-node) - (setq key-name (js2-prop-node-name (js2-object-prop-node-left current-node))) - (if rlt (setq rlt (concat "." key-name rlt)) - (setq rlt (concat "." key-name)))) - - ;; Array node - ((or (js2-array-node-p current-node)) - (setq rlt (concat (js2-get-element-index-from-array-node previous-node - current-node - hardcoded-array-index) - rlt))) - - ;; Other nodes are ignored - (t)) - - ;; current node is archived - (setq previous-node current-node) - ;; Get parent node and continue the loop - (setq current-node (js2-node-parent current-node))) - - (cond - (rlt - ;; Clean the final result - (setq rlt (replace-regexp-in-string "^\\." "" rlt)) - (kill-new rlt) - (message "%s => kill-ring" rlt)) - (t - (message "No JSON path found!"))) - - rlt)) - -;;; Indentation support (bouncing) - -;; In recent-enough Emacs, we reuse the indentation code from -;; `js-mode'. To continue support for the older versions, some code -;; that was here previously was moved to `js2-old-indent.el'. - -;; Whichever indenter is used, it's often "wrong", however, and needs -;; to be overridden. The right long-term solution is probably to -;; emulate (or integrate with) cc-engine, but it's a nontrivial amount -;; of coding. Even when a parse tree from `js2-parse' is present, -;; which is not true at the moment the user is typing, computing -;; indentation is still thousands of lines of code to handle every -;; possible syntactic edge case. - -;; In the meantime, the compromise solution is that we offer a "bounce -;; indenter", configured with `js2-bounce-indent-p', which cycles the -;; current line indent among various likely guess points. This approach -;; is far from perfect, but should at least make it slightly easier to -;; move the line towards its desired indentation when manually -;; overriding Karl's heuristic nesting guesser. - -(defun js2-backward-sws () - "Move backward through whitespace and comments." - (interactive) - (while (forward-comment -1))) - -(defun js2-forward-sws () - "Move forward through whitespace and comments." - (interactive) - (while (forward-comment 1))) - -(defun js2-arglist-close () - "Return non-nil if we're on a line beginning with a close-paren/brace." - (save-excursion - (goto-char (point-at-bol)) - (js2-forward-sws) - (looking-at "[])}]"))) - -(defun js2-indent-looks-like-label-p () - (goto-char (point-at-bol)) - (js2-forward-sws) - (looking-at (concat js2-mode-identifier-re ":"))) - -(defun js2-indent-in-objlit-p (parse-status) - "Return non-nil if this looks like an object-literal entry." - (let ((start (nth 1 parse-status))) - (and - start - (save-excursion - (and (zerop (forward-line -1)) - (not (< (point) start)) ; crossed a {} boundary - (js2-indent-looks-like-label-p))) - (save-excursion - (js2-indent-looks-like-label-p))))) - -;; If prev line looks like foobar({ then we're passing an object -;; literal to a function call, and people pretty much always want to -;; de-dent back to the previous line, so move the 'basic-offset' -;; position to the front. -(defun js2-indent-objlit-arg-p (parse-status) - (save-excursion - (back-to-indentation) - (js2-backward-sws) - (and (eq (1- (point)) (nth 1 parse-status)) - (eq (char-before) ?{) - (progn - (forward-char -1) - (skip-chars-backward " \t") - (eq (char-before) ?\())))) - -(defun js2-indent-case-block-p () - (save-excursion - (back-to-indentation) - (js2-backward-sws) - (goto-char (point-at-bol)) - (skip-chars-forward " \t") - (looking-at "case\\s-.+:"))) - -(defun js2-bounce-indent (normal-col parse-status &optional backward) - "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. If BACKWARDS, cycle positions -in reverse." - (let ((cur-indent (current-indentation)) - (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 main-pos anchor arglist-cont same-indent - basic-offset computed-pos) - ;; temporarily don't record undo info, if user requested this - (when js2-mode-indent-inhibit-undo - (setq buffer-undo-list t)) - (unwind-protect - (progn - ;; First likely point: indent from beginning of previous code line - (push (setq basic-offset - (+ (save-excursion - (back-to-indentation) - (js2-backward-sws) - (back-to-indentation) - (current-column)) - js2-basic-offset)) - positions) - - ;; (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) - (js2-backward-sws) - (back-to-indentation) - (current-column)) - (* 2 js2-basic-offset))) - positions) - - ;; Second likely point: indent from assign-expr RHS. This - ;; is just a crude guess based on finding " = " on the previous - ;; line containing actual code. - (setq pos (save-excursion - (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 - (cl-incf pos js2-basic-offset) - (push pos positions)) - - ;; Third likely point: same indent as previous line of code. - ;; Make it the first likely point if we're not on an - ;; arglist-close line and previous line ends in a comma, or - ;; both this line and prev line look like object-literal - ;; elements. - (setq pos (save-excursion - (goto-char (point-at-bol)) - (js2-backward-sws) - (back-to-indentation) - (prog1 - (current-column) - ;; while we're here, look for trailing comma - (if (save-excursion - (goto-char (point-at-eol)) - (js2-backward-sws) - (eq (char-before) ?,)) - (setq arglist-cont (1- (point))))))) - (when pos - (if (and (or arglist-cont - (js2-indent-in-objlit-p parse-status)) - (not (js2-arglist-close))) - (setq same-indent pos)) - (push pos positions)) - - ;; 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)) - (while (and (zerop (forward-line -1)) - (>= (progn - (back-to-indentation) - (current-column)) - anchor))) - (setq pos (current-column)))) - (push pos positions) - - ;; nesting-heuristic position, main by default - (push (setq main-pos 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 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 main-pos basic-offset)) - - ;; if bouncing backward, reverse positions list - (if backward - (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). - ((and js2-mode-indent-ignore-first-tab - pos - ;; first time pressing TAB on this line? - (not (eq js2-mode-last-indented-line current-line))) - ;; do nothing - (setq computed-pos nil)) - ;; case 1: only one computed position => use it - ((null (cdr positions)) - (setq computed-pos 0)) - ;; case 2: not on any of the computed spots => use main spot - ((not pos) - (setq computed-pos (js2-position main-pos positions))) - ;; case 3: on last position: cycle to first position - ((null (cdr pos)) - (setq computed-pos 0)) - ;; case 4: on intermediate position: cycle to next position - (t - (setq computed-pos (js2-position (cl-second pos) positions)))) - - ;; see if any hooks want to indent; otherwise we do it - (cl-loop with result = nil - for hook in js2-indent-hook - while (null result) - do - (setq result (funcall hook positions computed-pos)) - finally do - (unless (or result (null computed-pos)) - (indent-line-to (nth computed-pos positions))))) - - ;; finally - (if js2-mode-indent-inhibit-undo - (setq buffer-undo-list old-buffer-undo-list)) - ;; see commentary for `js2-mode-last-indented-line' - (setq js2-mode-last-indented-line current-line)))) - -(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 - (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-bounce (&optional backward) - "Indent the current line, bouncing between several positions." - (interactive) - (let (parse-status offset indent-col - ;; 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 - (syntax-ppss (point-at-bol))) - offset (- (point) (save-excursion - (back-to-indentation) - (point)))) - ;; Don't touch multiline strings. - (unless (nth 3 parse-status) - (setq indent-col (js2-proper-indentation parse-status)) - (cond - ;; It doesn't work well on first line of buffer. - ((and (not (nth 4 parse-status)) - (not (js2-same-line (point-min))) - (not (js2-1-line-comment-continuation-p))) - (js2-bounce-indent indent-col parse-status backward)) - ;; just indent to the guesser's likely spot - (t (indent-line-to indent-col))) - (when (cl-plusp offset) - (forward-char offset))))) - -(defun js2-indent-bounce-backward () - "Indent the current line, bouncing between positions in reverse." - (interactive) - (js2-indent-bounce t)) - -(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) - (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) - map) - "Keymap used when `js2-minor-mode' is active.") - -;;;###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 `js-mode', while retaining the asynchronous error/warning -highlighting features of `js2-mode'." - :group 'js2-mode - :lighter " js-lint" - (if (derived-mode-p 'js2-mode) - (setq js2-minor-mode nil) - (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) - ;; Experiment: make reparse-delay longer for longer files. - (if (cl-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) - (when js2-include-jslint-globals - (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t)) - (when js2-include-jslint-declaration-externs - (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs nil t)) - (run-hooks 'js2-init-hook) - (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) - (remove-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals t) - (remove-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs t) - (setq js2-mode-ast nil)) - -(defvar js2-source-buffer nil "Linked source buffer for diagnostics view") -(make-variable-buffer-local 'js2-source-buffer) - -(cl-defun js2-display-error-list () - "Display a navigable buffer listing parse errors/warnings." - (interactive) - (unless (js2-have-errors-p) - (message "No errors") - (cl-return-from js2-display-error-list)) - (cl-labels ((annotate-list - (lst type) - "Add diagnostic TYPE and line number to errs list" - (mapcar (lambda (err) - (list err 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) (< (cl-cadar e1) (cl-cadar e2)))))) - (with-current-buffer errbuf - (let ((inhibit-read-only t)) - (erase-buffer) - (dolist (err all-errs) - (cl-destructuring-bind ((msg-key beg _end &rest) 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 -(define-derived-mode js2-mode js-mode "Javascript-IDE" - "Major mode for editing JavaScript code." - (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) - (set (make-local-variable 'syntax-propertize-function) nil) - (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 - ;; for characters inside regexp literals. - (set (make-local-variable 'parse-sexp-lookup-properties) t) - ;; this is necessary to make `show-paren-function' work properly - (set (make-local-variable 'parse-sexp-ignore-comments) t) - ;; needed for M-x rgrep, among other things - (put 'js2-mode 'find-tag-default-function #'js2-mode-find-tag) - - (setq font-lock-defaults '(nil t)) - - ;; Experiment: make reparse-delay longer for longer files. - (when (cl-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)) - (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) - (when (fboundp 'cursor-sensor-mode) (cursor-sensor-mode 1)) - - (setq js2-mode-functions-hidden nil - js2-mode-comments-hidden nil - js2-mode-buffer-dirty-p t - js2-mode-parsing nil) - - (when js2-include-jslint-globals - (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t)) - (when js2-include-jslint-declaration-externs - (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs nil t)) - - (run-hooks 'js2-init-hook) - - (let ((js2-idle-timer-delay 0)) - ;; Schedule parsing for after when the mode hooks run. - (js2-mode-reset-timer))) - -;; We may eventually want js2-jsx-mode to derive from js-jsx-mode, but that'd be -;; a bit more complicated and it doesn't net us much yet. -;;;###autoload -(define-derived-mode js2-jsx-mode js2-mode "JSX-IDE" - "Major mode for editing JSX code. - -To customize the indentation for this mode, set the SGML offset -variables (`sgml-basic-offset' et al) locally, like so: - - (defun set-jsx-indentation () - (setq-local sgml-basic-offset js2-basic-offset)) - (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation)" - (set (make-local-variable 'indent-line-function) #'js2-jsx-indent-line)) - -(defun js2-mode-exit () - "Exit `js2-mode' and clean up." - (interactive) - (when js2-mode-node-overlay - (delete-overlay js2-mode-node-overlay) - (setq js2-mode-node-overlay nil)) - (js2-remove-overlays) - (setq js2-mode-ast nil) - (remove-hook 'change-major-mode-hook #'js2-mode-exit t) - (remove-from-invisibility-spec '(js2-outline . t)) - (js2-mode-show-all) - (with-silent-modifications - (js2-clear-face (point-min) (point-max)))) - -(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) - (let ((timer (timer-create))) - (setq js2-mode-parse-timer timer) - (timer-set-function timer 'js2-mode-idle-reparse (list (current-buffer))) - (timer-set-idle-time timer js2-idle-timer-delay) - ;; http://debbugs.gnu.org/cgi/bugreport.cgi?bug=12326 - (timer-activate-when-idle timer nil))) - -(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." - (cond ((eq buffer (current-buffer)) - (js2-reparse)) - ((buffer-live-p buffer) - ;; 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." - (setq js2-mode-buffer-dirty-p t) - (js2-mode-hide-overlay) - (js2-mode-reset-timer)) - -(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. -If we get any user input while parsing, including cursor motion, -we discard the parse and reschedule it. If FORCE is nil, then the -buffer will only rebuild its `js2-mode-ast' if the buffer is dirty." - (let (time - interrupted-p - (js2-compiler-strict-mode js2-mode-show-strict-warnings)) - (unless js2-mode-parsing - (setq js2-mode-parsing t) - (unwind-protect - (when (or js2-mode-buffer-dirty-p force) - (js2-remove-overlays) - (setq js2-mode-buffer-dirty-p nil - js2-mode-fontifications nil - js2-mode-deferred-properties nil) - (if js2-mode-verbose-parse-p - (message "parsing...")) - (setq time - (js2-time - (setq interrupted-p - (catch 'interrupted - (js2-parse) - (with-silent-modifications - ;; if parsing is interrupted, comments and regex - ;; literals stay ignored by `parse-partial-sexp' - (remove-text-properties (point-min) (point-max) - '(syntax-table)) - (js2-mode-apply-deferred-properties) - (js2-mode-remove-suppressed-warnings) - (js2-mode-show-warnings) - (js2-mode-show-errors) - (if (>= js2-highlight-level 1) - (js2-highlight-jsdoc js2-mode-ast))) - nil)))) - (if interrupted-p - (progn - ;; unfinished parse => try again - (setq js2-mode-buffer-dirty-p t) - (js2-mode-reset-timer)) - (if js2-mode-verbose-parse-p - (message "Parse time: %s" time)))) - (setq js2-mode-parsing nil) - (unless interrupted-p - (setq js2-mode-parse-timer nil)))))) - -;; We bound it to [mouse-1] previously. But the signature of -;; mouse-set-point changed around 24.4, so it's kind of hard to keep -;; it working in 24.1-24.3. Since the command is not hugely -;; important, we removed the binding (#356). Maybe we'll bring it -;; back when supporting <24.4 is not a goal anymore. -(defun js2-mode-show-node (event &optional promote-to-region) - "Debugging aid: highlight selected AST node on mouse click." - (interactive "e\np") - (mouse-set-point event promote-to-region) - (when js2-mode-show-overlay - (let ((node (js2-node-at-point)) - beg end) - (if (null node) - (message "No node found at location %s" (point)) - (setq beg (js2-node-abs-pos node) - end (+ beg (js2-node-len node))) - (if js2-mode-node-overlay - (move-overlay js2-mode-node-overlay beg end) - (setq js2-mode-node-overlay (make-overlay beg end)) - (overlay-put js2-mode-node-overlay 'font-lock-face 'highlight)) - (with-silent-modifications - (if (fboundp 'cursor-sensor-mode) - (put-text-property beg end 'cursor-sensor-functions - '(js2-mode-hide-overlay)) - (put-text-property beg end 'point-left #'js2-mode-hide-overlay))) - (message "%s, parent: %s" - (js2-node-short-name node) - (if (js2-node-parent node) - (js2-node-short-name (js2-node-parent node)) - "nil")))))) - -(defun js2-mode-hide-overlay (&optional arg1 arg2 _arg3) - "Remove the debugging overlay when point moves. -ARG1, ARG2 and ARG3 have different values depending on whether this function -was found on `point-left' or in `cursor-sensor-functions'." - (when js2-mode-node-overlay - (let ((beg (overlay-start js2-mode-node-overlay)) - (end (overlay-end js2-mode-node-overlay)) - (p2 (if (windowp arg1) - ;; Called from cursor-sensor-functions. - (window-point arg1) - ;; Called from point-left. - arg2))) - ;; Sometimes we're called spuriously. - (unless (and p2 - (>= p2 beg) - (<= p2 end)) - (with-silent-modifications - (remove-text-properties beg end - '(point-left nil cursor-sensor-functions))) - (delete-overlay js2-mode-node-overlay) - (setq js2-mode-node-overlay nil))))) - -(defun js2-mode-reset () - "Debugging helper: reset everything." - (interactive) - (js2-mode-exit) - (js2-mode)) - -(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 LEN OVERRIDE-FACE). -The last element is optional. When present, use instead of FACE." - (let* ((key (cl-first e)) - (beg (cl-second e)) - (end (+ beg (cl-third e))) - ;; Don't inadvertently go out of bounds. - (beg (max (point-min) (min beg (point-max)))) - (end (max (point-min) (min end (point-max)))) - (ovl (make-overlay beg end))) - ;; FIXME: Why a mix of overlays and text-properties? - (overlay-put ovl 'font-lock-face (or (cl-fourth e) face)) - (overlay-put ovl 'js2-error t) - (put-text-property beg end 'help-echo (js2-get-msg key)) - (if (fboundp 'cursor-sensor-mode) - (put-text-property beg end 'cursor-sensor-functions '(js2-echo-error)) - (put-text-property beg end 'point-entered #'js2-echo-error)))) - -(defun js2-remove-overlays () - "Remove overlays from buffer that have a `js2-error' property." - (let ((beg (point-min)) - (end (point-max))) - (save-excursion - (dolist (o (overlays-in beg end)) - (when (overlay-get o 'js2-error) - (delete-overlay o)))))) - -(defun js2-mode-apply-deferred-properties () - "Apply fontifications and other text properties recorded during parsing." - (when (cl-plusp js2-highlight-level) - ;; We defer clearing faces as long as possible to eliminate flashing. - (js2-clear-face (point-min) (point-max)) - ;; 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 (cl-first f) (cl-second f) 'font-lock-face (cl-third f))) - (setq js2-mode-fontifications nil)) - (dolist (p js2-mode-deferred-properties) - (apply #'put-text-property p)) - (setq js2-mode-deferred-properties nil)) - -(defun js2-mode-show-errors () - "Highlight syntax errors." - (when js2-mode-show-parse-errors - (dolist (e (js2-ast-root-errors js2-mode-ast)) - (js2-mode-show-warn-or-err e 'js2-error)))) - -(defun js2-mode-remove-suppressed-warnings () - "Take suppressed warnings out of the AST warnings list. -This ensures that the counts and `next-error' are correct." - (setf (js2-ast-root-warnings js2-mode-ast) - (js2-delete-if - (lambda (e) - (let ((key (caar e))) - (or - (and (not js2-strict-trailing-comma-warning) - (string-match "trailing\\.comma" key)) - (and (not js2-strict-cond-assign-warning) - (string= key "msg.equal.as.assign")) - (and js2-missing-semi-one-line-override - (string= key "msg.missing.semi") - (let* ((beg (cl-second e)) - (node (js2-node-at-point beg)) - (fn (js2-mode-find-parent-fn node)) - (body (and fn (js2-function-node-body fn))) - (lc (and body (js2-node-abs-pos body))) - (rc (and lc (+ lc (js2-node-len body))))) - (and fn - (or (null body) - (save-excursion - (goto-char beg) - (and (js2-same-line lc) - (js2-same-line rc)))))))))) - (js2-ast-root-warnings js2-mode-ast)))) - -(defun js2-mode-show-warnings () - "Highlight strict-mode warnings." - (when js2-mode-show-strict-warnings - (dolist (e (js2-ast-root-warnings js2-mode-ast)) - (js2-mode-show-warn-or-err e 'js2-warning)))) - -(defun js2-echo-error (arg1 arg2 &optional _arg3) - "Called by point-motion hooks. -ARG1, ARG2 and ARG3 have different values depending on whether this function -was found on `point-entered' or in `cursor-sensor-functions'." - (let* ((new-point (if (windowp arg1) - ;; Called from cursor-sensor-functions. - (window-point arg1) - ;; Called from point-left. - arg2)) - (msg (get-text-property new-point 'help-echo))) - (when (and (stringp msg) - (not (active-minibuffer-window)) - (not (current-message))) - (message msg)))) - -(defun js2-line-break (&optional _soft) - "Break line at point and indent, continuing comment if within one. -If inside a string, and `js2-concat-multiline-strings' is not -nil, turn it into concatenation." - (interactive) - (let ((parse-status (syntax-ppss))) - (cond - ;; Check if we're inside a string. - ((nth 3 parse-status) - (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 (nth 8 parse-status))) - (t - (newline-and-indent))))) - -(defun js2-mode-split-string (parse-status) - "Turn a newline in mid-string into a string concatenation. -PARSE-STATUS is as documented in `parse-partial-sexp'." - (let* ((quote-char (nth 3 parse-status)) - (at-eol (eq js2-concat-multiline-strings 'eol))) - (insert quote-char) - (insert (if at-eol " +\n" "\n")) - (unless at-eol - (insert "+ ")) - (js2-indent-line) - (insert quote-char) - (when (eolp) - (insert quote-char) - (backward-char 1)))) - -(defun js2-mode-extend-comment (start-pos) - "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) - (when (< (point) start-pos) - (goto-char start-pos)) - (cond - ((looking-at "\\*[^/]") - (setq star t - col (current-column))) - ((looking-at "/\\*") - (setq star t - first-line t - col (1+ (current-column)))) - ((looking-at "//") - (setq single t - col (current-column))))) - ;; Heuristic for whether we need to close the comment: - ;; if we've got a parse error here, assume it's an unterminated - ;; comment. - (setq needs-close - (or - (get-char-property (1- (point)) 'js2-error) - ;; The heuristic above doesn't work well when we're - ;; creating a comment and there's another one downstream, - ;; as our parser thinks this one ends at the end of the - ;; next one. (You can have a /* inside a js block comment.) - ;; So just close it if the next non-ws char isn't a *. - (and first-line - (eolp) - (save-excursion - (skip-chars-forward " \t\r\n") - (not (eq (char-after) ?*)))))) - (delete-horizontal-space) - (insert "\n") - (cond - (star - (indent-to col) - (insert "* ") - (if (and first-line needs-close) - (save-excursion - (insert "\n") - (indent-to col) - (insert "*/")))) - (single - (indent-to col) - (insert "// "))) - ;; Don't need to extend the comment after all. - (js2-indent-line))) - -(defun js2-beginning-of-line () - "Toggle point between bol and first non-whitespace char in line. -Also moves past comment delimiters when inside comments." - (interactive) - (let (node) - (cond - ((bolp) - (back-to-indentation)) - ((looking-at "//") - (skip-chars-forward "/ \t")) - ((and (eq (char-after) ?*) - (setq node (js2-comment-at-point)) - (memq (js2-comment-node-format node) '(jsdoc block)) - (save-excursion - (skip-chars-backward " \t") - (bolp))) - (skip-chars-forward "\* \t")) - (t - (goto-char (point-at-bol)))))) - -(defun js2-end-of-line () - "Toggle point between eol and last non-whitespace char in line." - (interactive) - (if (eolp) - (skip-chars-backward " \t") - (goto-char (point-at-eol)))) - -(defun js2-mode-wait-for-parse (callback) - "Invoke CALLBACK when parsing is finished. -If parsing is already finished, calls CALLBACK immediately." - (if (not js2-mode-buffer-dirty-p) - (funcall callback) - (push callback js2-mode-pending-parse-callbacks) - (add-hook 'js2-parse-finished-hook #'js2-mode-parse-finished))) - -(defun js2-mode-parse-finished () - "Invoke callbacks in `js2-mode-pending-parse-callbacks'." - ;; We can't let errors propagate up, since it prevents the - ;; `js2-parse' method from completing normally and returning - ;; the ast, which makes things mysteriously not work right. - (unwind-protect - (dolist (cb js2-mode-pending-parse-callbacks) - (condition-case err - (funcall cb) - (error (message "%s" err)))) - (setq js2-mode-pending-parse-callbacks nil))) - -(defun js2-mode-flag-region (from to flag) - "Hide or show text from FROM to TO, according to FLAG. -If FLAG is nil then text is shown, while if FLAG is t the text is hidden. -Returns the created overlay if FLAG is non-nil." - (remove-overlays from to 'invisible 'js2-outline) - (when flag - (let ((o (make-overlay from to))) - (overlay-put o 'invisible 'js2-outline) - (overlay-put o 'isearch-open-invisible - 'js2-isearch-open-invisible) - o))) - -;; Function to be set as an outline-isearch-open-invisible' property -;; to the overlay that makes the outline invisible (see -;; `js2-mode-flag-region'). -(defun js2-isearch-open-invisible (_overlay) - ;; We rely on the fact that isearch places point on the matched text. - (js2-mode-show-element)) - -(defun js2-mode-invisible-overlay-bounds (&optional pos) - "Return cons cell of bounds of folding overlay at POS. -Returns nil if not found." - (let ((overlays (overlays-at (or pos (point)))) - o) - (while (and overlays - (not o)) - (if (overlay-get (car overlays) 'invisible) - (setq o (car overlays)) - (setq overlays (cdr overlays)))) - (if o - (cons (overlay-start o) (overlay-end o))))) - -(defun js2-mode-function-at-point (&optional pos) - "Return the innermost function node enclosing current point. -Returns nil if point is not in a function." - (let ((node (js2-node-at-point pos))) - (while (and node (not (js2-function-node-p node))) - (setq node (js2-node-parent node))) - (if (js2-function-node-p node) - node))) - -(defun js2-mode-toggle-element () - "Hide or show the foldable element at the point." - (interactive) - (let (comment fn pos) - (save-excursion - (cond - ;; /* ... */ comment? - ((js2-block-comment-p (setq comment (js2-comment-at-point))) - (if (js2-mode-invisible-overlay-bounds - (setq pos (+ 3 (js2-node-abs-pos comment)))) - (progn - (goto-char pos) - (js2-mode-show-element)) - (js2-mode-hide-element))) - ;; //-comment? - ((save-excursion - (back-to-indentation) - (looking-at js2-mode-//-comment-re)) - (js2-mode-toggle-//-comment)) - ;; function? - ((setq fn (js2-mode-function-at-point)) - (setq pos (and (js2-function-node-body fn) - (js2-node-abs-pos (js2-function-node-body fn)))) - (goto-char (1+ pos)) - (if (js2-mode-invisible-overlay-bounds) - (js2-mode-show-element) - (js2-mode-hide-element))) - (t - (message "Nothing at point to hide or show")))))) - -(defun js2-mode-hide-element () - "Fold/hide contents of a block, showing ellipses. -Show the hidden text with \\[js2-mode-show-element]." - (interactive) - (if js2-mode-buffer-dirty-p - (js2-mode-wait-for-parse #'js2-mode-hide-element)) - (let (node body beg end) - (cond - ((js2-mode-invisible-overlay-bounds) - (message "already hidden")) - (t - (setq node (js2-node-at-point)) - (cond - ((js2-block-comment-p node) - (js2-mode-hide-comment node)) - (t - (while (and node (not (js2-function-node-p node))) - (setq node (js2-node-parent node))) - (if (and node - (setq body (js2-function-node-body node))) - (progn - (setq beg (js2-node-abs-pos body) - end (+ beg (js2-node-len body))) - (js2-mode-flag-region (1+ beg) (1- end) 'hide)) - (message "No collapsable element found at point")))))))) - -(defun js2-mode-show-element () - "Show the hidden element at current point." - (interactive) - (let ((bounds (js2-mode-invisible-overlay-bounds))) - (if bounds - (js2-mode-flag-region (car bounds) (cdr bounds) nil) - (message "Nothing to un-hide")))) - -(defun js2-mode-show-all () - "Show all of the text in the buffer." - (interactive) - (js2-mode-flag-region (point-min) (point-max) nil)) - -(defun js2-mode-toggle-hide-functions () - (interactive) - (if js2-mode-functions-hidden - (js2-mode-show-functions) - (js2-mode-hide-functions))) - -(defun js2-mode-hide-functions () - "Hides all non-nested function bodies in the buffer. -Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element] -to open an individual entry." - (interactive) - (if js2-mode-buffer-dirty-p - (js2-mode-wait-for-parse #'js2-mode-hide-functions)) - (if (null js2-mode-ast) - (message "Oops - parsing failed") - (setq js2-mode-functions-hidden t) - (js2-visit-ast js2-mode-ast #'js2-mode-function-hider))) - -(defun js2-mode-function-hider (n endp) - (when (not endp) - (let ((tt (js2-node-type n)) - body beg end) - (cond - ((and (= tt js2-FUNCTION) - (setq body (js2-function-node-body n))) - (setq beg (js2-node-abs-pos body) - end (+ beg (js2-node-len body))) - (js2-mode-flag-region (1+ beg) (1- end) 'hide) - nil) ; don't process children of function - (t - t))))) ; keep processing other AST nodes - -(defun js2-mode-show-functions () - "Un-hide any folded function bodies in the buffer." - (interactive) - (setq js2-mode-functions-hidden nil) - (save-excursion - (goto-char (point-min)) - (while (/= (goto-char (next-overlay-change (point))) - (point-max)) - (dolist (o (overlays-at (point))) - (when (and (overlay-get o 'invisible) - (not (overlay-get o 'comment))) - (js2-mode-flag-region (overlay-start o) (overlay-end o) nil)))))) - -(defun js2-mode-hide-comment (n) - (let* ((head (if (eq (js2-comment-node-format n) 'jsdoc) - 3 ; /** - 2)) ; /* - (beg (+ (js2-node-abs-pos n) head)) - (end (- (+ beg (js2-node-len n)) head 2)) - (o (js2-mode-flag-region beg end 'hide))) - (overlay-put o 'comment t))) - -(defun js2-mode-toggle-hide-comments () - "Folds all block comments in the buffer. -Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element] -to open an individual entry." - (interactive) - (if js2-mode-comments-hidden - (js2-mode-show-comments) - (js2-mode-hide-comments))) - -(defun js2-mode-hide-comments () - (interactive) - (if js2-mode-buffer-dirty-p - (js2-mode-wait-for-parse #'js2-mode-hide-comments)) - (if (null js2-mode-ast) - (message "Oops - parsing failed") - (setq js2-mode-comments-hidden t) - (dolist (n (js2-ast-root-comments js2-mode-ast)) - (when (js2-block-comment-p n) - (js2-mode-hide-comment n))) - (js2-mode-hide-//-comments))) - -(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. -Returns the end-of-line position of the furthest adjacent -//-comment line with the same indentation as the current line. -If there is no such matching line, returns current end of line." - (let ((pos (point-at-eol)) - (indent (current-indentation))) - (save-excursion - (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 - (goto-char (point-min)) - (while (re-search-forward js2-mode-//-comment-re nil t) - (setq beg (point) - end (js2-mode-extend-//-comment 1)) - (unless (eq beg end) - (overlay-put (js2-mode-flag-region beg end 'hide) - 'comment t)) - (goto-char end) - (forward-char 1))))) - -(defun js2-mode-toggle-//-comment () - "Fold or un-fold any multi-line //-comment at point. -Caller should have determined that this line starts with a //-comment." - (let* ((beg (point-at-eol)) - (end beg)) - (save-excursion - (goto-char end) - (if (js2-mode-invisible-overlay-bounds) - (js2-mode-show-element) - ;; else hide the comment - (setq beg (js2-mode-extend-//-comment -1) - end (js2-mode-extend-//-comment 1)) - (unless (eq beg end) - (overlay-put (js2-mode-flag-region beg end 'hide) - 'comment t)))))) - -(defun js2-mode-show-comments () - "Un-hide any hidden comments, leaving other hidden elements alone." - (interactive) - (setq js2-mode-comments-hidden nil) - (save-excursion - (goto-char (point-min)) - (while (/= (goto-char (next-overlay-change (point))) - (point-max)) - (dolist (o (overlays-at (point))) - (when (overlay-get o 'comment) - (js2-mode-flag-region (overlay-start o) (overlay-end o) nil)))))) - -(defun js2-mode-display-warnings-and-errors () - "Turn on display of warnings and errors." - (interactive) - (setq js2-mode-show-parse-errors t - js2-mode-show-strict-warnings t) - (js2-reparse 'force)) - -(defun js2-mode-hide-warnings-and-errors () - "Turn off display of warnings and errors." - (interactive) - (setq js2-mode-show-parse-errors nil - js2-mode-show-strict-warnings nil) - (js2-reparse 'force)) - -(defun js2-mode-toggle-warnings-and-errors () - "Toggle the display of warnings and errors. -Some users don't like having warnings/errors reported while they type." - (interactive) - (setq js2-mode-show-parse-errors (not js2-mode-show-parse-errors) - js2-mode-show-strict-warnings (not js2-mode-show-strict-warnings)) - (if (called-interactively-p 'any) - (message "warnings and errors %s" - (if js2-mode-show-parse-errors - "enabled" - "disabled"))) - (js2-reparse 'force)) - -(defun js2-mode-customize () - (interactive) - (customize-group 'js2-mode)) - -(defun js2-mode-forward-sexp (&optional arg) - "Move forward across one statement or balanced expression. -With ARG, do it that many times. Negative arg -N means -move backward across N balanced expressions." - (interactive "p") - (setq arg (or arg 1)) - (save-restriction - (widen) ;; `blink-matching-open' calls `narrow-to-region' - (js2-reparse) - (let (forward-sexp-function - node (start (point)) pos lp rp child) - (cond - ((js2-string-node-p (js2-node-at-point)) - (forward-sexp arg)) - ;; backward-sexp - ;; could probably make this better for some cases: - ;; - if in statement block (e.g. function body), go to parent - ;; - infix exprs like (foo in bar) - maybe go to beginning - ;; of infix expr if in the right-side expression? - ((and arg (cl-minusp arg)) - (dotimes (_ (- arg)) - (js2-backward-sws) - (forward-char -1) ; Enter the node we backed up to. - (when (setq node (js2-node-at-point (point) t)) - (setq pos (js2-node-abs-pos node)) - (let ((parens (js2-mode-forward-sexp-parens node pos))) - (setq lp (car parens) - rp (cdr parens))) - (when (and lp (> start lp)) - (if (and rp (<= start rp)) - ;; Between parens, check if there's a child node we can jump. - (when (setq child (js2-node-closest-child node (point) lp t)) - (setq pos (js2-node-abs-pos child))) - ;; Before both parens. - (setq pos lp))) - (let ((state (parse-partial-sexp start pos))) - (goto-char (if (not (zerop (car state))) - ;; Stumble at the unbalanced paren if < 0, or - ;; jump a bit further if > 0. - (scan-sexps start -1) - pos)))) - (unless pos (goto-char (point-min))))) - (t - ;; forward-sexp - (dotimes (_ arg) - (js2-forward-sws) - (when (setq node (js2-node-at-point (point) t)) - (setq pos (js2-node-abs-pos node)) - (let ((parens (js2-mode-forward-sexp-parens node pos))) - (setq lp (car parens) - rp (cdr parens))) - (or - (when (and rp (<= start rp)) - (if (> start lp) - (when (setq child (js2-node-closest-child node (point) rp)) - (setq pos (js2-node-abs-end child))) - (setq pos (1+ rp)))) - ;; No parens or child nodes, looks for the end of the current node. - (cl-incf pos (js2-node-len - (if (js2-expr-stmt-node-p (js2-node-parent node)) - ;; Stop after the semicolon. - (js2-node-parent node) - node)))) - (let ((state (save-excursion (parse-partial-sexp start pos)))) - (goto-char (if (not (zerop (car state))) - (scan-sexps start 1) - pos)))) - (unless pos (goto-char (point-max))))))))) - -(defun js2-mode-forward-sexp-parens (node abs-pos) - "Return a cons cell with positions of main parens in NODE." - (cond - ((or (js2-array-node-p node) - (js2-object-node-p node) - (js2-comp-node-p node) - (memq (aref node 0) '(cl-struct-js2-block-node cl-struct-js2-scope))) - (cons abs-pos (+ abs-pos (js2-node-len node) -1))) - ((js2-paren-expr-node-p node) - (let ((lp (js2-node-lp node)) - (rp (js2-node-rp node))) - (cons (when lp (+ abs-pos lp)) - (when rp (+ abs-pos rp))))))) - -(defun js2-node-closest-child (parent point limit &optional before) - (let* ((parent-pos (js2-node-abs-pos parent)) - (rpoint (- point parent-pos)) - (rlimit (- limit parent-pos)) - (min (min rpoint rlimit)) - (max (max rpoint rlimit)) - found) - (catch 'done - (js2-visit-ast - parent - (lambda (node _end-p) - (if (eq node parent) - t - (let ((pos (js2-node-pos node)) ;; Both relative values. - (end (+ (js2-node-pos node) (js2-node-len node)))) - (when (and (>= pos min) (<= end max) - (if before (< pos rpoint) (> end rpoint))) - (setq found node)) - (when (> end rpoint) - (throw 'done nil))) - nil)))) - found)) - -(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 (not (or (js2-errors) (js2-warnings))) - (message "No errors") - (when reset - (goto-char (point-min))) - (let* ((errs (js2-errors-and-warnings)) - (continue t) - (start (point)) - (count (or arg 1)) - (backward (cl-minusp count)) - (sorter (if backward '> '<)) - (stopper (if backward '< '>)) - (count (abs count)) - all-errs err) - ;; Sort by start position. - (setq errs (sort errs (lambda (e1 e2) - (funcall sorter (cl-second e1) (cl-second e2)))) - all-errs errs) - ;; Find nth error with pos > start. - (while (and errs continue) - (when (funcall stopper (cl-cadar errs) start) - (setq err (car errs)) - (if (zerop (cl-decf count)) - (setq continue nil))) - (setq errs (cdr errs))) - ;; Clear for `js2-echo-error'. - (message nil) - (if err - (goto-char (cl-second err)) - ;; Wrap around to first error. - (goto-char (cl-second (car all-errs))) - ;; If we were already on it, echo msg again. - (if (= (point) start) - (js2-echo-error (point) (point))))))) - -(defun js2-down-mouse-3 () - "Make right-click move the point to the click location. -This makes right-click context menu operations a bit more intuitive. -The point will not move if the region is active, however, to avoid -destroying the region selection." - (interactive) - (when (and js2-move-point-on-right-click - (not mark-active)) - (let ((e last-input-event)) - (ignore-errors - (goto-char (cl-cadadr e)))))) - -(defun js2-mode-create-imenu-index () - "Returns an alist for `imenu--index-alist'. Returns nil on first -scan if buffer size > `imenu-auto-rescan-maxout'." - (when (and (not js2-mode-ast) - (<= (buffer-size) imenu-auto-rescan-maxout)) - (js2-reparse)) - (when js2-mode-ast - ;; if we have an ast but no recorder, they're requesting a rescan - (unless js2-imenu-recorder - (js2-reparse 'force)) - (prog1 - (js2-build-imenu-index) - (setq js2-imenu-recorder nil - js2-imenu-function-map nil)))) - -(defun js2-mode-find-tag () - "Replacement for `find-tag-default'. -`find-tag-default' returns a ridiculous answer inside comments." - (let (beg end) - (save-excursion - (if (looking-at "\\_>") - (setq beg (progn (forward-symbol -1) (point)) - end (progn (forward-symbol 1) (point))) - (setq beg (progn (forward-symbol 1) (point)) - end (progn (forward-symbol -1) (point)))) - (replace-regexp-in-string - "[\"']" "" - (buffer-substring-no-properties beg end))))) - -(defun js2-mode-forward-sibling () - "Move to the end of the sibling following point in parent. -Returns non-nil if successful, or nil if there was no following sibling." - (let* ((node (js2-node-at-point)) - (parent (js2-mode-find-enclosing-fn node)) - sib) - (when (setq sib (js2-node-find-child-after (point) parent)) - (goto-char (+ (js2-node-abs-pos sib) - (js2-node-len sib)))))) - -(defun js2-mode-backward-sibling () - "Move to the beginning of the sibling node preceding point in parent. -Parent is defined as the enclosing script or function." - (let* ((node (js2-node-at-point)) - (parent (js2-mode-find-enclosing-fn node)) - sib) - (when (setq sib (js2-node-find-child-before (point) parent)) - (goto-char (js2-node-abs-pos sib))))) - -(defun js2-beginning-of-defun (&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 (cl-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) - (js2-beginning-of-defun (if (>= arg -1) 1 (1+ arg)))))) - -(defun js2-end-of-defun () - "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. -The function marked is the one that contains point. - -Interactively, if this command is repeated, -or (in Transient Mark mode) if the mark is active, -it marks the next defun after the ones already marked." - (interactive "p") - (let (extended) - (when (and allow-extend - (or (and (eq last-command this-command) (mark t)) - (and transient-mark-mode mark-active))) - (let ((sib (save-excursion - (goto-char (mark)) - (if (js2-mode-forward-sibling) - (point))))) - (if sib - (progn - (set-mark sib) - (setq extended t)) - ;; no more siblings - try extending to enclosing node - (goto-char (mark t))))) - (when (not extended) - (let ((node (js2-node-at-point (point) t)) ; skip comments - ast fn stmt parent beg end) - (when (js2-ast-root-p node) - (setq ast node - node (or (js2-node-find-child-after (point) node) - (js2-node-find-child-before (point) node)))) - ;; only mark whole buffer if we can't find any children - (if (null node) - (setq node ast)) - (if (js2-function-node-p node) - (setq parent node) - (setq fn (js2-mode-find-enclosing-fn node) - stmt (if (or (null fn) - (js2-ast-root-p fn)) - (js2-mode-find-first-stmt node)) - parent (or stmt fn))) - (setq beg (js2-node-abs-pos parent) - end (+ beg (js2-node-len parent))) - (push-mark beg) - (goto-char end) - (exchange-point-and-mark))))) - -(defun js2-narrow-to-defun () - "Narrow to the function enclosing point." - (interactive) - (let* ((node (js2-node-at-point (point) t)) ; skip comments - (fn (if (js2-script-node-p node) - node - (js2-mode-find-enclosing-fn node))) - (beg (js2-node-abs-pos fn))) - (unless (js2-ast-root-p fn) - (narrow-to-region beg (+ beg (js2-node-len fn)))))) - -(defun js2-jump-to-definition (&optional arg) - "Jump to the definition of an object's property, variable or function." - (interactive "P") - (if (eval-when-compile (fboundp 'xref-push-marker-stack)) - (xref-push-marker-stack) - (ring-insert find-tag-marker-ring (point-marker))) - (js2-reparse) - (let* ((node (js2-node-at-point)) - (parent (js2-node-parent node)) - (names (if (js2-prop-get-node-p parent) - (reverse (let ((temp (js2-compute-nested-prop-get parent))) - (cl-loop for n in temp - with result = '() - do (push n result) - until (equal node n) - finally return result))))) - node-init) - (unless (and (js2-name-node-p node) - (not (js2-var-init-node-p parent)) - (not (js2-function-node-p parent))) - (error "Node is not a supported jump node")) - (push (or (and names (pop names)) - (unless (and (js2-object-prop-node-p parent) - (eq node (js2-object-prop-node-left parent)) - (not (js2-node-get-prop parent 'SHORTHAND))) - node) - (error "Node is not a supported jump node")) names) - (setq node-init (js2-search-scope node names)) - - ;; todo: display list of results in buffer - ;; todo: group found references by buffer - (unless node-init - (switch-to-buffer - (catch 'found - (unless arg - (mapc (lambda (b) - (with-current-buffer b - (when (derived-mode-p 'js2-mode) - (setq node-init (js2-search-scope js2-mode-ast names)) - (if node-init - (throw 'found b))))) - (buffer-list))) - nil))) - (setq node-init (if (listp node-init) (car node-init) node-init)) - (unless node-init - (pop-tag-mark) - (error "No jump location found")) - (goto-char (js2-node-abs-pos node-init)))) - -(defun js2-search-object (node name-node) - "Check if object NODE contains element with NAME-NODE." - (cl-assert (js2-object-node-p node)) - ;; Only support name-node and nodes for the time being - (cl-loop for elem in (js2-object-node-elems node) - for left = (js2-object-prop-node-left elem) - if (or (and (js2-name-node-p left) - (equal (js2-name-node-name name-node) - (js2-name-node-name left))) - (and (js2-string-node-p left) - (string= (js2-name-node-name name-node) - (js2-string-node-value left)))) - return elem)) - -(defun js2-search-object-for-prop (object prop-names) - "Return node in OBJECT that matches PROP-NAMES or nil. -PROP-NAMES is a list of values representing a path to a value in OBJECT. -i.e. ('name' 'value') = {name : { value: 3}}" - (let (node - (temp-object object) - (temp t) ;temporay node - (names prop-names)) - (while (and temp names (js2-object-node-p temp-object)) - (setq temp (js2-search-object temp-object (pop names))) - (and (setq node temp) - (setq temp-object (js2-object-prop-node-right temp)))) - (unless names node))) - -(defun js2-search-scope (node names) - "Searches NODE scope for jump location matching NAMES. -NAMES is a list of property values to search for. For functions -and variables NAMES will contain one element." - (let (node-init - (val (js2-name-node-name (car names)))) - (setq node-init (js2-get-symbol-declaration node val)) - - (when (> (length names) 1) - - ;; Check var declarations - (when (and node-init (string= val (js2-name-node-name node-init))) - (let ((parent (js2-node-parent node-init)) - (temp-names names)) - (pop temp-names) ;; First element is var name - (setq node-init (when (js2-var-init-node-p parent) - (js2-search-object-for-prop - (js2-var-init-node-initializer parent) - temp-names))))) - - ;; Check all assign nodes - (js2-visit-ast - js2-mode-ast - (lambda (node endp) - (unless endp - (if (js2-assign-node-p node) - (let ((left (js2-assign-node-left node)) - (right (js2-assign-node-right node)) - (temp-names names)) - (when (js2-prop-get-node-p left) - (let* ((prop-list (js2-compute-nested-prop-get left)) - (found (cl-loop for prop in prop-list - until (not (string= (js2-name-node-name - (pop temp-names)) - (js2-name-node-name prop))) - if (not temp-names) return prop)) - (found-node (or found - (when (js2-object-node-p right) - (js2-search-object-for-prop right - temp-names))))) - (if found-node (push found-node node-init)))))) - t)))) - node-init)) - -(defun js2-get-symbol-declaration (node name) - "Find scope for NAME from NODE." - (let ((scope (js2-get-defining-scope - (or (js2-node-get-enclosing-scope node) - node) name))) - (if scope (js2-symbol-ast-node (js2-scope-get-symbol scope name))))) - -(provide 'js2-mode) - -;;; js2-mode.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.elc b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.elc deleted file mode 100644 index 6be02890c554..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-mode.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.el b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.el deleted file mode 100644 index 5538736eb9a7..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.el +++ /dev/null @@ -1,712 +0,0 @@ -;;; js2-old-indent.el --- Indentation code kept for compatibility - -;; Copyright (C) 2015 Free Software Foundation, Inc. - -;; This file is part of GNU Emacs. - -;; GNU Emacs is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; GNU Emacs is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. - -;;; Commentary: - -;; All features of this indentation code have been ported to Emacs's -;; built-in `js-mode' by now, so we derive from it. An older -;; commentary follows. - -;; This code is kept for Emacs 24.5 and ealier. - -;; This indenter is based on Karl Landström's "javascript.el" indenter. -;; Karl cleverly deduces that the desired indentation level is often a -;; function of paren/bracket/brace nesting depth, which can be determined -;; quickly via the built-in `parse-partial-sexp' function. His indenter -;; then does some equally clever checks to see if we're in the context of a -;; substatement of a possibly braceless statement keyword such as if, while, -;; or finally. This approach yields pretty good results. - -;; The indenter is often "wrong", however, and needs to be overridden. -;; The right long-term solution is probably to emulate (or integrate -;; with) cc-engine, but it's a nontrivial amount of coding. Even when a -;; parse tree from `js2-parse' is present, which is not true at the -;; moment the user is typing, computing indentation is still thousands -;; of lines of code to handle every possible syntactic edge case. - -;; In the meantime, the compromise solution is that we offer a "bounce -;; indenter", configured with `js2-bounce-indent-p', which cycles the -;; current line indent among various likely guess points. This approach -;; is far from perfect, but should at least make it slightly easier to -;; move the line towards its desired indentation when manually -;; overriding Karl's heuristic nesting guesser. - -;; I've made miscellaneous tweaks to Karl's code to handle some Ecma -;; extensions such as `let' and Array comprehensions. Major kudos to -;; Karl for coming up with the initial approach, which packs a lot of -;; punch for so little code. -- Steve - -;;; Code: - -(require 'sgml-mode) - -(defvar js2-language-version) - -(declare-function js2-backward-sws "js2-mode") -(declare-function js2-forward-sws "js2-mode") -(declare-function js2-same-line "js2-mode") - -(defcustom js2-basic-offset (if (and (boundp 'c-basic-offset) - (numberp c-basic-offset)) - c-basic-offset - 4) - "Number of spaces to indent nested statements. -Similar to `c-basic-offset'." - :group 'js2-mode - :safe 'integerp - :type 'integer) - -(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 t, and the first assigned value in the -declaration is a function/array/object literal spanning several -lines, it won't be indented additionally: - - var o = { var bar = 2, - foo: 3 vs. o = { - }, foo: 3 - bar = 2; }; - -If the value is `all', it will always be indented additionally: - - var o = { - foo: 3 - }; - - var o = { - foo: 3 - }, - bar = 2; - -If the value is `dynamic', it will be indented additionally only -if the declaration contains more than one variable: - - var o = { - foo: 3 - }; - - var o = { - foo: 3 - }, - bar = 2;" - :group 'js2-mode - :safe 'symbolp - :type 'symbol) - -(defcustom js2-indent-switch-body nil - "When nil, case labels are indented on the same level as the -containing switch statement. Otherwise, all lines inside -switch statement body are indented one additional level." - :type 'boolean - :safe 'booleanp - :group 'js2-mode) - -(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 js2-indent-operator-re - (concat "[-+*/%<>&^|?:.]\\([^-+*/.]\\|$\\)\\|!?=\\|" - (regexp-opt '("in" "instanceof") 'symbols)) - "Regular expression matching operators that affect indentation -of continued expressions.") - -(defconst js2-declaration-keyword-re - (regexp-opt '("var" "let" "const") 'symbols) - "Regular expression matching variable declaration keywords.") - -(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 (if saved-point - (parse-partial-sexp saved-point (point)) - (syntax-ppss (point)))) - (cond ((nth 3 parse) - (re-search-forward - (concat "\\(\\=\\|[^\\]\\|^\\)" (string (nth 3 parse))) - (save-excursion (end-of-line) (point)) t)) - ((nth 7 parse) - (forward-line)) - ((or (nth 4 parse) - (and (eq (char-before) ?\/) (eq (char-after) ?\*))) - (re-search-forward "\\*/")) - (t - (setq count (1- count)))) - (setq saved-point (point)))) - (point)) - -(defun 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))) - (condition-case err - (cond ((null count) - (js2-re-search-forward-inner regexp bound 1)) - ((< count 0) - (js2-re-search-backward-inner regexp bound (- count))) - ((> count 0) - (js2-re-search-forward-inner regexp bound count))) - (search-failed - (goto-char saved-point) - (unless noerror - (error (error-message-string err))))))) - -(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 (syntax-ppss (point))) - (cond ((nth 3 parse) - (re-search-backward - (concat "\\([^\\]\\|^\\)" (string (nth 3 parse))) - (line-beginning-position) t)) - ((nth 7 parse) - (goto-char (nth 8 parse))) - ((or (nth 4 parse) - (and (eq (char-before) ?/) (eq (char-after) ?*))) - (re-search-backward "/\\*")) - (t - (setq count (1- count)))))) - (point)) - -(defun 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))) - (condition-case err - (cond ((null count) - (js2-re-search-backward-inner regexp bound 1)) - ((< count 0) - (js2-re-search-forward-inner regexp bound (- count))) - ((> count 0) - (js2-re-search-backward-inner regexp bound count))) - (search-failed - (goto-char saved-point) - (unless noerror - (error (error-message-string err))))))) - -(defun js2-looking-at-operator-p () - "Return non-nil if text after point is a non-comma operator." - (defvar js2-mode-identifier-re) - (and (looking-at js2-indent-operator-re) - (or (not (eq (char-after) ?:)) - (save-excursion - (and (js2-re-search-backward "[?:{]\\|\\_<case\\_>" nil t) - (eq (char-after) ??)))) - (not (and - (eq (char-after) ?/) - (save-excursion - (eq (nth 3 (syntax-ppss)) ?/)))) - (not (and - (eq (char-after) ?*) - ;; Generator method (possibly using computed property). - (looking-at (concat "\\* *\\(?:\\[\\|" - js2-mode-identifier-re - " *(\\)")) - (save-excursion - (js2-backward-sws) - ;; We might misindent some expressions that would - ;; return NaN anyway. Shouldn't be a problem. - (memq (char-before) '(?, ?} ?{))))))) - -(defun js2-continued-expression-p () - "Return non-nil if the current line continues an expression." - (save-excursion - (back-to-indentation) - (if (js2-looking-at-operator-p) - (or (not (memq (char-after) '(?- ?+))) - (progn - (forward-comment (- (point))) - (not (memq (char-before) '(?, ?\[ ?\())))) - (forward-comment (- (point))) - (or (bobp) (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 - (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 () - "Return 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) ?\;)) - (prog2 (skip-syntax-backward ".") - (looking-at js2-indent-operator-re) - (js2-backward-sws)) - (not (eq (char-before) ?\;))) - (js2-same-line pos))))) - (condition-case _ - (backward-sexp) - (scan-error (setq at-opening-bracket t)))) - (when (looking-at js2-declaration-keyword-re) - (goto-char (match-end 0)) - (1+ (current-column))))))) - -(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 (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)) - (skip-chars-backward " \t" (point-at-bol))) - (let ((pt (point))) - (back-to-indentation) - (when (looking-at "}[ \t]*") - (goto-char (match-end 0))) - (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 ((bracket (nth 1 parse-status)) - (end (point))) - (when bracket - (save-excursion - (goto-char bracket) - (when (looking-at "\\[") - (forward-char 1) - (js2-forward-sws) - (if (looking-at "[[{]") - (let (forward-sexp-function) ; use Lisp version - (forward-sexp) ; skip destructuring form - (js2-forward-sws) - (if (and (/= (char-after) ?,) ; regular array - (looking-at "for")) - (match-beginning 0))) - ;; to skip arbitrary expressions we need the parser, - ;; so we'll just guess at it. - (if (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)))) - (and (= 1 (car state)) - (not (nth 8 state))))) - (match-beginning 1)))))))) - -(defun js2-array-comp-indentation (parse-status for-kwd) - (if (js2-same-line for-kwd) - ;; first continuation line - (save-excursion - (goto-char (nth 1 parse-status)) - (forward-char 1) - (skip-chars-forward " \t") - (current-column)) - (save-excursion - (goto-char for-kwd) - (current-column)))) - -(defun js2-maybe-goto-declaration-keyword-end (bracket) - "Helper function for `js2-proper-indentation'. -Depending on the value of `js2-pretty-multiline-declarations', -move point to the end of a variable declaration keyword so that -indentation is aligned to that column." - (cond - ((eq js2-pretty-multiline-declarations 'all) - (when (looking-at js2-declaration-keyword-re) - (goto-char (1+ (match-end 0))))) - ((eq js2-pretty-multiline-declarations 'dynamic) - (let (declaration-keyword-end - at-closing-bracket-p - comma-p) - (when (looking-at js2-declaration-keyword-re) - ;; Preserve the match data lest it somehow be overridden. - (setq declaration-keyword-end (match-end 0)) - (save-excursion - (goto-char bracket) - (setq at-closing-bracket-p - ;; Handle scan errors gracefully. - (condition-case nil - (progn - ;; Use the regular `forward-sexp-function' because the - ;; normal one for this mode uses the AST. - (let (forward-sexp-function) - (forward-sexp)) - t) - (error nil))) - (when at-closing-bracket-p - (js2-forward-sws) - (setq comma-p (looking-at-p ",")))) - (when comma-p - (goto-char (1+ declaration-keyword-end)))))))) - -(cl-defun js2-proper-indentation (parse-status) - "Return the proper indentation for the current line." - (save-excursion - (back-to-indentation) - (when (nth 4 parse-status) - (cl-return-from js2-proper-indentation (js2--comment-indent parse-status))) - (let* ((at-closing-bracket (looking-at "[]})]")) - (same-indent-p (or at-closing-bracket - (looking-at "\\_<case\\_>[^:]") - (and (looking-at "\\_<default:") - (save-excursion - (js2-backward-sws) - (not (memq (char-before) '(?, ?{))))))) - (continued-expr-p (js2-continued-expression-p)) - (declaration-indent (and js2-pretty-multiline-declarations - (js2-multiline-decl-indentation))) - (bracket (nth 1 parse-status)) - beg indent) - (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 - (goto-char beg) - (point-at-bol)))) ; at or after first loop? - (js2-array-comp-indentation parse-status beg)) - - ((js2-ctrl-statement-indentation)) - - ((and declaration-indent continued-expr-p) - (+ declaration-indent js2-basic-offset)) - - (declaration-indent) - - (bracket - (goto-char bracket) - (cond - ((looking-at "[({[][ \t]*\\(/[/*]\\|$\\)") - (when (save-excursion (skip-chars-backward " \t\n)") - (looking-at ")")) - (backward-list)) - (back-to-indentation) - (js2-maybe-goto-declaration-keyword-end bracket) - (setq indent - (cond (same-indent-p - (current-column)) - (continued-expr-p - (+ (current-column) (* 2 js2-basic-offset))) - (t - (+ (current-column) js2-basic-offset)))) - (if (and js2-indent-switch-body - (not at-closing-bracket) - (looking-at "\\_<switch\\_>")) - (+ indent js2-basic-offset) - indent)) - (t - (unless same-indent-p - (forward-char) - (skip-chars-forward " \t")) - (current-column)))) - - (continued-expr-p js2-basic-offset) - - (t 0))))) - -(defun js2--comment-indent (parse-status) - "Indentation inside a multi-line block comment continuation line." - (save-excursion - (goto-char (nth 8 parse-status)) - (if (looking-at "/\\*") - (+ 1 (current-column)) - 0))) - -(defun js2-indent-line (&optional bounce-backwards) - "Indent the current line as JavaScript source text." - (interactive) - (let (parse-status offset - ;; 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 - (syntax-ppss (point-at-bol))) - offset (- (point) (save-excursion - (back-to-indentation) - (point)))) - ;; Don't touch multiline strings. - (unless (nth 3 parse-status) - (indent-line-to (js2-proper-indentation parse-status)) - (when (cl-plusp offset) - (forward-char offset))))) - -;;; JSX Indentation - -;; The following JSX indentation code is copied basically verbatim from js.el at -;; 958da7f, except that the prefixes on the functions/variables are changed. - -(defsubst js2--jsx-find-before-tag () - "Find where JSX starts. - -Assume JSX appears in the following instances: -- Inside parentheses, when returned or as the first argument - to a function, and after a newline -- When assigned to variables or object properties, but only - on a single line -- As the N+1th argument to a function - -This is an optimized version of (re-search-backward \"[(,]\n\" -nil t), except set point to the end of the match. This logic -executes up to the number of lines in the file, so it should be -really fast to reduce that impact." - (let (pos) - (while (and (> (point) (point-min)) - (not (progn - (end-of-line 0) - (when (or (eq (char-before) 40) ; ( - (eq (char-before) 44)) ; , - (setq pos (1- (point)))))))) - pos)) - -(defconst js2--jsx-end-tag-re - (concat "</" sgml-name-re ">\\|/>") - "Find the end of a JSX element.") - -(defconst js2--jsx-after-tag-re "[),]" - "Find where JSX ends. -This complements the assumption of where JSX appears from -`js--jsx-before-tag-re', which see.") - -(defun js2--jsx-indented-element-p () - "Determine if/how the current line should be indented as JSX. - -Return `first' for the first JSXElement on its own line. -Return `nth' for subsequent lines of the first JSXElement. -Return `expression' for an embedded JS expression. -Return `after' for anything after the last JSXElement. -Return nil for non-JSX lines. - -Currently, JSX indentation supports the following styles: - -- Single-line elements (indented like normal JS): - - var element = <div></div>; - -- Multi-line elements (enclosed in parentheses): - - function () { - return ( - <div> - <div></div> - </div> - ); - } - -- Function arguments: - - React.render( - <div></div>, - document.querySelector('.root') - );" - (let ((current-pos (point)) - (current-line (line-number-at-pos)) - last-pos - before-tag-pos before-tag-line - tag-start-pos tag-start-line - tag-end-pos tag-end-line - after-tag-line - parens paren type) - (save-excursion - (and - ;; Determine if we're inside a jsx element - (progn - (end-of-line) - (while (and (not tag-start-pos) - (setq last-pos (js2--jsx-find-before-tag))) - (while (forward-comment 1)) - (when (= (char-after) 60) ; < - (setq before-tag-pos last-pos - tag-start-pos (point))) - (goto-char last-pos)) - tag-start-pos) - (progn - (setq before-tag-line (line-number-at-pos before-tag-pos) - tag-start-line (line-number-at-pos tag-start-pos)) - (and - ;; A "before" line which also starts an element begins with js, so - ;; indent it like js - (> current-line before-tag-line) - ;; Only indent the jsx lines like jsx - (>= current-line tag-start-line))) - (cond - ;; Analyze bounds if there are any - ((progn - (while (and (not tag-end-pos) - (setq last-pos (re-search-forward js2--jsx-end-tag-re nil t))) - (while (forward-comment 1)) - (when (looking-at js2--jsx-after-tag-re) - (setq tag-end-pos last-pos))) - tag-end-pos) - (setq tag-end-line (line-number-at-pos tag-end-pos) - after-tag-line (line-number-at-pos after-tag-line)) - (or (and - ;; Ensure we're actually within the bounds of the jsx - (<= current-line tag-end-line) - ;; An "after" line which does not end an element begins with - ;; js, so indent it like js - (<= current-line after-tag-line)) - (and - ;; Handle another case where there could be e.g. comments after - ;; the element - (> current-line tag-end-line) - (< current-line after-tag-line) - (setq type 'after)))) - ;; They may not be any bounds (yet) - (t)) - ;; Check if we're inside an embedded multi-line js expression - (cond - ((not type) - (goto-char current-pos) - (end-of-line) - (setq parens (nth 9 (syntax-ppss))) - (while (and parens (not type)) - (setq paren (car parens)) - (cond - ((and (>= paren tag-start-pos) - ;; Curly bracket indicates the start of an embedded expression - (= (char-after paren) 123) ; { - ;; The first line of the expression is indented like sgml - (> current-line (line-number-at-pos paren)) - ;; Check if within a closing curly bracket (if any) - ;; (exclusive, as the closing bracket is indented like sgml) - (cond - ((progn - (goto-char paren) - (ignore-errors (let (forward-sexp-function) - (forward-sexp)))) - (< current-line (line-number-at-pos))) - (t))) - ;; Indicate this guy will be indented specially - (setq type 'expression)) - (t (setq parens (cdr parens))))) - t) - (t)) - (cond - (type) - ;; Indent the first jsx thing like js so we can indent future jsx things - ;; like sgml relative to the first thing - ((= current-line tag-start-line) 'first) - ('nth)))))) - -(defmacro js2--as-sgml (&rest body) - "Execute BODY as if in sgml-mode." - `(with-syntax-table sgml-mode-syntax-table - (let (forward-sexp-function - parse-sexp-lookup-properties) - ,@body))) - -(defun js2--expression-in-sgml-indent-line () - "Indent the current line as JavaScript or SGML (whichever is farther)." - (let* (indent-col - (savep (point)) - ;; 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) - (parse-status (save-excursion - (syntax-ppss (point-at-bol))))) - ;; Don't touch multiline strings. - (unless (nth 3 parse-status) - (setq indent-col (save-excursion - (back-to-indentation) - (if (>= (point) savep) (setq savep nil)) - (js2--as-sgml (sgml-calculate-indent)))) - (if (null indent-col) - 'noindent - ;; Use whichever indentation column is greater, such that the sgml - ;; column is effectively a minimum - (setq indent-col (max (js2-proper-indentation parse-status) - (+ indent-col js2-basic-offset))) - (if savep - (save-excursion (indent-line-to indent-col)) - (indent-line-to indent-col)))))) - -(defun js2-jsx-indent-line () - "Indent the current line as JSX (with SGML offsets). -i.e., customize JSX element indentation with `sgml-basic-offset' -et al." - (interactive) - (let ((indentation-type (js2--jsx-indented-element-p))) - (cond - ((eq indentation-type 'expression) - (js2--expression-in-sgml-indent-line)) - ((or (eq indentation-type 'first) - (eq indentation-type 'after)) - ;; Don't treat this first thing as a continued expression (often a "<" or - ;; ">" causes this misinterpretation) - (cl-letf (((symbol-function #'js2-continued-expression-p) 'ignore)) - (js2-indent-line))) - ((eq indentation-type 'nth) - (js2--as-sgml (sgml-indent-line))) - (t (js2-indent-line))))) - -(provide 'js2-old-indent) - -;;; js2-old-indent.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.elc b/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.elc deleted file mode 100644 index a226eada4f50..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/js2-mode-20180724.801/js2-old-indent.elc +++ /dev/null Binary files differ |