// utility underscore to enhance humans reading the characters. Allowing use to

// write something like 100_000_256 or 0xDEAD_BEEF

int-bin-char = "0" | "1"

int-bin-constant = "0b" int-bin-char (int-bin-char | "_")* // 0b0100_1110

int-oct-char = "0"-"7"

int-oct-constant = "0o" int-oct-char (int-oct-char | "_")* // 0o777

int-dec-constant = DIGIT (DIGIT | "_")* //

int-hex-char = DIGIT | "a"-"f" | "A"-"F" 

int-hex-constant = "0x" int-hex-char (int-hex-char | "_")* // 0xFEFE_1337

int-constant = int-bin-constant | int-oct-constant | int-dec-constant | int-hex-constant

// Floating point numbers

//  language, but might be useful? 

float-constant = DIGIT* "." DIGIT+

// Character constants: a single character. Its element may be an escaped 

// character or a VCHAR (excluding "'" and "\")

char-element = ESCAPED_CHARS | (0x20-0x26 | 0x28-0x5B | 0x5D-0x7E) 

char-constant = "'" char-element "'"

// Same thing for strings, but these may contain 0 or more characters

str-element = ESCAPED_CHARS | (0x20-0x21 | 0x23-0x5B | 0x5D-0x7E)

str-constant = """ str-element* """

```

    identifier cw ":" cw stmt | // label

    "if" cw pexpr cw stmt (cw "else" cwb stmt)? |

    "while" cw pexpr cw stmt |

    "break" (cwb identifier)? cw ";" |

    "continue" (cwb identifier)? cw ";" |

    "synchronous" stmt |

    "return" cwb identifier cw ";" |

    "goto" cwb identifier cw ";" |

    "skip" cw ";" |

    "new" cwb method-expr cw ";" |

    expr cw ";"

method-params-list = "(" cw (expr (cw "," cw expr)* )? cw ")"

method-expr = method cw method-params-list

enum-destructure-expr = "let" cw ns-identifier "::" identifier cw "(" cw identifier cw ")" cw "=" expr

enum-test-expr = ns-identifier "::" identifier cw "==" cw expr

block = "{" (cw (channel-decl | memory-decl | stmt))* cw "}"

```

Note that we have a potential collision of various expressions/statements. The following cases are of importance:

1. An empty block is written as `{}`, while an empty array construction is also written as `{}`.

/// Key of an item in the freelist. Contains a generation number to prevent

/// use-after-free during development.

// TODO: Two usizes are probably overkill

#[derive(Copy, Clone)]

pub struct Key<T> {

    generation: usize,

    index: usize,

    _type: PhantomData<T>,

}

/// Generic freelist structure. Item insertion/retrieval/deletion works like a

/// HashMap through keys.

pub struct FreeList<T> {

    items: *mut Entry<T>,

    capacity: usize,

    length: usize,

    free: Vec<usize>,

}

impl<T> FreeList<T> {

    pub fn new() -> Self<T> {

        std::alloc::Layout::from_size_align()

        Self{

            items: std::ptr::null_mut(),

mod string_pool;

mod scoped_buffer;

mod sets;

mod raw_vec;

// mod freelist;

pub(crate) use string_pool::{StringPool, StringRef};

pub(crate) use scoped_buffer::{ScopedBuffer, ScopedSection};

pub(crate) use sets::{DequeSet, VecSet};

pub(crate) use raw_vec::RawVec;

        let initial_slab = Box::new(StringPoolSlab::new(null_mut()));

        let initial_slab = Box::into_raw(initial_slab);

        StringPool{

            last: initial_slab,

        }

    }

    /// Interns a string to the `StringPool`, returning a reference to it. The

    /// pointer owned by `StringRef` is `'static` as the `StringPool` doesn't

    /// reallocate/deallocate until dropped (which only happens at the end of

    /// the program.)

    pub(crate) fn intern(&mut self, data: &[u8]) -> StringRef<'static> {

        let data_len = data.len();

        debug_assert!(std::str::from_utf8(data).is_ok(), "string to intern is not valid UTF-8 encoded");

        let mut last = unsafe{&mut *self.last};

        if data.len() > last.remaining {

            // Doesn't fit: allocate new slab

            self.alloc_new_slab();

            last = unsafe{&mut *self.last};

        }

        // Must fit now, compute hash and put in buffer

        debug_assert!(data_len <= last.remaining);

        let range_start = last.data.len();

use std::fmt;

use std::fmt::{Debug, Display, Formatter};

use std::ops::{Index, IndexMut};

use super::arena::{Arena, Id};

use crate::collections::StringRef;

use crate::protocol::input_source::InputSpan;

/// Helper macro that defines a type alias for a AST element ID. In this case 

/// only used to alias the `Id<T>` types.

macro_rules! define_aliased_ast_id {

    // Variant where we just defined the alias, without any indexing

            ArrayLike | InputOrOutput | Array | Input | Output =>

                1,

            Definition(_, num) => *num as usize,

        }

    }

}

/// ParserTypeElement is an element of the type tree. An element may be

/// implicit, meaning that the user didn't specify the type, but it was set by

/// the compiler.

#[derive(Debug, Clone)]

pub struct ParserTypeElement {

    pub element_span: InputSpan, // span of this element, not including the child types

    pub variant: ParserTypeVariant,

}

/// ParserType is a specification of a type during the parsing phase and initial

/// linker/validator phase of the compilation process. These types may be

/// (partially) inferred or represent literals (e.g. a integer whose bytesize is

/// not yet determined).

///

/// Its contents are the depth-first serialization of the type tree. Each node

/// is a type that may accept polymorphic arguments. The polymorphic arguments

/// are then the children of the node.

            Expression::Binary(expr) => expr.full_span,

            Expression::Unary(expr) => expr.full_span,

            Expression::Indexing(expr) => expr.full_span,

            Expression::Slicing(expr) => expr.full_span,

            Expression::Select(expr) => expr.full_span,

            Expression::Literal(expr) => expr.span,

            Expression::Cast(expr) => expr.full_span,

            Expression::Call(expr) => expr.full_span,

            Expression::Variable(expr) => expr.identifier.span,

        }

    }

    pub fn parent(&self) -> &ExpressionParent {

        match self {

            Expression::Assignment(expr) => &expr.parent,

            Expression::Binding(expr) => &expr.parent,

            Expression::Conditional(expr) => &expr.parent,

            Expression::Binary(expr) => &expr.parent,

            Expression::Unary(expr) => &expr.parent,

            Expression::Indexing(expr) => &expr.parent,

            Expression::Slicing(expr) => &expr.parent,

            Expression::Select(expr) => &expr.parent,

            Expression::Literal(expr) => &expr.parent,

            Expression::Cast(expr) => &expr.parent,

            Expression::Call(expr) => &expr.parent,

            Expression::Variable(expr) => &expr.parent,

        }

    }

    pub fn parent_expr_id(&self) -> Option<ExpressionId> {

        if let ExpressionParent::Expression(id, _) = self.parent() {

            Some(*id)

        } else {

            None

        }

    }

    pub fn get_unique_id_in_definition(&self) -> i32 {

        match self {

            Expression::Assignment(expr) => expr.unique_id_in_definition,

            Expression::Binding(expr) => expr.unique_id_in_definition,

                    }

                    target.push('>');

                }

            }

        }

        element_idx

    }

    write_element(target, heap, t, 0);

}

fn write_concrete_type(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType) {

    use ConcreteTypePart as CTP;

    fn write_concrete_part(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType, mut idx: usize) -> usize {

        if idx >= t.parts.len() {

            return idx;

        }

        match &t.parts[idx] {

            CTP::Void => target.push_str("void"),

            CTP::Message => target.push_str("msg"),

            CTP::Bool => target.push_str("bool"),

            },

            Value::Array(lhs_pos) => {

                lhs_heap_pos = *lhs_pos;

                rhs_heap_pos = rhs.as_array();

                value_kind = ValueKind::Array;

            },

            _ => unreachable!("apply_binary_operator {:?} on lhs {:?} and rhs {:?}", op, lhs, rhs)

        }

        let lhs_heap_pos = lhs_heap_pos as usize;

        let rhs_heap_pos = rhs_heap_pos as usize;

        let mut concatenated = Vec::new();

        let lhs_len = store.heap_regions[lhs_heap_pos].values.len();

        let rhs_len = store.heap_regions[rhs_heap_pos].values.len();

        concatenated.reserve(lhs_len + rhs_len);

        for idx in 0..lhs_len {

            concatenated.push(store.clone_value(store.heap_regions[lhs_heap_pos].values[idx].clone()));

        }

        for idx in 0..rhs_len {

            concatenated.push(store.clone_value(store.heap_regions[rhs_heap_pos].values[idx].clone()));

        }

        store.heap_regions[target_heap_pos as usize].values = concatenated;

    InvalidNumArguments,

    InvalidArgumentType(usize),

    UnownedPort,

    InSync,

}

impl std::fmt::Debug for ProtocolDescription {

    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

        write!(f, "(An opaque protocol description)")

    }

}

impl ProtocolDescription {

    pub fn parse(buffer: &[u8]) -> Result<Self, String> {

        let source = InputSource::new(String::new(), Vec::from(buffer));

        let mut parser = Parser::new();

        parser.feed(source).expect("failed to feed source");

        if let Err(err) = parser.parse() {

            println!("ERROR:\n{}", err);

            return Err(format!("{}", err))

        }

        debug_assert_eq!(parser.modules.len(), 1, "only supporting one module here for now");

        let modules: Vec<Module> = parser.modules.into_iter()

            .map(|module| Module{

    pub(crate) fn new_component(&self, module_name: &[u8], identifier: &[u8], ports: &[PortId]) -> ComponentState {

        let mut args = Vec::new();

        for (&x, y) in ports.iter().zip(self.component_polarities(module_name, identifier).unwrap()) {

            match y {

                Polarity::Getter => args.push(Value::Input(x)),

                Polarity::Putter => args.push(Value::Output(x)),

            }

        }

        let module_root = self.lookup_module_root(module_name).unwrap();

        let root = &self.heap[module_root];

        let def = root.get_definition_ident(&self.heap, identifier).unwrap();

        ComponentState { prompt: Prompt::new(&self.types, &self.heap, def, 0, ValueGroup::new_stack(args)) }

    }

    // TODO: Ofcourse, rename this at some point, perhaps even remove it in its

    //  entirety. Find some way to interface with the parameter's types.

    pub(crate) fn new_component_v2(

        &self, module_name: &[u8], identifier: &[u8], arguments: ValueGroup

    ) -> Result<Prompt, ComponentCreationError> {

        // Find the module in which the definition can be found

        let module_root = self.lookup_module_root(module_name);

        if module_root.is_none() {

            return Err(ComponentCreationError::ModuleDoesntExist);

                            return is_valid;

                        }

                    },

                    _ => todo!("implement full type checking on user-supplied arguments"),

                }

                return false;

            },

        }

    }

}

pub trait RunContext {

    fn performed_put(&mut self, port: PortId) -> bool;

    fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message

    fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched

    fn performed_fork(&mut self) -> Option<bool>; // None if not yet forked

    fn created_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared

}

#[derive(Debug)]

pub enum RunResult {

    // Can only occur outside sync blocks

    ComponentTerminated, // component has exited its procedure

    BranchPut(PortId, ValueGroup),

}

impl ComponentState {

    pub(crate) fn run(&mut self, ctx: &mut impl RunContext, pd: &ProtocolDescription) -> RunResult {

        use EvalContinuation as EC;

        use RunResult as RR;

        loop {

            let step_result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, ctx);

            match step_result {

                Err(reason) => {

                    println!("Evaluation error:\n{}", reason);

                    todo!("proper error handling/bubbling up");

                },

                Ok(continuation) => match continuation {

                    EC::Stepping => continue,

                    EC::BranchInconsistent => return RR::BranchInconsistent,

                    EC::ComponentTerminated => return RR::ComponentTerminated,

                    EC::SyncBlockStart => return RR::ComponentAtSyncStart,

                    EC::SyncBlockEnd => return RR::BranchAtSyncEnd,

                    EC::NewComponent(definition_id, monomorph_idx, args) =>

                        return RR::NewComponent(definition_id, monomorph_idx, args),

                    EC::NewChannel =>

                        return RR::NewChannel,

                    EC::NewFork =>

                        return RR::BranchFork,

                    EC::BlockFires(port_id) => return RR::BranchMissingPortState(port_id),

                Err(err) => {

                    println!("Evaluation error:\n{}", err);

                    panic!("proper error handling when component fails");

                },

                Ok(cont) => match cont {

                    EvalContinuation::Stepping => continue,

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

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

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

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

                    EvalContinuation::SyncBlockEnd => unreachable!(),

                    EvalContinuation::NewComponent(definition_id, monomorph_idx, args) => {

                        let mut moved_ports = HashSet::new();

                        for arg in args.values.iter() {

                            match arg {

                                Value::Output(port) => {

                                    moved_ports.insert(*port);

                                }

                                Value::Input(port) => {

                                    moved_ports.insert(*port);

                                }

                                _ => {}

                            }

                        }

            EvalContext::Sync(_) => unreachable!(),

        }

    }

    fn performed_fork(&mut self) -> Option<bool> {

        // Never actually used in the old runtime

        return None;

    }

}

// TODO: @remove once old runtime has disappeared

impl EvalContext<'_> {

    fn new_component(&mut self, moved_ports: HashSet<PortId>, init_state: ComponentState) -> () {

        match self {

            EvalContext::None => unreachable!(),

            EvalContext::Nonsync(context) => {

                context.new_component(moved_ports, init_state)

            }

            EvalContext::Sync(_) => unreachable!(),

        }

    }

    fn new_channel(&mut self) -> [Value; 2] {

        match self {

            EvalContext::None => unreachable!(),

        ));

        insert_builtin_function(&mut parser, "print", &[], |_id| (

            vec![

                ("message", quick_type(&[PTV::String])),

            ],

            quick_type(&[PTV::Void])

        ));

        parser

    }

    pub fn feed(&mut self, mut source: InputSource) -> Result<(), ParseError> {

        let mut token_buffer = TokenBuffer::new();

        self.pass_tokenizer.tokenize(&mut source, &mut token_buffer)?;

        let module = Module{

            source,

            tokens: token_buffer,

            root_id: RootId::new_invalid(),

            name: None,

            version: None,

            phase: ModuleCompilationPhase::Tokenized,

        };

        self.modules.push(module);

        let mut return_types = self.parser_types.start_section();

        let mut open_curly_pos = iter.last_valid_pos(); // bogus value

        consume_comma_separated_until(

            TokenKind::OpenCurly, &module.source, iter, ctx,

            |source, iter, ctx| {

                let poly_vars = ctx.heap[definition_id].poly_vars();

                consume_parser_type(source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope, definition_id, false, 0)

            },

            &mut return_types, "a return type", Some(&mut open_curly_pos)

        )?;

        let return_types = return_types.into_vec();

        match return_types.len() {

            0 => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "expected a return type")),

            1 => {},

            _ => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "multiple return types are not (yet) allowed")),

        }

        // Consume block

        let body = self.consume_block_statement_without_leading_curly(module, iter, ctx, open_curly_pos)?;

        // Assign everything in the preallocated AST node

        let function = ctx.heap[definition_id].as_function_mut();

        function.return_types = return_types;

            self.pop_range(target, target.tokens.len() as u32);

        }

        // And finally, we may have a token range at the end that doesn't belong

        // to a range yet, so insert a "code" range if this is the case.

        debug_assert_eq!(self.stack_idx, 0);

        let last_registered_idx = target.ranges[0].end;

        let last_token_idx = target.tokens.len() as u32;

        if last_registered_idx != last_token_idx {

            self.add_code_range(target, 0, last_registered_idx, last_token_idx, NO_RELATION);

        }

        Ok(())

    }

    fn is_line_comment_start(&self, first_char: u8, source: &InputSource) -> bool {

        return first_char == b'/' && Some(b'/') == source.lookahead(1);

    }

    fn is_block_comment_start(&self, first_char: u8, source: &InputSource) -> bool {

        return first_char == b'/' && Some(b'*') == source.lookahead(1);

    }

    fn maybe_parse_punctuation(

            reserved_idx: -1,

            definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),

            poly_vars: Vec::new(),

            stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),

            expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),

            var_types: HashMap::new(),

            expr_types: Vec::new(),

            extra_data: Vec::new(),

            expr_queued: DequeSet::new(),

        }

    }

    pub(crate) fn queue_module_definitions(ctx: &mut Ctx, queue: &mut ResolveQueue) {

        debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::ValidatedAndLinked);

        let root_id = ctx.module().root_id;

        let root = &ctx.heap.protocol_descriptions[root_id];

        for definition_id in &root.definitions {

            let definition = &ctx.heap[*definition_id];

            let first_concrete_part = match definition {

                Definition::Function(definition) => {

                    if definition.poly_vars.is_empty() {

                        Some(ConcreteTypePart::Function(*definition_id, 0))

                    } else {

        Ok(false) => {

            return Err(ParseError::new_error_at_pos(

                source, first_pos,

                format!("expected {}", list_name_and_article)

            ));

        },

        Err(err) => Err(err)

    }

}

/// Consumes an integer literal, may be binary, octal, hexadecimal or decimal,

/// and may have separating '_'-characters.

pub(crate) fn consume_integer_literal(source: &InputSource, iter: &mut TokenIter, buffer: &mut String) -> Result<(u64, InputSpan), ParseError> {

    if Some(TokenKind::Integer) != iter.next() {

        return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected an integer literal"));

    }

    let integer_span = iter.next_span();

    iter.consume();

    let integer_text = source.section_at_span(integer_span);

    // Determine radix and offset from prefix

    let (radix, input_offset, radix_name) =

        if integer_text.starts_with(b"0b") || integer_text.starts_with(b"0B") {

        // Return previous token end

        let token = &self.tokens[self.cur - 1];

        return if token.kind == TokenKind::SpanEnd {

            token.pos

        } else {

            token.pos.with_offset(token.kind.num_characters())

        };

    }

    /// Returns the token range belonging to the token returned by `next`. This

    /// assumes that we're not at the end of the range we're iterating over.

    pub(crate) fn next_positions(&self) -> (InputPosition, InputPosition) {

        debug_assert!(self.cur < self.end);

        let token = &self.tokens[self.cur];

        if token.kind.has_span_end() {

            let span_end = &self.tokens[self.cur + 1];

            debug_assert_eq!(span_end.kind, TokenKind::SpanEnd);

            (token.pos, span_end.pos)

        } else {

            let offset = token.kind.num_characters();

            (token.pos, token.pos.with_offset(offset))

        }

    }

        });

        return Ok(())

    }

    /// Builds base function type.

    fn build_base_function_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {

        debug_assert!(!self.lookup.contains_key(&definition_id), "base function already built");

        let definition = ctx.heap[definition_id].as_function();

        let root_id = definition.defined_in;

        // Check and construct return types and argument types.

        for return_type in &definition.return_types {

            Self::check_member_parser_type(

                modules, ctx, root_id, return_type, definition.builtin

            )?;

        }

        let mut arguments = Vec::with_capacity(definition.parameters.len());

        for parameter_id in &definition.parameters {

            let parameter = &ctx.heap[*parameter_id];

            Self::check_member_parser_type(

                modules, ctx, root_id, &parameter.parser_type, definition.builtin

            )?;

type Unit = ();

pub(crate) type VisitorResult = Result<Unit, ParseError>;

/// Globally configured vector capacity for statement buffers in visitor 

/// implementations

pub(crate) const STMT_BUFFER_INIT_CAPACITY: usize = 256;

/// Globally configured vector capacity for expression buffers in visitor

/// implementations

pub(crate) const EXPR_BUFFER_INIT_CAPACITY: usize = 256;

/// General context structure that is used while traversing the AST.

pub(crate) struct Ctx<'p> {

    pub heap: &'p mut Heap,

    pub modules: &'p mut [Module],

    pub module_idx: usize, // currently considered module

    pub symbols: &'p mut SymbolTable,

    pub types: &'p mut TypeTable,

    pub arch: &'p crate::protocol::TargetArch,

}

impl<'p> Ctx<'p> {

    /// Returns module `modules[module_idx]`

    pub(crate) fn module(&self) -> &Module {

fn test_union_monomorphs() {

    Tester::new_single_source_expect_ok(

        "no polymorph",

        "

        union Trinary { Undefined, Value(bool) }

        func do_it() -> s32 { auto a = Trinary::Value(true); return 0; }

        "

    ).for_union("Trinary", |e| { e

        .assert_num_monomorphs(1)

        .assert_has_monomorph("Trinary");

    });

    Tester::new_single_source_expect_ok(

        "polymorphs",

        "

        union Result<T, E>{ Ok(T), Err(E) }

        func instantiator() -> s32 {

            s16 a_s16 = 5;

            auto a = Result<s8, bool>::Ok(0);

            auto b = Result<bool, s8>::Ok(true);

            auto c = Result<Result<s8, s32>, Result<s16, s64>>::Err(Result::Ok(5));

            auto d = Result<Result<s8, s32>, auto>::Err(Result<auto, s64>::Ok(a_s16));

            return 0;

        }

    }

}

/// The execution state of a branch. This envelops the PDL code and the

/// execution state. And derived from that: if we're ready to keep running the

/// code, or if we're halted for some reason (e.g. waiting for a message).

pub(crate) struct Branch {

    pub id: BranchId,

    pub parent_id: BranchId,

    // Execution state

    pub code_state: Prompt,

    pub sync_state: SpeculativeState,

    pub next_in_queue: BranchId, // used by `ExecTree`/`BranchQueue`

    pub prepared: PreparedStatement,

}

impl BranchListItem for Branch {

    #[inline] fn get_id(&self) -> BranchId { return self.id; }

    #[inline] fn set_next_id(&mut self, id: BranchId) { self.next_in_queue = id; }

    #[inline] fn get_next_id(&self) -> BranchId { return self.next_in_queue; }

}

impl Branch {

    /// Creates a new non-speculative branch

    NotNow,             // Do not reschedule for running

    Exit,               // Connector has exited

}

pub(crate) struct ConnectorPDL {

    mode: Mode,

    eval_error: Option<EvalError>,

    tree: ExecTree,

    consensus: Consensus,

    last_finished_handled: Option<BranchId>,

}

struct ConnectorRunContext<'a> {

    branch_id: BranchId,

    consensus: &'a Consensus,

    prepared: PreparedStatement,

}

impl<'a> RunContext for ConnectorRunContext<'a>{

    fn performed_put(&mut self, _port: PortId) -> bool {

        return match self.prepared.take() {

            PreparedStatement::None => false,

            PreparedStatement::PerformedPut => true,

            taken => unreachable!("prepared statement is '{:?}' during 'performed_put()'", taken)

            sync_round: 0,

            workspace_ports: Vec::new(),

        }

    }

    // --- Controlling sync round and branches

    /// Returns whether the consensus algorithm is running in sync mode

    pub fn is_in_sync(&self) -> bool {

        return !self.branch_annotations.is_empty();

    }

    #[deprecated]

    pub fn get_annotation(&self, branch_id: BranchId, channel_id: PortIdLocal) -> &ChannelAnnotation {

        let branch = &self.branch_annotations[branch_id.index as usize];

        let port = branch.channel_mapping.iter().find(|v| v.channel_id.index == channel_id.index).unwrap();

        return port;

    }

    /// Sets up the consensus algorithm for a new synchronous round. The

    /// provided ports should be the ports the component owns at the start of

    /// the sync round.

    pub fn start_sync(&mut self, ctx: &ComponentCtx) {

        debug_assert!(!self.highest_connector_id.is_valid());

use std::sync::Mutex;

use std::collections::VecDeque;

use crate::protocol::eval::ValueGroup;

use crate::runtime2::consensus::{ComponentPresence, SolutionCombiner};

use crate::runtime2::port::ChannelId;

use super::ConnectorId;

use super::consensus::{GlobalSolution, LocalSolution};

use super::port::PortIdLocal;

#[derive(Debug, Copy, Clone)]

pub(crate) struct ChannelAnnotation {

    pub channel_id: ChannelId,

    pub registered_id: Option<BranchMarker>,

    pub expected_firing: Option<bool>,

}

/// Marker for a branch in a port mapping. A marker is, like a branch ID, a

/// unique identifier for a branch, but differs in that a branch only has one

/// branch ID, but might have multiple associated markers (i.e. one branch

/// performing a `put` three times will generate three markers.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]