9b45c3f | plum | pyrossh

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

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

9b45c3f — Peter John 2026-11-02T15:39:26+05:30

Report an unclosed delimiter at its opener; hint suggests a bare return body

Files changed (3) hide show

plum-cli/tests/compile_tests.rs +33 -0
plum-core/src/loader.rs +29 -2
plum-core/tests/loader_test.rs +19 -2

plum-cli/tests/compile_tests.rs CHANGED Viewed

@@ -74,3 +74,36 @@ fn compileWithImportResolvesViaLibPath() {
     let bytes = std::fs::read(out_path).expect("output wasm not found");
     assert_eq!(&bytes[0..4], b"\0asm");
 }
+/// The body the parse-error hint for `()` suggests must itself compile, with
+/// only the imports the failing file already had.
+#[test]
+fn returnBodySuggestedByTheParseErrorHintCompiles() {
+    let dir = freshTempDir("return_hint");
+    let src_path = dir.join("h.plum");
+    std::fs::write(
+        &src_path,
+        "import std/Float\n\nexport fun update(w: Float, dt: Float) =\n  return\n",
+    )
+    .unwrap();
+    let out_path = dir.join("h.wasm");
+    let repo = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap();
+    let output = Command::new(plumBin())
+        .args([
+            "compile",
+            src_path.to_str().unwrap(),
+            "-o",
+            out_path.to_str().unwrap(),
+            "--lib-path",
+            repo.to_str().unwrap(),
+        ])
+        .output()
+        .expect("failed to run plum compile");
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+}

plum-core/src/loader.rs CHANGED Viewed

@@ -263,7 +263,7 @@ impl SyntaxError {
                 if tok == "()" {
                     msg.push_str(
                         "\n  hint: `()` is not a value in Plum; a body with nothing to do \
-                         can be `_ := 0` (or `todo` while it is unimplemented)",
+                         is `return` (or `todo` while it is unimplemented)",
                     );
                 }
                 msg
@@ -285,7 +285,8 @@ impl SyntaxError {
 ///   `y := 3` blames `y`);
 /// - an `ERROR` that only wraps tokens the parser had already accepted (it
 ///   gave up on them after seeing what came next) blames the first token
-///   after it, or end of file when nothing follows.
+///   after it, or end of file when nothing follows (reported as the
+///   innermost unclosed delimiter when the file ends inside one).
 pub fn syntaxErrors(root: tree_sitter::Node, text: &str) -> Vec<SyntaxError> {
     let mut out: Vec<SyntaxError> = Vec::new();
     collectSyntaxErrors(root, root, text, &mut out);
@@ -344,6 +345,13 @@ fn locateError(err: tree_sitter::Node, root: tree_sitter::Node, text: &str) -> S
         leafStartingAtOrAfter(root, err.end_byte())
     };
     let eof = || {
+        if let Some(open) = innermostUnclosed(root) {
+            return SyntaxError {
+                start: open.start_position(),
+                end: open.end_position(),
+                kind: SyntaxErrorKind::Unclosed(open.kind().to_string()),
+            };
+        }
         let end = lastLeaf(root).map_or(root.end_position(), |l| l.end_position());
         SyntaxError {
             start: end,
@@ -407,6 +415,25 @@ fn closerOf(kind: &str) -> Option<&'static str> {
     }
 }
+/// The last opening delimiter still open at the end of the file, if any.
+fn innermostUnclosed(root: tree_sitter::Node) -> Option<tree_sitter::Node> {
+    let mut stack: Vec<tree_sitter::Node> = Vec::new();
+    let mut at = 0;
+    while let Some(leaf) = leafStartingAtOrAfter(root, at) {
+        if closerOf(leaf.kind()).is_some() {
+            stack.push(leaf);
+        } else if matches!(leaf.kind(), ")" | "]" | "}") {
+            if let Some(top) = stack.last() {
+                if closerOf(top.kind()) == Some(leaf.kind()) {
+                    stack.pop();
+                }
+            }
+        }
+        at = leaf.end_byte();
+    }
+    stack.pop()
+}
 /// Whether `open` has a matching `closer` later in the file, counting nesting.
 fn isClosed(root: tree_sitter::Node, open: tree_sitter::Node, closer: &str) -> bool {
     let mut depth = 1usize;

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -283,7 +283,10 @@ fn parseErrorBlamesTheTokenNotTheWholeFunction() {
         err.contains("at line 4, column 3: unexpected '()'"),
         "{err}"
     );
+    assert!(
-    assert!(err.contains("hint:") && err.contains("_ := 0"), "{err}");
+        err.contains("hint:") && err.contains("is `return`"),
+        "{err}"
+    );
     assert!(!err.contains("export fun"), "{err}");
 }
@@ -305,6 +308,18 @@ fn parseErrorOnMissingClosingDelimiter() {
     assert!(err.contains("at line 3, column 3: unexpected 'y'"), "{err}");
 }
+#[test]
+fn unclosedOpenerAtEndOfFileIsReportedAtTheOpener() {
+    let err = parseErrorOf("import std/Int\n\nfun f(a: Int) -> Int =\n  g(a, 2\n");
+    assert!(err.contains("at line 4, column 4: unclosed '('"), "{err}");
+    let err = parseErrorOf("fun f() =\n  x := [1, 2\n");
+    assert!(err.contains("at line 2, column 8: unclosed '['"), "{err}");
+    let err = parseErrorOf("fun f() =\n  x := g(h(1), 2\n");
+    assert!(err.contains("at line 2, column 9: unclosed '('"), "{err}");
+    let err = parseErrorOf("fun f() =\n  x := { 1 + 2\n");
+    assert!(err.contains("at line 2, column 8: unclosed '{'"), "{err}");
+}
 #[test]
 fn parseErrorAtEndOfFile() {
     let err = parseErrorOf("fun f() =\n  x := 1 +\n");
@@ -313,8 +328,10 @@ fn parseErrorAtEndOfFile() {
         "{err}"
     );
     let err = parseErrorOf("fun f() =\n  x := foo(1, 2");
+    assert!(err.contains("at line 2, column 11: unclosed '('"), "{err}");
+    let err = parseErrorOf("fun f() =\n  if true\n    x := 1\n  else\n");
     assert!(
-        err.contains("at line 2, column 16: unexpected end of file"),
+        err.contains("at line 4, column 7: unexpected end of file"),
         "{err}"
     );
 }