From bc85b2bc1a5fd3b520948abdd15e6ec776f0fad5 Mon Sep 17 00:00:00 2001 From: overlookmotel Date: Fri, 22 Nov 2024 09:06:56 +0000 Subject: [PATCH] feat(traverse): add methods to `BoundIdentifier` + `MaybeBoundIdentifier` to create `SimpleAssignmentTarget`s --- .../src/context/bound_identifier.rs | 59 ++++++++++++++++++- .../src/context/maybe_bound_identifier.rs | 59 ++++++++++++++++++- 2 files changed, 116 insertions(+), 2 deletions(-) diff --git a/crates/oxc_traverse/src/context/bound_identifier.rs b/crates/oxc_traverse/src/context/bound_identifier.rs index ba46995c387ba2..793fe6603a842a 100644 --- a/crates/oxc_traverse/src/context/bound_identifier.rs +++ b/crates/oxc_traverse/src/context/bound_identifier.rs @@ -1,7 +1,7 @@ use oxc_ast::{ ast::{ AssignmentTarget, BindingIdentifier, BindingPattern, BindingPatternKind, Expression, - IdentifierReference, + IdentifierReference, SimpleAssignmentTarget, }, NONE, }; @@ -120,6 +120,14 @@ impl<'a> BoundIdentifier<'a> { self.create_spanned_write_target(SPAN, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is written to, with dummy `Span` + pub fn create_write_simple_target( + &self, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_write_simple_target(SPAN, ctx) + } + /// Create `IdentifierReference` referencing this binding, which is written to, with specified `Span` pub fn create_spanned_write_reference( &self, @@ -147,6 +155,15 @@ impl<'a> BoundIdentifier<'a> { self.create_spanned_target(span, ReferenceFlags::Write, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is written to, with specified `Span` + pub fn create_spanned_write_simple_target( + &self, + span: Span, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_simple_target(span, ReferenceFlags::Write, ctx) + } + // --- Read and write --- /// Create `IdentifierReference` referencing this binding, which is read from + written to, @@ -170,6 +187,15 @@ impl<'a> BoundIdentifier<'a> { self.create_spanned_read_write_target(SPAN, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is read from + written to, + /// with dummy `Span` + pub fn create_read_write_simple_target( + &self, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_read_write_simple_target(SPAN, ctx) + } + /// Create `IdentifierReference` referencing this binding, which is read from + written to, /// with specified `Span` pub fn create_spanned_read_write_reference( @@ -200,6 +226,16 @@ impl<'a> BoundIdentifier<'a> { self.create_spanned_target(span, ReferenceFlags::Read | ReferenceFlags::Write, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is read from + written to, + /// with specified `Span` + pub fn create_spanned_read_write_simple_target( + &self, + span: Span, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_simple_target(span, ReferenceFlags::Read | ReferenceFlags::Write, ctx) + } + // --- Specified ReferenceFlags --- /// Create `IdentifierReference` referencing this binding, with specified `ReferenceFlags` @@ -229,6 +265,15 @@ impl<'a> BoundIdentifier<'a> { self.create_spanned_target(SPAN, flags, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, with specified `ReferenceFlags` + pub fn create_simple_target( + &self, + flags: ReferenceFlags, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_simple_target(SPAN, flags, ctx) + } + /// Create `IdentifierReference` referencing this binding, with specified `Span` and `ReferenceFlags` pub fn create_spanned_reference( &self, @@ -261,4 +306,16 @@ impl<'a> BoundIdentifier<'a> { let ident = self.create_spanned_reference(span, flags, ctx); AssignmentTarget::AssignmentTargetIdentifier(ctx.alloc(ident)) } + + /// Create `SimpleAssignmentTarget::AssignmentTargetIdentifier` referencing this binding, + /// with specified `Span` and `ReferenceFlags` + pub fn create_spanned_simple_target( + &self, + span: Span, + flags: ReferenceFlags, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + let ident = self.create_spanned_reference(span, flags, ctx); + SimpleAssignmentTarget::AssignmentTargetIdentifier(ctx.alloc(ident)) + } } diff --git a/crates/oxc_traverse/src/context/maybe_bound_identifier.rs b/crates/oxc_traverse/src/context/maybe_bound_identifier.rs index e729ba9b396b22..623b7ef2e1fb1f 100644 --- a/crates/oxc_traverse/src/context/maybe_bound_identifier.rs +++ b/crates/oxc_traverse/src/context/maybe_bound_identifier.rs @@ -1,4 +1,4 @@ -use oxc_ast::ast::{AssignmentTarget, Expression, IdentifierReference}; +use oxc_ast::ast::{AssignmentTarget, Expression, IdentifierReference, SimpleAssignmentTarget}; use oxc_span::{Atom, Span, SPAN}; use oxc_syntax::{reference::ReferenceFlags, symbol::SymbolId}; @@ -102,6 +102,14 @@ impl<'a> MaybeBoundIdentifier<'a> { self.create_spanned_write_target(SPAN, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is written to, with dummy `Span` + pub fn create_write_simple_target( + &self, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_write_simple_target(SPAN, ctx) + } + /// Create `IdentifierReference` referencing this binding, which is written to, with specified `Span` pub fn create_spanned_write_reference( &self, @@ -129,6 +137,15 @@ impl<'a> MaybeBoundIdentifier<'a> { self.create_spanned_target(span, ReferenceFlags::Write, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is written to, with specified `Span` + pub fn create_spanned_write_simple_target( + &self, + span: Span, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_simple_target(span, ReferenceFlags::Write, ctx) + } + // --- Read and write --- /// Create `IdentifierReference` referencing this binding, which is read from + written to, @@ -152,6 +169,15 @@ impl<'a> MaybeBoundIdentifier<'a> { self.create_spanned_read_write_target(SPAN, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is read from + written to, + /// with dummy `Span` + pub fn create_read_write_simple_target( + &self, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_read_write_simple_target(SPAN, ctx) + } + /// Create `IdentifierReference` referencing this binding, which is read from + written to, /// with specified `Span` pub fn create_spanned_read_write_reference( @@ -182,6 +208,16 @@ impl<'a> MaybeBoundIdentifier<'a> { self.create_spanned_target(span, ReferenceFlags::Read | ReferenceFlags::Write, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, which is read from + written to, + /// with specified `Span` + pub fn create_spanned_read_write_simple_target( + &self, + span: Span, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_simple_target(span, ReferenceFlags::Read | ReferenceFlags::Write, ctx) + } + // --- Specified ReferenceFlags --- /// Create `IdentifierReference` referencing this binding, with specified `ReferenceFlags` @@ -211,6 +247,15 @@ impl<'a> MaybeBoundIdentifier<'a> { self.create_spanned_target(SPAN, flags, ctx) } + /// Create `SimpleAssignmentTarget` referencing this binding, with specified `ReferenceFlags` + pub fn create_simple_target( + &self, + flags: ReferenceFlags, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + self.create_spanned_simple_target(SPAN, flags, ctx) + } + /// Create `IdentifierReference` referencing this binding, with specified `Span` and `ReferenceFlags` pub fn create_spanned_reference( &self, @@ -243,4 +288,16 @@ impl<'a> MaybeBoundIdentifier<'a> { let ident = self.create_spanned_reference(span, flags, ctx); AssignmentTarget::AssignmentTargetIdentifier(ctx.alloc(ident)) } + + /// Create `SimpleAssignmentTarget::AssignmentTargetIdentifier` referencing this binding, + /// with specified `Span` and `ReferenceFlags` + pub fn create_spanned_simple_target( + &self, + span: Span, + flags: ReferenceFlags, + ctx: &mut TraverseCtx<'a>, + ) -> SimpleAssignmentTarget<'a> { + let ident = self.create_spanned_reference(span, flags, ctx); + SimpleAssignmentTarget::AssignmentTargetIdentifier(ctx.alloc(ident)) + } }