playground: fix print function arity

Author: fffonion

pd-vm/pd-vm-runtime-wasm/src/lib.rs

@@ -787,6 +787,50 @@ mod tests {
         );
     }
 
+    #[test]
+    fn run_supports_multi_arg_print_for_javascript() {
+        let source = r#"
+            print(1, 2);
+            1;
+        "#;
+        let report = run_source_with_flavor(source, SourceFlavor::JavaScript);
+        assert!(
+            report.error.is_none(),
+            "expected run to succeed with multi-arg print, got {:?}",
+            report.error
+        );
+        assert!(
+            report.output.iter().any(|line| line == "1 2"),
+            "expected output to include joined print line, got {:?}",
+            report.output
+        );
+    }
+
+    #[test]
+    fn run_supports_mixed_print_call_arities_for_rustscript() {
+        let source = r#"
+            print(1);
+            print("{}", 2);
+            1;
+        "#;
+        let report = run_source_with_flavor(source, SourceFlavor::RustScript);
+        assert!(
+            report.error.is_none(),
+            "expected run to succeed with mixed print arities, got {:?}",
+            report.error
+        );
+        assert!(
+            report.output.iter().any(|line| line == "1"),
+            "expected output to include first print line, got {:?}",
+            report.output
+        );
+        assert!(
+            report.output.iter().any(|line| line == "2"),
+            "expected output to include formatted print line, got {:?}",
+            report.output
+        );
+    }
+
     #[test]
     fn completion_catalog_reports_stdlib_and_host_entries() {
         let catalog = build_completion_catalog();

pd-vm/pd-vm-runtime-wasm/src/runtime.rs

@@ -11,10 +11,9 @@ use std::time::Instant;
 
 use serde::Deserialize;
 use vm::{
-    CallOutcome, FunctionDecl, HostAsyncBridge, HostFunction, HostOpId, LocalInfo,
-    PrintHostFunction, PrintlnHostFunction, SourceFlavor, SourcePathError, Value, Vm, VmError,
-    VmResult, VmStatus, VmYieldReason, compile_source_with_flavor_and_options, format_value,
-    render_vm_error,
+    CallOutcome, FunctionDecl, HostAsyncBridge, HostFunction, HostOpId, LocalInfo, SourceFlavor,
+    SourcePathError, Value, Vm, VmError, VmResult, VmStatus, VmYieldReason,
+    compile_source_with_flavor_and_options, format_value, render_vm_error,
 };
 
 use crate::analyzer::{LintDiagnostic, lint_source_with_flavor};
@@ -1342,6 +1341,10 @@ fn register_functions(
     functions: &[FunctionDecl],
     print_output: &Arc<Mutex<Vec<String>>>,
 ) -> Result<(), String> {
+    let lines = Arc::clone(print_output);
+    vm.set_runtime_print_sink(move |rendered| {
+        push_output_line(&lines, rendered);
+    });
     let async_state = functions
         .iter()
         .any(|decl| decl.name == "runtime::sleep")
@@ -1351,36 +1354,18 @@ fn register_functions(
             state
         });
     for decl in functions {
-        register_named_function(vm, &decl.name, print_output, async_state.as_ref())?;
+        register_named_function(vm, &decl.name, async_state.as_ref())?;
     }
     Ok(())
 }
 
 fn register_named_function(
     vm: &mut Vm,
     name: &str,
-    print_output: &Arc<Mutex<Vec<String>>>,
     async_state: Option<&Arc<Mutex<BrowserAsyncState>>>,
 ) -> Result<(), String> {
     match name {
-        "print" => {
-            let lines = Arc::clone(print_output);
-            vm.bind_function(
-                "print",
-                Box::new(PrintHostFunction::new(move |rendered| {
-                    push_output_line(&lines, rendered);
-                })),
-            );
-        }
-        "println" => {
-            let lines = Arc::clone(print_output);
-            vm.bind_function(
-                "println",
-                Box::new(PrintlnHostFunction::new(move |rendered| {
-                    push_output_line(&lines, rendered);
-                })),
-            );
-        }
+        "print" | "println" => {}
         "runtime::sleep" => {
             let Some(state) = async_state else {
                 return Err("runtime::sleep async bridge not initialized".to_string());

pd-vm/src/compiler/parser.rs

@@ -1890,8 +1890,25 @@ impl Parser {
                     let local = self.get_local(&name)?;
                     Expr::LocalCall(local, args)
                 } else if self.functions.contains_key(&name) {
-                    let decl = self.resolve_function_for_call(&name, args.len())?;
-                    Expr::Call(decl.index, args)
+                    let builtin_alias_call = if matches!(name.as_str(), "print" | "println") {
+                        self.functions
+                            .get(&name)
+                            .map(|decl| !self.function_impls.contains_key(&decl.index))
+                            .unwrap_or(false)
+                    } else {
+                        false
+                    };
+                    if builtin_alias_call {
+                        if let Some(expr) = self.try_build_language_builtin_call(&name, &args)? {
+                            expr
+                        } else {
+                            let decl = self.resolve_function_for_call(&name, args.len())?;
+                            Expr::Call(decl.index, args)
+                        }
+                    } else {
+                        let decl = self.resolve_function_for_call(&name, args.len())?;
+                        Expr::Call(decl.index, args)
+                    }
                 } else if let Some(expr) = self.try_build_language_builtin_call(&name, &args)? {
                     expr
                 } else if let Some(host_name) = self.resolve_direct_host_call_target(&name) {
@@ -2640,9 +2657,11 @@ impl Parser {
             "print" if self.dialect.allow_macro_calls() => {
                 Ok(Some(self.lower_print_call(args.to_vec())?))
             }
+            "print" => Ok(Some(self.lower_plain_print_call(args.to_vec())?)),
             "println" if self.dialect.allow_macro_calls() => {
                 Ok(Some(self.lower_println_call(args.to_vec())?))
             }
+            "println" => Ok(Some(self.lower_plain_println_call(args.to_vec())?)),
             "type" | "typeof" => {
                 if args.len() != 1 {
                     return Err(ParseError {
@@ -2694,6 +2713,11 @@ impl Parser {
         self.build_print_call_expr(rendered)
     }
 
+    fn lower_plain_print_call(&mut self, args: Vec<Expr>) -> Result<Expr, ParseError> {
+        let rendered = self.render_plain_print_args(args)?;
+        self.build_print_call_expr(rendered)
+    }
+
     fn lower_println_call(&mut self, args: Vec<Expr>) -> Result<Expr, ParseError> {
         let rendered = match args.as_slice() {
             [] => Expr::String("\n".to_string()),
@@ -2714,6 +2738,42 @@ impl Parser {
         self.build_print_call_expr(rendered)
     }
 
+    fn lower_plain_println_call(&mut self, args: Vec<Expr>) -> Result<Expr, ParseError> {
+        let rendered = match args.is_empty() {
+            true => Expr::String("\n".to_string()),
+            false => {
+                let rendered = self.render_plain_print_args(args)?;
+                let value = self.build_to_string_expr(rendered)?;
+                self.append_newline_expr(value)
+            }
+        };
+        self.build_print_call_expr(rendered)
+    }
+
+    fn render_plain_print_args(&mut self, args: Vec<Expr>) -> Result<Expr, ParseError> {
+        match args.len() {
+            0 => Ok(Expr::String(String::new())),
+            1 => Ok(args
+                .into_iter()
+                .next()
+                .expect("single print arg should exist")),
+            _ => {
+                let mut args = args.into_iter();
+                let mut rendered =
+                    self.build_to_string_expr(args.next().expect("first print arg should exist"))?;
+                for arg in args {
+                    rendered =
+                        Expr::Add(Box::new(rendered), Box::new(Expr::String(" ".to_string())));
+                    rendered = Expr::Add(
+                        Box::new(rendered),
+                        Box::new(self.build_to_string_expr(arg)?),
+                    );
+                }
+                Ok(rendered)
+            }
+        }
+    }
+
     fn expect_format_literal<'a>(
         &self,
         callee: &str,
@@ -3126,8 +3186,9 @@ impl Parser {
         let mut args = self.parse_call_args()?;
 
         if base == "console" && segments.len() == 1 && segments[0] == "log" {
-            let decl = self.resolve_function_for_call(STDLIB_PRINT_NAME, args.len())?;
-            return Ok(Some(Expr::Call(decl.index, args)));
+            return Ok(Some(
+                self.lower_plain_print_call(std::mem::take(&mut args))?,
+            ));
         }
 
         if segments.is_empty() {

pd-vm/tests/compiler_javascript_tests.rs

@@ -344,6 +344,43 @@ fn javascript_console_log_works_without_decl() {
     run_runtime_case_with_bindings(&case, &bindings);
 }
 
+#[test]
+fn javascript_print_supports_multiple_arguments_without_decl() {
+    let case = RuntimeCase {
+        name: "print supports multiple arguments without decl",
+        source: r#"
+            print(40, 2);
+        "#,
+        flavor: SourceFlavor::JavaScript,
+        expected_stack: vec![Value::string("40 2")],
+        expected_locals: None,
+    };
+    let bindings = [HostBindingCase {
+        name: "print",
+        factory: make_print_builtin,
+    }];
+    run_runtime_case_with_bindings(&case, &bindings);
+}
+
+#[test]
+fn javascript_print_alias_handles_mixed_call_arities() {
+    let case = RuntimeCase {
+        name: "print alias handles mixed call arities",
+        source: r#"
+            print(1);
+            print(2, 3);
+        "#,
+        flavor: SourceFlavor::JavaScript,
+        expected_stack: vec![Value::Int(1), Value::string("2 3")],
+        expected_locals: None,
+    };
+    let bindings = [HostBindingCase {
+        name: "print",
+        factory: make_print_builtin,
+    }];
+    run_runtime_case_with_bindings(&case, &bindings);
+}
+
 #[test]
 fn compile_source_file_with_javascript_complex_fixture() {
     let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/example_complex.js");

pd-vm/tests/compiler_rustscript_tests.rs

@@ -467,6 +467,25 @@ fn rustscript_println_function_supports_rust_style_formatting() {
     run_runtime_case_with_bindings(&case, &bindings);
 }
 
+#[test]
+fn rustscript_print_alias_handles_mixed_call_arities() {
+    let case = RuntimeCase {
+        name: "print alias handles mixed call arities",
+        source: r#"
+            print(1);
+            print("{}", 2);
+        "#,
+        flavor: SourceFlavor::RustScript,
+        expected_stack: vec![Value::Int(1), Value::string("2")],
+        expected_locals: None,
+    };
+    let bindings = [HostBindingCase {
+        name: "print",
+        factory: make_print_builtin,
+    }];
+    run_runtime_case_with_bindings(&case, &bindings);
+}
+
 #[test]
 fn rustscript_print_rejects_non_literal_format_string() {
     let case = ParseErrorCase {