daniel/emacs-conf
1
2
Fork 0
Code Issues 7 Pull Requests Projects Releases Wiki Activity

update packages

Browse Source
This commit is contained in:
Daniel Weschke
2022-01-04 21:35:17 +01:00
parent 1d5275c946
commit 8de00e5202
700 changed files with 42441 additions and 85378 deletions
Download Patch File Download Diff File Expand all files Collapse all files

236
lisp/js2-mode/js2-mode.el
View File

@@ -1,13 +1,13 @@
;;; js2-mode.el --- Improved JavaScript editing mode -*- lexical-binding: t -*-
;; Copyright (C) 2009, 2011-2020 Free Software Foundation, Inc.
;; Copyright (C) 2009, 2011-2021 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: 20201220
;; Version: 20211229
;; Keywords: languages, javascript
;; Package-Requires: ((emacs "24.1") (cl-lib "0.5"))
@@ -657,7 +657,9 @@ which doesn't seem particularly useful, but Rhino permits it."
(defvar js2-EXPON 175)
(defvar js2-NULLISH-COALESCING 176) ; nullish coalescing (obj.value ?? obj.defaultValue ?? 0))
(defconst js2-num-tokens (1+ js2-NULLISH-COALESCING))
(defvar js2-PRIVATE_NAME 177) ; this.#bar();
(defconst js2-num-tokens (1+ js2-PRIVATE_NAME))
(defconst js2-debug-print-trees nil)
@@ -2651,14 +2653,17 @@ so many of its properties will be nil.
object
in-pos
each-pos
foreach-p forof-p
await-pos
foreach-p forof-p forawait-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
await-pos ; buffer position of 'await' keyword, if forawait-p
foreach-p ; t if it's a for-each loop
forawait-p ; t if it's a for-await 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)
@@ -2672,10 +2677,13 @@ so many of its properties will be nil.
(defun js2-print-for-in-node (n i)
(let ((pad (js2-make-pad i))
(foreach (js2-for-in-node-foreach-p n))
(forawait (js2-for-in-node-forawait-p n))
(forof (js2-for-in-node-forof-p n)))
(insert pad "for ")
(if foreach
(insert "each "))
(if forawait
(insert "await "))
(insert "(")
(js2-print-ast (js2-for-in-node-iterator n) 0)
(insert (if forof " of " " in "))
@@ -3009,12 +3017,15 @@ modules metadata itself."
(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")
(insert " catch ")
(when (js2-catch-node-lp n)
(insert "(")
(js2-print-ast (js2-catch-node-param n) 0)
(when guard-kwd
(insert " if ")
(js2-print-ast guard-expr 0))
(insert ") "))
(insert "{\n")
(js2-print-body n (1+ i))
(insert pad "}")))
@@ -5892,6 +5903,7 @@ the token is flagged as such."
During operation, creates an instance of `js2-token' struct, sets
its relevant fields and puts it into `js2-ti-tokens'."
(let (identifier-start
identifier-private
is-unicode-escape-start c
contains-escape escape-val str result base
look-for-slash continue tt legacy-octal
@@ -5937,7 +5949,10 @@ its relevant fields and puts it into `js2-ti-tokens'."
(js2-unget-char)
(setq c ?\\)))
(t
(when (setq identifier-start (js2-identifier-start-p c))
(when (setq identifier-start (or (js2-identifier-start-p c)
(and
(eq c ?#)
(setq identifier-private t))))
(setq js2-ts-string-buffer nil)
(js2-add-to-string c))))
(when identifier-start
@@ -5997,7 +6012,11 @@ its relevant fields and puts it into `js2-ti-tokens'."
(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
(throw 'return
(if identifier-private
js2-PRIVATE_NAME
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))))
@@ -8015,7 +8034,7 @@ string is NAME. Returns nil and keeps current token otherwise."
"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))
(if (memq (js2-get-prop-name-token) `(,js2-NAME ,js2-PRIVATE_NAME))
t
(js2-unget-token)
nil))
@@ -8606,7 +8625,7 @@ node are given relative start positions and correct lengths."
(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-IMPORT #'js2-parse-import-declaration-or-expr)
(aset parsers js2-LC #'js2-parse-block)
(aset parsers js2-LET #'js2-parse-let-stmt)
(aset parsers js2-NAME #'js2-parse-name-or-label)
@@ -8736,6 +8755,11 @@ Return value is a list (EXPR LP RP), with absolute paren positions."
(js2-node-add-children pn (car cond) if-true if-false)
pn))
(defun js2-parse-import-declaration-or-expr ()
(if (memq (js2-peek-token) `(,js2-LP ,js2-DOT))
(js2-parse-expr-stmt)
(js2-parse-import)))
(defun js2-parse-import ()
"Parse import statement. The current token must be js2-IMPORT."
(unless (js2-ast-root-p js2-current-scope)
@@ -9133,24 +9157,31 @@ invalid export statements."
node)))
(defun js2-parse-for ()
"Parse a for, for-in or for each-in statement.
"Parse a for, for-in, for each-in or for await-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
pn is-for-each is-for-in-or-of is-for-of is-for-await
in-pos each-pos tmp-pos await-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")))
(cond
;; See if this is a for each () instead of just a for ()
((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)))
;; See if this is a for await () instead of just a for ()
((string= "await" (js2-current-token-string))
(progn
(setq is-for-await t
await-pos (- (js2-current-token-beg) for-pos)) ; relative
(js2-record-face 'font-lock-keyword-face)))
(t (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))
@@ -9212,6 +9243,8 @@ Last matched token must be js2-FOR."
:in-pos in-pos
:foreach-p is-for-each
:each-pos each-pos
:forawait-p is-for-await
:await-pos await-pos
:forof-p is-for-of
:lp lp
:rp rp)))
@@ -9258,30 +9291,30 @@ Last matched token must be js2-FOR."
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)))
(when (js2-match-token js2-LP)
(setq lp (- (js2-current-token-beg) catch-pos))
(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")
@@ -9877,15 +9910,20 @@ If NODE is non-nil, it is the AST node associated with the symbol."
(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))
(if (eq (js2-peek-token) js2-RP)
;; Stop the parser from scanning too far: it's actually
;; valid syntax in arrow fun arguments, and we don't want
;; the RP token to get consumed.
(js2-report-error "msg.syntax")
(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 ()
@@ -10489,7 +10527,7 @@ Last token parsed must be `js2-RB'."
tt (js2-get-prop-name-token))
(cond
;; handles: name, ns::name, ns::*, ns::[expr]
((= tt js2-NAME)
((or (= tt js2-NAME) (= tt js2-PRIVATE_NAME))
(setq ref (js2-parse-property-name -1 nil member-type-flags)))
;; handles: *, *::name, *::*, *::[expr]
((= tt js2-MUL)
@@ -10631,6 +10669,8 @@ array-literals, array comprehensions and regular expressions."
(js2-parse-attribute-access))
((= tt js2-NAME)
(js2-parse-name tt))
((= tt js2-IMPORT)
(js2-create-name-node nil nil "import"))
((= tt js2-NUMBER)
(setq node (make-js2-number-node))
(when (and js2-in-use-strict-directive
@@ -11034,8 +11074,8 @@ expression)."
(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)))
(memq (js2-peek-token 'KEYWORD_IS_NAME)
`(,js2-NAME ,js2-PRIVATE_NAME ,js2-STRING ,js2-NUMBER ,js2-LB)))
(setq previous-token (js2-current-token)
tt (js2-get-prop-name-token))))
(cond
@@ -11046,7 +11086,7 @@ expression)."
(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))
((memq tt `(,js2-NAME ,js2-PRIVATE_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)
@@ -11110,7 +11150,7 @@ expression)."
(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))
(let ((key (js2-parse-prop-name tt class-p))
(prop (and previous-token (js2-token-string previous-token)))
(property-type (when previous-token
(if (= (js2-token-type previous-token) js2-MUL)
@@ -11162,7 +11202,7 @@ When `js2-is-in-destructuring' is t, forms like {a, b, c} will be permitted."
(when (js2-match-token js2-ASSIGN)
(js2-make-binary js2-ASSIGN name 'js2-parse-assign-expr t)))
(defun js2-parse-prop-name (tt)
(defun js2-parse-prop-name (tt allow-private)
(cond
;; Literal string keys: {'foo': 'bar'}
((= tt js2-STRING)
@@ -11180,6 +11220,9 @@ When `js2-is-in-destructuring' is t, forms like {a, b, c} will be permitted."
;; Unquoted names: {foo: 12}
((= tt js2-NAME)
(js2-create-name-node))
((and allow-private
(= tt js2-PRIVATE_NAME))
(js2-create-name-node))
;; Anything else is an error
(t (js2-report-error "msg.bad.prop"))))
@@ -11195,9 +11238,9 @@ string or expression."
((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)))
(memq tt `(,js2-EOL ,js2-RC ,js2-SEMI)))
(and (setq tt (js2-peek-token))
(member tt (list js2-COMMA js2-RC))
(memq tt `(,js2-COMMA ,js2-RC))
(js2-name-node-p prop))))
(setq result (make-js2-object-prop-node
:pos pos
@@ -11269,7 +11312,7 @@ 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)
(if (or (= js2-NAME tt) (= js2-PRIVATE_NAME tt))
(js2-current-token-string)
(js2-tt-name tt))))
name)
@@ -12569,7 +12612,7 @@ move backward across N balanced expressions."
(setq pos (js2-node-abs-pos child)))
;; Before both parens.
(setq pos lp)))
(let ((state (parse-partial-sexp start pos)))
(let ((state (parse-partial-sexp pos start)))
(goto-char (if (not (zerop (car state)))
;; Stumble at the unbalanced paren if < 0, or
;; jump a bit further if > 0.
@@ -12910,7 +12953,7 @@ it marks the next defun after the ones already marked."
(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)
for left = (js2-infix-node-left elem)
if (or (and (js2-name-node-p left)
(equal (js2-name-node-name name-node)
(js2-name-node-name left)))
@@ -12930,28 +12973,43 @@ i.e. (\\='name\\=' \\='value\\=') = {name : { value: 3}}"
(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))))
(setq temp-object (js2-infix-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))
(let (node-init val)
(cond
((js2-name-node-p (car names))
(setq val (js2-name-node-name (car names)))
(setq node-init (js2-get-symbol-declaration node val)))
((and (js2-keyword-node-p (car names))
(equal (js2-keyword-node-type (car names))
js2-THIS))
(let* ((scope (js2-node-get-enclosing-scope node))
(parent (js2-node-parent scope)))
(when (or (js2-method-node-p parent)
(js2-object-prop-node-p parent))
;; class or object
(setq node-init (js2-node-parent parent))))))
(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)))))
(when node-init
(cond
((js2-name-node-p (car names))
;; Check var declarations
(when (string= val (js2-name-node-name node-init))
(let ((parent (js2-node-parent node-init)))
(setq node-init (when (js2-var-init-node-p parent)
(js2-search-object-for-prop
(js2-var-init-node-initializer parent)
(cdr names)))))))
((js2-object-node-p node-init)
(setq node-init (js2-search-object-for-prop
node-init
(cdr names))))))
;; Check all assign nodes
(js2-visit-ast
@@ -12964,11 +13022,17 @@ and variables NAMES will contain one element."
(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))
;; 'this' or 'super'
(target-is-keyword (js2-keyword-node-p (car temp-names)))
(_ (when target-is-keyword
(pop temp-names)))
(found (unless target-is-keyword
(cl-loop for prop in prop-list
until (not (string= (js2-name-node-name
(pop temp-names))
(and (js2-name-node-p prop)
(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