[package]

name = "reowolf_rs"

version = "0.1.4"

authors = [

	"Christopher Esterhuyse <esterhuy@cwi.nl, christopher.esterhuyse@gmail.com>",

	"Hans-Dieter Hiep <hdh@cwi.nl>"

]

edition = "2018"

[dependencies]

# convenience macros

maplit = "1.0.2"

derive_more = "0.99.2"

# runtime

bincode = "1.3.1"

serde = { version = "1.0.114", features = ["derive"] }

getrandom = "0.1.14" # tiny crate. used to guess controller-id

# network

mio = { version = "0.7.0", package = "mio", features = ["udp", "tcp", "os-poll"] }

socket2 = { version = "0.3.12", optional = true }

# protocol

backtrace = "0.3"

lazy_static = "1.4.0"

# ffi

# socket ffi

libc = { version = "^0.2", optional = true }

os_socketaddr = { version = "0.1.0", optional = true }

[dev-dependencies]

# test-generator = "0.3.0"

crossbeam-utils = "0.7.2"

lazy_static = "1.4.0"

[lib]

# compile target: dynamically linked library using C ABI

crate-type = ["cdylib"]

[features]

ffi = [] # see src/ffi/mod.rs

ffi_pseudo_socket_api = ["ffi", "libc", "os_socketaddr"]# see src/ffi/pseudo_socket_api.rs

endpoint_logging = [] # see src/macros.rs

session_optimization = [] # see src/runtime/setup.rs

#ifndef REOWOLF_HEADER_DEFINED

#define REOWOLF_HEADER_DEFINED

#include <stdarg.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdlib.h>

#define RW_BAD_FD -5

#define RW_BAD_SOCKADDR -8

#define RW_CLOSE_FAIL -4

#define RW_CONNECT_FAILED -6

#define RW_LOCK_POISONED -3

#define RW_OK 0

#define RW_TL_ERR -1

#define RW_WOULD_BLOCK -7

#define RW_WRONG_STATE -2

typedef enum {

  EndpointPolarity_Active,

  EndpointPolarity_Passive,

} EndpointPolarity;

typedef enum {

  Polarity_Putter,

  Polarity_Getter,

} Polarity;

typedef struct Arc_ProtocolDescription Arc_ProtocolDescription;

typedef struct Connector Connector;

typedef uint32_t ConnectorId;

typedef uint32_t U32Suffix;

typedef struct {

  ConnectorId connector_id;

  U32Suffix u32_suffix;

typedef struct {

  uint8_t ipv4[4];

  uint16_t port;

} FfiSocketAddr;

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a string slice for the component's identifier in the connector's configured protocol description,

 * - a set of ports (represented as a slice; duplicates are ignored) in the native component's interface,

 * the connector creates a new (internal) protocol component C, such that the set of native ports are moved to C.

 * Usable in {setup, communication} states.

 */

int connector_add_component(Connector *connector,

                            const uint8_t *ident_ptr,

                            uintptr_t ident_len,

                            const PortId *ports_ptr,

                            uintptr_t ports_len);

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a utf-8 encoded socket address,

 * - the logical polarity of P,

 * - the "physical" polarity in {Active, Passive} of the endpoint through which P's peer will be discovered,

 * returns P, a port newly added to the native interface.

 */

int connector_add_net_port(Connector *connector,

                           PortId *port,

                           FfiSocketAddr addr,

                           Polarity port_polarity,

                           EndpointPolarity endpoint_polarity);

/**

 * Given an initialized connector in setup or connecting state,

 * - Creates a new directed port pair with logical channel putter->getter,

 * - adds the ports to the native component's interface,

 * - and returns them using the given out pointers.

 * Usable in {setup, communication} states.

 */

void connector_add_port_pair(Connector *connector, PortId *out_putter, PortId *out_getter);

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a utf-8 encoded BIND socket addresses (i.e., "local"),

 * - a utf-8 encoded CONNECT socket addresses (i.e., "peer"),

            Statement::EndSynchronous(result) => result,

            _ => panic!("Unable to cast `Statement` to `EndSynchronousStatement`"),

        }

    }

    pub fn as_return(&self) -> &ReturnStatement {

        match self {

            Statement::Return(result) => result,

            _ => panic!("Unable to cast `Statement` to `ReturnStatement`"),

        }

    }

    pub fn as_assert(&self) -> &AssertStatement {

        match self {

            Statement::Assert(result) => result,

            _ => panic!("Unable to cast `Statement` to `AssertStatement`"),

        }

    }

    pub fn as_goto(&self) -> &GotoStatement {

        match self {

            Statement::Goto(result) => result,

            _ => panic!("Unable to cast `Statement` to `GotoStatement`"),

        }

    }

    pub fn as_goto_mut(&mut self) -> &mut GotoStatement {

        match self {

            Statement::Goto(result) => result,

            _ => panic!("Unable to cast `Statement` to `GotoStatement`"),

        }

    }

    pub fn as_new(&self) -> &NewStatement {

        match self {

            Statement::New(result) => result,

            _ => panic!("Unable to cast `Statement` to `NewStatement`"),

        }

    }

    pub fn as_put(&self) -> &PutStatement {

        match self {

            Statement::Put(result) => result,

            _ => panic!("Unable to cast `Statement` to `PutStatement`"),

        }

    }

    pub fn as_expression(&self) -> &ExpressionStatement {

        match self {

            Statement::Expression(result) => result,

            _ => panic!("Unable to cast `Statement` to `ExpressionStatement`"),

        }

    }

    pub fn link_next(&mut self, next: StatementId) {

        match self {

            Statement::Local(stmt) => match stmt {

                LocalStatement::Channel(stmt) => stmt.next = Some(next),

                LocalStatement::Memory(stmt) => stmt.next = Some(next),

            },

            Statement::Skip(stmt) => stmt.next = Some(next),

            Statement::EndIf(stmt) => stmt.next = Some(next),

            Statement::EndWhile(stmt) => stmt.next = Some(next),

            Statement::EndSynchronous(stmt) => stmt.next = Some(next),

            Statement::Assert(stmt) => stmt.next = Some(next),

            Statement::New(stmt) => stmt.next = Some(next),

            Statement::Put(stmt) => stmt.next = Some(next),

            Statement::Expression(stmt) => stmt.next = Some(next),

        }

    }

}

impl SyntaxElement for Statement {

    fn position(&self) -> InputPosition {

        match self {

            Statement::Block(stmt) => stmt.position(),

            Statement::Local(stmt) => stmt.position(),

            Statement::Skip(stmt) => stmt.position(),

            Statement::Labeled(stmt) => stmt.position(),

            Statement::If(stmt) => stmt.position(),

            Statement::EndIf(stmt) => stmt.position(),

            Statement::While(stmt) => stmt.position(),

            Statement::EndWhile(stmt) => stmt.position(),

            Statement::Break(stmt) => stmt.position(),

            Statement::Continue(stmt) => stmt.position(),

            Statement::Synchronous(stmt) => stmt.position(),

            Statement::EndSynchronous(stmt) => stmt.position(),

            Statement::Return(stmt) => stmt.position(),

            Statement::Assert(stmt) => stmt.position(),

            Statement::Goto(stmt) => stmt.position(),

            Statement::New(stmt) => stmt.position(),

            Statement::Put(stmt) => stmt.position(),

            Statement::Expression(stmt) => stmt.position(),

        }

    }

}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct BlockStatement {

    pub this: BlockStatementId,

    // Phase 1: parser

    pub position: InputPosition,

    pub statements: Vec<StatementId>,

    // Phase 2: linker

    pub parent_scope: Option<Scope>,

    pub locals: Vec<LocalId>,

    pub labels: Vec<LabeledStatementId>,

}

impl BlockStatement {

    pub fn parent_block(&self, h: &Heap) -> Option<BlockStatementId> {

        let parent = self.parent_scope.unwrap();

        match parent {

            Scope::Definition(_) => {

                // If the parent scope is a definition, then there is no

                // parent block.

                        right = self.eval(h, ctx, expr.right)?;

                        right.as_boolean(); // panics if not a boolean

                        return Ok(right);

                    }

                    BinaryOperator::LogicalOr => {

                        if left.as_boolean().0 == true {

                            return Ok(left);

                        }

                        right = self.eval(h, ctx, expr.right)?;

                        right.as_boolean(); // panics if not a boolean

                        return Ok(right);

                    }

                    _ => {}

                }

                right = self.eval(h, ctx, expr.right)?;

                match expr.operation {

                    BinaryOperator::Equality => Ok(left.eq(&right)),

                    BinaryOperator::Inequality => Ok(left.neq(&right)),

                    BinaryOperator::LessThan => Ok(left.lt(&right)),

                    BinaryOperator::LessThanEqual => Ok(left.lte(&right)),

                    BinaryOperator::GreaterThan => Ok(left.gt(&right)),

                    BinaryOperator::GreaterThanEqual => Ok(left.gte(&right)),

                    BinaryOperator::Remainder => Ok(left.modulus(&right)),

                    _ => unimplemented!("{:?}", expr.operation),

                }

            }

            Expression::Unary(expr) => {

                let mut value = self.eval(h, ctx, expr.expression)?;

                match expr.operation {

                    UnaryOperation::PostIncrement => {

                        self.update(h, ctx, expr.expression, value.plus(&ONE))?;

                    }

                    UnaryOperation::PreIncrement => {

                        value = value.plus(&ONE);

                        self.update(h, ctx, expr.expression, value.clone())?;

                    }

                    UnaryOperation::PostDecrement => {

                        self.update(h, ctx, expr.expression, value.minus(&ONE))?;

                    }

                    UnaryOperation::PreDecrement => {

                        value = value.minus(&ONE);

                        self.update(h, ctx, expr.expression, value.clone())?;

                    }

                    _ => unimplemented!(),

                }

                Ok(value)

            }

            Expression::Indexing(expr) => self.get(h, ctx, expr.this.upcast()),

            Expression::Select(expr) => self.get(h, ctx, expr.this.upcast()),

            Expression::Array(expr) => {

                let mut elements = Vec::new();

                for &elem in expr.elements.iter() {

                    elements.push(self.eval(h, ctx, elem)?);

                }

                todo!()

            }

            Expression::Constant(expr) => Ok(Value::from_constant(&expr.value)),

            Expression::Call(expr) => match expr.method {

                Method::Create => {

                    assert_eq!(1, expr.arguments.len());

                    let length = self.eval(h, ctx, expr.arguments[0])?;

                    Ok(Value::create_message(length))

                }

                Method::Fires => {

                    assert_eq!(1, expr.arguments.len());

                    let value = self.eval(h, ctx, expr.arguments[0])?;

                    match ctx.fires(value.clone()) {

                        None => Err(EvalContinuation::BlockFires(value)),

                        Some(result) => Ok(result),

                    }

                }

                Method::Get => {

                    assert_eq!(1, expr.arguments.len());

                    let value = self.eval(h, ctx, expr.arguments[0])?;

                    match ctx.get(value.clone()) {

                        None => Err(EvalContinuation::BlockGet(value)),

                        Some(result) => Ok(result),

                    }

                }

            },

            Expression::Variable(expr) => self.get(h, ctx, expr.this.upcast()),

        }

    }

}

type EvalResult = Result<Value, EvalContinuation>;

pub enum EvalContinuation {

    Stepping,

    Inconsistent,

    Terminal,

    SyncBlockStart,

    SyncBlockEnd,

    NewComponent(DeclarationId, Vec<Value>),

    BlockFires(Value),

    BlockGet(Value),

    Put(Value, Value),

}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub(crate) struct Prompt {

    definition: DefinitionId,

    store: Store,

    position: Option<StatementId>,

}

impl Prompt {

    pub fn new(h: &Heap, def: DefinitionId, args: &Vec<Value>) -> Self {

        let mut prompt =

            Prompt { definition: def, store: Store::new(), position: Some((&h[def]).body()) };

        prompt.set_arguments(h, args);

        prompt

    }

    fn set_arguments(&mut self, h: &Heap, args: &Vec<Value>) {

        let def = &h[self.definition];

        let params = def.parameters();

        assert_eq!(params.len(), args.len());

        for (param, value) in params.iter().zip(args.iter()) {

            let hparam = &h[*param];

            let type_annot = &h[hparam.type_annotation];

            assert!(value.is_type_compatible(&type_annot.the_type));

            self.store.initialize(h, param.upcast(), value.clone());

        }

    }

    pub fn step(&mut self, h: &Heap, ctx: &mut EvalContext) -> EvalResult {

        if self.position.is_none() {

            return Err(EvalContinuation::Terminal);

        }

                // Continue to beginning of while

                self.position = stmt.target.map(WhileStatementId::upcast);

                Err(EvalContinuation::Stepping)

            }

            Statement::Assert(stmt) => {

                // Evaluate expression

                let value = self.store.eval(h, ctx, stmt.expression)?;

                if value.as_boolean().0 {

                    // Continue to next statement

                    self.position = stmt.next;

                    Err(EvalContinuation::Stepping)

                } else {

                    // Assertion failed: inconsistent

                    Err(EvalContinuation::Inconsistent)

                }

            }

            Statement::Return(stmt) => {

                // Evaluate expression

                let value = self.store.eval(h, ctx, stmt.expression)?;

                // Done with evaluation

                Ok(value)

            }

            Statement::Goto(stmt) => {

                // Continue to target

                self.position = stmt.target.map(|x| x.upcast());

                Err(EvalContinuation::Stepping)

            }

            Statement::New(stmt) => {

                let expr = &h[stmt.expression];

                let mut args = Vec::new();

                for &arg in expr.arguments.iter() {

                    let value = self.store.eval(h, ctx, arg)?;

                    args.push(value);

                }

                self.position = stmt.next;

                Err(EvalContinuation::NewComponent(expr.declaration.unwrap(), args))

            }

            Statement::Put(stmt) => {

                // Evaluate port and message

                let port = self.store.eval(h, ctx, stmt.port)?;

                let message = self.store.eval(h, ctx, stmt.message)?;

                // Continue to next statement

                self.position = stmt.next;

                // Signal the put upwards

                Err(EvalContinuation::Put(port, message))

            }

            Statement::Expression(stmt) => {

                // Evaluate expression

                // Continue to next statement

                self.position = stmt.next;

                Err(EvalContinuation::Stepping)

            }

        }

    }

    // let mut prompt = Self::new(h, fun.upcast(), args);

    // let mut context = EvalContext::None;

    // loop {

    //     let result = prompt.step(h, &mut context);

    //     match result {

    //         Ok(val) => return Some(val),

    //         Err(cont) => match cont {

    //             EvalContinuation::Stepping => continue,

    //             EvalContinuation::Inconsistent => return None,

    //             // Functions never terminate without returning

    //             EvalContinuation::Terminal => unreachable!(),

    //             // Functions never encounter any blocking behavior

    //             EvalContinuation::SyncBlockStart => unreachable!(),

    //             EvalContinuation::SyncBlockEnd => unreachable!(),

    //             EvalContinuation::NewComponent(_, _) => unreachable!(),

    //             EvalContinuation::BlockFires(val) => unreachable!(),

    //             EvalContinuation::BlockGet(val) => unreachable!(),

    //             EvalContinuation::Put(port, msg) => unreachable!(),

    //         },

    //     }

    // }

}

// #[cfg(test)]

// mod tests {

//     extern crate test_generator;

//     use std::fs::File;

//     use std::io::Read;

//     use std::path::Path;

//     use test_generator::test_resources;

//     use super::*;

//     #[test_resources("testdata/eval/positive/*.pdl")]

//     fn batch1(resource: &str) {

//         let path = Path::new(resource);

//         let expect = path.with_extension("txt");

//         let mut heap = Heap::new();

//         let mut source = InputSource::from_file(&path).unwrap();

//         let mut parser = Parser::new(&mut source);

//         let pd = parser.parse(&mut heap).unwrap();

//         let def = heap[pd].get_definition_ident(&heap, b"test").unwrap();

//         let fun = heap[def].as_function().this;

//         let args = Vec::new();

//         let result = Prompt::compute_function(&heap, fun, &args).unwrap();

//         let valstr: String = format!("{}", result);

//         println!("{}", valstr);

//         let mut cev: Vec<u8> = Vec::new();

//         let mut f = File::open(expect).unwrap();

//         f.read_to_end(&mut cev).unwrap();

//         let lavstr = String::from_utf8_lossy(&cev);

//         println!("{}", lavstr);

//         assert_eq!(valstr, lavstr);

//     }

// }

    def: CompositeId,

) -> VisitorResult {

    for &param in h[def].parameters.clone().iter() {

        recursive_parameter_as_variable(this, h, param)?;

    }

    this.visit_statement(h, h[def].body)

}

fn recursive_primitive_definition<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    def: PrimitiveId,

) -> VisitorResult {

    for &param in h[def].parameters.clone().iter() {

        recursive_parameter_as_variable(this, h, param)?;

    }

    this.visit_statement(h, h[def].body)

}

fn recursive_function_definition<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    def: FunctionId,

) -> VisitorResult {

    for &param in h[def].parameters.clone().iter() {

        recursive_parameter_as_variable(this, h, param)?;

    }

    this.visit_statement(h, h[def].body)

}

fn recursive_variable_declaration<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    decl: VariableId,

) -> VisitorResult {

    match h[decl].clone() {

        Variable::Parameter(decl) => this.visit_parameter_declaration(h, decl.this),

        Variable::Local(decl) => this.visit_local_declaration(h, decl.this),

    }

}

fn recursive_statement<T: Visitor>(this: &mut T, h: &mut Heap, stmt: StatementId) -> VisitorResult {

    match h[stmt].clone() {

        Statement::Block(stmt) => this.visit_block_statement(h, stmt.this),

        Statement::Local(stmt) => this.visit_local_statement(h, stmt.this()),

        Statement::Skip(stmt) => this.visit_skip_statement(h, stmt.this),

        Statement::Labeled(stmt) => this.visit_labeled_statement(h, stmt.this),

        Statement::If(stmt) => this.visit_if_statement(h, stmt.this),

        Statement::While(stmt) => this.visit_while_statement(h, stmt.this),

        Statement::Break(stmt) => this.visit_break_statement(h, stmt.this),

        Statement::Continue(stmt) => this.visit_continue_statement(h, stmt.this),

        Statement::Synchronous(stmt) => this.visit_synchronous_statement(h, stmt.this),

        Statement::Return(stmt) => this.visit_return_statement(h, stmt.this),

        Statement::Assert(stmt) => this.visit_assert_statement(h, stmt.this),

        Statement::Goto(stmt) => this.visit_goto_statement(h, stmt.this),

        Statement::New(stmt) => this.visit_new_statement(h, stmt.this),

        Statement::Put(stmt) => this.visit_put_statement(h, stmt.this),

        Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),

    }

}

fn recursive_block_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    block: BlockStatementId,

) -> VisitorResult {

    for &local in h[block].locals.clone().iter() {

        recursive_local_as_variable(this, h, local)?;

    }

    for &stmt in h[block].statements.clone().iter() {

        this.visit_statement(h, stmt)?;

    }

    Ok(())

}

fn recursive_local_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    stmt: LocalStatementId,

) -> VisitorResult {

    match h[stmt].clone() {

        LocalStatement::Channel(stmt) => this.visit_channel_statement(h, stmt.this),

        LocalStatement::Memory(stmt) => this.visit_memory_statement(h, stmt.this),

    }

}

fn recursive_memory_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    stmt: MemoryStatementId,

) -> VisitorResult {

    this.visit_expression(h, h[stmt].initial)

}

fn recursive_labeled_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    stmt: LabeledStatementId,

) -> VisitorResult {

    this.visit_statement(h, h[stmt].body)

}

fn recursive_if_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    stmt: IfStatementId,

        match h[expr].method {

            Method::Get | Method::Fires => {

                if !self.legal {

                    return Err(ParseError::new(h[expr].position, "Illegal built-in occurrence"));

                }

            }

            _ => {}

        }

        recursive_call_expression(self, h, expr)

    }

}

struct BuildSymbolDeclarations {

    declarations: Vec<DeclarationId>,

}

impl BuildSymbolDeclarations {

    fn new() -> Self {

        BuildSymbolDeclarations { declarations: Vec::new() }

    }

    fn checked_add(&mut self, h: &mut Heap, decl: DeclarationId) -> VisitorResult {

        for &old in self.declarations.iter() {

            let id = h[decl].identifier();

            if h[id] == h[h[old].identifier()] {

                return match h[decl].clone() {

                    Declaration::Defined(defined) => Err(ParseError::new(

                        h[defined.definition].position(),

                        format!("Defined symbol clash: {}", h[id]),

                    )),

                    Declaration::Imported(imported) => Err(ParseError::new(

                        h[imported.import].position(),

                        format!("Imported symbol clash: {}", h[id]),

                    )),

                };

            }

        }

        self.declarations.push(decl);

        Ok(())

    }

}

impl Visitor for BuildSymbolDeclarations {

    fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {

        recursive_protocol_description(self, h, pd)?;

        // Move all collected declarations to the protocol description

        h[pd].declarations.append(&mut self.declarations);

        Ok(())

    }

        todo!()

        // let vec = library::get_declarations(h, import)?;

        // // Destructively iterate over the vector

        // for decl in vec {

        //     self.checked_add(h, decl)?;

        // }

        // Ok(())

    }

    fn visit_symbol_definition(&mut self, h: &mut Heap, definition: DefinitionId) -> VisitorResult {

        let signature = Signature::from_definition(h, definition);

        let decl = h

            .alloc_defined_declaration(|this| DefinedDeclaration { this, definition, signature })

            .upcast();

        self.checked_add(h, decl)?;

        Ok(())

    }

}

struct LinkCallExpressions {

    pd: Option<RootId>,

    composite: bool,

    new_statement: bool,

}

impl LinkCallExpressions {

    fn new() -> Self {

        LinkCallExpressions { pd: None, composite: false, new_statement: false }

    }

    fn get_declaration(

        &self,

        h: &Heap,

        id: SourceIdentifierId,

    ) -> Result<DeclarationId, ParseError> {

        match h[self.pd.unwrap()].get_declaration(h, id.upcast()) {

            Some(id) => Ok(id),

            None => Err(ParseError::new(h[id].position, "Unresolved method")),

        }

    }

}

impl Visitor for LinkCallExpressions {

    fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {

        self.pd = Some(pd);

        recursive_protocol_description(self, h, pd)?;

        self.pd = None;

        Ok(())

    }

    fn visit_composite_definition(&mut self, h: &mut Heap, def: CompositeId) -> VisitorResult {

}

struct BuildScope {

    scope: Option<Scope>,

}

impl BuildScope {

    fn new() -> Self {

        BuildScope { scope: None }

    }

}

impl Visitor for BuildScope {

    fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {

        assert!(self.scope.is_none());

        self.scope = Some(Scope::Definition(def));

        recursive_symbol_definition(self, h, def)?;

        self.scope = None;

        Ok(())

    }

    fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {

        assert!(!self.scope.is_none());

        let old = self.scope;

        // First store the current scope

        h[stmt].parent_scope = self.scope;

        // Then move scope down to current block

        self.scope = Some(Scope::Block(stmt));

        recursive_block_statement(self, h, stmt)?;

        // Move scope back up

        self.scope = old;

        Ok(())

    }

    fn visit_synchronous_statement(

        &mut self,

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

        assert!(!self.scope.is_none());

        let old = self.scope;

        // First store the current scope

        h[stmt].parent_scope = self.scope;

        // Then move scope down to current sync

        self.scope = Some(Scope::Synchronous(stmt));

        recursive_synchronous_statement(self, h, stmt)?;

        // Move scope back up

        self.scope = old;

        Ok(())

    }

        Ok(())

    }

}

struct ResolveVariables {

    scope: Option<Scope>,

}

impl ResolveVariables {

    fn new() -> Self {

        ResolveVariables { scope: None }

    }

    fn get_variable(&self, h: &Heap, id: SourceIdentifierId) -> Result<VariableId, ParseError> {

        if let Some(var) = self.find_variable(h, id) {

            Ok(var)

        } else {

            Err(ParseError::new(h[id].position, "Unresolved variable"))

        }

    }

    fn find_variable(&self, h: &Heap, id: SourceIdentifierId) -> Option<VariableId> {

        ResolveVariables::find_variable_impl(h, self.scope, id)

    }

    fn find_variable_impl(

        h: &Heap,

        scope: Option<Scope>,

        id: SourceIdentifierId,

    ) -> Option<VariableId> {

        if let Some(scope) = scope {

            // The order in which we check for variables is important:

            // otherwise, two variables with the same name are shadowed.

            if let Some(var) = ResolveVariables::find_variable_impl(h, scope.parent_scope(h), id) {

                Some(var)

            } else {

                scope.get_variable(h, id)

            }

        } else {

            None

        }

    }

}

impl Visitor for ResolveVariables {

    fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {

        assert!(self.scope.is_none());

        self.scope = Some(Scope::Definition(def));

        recursive_symbol_definition(self, h, def)?;

        self.scope = None;

        Ok(())

    }

    fn visit_variable_declaration(&mut self, h: &mut Heap, decl: VariableId) -> VisitorResult {

        // This is only called for parameters of definitions and synchronous statements,

        // since the local variables of block statements are still empty

        // the moment it is traversed. After resolving variables, this

        // function is also called for every local variable declaration.

        // We want to make sure that the resolved variable is the variable declared itself;

        // otherwise, there is some variable defined in the parent scope. This check

        // imposes that the order in which find_variable looks is significant!

        let id = h[decl].identifier();

        let check_same = self.find_variable(h, id);

        if let Some(check_same) = check_same {

            if check_same != decl {

                return Err(ParseError::new(h[id].position, "Declared variable clash"));

            }

        }

        recursive_variable_declaration(self, h, decl)

    }

    fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {