[elpa] master 4125b49a 04/22: Merge pull request #487 from lelit/classify-imported

[Dmitry Gutov]

branch: master
commit 4125b49a6982a3eb36674962160118250daf665e
Merge: 8bb1907 47dee19
Author: Dmitry Gutov <address@hidden>
Commit: GitHub <address@hidden>

    Merge pull request #487 from lelit/classify-imported
    
    Classify imported variables
---
 js2-mode.el     | 115 +++++++++++++++++++++++++++++++-------------------------
 tests/parser.el |  30 ++++++++++++++-
 2 files changed, 93 insertions(+), 52 deletions(-)

diff --git a/js2-mode.el b/js2-mode.el
index bd691c5..5dcb2a6 100644
--- a/js2-mode.el
+++ b/js2-mode.el
@@ -7192,58 +7192,71 @@ key of a literal object."
         (let ((left (js2-prop-get-node-left parent)))
           (when (js2-name-node-p left)
             (js2--add-or-update-symbol left nil t vars)))
-      (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)
+      ;; 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-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)))
-             (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))))))
+             ((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.
diff --git a/tests/parser.el b/tests/parser.el
index 1853f03..9137940 100644
--- a/tests/parser.el
+++ b/tests/parser.el
@@ -635,7 +635,7 @@ the test."
       (should name)
       (should (equal "default" (js2-name-node-name name))))))
 
-(js2-deftest parse-namepsace-import "* as lib;"
+(js2-deftest parse-namespace-import "* as lib;"
   (js2-init-scanner)
   (should (js2-match-token js2-MUL))
   (let ((namespace-import (js2-parse-namespace-import)))
@@ -1358,6 +1358,34 @@ the test."
   "function foo() { let {foo: missing = 10} = {}; }"
   '("address@hidden:U" "address@hidden:U"))
 
+(js2-deftest-classify-variables import-unused
+  "import foo from 'module';"
+  '("address@hidden:U"))
+
+(js2-deftest-classify-variables named-import-unused
+  "import foo as bar from 'module';"
+  '("address@hidden:U"))
+
+(js2-deftest-classify-variables import-unused-many
+  "import {a,b} from 'module';"
+  '("address@hidden:U" "address@hidden:U"))
+
+(js2-deftest-classify-variables named-import-unused-many
+  "import {a as b, c as d} from 'module';"
+  '("address@hidden:U" "address@hidden:U"))
+
+(js2-deftest-classify-variables import-export
+  "import foo from 'module'; export {foo}"
+  '("address@hidden:I" 35))
+
+(js2-deftest-classify-variables import-namespace-unused
+  "import * as foo from 'module';"
+  '("address@hidden:U"))
+
+(js2-deftest-classify-variables import-namespace-used
+  "import * as foo from 'module'; function bar() { return foo.x; }"
+  '("address@hidden:I" 56 "address@hidden:U"))
+
 ;; Side effects
 
 (js2-deftest no-side-effects-at-top-level