refactor(ast): simplify get_identifier_reference of TSType and TSTypeName

crates/oxc_ast/src/ast_impl/ts.rs

@@ -25,19 +25,14 @@ impl<'a> TSType<'a> {
     ///
     /// For qualified (i.e.  namespaced) types, the left-most identifier is
     /// returned.
-    ///
-    /// ```
-    /// let ty = get_type_for("foo.bar.Baz"); // TSType::TSQualifiedName
-    /// get_identifier_reference(&ty); // Some(IdentifierReference { name: "foo", .. })
-    /// ```
-    pub fn get_identifier_reference(&self) -> Option<IdentifierReference<'a>> {
+    pub fn get_identifier_reference(&self) -> Option<&IdentifierReference<'a>> {
         match self {
             TSType::TSTypeReference(reference) => {
-                Some(TSTypeName::get_first_name(&reference.type_name))
+                Some(reference.type_name.get_identifier_reference())
             }
-            TSType::TSQualifiedName(qualified) => Some(TSTypeName::get_first_name(&qualified.left)),
+            TSType::TSQualifiedName(name) => Some(name.left.get_identifier_reference()),
             TSType::TSTypeQuery(query) => match &query.expr_name {
-                TSTypeQueryExprName::IdentifierReference(ident) => Some((*ident).clone()),
+                TSTypeQueryExprName::IdentifierReference(ident) => Some(ident),
                 _ => None,
             },
             _ => None,
@@ -87,10 +82,10 @@ impl<'a> TSTypeName<'a> {
     /// type Foo = Bar; // -> Bar
     /// type Foo = Bar.Baz; // -> Bar
     /// ```
-    pub fn get_first_name(name: &TSTypeName<'a>) -> IdentifierReference<'a> {
-        match name {
-            TSTypeName::IdentifierReference(name) => (*name).clone(),
-            TSTypeName::QualifiedName(name) => TSTypeName::get_first_name(&name.left),
+    pub fn get_identifier_reference(&self) -> &IdentifierReference<'a> {
+        match self {
+            TSTypeName::IdentifierReference(ident) => ident,
+            TSTypeName::QualifiedName(name) => name.left.get_identifier_reference(),
         }
     }
 

crates/oxc_isolated_declarations/src/scope.rs

@@ -112,7 +112,7 @@ impl<'a> Visit<'a> for ScopeTree<'a> {
 
     fn visit_ts_type_query(&mut self, ty: &TSTypeQuery<'a>) {
         if let Some(type_name) = ty.expr_name.as_ts_type_name() {
-            let ident = TSTypeName::get_first_name(type_name);
+            let ident = TSTypeName::get_identifier_reference(type_name);
             self.add_reference(ident.name.clone(), KindFlags::Value);
         } else {
             walk_ts_type_query(self, ty);

crates/oxc_linter/src/rules/typescript/array_type.rs

@@ -344,7 +344,7 @@ fn is_simple_type(ts_type: &TSType) -> bool {
         | TSType::TSQualifiedName(_)
         | TSType::TSThisType(_) => true,
         TSType::TSTypeReference(node) => {
-            let type_name = TSTypeName::get_first_name(&node.type_name);
+            let type_name = TSTypeName::get_identifier_reference(&node.type_name);
             if type_name.name.as_str() == "Array" {
                 if node.type_parameters.is_none() {
                     return true;