Store { map: HashMap::new() }

    }

    fn initialize(&mut self, h: &Heap, var: VariableId, value: Value) {

        // Ensure value is compatible with type of variable

        let the_type = h[var].the_type(h);

        assert!(value.is_type_compatible(the_type));

        // Overwrite mapping

        self.map.insert(var, value.clone());

    }

    fn update(

        &mut self,

        h: &Heap,

        ctx: &mut EvalContext,

        lexpr: ExpressionId,

        value: Value,

    ) -> EvalResult {

        match &h[lexpr] {

            Expression::Variable(var) => {

                let var = var.declaration.unwrap();

                // Ensure value is compatible with type of variable

                let the_type = h[var].the_type(h);

                assert!(value.is_type_compatible(the_type));

                // Overwrite mapping

                self.map.insert(var, value.clone());

                Ok(value)

            }

            Expression::Indexing(indexing) => {

                // Evaluate index expression, which must be some integral type

                let index = self.eval(h, ctx, indexing.index)?;

                // Mutable reference to the subject

                let subject;

                match &h[indexing.subject] {

                    Expression::Variable(var) => {

                        let var = var.declaration.unwrap();

                        subject = self.map.get_mut(&var).unwrap();

                    }

                    _ => unreachable!(),

                }

                match subject.set(&index, &value) {

                    Some(value) => Ok(value),

                    None => Err(EvalContinuation::Inconsistent),

                }

            }

            _ => unimplemented!("{:?}", h[lexpr]),

        }

    }

    fn get(&mut self, h: &Heap, rexpr: ExpressionId) -> EvalResult {

        match &h[rexpr] {

            Expression::Variable(var) => {

                let var = var.declaration.unwrap();

                let value = self.map.get(&var).expect(&format!("Uninitialized variable {:?}", h[h[var].identifier()]));

                Ok(value.clone())

            }

            _ => unimplemented!("{:?}", h[rexpr]),

        }

    }

    fn eval(&mut self, h: &Heap, ctx: &mut EvalContext, expr: ExpressionId) -> EvalResult {

        match &h[expr] {

            Expression::Assignment(expr) => {

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

                match expr.operation {

                    AssignmentOperator::Set => {

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

                    }

                    AssignmentOperator::Added => {

                        let old = self.get(h, expr.left)?;

                        self.update(h, ctx, expr.left, old.plus(&value));

                    }

                    AssignmentOperator::Subtracted => {

                        let old = self.get(h, expr.left)?;

                        self.update(h, ctx, expr.left, old.minus(&value));

                    }

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

                }

                Ok(value)

            }

            Expression::Conditional(expr) => {

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

                if test.as_boolean().0 {

                    self.eval(h, ctx, expr.true_expression)

                } else {

                    self.eval(h, ctx, expr.false_expression)

                }

            }

            Expression::Binary(expr) => {

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

                let 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!(),

                }

            }

            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, expr.this.upcast()),

            Expression::Slicing(expr) => unimplemented!(),

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

            Expression::Array(expr) => unimplemented!(),

            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),

                    }

                }

                Method::Symbolic(symbol) => unimplemented!(),

            },

            Expression::Variable(expr) => self.get(h, 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)]

pub 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 {

        match stmt {

            Statement::Block(stmt) => {

                // Continue to first statement

                self.position = Some(stmt.first());

                Err(EvalContinuation::Stepping)

            }

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Memory(stmt) => {

                        // Evaluate initial expression

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

                        // Update store

                        self.store.initialize(h, stmt.variable.upcast(), value);

                    }

                    LocalStatement::Channel(stmt) => {

                        let [from, to] = ctx.new_channel();

                        // Store the values in the declared variables

                        self.store.initialize(h, stmt.from.upcast(), from);

                        self.store.initialize(h, stmt.to.upcast(), to);

                    },

                }

                // Continue to next statement

                self.position = stmt.next();

                Err(EvalContinuation::Stepping)

            }

            Statement::Skip(stmt) => {

                // Continue to next statement

                self.position = stmt.next;

                Err(EvalContinuation::Stepping)

            }

            Statement::Labeled(stmt) => {

                // Continue to next statement

                self.position = Some(stmt.body);

                Err(EvalContinuation::Stepping)

            }

            Statement::If(stmt) => {

                // Evaluate test

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

                // Continue with either branch

                if value.as_boolean().0 {

                    self.position = Some(stmt.true_body);

                } else {

                    self.position = Some(stmt.false_body);

                }

                Err(EvalContinuation::Stepping)

            }

            Statement::EndIf(stmt) => {

                // Continue to next statement

                self.position = stmt.next;

                Err(EvalContinuation::Stepping)

            }

            Statement::While(stmt) => {

                // Evaluate test

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

                // Either continue with body, or go to next

                if value.as_boolean().0 {

                    self.position = Some(stmt.body);

                } else {

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

                }

                Err(EvalContinuation::Stepping)

            }

            Statement::EndWhile(stmt) => {

                // Continue to next statement

                self.position = stmt.next;

                Err(EvalContinuation::Stepping)

            }

            Statement::Synchronous(stmt) => {

                // Continue to next statement, and signal upward

                self.position = Some(stmt.body);

                Err(EvalContinuation::SyncBlockStart)

            }

            Statement::EndSynchronous(stmt) => {

                // Continue to next statement, and signal upward

                self.position = stmt.next;

                Err(EvalContinuation::SyncBlockEnd)

            }

            Statement::Break(stmt) => {

                // Continue to end of while

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

                Err(EvalContinuation::Stepping)

            }

            Statement::Continue(stmt) => {

                // 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

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

                // Continue to next statement

                self.position = stmt.next;

                Err(EvalContinuation::Stepping)

            }

        }

    }

    fn compute_function(h: &Heap, fun: FunctionId, args: &Vec<Value>) -> Option<Value> {

        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);

    }

}

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(())

    }

    fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {

        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 {

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

        let var = h[stmt].variable;

        let id = h[var].identifier;

        // First check whether variable with same identifier is in scope

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

        if !check_duplicate.is_none() {

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

        }

        // Then check the expression's variables (this should not refer to own variable)

        recursive_memory_statement(self, h, stmt)?;

        // Finally, we may add the variable to the scope, which is guaranteed to be a block

        {

            let mut block = &mut h[self.scope.unwrap().to_block()];

            block.locals.push(var);

        }

        Ok(())

    }

    fn visit_channel_statement(&mut self, h: &mut Heap, stmt: ChannelStatementId) -> VisitorResult {

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

        // First handle the from variable

        {

            let var = h[stmt].from;

            let id = h[var].identifier;

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

            if !check_duplicate.is_none() {

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

            }

            let mut block = &mut h[self.scope.unwrap().to_block()];

            block.locals.push(var);

        }

        // Then handle the to variable (which may not be the same as the from)

        {

            let var = h[stmt].to;

            let id = h[var].identifier;

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

            if !check_duplicate.is_none() {

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

            }

            let mut block = &mut h[self.scope.unwrap().to_block()];

            block.locals.push(var);

        }

        Ok(())

    }

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

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

        let old = self.scope;

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

        recursive_block_statement(self, h, stmt)?;

        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;

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

        recursive_synchronous_statement(self, h, stmt)?;

        self.scope = old;

        Ok(())

    }

    fn visit_variable_expression(

        &mut self,

        h: &mut Heap,

        expr: VariableExpressionId,

    ) -> VisitorResult {

        let var = self.get_variable(h, h[expr].identifier)?;

        h[expr].declaration = Some(var);

        Ok(())

    }

}

struct UniqueStatementId(StatementId);

struct LinkStatements {

    prev: Option<UniqueStatementId>,

}

impl LinkStatements {

    fn new() -> Self {

        LinkStatements { prev: None }

    }

}

impl Visitor for LinkStatements {

    fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {

        if let Some(UniqueStatementId(prev)) = self.prev.take() {

            h[prev].link_next(stmt);

        }

        recursive_statement(self, h, stmt)

    }

    fn visit_local_statement(&mut self, _h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {

        recursive_labeled_statement(self, h, stmt)

    }

    fn visit_skip_statement(&mut self, _h: &mut Heap, stmt: SkipStatementId) -> VisitorResult {

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {

        // We allocate a pseudo-statement, which combines both branches into one next statement

        let position = h[stmt].position;

        let pseudo =

            h.alloc_end_if_statement(|this| EndIfStatement { this, position, next: None }).upcast();

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

        self.visit_statement(h, h[stmt].true_body)?;

        if let Some(UniqueStatementId(prev)) = self.prev.take() {

            h[prev].link_next(pseudo);

        }

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

        self.visit_statement(h, h[stmt].false_body)?;

        if let Some(UniqueStatementId(prev)) = self.prev.take() {

            h[prev].link_next(pseudo);

        }

        // Use the pseudo-statement as the statement where to update the next pointer

        self.prev = Some(UniqueStatementId(pseudo));

        Ok(())

    }

    fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {

        // We allocate a pseudo-statement, to which the break statement finds its target

        let position = h[stmt].position;

        let pseudo =

            h.alloc_end_while_statement(|this| EndWhileStatement { this, position, next: None });

        // Update the while's next statement to point to the pseudo-statement

        h[stmt].next = Some(pseudo);

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

        self.visit_statement(h, h[stmt].body)?;

        // The body's next statement loops back to the while statement itself

        // Note: continue statements also loop back to the while statement itself

        if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {

            h[prev].link_next(stmt.upcast());

        }

        // Use the while statement as the statement where the next pointer is updated

        self.prev = Some(UniqueStatementId(pseudo.upcast()));

        Ok(())

    }

    fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {

        Ok(())

    }

    fn visit_continue_statement(

        &mut self,

        _h: &mut Heap,

        _stmt: ContinueStatementId,

    ) -> VisitorResult {

        Ok(())

    }

    fn visit_synchronous_statement(

        &mut self,

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

        // Allocate a pseudo-statement, that is added for helping the evaluator to issue a command

        // that marks the end of the synchronous block. Every evaluation has to pause at this

        // point, only to resume later when the thread is selected as unique thread to continue.

        let position = h[stmt].position;

        let pseudo = h

            .alloc_end_synchronous_statement(|this| EndSynchronousStatement {

                this,

                position,

                next: None,

            })

            .upcast();

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

        self.visit_statement(h, h[stmt].body)?;

        // The body's next statement points to the pseudo element

        if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {

            h[prev].link_next(pseudo);

        }

        // Use the pseudo-statement as the statement where the next pointer is updated

        self.prev = Some(UniqueStatementId(pseudo));

        Ok(())

    }

    fn visit_return_statement(&mut self, h: &mut Heap, stmt: ReturnStatementId) -> VisitorResult {

        Ok(())

    }

    fn visit_assert_statement(&mut self, h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {

        Ok(())

    }

    fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_put_statement(&mut self, h: &mut Heap, stmt: PutStatementId) -> VisitorResult {

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_expression_statement(

        &mut self,

        h: &mut Heap,

        stmt: ExpressionStatementId,

    ) -> VisitorResult {

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {

        Ok(())

    }

}

struct BuildLabels {

    block: Option<BlockStatementId>,

    sync_enclosure: Option<SynchronousStatementId>,

}

impl BuildLabels {

    fn new() -> Self {

        BuildLabels { block: None, sync_enclosure: None }

    }

}

impl Visitor for BuildLabels {

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

        assert_eq!(self.block, h[stmt].parent_block(h));

        let old = self.block;

        self.block = Some(stmt);

        recursive_block_statement(self, h, stmt)?;

        self.block = old;

        Ok(())

    }

    fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {

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

        // Store label in current block (on the fly)

        h[self.block.unwrap()].labels.push(stmt);

        // Update synchronous scope of label

        h[stmt].in_sync = self.sync_enclosure;

        recursive_labeled_statement(self, h, stmt)

    }

    fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {

        h[stmt].in_sync = self.sync_enclosure;

        recursive_while_statement(self, h, stmt)

    }

    fn visit_synchronous_statement(

        &mut self,

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

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

        self.sync_enclosure = Some(stmt);

        recursive_synchronous_statement(self, h, stmt)?;

        self.sync_enclosure = None;

        Ok(())

    }

    fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {

        Ok(())

    }

}

struct ResolveLabels {

    block: Option<BlockStatementId>,

    while_enclosure: Option<WhileStatementId>,

    sync_enclosure: Option<SynchronousStatementId>,

}

impl ResolveLabels {

    fn new() -> Self {

        ResolveLabels { block: None, while_enclosure: None, sync_enclosure: None }

    }

    fn check_duplicate_impl(

        h: &Heap,

        block: Option<BlockStatementId>,

        stmt: LabeledStatementId,

    ) -> VisitorResult {

        if let Some(block) = block {

            // Checking the parent first is important. Otherwise, labels

            // overshadow previously defined labels: and this is illegal!

            ResolveLabels::check_duplicate_impl(h, h[block].parent_block(h), stmt)?;

            // For the current block, check for a duplicate.

            for &other_stmt in h[block].labels.iter() {

                if other_stmt == stmt {

                    continue;