implement method definitions

Author: Swatinem

src/scope_name.rs

@@ -1,3 +1,6 @@
+// TODO: punctuation components
+#![allow(dead_code)]
+
 use std::collections::VecDeque;
 use std::fmt::Display;
 use std::ops::Range;
@@ -6,10 +9,6 @@ use swc_ecma_visit::swc_ecma_ast as ast;
 
 use crate::swc::convert_span;
 
-//use rslint_parser::SyntaxToken;
-
-//use crate::rslint::convert_text_range;
-
 #[derive(Debug)]
 pub(crate) struct SyntaxToken;
 
@@ -64,7 +63,7 @@ impl NameComponent {
     pub fn range(&self) -> Option<Range<u32>> {
         match &self.inner {
             NameComponentInner::SourceIdentifierToken(t) => Some(convert_span(t.span)),
-            NameComponentInner::SourcePunctuationToken(t) => {
+            NameComponentInner::SourcePunctuationToken(_t) => {
                 None
                 //Some(convert_text_range(t.text_range()))
             }

src/swc.rs

@@ -69,6 +69,8 @@ impl VisitAstPath for FnVisitor {
         let name = infer_name_from_ctx(path);
 
         self.scopes.push((convert_span(node.span), name));
+
+        node.visit_children_with_path(self, path);
     }
 
     fn visit_function<'ast: 'r, 'r>(
@@ -134,11 +136,63 @@ fn infer_name_from_ctx(path: &AstNodePath) -> Option<ScopeName> {
         match parent {
             // These create a new scope. If we reached this, it means we didn’t
             // use any of the other parents properly.
-            Parent::Function(..)
-            | Parent::ArrowExpr(..)
-            | Parent::Constructor(..)
-            | Parent::ClassMethod(..)
-            | Parent::PrivateMethod(..) => return None,
+            Parent::Function(..) | Parent::ArrowExpr(..) | Parent::Constructor(..) => return None,
+
+            // A class which is the parent of a method for which we already
+            // have part of the name.
+            Parent::ClassExpr(class_expr, _) => {
+                if let Some(ident) = &class_expr.ident {
+                    scope_name
+                        .components
+                        .push_front(NameComponent::ident(ident.clone()));
+                }
+            }
+            Parent::ClassDecl(class_decl, _) => {
+                push_sep(&mut scope_name);
+                scope_name
+                    .components
+                    .push_front(NameComponent::ident(class_decl.ident.clone()));
+                return Some(scope_name);
+            }
+
+            // An object literal member:
+            // `{ $name() ... }`
+            Parent::MethodProp(method, _) => {
+                if let Some(ident) = method.key.as_ident() {
+                    scope_name
+                        .components
+                        .push_front(NameComponent::ident(ident.clone()));
+                }
+            }
+
+            // An object literal property:
+            // `{ $name: ... }`
+            Parent::KeyValueProp(kv, _) => {
+                if let Some(ident) = kv.key.as_ident() {
+                    scope_name
+                        .components
+                        .push_front(NameComponent::ident(ident.clone()));
+                }
+            }
+
+            // A class method:
+            // `class { $name() ... }`
+            Parent::ClassMethod(method, _) => {
+                if let Some(ident) = method.key.as_ident() {
+                    scope_name
+                        .components
+                        .push_front(NameComponent::ident(ident.clone()));
+                }
+            }
+
+            // A private class method:
+            // `class { #$name() ... }`
+            Parent::PrivateMethod(method, _) => {
+                scope_name
+                    .components
+                    .push_front(NameComponent::ident(method.key.id.clone()));
+                scope_name.components.push_front(NameComponent::interp("#"));
+            }
 
             // A variable declaration with a name:
             // `var $name = ...`

tests/extract.rs

@@ -19,8 +19,11 @@ fn extracts_named_fn() {
     let scopes = extract_scope_names(src);
     let scopes = scope_strs(scopes);
 
-    assert_eq!(scopes[0], (9..81, Some("fn_decl".into())));
-    assert_eq!(scopes[1], (49..70, Some("fn_expr".into())));
+    let expected = [
+        (9..81, Some("fn_decl".into())),
+        (49..70, Some("fn_expr".into())),
+    ];
+    assert_eq!(scopes, expected);
 }
 
 #[test]
@@ -35,8 +38,11 @@ fn extracts_named_class() {
     let scopes = extract_scope_names(src);
     let scopes = scope_strs(scopes);
 
-    assert_eq!(scopes[0], (9..123, Some("new class_decl".into())));
-    assert_eq!(scopes[1], (79..98, Some("new class_expr".into())));
+    let expected = [
+        (9..123, Some("new class_decl".into())),
+        (79..98, Some("new class_expr".into())),
+    ];
+    assert_eq!(scopes, expected);
 }
 
 #[test]
@@ -49,9 +55,12 @@ fn infer_from_decl() {
     let scopes = extract_scope_names(src);
     let scopes = scope_strs(scopes);
 
-    assert_eq!(scopes[0], (23..37, Some("anon_fn".into())));
-    assert_eq!(scopes[1], (64..72, Some("new anon_class".into())));
-    assert_eq!(scopes[2], (96..104, Some("arrow".into())));
+    let expected = [
+        (23..37, Some("anon_fn".into())),
+        (64..72, Some("new anon_class".into())),
+        (96..104, Some("arrow".into())),
+    ];
+    assert_eq!(scopes, expected);
 }
 
 #[test]
@@ -63,6 +72,52 @@ fn infer_from_assign() {
     let scopes = extract_scope_names(src);
     let scopes = scope_strs(scopes);
 
-    assert_eq!(scopes[0], (23..37, Some("assigned_fn".into())));
-    assert_eq!(scopes[1], (69..77, Some("new deep.assigned.klass".into())));
+    let expected = [
+        (23..37, Some("assigned_fn".into())),
+        (69..77, Some("new deep.assigned.klass".into())),
+    ];
+    assert_eq!(scopes, expected);
+}
+
+#[test]
+fn extract_obj_literal() {
+    let src = r#"
+        const obj_literal = {
+            named_prop: function named_prop() {},
+            anon_prop: function () {},
+            arrow_prop: () => {},
+            method_prop() {},
+        };
+        "#;
+    let scopes = extract_scope_names(src);
+    let scopes = scope_strs(scopes);
+
+    let expected = [
+        (55..79, Some("named_prop".into())),
+        (104..118, Some("obj_literal.anon_prop".into())),
+        (144..152, Some("obj_literal.arrow_prop".into())),
+        (166..182, Some("obj_literal.method_prop".into())),
+    ];
+    assert_eq!(scopes, expected);
+}
+
+#[test]
+fn extract_method_names() {
+    let src = r#"
+        class class_decl {
+            static static_method() {}
+            class_method() {}
+            #private_method() {}
+        }
+        "#;
+    let scopes = extract_scope_names(src);
+    let scopes = scope_strs(scopes);
+
+    let expected = [
+        (9..138, Some("new class_decl".into())),
+        (40..65, Some("class_decl.static_method".into())),
+        (78..95, Some("class_decl.class_method".into())),
+        (108..128, Some("class_decl.#private_method".into())),
+    ];
+    assert_eq!(scopes, expected);
 }

tests/integration.rs

@@ -46,6 +46,7 @@ fn resolves_scope_names() {
 
     let scopes = extract_scope_names(&src);
     // dbg!(&scopes);
+
     let scopes: Vec<_> = scopes
         .into_iter()
         .map(|s| (s.0, s.1.map(|n| n.to_string()).filter(|s| !s.is_empty())))