--wip-- [skip ci]

Author: hugoclrd

components/ts-to-clar/src/converter.rs

@@ -140,7 +140,15 @@ fn convert_expression_with_type(
 
             _ => return Err(anyhow::anyhow!("Unsupported expression for Tuple")),
         },
-        _ => return Err(anyhow::anyhow!("Unsupported type for variable")),
+        ClarityTypeSignature::ResponseType(boxed_types) => match &expr {
+            _ => return Err(anyhow::anyhow!("Invalid expression for Response type")),
+        },
+        _ => {
+            return Err(anyhow::anyhow!(format!(
+                "Unsupported type for variable with {:?} type",
+                r#type
+            )))
+        }
     })
 }
 

components/ts-to-clar/src/expression_converter.rs

@@ -88,9 +88,12 @@ impl<'a> StatementConverter<'a> {
         {
             Some(ts_to_clar_type(&boxed_type_annotation.type_annotation).unwrap())
         } else {
-            // type annotation is not always needed
-            // but this current approach probably isn't robust enough
-            None
+            // Try to infer type from initializer expression
+            if let Some(init_expr) = &variable_declarator.init {
+                self.infer_type_from_expression(init_expr)
+            } else {
+                None
+            }
         };
 
         let binding_name = if let ast::BindingPattern {
@@ -109,6 +112,45 @@ impl<'a> StatementConverter<'a> {
         type_annotation
     }
 
+    fn infer_type_from_expression(&self, expr: &Expression<'a>) -> Option<TypeSignature> {
+        match expr {
+            // Handle method call chains like: counts.get(txSender).defaultTo(0)
+            Expression::CallExpression(call_expr) => {
+                if let Expression::StaticMemberExpression(member_expr) = &call_expr.callee {
+                    if member_expr.property.name.as_str() == "defaultTo" {
+                        if let Some(root_type) = self.find_root_data_map_type(&member_expr.object) {
+                            return Some(root_type);
+                        }
+                    }
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    fn find_root_data_map_type(&self, expr: &Expression<'a>) -> Option<TypeSignature> {
+        match expr {
+            Expression::StaticMemberExpression(member_expr) => {
+                self.find_root_data_map_type(&member_expr.object)
+            }
+            Expression::CallExpression(call_expr) => {
+                self.find_root_data_map_type(&call_expr.callee)
+            }
+            Expression::Identifier(ident) => {
+                let var_name = ident.name.as_str();
+                self.ir.data_maps.iter().find_map(|data_map| {
+                    if data_map.name == var_name {
+                        Some(data_map.value_type.clone())
+                    } else {
+                        None
+                    }
+                })
+            }
+            _ => None,
+        }
+    }
+
     fn get_parameter_type(&self, param_name: &str) -> Option<&TypeSignature> {
         self.function
             .parameters
@@ -387,6 +429,16 @@ impl<'a> Traverse<'a, ConverterState<'a>> for StatementConverter<'a> {
             }
             Expression::StaticMemberExpression(member_expr) => {
                 let Expression::Identifier(ident) = &member_expr.object else {
+                    if member_expr.property.name.as_str() == "defaultTo" {
+                        // For defaultTo, we need special handling to get correct argument order
+                        self.lists_stack
+                            .push(PreSymbolicExpression::list(vec![atom("default-to")]));
+                        // Keep the current context type for proper type inference of the default value
+                        // The argument should have the same type as the optional's inner type
+                        self.current_context_type_stack
+                            .push(self.current_context_type.clone());
+                        return;
+                    }
                     return;
                 };
                 let ident_name = ident.name.as_str();
@@ -410,6 +462,27 @@ impl<'a> Traverse<'a, ConverterState<'a>> for StatementConverter<'a> {
                     return;
                 }
 
+                // Handle data map access
+                if let Some(data_map) = self
+                    .ir
+                    .data_maps
+                    .iter()
+                    .find(|data_map| data_map.name == ident_name)
+                {
+                    self.current_context_type = Some(data_map.value_type.clone());
+                    let atom_name = match member_expr.property.name.as_str() {
+                        "get" => "map-get?",
+                        "insert" => "map-insert",
+                        "set" => "map-set",
+                        "delete" => "map-delete",
+                        _ => return,
+                    };
+                    self.lists_stack
+                        .push(PreSymbolicExpression::list(vec![atom(atom_name)]));
+                    ctx.state.ingest_call_expression = true;
+                    return;
+                }
+
                 // Handle std namespace calls
                 if self
                     .ir
@@ -442,9 +515,24 @@ impl<'a> Traverse<'a, ConverterState<'a>> for StatementConverter<'a> {
 
     fn exit_call_expression(
         &mut self,
-        _call_expr: &mut ast::CallExpression<'a>,
+        call_expr: &mut ast::CallExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
+        if let Expression::StaticMemberExpression(member_expr) = &call_expr.callee {
+            if member_expr.property.name.as_str() == "defaultTo" {
+                // For defaultTo, we need to reorder arguments: (default-to default_value optional_expr)
+                if let Some(current_list) = self.lists_stack.last_mut() {
+                    if let PreSymbolicExpressionType::List(list) = &mut current_list.pre_expr {
+                        if list.len() == 3 {
+                            list.swap(1, 2);
+                        }
+                    }
+                }
+                self.ingest_last_stack_item();
+                return;
+            }
+        }
+
         if ctx.state.ingest_call_expression {
             // Don't ingest immediately if we're inside an object property
             // Let the object property handler take care of it
@@ -1336,4 +1424,58 @@ mod test {
         let expected_clar_src = "{ list: (list (list true false)) }";
         assert_body_eq(ts_src, expected_clar_src);
     }
+
+    #[test]
+    fn test_data_map_get() {
+        let ts_src = indoc! {
+            r#"const counts = new DataMap<Principal, Uint>();
+            function getMyCount() {
+                const count = counts.get(txSender);
+                return count;
+            }"#
+        };
+        let expected_clar_src = "(let ((count (map-get? counts tx-sender))) count)";
+        assert_body_eq(ts_src, expected_clar_src);
+    }
+
+    #[test]
+    fn test_optional_default_to() {
+        let ts_src = indoc! {
+            r#"const counts = new DataMap<Principal, Uint>();
+            function getMyCount() {
+                return counts.get(txSender).defaultTo(0);
+            }"#
+        };
+        let expected_clar_src = "(default-to u0 (map-get? counts tx-sender))";
+        assert_body_eq(ts_src, expected_clar_src);
+    }
+
+    #[test]
+    fn test_optional_default_to_type_inference() {
+        let ts_src = indoc! {
+            r#"const counts = new DataMap<Principal, Uint>();
+            function getMyCountPlus1() {
+                return counts.get(txSender).defaultTo(0) + 1;
+            }"#
+        };
+        let expected_clar_src = "(+ (default-to u0 (map-get? counts tx-sender)) u1)";
+        assert_body_eq(ts_src, expected_clar_src);
+    }
+
+    #[test]
+    fn test_variable_type_inference() {
+        let ts_src = indoc! {
+            r#"const counts = new DataMap<Principal, Uint>();
+            function getMyCountPlus1() {
+                const currentCount = counts.get(txSender).defaultTo(0);
+                return currentCount + 1;
+            }"#
+        };
+        let expected_clar_src = indoc! {
+            r#"(let ((current-count (default-to u0 (map-get? counts tx-sender))))
+                (+ current-count u1)
+            )"#
+        };
+        assert_body_eq(ts_src, expected_clar_src);
+    }
 }

components/ts-to-clar/src/lib.rs

@@ -35,6 +35,7 @@ mod test {
     fn test_transpile_toplevel_data() {
         let src = indoc! {
             "const OWNER_ROLE = new Constant<Uint>(1);
+            const ERR_FORBIDDEN = new Constant<ClError<never, Uint>>(err(4001));
             const count = new DataVar<Uint>(0);
             const msgs = new DataMap<Uint, StringAscii<16>>();
         "};
@@ -44,6 +45,7 @@ mod test {
             clarity_code,
             indoc! {r#"
                 (define-const OWNER_ROLE u1)
+                (define-const ERR_FORBIDDEN (err u4001))
                 (define-data-var count uint u0)
                 (define-map msgs
                   uint

components/ts-to-clar/src/parser.rs

@@ -347,7 +347,7 @@ mod test {
     use clarity::vm::types::TypeSignature::{self, *};
     use clarity::vm::ClarityName;
     use indoc::{formatdoc, indoc};
-    use oxc_allocator::{Allocator, Box, FromIn};
+    use oxc_allocator::{Allocator, FromIn};
     use oxc_ast::ast::{
         BinaryOperator, Expression, NumberBase, ObjectPropertyKind, PropertyKey, PropertyKind,
         Statement,
@@ -378,6 +378,18 @@ mod test {
         )
     }
 
+    fn expr_error_uint<'a>(allocator: &'a Allocator, value: f64) -> Expression<'a> {
+        let func = expr_identifier(allocator, "err");
+        let arg = expr_number(allocator, value);
+        AstBuilder::new(allocator).expression_call(
+            Span::empty(0),
+            func,
+            None::<oxc_allocator::Box<'a, oxc_ast::ast::TSTypeParameterInstantiation<'a>>>,
+            oxc_allocator::Vec::from_array_in([arg.into()], allocator),
+            false,
+        )
+    }
+
     fn expr_string<'a>(allocator: &'a Allocator, value: &'a str) -> Expression<'a> {
         AstBuilder::new(allocator).expression_string_literal(
             Span::empty(0),
@@ -398,7 +410,7 @@ mod test {
     ) -> Expression<'a> {
         let expr =
             AstBuilder::new(allocator).binary_expression(Span::empty(0), left, operator, right);
-        Expression::BinaryExpression(Box::new_in(expr, allocator))
+        Expression::BinaryExpression(oxc_allocator::Box::new_in(expr, allocator))
     }
 
     fn simple_object_property<'a>(
@@ -418,7 +430,6 @@ mod test {
         )
     }
 
-    #[track_caller]
     fn assert_expr_eq(actual: &Expression, expected: &Expression) {
         use Expression::*;
         match (&actual, &expected) {
@@ -466,6 +477,17 @@ mod test {
                     }
                 }
             }
+            (CallExpression(actual_call), CallExpression(expected_call)) => {
+                assert_expr_eq(&actual_call.callee, &expected_call.callee);
+                assert_eq!(actual_call.arguments.len(), expected_call.arguments.len());
+                for (actual_arg, expected_arg) in actual_call
+                    .arguments
+                    .iter()
+                    .zip(expected_call.arguments.iter())
+                {
+                    assert_expr_eq(actual_arg.to_expression(), expected_arg.to_expression());
+                }
+            }
             _ => panic!("Expected matching expression types"),
         }
     }
@@ -512,6 +534,19 @@ mod test {
         assert_constant_eq(&constants[2], &expected);
     }
 
+    #[test]
+    fn test_constant_err_ir() {
+        let allocator = Allocator::default();
+        let src = "const ERR_FORBIDDEN = new Constant<ClError<never, Uint>>(err(4003));";
+        let constants = get_tmp_ir(&allocator, src).constants;
+        let expected = IRConstant {
+            name: "ERR_FORBIDDEN".to_string(),
+            r#type: ResponseType(Box::new((NoType, UIntType))),
+            expr: expr_error_uint(&allocator, 4003.0),
+        };
+        assert_constant_eq(&constants[0], &expected);
+    }
+
     #[test]
     fn test_data_var_ir() {
         let allocator = Allocator::default();

components/ts-to-clar/src/types.rs

@@ -43,6 +43,10 @@ fn extract_type(
         "Int" => Ok(TypeSignature::IntType),
         "Bool" => Ok(TypeSignature::BoolType),
         "Principal" => Ok(TypeSignature::PrincipalType),
+        "ClError" => Ok(TypeSignature::ResponseType(Box::new((
+            TypeSignature::NoType,
+            TypeSignature::UIntType,
+        )))),
         "StringAscii" => extract_numeric_type_param(type_params).map(get_ascii_type),
         "StringUtf8" => extract_numeric_type_param(type_params).map(get_utf8_type),
         _ => Err(anyhow!("Unknown type: {}", type_ident)),