From cf4189cbf1581e876a476fd3606ca4b15794faed Mon Sep 17 00:00:00 2001
From: Daniel Frederico Lins Leite <xunilrj@hotmail.com>
Date: Mon, 20 Jun 2022 18:05:05 +0100
Subject: [PATCH] feature(rome_js_semantic): extraction of reference (read)
 events  (#2725)

* extraction of read events
---
 crates/rome_js_semantic/src/events.rs         | 122 +++++++++++++++---
 .../rome_js_semantic/src/tests/assertions.rs  |  77 ++++++++++-
 crates/rome_js_semantic/src/tests/mod.rs      |   1 +
 .../rome_js_semantic/src/tests/references.rs  |  17 +++
 crates/rome_rowan/src/cursor/token.rs         |   8 ++
 crates/rome_rowan/src/syntax/token.rs         |   4 +
 crates/rome_rowan/src/syntax_token_text.rs    |  11 ++
 xtask/coverage/src/symbols/msts.rs            |  11 +-
 8 files changed, 226 insertions(+), 25 deletions(-)
 create mode 100644 crates/rome_js_semantic/src/tests/references.rs

diff --git a/crates/rome_js_semantic/src/events.rs b/crates/rome_js_semantic/src/events.rs
index a34b51d0731..e7027c1f25f 100644
--- a/crates/rome_js_semantic/src/events.rs
+++ b/crates/rome_js_semantic/src/events.rs
@@ -1,16 +1,19 @@
 //! Events emitted by the [SemanticEventExtractor] which are then constructed into the Semantic Model
 
-use std::collections::VecDeque;
+use std::collections::{HashMap, VecDeque};
 
-use rome_js_syntax::{JsLanguage, JsSyntaxNode, TextRange, TextSize};
-use rome_rowan::syntax::Preorder;
+use rome_js_syntax::{
+    JsIdentifierBinding, JsLanguage, JsReferenceIdentifier, JsSyntaxNode, JsSyntaxToken, TextRange,
+    TextSize,
+};
+use rome_rowan::{syntax::Preorder, SyntaxNodeCast, SyntaxTokenText};
 
 /// Events emitted by the [SemanticEventExtractor]. These events are later
 /// made into the Semantic Model.
 #[derive(Debug)]
 pub enum SemanticEvent {
     /// Signifies that a new symbol declaration was found.
-    /// Currently is generated for:
+    /// Generated for:
     /// - Variable Declarations
     /// - Import bindings
     /// - Functions parameters
@@ -19,14 +22,22 @@ pub enum SemanticEvent {
         scope_started_at: TextSize,
     },
 
+    /// Signifies that a symbol value is being read.
+    /// Generated for:
+    /// - All reference identifiers
+    Read {
+        range: TextRange,
+        declaration_at: Option<TextRange>,
+    },
+
     /// Signifies that a new scope was started
-    /// Currently generated for:
+    /// Generated for:
     /// - Blocks
     /// - Function body
     ScopeStarted { range: TextRange },
 
     /// Signifies that a new scope was ended
-    /// Currently generated for:
+    /// Generated for:
     /// - Blocks
     /// - Function body
     ScopeEnded {
@@ -41,6 +52,7 @@ impl SemanticEvent {
             SemanticEvent::DeclarationFound { range, .. } => range,
             SemanticEvent::ScopeStarted { range } => range,
             SemanticEvent::ScopeEnded { range, .. } => range,
+            SemanticEvent::Read { range, .. } => range,
         }
     }
 
@@ -87,10 +99,17 @@ impl SemanticEvent {
 pub struct SemanticEventExtractor {
     stash: VecDeque<SemanticEvent>,
     scopes: Vec<Scope>,
+    declared_names: HashMap<SyntaxTokenText, TextRange>,
+}
+
+struct ScopeDeclaration {
+    name: SyntaxTokenText,
 }
 
 struct Scope {
     started_at: TextSize,
+    declared: Vec<ScopeDeclaration>,
+    shadowed: Vec<(SyntaxTokenText, TextRange)>,
 }
 
 impl SemanticEventExtractor {
@@ -98,6 +117,7 @@ impl SemanticEventExtractor {
         Self {
             stash: VecDeque::new(),
             scopes: vec![],
+            declared_names: HashMap::new(),
         }
     }
 
@@ -105,13 +125,31 @@ impl SemanticEventExtractor {
     /// of which ```SyntaxNode``` generates which events.
     pub fn enter(&mut self, node: &JsSyntaxNode) {
         use rome_js_syntax::JsSyntaxKind::*;
-        use SemanticEvent::*;
 
         match node.kind() {
-            JS_IDENTIFIER_BINDING => self.stash.push_back(DeclarationFound {
-                range: node.text_range(),
-                scope_started_at: self.current_scope_start(),
-            }),
+            JS_IDENTIFIER_BINDING => {
+                if let Some(name_token) = node
+                    .clone()
+                    .cast::<JsIdentifierBinding>()
+                    .and_then(|id| id.name_token().ok())
+                {
+                    self.declare_name(&name_token);
+                }
+            }
+            JS_REFERENCE_IDENTIFIER => {
+                if let Some(name_token) = node
+                    .clone()
+                    .cast::<JsReferenceIdentifier>()
+                    .and_then(|reference| reference.value_token().ok())
+                {
+                    self.stash.push_back(SemanticEvent::Read {
+                        range: node.text_range(),
+                        declaration_at: self
+                            .get_declaration_range_by_trimmed_text(&name_token)
+                            .cloned(),
+                    })
+                }
+            }
 
             JS_MODULE | JS_SCRIPT => self.push_scope(node.text_range()),
             JS_FUNCTION_DECLARATION
@@ -155,15 +193,6 @@ impl SemanticEventExtractor {
         }
     }
 
-    fn current_scope_start(&self) -> TextSize {
-        let started_at = self.scopes.last().map(|x| x.started_at);
-
-        // We should always have, at least, the global scope
-        debug_assert!(started_at.is_some());
-
-        started_at.unwrap_or_else(|| TextSize::of(""))
-    }
-
     /// Return any previous extracted [SemanticEvent].
     pub fn pop(&mut self) -> Option<SemanticEvent> {
         self.stash.pop_front()
@@ -173,6 +202,8 @@ impl SemanticEventExtractor {
         self.stash.push_back(SemanticEvent::ScopeStarted { range });
         self.scopes.push(Scope {
             started_at: range.start(),
+            declared: vec![],
+            shadowed: vec![],
         });
     }
 
@@ -182,8 +213,59 @@ impl SemanticEventExtractor {
                 range,
                 started_at: scope.started_at,
             });
+
+            // remove all declarations
+            for decl in scope.declared {
+                self.declared_names.remove(&decl.name);
+            }
+
+            // return all shadowed names
+            for (name, range) in scope.shadowed {
+                self.declared_names.insert(name, range);
+            }
+        }
+    }
+
+    fn current_scope_mut(&mut self) -> &mut Scope {
+        // We should at least have the global scope
+        debug_assert!(!self.scopes.is_empty());
+
+        match self.scopes.last_mut() {
+            None => unreachable!(),
+            Some(scope) => scope,
         }
     }
+
+    fn declare_name(&mut self, name_token: &JsSyntaxToken) {
+        let name = name_token.token_text_trimmed();
+
+        let declaration_range = name_token.text_range();
+
+        // insert this name into the list of available names
+        // and save shadowed names to be used later
+        let shadowed = self
+            .declared_names
+            .insert(name.clone(), declaration_range)
+            .map(|shadowed_range| (name.clone(), shadowed_range));
+
+        let current_scope = self.current_scope_mut();
+        current_scope.declared.push(ScopeDeclaration { name });
+        current_scope.shadowed.extend(shadowed);
+        let scope_started_at = current_scope.started_at;
+
+        self.stash.push_back(SemanticEvent::DeclarationFound {
+            range: declaration_range,
+            scope_started_at,
+        });
+    }
+
+    fn get_declaration_range_by_trimmed_text(
+        &self,
+        name_token: &JsSyntaxToken,
+    ) -> Option<&TextRange> {
+        let name = name_token.token_text_trimmed();
+        self.declared_names.get(&name)
+    }
 }
 
 /// Extracts [SemanticEvent] from [SyntaxNode].
diff --git a/crates/rome_js_semantic/src/tests/assertions.rs b/crates/rome_js_semantic/src/tests/assertions.rs
index 13841fcb3e2..56991d770e7 100644
--- a/crates/rome_js_semantic/src/tests/assertions.rs
+++ b/crates/rome_js_semantic/src/tests/assertions.rs
@@ -24,6 +24,17 @@ use std::collections::{BTreeMap, HashMap};
 /// let a/*#A*/ = 1;
 /// ```
 ///
+/// #### Read Assertion
+///
+/// Test if the attached token is reference "reading" the value of a symbol.
+/// Pattern: ```/*READ <LABEL> */
+///
+/// /// Example:
+/// ```js
+/// let a/*#A*/ = 1;
+/// let b = a/*READ A*/ + 1;
+/// ```
+///
 /// #### At Scope Assertion
 ///
 /// Test if the attached token is a declaration that lives inside the specified scope.
@@ -110,6 +121,10 @@ pub fn assert(code: &str, test_name: &str) {
                 let v = events_by_pos.entry(range.end()).or_default();
                 v.push(event);
             }
+            SemanticEvent::Read { range, .. } => {
+                let v = events_by_pos.entry(range.start()).or_default();
+                v.push(event);
+            }
         }
     }
 
@@ -126,6 +141,12 @@ struct DeclarationAssertion {
     declaration_name: String,
 }
 
+#[derive(Clone, Debug)]
+struct ReadAssertion {
+    range: TextRange,
+    symbol_name: String,
+}
+
 #[derive(Clone, Debug)]
 struct AtScopeAssertion {
     range: TextRange,
@@ -157,6 +178,7 @@ struct UniqueAssertion {
 #[derive(Clone, Debug)]
 enum SemanticAssertion {
     Declaration(DeclarationAssertion),
+    Read(ReadAssertion),
     ScopeStart(ScopeStartAssertion),
     ScopeEnd(ScopeEndAssertion),
     AtScope(AtScopeAssertion),
@@ -178,6 +200,18 @@ impl SemanticAssertion {
                 range: token.text_range(),
                 declaration_name: name,
             }))
+        } else if assertion_text.starts_with("/*READ ") {
+            let symbol_name = assertion_text
+                .trim()
+                .trim_start_matches("/*READ ")
+                .trim_end_matches("*/")
+                .trim()
+                .to_string();
+
+            Some(SemanticAssertion::Read(ReadAssertion {
+                range: token.text_range(),
+                symbol_name,
+            }))
         } else if assertion_text.contains("/*START") {
             let scope_name = assertion_text
                 .trim()
@@ -228,6 +262,7 @@ impl SemanticAssertion {
 #[derive(Debug)]
 struct SemanticAssertions {
     declarations_assertions: BTreeMap<String, DeclarationAssertion>,
+    read_assertions: Vec<ReadAssertion>,
     at_scope_assertions: Vec<AtScopeAssertion>,
     scope_start_assertions: BTreeMap<String, ScopeStartAssertion>,
     scope_end_assertions: Vec<ScopeEndAssertion>,
@@ -238,6 +273,7 @@ struct SemanticAssertions {
 impl SemanticAssertions {
     fn from_root(root: JsAnyRoot, code: &str, test_name: &str) -> Self {
         let mut declarations_assertions: BTreeMap<String, DeclarationAssertion> = BTreeMap::new();
+        let mut read_assertions = vec![];
         let mut at_scope_assertions = vec![];
         let mut scope_start_assertions: BTreeMap<String, ScopeStartAssertion> = BTreeMap::new();
         let mut scope_end_assertions = vec![];
@@ -267,6 +303,9 @@ impl SemanticAssertions {
                                 error_assertion_name_clash(&token, code, test_name, old);
                             }
                         }
+                        Some(SemanticAssertion::Read(assertion)) => {
+                            read_assertions.push(assertion);
+                        }
                         Some(SemanticAssertion::ScopeStart(assertion)) => {
                             // Scope start assertions names cannot clash
                             let old = scope_start_assertions
@@ -288,7 +327,8 @@ impl SemanticAssertions {
                         Some(SemanticAssertion::Unique(assertion)) => {
                             uniques.push(assertion);
                         }
-                        _ => {}
+
+                        None => {}
                     };
                 }
             }
@@ -296,6 +336,7 @@ impl SemanticAssertions {
 
         Self {
             declarations_assertions,
+            read_assertions,
             at_scope_assertions,
             scope_start_assertions,
             scope_end_assertions,
@@ -329,6 +370,40 @@ impl SemanticAssertions {
             }
         }
 
+        // Check every read assertion is ok
+
+        for assertion in self.read_assertions.iter() {
+            let decl = match self.declarations_assertions.get(&assertion.symbol_name) {
+                Some(decl) => decl,
+                None => {
+                    panic!("No declaration found with name: {}", assertion.symbol_name);
+                }
+            };
+
+            let events = match events_by_pos.get(&assertion.range.start()) {
+                Some(events) => events,
+                None => {
+                    panic!("No read event found at this range");
+                }
+            };
+
+            let at_least_one_match = dbg!(events).iter().any(|e| {
+                if let SemanticEvent::Read {
+                    declaration_at: Some(declaration_at_range),
+                    ..
+                } = e
+                {
+                    code[*declaration_at_range] == code[decl.range]
+                } else {
+                    false
+                }
+            });
+
+            if !at_least_one_match {
+                panic!("No matching read event found at this range");
+            }
+        }
+
         // Check every at scope assertion is ok
 
         for assertion in self.at_scope_assertions.iter() {
diff --git a/crates/rome_js_semantic/src/tests/mod.rs b/crates/rome_js_semantic/src/tests/mod.rs
index 55479ac409f..846801c0935 100644
--- a/crates/rome_js_semantic/src/tests/mod.rs
+++ b/crates/rome_js_semantic/src/tests/mod.rs
@@ -1,5 +1,6 @@
 mod assertions;
 pub mod declarations;
+mod references;
 pub mod scopes;
 
 #[macro_export]
diff --git a/crates/rome_js_semantic/src/tests/references.rs b/crates/rome_js_semantic/src/tests/references.rs
new file mode 100644
index 00000000000..ff69d5153e4
--- /dev/null
+++ b/crates/rome_js_semantic/src/tests/references.rs
@@ -0,0 +1,17 @@
+use crate::assert_semantics;
+
+assert_semantics! {
+    ok_reference_read_global, "let a/*#A*/ = 1; let b = a/*READ A*/ + 1;",
+    ok_reference_read_inner_scope, r#"function f(a/*#A1*/) {
+    let b = a/*READ A1*/ + 1;
+    console.log(b);
+    if (true) {
+        let a/*#A2*/ = 2;
+        let b = a/*READ A2*/ + 1;
+        console.log(b);
+    }
+    let c = a/*READ A1*/ + 1;
+    console.log(b);
+}
+f(1);"#,
+}
diff --git a/crates/rome_rowan/src/cursor/token.rs b/crates/rome_rowan/src/cursor/token.rs
index 2790bd95958..f7479bd9376 100644
--- a/crates/rome_rowan/src/cursor/token.rs
+++ b/crates/rome_rowan/src/cursor/token.rs
@@ -104,6 +104,14 @@ impl SyntaxToken {
         SyntaxTokenText::new(self.green().to_owned())
     }
 
+    #[inline]
+    pub fn token_text_trimmed(&self) -> SyntaxTokenText {
+        let green = self.green().to_owned();
+        let mut range = self.text_trimmed_range();
+        range -= self.data().offset;
+        SyntaxTokenText::with_range(green, range)
+    }
+
     #[inline]
     pub fn text_trimmed(&self) -> &str {
         self.green().text_trimmed()
diff --git a/crates/rome_rowan/src/syntax/token.rs b/crates/rome_rowan/src/syntax/token.rs
index 6ebdc7a1578..ecf34c9764f 100644
--- a/crates/rome_rowan/src/syntax/token.rs
+++ b/crates/rome_rowan/src/syntax/token.rs
@@ -115,6 +115,10 @@ impl<L: Language> SyntaxToken<L> {
         self.raw.token_text()
     }
 
+    pub fn token_text_trimmed(&self) -> SyntaxTokenText {
+        self.raw.token_text_trimmed()
+    }
+
     /// Returns the text of the token, excluding all trivia.
     ///
     /// ```
diff --git a/crates/rome_rowan/src/syntax_token_text.rs b/crates/rome_rowan/src/syntax_token_text.rs
index ab06611ed90..577ac1f832c 100644
--- a/crates/rome_rowan/src/syntax_token_text.rs
+++ b/crates/rome_rowan/src/syntax_token_text.rs
@@ -12,12 +12,23 @@ pub struct SyntaxTokenText {
     range: TextRange,
 }
 
+impl std::hash::Hash for SyntaxTokenText {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.text().hash(state);
+    }
+}
+
 impl SyntaxTokenText {
     pub(crate) fn new(token: GreenToken) -> SyntaxTokenText {
         let range = TextRange::at(TextSize::default(), token.text_len());
         Self { token, range }
     }
 
+    pub(crate) fn with_range(token: GreenToken, range: TextRange) -> SyntaxTokenText {
+        debug_assert!(range.end() <= token.text_len());
+        Self { token, range }
+    }
+
     /// Returns the length of the text
     pub fn len(&self) -> TextSize {
         self.range.len()
diff --git a/xtask/coverage/src/symbols/msts.rs b/xtask/coverage/src/symbols/msts.rs
index 0a16dad3e1a..7299643a64b 100644
--- a/xtask/coverage/src/symbols/msts.rs
+++ b/xtask/coverage/src/symbols/msts.rs
@@ -78,10 +78,13 @@ impl TestCase for SymbolsMicrosoftTestCase {
                 // We filter any event pointing to string literals.
                 // We do the same below because TS classifies some string literals as symbols and we also
                 // filter them below.
-                let name = x.str(&code);
-                matches!(x, SemanticEvent::DeclarationFound { .. })
-                    && !name.contains('\"')
-                    && !name.contains('\'')
+                match x {
+                    SemanticEvent::DeclarationFound { .. } | SemanticEvent::Read { .. } => {
+                        let name = x.str(&code);
+                        !name.contains('\"') && !name.contains('\'')
+                    }
+                    _ => false,
+                }
             })
             .collect();
         actual.sort_by_key(|x| x.range().start());