dan/oxc
1
0
Fork 0
mirror of https://github.com/danbulant/oxc synced 2026-05-19 12:19:15 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor(isolated-declarations): remove useless code from scope (#4420)

Browse source 
The original logic was written to fix incorrect TypeScript ast scopes. Now the scopes are correct so they can be removed
This commit is contained in:
Dunqing 2024-07-23 09:39:16 +00:00
parent 25dab7b1ac
commit 0e1ea90282
1 changed files with 1 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

131
crates/oxc_isolated_declarations/src/scope.rs
View file

@ -50,8 +50,7 @@ impl<'a> ScopeTree<'a> {
}
pub fn has_reference(&self, name: &str) -> bool {
// XXX(lucab): this should probably unwrap?
let Some(scope) = self.levels.last() else { return false };
let Some(scope) = self.levels.last() else { unreachable!() };
scope.value_references.contains(name) || scope.type_references.contains(name)
}
@ -194,132 +193,4 @@ impl<'a> Visit<'a> for ScopeTree<'a> {
}
walk_declaration(self, declaration);
}
// ==================== TSTypeParameter ====================
fn visit_ts_type_parameter(&mut self, it: &TSTypeParameter<'a>) {
self.add_type_binding(it.name.name.clone());
if let Some(constraint) = &it.constraint {
self.visit_ts_type(constraint);
}
if let Some(default) = &it.default {
self.visit_ts_type(default);
}
}
/// ```ts
/// function foo<T>(x: T): T {
/// ^^^
/// `T` is a type parameter
/// return x;
/// }
/// ```
/// We should create a new scope for TSTypeParameterDeclaration
/// Because the type parameter is can be used in following nodes
/// until the end of the function. So we leave the scope in the parent node (Function)
fn visit_ts_type_parameter_declaration(&mut self, decl: &TSTypeParameterDeclaration<'a>) {
// TODO: doesn't have a scope_id!
self.enter_scope(ScopeFlags::empty(), &Cell::default());
decl.params.iter().for_each(|param| self.visit_ts_type_parameter(param));
// exit scope in parent AST node
}
fn visit_class(&mut self, class: &Class<'a>) {
walk_class(self, class);
if class.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_function(&mut self, func: &Function<'a>, flags: ScopeFlags) {
walk_function(self, func, flags);
if func.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_arrow_function_expression(&mut self, expr: &ArrowFunctionExpression<'a>) {
walk_arrow_function_expression(self, expr);
if expr.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_ts_type_alias_declaration(&mut self, decl: &TSTypeAliasDeclaration<'a>) {
walk_ts_type_alias_declaration(self, decl);
if decl.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_ts_interface_declaration(&mut self, decl: &TSInterfaceDeclaration<'a>) {
walk_ts_interface_declaration(self, decl);
if decl.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_ts_call_signature_declaration(&mut self, signature: &TSCallSignatureDeclaration<'a>) {
walk_ts_call_signature_declaration(self, signature);
if signature.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_ts_method_signature(&mut self, signature: &TSMethodSignature<'a>) {
walk_ts_method_signature(self, signature);
if signature.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_ts_construct_signature_declaration(
&mut self,
signature: &TSConstructSignatureDeclaration<'a>,
) {
walk_ts_construct_signature_declaration(self, signature);
if signature.type_parameters.is_some() {
self.leave_scope();
}
}
fn visit_ts_function_type(&mut self, signature: &TSFunctionType<'a>) {
walk_ts_function_type(self, signature);
if signature.type_parameters.is_some() {
self.leave_scope();
}
}
/// `type D = { [key in keyof T]: K };`
/// ^^^^^^^^^^^^^^^^^^^^
/// We need to add both `T` and `K` to the scope
fn visit_ts_mapped_type(&mut self, ty: &TSMappedType<'a>) {
// TODO: doesn't have a scope_id!
self.enter_scope(ScopeFlags::empty(), &Cell::default());
// copy from walk_ts_mapped_type
self.visit_ts_type_parameter(&ty.type_parameter);
if let Some(name) = &ty.name_type {
self.visit_ts_type(name);
}
if let Some(type_annotation) = &ty.type_annotation {
self.visit_ts_type(type_annotation);
}
self.leave_scope();
}
/// `export type Flatten<Type> = Type extends Array<infer Item> ? Item : Type;`
/// ^^^^^^^^^^
/// `Item` is a type parameter
/// We need to add `Item` to the scope
fn visit_conditional_expression(&mut self, expr: &ConditionalExpression<'a>) {
// TODO: doesn't have a scope_id!
self.enter_scope(ScopeFlags::empty(), &Cell::default());
walk_conditional_expression(self, expr);
self.leave_scope();
}
fn visit_ts_infer_type(&mut self, ty: &TSInferType<'a>) {
// copy from walk_ts_infer_type
self.visit_ts_type_parameter(&ty.type_parameter);
}
}