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

refactor(semantic): rename SemanticBuilder::current_reference_flags field (#5027)

Browse source 
Part of #4991.
This commit is contained in:
overlookmotel 2024-08-21 00:19:58 +00:00
parent 0bacdd8102
commit 3b7de18eb2
1 changed files with 30 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

60
crates/oxc_semantic/src/builder.rs
View file

@ -82,7 +82,7 @@ pub struct SemanticBuilder<'a> {
// and when we reach a value declaration we set it // and when we reach a value declaration we set it
// to value like // to value like
pub(crate) namespace_stack: Vec<SymbolId>, pub(crate) namespace_stack: Vec<SymbolId>,
current_reference_flag: ReferenceFlags, current_reference_flags: ReferenceFlags,
pub(crate) hoisting_variables: FxHashMap<ScopeId, FxHashMap<Atom<'a>, SymbolId>>, pub(crate) hoisting_variables: FxHashMap<ScopeId, FxHashMap<Atom<'a>, SymbolId>>,
// builders // builders
@ -131,7 +131,7 @@ impl<'a> SemanticBuilder<'a> {
current_node_id: AstNodeId::new(0), current_node_id: AstNodeId::new(0),
current_node_flags: NodeFlags::empty(), current_node_flags: NodeFlags::empty(),
current_symbol_flags: SymbolFlags::empty(), current_symbol_flags: SymbolFlags::empty(),
current_reference_flag: ReferenceFlags::empty(), current_reference_flags: ReferenceFlags::empty(),
current_scope_id, current_scope_id,
function_stack: vec![], function_stack: vec![],
namespace_stack: vec![], namespace_stack: vec![],
@ -1743,14 +1743,14 @@ impl<'a> SemanticBuilder<'a> {
AstKind::ExportNamedDeclaration(decl) => { AstKind::ExportNamedDeclaration(decl) => {
self.current_symbol_flags |= SymbolFlags::Export; self.current_symbol_flags |= SymbolFlags::Export;
if decl.export_kind.is_type() { if decl.export_kind.is_type() {
self.current_reference_flag = ReferenceFlags::Type; self.current_reference_flags = ReferenceFlags::Type;
} }
} }
AstKind::ExportSpecifier(s) => { AstKind::ExportSpecifier(s) => {
if self.current_reference_flag.is_type() || s.export_kind.is_type() { if self.current_reference_flags.is_type() || s.export_kind.is_type() {
self.current_reference_flag = ReferenceFlags::Type; self.current_reference_flags = ReferenceFlags::Type;
} else { } else {
self.current_reference_flag = ReferenceFlags::Read | ReferenceFlags::Type; self.current_reference_flags = ReferenceFlags::Read | ReferenceFlags::Type;
} }
} }
AstKind::ImportSpecifier(specifier) => { AstKind::ImportSpecifier(specifier) => {
@ -1839,17 +1839,17 @@ impl<'a> SemanticBuilder<'a> {
type_parameter.bind(self); type_parameter.bind(self);
} }
AstKind::TSInterfaceHeritage(_) => { AstKind::TSInterfaceHeritage(_) => {
self.current_reference_flag = ReferenceFlags::Type; self.current_reference_flags = ReferenceFlags::Type;
} }
AstKind::TSTypeQuery(_) => { AstKind::TSTypeQuery(_) => {
// type A = typeof a; // type A = typeof a;
// ^^^^^^^^ // ^^^^^^^^
self.current_reference_flag = ReferenceFlags::Read | ReferenceFlags::TSTypeQuery; self.current_reference_flags = ReferenceFlags::Read | ReferenceFlags::TSTypeQuery;
} }
AstKind::TSTypeParameterInstantiation(_) => { AstKind::TSTypeParameterInstantiation(_) => {
// type A<T> = typeof a<T>; // type A<T> = typeof a<T>;
// ^^^ avoid treat T as a value and TSTypeQuery // ^^^ avoid treat T as a value and TSTypeQuery
self.current_reference_flag -= ReferenceFlags::Read | ReferenceFlags::TSTypeQuery; self.current_reference_flags -= ReferenceFlags::Read | ReferenceFlags::TSTypeQuery;
} }
AstKind::TSTypeName(_) => { AstKind::TSTypeName(_) => {
match self.nodes.parent_kind(self.current_node_id) { match self.nodes.parent_kind(self.current_node_id) {
@ -1858,15 +1858,15 @@ impl<'a> SemanticBuilder<'a> {
// ^ // ^
AstKind::TSModuleReference(_), AstKind::TSModuleReference(_),
) => { ) => {
self.current_reference_flag = ReferenceFlags::Read; self.current_reference_flags = ReferenceFlags::Read;
} }
Some(AstKind::TSQualifiedName(_)) => { Some(AstKind::TSQualifiedName(_)) => {
// import A = a.b // import A = a.b
// ^^^ Keep the current reference flag // ^^^ Keep the current reference flag
} }
_ => { _ => {
if !self.current_reference_flag.is_ts_type_query() { if !self.current_reference_flags.is_ts_type_query() {
self.current_reference_flag = ReferenceFlags::Type; self.current_reference_flags = ReferenceFlags::Type;
} }
} }
} }
@ -1875,7 +1875,7 @@ impl<'a> SemanticBuilder<'a> {
// export = a; // export = a;
// ^ can reference value or type // ^ can reference value or type
if export.expression.is_identifier_reference() { if export.expression.is_identifier_reference() {
self.current_reference_flag = ReferenceFlags::Read | ReferenceFlags::Type; self.current_reference_flags = ReferenceFlags::Read | ReferenceFlags::Type;
} }
} }
AstKind::IdentifierReference(ident) => { AstKind::IdentifierReference(ident) => {
@ -1885,27 +1885,27 @@ impl<'a> SemanticBuilder<'a> {
self.reference_jsx_identifier(ident); self.reference_jsx_identifier(ident);
} }
AstKind::UpdateExpression(_) => { AstKind::UpdateExpression(_) => {
if !self.current_reference_flag.is_type() if !self.current_reference_flags.is_type()
&& self.is_not_expression_statement_parent() && self.is_not_expression_statement_parent()
{ {
self.current_reference_flag |= ReferenceFlags::Read; self.current_reference_flags |= ReferenceFlags::Read;
} }
self.current_reference_flag |= ReferenceFlags::Write; self.current_reference_flags |= ReferenceFlags::Write;
} }
AstKind::AssignmentExpression(expr) => { AstKind::AssignmentExpression(expr) => {
if expr.operator != AssignmentOperator::Assign if expr.operator != AssignmentOperator::Assign
|| self.is_not_expression_statement_parent() || self.is_not_expression_statement_parent()
{ {
self.current_reference_flag |= ReferenceFlags::Read; self.current_reference_flags |= ReferenceFlags::Read;
} }
} }
AstKind::MemberExpression(_) => { AstKind::MemberExpression(_) => {
if !self.current_reference_flag.is_type() { if !self.current_reference_flags.is_type() {
self.current_reference_flag = ReferenceFlags::Read; self.current_reference_flags = ReferenceFlags::Read;
} }
} }
AstKind::AssignmentTarget(_) => { AstKind::AssignmentTarget(_) => {
self.current_reference_flag |= ReferenceFlags::Write; self.current_reference_flags |= ReferenceFlags::Write;
} }
AstKind::LabeledStatement(stmt) => { AstKind::LabeledStatement(stmt) => {
self.label_builder.enter(stmt, self.current_node_id); self.label_builder.enter(stmt, self.current_node_id);
@ -1937,8 +1937,8 @@ impl<'a> SemanticBuilder<'a> {
self.current_symbol_flags -= SymbolFlags::Export; self.current_symbol_flags -= SymbolFlags::Export;
} }
AstKind::ExportSpecifier(_) => { AstKind::ExportSpecifier(_) => {
if !self.current_reference_flag.is_type_only() { if !self.current_reference_flags.is_type_only() {
self.current_reference_flag = ReferenceFlags::empty(); self.current_reference_flags = ReferenceFlags::empty();
} }
} }
AstKind::LabeledStatement(_) => self.label_builder.leave(), AstKind::LabeledStatement(_) => self.label_builder.leave(),
@ -1968,27 +1968,27 @@ impl<'a> SemanticBuilder<'a> {
self.namespace_stack.pop(); self.namespace_stack.pop();
} }
AstKind::TSTypeName(_) => { AstKind::TSTypeName(_) => {
self.current_reference_flag -= ReferenceFlags::Type; self.current_reference_flags -= ReferenceFlags::Type;
} }
AstKind::UpdateExpression(_) => { AstKind::UpdateExpression(_) => {
if self.is_not_expression_statement_parent() { if self.is_not_expression_statement_parent() {
self.current_reference_flag -= ReferenceFlags::Read; self.current_reference_flags -= ReferenceFlags::Read;
} }
self.current_reference_flag -= ReferenceFlags::Write; self.current_reference_flags -= ReferenceFlags::Write;
} }
AstKind::AssignmentExpression(expr) => { AstKind::AssignmentExpression(expr) => {
if expr.operator != AssignmentOperator::Assign if expr.operator != AssignmentOperator::Assign
|| self.is_not_expression_statement_parent() || self.is_not_expression_statement_parent()
{ {
self.current_reference_flag -= ReferenceFlags::Read; self.current_reference_flags -= ReferenceFlags::Read;
} }
} }
AstKind::MemberExpression(_) AstKind::MemberExpression(_)
| AstKind::TSTypeQuery(_) | AstKind::TSTypeQuery(_)
| AstKind::ExportNamedDeclaration(_) => { | AstKind::ExportNamedDeclaration(_) => {
self.current_reference_flag = ReferenceFlags::empty(); self.current_reference_flags = ReferenceFlags::empty();
} }
AstKind::AssignmentTarget(_) => self.current_reference_flag -= ReferenceFlags::Write, AstKind::AssignmentTarget(_) => self.current_reference_flags -= ReferenceFlags::Write,
_ => {} _ => {}
} }
} }
@ -2012,10 +2012,10 @@ impl<'a> SemanticBuilder<'a> {
/// Resolve reference flags for the current ast node. /// Resolve reference flags for the current ast node.
fn resolve_reference_usages(&self) -> ReferenceFlags { fn resolve_reference_usages(&self) -> ReferenceFlags {
if self.current_reference_flag.is_empty() { if self.current_reference_flags.is_empty() {
ReferenceFlags::Read ReferenceFlags::Read
} else { } else {
self.current_reference_flag self.current_reference_flags
} }
} }