Private foreign function should result in parser error

[Akirathan]

Follow-up of #10060

The following snippet:

private foreign js js_func = """
    return 42;

Should result in parsing error. Currently, the parser returns:

(Private (Function (Ident foreign) #((() (Ident js) () ()) (() (Ident js_func) () ())) () "=" (TextLiteral #((Section "return 42;")))))

but it should result in an invalid tree. Or even better in (Private (ForeignFunction ...)).

Failed attempts

diff --git a/lib/rust/parser/debug/tests/parse.rs b/lib/rust/parser/debug/tests/parse.rs
index b9d7e0489..c1e0c3ce6 100644
--- a/lib/rust/parser/debug/tests/parse.rs
+++ b/lib/rust/parser/debug/tests/parse.rs
@@ -492,6 +492,12 @@ fn foreign_functions() {
             #((() (Ident a) () ()) (() (Ident b) () ()))
             "="
             (TextLiteral #((Section "42")))));
+
+    test!("private foreign python my_method a b = \"42\"",
+        (Private (ForeignFunction foreign python my_method
+            #((() (Ident a) () ()) (() (Ident b) () ()))
+            "="
+            (TextLiteral #((Section "42"))))));
 }
 
 #[test]
diff --git a/lib/rust/parser/src/macros/built_in.rs b/lib/rust/parser/src/macros/built_in.rs
index f06804ac6..cd1fdefd7 100644
--- a/lib/rust/parser/src/macros/built_in.rs
+++ b/lib/rust/parser/src/macros/built_in.rs
@@ -753,9 +753,29 @@ fn private_keyword<'s>(
     precedence: &mut operator::Precedence<'s>,
 ) -> syntax::Tree<'s> {
     use syntax::tree::*;
-    let segment = segments.pop().0;
-    let keyword = into_private(segment.header);
-    let body_opt = precedence.resolve(segment.result.tokens());
+    let segment = segments.pop();
+    let matched_segment = segment.0;
+    let rest_of_segment = segment.1;
+    println!("private_keyword: matched_segment={:#?}", matched_segment);
+    println!("private_keyword: rest_of_segment={:#?}", rest_of_segment);
+    let cloned_result = matched_segment.result.clone();
+    let cloned_tokens = cloned_result.tokens();
+    let first_item = cloned_tokens.first().unwrap().clone();
+    println!("private_keyword: first_item={:#?}", first_item);
+    let first_ident = try_into_token(first_item)
+    .and_then(try_token_into_ident);
+    if let Some(mut id) = first_ident && id.code == "foreign" {
+        println!("private_keyword: first token in body is 'foreign' identifier");
+        id.left_offset += matched_segment.header.left_offset;
+        // TODO: Add left offset of the private keyword?
+        let foreign_body_opt = try_foreign_body(id, cloned_tokens, precedence);
+        if foreign_body_opt.is_ok() {
+            println!("private_keyword: body is a foreign function");
+            return foreign_body_opt.unwrap();
+        }
+    }
+    let keyword = into_private(matched_segment.header);
+    let body_opt = precedence.resolve(matched_segment.result.tokens());
     match body_opt {
         Some(body) => {
             let statement = crate::expression_to_statement(body);

Tasks

Preview Give feedback

1. Update documentation

[kazcw]

Currently we treat the body of any macro as expression context. For private, we need a new behavior in the macro resolver: When handling Step::StartSegment(header), leave the context unchanged so that if private is in statement context, we recognize functions etc in its body.
One way to do this would be to add a new field to macro::Definition to mark whether it has this context-preserving property, and in the resolver include that information in Step::StartSegment (maybe as an Option<Context>, that is either None: preserve or Some(Context::Expression): set to Expression).