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(codegen): add GetSpan requirement to Gen trait (#5772)

Browse source
This commit is contained in:
Boshen 2024-09-14 11:13:12 +00:00
parent 4abfa7682a
commit 7caae5bca7
4 changed files with 78 additions and 115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
crates/oxc_ast/src/ast_impl/ts.rs
View file

@ -159,6 +159,16 @@ impl<'a> TSModuleDeclaration<'a> {
}
}
impl TSModuleDeclarationKind {
pub fn as_str(&self) -> &str {
match self {
Self::Global => "global",
Self::Module => "module",
Self::Namespace => "namespace",
}
}
}
impl<'a> TSModuleDeclarationName<'a> {
pub fn is_string_literal(&self) -> bool {
matches!(self, Self::StringLiteral(_))

29
crates/oxc_codegen/src/binary_expr_visitor.rs
View file

@ -9,10 +9,7 @@ use oxc_syntax::{
precedence::{GetPrecedence, Precedence},
};
use crate::{
gen::{Gen, GenExpr},
Codegen, Context,
};
use crate::{gen::GenExpr, Codegen, Context, Operator};
#[derive(Clone, Copy)]
pub enum Binaryish<'a> {
@ -49,11 +46,25 @@ pub enum BinaryishOperator {
Logical(LogicalOperator),
}
impl Gen for BinaryishOperator {
fn gen(&self, p: &mut Codegen, ctx: Context) {
fn print_binary_operator(op: BinaryOperator, p: &mut Codegen) {
let operator = op.as_str();
if op.is_keyword() {
p.print_space_before_identifier();
p.print_str(operator);
} else {
let op: Operator = op.into();
p.print_space_before_operator(op);
p.print_str(operator);
p.prev_op = Some(op);
p.prev_op_end = p.code().len();
}
}
impl BinaryishOperator {
fn gen(self, p: &mut Codegen) {
match self {
Self::Binary(op) => op.gen(p, ctx),
Self::Logical(op) => op.gen(p, ctx),
Self::Binary(op) => print_binary_operator(op, p),
Self::Logical(op) => p.print_str(op.as_str()),
}
}
}
@ -185,7 +196,7 @@ impl<'a> BinaryExpressionVisitor<'a> {
pub fn visit_right_and_finish(&self, p: &mut Codegen) {
p.print_soft_space();
self.operator.gen(p, Context::empty());
self.operator.gen(p);
p.print_soft_space();
self.e.right().gen_expr(p, self.right_precedence, self.ctx & Context::FORBID_IN);
if self.wrap {

149
crates/oxc_codegen/src/gen.rs
View file

@ -1,14 +1,13 @@
use std::{borrow::Cow, ops::Not};
use cow_utils::CowUtils;
use oxc_allocator::{Box, Vec};
#[allow(clippy::wildcard_imports)]
use oxc_ast::ast::*;
use oxc_span::GetSpan;
use oxc_syntax::{
identifier::{LS, PS},
keyword::is_reserved_keyword_or_global_object,
operator::{BinaryOperator, LogicalOperator, UnaryOperator},
operator::UnaryOperator,
precedence::{GetPrecedence, Precedence},
};
@ -18,32 +17,12 @@ use crate::{
Codegen, Context, Operator,
};
pub trait Gen {
#[allow(unused_variables)]
fn gen(&self, p: &mut Codegen, ctx: Context) {}
pub trait Gen: GetSpan {
fn gen(&self, p: &mut Codegen, ctx: Context);
}
pub trait GenExpr {
#[allow(unused_variables)]
fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) {}
}
impl<'a, T> Gen for Box<'a, T>
where
T: Gen,
{
fn gen(&self, p: &mut Codegen, ctx: Context) {
(**self).gen(p, ctx);
}
}
impl<'a, T> GenExpr for Box<'a, T>
where
T: GenExpr,
{
fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) {
(**self).gen_expr(p, precedence, ctx);
}
pub trait GenExpr: GetSpan {
fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context);
}
impl<'a> Gen for Program<'a> {
@ -679,9 +658,13 @@ impl<'a> Gen for FunctionBody<'a> {
impl<'a> Gen for FormalParameter<'a> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
self.decorators.gen(p, ctx);
for decorator in &self.decorators {
decorator.gen(p, ctx);
p.print_hard_space();
}
if let Some(accessibility) = self.accessibility {
accessibility.gen(p, ctx);
p.print_str(accessibility.as_str());
p.print_hard_space();
}
if self.readonly {
p.print_str("readonly ");
@ -1716,28 +1699,6 @@ impl<'a> GenExpr for BinaryExpression<'a> {
}
}
impl Gen for LogicalOperator {
fn gen(&self, p: &mut Codegen, _ctx: Context) {
p.print_str(self.as_str());
}
}
impl Gen for BinaryOperator {
fn gen(&self, p: &mut Codegen, _ctx: Context) {
let operator = self.as_str();
if self.is_keyword() {
p.print_space_before_identifier();
p.print_str(operator);
} else {
let op: Operator = (*self).into();
p.print_space_before_operator(op);
p.print_str(operator);
p.prev_op = Some(op);
p.prev_op_end = p.code().len();
}
}
}
impl<'a> GenExpr for PrivateInExpression<'a> {
fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) {
p.wrap(precedence >= Precedence::Compare, |p| {
@ -1868,7 +1829,15 @@ impl<'a> Gen for ArrayAssignmentTarget<'a> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
p.add_source_mapping(self.span.start);
p.print_char(b'[');
p.print_list(&self.elements, ctx);
for (index, item) in self.elements.iter().enumerate() {
if index != 0 {
p.print_comma();
p.print_soft_space();
}
if let Some(item) = item {
item.gen(p, ctx);
}
}
if let Some(target) = &self.rest {
if !self.elements.is_empty() {
p.print_comma();
@ -1884,14 +1853,6 @@ impl<'a> Gen for ArrayAssignmentTarget<'a> {
}
}
impl<'a> Gen for Option<AssignmentTargetMaybeDefault<'a>> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
if let Some(arg) = self {
arg.gen(p, ctx);
}
}
}
impl<'a> Gen for ObjectAssignmentTarget<'a> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
p.add_source_mapping(self.span.start);
@ -2166,7 +2127,10 @@ impl<'a> Gen for Class<'a> {
let n = p.code_len();
let wrap = self.is_expression() && (p.start_of_stmt == n || p.start_of_default_export == n);
p.wrap(wrap, |p| {
self.decorators.gen(p, ctx);
for decorator in &self.decorators {
decorator.gen(p, ctx);
p.print_hard_space();
}
if self.declare {
p.print_str("declare ");
}
@ -2469,10 +2433,14 @@ impl<'a> Gen for StaticBlock<'a> {
impl<'a> Gen for MethodDefinition<'a> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
p.add_source_mapping(self.span.start);
self.decorators.gen(p, ctx);
for decorator in &self.decorators {
decorator.gen(p, ctx);
p.print_hard_space();
}
if let Some(accessibility) = &self.accessibility {
accessibility.gen(p, ctx);
p.print_str(accessibility.as_str());
p.print_hard_space();
}
if self.r#type == MethodDefinitionType::TSAbstractMethodDefinition {
p.print_str("abstract ");
@ -2532,12 +2500,16 @@ impl<'a> Gen for MethodDefinition<'a> {
impl<'a> Gen for PropertyDefinition<'a> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
p.add_source_mapping(self.span.start);
self.decorators.gen(p, ctx);
for decorator in &self.decorators {
decorator.gen(p, ctx);
p.print_hard_space();
}
if self.declare {
p.print_str("declare ");
}
if let Some(accessibility) = &self.accessibility {
accessibility.gen(p, ctx);
if let Some(accessibility) = self.accessibility {
p.print_str(accessibility.as_str());
p.print_hard_space();
}
if self.r#type == PropertyDefinitionType::TSAbstractPropertyDefinition {
p.print_str("abstract ");
@ -2575,12 +2547,16 @@ impl<'a> Gen for PropertyDefinition<'a> {
impl<'a> Gen for AccessorProperty<'a> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
p.add_source_mapping(self.span.start);
self.decorators.gen(p, ctx);
for decorator in &self.decorators {
decorator.gen(p, ctx);
p.print_hard_space();
}
if self.r#type.is_abstract() {
p.print_str("abstract ");
}
if let Some(accessibility) = &self.accessibility {
accessibility.gen(p, ctx);
if let Some(accessibility) = self.accessibility {
p.print_str(accessibility.as_str());
p.print_hard_space();
}
if self.r#static {
p.print_str("static ");
@ -2740,15 +2716,6 @@ impl<'a> Gen for AssignmentPattern<'a> {
}
}
impl<'a> Gen for Vec<'a, Decorator<'a>> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
for decorator in self {
decorator.gen(p, ctx);
p.print_hard_space();
}
}
}
impl<'a> Gen for Decorator<'a> {
fn gen(&self, p: &mut Codegen, _ctx: Context) {
fn need_wrap(expr: &Expression) -> bool {
@ -3427,7 +3394,7 @@ impl<'a> Gen for TSModuleDeclaration<'a> {
if self.declare {
p.print_str("declare ");
}
self.kind.gen(p, ctx);
p.print_str(self.kind.as_str());
// If the kind is global, then the id is also `global`, so we don't need to print it
if !self.kind.is_global() {
p.print_space_before_identifier();
@ -3459,22 +3426,6 @@ impl<'a> Gen for TSModuleDeclaration<'a> {
}
}
impl Gen for TSModuleDeclarationKind {
fn gen(&self, p: &mut Codegen, _: Context) {
match self {
TSModuleDeclarationKind::Global => {
p.print_str("global");
}
TSModuleDeclarationKind::Module => {
p.print_str("module");
}
TSModuleDeclarationKind::Namespace => {
p.print_str("namespace");
}
}
}
}
impl<'a> Gen for TSModuleDeclarationName<'a> {
fn gen(&self, p: &mut Codegen, ctx: Context) {
match self {
@ -3639,13 +3590,3 @@ impl<'a> Gen for TSModuleReference<'a> {
}
}
}
impl Gen for TSAccessibility {
fn gen(&self, p: &mut Codegen, _ctx: Context) {
match self {
Self::Public => p.print_str("public "),
Self::Private => p.print_str("private "),
Self::Protected => p.print_str("protected "),
}
}
}

5
crates/oxc_linter/src/rules/eslint/no_unsafe_negation.rs
View file

@ -76,7 +76,6 @@ impl NoUnsafeNegation {
/// Precondition:
/// expr.left is `UnaryExpression` whose operator is '!'
fn report_with_fix<'a>(expr: &BinaryExpression, ctx: &LintContext<'a>) {
use oxc_codegen::{Context, Gen};
// Diagnostic points at the unexpected negation
let diagnostic = no_unsafe_negation_diagnostic(expr.operator.as_str(), expr.left.span());
@ -88,7 +87,9 @@ impl NoUnsafeNegation {
let Expression::UnaryExpression(left) = &expr.left else { unreachable!() };
codegen.print_char(b'(');
codegen.print_expression(&left.argument);
expr.operator.gen(&mut codegen, Context::default());
codegen.print_char(b' ');
codegen.print_str(expr.operator.as_str());
codegen.print_char(b' ');
codegen.print_expression(&expr.right);
codegen.print_char(b')');
codegen.into_source_text()