}

}

impl<T: Sized> Drop for ScopedSection<T> {

    fn drop(&mut self) {

        let vec = unsafe{&mut *self.inner};

    True,

    False,

    Character(char),

    String(StringRef<'static>),

    Integer(LiteralInteger),

    Struct(LiteralStruct),

                    self.write_variable(heap, *variable_id, indent3);

                }

            },

        }

    }

                    Literal::True => { val.with_s_val("true"); },

                    Literal::False => { val.with_s_val("false"); },

                    Literal::Character(data) => { val.with_disp_val(data); },

                    Literal::String(data) => {

                        // Stupid hack

                        let string = String::from(data.as_str());

                // Here we only care about literals that have subexpressions

                match &expr.value {

                    Literal::Null | Literal::True | Literal::False |

                    Literal::Integer(_) | Literal::Enum(_) => {

                        // No subexpressions

                    },

                                Literal::True => Value::Bool(true),

                                Literal::False => Value::Bool(false),

                                Literal::Character(lit_value) => Value::Char(*lit_value),

                                Literal::String(lit_value) => {

                                    let heap_pos = self.store.alloc_heap();

                                    let values = &mut self.store.heap_regions[heap_pos as usize].values;

                                    // Convert the runtime-variant of a string

                                    // into an actual string.

                                    let value = cur_frame.expr_values.pop_front().unwrap();

                                    let value_heap_pos = value.as_string();

                                    let elements = &self.store.heap_regions[value_heap_pos as usize].values;

                                    // Drop the heap-allocated value from the

                                    // store

                                    println!("{}", message);

                                },

                                Method::SelectStart => {

        } else if next == Some(TokenKind::Integer) {

            let (literal, span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;

            ctx.heap.alloc_literal_expression(|this| LiteralExpression{

                this, span,

                parent: ExpressionParent::None,

            }).upcast()

        } else if next == Some(TokenKind::String) {

            let span = consume_string_literal(&module.source, iter, &mut self.buffer)?;

            if is_char_literal_start(c) {

                self.consume_char_literal(source, target)?;

            } else if is_string_literal_start(c) {

                self.consume_string_literal(source, target)?;

            } else if is_identifier_start(c) {

        Ok(())

    }

        let begin_pos = source.pos();

        source.consume();

        target.tokens.push(Token::new(TokenKind::String, begin_pos));

        target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));

        Ok(())

    }

    // Consumes whitespace and returns whether or not the whitespace contained

    // a newline.

    fn consume_whitespace(&self, source: &mut InputSource) -> bool {

            ident == KW_COMPOSITE

}

fn demarks_import(ident: &[u8]) -> bool {

    return ident == KW_IMPORT;

}

fn is_whitespace(c: u8) -> bool {

    c.is_ascii_whitespace()

}

fn is_char_literal_start(c: u8) -> bool {

    return c == b'\'';

}

fn is_string_literal_start(c: u8) -> bool {

    return c == b'"';

}

fn is_pragma_start_or_pound(c: u8) -> bool {

    return c == b'#';

}

            c == b'_'

}

fn is_integer_literal_start(c: u8) -> bool {

    return c >= b'0' && c <= b'9';

}

const MESSAGE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Message, InferenceTypePart::UInt8 ];

const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];

const CHARACTER_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Character ];

const STRING_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::String, InferenceTypePart::Character ];

const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];

const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];

                let node = &mut self.infer_nodes[self_index];

                node.inference_rule = InferenceRule::MonoTemplate(InferenceRuleTemplate::new_forced(&CHARACTER_TEMPLATE));

            },

            Literal::String(_) => {

                let node = &mut self.infer_nodes[self_index];

                node.inference_rule = InferenceRule::MonoTemplate(InferenceRuleTemplate::new_forced(&STRING_TEMPLATE));

        expr_ids.forget();

        let argument_indices = expr_indices.into_vec();

        let node = &mut self.infer_nodes[self_index];

        node.poly_data_index = extra_index;

        node.inference_rule = InferenceRule::CallExpr(InferenceRuleCallExpr{

        use InferenceRule as IR;

        let node = &self.infer_nodes[node_index];

            IR::Noop =>

                unreachable!(),

            IR::MonoTemplate(_) =>

                self.progress_inference_rule_call_expr(ctx, node_index),

            IR::VariableExpr(_) =>

                self.progress_inference_rule_variable_expr(ctx, node_index),

    }

    fn progress_inference_rule_mono_template(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }

        poly_progress_section.forget();

        self.finish_polydata_constraint(node_index);

        return Ok(());

    }

        let node_expr_id = node.expr_id;

        let rule = node.inference_rule.as_call_expr();

        let mut poly_progress_section = self.poly_progress_buffer.start_section();

        let argument_node_indices = self.index_buffer.start_section_initialized(&rule.argument_indices);

        // out the polymorphic variables

        for (argument_index, argument_node_index) in argument_node_indices.iter_copied().enumerate() {

            let argument_expr_id = self.infer_nodes[argument_node_index].expr_id;

            let (_, progress_argument) = self.apply_polydata_equal2_constraint(

                ctx, node_index, argument_expr_id, "argument's",

                PolyDataTypeIndex::Associated(argument_index), 0,

                argument_node_index, 0, &mut poly_progress_section

            )?;

            if progress_argument { self.queue_node(argument_node_index); }

        }

        // Same for the return type.

        let (_, progress_call_1) = self.apply_polydata_equal2_constraint(

            ctx, node_index, node_expr_id, "return",

            PolyDataTypeIndex::Returned, 0,

            node_index, 0, &mut poly_progress_section

        )?;

        // We will now apply any progression in the polymorphic variable type

        // back to the arguments.

        match &mut literal_expr.value {

            Literal::Null | Literal::True | Literal::False |

                // Just the parent has to be set, done above

            },

            Literal::Struct(literal) => {

    return Err(ParseError::new_error_str_at_span(source, span, "too many characters in character literal"))

}

/// Consumes a string literal. We currently support a limited number of

/// backslash-escaped characters. Note that the result is stored in the

/// buffer.

pub(crate) fn consume_string_literal(

    source: &InputSource, iter: &mut TokenIter, buffer: &mut String

) -> Result<InputSpan, ParseError> {

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

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

    }

    let span = iter.next_span();

    iter.consume();

    if !text.is_ascii() {

    }

    debug_assert_eq!(text[0], b'"'); // here as kind of a reminder: the span includes the bounding quotation marks

    debug_assert_eq!(text[text.len() - 1], b'"');

    buffer.reserve(text.len() - 2);

    let mut was_escape = false;

        let cur = text[idx];

        let is_escape = cur == b'\\';

        if was_escape {

            buffer.push(to_push);

            buffer.push(cur as char);

        }

    debug_assert!(!was_escape); // because otherwise we couldn't have ended the string literal

}

fn parse_escaped_character(source: &InputSource, literal_span: InputSpan, v: u8) -> Result<char, ParseError> {

    let result = match v {

        b'r' => '\r',

    Ident,          // regular identifier

    Pragma,         // identifier with prefixed `#`, range includes `#`

    Integer,        // integer literal

    String,         // string literal, range includes `"`

    Character,      // character literal, range includes `'`

    LineComment,    // line comment, range includes leading `//`, but not newline

            TK::ShiftLeftEquals => "<<=",

            TK::ShiftRightEquals => ">>=",

            // Lets keep these in explicitly for now, in case we want to add more symbols

            TK::LineComment | TK::BlockComment | TK::SpanEnd => unreachable!(),

        }

    }

    auto res2 = perform_concatenate(left, right);

    auto expected = \"Darth Vader, but also Anakin Skywalker\";

    return

        res2 == \"Darth Vader, but also Anakin Skywalker\" &&

        res1 != \"This kind of thing\" && res2 != \"Another likewise kind of thing\";

}

    ").error(|e| { e.assert_msg_has(0, "non-ASCII character in string literal"); });

}

#[test]

fn test_tuple_literals() {

    Tester::new_single_source_expect_ok("zero tuples", "

    pub(crate) fn compile(self) -> AstTesterResult {

        let mut parser = Parser::new().unwrap();

        for source in self.sources.into_iter() {

            let source = source.into_bytes();

            let input_source = InputSource::new(String::from(""), source);

/// Generic representation of a component (as viewed by a scheduler).

pub(crate) trait Component {

    fn on_creation(&mut self, comp_id: CompId, sched_ctx: &SchedulerCtx);

    /// Called if the component is created by another component and the messages

    /// are being transferred between the two.

    fn adopt_message(&mut self, comp_ctx: &mut CompCtx, message: DataMessage);

    }

}

/// Handles control messages in the default way. Note that this function may

/// take a lot of actions in the name of the caller: pending messages may be

/// sent, ports may become blocked/unblocked, etc. So the execution

    Getting,

    Putting,

    FinishSync,

}

pub struct ComponentTcpClient {

        }

    }

    fn adopt_message(&mut self, _comp_ctx: &mut CompCtx, message: DataMessage) {

        if self.inbox_main.is_none() {

            self.inbox_main = Some(message);

    }

    fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError> {

        match self.exec_state.mode {

            CompMode::BlockedSelect => {

                // When in non-sync mode

                match &mut self.socket_state {

                    SocketState::Connected(_socket) => {

                    },

                    SocketState::Error => {

                        // Could potentially send an error message to the

                // When in sync mode: wait for a command to come in

                match self.sync_state {

                    SyncState::AwaitingCmd => {

                            if self.consensus.try_receive_data_message(sched_ctx, comp_ctx, &message) {

                                // Check which command we're supposed to execute.

                                let (tag_value, embedded_heap_pos) = message.content.values[0].as_union();

                                if tag_value == self.input_union_send_tag_value {

                                    // Retrieve bytes from the message

                                    return Ok(CompScheduling::Immediate);

                                } else if tag_value == self.input_union_finish_tag_value {

                                    // Component requires us to end the sync round

                                } else if tag_value == self.input_union_shutdown_tag_value {

                                    // Component wants to close the connection

                                }

                            } else {

                                todo!("handle sync failure due to message deadlock");

                        // If here then we're done putting the data, we can

                        // finish the sync round

                        let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);

                        component::default_handle_sync_decision(&mut self.exec_state, decision, &mut self.consensus);

                    },

                    SyncState::Getting => {

                        // We're going to try and receive a single message. If

                        const BUFFER_SIZE: usize = 1024; // TODO: Move to config

                        let socket = self.socket_state.get_socket();

                        self.byte_buffer.resize(BUFFER_SIZE, 0);

                        match socket.receive(&mut self.byte_buffer) {

                            Ok(num_received) => {

                                self.byte_buffer.resize(num_received, 0);

                                let message_content = self.bytes_to_data_message_content(&self.byte_buffer);

                                let scheduling = component::default_send_data_message(&mut self.exec_state, self.pdl_output_port_id, message_content, sched_ctx, &mut self.consensus, comp_ctx);

                                return Ok(scheduling);

                            },

                            Err(err) => {

                                if err.kind() == IoErrorKind::WouldBlock {

                                    return Ok(CompScheduling::Sleep); // wait until polled

                                } else {

                                }

                            }

                        }

                    },

                        let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);

                        self.exec_state.mode = CompMode::SyncEnd;

                        component::default_handle_sync_decision(&mut self.exec_state, decision, &mut self.consensus);

                        return Ok(CompScheduling::Requeue);

                }

            },

            CompMode::BlockedGet => {

            CompMode::Exit =>

                return Ok(component::default_handle_exit(&self.exec_state)),

        }

    }

}

        let socket = SocketTcpClient::new(ip_address, port);

        if let Err(socket) = socket {

        }

        return Self{

        // Intentionally empty

    }

    fn adopt_message(&mut self, comp_ctx: &mut CompCtx, message: DataMessage) {

        let port_handle = comp_ctx.get_port_handle(message.data_header.target_port);

        let port_index = comp_ctx.get_port_index(port_handle);

    }

    fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, mut message: Message) {

        if let Some(new_target) = self.control.should_reroute(&mut message) {

            let mut target = sched_ctx.runtime.get_component_public(new_target); // TODO: @NoDirectHandle

            target.send_message(&sched_ctx.runtime, message, false); // not waking up: we schedule once we've received all PortPeerChanged Acks

                        // Message was received. Make sure any blocked peers and

                        // pending messages are handled.

                        let message = self.inbox_main[port_index].take().unwrap();

                        self.exec_ctx.stmt = ExecStmt::PerformedGet(message.content);

                        return Ok(CompScheduling::Immediate);

        }

    }