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) 

    "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

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

}

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;

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

use std::fmt;

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

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

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

use crate::collections::StringRef;

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

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

        }

        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;

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

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

            }

        }

        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(

                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

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

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

                                }

        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)

            }

        ));

        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,

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

        }

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

    }

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

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

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

    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

            )?;

        }

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,

        "

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

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

    eval_error: Option<EvalError>,

    tree: ExecTree,

    consensus: Consensus,

    last_finished_handled: Option<BranchId>,

}

struct ConnectorRunContext<'a> {

    branch_id: BranchId,

    consensus: &'a Consensus,

    prepared: PreparedStatement,

}

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

    }

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

}

        if should_signal {

            self.scheduler_notifier.notify_all();

        }

    }

}

unsafe impl Send for RuntimeInner {}

unsafe impl Sync for RuntimeInner {}

// -----------------------------------------------------------------------------

// ConnectorStore

// -----------------------------------------------------------------------------

    }

    /// Queues up a description of a synchronous round to run. Will not actually

    /// run the synchronous behaviour in blocking fashion. The results *must* be

    /// retrieved using `try_wait` or `wait` for the interface to be considered

    /// in non-sync mode.

    pub fn perform_sync_round(&mut self, actions: Vec<ApplicationSyncAction>) -> Result<(), ApplicationStartSyncError> {

        if self.is_in_sync {

            return Err(ApplicationStartSyncError::AlreadyInSync);

        }

        // Check the action ports for consistency

    pub channel_id: ChannelId,

    pub kind: PortKind,

    pub state: PortState,

    pub peer_connector: ConnectorId, // might be temporarily inconsistent while peer port is sent around in non-sync phase

}

pub struct Channel {

    pub putter_id: PortIdLocal, // can put on it, so from the connector's point of view, this is an output

    pub getter_id: PortIdLocal, // vice versa: can get on it, so an input for the connector

}

            let (target_component_id, over_port) = match &message {

                Message::Data(content) => {

                    // Data messages are always sent to a particular port, and

                    // may end up being rerouted.

                    let port_desc = scheduled.ctx.get_port_by_id(content.data_header.sending_port).unwrap();

                    debug_assert_eq!(port_desc.peer_id, content.data_header.target_port);

                    (port_desc.peer_connector, true)

                },

                Message::SyncComp(content) => {

                    // Sync messages are always sent to a particular component,

                    // the sender must make sure it actually wants to send to

                    // component ID associated with a port).

                    (content.target_component_id, false)

                },

                Message::SyncPort(content) => {

                    let port_desc = scheduled.ctx.get_port_by_id(content.source_port).unwrap();

                    debug_assert_eq!(port_desc.peer_id, content.target_port);

                    (port_desc.peer_connector, true)

                },

                Message::SyncControl(_) => unreachable!("component sending 'SyncControl' messages directly"),

                Message::Control(_) => unreachable!("component sending 'Control' messages directly"),

            };

            if should_wake_up_again {

                self.runtime.push_work(connector_key)

            }

        }

    }

    fn debug(&self, message: &str) {

        println!("DEBUG [thrd:{:02} conn:  ]: {}", self.scheduler_id, message);

    }

    fn debug_conn(&self, conn: ConnectorId, message: &str) {

        println!("DEBUG [thrd:{:02} conn:{:02}]: {}", self.scheduler_id, conn.index, message);