33fe838 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

33fe838 — Peter John 2026-11-06T14:36:31+05:30

Report type errors inside string interpolation

Files changed (4) hide show

compiler/checker/src/infer.rs +4 -4
compiler/checker/tests/checker/checker_tests.rs +4 -2
compiler/checker/tests/checker/diagnostic_tests.rs +36 -0
compiler/wasm-codegen/tests/wasm_codegen/codegen_tests.rs +22 -0

compiler/checker/src/infer.rs CHANGED Viewed

@@ -114,12 +114,12 @@ pub(crate) fn inferExprInner(
         ast::Expr { kind: ast::ExprKind::Int(_), .. } => Ok(PlumType::TInt),
         ast::Expr { kind: ast::ExprKind::Float(_), .. } => Ok(PlumType::TFloat),
         ast::Expr { kind: ast::ExprKind::String(s), .. } => {
-            // Interpolated parts are typed for the record only; errors in them
+            // Interpolated parts are typed and recorded; an error in one is the
-            // were never part of this check.
+            // string's error (positioned at the failing node inside the part).
             for part in &s.parts {
                 if let ast::StringPart::Interp(e) = part {
-                    let ity = inferExprWith(e, env, ctx, None);
+                    let ity = inferExprWith(e, env, ctx, None)?;
-                    if let Ok(PlumType::TApp(n, targs)) = ity {
+                    if let PlumType::TApp(n, targs) = ity {
                         let gens = enumGenericsOf(&n, ctx);
                         if gens.len() == targs.len()
                             && ctx.methods.contains_key(&(n.clone(), "toStr".to_string()))

compiler/checker/tests/checker/checker_tests.rs CHANGED Viewed

@@ -440,11 +440,13 @@ fn unknown_method_on_heap_const_is_checker_error() {
 fn recovered_call_failure_does_not_reposition_genuine_error() {
     let src = "enum Box[T] =\n  | Box(v: T)\n\nenum Cfg =\n  | Cfg(a: Int)\n\n  Cell = Box(1)\n\nfun f() -> Int =\n  return \"{Cfg.Cell.size()}\"\n";
     let errs = checkSrc(src).unwrap_err();
+    // The interpolated call is a genuine error now (it used to be dropped, leaving only
+    // the return mismatch): reported at the call inside the string.
     let e = errs
         .iter()
-        .find(|e| e.message.contains("return type mismatch"))
+        .find(|e| e.message.contains("has no method 'size'"))
         .unwrap();
-    assert_eq!((e.line, e.column), (9, 1), "{:?}", errs);
+    assert_eq!(e.line, 10, "{:?}", errs);
 }
 // ---------- constants: PascalCase, always `Type.Name` ----------

compiler/checker/tests/checker/diagnostic_tests.rs CHANGED Viewed

@@ -119,3 +119,39 @@ fn payloadFreeVariantRejectsNamedArguments() {
     assert_eq!((es[0].line, es[0].column), (4, 20), "{es:?}");
     assert!(es[0].message.contains("variant 'Nothing': expected 0 arg(s), got 1"), "{es:?}");
 }
+const INTERP_TYPES: &str = "struct Dur(ms: Int) =\n  fun toMillis(self) -> Int = self.ms\n\nstruct Tm(t: Int) =\n  fun sub(self, d: Dur) -> Dur = Dur(ms: self.t - d.ms)\n\n";
+/// A type error inside an interpolation is the type error, at the bad node inside the string.
+#[test]
+fn interpolationTypeErrorIsReportedAtTheBadCall() {
+    let src = format!("{INTERP_TYPES}fun f(a: Tm, b: Tm) -> Str = \"x {{b.sub(a).toMillis()}}\"\n");
+    let es = errors(&src);
+    assert_eq!(es.len(), 1, "{es:?}");
+    assert_eq!(es[0].kind, DiagKind::Type, "{es:?}");
+    assert!(es[0].message.contains("expected Dur, found Tm"), "{es:?}");
+    assert_eq!((es[0].line, es[0].column), (7, 34), "{es:?}");
+}
+/// The same mistake outside a string gives the same wording.
+#[test]
+fn interpolationTypeErrorHasTheWordingOfThePlainExpression() {
+    let plain = errors(&format!("{INTERP_TYPES}fun f(a: Tm, b: Tm) -> Int = b.sub(a).toMillis()\n"));
+    let interp = errors(&format!("{INTERP_TYPES}fun f(a: Tm, b: Tm) -> Str = \"{{b.sub(a).toMillis()}}\"\n"));
+    assert_eq!(plain[0].message, interp[0].message);
+}
+/// Nested interpolation and a triple-quoted multi-line string report the bad part's own line.
+#[test]
+fn interpolationTypeErrorPositionsInNestedAndMultiLineStrings() {
+    let multi = format!("{INTERP_TYPES}fun f(a: Tm, b: Tm) -> Str =\n  \"\"\"one\n  two {{b.sub(a).t}}\"\"\"\n");
+    let es = errors(&multi);
+    assert_eq!(es.len(), 1, "{es:?}");
+    assert!(es[0].message.contains("expected Dur, found Tm"), "{es:?}");
+    assert_eq!(es[0].line, 9, "{es:?}");
+    let nested = format!("{INTERP_TYPES}fun f(a: Tm, b: Tm) -> Str = \"x {{\"in {{b.sub(a).toMillis()}}\"}}\"\n");
+    let es = errors(&nested);
+    assert_eq!(es.len(), 1, "{es:?}");
+    assert!(es[0].message.contains("expected Dur, found Tm"), "{es:?}");
+    assert_eq!((es[0].line, es[0].column), (7, 39), "{es:?}");
+}

compiler/wasm-codegen/tests/wasm_codegen/codegen_tests.rs CHANGED Viewed

@@ -1043,6 +1043,28 @@ fun main() -> Int =
     assert_eq!(runMerged::<i64>("question_interp", src), 1);
 }
+/// A valid method chain inside an interpolation still compiles and runs (the part's
+/// type errors are reported now, F-INTERP-1; a correct part must not be affected).
+#[test]
+fn valid_method_chain_inside_string_interpolation_runs() {
+    let src = "\
+import std/Str
+import std/Int
+struct A(n: Int) =
+  fun c(self) -> B = B(m: self.n + 1)
+struct B(m: Int) =
+  fun b(self) -> Int = self.m * 10
+fun main() -> Int =
+  a := A(n: 4)
+  s := \"v={a.c().b()}\"
+  return s.length()
+";
+    assert_eq!(runMerged::<i64>("interp_chain", src), 4);
+}
 // ---- mixed types via enums (T4) ----
 /// Compiles `src` as a real file (so `import std/...` resolves against the repo's