feat(ast): allow differing function implementations

`FunctionDeclaration` has an `implementation` property, which is an enum
of different implementation sources. Currently only `Body` (existing
behaviour where the implementation is within a set of curly brackets)
and `None` (basic support for `extern` functions) are supported.

Author: andogq

src/ir/ast.rs

@@ -115,7 +115,17 @@ mod function {
     #[derive(Clone, Debug)]
     pub struct FunctionDeclaration {
         pub signature: FunctionSignature,
-        pub body: BlockId,
+        pub implementation: FunctionImplementation,
+    }
+
+    /// The implementation of a function.
+    #[derive(Clone, Debug)]
+    pub enum FunctionImplementation {
+        /// No implementation has been provided for the function, although one may be added by a
+        /// later stage.
+        None,
+        /// Implementation exists within the provided [`Block`].
+        Body(BlockId),
     }
 
     #[derive(Clone, Debug)]

src/main.rs

@@ -499,5 +499,19 @@ mod test {
                 10
             );
         }
+
+        #[test]
+        #[should_panic(expected = "cannot generate HIR for function without implementation")]
+        fn extern_function_no_implementation() {
+            run(r#"extern fn something() -> bool;
+
+            fn main() -> u8 {
+                if something() {
+                    3
+                } else {
+                    7
+                }
+            }"#);
+        }
     }
 }

src/passes/ast_gen.rs

@@ -28,7 +28,7 @@ impl<'ctx, 'cst> Pass<'ctx, 'cst> for AstGen<'ctx> {
                     ast_gen.lower_trait_implementation(trait_implementation);
                 }
                 cst::Item::ExternalFunction(external_function) => {
-                    todo!();
+                    ast_gen.lower_external_function(external_function);
                 }
             }
         }
@@ -48,7 +48,7 @@ impl<'ctx> AstGen<'ctx> {
     fn lower_function(&mut self, function: &cst::FunctionDeclaration) -> FunctionId {
         let function_declaration = FunctionDeclaration {
             signature: self.lower_function_signature(&function.signature),
-            body: self.lower_block(&function.body),
+            implementation: FunctionImplementation::Body(self.lower_block(&function.body)),
         };
         self.ast.function_declarations.insert(function_declaration)
     }
@@ -59,6 +59,16 @@ impl<'ctx> AstGen<'ctx> {
         id
     }
 
+    fn lower_external_function(&mut self, external_function: &cst::ExternalFunction) -> FunctionId {
+        let signature = self.lower_function_signature(&external_function.signature);
+        let id = self.ast.function_declarations.insert(FunctionDeclaration {
+            signature,
+            implementation: FunctionImplementation::None,
+        });
+        self.ast.item_functions.push(id);
+        id
+    }
+
     fn lower_function_signature(
         &mut self,
         signature: &cst::FunctionSignature,
@@ -411,4 +421,21 @@ mod test {
         pass.lower_trait_implementation(&parse(source));
         assert_debug_snapshot!(name, pass.ast.trait_implementations[0], source);
     }
+
+    #[rstest]
+    #[case("external_function_simple", "extern fn some_function();")]
+    #[case(
+        "external_function_parameters",
+        "extern fn some_function(parameter: u8);"
+    )]
+    #[case("external_function_return", "extern fn some_function() -> bool;")]
+    #[case(
+        "external_function_full",
+        "extern fn some_function(parameter: u8) -> bool;"
+    )]
+    fn external_function(#[case] name: &str, mut ctx: Ctx, #[case] source: &'static str) {
+        let mut pass = AstGen::new(&mut ctx);
+        let id = pass.lower_external_function(&parse(source));
+        assert_debug_snapshot!(name, pass.ast[id], source);
+    }
 }

src/passes/hir_gen.rs

@@ -190,7 +190,14 @@ impl<'ctx, 'ast> HirGen<'ctx, 'ast> {
         };
 
         // Lower the body of the function.
-        let entry = self.lower_block(ctx, &self.ast[function.body], function_scope)?;
+        let entry = match &function.implementation {
+            ast::FunctionImplementation::Body(body) => {
+                self.lower_block(ctx, &self.ast[*body], function_scope)?
+            }
+            ast::FunctionImplementation::None => {
+                panic!("cannot generate HIR for function without implementation")
+            }
+        };
 
         Ok(self.hir.functions.insert(Function {
             binding,

src/passes/snapshots/lumina2__passes__ast_gen__test__external_function_full.snap

@@ -0,0 +1,27 @@
+---
+source: src/passes/ast_gen.rs
+expression: "extern fn some_function(parameter: u8) -> bool;"
+---
+FunctionDeclaration {
+    signature: FunctionSignature {
+        name: StringId(
+            0,
+        ),
+        parameters: [
+            FunctionParameter {
+                name: StringId(
+                    1,
+                ),
+                ty: AstTypeId(
+                    0,
+                ),
+            },
+        ],
+        return_ty: Some(
+            AstTypeId(
+                1,
+            ),
+        ),
+    },
+    implementation: None,
+}

src/passes/snapshots/lumina2__passes__ast_gen__test__external_function_parameters.snap

@@ -0,0 +1,23 @@
+---
+source: src/passes/ast_gen.rs
+expression: "extern fn some_function(parameter: u8);"
+---
+FunctionDeclaration {
+    signature: FunctionSignature {
+        name: StringId(
+            0,
+        ),
+        parameters: [
+            FunctionParameter {
+                name: StringId(
+                    1,
+                ),
+                ty: AstTypeId(
+                    0,
+                ),
+            },
+        ],
+        return_ty: None,
+    },
+    implementation: None,
+}

src/passes/snapshots/lumina2__passes__ast_gen__test__external_function_return.snap

@@ -0,0 +1,18 @@
+---
+source: src/passes/ast_gen.rs
+expression: extern fn some_function() -> bool;
+---
+FunctionDeclaration {
+    signature: FunctionSignature {
+        name: StringId(
+            0,
+        ),
+        parameters: [],
+        return_ty: Some(
+            AstTypeId(
+                0,
+            ),
+        ),
+    },
+    implementation: None,
+}

src/passes/snapshots/lumina2__passes__ast_gen__test__external_function_simple.snap

@@ -0,0 +1,14 @@
+---
+source: src/passes/ast_gen.rs
+expression: extern fn some_function();
+---
+FunctionDeclaration {
+    signature: FunctionSignature {
+        name: StringId(
+            0,
+        ),
+        parameters: [],
+        return_ty: None,
+    },
+    implementation: None,
+}

src/ty/mod.rs

@@ -351,7 +351,7 @@ mod test {
                     parameters: Vec::new(),
                     return_ty: None,
                 },
-                body: block_id,
+                implementation: ast::FunctionImplementation::Body(block_id),
             });
             // Add function as top level function.
             ast.item_functions.push(function_id);