}

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

pub struct StatementId(Id<Statement>);

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

impl BlockStatementId {

    pub fn upcast(self) -> StatementId {

        self.0

    }

}

    type Output = Local;

    fn index(&self, index: LocalId) -> &Self::Output {

        &self.variables[(index.0).0].as_local()

    }

}

impl Index<DefinitionId> for Heap {

    type Output = Definition;

    fn index(&self, index: DefinitionId) -> &Self::Output {

        &self.definitions[index.0]

    }

}

    type Output = IfStatement;

    fn index(&self, index: IfStatementId) -> &Self::Output {

        &self.statements[(index.0).0].as_if()

    }

}

impl Index<EndIfStatementId> for Heap {

    type Output = EndIfStatement;

    fn index(&self, index: EndIfStatementId) -> &Self::Output {

        &self.statements[(index.0).0].as_end_if()

    }

}

            _ => false,

        }

    }

}

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

    Definition(DefinitionId),

    Regular(BlockStatementId),

    Synchronous((SynchronousStatementId, BlockStatementId)),

}

impl Scope {

    pub fn is_block(&self) -> bool {

        }

    }

    pub fn to_block(&self) -> BlockStatementId {

            _ => panic!("unable to get BlockStatement from Scope")

        }

    }

}

pub trait VariableScope {

}

impl VariableScope for Scope {

    fn parent_scope(&self, h: &Heap) -> Option<Scope> {

        match self {

            Scope::Definition(def) => h[*def].parent_scope(h),

        }

    }

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

        match self {

            Scope::Definition(def) => h[*def].get_variable(h, id),

        }

    }

}

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

pub enum Variable {

    pub fn as_local(&self) -> &Local {

        match self {

            Variable::Local(result) => result,

            _ => panic!("Unable to cast `Variable` to `Local`"),

        }

    }

    pub fn the_type<'b>(&self, h: &'b Heap) -> &'b Type {

        match self {

            Variable::Parameter(param) => &h[param.type_annotation].the_type,

            Variable::Local(local) => &h[local.type_annotation].the_type,

        }

    }

    pub fn as_if(&self) -> &IfStatement {

        match self {

            Statement::If(result) => result,

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

        }

    }

    pub fn as_end_if(&self) -> &EndIfStatement {

        match self {

            Statement::EndIf(result) => result,

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

        }

    }

        match parent {

            Scope::Definition(_) => {

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

                // parent block.

                None

            }

                // It is always the case that when this function is called,

                // the parent of a synchronous statement is a block statement:

                // nested synchronous statements are flagged illegal,

                // and that happens before resolving variables that

                // creates the parent_scope references in the first place.

                Some(h[parent].parent_scope(h).unwrap().to_block())

            }

                // A variable scope is either a definition, sync, or block.

                Some(parent)

            }

        }

    }

    pub fn first(&self) -> StatementId {

}

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

pub struct EndWhileStatement {

    pub this: EndWhileStatementId,

    // Phase 2: linker

    pub position: InputPosition, // of corresponding while

    pub next: Option<StatementId>,

}

impl SyntaxElement for EndWhileStatement {

    fn position(&self) -> InputPosition {

}

impl VariableScope for SynchronousStatement {

    fn parent_scope(&self, _h: &Heap) -> Option<Scope> {

        self.parent_scope.clone()

    }

        None

    }

}

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

pub struct EndSynchronousStatement {

pub enum EvalContinuation {

    Stepping,

    Inconsistent,

    Terminal,

    SyncBlockStart,

    SyncBlockEnd,

    BlockFires(Value),

    BlockGet(Value),

    Put(Value, Value),

}

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

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

                }

                Err(EvalContinuation::Stepping)

            }

            Statement::EndWhile(stmt) => {

                // Continue to next statement

                self.position = stmt.next;

                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;

            }

            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

    column: usize,

    offset: usize,

}

static STD_LIB_PDL: &'static [u8] = b"

primitive forward(in i, out o) {

}

primitive sync(in i, out o) {

}

primitive alternator(in i, out l, out r) {

    while(true) {

    }

}

primitive replicator(in i, out l, out r) {

    while(true) synchronous {

        if(fires(i)) {

            msg m = get(i);

        let mut num_namespaces = 1;

        while self.has_string(b"::") {

            if num_namespaces >= MAX_NAMESPACES {

                return Err(self.error_at_pos("Too many namespaces in identifier"));

            }

            let new_ident = self.consume_ident()?;

            num_namespaces += 1;

        }

        Ok(NamespacedIdentifier{

            position,

            value: ns_ident,

        }

        self.consume_string(b")")?;

        Ok(h.alloc_call_expression(|this| CallExpression {

            this,

            position,

            method,

        }))

    }

    fn consume_variable_expression(

        &mut self,

        h: &mut Heap,

    ) -> Result<VariableExpressionId, ParseError2> {

        } else {

            Ok(h.alloc_block_statement(|this| BlockStatement {

                this,

                position,

                statements,

                parent_scope: None,

                locals: Vec::new(),

                labels: Vec::new(),

            })

            .upcast())

        }

    }

        self.consume_string(b";")?;

        let from = h.alloc_local(|this| Local {

            this,

            position,

            type_annotation: from_annotation,

            identifier: from_identifier,

        });

        let to = h.alloc_local(|this| Local {

            this,

            position,

            type_annotation: to_annotation,

            identifier: to_identifier,

        });

        Ok(h.alloc_channel_statement(|this| ChannelStatement {

            this,

            position,

            from,

            to,

            next: None,

        }))

    }

    fn consume_memory_statement(&mut self, h: &mut Heap) -> Result<MemoryStatementId, ParseError2> {

        let position = self.source.pos();

        let type_annotation = self.consume_type_annotation(h)?;

        self.consume_whitespace(true)?;

        let identifier = self.consume_identifier()?;

        self.consume_whitespace(false)?;

        self.consume_string(b"=")?;

        self.consume_whitespace(false)?;

        let initial = self.consume_expression(h)?;

        self.consume_whitespace(false)?;

        self.consume_string(b";")?;

        Ok(h.alloc_memory_statement(|this| MemoryStatement {

            this,

            position,

            variable,

        let body = self.consume_statement(h)?;

        Ok(h.alloc_labeled_statement(|this| LabeledStatement {

            this,

            position,

            label,

            body,

            in_sync: None,

        }))

    }

    fn consume_skip_statement(&mut self, h: &mut Heap) -> Result<SkipStatementId, ParseError2> {

        let position = self.source.pos();

        self.consume_keyword(b"skip")?;

            self.consume_keyword(b"else")?;

            self.consume_whitespace(false)?;

            self.consume_statement(h)?

        } else {

            h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }).upcast()

        };

    }

    fn consume_while_statement(&mut self, h: &mut Heap) -> Result<WhileStatementId, ParseError2> {

        let position = self.source.pos();

        self.consume_keyword(b"while")?;

        self.consume_whitespace(false)?;

        let test = self.consume_paren_expression(h)?;

        let body = self.consume_statement(h)?;

        Ok(h.alloc_while_statement(|this| WhileStatement {

            this,

            position,

            test,

            body,

            in_sync: None,

        }))

    }

    fn consume_break_statement(&mut self, h: &mut Heap) -> Result<BreakStatementId, ParseError2> {

        let position = self.source.pos();

        self.consume_keyword(b"break")?;

        // }

        let body = self.consume_statement(h)?;

        Ok(h.alloc_synchronous_statement(|this| SynchronousStatement {

            this,

            position,

            body,

            parent_scope: None,

        }))

    }

    fn consume_return_statement(&mut self, h: &mut Heap) -> Result<ReturnStatementId, ParseError2> {

        let position = self.source.pos();

        self.consume_keyword(b"return")?;

use crate::protocol::ast::*;

use crate::protocol::inputsource::*;

// TABBED OUT FOR NOW

    todo!("implement me");

    // if h[i].value == b"std.reo" {

    //     let mut vec = Vec::new();

    //     vec.push(cd(h, i, b"sync", &[Type::INPUT, Type::OUTPUT]));

    //     vec.push(cd(h, i, b"syncdrain", &[Type::INPUT, Type::INPUT]));

    //     vec.push(cd(h, i, b"syncspout", &[Type::OUTPUT, Type::OUTPUT]));

// mod ast;

mod eval;

pub(crate) mod inputsource;

// mod lexer;

mod library;

mod parser;

// TODO: Remove when not benchmarking

pub(crate) mod ast;

pub(crate) mod lexer;

lazy_static::lazy_static! {

                    EvalContinuation::Stepping => continue,

                    EvalContinuation::Inconsistent => return NonsyncBlocker::Inconsistent,

                    EvalContinuation::Terminal => return NonsyncBlocker::ComponentExit,

                    EvalContinuation::SyncBlockStart => return NonsyncBlocker::SyncBlockStart,

                    // Not possible to end sync block if never entered one

                    EvalContinuation::SyncBlockEnd => unreachable!(),

                        // Look up definition (TODO for now, assume it is a definition)

                        let h = &pd.heap;

                        context.new_component(&args, init_state);

                        // Continue stepping

                        continue;

                    }

                    // Outside synchronous blocks, no fires/get/put happens

                    EvalContinuation::BlockFires(_) => unreachable!(),

        Ok(())

    }

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

        recursive_symbol_definition(self, h, def)

    }

        Ok(())

    }

        Ok(())

    }

    fn visit_component_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {

        recursive_component_definition(self, h, def)

    }

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

fn recursive_synchronous_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    stmt: SynchronousStatementId,

) -> VisitorResult {

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

}

fn recursive_return_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

                return Err((id.identifier.position, "Illegal call expression".to_string()));

            }

            if !self.new_statement && h[decl].is_component() {

                return Err((id.identifier.position, "Illegal call expression".to_string()));

            }

            // Set the corresponding declaration of the call

        }

        // A new statement's call expression may have as arguments function calls

        let old = self.new_statement;

        self.new_statement = false;

        recursive_call_expression(self, h, expr)?;

        self.new_statement = old;

    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

        recursive_block_statement(self, h, stmt)?;

        // Move scope back up

        self.scope = old;

        Ok(())

    }

    fn visit_synchronous_statement(

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

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

    }

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

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

        let old = self.scope;

        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;

        recursive_synchronous_statement(self, h, stmt)?;

        self.scope = old;

        Ok(())

    }

    fn visit_variable_expression(

        &mut self,

        h: &mut Heap,

        expr: VariableExpressionId,

    ) -> VisitorResult {

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

        Ok(())

    }

}

pub(crate) struct UniqueStatementId(StatementId);

        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 =

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

        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 =

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

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

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

        if the_while.in_sync != self.sync_enclosure {

            return Err((

                h[stmt].position,

                "Illegal break: synchronous statement escape".to_string(),

            ));

        }

        Ok(())

    }

    fn visit_continue_statement(

        &mut self,

        h: &mut Heap,

        stmt: ContinueStatementId,

mod depth_visitor;

mod symbol_table;

mod type_table;

mod visitor;

use depth_visitor::*;

use symbol_table::SymbolTable;

use type_table::TypeTable;

use crate::protocol::ast::*;

use crate::protocol::inputsource::*;

use crate::protocol::lexer::*;

use std::collections::HashMap;

// TODO: @fixme, pub qualifier

pub(crate) struct LexedModule {

    pub(crate) source: InputSource,

    module_name: Vec<u8>,

    version: Option<u64>,

    }

    pub fn compile(&mut self) {

        // Build module lookup

    }

        // Construct the symbol table to resolve any imports and/or definitions,

        // then use the symbol table to actually annotate all of the imports.

        // If the type table is constructed correctly then all imports MUST be

        // resolvable.

        // TODO: Update once namespaced identifiers are implemented

        let symbol_table = SymbolTable::new(&self.heap, &self.modules)?;

        }

        // All imports in the AST are now annotated. We now use the symbol table

        // to construct the type table.

        let type_table = TypeTable::new(&symbol_table, &self.heap, &self.modules)?;

    }

    // TODO: @fix, temporary impl to keep code compilable

    pub fn parse(&mut self) -> Result<RootId, ParseError2> {

        assert_eq!(self.modules.len(), 1, "Fix meeeee");

        let root_id = self.modules[0].root_id;

        if let Err((position, message)) = Self::parse_inner(&mut self.heap, root_id) {

            return Err(ParseError2::new_error(&self.modules[0].source, position, &message))

        }

        Ok(root_id)

    }

    pub fn parse_inner(h: &mut Heap, pd: RootId) -> VisitorResult {

        NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;

        ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;

        FunctionStatementReturns::new().visit_protocol_description(h, pd)?;

        ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;

        CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;

        BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;

        LinkCallExpressions::new().visit_protocol_description(h, pd)?;

        BuildScope::new().visit_protocol_description(h, pd)?;

        ResolveVariables::new().visit_protocol_description(h, pd)?;

        LinkStatements::new().visit_protocol_description(h, pd)?;

        AssignableExpressions::new().visit_protocol_description(h, pd)?;

        IndexableExpressions::new().visit_protocol_description(h, pd)?;

        SelectableExpressions::new().visit_protocol_description(h, pd)?;

        Ok(())

    }

    // #[test]

    fn positive_tests() {

        for resource in TestFileIter::new("testdata/parser/positive", "pdl") {

            let resource = resource.expect("read testdata filepath");

            // println!(" * running: {}", &resource);

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

            // println!("DEBUG -- input:\n{}", String::from_utf8_lossy(&source.input));

            let mut parser = Parser::new_with_source(source).expect("parse source");

            match parser.parse() {

                Ok(_) => {}

                Err(err) => {

                    println!(" > file: {}", &resource);

                                None => {

                                    return Err(

                                        ParseError2::new_error(&module.source, import.position, "Cannot resolve module")

                                    );

                                }

                            }