Changeset - 120857c65991
Parent rev.
Child rev.
[Not reviewed]
1 12 0
MH - 4 years ago 2021-05-27 18:17:47
contact@maxhenger.nl
Second round of dead code removal
13 files changed with 107 insertions and 717 deletions:
src/collections/scoped_buffer.rs
2
2
src/protocol/arena.rs
3
3
src/protocol/ast.rs
2
1
src/protocol/eval/executor.rs
2
1
src/protocol/mod.rs
2
src/protocol/parser/depth_visitor.rs
652
src/protocol/parser/mod.rs
4
34
src/protocol/parser/pass_definitions.rs
3
1
src/protocol/parser/pass_typing.rs
2
2
src/protocol/parser/pass_validation_linking.rs
72
15
src/protocol/parser/visitor.rs
1
1
src/protocol/tests/eval_calls.rs
13
src/protocol/tests/utils.rs
1
5
0 comments (0 inline, 0 general)
src/collections/scoped_buffer.rs
➞
Show inline comments
 
@@ -43,12 +43,12 @@ impl<T: Sized> ScopedBuffer<T> {
 
impl<T: Clone> ScopedBuffer<T> {
 
    pub(crate) fn start_section_initialized(&mut self, initialize_with: &[T]) -> ScopedSection<T> {
 
        let start_size = self.inner.len() as u32;
 
        let data_size = initialize_with.len() as u32;
 
        let _data_size = initialize_with.len() as u32;
 
        self.inner.extend_from_slice(initialize_with);
 
        ScopedSection{
 
            inner: &mut self.inner,
 
            start_size,
 
            #[cfg(debug_assertions)] cur_size: start_size + data_size,
 
            #[cfg(debug_assertions)] cur_size: start_size + _data_size,
 
        }
 
    }
 
}
src/protocol/arena.rs
➞
Show inline comments
 
@@ -10,9 +10,9 @@ pub struct Id<T> {
 
}
 

			




	
	
	
		
 
impl<T> Id<T> {

			




	
	
	
		
 
    pub(crate) fn new_invalid() -> Self     { Self{ index: -1, _phantom: Default::default() } }

			




	
	
	
		
 
    pub(crate) fn new(index: i32) -> Self   { Self{ index, _phantom: Default::default() } }

			




	
	
	
		
 
    pub(crate) fn is_invalid(&self) -> bool { self.index < 0 }

			




	
	
	
		
 
    #[inline] pub(crate) fn new_invalid() -> Self     { Self{ index: -1, _phantom: Default::default() } }

			




	
	
	
		
 
    #[inline] pub(crate) fn new(index: i32) -> Self   { Self{ index, _phantom: Default::default() } }

			




	
	
	
		
 
    #[inline] pub(crate) fn is_invalid(&self) -> bool { self.index < 0 }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[derive(Debug)]

			




        

    


    
    

    

        

                

                    src/protocol/ast.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -931,7 +931,7 @@ impl Statement {

			




	
	
	
		
 
    }

			




	
	
	
		
 
    pub fn link_next(&mut self, next: StatementId) {

			




	
	
	
		
 
        match self {

			




	
	
	
		
 
            Statement::Block(_) => todo!(),

			




	
	
	
		
 
            Statement::Block(stmt) => stmt.next = next,

			




	
	
	
		
 
            Statement::EndBlock(stmt) => stmt.next = next,

			




	
	
	
		
 
            Statement::Local(stmt) => match stmt {

			




	
	
	
		
 
                LocalStatement::Channel(stmt) => stmt.next = next,

			




	
	
		
 
@@ -969,6 +969,7 @@ pub struct BlockStatement {

			




	
	
	
		
 
    pub relative_pos_in_parent: u32,

			




	
	
	
		
 
    pub locals: Vec<VariableId>,

			




	
	
	
		
 
    pub labels: Vec<LabeledStatementId>,

			




	
	
	
		
 
    pub next: StatementId,

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[derive(Debug, Clone)]

			




        

    


    
    

    

        

                

                    src/protocol/eval/executor.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -737,7 +737,8 @@ impl Prompt {

			




	
	
	
		
 
        let stmt = &heap[cur_frame.position];

			




	
	
	
		
 
        let return_value = match stmt {

			




	
	
	
		
 
            Statement::Block(stmt) => {

			




	
	
	
		
 
                cur_frame.position = stmt.statements[0];

			




	
	
	
		
 
                debug_assert!(stmt.statements.is_empty() || stmt.next == stmt.statements[0]);

			




	
	
	
		
 
                cur_frame.position = stmt.next;

			




	
	
	
		
 
                Ok(EvalContinuation::Stepping)

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Statement::EndBlock(stmt) => {

			




        

    


    
    

    

        

                

                    src/protocol/mod.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -35,6 +35,8 @@ pub struct ProtocolDescription {

			




	
	
	
		
 
pub(crate) struct ComponentState {

			




	
	
	
		
 
    prompt: Prompt,

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[allow(dead_code)]

			




	
	
	
		
 
pub(crate) enum EvalContext<'a> {

			




	
	
	
		
 
    Nonsync(&'a mut NonsyncProtoContext<'a>),

			




	
	
	
		
 
    Sync(&'a mut SyncProtoContext<'a>),

			




        

    


    
    

    

        

                

                    src/protocol/parser/depth_visitor.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
deleted file

			




        

    


    
    

    

        

                

                    src/protocol/parser/mod.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
mod depth_visitor;

			




	
	
	
		
 
pub(crate) mod symbol_table;

			




	
	
	
		
 
pub(crate) mod type_table;

			




	
	
	
		
 
pub(crate) mod tokens;

			




	
	
		
 
@@ -11,10 +10,9 @@ pub(crate) mod pass_validation_linking;

			




	
	
	
		
 
pub(crate) mod pass_typing;

			




	
	
	
		
 
mod visitor;

			




	
	
	
		
 

			




	
	
	
		
 
use depth_visitor::*;

			




	
	
	
		
 
use tokens::*;

			




	
	
	
		
 
use crate::collections::*;

			




	
	
	
		
 
use visitor::Visitor2;

			




	
	
	
		
 
use visitor::Visitor;

			




	
	
	
		
 
use pass_tokenizer::PassTokenizer;

			




	
	
	
		
 
use pass_symbols::PassSymbols;

			




	
	
	
		
 
use pass_imports::PassImport;

			




	
	
		
 
@@ -37,7 +35,8 @@ pub enum ModuleCompilationPhase {

			




	
	
	
		
 
    DefinitionsParsed,      // produced the AST for the entire module

			




	
	
	
		
 
    TypesAddedToTable,      // added all definitions to the type table

			




	
	
	
		
 
    ValidatedAndLinked,     // AST is traversed and has linked the required AST nodes

			




	
	
	
		
 
    Typed,                  // Type inference and checking has been performed

			




	
	
	
		
 
    // When we continue with the compiler:

			




	
	
	
		
 
    // Typed,                  // Type inference and checking has been performed

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
pub struct Module {

			




	
	
		
 
@@ -222,15 +221,7 @@ impl Parser {

			




	
	
	
		
 
            self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Perform remaining steps

			




	
	
	
		
 
        // TODO: Phase out at some point

			




	
	
	
		
 
        for module in &self.modules {

			




	
	
	
		
 
            let root_id = module.root_id;

			




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

			




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

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Write out desired information

			




	
	
	
		
 
        if let Some(filename) = &self.write_ast_to {

			




	
	
	
		
 
            let mut writer = ASTWriter::new();

			




	
	
	
		
 
            let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();

			




	
	
		
 
@@ -239,27 +230,6 @@ impl Parser {

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




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

			




	
	
	
		
 
        // TODO: @cleanup, slowly phasing out old compiler

			




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

			




	
	
	
		
 
        // BuildLabels::new().visit_protocol_description(h, pd)?;

			




	
	
	
		
 
        // ResolveLabels::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(())

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// Note: args and return type need to be a function because we need to know the function ID.

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_definitions.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -362,7 +362,8 @@ impl PassDefinitions {

			




	
	
	
		
 
                next_unique_id_in_scope: -1,

			




	
	
	
		
 
                relative_pos_in_parent: 0,

			




	
	
	
		
 
                locals: Vec::new(),

			




	
	
	
		
 
                labels: Vec::new()

			




	
	
	
		
 
                labels: Vec::new(),

			




	
	
	
		
 
                next: StatementId::new_invalid(),

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
            let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{

			




	
	
		
 
@@ -501,6 +502,7 @@ impl PassDefinitions {

			




	
	
	
		
 
            relative_pos_in_parent: 0,

			




	
	
	
		
 
            locals: Vec::new(),

			




	
	
	
		
 
            labels: Vec::new(),

			




	
	
	
		
 
            next: StatementId::new_invalid(),

			




	
	
	
		
 
        });

			




	
	
	
		
 

			




	
	
	
		
 
        let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_typing.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -59,7 +59,7 @@ use super::visitor::{

			




	
	
	
		
 
    STMT_BUFFER_INIT_CAPACITY,

			




	
	
	
		
 
    EXPR_BUFFER_INIT_CAPACITY,

			




	
	
	
		
 
    Ctx,

			




	
	
	
		
 
    Visitor2,

			




	
	
	
		
 
    Visitor,

			




	
	
	
		
 
    VisitorResult

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
		
 
@@ -999,7 +999,7 @@ impl PassTyping {

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
impl Visitor2 for PassTyping {

			




	
	
	
		
 
impl Visitor for PassTyping {

			




	
	
	
		
 
    // Definitions

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_validation_linking.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -7,8 +7,8 @@ use crate::protocol::parser::type_table::*;

			




	
	
	
		
 
use super::visitor::{

			




	
	
	
		
 
    STMT_BUFFER_INIT_CAPACITY,

			




	
	
	
		
 
    EXPR_BUFFER_INIT_CAPACITY,

			




	
	
	
		
 
    Ctx, 

			




	
	
	
		
 
    Visitor2, 

			




	
	
	
		
 
    Ctx,

			




	
	
	
		
 
    Visitor,

			




	
	
	
		
 
    VisitorResult

			




	
	
	
		
 
};

			




	
	
	
		
 
use crate::protocol::parser::ModuleCompilationPhase;

			




	
	
		
 
@@ -51,12 +51,12 @@ pub(crate) struct PassValidationLinking {

			




	
	
	
		
 
    in_test_expr: StatementId, // wrapping if/while stmt id

			




	
	
	
		
 
    in_binding_expr: BindingExpressionId, // to resolve variable expressions

			




	
	
	
		
 
    in_binding_expr_lhs: bool,

			




	
	
	
		
 
    // Traversal state: current scope (which can be used to find the parent

			




	
	
	
		
 
    // Traversal state, current scope (which can be used to find the parent

			




	
	
	
		
 
    // scope) and the definition variant we are considering.

			




	
	
	
		
 
    cur_scope: Scope,

			




	
	
	
		
 
    def_type: DefinitionType,

			




	
	
	
		
 
    // Parent expression (the previous stmt/expression we visited that could be

			




	
	
	
		
 
    // used as an expression parent)

			




	
	
	
		
 
    // "Trailing" traversal state, set be child/prev stmt/expr used by next one

			




	
	
	
		
 
    prev_stmt: StatementId,

			




	
	
	
		
 
    expr_parent: ExpressionParent,

			




	
	
	
		
 
    // Set by parent to indicate that child expression must be assignable. The

			




	
	
	
		
 
    // child will throw an error if it is not assignable. The stored span is

			




	
	
		
 
@@ -83,6 +83,7 @@ impl PassValidationLinking {

			




	
	
	
		
 
            in_binding_expr: BindingExpressionId::new_invalid(),

			




	
	
	
		
 
            in_binding_expr_lhs: false,

			




	
	
	
		
 
            cur_scope: Scope::Definition(DefinitionId::new_invalid()),

			




	
	
	
		
 
            prev_stmt: StatementId::new_invalid(),

			




	
	
	
		
 
            expr_parent: ExpressionParent::None,

			




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

			




	
	
	
		
 
            must_be_assignable: None,

			




	
	
		
 
@@ -103,6 +104,7 @@ impl PassValidationLinking {

			




	
	
	
		
 
        self.in_binding_expr_lhs = false;

			




	
	
	
		
 
        self.cur_scope = Scope::Definition(DefinitionId::new_invalid());

			




	
	
	
		
 
        self.def_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());

			




	
	
	
		
 
        self.prev_stmt = StatementId::new_invalid();

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::None;

			




	
	
	
		
 
        self.must_be_assignable = None;

			




	
	
	
		
 
        self.relative_pos_in_block = 0;

			




	
	
		
 
@@ -110,7 +112,25 @@ impl PassValidationLinking {

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
macro_rules! assign_then_erase_next_stmt {

			




	
	
	
		
 
    ($self:ident, $ctx:ident, $stmt_id:expr) => {

			




	
	
	
		
 
        if !$self.prev_stmt.is_invalid() {

			




	
	
	
		
 
            $ctx.heap[$self.prev_stmt].link_next($stmt_id);

			




	
	
	
		
 
            $self.prev_stmt = StatementId::new_invalid();

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
macro_rules! assign_and_replace_next_stmt {

			




	
	
	
		
 
    ($self:ident, $ctx:ident, $stmt_id:expr) => {

			




	
	
	
		
 
        if !$self.prev_stmt.is_invalid() {

			




	
	
	
		
 
            $ctx.heap[$self.prev_stmt].link_next($stmt_id);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        $self.prev_stmt = $stmt_id;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
impl Visitor for PassValidationLinking {

			




	
	
	
		
 
    fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {

			




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

			




	
	
	
		
 

			




	
	
		
 
@@ -199,11 +219,13 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
        self.visit_block_stmt_with_hint(ctx, id, None)

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult {

			




	
	
	
		
 
    fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult {

			




	
	
	
		
 
    fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
		
 
@@ -216,6 +238,7 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {

			




	
	
	
		
 
        let if_stmt = &ctx.heap[id];

			




	
	
	
		
 
        let end_if_id = if_stmt.end_if;

			




	
	
	
		
 
        let test_expr_id = if_stmt.test;

			




	
	
	
		
 
        let true_stmt_id = if_stmt.true_body;

			




	
	
	
		
 
        let false_stmt_id = if_stmt.false_body;

			




	
	
		
 
@@ -223,6 +246,7 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
        // Visit test expression

			




	
	
	
		
 
        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

			




	
	
	
		
 
        debug_assert!(self.in_test_expr.is_invalid());

			




	
	
	
		
 

			




	
	
	
		
 
        self.in_test_expr = id.upcast();

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::If(id);

			




	
	
	
		
 
        self.visit_expr(ctx, test_expr_id)?;

			




	
	
		
 
@@ -230,19 +254,27 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::None;

			




	
	
	
		
 

			




	
	
	
		
 
        // Visit true and false branch. Executor chooses next statement based on

			




	
	
	
		
 
        // test expression, not on if-statement itself.

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        self.visit_block_stmt(ctx, true_stmt_id)?;

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        if let Some(false_id) = false_stmt_id {

			




	
	
	
		
 
            self.visit_block_stmt(ctx, false_id)?;

			




	
	
	
		
 
            assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        self.prev_stmt = end_if_id.upcast();

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {

			




	
	
	
		
 
        let (test_id, body_id) = {

			




	
	
	
		
 
            let stmt = &ctx.heap[id];

			




	
	
	
		
 
            (stmt.test, stmt.body)

			




	
	
	
		
 
        };

			




	
	
	
		
 
        let stmt = &ctx.heap[id];

			




	
	
	
		
 
        let end_while_id = stmt.end_while;

			




	
	
	
		
 
        let test_expr_id = stmt.test;

			




	
	
	
		
 
        let body_stmt_id = stmt.body;

			




	
	
	
		
 

			




	
	
	
		
 
        let old_while = self.in_while;

			




	
	
	
		
 
        self.in_while = id;

			




	
	
	
		
 

			




	
	
		
 
@@ -251,13 +283,22 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
        debug_assert!(self.in_test_expr.is_invalid());

			




	
	
	
		
 
        self.in_test_expr = id.upcast();

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::While(id);

			




	
	
	
		
 
        self.visit_expr(ctx, test_id)?;

			




	
	
	
		
 
        self.visit_expr(ctx, test_expr_id)?;

			




	
	
	
		
 
        self.in_test_expr = StatementId::new_invalid();

			




	
	
	
		
 

			




	
	
	
		
 
        // Link up to body statement

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::None;

			




	
	
	
		
 
        self.visit_block_stmt(ctx, body_id)?;

			




	
	
	
		
 
        self.visit_block_stmt(ctx, body_stmt_id)?;

			




	
	
	
		
 
        self.in_while = old_while;

			




	
	
	
		
 

			




	
	
	
		
 
        // Link final entry in while's block statement back to the while. The

			




	
	
	
		
 
        // executor will go to the end-while statement if the test expression

			




	
	
	
		
 
        // is false, so put that in as the new previous stmt

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        self.prev_stmt = end_while_id.upcast();

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
		
 
@@ -272,6 +313,7 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
            target_while.end_while

			




	
	
	
		
 
        };

			




	
	
	
		
 

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        let stmt = &mut ctx.heap[id];

			




	
	
	
		
 
        stmt.target = Some(target_end_while);

			




	
	
	
		
 

			




	
	
		
 
@@ -285,6 +327,7 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
            self.resolve_break_or_continue_target(ctx, stmt.span, &stmt.label)?

			




	
	
	
		
 
        };

			




	
	
	
		
 

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        let stmt = &mut ctx.heap[id];

			




	
	
	
		
 
        stmt.target = Some(target_while_id);

			




	
	
	
		
 

			




	
	
		
 
@@ -293,7 +336,9 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {

			




	
	
	
		
 
        // Check for validity of synchronous statement

			




	
	
	
		
 
        let cur_sync_span = ctx.heap[id].span;

			




	
	
	
		
 
        let sync_stmt = &ctx.heap[id];

			




	
	
	
		
 
        let end_sync_id = sync_stmt.end_sync;

			




	
	
	
		
 
        let cur_sync_span = sync_stmt.span;

			




	
	
	
		
 
        if !self.in_sync.is_invalid() {

			




	
	
	
		
 
            // Nested synchronous statement

			




	
	
	
		
 
            let old_sync_span = ctx.heap[self.in_sync].span;

			




	
	
		
 
@@ -311,10 +356,14 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
            ));

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Synchronous statement implicitly moves to its block

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        let sync_body = ctx.heap[id].body;

			




	
	
	
		
 
        debug_assert!(self.in_sync.is_invalid());

			




	
	
	
		
 
        self.in_sync = id;

			




	
	
	
		
 
        self.visit_block_stmt_with_hint(ctx, sync_body, Some(id))?;

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, end_sync_id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        self.in_sync = SynchronousStatementId::new_invalid();

			




	
	
	
		
 

			




	
	
		
 
@@ -332,6 +381,7 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // If here then we are within a function

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

			




	
	
	
		
 
        debug_assert_eq!(ctx.heap[id].expressions.len(), 1);

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::Return(id);

			




	
	
		
 
@@ -360,6 +410,8 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
            );

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
		
 
@@ -377,6 +429,7 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
        // to ensure that the "new" statment instantiates a component)

			




	
	
	
		
 
        let call_expr_id = ctx.heap[id].expression;

			




	
	
	
		
 

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::New(id);

			




	
	
	
		
 
        self.visit_call_expr(ctx, call_expr_id)?;

			




	
	
		
 
@@ -388,6 +441,7 @@ impl Visitor2 for PassValidationLinking {

			




	
	
	
		
 
    fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {

			




	
	
	
		
 
        let expr_id = ctx.heap[id].expression;

			




	
	
	
		
 

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::ExpressionStmt(id);

			




	
	
	
		
 
        self.visit_expr(ctx, expr_id)?;

			




	
	
		
 
@@ -1182,6 +1236,7 @@ impl PassValidationLinking {

			




	
	
	
		
 
        let body = &mut ctx.heap[id];

			




	
	
	
		
 
        body.scope_node.parent = old_scope;

			




	
	
	
		
 
        body.relative_pos_in_parent = self.relative_pos_in_block;

			




	
	
	
		
 
        let end_block_id = body.end_block;

			




	
	
	
		
 

			




	
	
	
		
 
        let old_relative_pos = self.relative_pos_in_block;

			




	
	
	
		
 

			




	
	
		
 
@@ -1197,10 +1252,12 @@ impl PassValidationLinking {

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Perform the depth-first traversal

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        for stmt_idx in 0..statement_section.len() {

			




	
	
	
		
 
            self.relative_pos_in_block = stmt_idx as u32;

			




	
	
	
		
 
            self.visit_stmt(ctx, statement_section[stmt_idx])?;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, end_block_id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        self.cur_scope = old_scope;

			




	
	
	
		
 
        self.relative_pos_in_block = old_relative_pos;

			




        

    


    
    

    

        

                

                    src/protocol/parser/visitor.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -25,7 +25,7 @@ pub(crate) struct Ctx<'p> {

			




	
	
	
		
 
/// implementation of the visitors is to not recurse. The exception is the

			




	
	
	
		
 
/// top-level `visit_definition`, `visit_stmt` and `visit_expr` methods, which

			




	
	
	
		
 
/// call the appropriate visitor function.

			




	
	
	
		
 
pub(crate) trait Visitor2 {

			




	
	
	
		
 
pub(crate) trait Visitor {

			




	
	
	
		
 
    // Entry point

			




	
	
	
		
 
    fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {

			




	
	
	
		
 
        let mut def_index = 0;

			




        

    


    
    

    

        

                

                    src/protocol/tests/eval_calls.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -25,4 +25,17 @@ fn test_function_call() {

			




	
	
	
		
 
    }").for_function("foo", |f| {

			




	
	
	
		
 
        f.call_ok(Some(Value::Bool(true)));

			




	
	
	
		
 
    });

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn test_empty_blocks() {

			




	
	
	
		
 
    // Yes this is silly, but I managed to make this a bug before

			




	
	
	
		
 
    Tester::new_single_source_expect_ok("traversing empty statements", "

			




	
	
	
		
 
    func foo() -> u32 {

			




	
	
	
		
 
        auto val = 128;

			




	
	
	
		
 
        if (true) {}

			




	
	
	
		
 
        while (false) {}

			




	
	
	
		
 
        return val;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    ").for_function("foo", |f| { f.call_ok(Some(Value::UInt32(128))); });

			




	
	
	
		
 
}

			




	
	
		
 
\ No newline at end of file

			




        

    


    
    

    

        

                

                    src/protocol/tests/utils.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -120,6 +120,7 @@ impl AstTesterResult {

			




	
	
	
		
 
// Interface for successful compilation

			




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

			




	
	
	
		
 

			




	
	
	
		
 
#[allow(dead_code)]

			




	
	
	
		
 
pub(crate) struct AstOkTester {

			




	
	
	
		
 
    test_name: String,

			




	
	
	
		
 
    modules: Vec<Module>,

			




	
	
		
 
@@ -949,11 +950,6 @@ fn has_monomorph(ctx: TestCtx, definition_id: DefinitionId, serialized_monomorph

			




	
	
	
		
 
fn serialize_parser_type(buffer: &mut String, heap: &Heap, parser_type: &ParserType) {

			




	
	
	
		
 
    use ParserTypeVariant as PTV;

			




	
	
	
		
 

			




	
	
	
		
 
    fn write_bytes(buffer: &mut String, bytes: &[u8]) {

			




	
	
	
		
 
        let utf8 = String::from_utf8_lossy(bytes);

			




	
	
	
		
 
        buffer.push_str(&utf8);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn serialize_variant(buffer: &mut String, heap: &Heap, parser_type: &ParserType, mut idx: usize) -> usize {

			




	
	
	
		
 
        match &parser_type.elements[idx].variant {

			




	
	
	
		
 
            PTV::Void => buffer.push_str("void"),

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: kalli-339433
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2022 by various authors & licensed under GPLv3.
            – Support