feat(ast): align ts ast scope with typescript (#4253)

close: #3969 close: #2023 We need to add scope according to [this](https://github.com/microsoft/TypeScript/blob/d8086f14b6b97c0df34a0cc2f56d4b5926a0c299/src/compiler/binder.ts#L3883-L3962). There are still some ASTs that need to be added to the scope. --- Context from @Boshen: Before this whole journey of fixing symbols and scopes I asked @Dunqing to debug through binder.ts via a debugger to fully understand how it does resolution. We then agreed to align the implementation so that when a problem occurs, we can debug through both implementations and find where our problem is. tsc doesn't have a specification, so we need to align with the reference implementation instead.
oxc-project · Jul 17, 2024 · af4dc01 · af4dc01
1 parent 1f8968a
commit af4dc01
Show file tree

Hide file tree

Showing 15 changed files with 582 additions and 709 deletions.
diff --git a/crates/oxc_ast/src/ast/ts.rs b/crates/oxc_ast/src/ast/ts.rs
@@ -230,7 +230,8 @@ pub use match_ts_type;
 ///
 /// <https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#handbook-content>
 #[visited_node]
-#[derive(Debug, Hash)]
+#[scope]
+#[derive(Debug)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct TSConditionalType<'a> {
@@ -240,6 +241,7 @@ pub struct TSConditionalType<'a> {
     pub extends_type: TSType<'a>,
     pub true_type: TSType<'a>,
     pub false_type: TSType<'a>,
+    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 /// string | string[] | (() => string) | { s: string }
@@ -579,8 +581,7 @@ pub struct TSTypeParameterInstantiation<'a> {
 }
 
 #[visited_node]
-#[scope]
-#[derive(Debug)]
+#[derive(Debug, Hash)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct TSTypeParameter<'a> {
@@ -592,7 +593,6 @@ pub struct TSTypeParameter<'a> {
     pub r#in: bool,
     pub out: bool,
     pub r#const: bool,
-    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 #[visited_node]
@@ -606,16 +606,19 @@ pub struct TSTypeParameterDeclaration<'a> {
 }
 
 #[visited_node]
-#[derive(Debug, Hash)]
+#[scope]
+#[derive(Debug)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct TSTypeAliasDeclaration<'a> {
     #[cfg_attr(feature = "serialize", serde(flatten))]
     pub span: Span,
     pub id: BindingIdentifier<'a>,
+    #[scope(enter_before)]
     pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     pub type_annotation: TSType<'a>,
     pub declare: bool,
+    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -642,17 +645,20 @@ pub struct TSClassImplements<'a> {
 ///
 ///   interface `BindingIdentifier` `TypeParameters_opt` `InterfaceExtendsClause_opt` `ObjectType`
 #[visited_node]
-#[derive(Debug, Hash)]
+#[scope]
+#[derive(Debug)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct TSInterfaceDeclaration<'a> {
     #[cfg_attr(feature = "serialize", serde(flatten))]
     pub span: Span,
     pub id: BindingIdentifier<'a>,
+    #[scope(enter_before)]
     pub extends: Option<Vec<'a, TSInterfaceHeritage<'a>>>,
     pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     pub body: Box<'a, TSInterfaceBody<'a>>,
     pub declare: bool,
+    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 #[visited_node]
@@ -726,7 +732,8 @@ pub enum TSMethodSignatureKind {
 }
 
 #[visited_node]
-#[derive(Debug, Hash)]
+#[scope]
+#[derive(Debug)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct TSMethodSignature<'a> {
@@ -740,10 +747,12 @@ pub struct TSMethodSignature<'a> {
     pub params: Box<'a, FormalParameters<'a>>,
     pub return_type: Option<Box<'a, TSTypeAnnotation<'a>>>,
     pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
+    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 #[visited_node]
-#[derive(Debug, Hash)]
+#[scope]
+#[derive(Debug)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct TSConstructSignatureDeclaration<'a> {
@@ -752,6 +761,7 @@ pub struct TSConstructSignatureDeclaration<'a> {
     pub params: Box<'a, FormalParameters<'a>>,
     pub return_type: Option<Box<'a, TSTypeAnnotation<'a>>>,
     pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
+    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 #[visited_node]
@@ -994,7 +1004,8 @@ pub struct TSConstructorType<'a> {
 }
 
 #[visited_node]
-#[derive(Debug, Hash)]
+#[scope]
+#[derive(Debug)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct TSMappedType<'a> {
@@ -1005,6 +1016,7 @@ pub struct TSMappedType<'a> {
     pub type_annotation: Option<TSType<'a>>,
     pub optional: TSMappedTypeModifierOperator,
     pub readonly: TSMappedTypeModifierOperator,
+    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

diff --git a/crates/oxc_ast/src/ast_impl/ts.rs b/crates/oxc_ast/src/ast_impl/ts.rs
@@ -103,31 +103,6 @@ impl<'a> TSTypeName<'a> {
     }
 }
 
-impl<'a> TSTypeParameter<'a> {
-    pub fn new(
-        span: Span,
-        name: BindingIdentifier<'a>,
-        constraint: Option<TSType<'a>>,
-        default: Option<TSType<'a>>,
-        r#in: bool,
-        out: bool,
-        r#const: bool,
-    ) -> Self {
-        Self { span, name, constraint, default, r#in, out, r#const, scope_id: Cell::default() }
-    }
-}
-
-impl<'a> Hash for TSTypeParameter<'a> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-        self.constraint.hash(state);
-        self.default.hash(state);
-        self.r#in.hash(state);
-        self.out.hash(state);
-        self.r#const.hash(state);
-    }
-}
-
 impl<'a> TSType<'a> {
     /// Remove nested parentheses from this type.
     pub fn without_parenthesized(&self) -> &Self {
@@ -233,3 +208,68 @@ impl ImportOrExportKind {
         matches!(self, Self::Type)
     }
 }
+
+impl<'a> Hash for TSMappedType<'a> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.span.hash(state);
+        self.type_parameter.hash(state);
+        self.name_type.hash(state);
+        self.type_annotation.hash(state);
+        self.optional.hash(state);
+        self.readonly.hash(state);
+    }
+}
+
+impl<'a> Hash for TSConditionalType<'a> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.span.hash(state);
+        self.check_type.hash(state);
+        self.extends_type.hash(state);
+        self.true_type.hash(state);
+        self.false_type.hash(state);
+    }
+}
+
+impl<'a> Hash for TSInterfaceDeclaration<'a> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.span.hash(state);
+        self.id.hash(state);
+        self.type_parameters.hash(state);
+        self.extends.hash(state);
+        self.body.hash(state);
+        self.declare.hash(state);
+    }
+}
+
+impl<'a> Hash for TSTypeAliasDeclaration<'a> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.span.hash(state);
+        self.id.hash(state);
+        self.type_parameters.hash(state);
+        self.type_annotation.hash(state);
+        self.declare.hash(state);
+    }
+}
+
+impl<'a> Hash for TSMethodSignature<'a> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.span.hash(state);
+        self.key.hash(state);
+        self.computed.hash(state);
+        self.optional.hash(state);
+        self.kind.hash(state);
+        self.this_param.hash(state);
+        self.params.hash(state);
+        self.return_type.hash(state);
+        self.type_parameters.hash(state);
+    }
+}
+
+impl<'a> Hash for TSConstructSignatureDeclaration<'a> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.span.hash(state);
+        self.params.hash(state);
+        self.return_type.hash(state);
+        self.type_parameters.hash(state);
+    }
+}
diff --git a/crates/oxc_ast/src/ast_kind_impl.rs b/crates/oxc_ast/src/ast_kind_impl.rs
@@ -345,6 +345,9 @@ impl<'a> AstKind<'a> {
             Self::TSNamedTupleMember(_) => "TSNamedTupleMember".into(),
 
             Self::TSPropertySignature(_) => "TSPropertySignature".into(),
+            Self::TSConditionalType(_) => "TSConditionalType".into(),
+            Self::TSMappedType(_) => "TSMappedType".into(),
+            Self::TSConstructSignatureDeclaration(_) => "TSConstructSignatureDeclaration".into(),
         }
     }
 }
diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs
@@ -6062,7 +6062,14 @@ impl<'a> AstBuilder<'a> {
         true_type: TSType<'a>,
         false_type: TSType<'a>,
     ) -> TSConditionalType<'a> {
-        TSConditionalType { span, check_type, extends_type, true_type, false_type }
+        TSConditionalType {
+            span,
+            check_type,
+            extends_type,
+            true_type,
+            false_type,
+            scope_id: Default::default(),
+        }
     }
 
     #[inline]
@@ -6542,16 +6549,7 @@ impl<'a> AstBuilder<'a> {
         out: bool,
         r#const: bool,
     ) -> TSTypeParameter<'a> {
-        TSTypeParameter {
-            span,
-            name,
-            constraint,
-            default,
-            r#in,
-            out,
-            r#const,
-            scope_id: Default::default(),
-        }
+        TSTypeParameter { span, name, constraint, default, r#in, out, r#const }
     }
 
     #[inline]
@@ -6605,6 +6603,7 @@ impl<'a> AstBuilder<'a> {
             type_parameters: type_parameters.into_in(self.allocator),
             type_annotation,
             declare,
+            scope_id: Default::default(),
         }
     }
 
@@ -6675,6 +6674,7 @@ impl<'a> AstBuilder<'a> {
             type_parameters: type_parameters.into_in(self.allocator),
             body: body.into_in(self.allocator),
             declare,
+            scope_id: Default::default(),
         }
     }
 
@@ -7013,6 +7013,7 @@ impl<'a> AstBuilder<'a> {
             params: params.into_in(self.allocator),
             return_type: return_type.into_in(self.allocator),
             type_parameters: type_parameters.into_in(self.allocator),
+            scope_id: Default::default(),
         }
     }
 
@@ -7066,6 +7067,7 @@ impl<'a> AstBuilder<'a> {
             params: params.into_in(self.allocator),
             return_type: return_type.into_in(self.allocator),
             type_parameters: type_parameters.into_in(self.allocator),
+            scope_id: Default::default(),
         }
     }
 
@@ -7678,6 +7680,7 @@ impl<'a> AstBuilder<'a> {
             type_annotation,
             optional,
             readonly,
+            scope_id: Default::default(),
         }
     }
 

diff --git a/crates/oxc_ast/src/generated/ast_kind.rs b/crates/oxc_ast/src/generated/ast_kind.rs
@@ -107,6 +107,7 @@ pub enum AstType {
     TSEnumMember,
     TSTypeAnnotation,
     TSLiteralType,
+    TSConditionalType,
     TSUnionType,
     TSIntersectionType,
     TSParenthesizedType,
@@ -137,13 +138,15 @@ pub enum AstType {
     TSInterfaceDeclaration,
     TSPropertySignature,
     TSMethodSignature,
+    TSConstructSignatureDeclaration,
     TSInterfaceHeritage,
     TSModuleDeclaration,
     TSModuleBlock,
     TSTypeLiteral,
     TSInferType,
     TSTypeQuery,
     TSImportType,
+    TSMappedType,
     TSTemplateLiteralType,
     TSAsExpression,
     TSSatisfiesExpression,
@@ -273,6 +276,7 @@ pub enum AstKind<'a> {
     TSEnumMember(&'a TSEnumMember<'a>),
     TSTypeAnnotation(&'a TSTypeAnnotation<'a>),
     TSLiteralType(&'a TSLiteralType<'a>),
+    TSConditionalType(&'a TSConditionalType<'a>),
     TSUnionType(&'a TSUnionType<'a>),
     TSIntersectionType(&'a TSIntersectionType<'a>),
     TSParenthesizedType(&'a TSParenthesizedType<'a>),
@@ -303,13 +307,15 @@ pub enum AstKind<'a> {
     TSInterfaceDeclaration(&'a TSInterfaceDeclaration<'a>),
     TSPropertySignature(&'a TSPropertySignature<'a>),
     TSMethodSignature(&'a TSMethodSignature<'a>),
+    TSConstructSignatureDeclaration(&'a TSConstructSignatureDeclaration<'a>),
     TSInterfaceHeritage(&'a TSInterfaceHeritage<'a>),
     TSModuleDeclaration(&'a TSModuleDeclaration<'a>),
     TSModuleBlock(&'a TSModuleBlock<'a>),
     TSTypeLiteral(&'a TSTypeLiteral<'a>),
     TSInferType(&'a TSInferType<'a>),
     TSTypeQuery(&'a TSTypeQuery<'a>),
     TSImportType(&'a TSImportType<'a>),
+    TSMappedType(&'a TSMappedType<'a>),
     TSTemplateLiteralType(&'a TSTemplateLiteralType<'a>),
     TSAsExpression(&'a TSAsExpression<'a>),
     TSSatisfiesExpression(&'a TSSatisfiesExpression<'a>),
@@ -440,6 +446,7 @@ impl<'a> GetSpan for AstKind<'a> {
             Self::TSEnumMember(it) => it.span(),
             Self::TSTypeAnnotation(it) => it.span(),
             Self::TSLiteralType(it) => it.span(),
+            Self::TSConditionalType(it) => it.span(),
             Self::TSUnionType(it) => it.span(),
             Self::TSIntersectionType(it) => it.span(),
             Self::TSParenthesizedType(it) => it.span(),
@@ -470,13 +477,15 @@ impl<'a> GetSpan for AstKind<'a> {
             Self::TSInterfaceDeclaration(it) => it.span(),
             Self::TSPropertySignature(it) => it.span(),
             Self::TSMethodSignature(it) => it.span(),
+            Self::TSConstructSignatureDeclaration(it) => it.span(),
             Self::TSInterfaceHeritage(it) => it.span(),
             Self::TSModuleDeclaration(it) => it.span(),
             Self::TSModuleBlock(it) => it.span(),
             Self::TSTypeLiteral(it) => it.span(),
             Self::TSInferType(it) => it.span(),
             Self::TSTypeQuery(it) => it.span(),
             Self::TSImportType(it) => it.span(),
+            Self::TSMappedType(it) => it.span(),
             Self::TSTemplateLiteralType(it) => it.span(),
             Self::TSAsExpression(it) => it.span(),
             Self::TSSatisfiesExpression(it) => it.span(),