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

refactor(codegen): move gen_ts into gen to make searching things easier (#3680)

Browse source
This commit is contained in:
Boshen 2024-06-15 06:44:14 +00:00
parent 4f166642a0
commit 09b92b6086
3 changed files with 704 additions and 710 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -2553,3 +2553,707 @@ impl<'a, const MINIFY: bool> Gen<MINIFY> for Decorator<'a> {
});
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeParameterDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"<");
p.print_list(&self.params, ctx);
p.print_str(b">");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeAnnotation<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.type_annotation.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::TSFunctionType(decl) => decl.gen(p, ctx),
Self::TSConstructorType(decl) => {
decl.gen(p, ctx);
}
Self::TSArrayType(decl) => {
p.print_str(b"(");
decl.element_type.gen(p, ctx);
p.print_str(b")[]");
}
Self::TSTupleType(decl) => {
p.print_str(b"[");
p.print_list(&decl.element_types, ctx);
p.print_str(b"]");
}
Self::TSUnionType(decl) => {
if decl.types.len() == 1 {
decl.types[0].gen(p, ctx);
return;
}
p.print_str(b"(");
for (index, item) in decl.types.iter().enumerate() {
if index != 0 {
p.print_soft_space();
p.print_str(b"|");
p.print_soft_space();
}
p.print_str(b"(");
item.gen(p, ctx);
p.print_str(b")");
}
p.print_str(b")");
}
Self::TSIntersectionType(decl) => {
if decl.types.len() == 1 {
decl.types[0].gen(p, ctx);
return;
}
p.print_str(b"(");
for (index, item) in decl.types.iter().enumerate() {
if index != 0 {
p.print_soft_space();
p.print_str(b"&");
p.print_soft_space();
}
p.print_str(b"(");
item.gen(p, ctx);
p.print_str(b")");
}
p.print_str(b")");
}
Self::TSConditionalType(decl) => {
decl.check_type.gen(p, ctx);
p.print_str(b" extends (");
decl.extends_type.gen(p, ctx);
p.print_str(b") ? ");
decl.true_type.gen(p, ctx);
p.print_str(b" : ");
decl.false_type.gen(p, ctx);
}
Self::TSInferType(decl) => {
p.print_str(b"infer ");
decl.type_parameter.gen(p, ctx);
}
Self::TSIndexedAccessType(decl) => {
decl.object_type.gen(p, ctx);
p.print_str(b"[");
decl.index_type.gen(p, ctx);
p.print_str(b"]");
}
Self::TSMappedType(decl) => {
p.print_str(b"{");
match decl.readonly {
TSMappedTypeModifierOperator::True => {
p.print_str(b"readonly");
}
TSMappedTypeModifierOperator::Plus => {
p.print_str(b"+readonly");
}
TSMappedTypeModifierOperator::Minus => {
p.print_str(b"-readonly");
}
TSMappedTypeModifierOperator::None => {}
}
p.print_hard_space();
p.print_str(b"[");
decl.type_parameter.name.gen(p, ctx);
if let Some(constraint) = &decl.type_parameter.constraint {
p.print_str(b" in ");
constraint.gen(p, ctx);
}
if let Some(default) = &decl.type_parameter.default {
p.print_str(b" = ");
default.gen(p, ctx);
}
p.print_str(b"]");
match decl.optional {
TSMappedTypeModifierOperator::True => {
p.print_str(b"?");
}
TSMappedTypeModifierOperator::Plus => {
p.print_str(b"+?");
}
TSMappedTypeModifierOperator::Minus => {
p.print_str(b"-?");
}
TSMappedTypeModifierOperator::None => {}
}
p.print_soft_space();
if let Some(type_annotation) = &decl.type_annotation {
p.print_str(b":");
p.print_soft_space();
type_annotation.gen(p, ctx);
}
p.print_semicolon_if_needed();
p.print_str(b"}");
}
Self::TSNamedTupleMember(decl) => {
decl.gen(p, ctx);
}
Self::TSLiteralType(decl) => {
decl.literal.gen(p, ctx);
}
Self::TSImportType(decl) => {
decl.gen(p, ctx);
}
Self::TSQualifiedName(decl) => {
decl.left.gen(p, ctx);
p.print_str(b".");
decl.right.gen(p, ctx);
}
Self::TSAnyKeyword(_) => {
p.print_str(b"any");
}
Self::TSBigIntKeyword(_) => {
p.print_str(b"bigint");
}
Self::TSBooleanKeyword(_) => {
p.print_str(b"boolean");
}
Self::TSNeverKeyword(_) => {
p.print_str(b"never");
}
Self::TSNullKeyword(_) => {
p.print_str(b"null");
}
Self::TSNumberKeyword(_) => {
p.print_str(b"number");
}
Self::TSObjectKeyword(_) => {
p.print_str(b"object");
}
Self::TSStringKeyword(_) => {
p.print_str(b"string");
}
Self::TSSymbolKeyword(_) => {
p.print_str(b"symbol");
}
Self::TSThisType(_) => {
p.print_str(b"this");
}
Self::TSUndefinedKeyword(_) => {
p.print_str(b"undefined");
}
Self::TSUnknownKeyword(_) => {
p.print_str(b"unknown");
}
Self::TSVoidKeyword(_) => {
p.print_str(b"void");
}
Self::TSTemplateLiteralType(decl) => decl.gen(p, ctx),
Self::TSTypeLiteral(decl) => {
p.print_block_start(decl.span.start);
for item in &decl.members {
item.gen(p, ctx);
p.print_semicolon();
}
p.print_block_end(decl.span.end);
}
Self::TSTypeOperatorType(decl) => {
match decl.operator {
TSTypeOperatorOperator::Keyof => {
p.print_str(b"keyof ");
}
TSTypeOperatorOperator::Unique => {
p.print_str(b"unique ");
}
TSTypeOperatorOperator::Readonly => {
p.print_str(b"readonly ");
}
}
decl.type_annotation.gen(p, ctx);
}
Self::TSTypePredicate(decl) => {
if decl.asserts {
p.print_str(b"asserts ");
}
match &decl.parameter_name {
TSTypePredicateName::Identifier(ident) => {
ident.gen(p, ctx);
}
TSTypePredicateName::This(_ident) => {
p.print_str(b"this");
}
}
if let Some(type_annotation) = &decl.type_annotation {
p.print_str(b" is ");
type_annotation.gen(p, ctx);
}
}
Self::TSTypeQuery(decl) => decl.gen(p, ctx),
Self::TSTypeReference(decl) => {
decl.type_name.gen(p, ctx);
if let Some(type_parameters) = &decl.type_parameters {
type_parameters.gen(p, ctx);
}
}
Self::JSDocNullableType(decl) => {
if decl.postfix {
decl.type_annotation.gen(p, ctx);
p.print_str(b"?");
} else {
p.print_str(b"?");
decl.type_annotation.gen(p, ctx);
}
}
Self::JSDocUnknownType(_decl) => p.print_str(b"unknown"),
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTemplateLiteralType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"`");
for (index, item) in self.quasis.iter().enumerate() {
if index != 0 {
if let Some(types) = self.types.get(index - 1) {
p.print_str(b"${");
types.gen(p, ctx);
p.print_str(b"}");
}
}
p.print_str(item.value.raw.as_bytes());
}
p.print_str(b"`");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeName<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::IdentifierReference(decl) => {
p.print_str(decl.name.as_bytes());
}
Self::QualifiedName(decl) => {
decl.left.gen(p, ctx);
p.print_str(b".");
decl.right.gen(p, ctx);
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSLiteral<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::BooleanLiteral(decl) => decl.gen(p, ctx),
Self::NullLiteral(decl) => decl.gen(p, ctx),
Self::NumericLiteral(decl) => decl.gen(p, ctx),
Self::BigintLiteral(decl) => decl.gen(p, ctx),
Self::RegExpLiteral(decl) => decl.gen(p, ctx),
Self::StringLiteral(decl) => decl.gen(p, ctx),
Self::TemplateLiteral(decl) => decl.gen(p, ctx),
Self::UnaryExpression(decl) => decl.gen_expr(p, Precedence::Assign, ctx),
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeParameter<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.name.gen(p, ctx);
if let Some(constraint) = &self.constraint {
p.print_str(b" extends ");
constraint.gen(p, ctx);
}
if let Some(default) = &self.default {
p.print_str(b" = ");
default.gen(p, ctx);
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSFunctionType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b"(");
if let Some(this_param) = &self.this_param {
this_param.this.gen(p, ctx);
p.print_str(b":");
if let Some(type_annotation) = &this_param.type_annotation {
type_annotation.gen(p, ctx);
} else {
p.print_str(b"unknown");
}
if !self.params.is_empty() || self.params.rest.is_some() {
p.print_str(b",");
}
p.print_soft_space();
}
self.params.gen(p, ctx);
p.print_str(b")");
p.print_soft_space();
p.print_str(b"=>");
p.print_soft_space();
self.return_type.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSSignature<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_soft_space();
match self {
Self::TSIndexSignature(signature) => signature.gen(p, ctx),
Self::TSPropertySignature(signature) => {
if signature.readonly {
p.print_str(b"readonly");
p.print_hard_space();
}
if signature.computed {
p.print(b'[');
signature.key.gen(p, ctx);
p.print(b']');
} else {
match &signature.key {
PropertyKey::StaticIdentifier(key) => {
key.gen(p, ctx);
}
PropertyKey::PrivateIdentifier(key) => {
p.print_str(key.name.as_bytes());
}
key @ match_expression!(PropertyKey) => {
key.to_expression().gen_expr(p, Precedence::Assign, ctx);
}
}
}
if signature.optional {
p.print_str(b"?");
}
if let Some(type_annotation) = &signature.type_annotation {
p.print_colon();
p.print_soft_space();
type_annotation.gen(p, ctx);
}
}
Self::TSCallSignatureDeclaration(signature) => {
p.print_str(b"(");
signature.params.gen(p, ctx);
p.print_str(b")");
if let Some(return_type) = &signature.return_type {
p.print_colon();
p.print_soft_space();
return_type.gen(p, ctx);
}
}
Self::TSConstructSignatureDeclaration(signature) => {
p.print_str(b"new ");
p.print_str(b"(");
signature.params.gen(p, ctx);
p.print_str(b")");
if let Some(return_type) = &signature.return_type {
p.print_colon();
p.print_soft_space();
return_type.gen(p, ctx);
}
}
Self::TSMethodSignature(signature) => {
match signature.kind {
TSMethodSignatureKind::Method => {}
TSMethodSignatureKind::Get => p.print_str(b"get "),
TSMethodSignatureKind::Set => p.print_str(b"set "),
}
if signature.computed {
p.print(b'[');
signature.key.gen(p, ctx);
p.print(b']');
} else {
match &signature.key {
PropertyKey::StaticIdentifier(key) => {
key.gen(p, ctx);
}
PropertyKey::PrivateIdentifier(key) => {
p.print_str(key.name.as_bytes());
}
key @ match_expression!(PropertyKey) => {
key.to_expression().gen_expr(p, Precedence::Assign, ctx);
}
}
}
if signature.optional {
p.print_str(b"?");
}
if let Some(type_parameters) = &signature.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b"(");
signature.params.gen(p, ctx);
p.print_str(b")");
if let Some(return_type) = &signature.return_type {
p.print_colon();
p.print_soft_space();
return_type.gen(p, ctx);
}
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeQuery<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"typeof ");
self.expr_name.gen(p, ctx);
if let Some(type_params) = &self.type_parameters {
type_params.gen(p, ctx);
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeQueryExprName<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
match_ts_type_name!(Self) => self.to_ts_type_name().gen(p, ctx),
Self::TSImportType(decl) => decl.gen(p, ctx),
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSImportType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"import(");
self.argument.gen(p, ctx);
p.print_str(b")");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeParameterInstantiation<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"<");
p.print_list(&self.params, ctx);
p.print_str(b">");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSIndexSignature<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"[");
for (index, parameter) in self.parameters.iter().enumerate() {
if index != 0 {
p.print_str(b" | ");
}
p.print_str(parameter.name.as_bytes());
p.print_colon();
p.print_soft_space();
parameter.type_annotation.gen(p, ctx);
}
p.print_str(b"]");
p.print_colon();
p.print_soft_space();
self.type_annotation.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTupleElement<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
match_ts_type!(TSTupleElement) => self.to_ts_type().gen(p, ctx),
TSTupleElement::TSOptionalType(ts_type) => {
ts_type.type_annotation.gen(p, ctx);
p.print_str(b"?");
}
TSTupleElement::TSRestType(ts_type) => {
p.print_str(b"...");
ts_type.type_annotation.gen(p, ctx);
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSNamedTupleMember<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.label.gen(p, ctx);
p.print_str(b":");
p.print_soft_space();
self.element_type.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSModuleDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
if self.modifiers.contains(ModifierKind::Export) {
p.print_str(b"export ");
}
if self.modifiers.contains(ModifierKind::Declare) {
p.print_str(b"declare ");
}
p.print_str(b"module");
p.print_space_before_identifier();
let name = self.id.name();
p.wrap_quote(name, |p, _| p.print_str(name.as_bytes()));
p.print_hard_space();
match &self.body {
Some(TSModuleDeclarationBody::TSModuleDeclaration(body)) => {
p.print_block_start(body.span.start);
body.gen(p, ctx);
p.print_block_end(body.span.end);
}
Some(TSModuleDeclarationBody::TSModuleBlock(body)) => {
p.print_block_start(body.span.start);
for item in &body.body {
p.print_semicolon_if_needed();
item.gen(p, ctx);
}
p.print_semicolon_if_needed();
p.print_block_end(body.span.end);
}
None => {}
}
if MINIFY {
p.print_semicolon();
}
p.print_hard_space();
p.print_soft_newline();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeAliasDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"type ");
self.id.gen(p, ctx);
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b" = ");
self.type_annotation.gen(p, ctx);
p.print_semicolon_after_statement();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSInterfaceDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"interface");
p.print_hard_space();
self.id.gen(p, ctx);
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
if let Some(extends) = &self.extends {
if !extends.is_empty() {
p.print_str(b" extends ");
p.print_list(extends, ctx);
}
}
p.print_soft_space();
p.print_block_start(self.body.span.start);
for item in &self.body.body {
p.print_indent();
p.print_semicolon_if_needed();
item.gen(p, ctx);
p.print_semicolon_after_statement();
}
p.print_block_end(self.body.span.end);
if MINIFY {
p.print_hard_space();
}
p.print_soft_newline();
p.needs_semicolon = false;
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSInterfaceHeritage<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.expression.gen_expr(p, Precedence::Call, ctx);
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSEnumDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_indent();
if self.modifiers.contains(ModifierKind::Export) {
p.print_str(b"export ");
}
if self.modifiers.contains(ModifierKind::Declare) {
p.print_str(b"declare ");
}
if self.modifiers.contains(ModifierKind::Const) {
p.print_str(b"const ");
}
p.print_space_before_identifier();
p.print_str(b"enum ");
self.id.gen(p, ctx);
p.print_space_before_identifier();
p.print_block_start(self.span.start);
p.print_list(&self.members, ctx);
p.print_block_end(self.span.end);
p.print_hard_space();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSEnumMember<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match &self.id {
TSEnumMemberName::StaticIdentifier(decl) => decl.gen(p, ctx),
TSEnumMemberName::StaticStringLiteral(decl) => decl.gen(p, ctx),
TSEnumMemberName::StaticNumericLiteral(decl) => decl.gen(p, ctx),
decl @ match_expression!(TSEnumMemberName) => {
p.print_str(b"[");
decl.to_expression().gen_expr(p, Precedence::lowest(), ctx);
p.print_str(b"]");
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSConstructorType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
if self.r#abstract {
p.print_str(b"abstract ");
}
p.print_str(b"new ");
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b"(");
self.params.gen(p, ctx);
p.print_str(b")");
p.print_soft_space();
p.print_str(b"=>");
p.print_soft_space();
self.return_type.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSImportEqualsDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"import ");
self.id.gen(p, ctx);
p.print_str(b" = ");
self.module_reference.gen(p, ctx);
p.print_semicolon_after_statement();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSModuleReference<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::ExternalModuleReference(decl) => {
p.print_str(b"require(");
decl.expression.gen(p, ctx);
p.print_str(b")");
}
match_ts_type_name!(Self) => self.to_ts_type_name().gen(p, ctx),
}
}
}
impl<'a, const MINIFY: bool> GenExpr<MINIFY> for TSTypeAssertion<'a> {
fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) {
p.print_str(b"<");
self.type_annotation.gen(p, ctx);
p.print_str(b">");
self.expression.gen_expr(p, precedence, ctx);
}
}
impl<const MINIFY: bool> Gen<MINIFY> for TSAccessibility {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) {
match self {
Self::Public => p.print_str(b"public "),
Self::Private => p.print_str(b"private "),
Self::Protected => p.print_str(b"protected "),
}
}
}

709
crates/oxc_codegen/src/gen_ts.rs
View file

@ -1,709 +0,0 @@
#[allow(clippy::wildcard_imports)]
use oxc_ast::ast::*;
use oxc_syntax::precedence::Precedence;
use crate::{context::Context, Codegen, Gen, GenExpr};
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeParameterDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"<");
p.print_list(&self.params, ctx);
p.print_str(b">");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeAnnotation<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.type_annotation.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::TSFunctionType(decl) => decl.gen(p, ctx),
Self::TSConstructorType(decl) => {
decl.gen(p, ctx);
}
Self::TSArrayType(decl) => {
p.print_str(b"(");
decl.element_type.gen(p, ctx);
p.print_str(b")[]");
}
Self::TSTupleType(decl) => {
p.print_str(b"[");
p.print_list(&decl.element_types, ctx);
p.print_str(b"]");
}
Self::TSUnionType(decl) => {
if decl.types.len() == 1 {
decl.types[0].gen(p, ctx);
return;
}
p.print_str(b"(");
for (index, item) in decl.types.iter().enumerate() {
if index != 0 {
p.print_soft_space();
p.print_str(b"|");
p.print_soft_space();
}
p.print_str(b"(");
item.gen(p, ctx);
p.print_str(b")");
}
p.print_str(b")");
}
Self::TSIntersectionType(decl) => {
if decl.types.len() == 1 {
decl.types[0].gen(p, ctx);
return;
}
p.print_str(b"(");
for (index, item) in decl.types.iter().enumerate() {
if index != 0 {
p.print_soft_space();
p.print_str(b"&");
p.print_soft_space();
}
p.print_str(b"(");
item.gen(p, ctx);
p.print_str(b")");
}
p.print_str(b")");
}
Self::TSConditionalType(decl) => {
decl.check_type.gen(p, ctx);
p.print_str(b" extends (");
decl.extends_type.gen(p, ctx);
p.print_str(b") ? ");
decl.true_type.gen(p, ctx);
p.print_str(b" : ");
decl.false_type.gen(p, ctx);
}
Self::TSInferType(decl) => {
p.print_str(b"infer ");
decl.type_parameter.gen(p, ctx);
}
Self::TSIndexedAccessType(decl) => {
decl.object_type.gen(p, ctx);
p.print_str(b"[");
decl.index_type.gen(p, ctx);
p.print_str(b"]");
}
Self::TSMappedType(decl) => {
p.print_str(b"{");
match decl.readonly {
TSMappedTypeModifierOperator::True => {
p.print_str(b"readonly");
}
TSMappedTypeModifierOperator::Plus => {
p.print_str(b"+readonly");
}
TSMappedTypeModifierOperator::Minus => {
p.print_str(b"-readonly");
}
TSMappedTypeModifierOperator::None => {}
}
p.print_hard_space();
p.print_str(b"[");
decl.type_parameter.name.gen(p, ctx);
if let Some(constraint) = &decl.type_parameter.constraint {
p.print_str(b" in ");
constraint.gen(p, ctx);
}
if let Some(default) = &decl.type_parameter.default {
p.print_str(b" = ");
default.gen(p, ctx);
}
p.print_str(b"]");
match decl.optional {
TSMappedTypeModifierOperator::True => {
p.print_str(b"?");
}
TSMappedTypeModifierOperator::Plus => {
p.print_str(b"+?");
}
TSMappedTypeModifierOperator::Minus => {
p.print_str(b"-?");
}
TSMappedTypeModifierOperator::None => {}
}
p.print_soft_space();
if let Some(type_annotation) = &decl.type_annotation {
p.print_str(b":");
p.print_soft_space();
type_annotation.gen(p, ctx);
}
p.print_semicolon_if_needed();
p.print_str(b"}");
}
Self::TSNamedTupleMember(decl) => {
decl.gen(p, ctx);
}
Self::TSLiteralType(decl) => {
decl.literal.gen(p, ctx);
}
Self::TSImportType(decl) => {
decl.gen(p, ctx);
}
Self::TSQualifiedName(decl) => {
decl.left.gen(p, ctx);
p.print_str(b".");
decl.right.gen(p, ctx);
}
Self::TSAnyKeyword(_) => {
p.print_str(b"any");
}
Self::TSBigIntKeyword(_) => {
p.print_str(b"bigint");
}
Self::TSBooleanKeyword(_) => {
p.print_str(b"boolean");
}
Self::TSNeverKeyword(_) => {
p.print_str(b"never");
}
Self::TSNullKeyword(_) => {
p.print_str(b"null");
}
Self::TSNumberKeyword(_) => {
p.print_str(b"number");
}
Self::TSObjectKeyword(_) => {
p.print_str(b"object");
}
Self::TSStringKeyword(_) => {
p.print_str(b"string");
}
Self::TSSymbolKeyword(_) => {
p.print_str(b"symbol");
}
Self::TSThisType(_) => {
p.print_str(b"this");
}
Self::TSUndefinedKeyword(_) => {
p.print_str(b"undefined");
}
Self::TSUnknownKeyword(_) => {
p.print_str(b"unknown");
}
Self::TSVoidKeyword(_) => {
p.print_str(b"void");
}
Self::TSTemplateLiteralType(decl) => decl.gen(p, ctx),
Self::TSTypeLiteral(decl) => {
p.print_block_start(decl.span.start);
for item in &decl.members {
item.gen(p, ctx);
p.print_semicolon();
}
p.print_block_end(decl.span.end);
}
Self::TSTypeOperatorType(decl) => {
match decl.operator {
TSTypeOperatorOperator::Keyof => {
p.print_str(b"keyof ");
}
TSTypeOperatorOperator::Unique => {
p.print_str(b"unique ");
}
TSTypeOperatorOperator::Readonly => {
p.print_str(b"readonly ");
}
}
decl.type_annotation.gen(p, ctx);
}
Self::TSTypePredicate(decl) => {
if decl.asserts {
p.print_str(b"asserts ");
}
match &decl.parameter_name {
TSTypePredicateName::Identifier(ident) => {
ident.gen(p, ctx);
}
TSTypePredicateName::This(_ident) => {
p.print_str(b"this");
}
}
if let Some(type_annotation) = &decl.type_annotation {
p.print_str(b" is ");
type_annotation.gen(p, ctx);
}
}
Self::TSTypeQuery(decl) => decl.gen(p, ctx),
Self::TSTypeReference(decl) => {
decl.type_name.gen(p, ctx);
if let Some(type_parameters) = &decl.type_parameters {
type_parameters.gen(p, ctx);
}
}
Self::JSDocNullableType(decl) => {
if decl.postfix {
decl.type_annotation.gen(p, ctx);
p.print_str(b"?");
} else {
p.print_str(b"?");
decl.type_annotation.gen(p, ctx);
}
}
Self::JSDocUnknownType(_decl) => p.print_str(b"unknown"),
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTemplateLiteralType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"`");
for (index, item) in self.quasis.iter().enumerate() {
if index != 0 {
if let Some(types) = self.types.get(index - 1) {
p.print_str(b"${");
types.gen(p, ctx);
p.print_str(b"}");
}
}
p.print_str(item.value.raw.as_bytes());
}
p.print_str(b"`");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeName<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::IdentifierReference(decl) => {
p.print_str(decl.name.as_bytes());
}
Self::QualifiedName(decl) => {
decl.left.gen(p, ctx);
p.print_str(b".");
decl.right.gen(p, ctx);
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSLiteral<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::BooleanLiteral(decl) => decl.gen(p, ctx),
Self::NullLiteral(decl) => decl.gen(p, ctx),
Self::NumericLiteral(decl) => decl.gen(p, ctx),
Self::BigintLiteral(decl) => decl.gen(p, ctx),
Self::RegExpLiteral(decl) => decl.gen(p, ctx),
Self::StringLiteral(decl) => decl.gen(p, ctx),
Self::TemplateLiteral(decl) => decl.gen(p, ctx),
Self::UnaryExpression(decl) => decl.gen_expr(p, Precedence::Assign, ctx),
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeParameter<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.name.gen(p, ctx);
if let Some(constraint) = &self.constraint {
p.print_str(b" extends ");
constraint.gen(p, ctx);
}
if let Some(default) = &self.default {
p.print_str(b" = ");
default.gen(p, ctx);
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSFunctionType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b"(");
if let Some(this_param) = &self.this_param {
this_param.this.gen(p, ctx);
p.print_str(b":");
if let Some(type_annotation) = &this_param.type_annotation {
type_annotation.gen(p, ctx);
} else {
p.print_str(b"unknown");
}
if !self.params.is_empty() || self.params.rest.is_some() {
p.print_str(b",");
}
p.print_soft_space();
}
self.params.gen(p, ctx);
p.print_str(b")");
p.print_soft_space();
p.print_str(b"=>");
p.print_soft_space();
self.return_type.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSSignature<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_soft_space();
match self {
Self::TSIndexSignature(signature) => signature.gen(p, ctx),
Self::TSPropertySignature(signature) => {
if signature.readonly {
p.print_str(b"readonly");
p.print_hard_space();
}
if signature.computed {
p.print(b'[');
signature.key.gen(p, ctx);
p.print(b']');
} else {
match &signature.key {
PropertyKey::StaticIdentifier(key) => {
key.gen(p, ctx);
}
PropertyKey::PrivateIdentifier(key) => {
p.print_str(key.name.as_bytes());
}
key @ match_expression!(PropertyKey) => {
key.to_expression().gen_expr(p, Precedence::Assign, ctx);
}
}
}
if signature.optional {
p.print_str(b"?");
}
if let Some(type_annotation) = &signature.type_annotation {
p.print_colon();
p.print_soft_space();
type_annotation.gen(p, ctx);
}
}
Self::TSCallSignatureDeclaration(signature) => {
p.print_str(b"(");
signature.params.gen(p, ctx);
p.print_str(b")");
if let Some(return_type) = &signature.return_type {
p.print_colon();
p.print_soft_space();
return_type.gen(p, ctx);
}
}
Self::TSConstructSignatureDeclaration(signature) => {
p.print_str(b"new ");
p.print_str(b"(");
signature.params.gen(p, ctx);
p.print_str(b")");
if let Some(return_type) = &signature.return_type {
p.print_colon();
p.print_soft_space();
return_type.gen(p, ctx);
}
}
Self::TSMethodSignature(signature) => {
match signature.kind {
TSMethodSignatureKind::Method => {}
TSMethodSignatureKind::Get => p.print_str(b"get "),
TSMethodSignatureKind::Set => p.print_str(b"set "),
}
if signature.computed {
p.print(b'[');
signature.key.gen(p, ctx);
p.print(b']');
} else {
match &signature.key {
PropertyKey::StaticIdentifier(key) => {
key.gen(p, ctx);
}
PropertyKey::PrivateIdentifier(key) => {
p.print_str(key.name.as_bytes());
}
key @ match_expression!(PropertyKey) => {
key.to_expression().gen_expr(p, Precedence::Assign, ctx);
}
}
}
if signature.optional {
p.print_str(b"?");
}
if let Some(type_parameters) = &signature.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b"(");
signature.params.gen(p, ctx);
p.print_str(b")");
if let Some(return_type) = &signature.return_type {
p.print_colon();
p.print_soft_space();
return_type.gen(p, ctx);
}
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeQuery<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"typeof ");
self.expr_name.gen(p, ctx);
if let Some(type_params) = &self.type_parameters {
type_params.gen(p, ctx);
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeQueryExprName<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
match_ts_type_name!(Self) => self.to_ts_type_name().gen(p, ctx),
Self::TSImportType(decl) => decl.gen(p, ctx),
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSImportType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"import(");
self.argument.gen(p, ctx);
p.print_str(b")");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeParameterInstantiation<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"<");
p.print_list(&self.params, ctx);
p.print_str(b">");
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSIndexSignature<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"[");
for (index, parameter) in self.parameters.iter().enumerate() {
if index != 0 {
p.print_str(b" | ");
}
p.print_str(parameter.name.as_bytes());
p.print_colon();
p.print_soft_space();
parameter.type_annotation.gen(p, ctx);
}
p.print_str(b"]");
p.print_colon();
p.print_soft_space();
self.type_annotation.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTupleElement<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
match_ts_type!(TSTupleElement) => self.to_ts_type().gen(p, ctx),
TSTupleElement::TSOptionalType(ts_type) => {
ts_type.type_annotation.gen(p, ctx);
p.print_str(b"?");
}
TSTupleElement::TSRestType(ts_type) => {
p.print_str(b"...");
ts_type.type_annotation.gen(p, ctx);
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSNamedTupleMember<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.label.gen(p, ctx);
p.print_str(b":");
p.print_soft_space();
self.element_type.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSModuleDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
if self.modifiers.contains(ModifierKind::Export) {
p.print_str(b"export ");
}
if self.modifiers.contains(ModifierKind::Declare) {
p.print_str(b"declare ");
}
p.print_str(b"module");
p.print_space_before_identifier();
let name = self.id.name();
p.wrap_quote(name, |p, _| p.print_str(name.as_bytes()));
p.print_hard_space();
match &self.body {
Some(TSModuleDeclarationBody::TSModuleDeclaration(body)) => {
p.print_block_start(body.span.start);
body.gen(p, ctx);
p.print_block_end(body.span.end);
}
Some(TSModuleDeclarationBody::TSModuleBlock(body)) => {
p.print_block_start(body.span.start);
for item in &body.body {
p.print_semicolon_if_needed();
item.gen(p, ctx);
}
p.print_semicolon_if_needed();
p.print_block_end(body.span.end);
}
None => {}
}
if MINIFY {
p.print_semicolon();
}
p.print_hard_space();
p.print_soft_newline();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSTypeAliasDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"type ");
self.id.gen(p, ctx);
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b" = ");
self.type_annotation.gen(p, ctx);
p.print_semicolon_after_statement();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSInterfaceDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"interface");
p.print_hard_space();
self.id.gen(p, ctx);
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
if let Some(extends) = &self.extends {
if !extends.is_empty() {
p.print_str(b" extends ");
p.print_list(extends, ctx);
}
}
p.print_soft_space();
p.print_block_start(self.body.span.start);
for item in &self.body.body {
p.print_indent();
p.print_semicolon_if_needed();
item.gen(p, ctx);
p.print_semicolon_after_statement();
}
p.print_block_end(self.body.span.end);
if MINIFY {
p.print_hard_space();
}
p.print_soft_newline();
p.needs_semicolon = false;
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSInterfaceHeritage<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
self.expression.gen_expr(p, Precedence::Call, ctx);
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSEnumDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_indent();
if self.modifiers.contains(ModifierKind::Export) {
p.print_str(b"export ");
}
if self.modifiers.contains(ModifierKind::Declare) {
p.print_str(b"declare ");
}
if self.modifiers.contains(ModifierKind::Const) {
p.print_str(b"const ");
}
p.print_space_before_identifier();
p.print_str(b"enum ");
self.id.gen(p, ctx);
p.print_space_before_identifier();
p.print_block_start(self.span.start);
p.print_list(&self.members, ctx);
p.print_block_end(self.span.end);
p.print_hard_space();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSEnumMember<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match &self.id {
TSEnumMemberName::StaticIdentifier(decl) => decl.gen(p, ctx),
TSEnumMemberName::StaticStringLiteral(decl) => decl.gen(p, ctx),
TSEnumMemberName::StaticNumericLiteral(decl) => decl.gen(p, ctx),
decl @ match_expression!(TSEnumMemberName) => {
p.print_str(b"[");
decl.to_expression().gen_expr(p, Precedence::lowest(), ctx);
p.print_str(b"]");
}
}
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSConstructorType<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
if self.r#abstract {
p.print_str(b"abstract ");
}
p.print_str(b"new ");
if let Some(type_parameters) = &self.type_parameters {
type_parameters.gen(p, ctx);
}
p.print_str(b"(");
self.params.gen(p, ctx);
p.print_str(b")");
p.print_soft_space();
p.print_str(b"=>");
p.print_soft_space();
self.return_type.gen(p, ctx);
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSImportEqualsDeclaration<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
p.print_str(b"import ");
self.id.gen(p, ctx);
p.print_str(b" = ");
self.module_reference.gen(p, ctx);
p.print_semicolon_after_statement();
}
}
impl<'a, const MINIFY: bool> Gen<MINIFY> for TSModuleReference<'a> {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
match self {
Self::ExternalModuleReference(decl) => {
p.print_str(b"require(");
decl.expression.gen(p, ctx);
p.print_str(b")");
}
match_ts_type_name!(Self) => self.to_ts_type_name().gen(p, ctx),
}
}
}
impl<'a, const MINIFY: bool> GenExpr<MINIFY> for TSTypeAssertion<'a> {
fn gen_expr(&self, p: &mut Codegen<{ MINIFY }>, precedence: Precedence, ctx: Context) {
p.print_str(b"<");
self.type_annotation.gen(p, ctx);
p.print_str(b">");
self.expression.gen_expr(p, precedence, ctx);
}
}
impl<const MINIFY: bool> Gen<MINIFY> for TSAccessibility {
fn gen(&self, p: &mut Codegen<{ MINIFY }>, _ctx: Context) {
match self {
Self::Public => p.print_str(b"public "),
Self::Private => p.print_str(b"private "),
Self::Protected => p.print_str(b"protected "),
}
}
}

1
crates/oxc_codegen/src/lib.rs
View file

@ -11,7 +11,6 @@
mod annotation_comment;
mod context;
mod gen;
mod gen_ts;
mod operator;
mod sourcemap_builder;