diff --git a/src/protocol/parser/pass_definitions.rs b/src/protocol/parser/pass_definitions.rs
index 2f901cfd514e709e41823a10195bfae922b33871..a96d0f2df6f0cca3f62ea4f1017449ab885b0f2f 100644
--- a/src/protocol/parser/pass_definitions.rs
+++ b/src/protocol/parser/pass_definitions.rs
@@ -423,13 +423,28 @@ impl PassDefinitions {
                 let id = self.consume_synchronous_statement(module, iter, ctx)?;
                 section.push(id.upcast());
 
-                let end_sync = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
-                    this, start_sync: id, next: StatementId::new_invalid()
+                let end_sync = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement {
+                    this,
+                    start_sync: id,
+                    next: StatementId::new_invalid()
                 });
                 section.push(end_sync.upcast());
 
                 let sync_stmt = &mut ctx.heap[id];
                 sync_stmt.end_sync = end_sync;
+            } else if ident == KW_STMT_FORK {
+                let id = self.consume_fork_statement(module, iter, ctx)?;
+                section.push(id.upcast());
+
+                let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement{
+                    this,
+                    start_fork: id,
+                    next: StatementId::new_invalid(),
+                });
+                section.push(end_fork.upcast());
+
+                let fork_stmt = &mut ctx.heap[id];
+                fork_stmt.end_fork = end_fork;
             } else if ident == KW_STMT_RETURN {
                 let id = self.consume_return_statement(module, iter, ctx)?;
                 section.push(id.upcast());
@@ -613,6 +628,29 @@ impl PassDefinitions {
         }))
     }
 
+    fn consume_fork_statement(
+        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
+    ) -> Result<ForkStatementId, ParseError> {
+        let fork_span = consume_exact_ident(&module.source, iter, KW_STMT_FORK)?;
+        let left_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
+
+        let right_body = if has_ident(&module.source, iter, KW_STMT_OR) {
+            iter.consume();
+            let right_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
+            Some(right_body)
+        } else {
+            None
+        };
+
+        Ok(ctx.heap.alloc_fork_statement(|this| ForkStatement{
+            this,
+            span: fork_span,
+            left_body,
+            right_body,
+            end_fork: EndForkStatementId::new_invalid(),
+        }))
+    }
+
     fn consume_return_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ReturnStatementId, ParseError> {