WIP

Author: marvinhagemeister

src/fast_check/mod.rs

@@ -11,6 +11,8 @@ mod range_finder;
 mod swc_helpers;
 #[cfg(feature = "fast_check")]
 mod transform;
+#[cfg(feature = "fast_check")]
+mod transform_dts;
 
 #[cfg(feature = "fast_check")]
 pub use transform::FastCheckModule;

src/fast_check/swc_helpers.rs

@@ -1,17 +1,28 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
+use deno_ast::swc::ast::ArrayLit;
 use deno_ast::swc::ast::Expr;
 use deno_ast::swc::ast::Ident;
 use deno_ast::swc::ast::Lit;
 use deno_ast::swc::ast::MemberProp;
+use deno_ast::swc::ast::ObjectLit;
+use deno_ast::swc::ast::ParenExpr;
 use deno_ast::swc::ast::Prop;
 use deno_ast::swc::ast::PropName;
 use deno_ast::swc::ast::PropOrSpread;
 use deno_ast::swc::ast::ReturnStmt;
 use deno_ast::swc::ast::Stmt;
+use deno_ast::swc::ast::TsAsExpr;
+use deno_ast::swc::ast::TsEntityName;
 use deno_ast::swc::ast::TsKeywordType;
 use deno_ast::swc::ast::TsKeywordTypeKind;
+use deno_ast::swc::ast::TsLit;
+use deno_ast::swc::ast::TsLitType;
 use deno_ast::swc::ast::TsType;
+use deno_ast::swc::ast::TsTypeAnn;
+use deno_ast::swc::ast::TsTypeOperator;
+use deno_ast::swc::ast::TsTypeOperatorOp;
+use deno_ast::swc::ast::TsTypeRef;
 use deno_ast::swc::common::DUMMY_SP;
 
 pub fn ident(name: String) -> Ident {
@@ -187,3 +198,135 @@ fn is_keyword_type(return_type: &TsType, kind: TsKeywordTypeKind) -> bool {
     _ => false,
   }
 }
+
+pub fn paren_expr(expr: Box<Expr>) -> Expr {
+  Expr::Paren(ParenExpr {
+    span: DUMMY_SP,
+    expr,
+  })
+}
+
+pub fn any_type_ann() -> Box<TsTypeAnn> {
+  type_ann(ts_keyword_type(TsKeywordTypeKind::TsAnyKeyword))
+}
+
+pub fn ts_readonly(ann: TsType) -> TsType {
+  TsType::TsTypeOperator(TsTypeOperator {
+    span: DUMMY_SP,
+    op: TsTypeOperatorOp::ReadOnly,
+    type_ann: Box::new(ann),
+  })
+}
+
+pub fn unknown_type_ann() -> Box<TsTypeAnn> {
+  Box::new(TsTypeAnn {
+    span: DUMMY_SP,
+    type_ann: Box::new(ts_keyword_type(TsKeywordTypeKind::TsUnknownKeyword)),
+  })
+}
+
+pub fn type_ann(ts_type: TsType) -> Box<TsTypeAnn> {
+  Box::new(TsTypeAnn {
+    span: DUMMY_SP,
+    type_ann: Box::new(ts_type),
+  })
+}
+
+pub fn type_ref(name: String) -> TsTypeRef {
+  TsTypeRef {
+    span: DUMMY_SP,
+    type_name: TsEntityName::Ident(Ident::new(name.into(), DUMMY_SP)),
+    type_params: None,
+  }
+}
+
+pub fn ts_lit_type(lit: TsLit) -> TsType {
+  TsType::TsLitType(TsLitType {
+    lit,
+    span: DUMMY_SP,
+  })
+}
+
+pub fn array_as_any_expr() -> Box<Expr> {
+  expr_as_keyword_expr(
+    Expr::Array(ArrayLit {
+      span: DUMMY_SP,
+      elems: Default::default(),
+    }),
+    TsKeywordTypeKind::TsAnyKeyword,
+  )
+}
+
+pub fn obj_as_any_expr() -> Box<Expr> {
+  expr_as_keyword_expr(
+    Expr::Object(ObjectLit {
+      span: DUMMY_SP,
+      props: Default::default(),
+    }),
+    TsKeywordTypeKind::TsAnyKeyword,
+  )
+}
+
+pub fn obj_as_never_expr() -> Box<Expr> {
+  expr_as_keyword_expr(
+    Expr::Object(ObjectLit {
+      span: DUMMY_SP,
+      props: Default::default(),
+    }),
+    TsKeywordTypeKind::TsNeverKeyword,
+  )
+}
+
+pub fn expr_as_keyword_expr(
+  expr: Expr,
+  keyword: TsKeywordTypeKind,
+) -> Box<Expr> {
+  Box::new(Expr::TsAs(TsAsExpr {
+    span: DUMMY_SP,
+    expr: Box::new(expr),
+    type_ann: Box::new(TsType::TsKeywordType(TsKeywordType {
+      span: DUMMY_SP,
+      kind: keyword,
+    })),
+  }))
+}
+
+pub fn replacement_return_value(ty: &TsType) -> Option<Box<Expr>> {
+  if is_void_type(ty) {
+    None
+  } else if is_never_type(ty) {
+    Some(obj_as_never_expr())
+  } else {
+    Some(obj_as_any_expr())
+  }
+}
+
+pub fn regex_type() -> TsType {
+  TsType::TsTypeRef(type_ref("RegExp".to_string()))
+}
+
+pub fn maybe_lit_to_ts_type_const(lit: &Lit) -> Option<TsType> {
+  match lit {
+    Lit::Str(lit_str) => Some(ts_lit_type(TsLit::Str(lit_str.clone()))),
+    Lit::Bool(lit_bool) => Some(ts_lit_type(TsLit::Bool(lit_bool.clone()))),
+    Lit::Null(_) => Some(ts_keyword_type(TsKeywordTypeKind::TsNullKeyword)),
+    Lit::Num(lit_num) => Some(ts_lit_type(TsLit::Number(lit_num.clone()))),
+    Lit::BigInt(lit_bigint) => {
+      Some(ts_lit_type(TsLit::BigInt(lit_bigint.clone())))
+    }
+    Lit::Regex(_) => Some(regex_type()),
+    Lit::JSXText(_) => None,
+  }
+}
+
+pub fn maybe_lit_to_ts_type(lit: &Lit) -> Option<TsType> {
+  match lit {
+    Lit::Str(_) => Some(ts_keyword_type(TsKeywordTypeKind::TsStringKeyword)),
+    Lit::Bool(_) => Some(ts_keyword_type(TsKeywordTypeKind::TsBooleanKeyword)),
+    Lit::Null(_) => Some(ts_keyword_type(TsKeywordTypeKind::TsNullKeyword)),
+    Lit::Num(_) => Some(ts_keyword_type(TsKeywordTypeKind::TsNumberKeyword)),
+    Lit::BigInt(_) => Some(ts_keyword_type(TsKeywordTypeKind::TsBigIntKeyword)),
+    Lit::Regex(_) => Some(regex_type()),
+    Lit::JSXText(_) => None,
+  }
+}