Changeset - e2849e9bfb16
Parent rev.
Child rev.
[Not reviewed]
0 9 0
mh - 4 years ago 2021-05-05 12:00:13
contact@maxhenger.nl
moving to desktop
9 files changed with 136 insertions and 122 deletions:
src/collections/scoped_buffer.rs
1
1
src/protocol/ast_printer.rs
1
1
src/protocol/parser/pass_definitions.rs
11
8
src/protocol/parser/pass_imports.rs
5
2
src/protocol/parser/pass_symbols.rs
1
src/protocol/parser/pass_tokenizer.rs
41
36
src/protocol/parser/pass_typing.rs
17
18
src/protocol/parser/symbol_table.rs
4
1
src/protocol/tests/parser_inference.rs
55
55
0 comments (0 inline, 0 general)
src/collections/scoped_buffer.rs
➞
Show inline comments
 
@@ -95,29 +95,29 @@ impl<T: Sized> ScopedSection<T> {
 
        if cfg!(debug_assertions) {
 
            debug_assert_eq!(
 
                vec.len(), self.cur_size as usize,
 
                "trying to turn section into vec, but size is larger than expected"
 
            );
 
            self.cur_size = self.start_size;
 
        }
 
        let section = Vec::from_iter(vec.drain(self.start_size as usize..));
 
        section
 
    }
 
}
 

			




	
	
	
		
 
impl<T: Sized> std::ops::Index<usize> for ScopedSection<T> {

			




	
	
	
		
 
    type Output = T;

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
        return &vec[self.start_size as usize + idx]

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[cfg(debug_assertions)]

			




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

			




	
	
	
		
 
    fn drop(&mut self) {

			




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

			




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

			




	
	
	
		
 
        debug_assert_eq!(vec.len(), self.cur_size as usize);

			




	
	
	
		
 
        vec.truncate(self.start_size as usize);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
		
 
\ No newline at end of file

			




        

    


    
    

    

        

                

                    src/protocol/ast_printer.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#![allow(dead_code)]

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
use std::io::Write as IOWrite;

			




	
	
	
		
 

			




	
	
	
		
 
use super::ast::*;

			




	
	
	
		
 
use super::token_parsing::*;

			




	
	
	
		
 

			




	
	
	
		
 
const INDENT: usize = 2;

			




	
	
	
		
 

			




	
	
	
		
 
const PREFIX_EMPTY: &'static str = "    ";

			




	
	
	
		
 
const PREFIX_ROOT_ID: &'static str = "Root";

			




	
	
	
		
 
const PREFIX_PRAGMA_ID: &'static str = "Prag";

			




	
	
	
		
 
const PREFIX_IMPORT_ID: &'static str = "Imp ";

			




	
	
	
		
 
const PREFIX_TYPE_ANNOT_ID: &'static str = "TyAn";

			




	
	
	
		
 
const PREFIX_VARIABLE_ID: &'static str = "Var ";

			




	
	
	
		
 
const PREFIX_PARAMETER_ID: &'static str = "Par ";

			




	
	
	
		
 
const PREFIX_LOCAL_ID: &'static str = "Loc ";

			




	
	
	
		
 
const PREFIX_DEFINITION_ID: &'static str = "Def ";

			




	
	
	
		
 
const PREFIX_STRUCT_ID: &'static str = "DefS";

			




	
	
	
		
 
const PREFIX_ENUM_ID: &'static str = "DefE";

			




	
	
	
		
 
const PREFIX_UNION_ID: &'static str = "DefU";

			




	
	
	
		
 
const PREFIX_COMPONENT_ID: &'static str = "DefC";

			




	
	
	
		
 
const PREFIX_FUNCTION_ID: &'static str = "DefF";

			




	
	
	
		
 
const PREFIX_STMT_ID: &'static str = "Stmt";

			




	
	
	
		
 
const PREFIX_BLOCK_STMT_ID: &'static str = "SBl ";

			




	
	
	
		
 
const PREFIX_LOCAL_STMT_ID: &'static str = "SLoc";

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_definitions.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



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

			




	
	
	
		
 
use super::symbol_table::*;

			




	
	
	
		
 
use super::{Module, ModuleCompilationPhase, PassCtx};

			




	
	
	
		
 
use super::tokens::*;

			




	
	
	
		
 
use super::token_parsing::*;

			




	
	
	
		
 
use crate::protocol::input_source::{InputSource as InputSource, InputPosition as InputPosition, InputSpan, ParseError};

			




	
	
	
		
 
use crate::collections::*;

			




	
	
	
		
 

			




	
	
	
		
 
/// Parses all the tokenized definitions into actual AST nodes.

			




	
	
	
		
 
pub(crate) struct PassDefinitions {

			




	
	
	
		
 
    // State

			




	
	
	
		
 
    cur_definition: DefinitionId,

			




	
	
	
		
 
    // Temporary buffers of various kinds

			




	
	
	
		
 
    buffer: String,

			




	
	
	
		
 
    struct_fields: ScopedBuffer<StructFieldDefinition>,

			




	
	
	
		
 
    enum_variants: ScopedBuffer<EnumVariantDefinition>,

			




	
	
	
		
 
    union_variants: ScopedBuffer<UnionVariantDefinition>,

			




	
	
	
		
 
    parameters: ScopedBuffer<ParameterId>,

			




	
	
	
		
 
    expressions: ScopedBuffer<ExpressionId>,

			




	
	
	
		
 
    statements: ScopedBuffer<StatementId>,

			




	
	
	
		
 
    parser_types: Vec<ParserType>,

			




	
	
	
		
 
    parser_types: ScopedBuffer<ParserType>,

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
impl PassDefinitions {

			




	
	
	
		
 
    pub(crate) fn new() -> Self {

			




	
	
	
		
 
        Self{

			




	
	
	
		
 
            cur_definition: DefinitionId::new_invalid(),

			




	
	
	
		
 
            buffer: String::with_capacity(128),

			




	
	
	
		
 
            struct_fields: ScopedBuffer::new_reserved(128),

			




	
	
	
		
 
            enum_variants: ScopedBuffer::new_reserved(128),

			




	
	
	
		
 
            union_variants: ScopedBuffer::new_reserved(128),

			




	
	
	
		
 
            parameters: ScopedBuffer::new_reserved(128),

			




	
	
	
		
 
            expressions: ScopedBuffer::new_reserved(128),

			




	
	
	
		
 
            statements: ScopedBuffer::new_reserved(128),

			




	
	
	
		
 
            parser_types: Vec::with_capacity(128),

			




	
	
	
		
 
            parser_types: ScopedBuffer::new_reserved(128),

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {

			




	
	
	
		
 
        let module = &modules[module_idx];

			




	
	
	
		
 
        let module_range = &module.tokens.ranges[0];

			




	
	
	
		
 
        debug_assert_eq!(module.phase, ModuleCompilationPhase::ImportsResolved);

			




	
	
	
		
 
        debug_assert_eq!(module_range.range_kind, TokenRangeKind::Module);

			




	
	
	
		
 

			




	
	
	
		
 
        // Although we only need to parse the definitions, we want to go through

			




	
	
	
		
 
        // code ranges as well such that we can throw errors if we get

			




	
	
	
		
 
        // unexpected tokens at the module level of the source.

			




	
	
	
		
 
        let mut range_idx = module_range.first_child_idx;

			




	
	
	
		
 
        loop {

			




	
	
	
		
 
            let range_idx_usize = range_idx as usize;

			




	
	
	
		
 
            let cur_range = &module.tokens.ranges[range_idx_usize];

			




	
	
	
		
 

			




	
	
	
		
 
            match cur_range.range_kind {

			




	
	
	
		
 
                TokenRangeKind::Module => unreachable!(), // should not be reachable

			




	
	
	
		
 
                TokenRangeKind::Pragma | TokenRangeKind::Import => continue, // already fully parsed

			




	
	
	
		
 
                TokenRangeKind::Definition | TokenRangeKind::Code => {}

			




	
	
	
		
 
            }

			




	
	
	
		
 

			




	
	
	
		
 
            self.visit_range(modules, module_idx, ctx, range_idx_usize)?;

			




	
	
		
 
@@ -183,115 +183,118 @@ impl PassDefinitions {

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_union_definition(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<(), ParseError> {

			




	
	
	
		
 
        consume_exact_ident(&module.source, iter, KW_UNION)?;

			




	
	
	
		
 
        let (ident_text, _) = consume_ident(&module.source, iter)?;

			




	
	
	
		
 

			




	
	
	
		
 
        // Retrieve preallocated DefinitionId

			




	
	
	
		
 
        let module_scope = SymbolScope::Module(module.root_id);

			




	
	
	
		
 
        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

			




	
	
	
		
 
            .unwrap().variant.as_definition().definition_id;

			




	
	
	
		
 
        self.cur_definition = definition_id;

			




	
	
	
		
 

			




	
	
	
		
 
        // Parse union definition

			




	
	
	
		
 
        consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
        let mut variants_section = self.union_variants.start_section();

			




	
	
	
		
 
        consume_comma_separated(

			




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

			




	
	
	
		
 
            |source, iter, ctx| {

			




	
	
	
		
 
                let identifier = consume_ident_interned(source, iter, ctx)?;

			




	
	
	
		
 
                let mut close_pos = identifier.span.end;

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
                let has_embedded = maybe_consume_comma_separated(

			




	
	
	
		
 
                    TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,

			




	
	
	
		
 
                    |source, iter, ctx| {

			




	
	
	
		
 
                        let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...

			




	
	
	
		
 
                        consume_parser_type(

			




	
	
	
		
 
                            source, iter, &ctx.symbols, &ctx.heap, poly_vars,

			




	
	
	
		
 
                            module_scope, definition_id, false, 0

			




	
	
	
		
 
                        )

			




	
	
	
		
 
                    },

			




	
	
	
		
 
                    &mut self.parser_types, "an embedded type", Some(&mut close_pos)

			




	
	
	
		
 
                    &mut types_section, "an embedded type", Some(&mut close_pos)

			




	
	
	
		
 
                )?;

			




	
	
	
		
 
                let value = if has_embedded {

			




	
	
	
		
 
                    UnionVariantValue::Embedded(self.parser_types.clone())

			




	
	
	
		
 
                    UnionVariantValue::Embedded(types_section.into_vec())

			




	
	
	
		
 
                } else {

			




	
	
	
		
 
                    types_section.forget();

			




	
	
	
		
 
                    UnionVariantValue::None

			




	
	
	
		
 
                };

			




	
	
	
		
 
                self.parser_types.clear();

			




	
	
	
		
 

			




	
	
	
		
 
                Ok(UnionVariantDefinition{

			




	
	
	
		
 
                    span: InputSpan::from_positions(identifier.span.begin, close_pos),

			




	
	
	
		
 
                    identifier,

			




	
	
	
		
 
                    value

			




	
	
	
		
 
                })

			




	
	
	
		
 
            },

			




	
	
	
		
 
            &mut variants_section, "a union variant", "a list of union variants", None

			




	
	
	
		
 
        )?;

			




	
	
	
		
 

			




	
	
	
		
 
        // Transfer to AST

			




	
	
	
		
 
        let union_def = ctx.heap[definition_id].as_union_mut();

			




	
	
	
		
 
        union_def.variants = variants_section.into_vec();

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_function_definition(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<(), ParseError> {

			




	
	
	
		
 
        consume_exact_ident(&module.source, iter, KW_FUNCTION)?;

			




	
	
	
		
 
        let (ident_text, _) = consume_ident(&module.source, iter)?;

			




	
	
	
		
 

			




	
	
	
		
 
        // Retrieve preallocated DefinitionId

			




	
	
	
		
 
        let module_scope = SymbolScope::Module(module.root_id);

			




	
	
	
		
 
        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

			




	
	
	
		
 
            .unwrap().variant.as_definition().definition_id;

			




	
	
	
		
 
        self.cur_definition = definition_id;

			




	
	
	
		
 

			




	
	
	
		
 
        consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
        // Parse function's argument list

			




	
	
	
		
 
        let mut parameter_section = self.parameters.start_section();

			




	
	
	
		
 
        consume_parameter_list(

			




	
	
	
		
 
            &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id

			




	
	
	
		
 
        )?;

			




	
	
	
		
 
        let parameters = parameter_section.into_vec();

			




	
	
	
		
 

			




	
	
	
		
 
        // Consume return types

			




	
	
	
		
 
        consume_token(&module.source, iter, TokenKind::ArrowRight)?;

			




	
	
	
		
 
        let mut open_curly_pos = iter.last_valid_pos();

			




	
	
	
		
 
        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(); // TODO: @Cleanup, this is really ugly. But rust...

			




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

			




	
	
	
		
 
            },

			




	
	
	
		
 
            &mut self.parser_types, "a return type", Some(&mut open_curly_pos)

			




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

			




	
	
	
		
 
        )?;

			




	
	
	
		
 
        let return_types = self.parser_types.clone();

			




	
	
	
		
 
        let return_types = return_types.into_vec();

			




	
	
	
		
 

			




	
	
	
		
 
        // TODO: @ReturnValues

			




	
	
	
		
 
        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;

			




	
	
	
		
 
        function.parameters = parameters;

			




	
	
	
		
 
        function.body = body;

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_component_definition(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<(), ParseError> {

			




	
	
	
		
 
        let (_variant_text, _) = consume_any_ident(&module.source, iter)?;

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_imports.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -78,55 +78,58 @@ impl PassImport {

			




	
	
	
		
 
                format!("could not resolve module '{}'", String::from_utf8_lossy(module_name))

			




	
	
	
		
 
            ));

			




	
	
	
		
 
        }

			




	
	
	
		
 
        let module_name = ctx.pool.intern(module_name);

			




	
	
	
		
 
        let module_identifier = Identifier{ span: module_name_span, value: module_name };

			




	
	
	
		
 
        let target_root_id = target_root_id.unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
        // Check for subsequent characters (alias, multiple imported symbols)

			




	
	
	
		
 
        let next = iter.next();

			




	
	
	
		
 
        let import_id;

			




	
	
	
		
 

			




	
	
	
		
 
        if has_ident(&module.source, &mut iter, b"as") {

			




	
	
	
		
 
            // Alias for module

			




	
	
	
		
 
            iter.consume();

			




	
	
	
		
 
            let alias_identifier = consume_ident_interned(&module.source, &mut iter, ctx)?;

			




	
	
	
		
 
            let alias_name = alias_identifier.value.clone();

			




	
	
	
		
 

			




	
	
	
		
 
            import_id = ctx.heap.alloc_import(|this| Import::Module(ImportModule{

			




	
	
	
		
 
                this,

			




	
	
	
		
 
                span: import_span,

			




	
	
	
		
 
                module: module_identifier,

			




	
	
	
		
 
                alias: alias_identifier,

			




	
	
	
		
 
                module_id: target_root_id

			




	
	
	
		
 
            }));

			




	
	
	
		
 
            ctx.symbols.insert_symbol(SymbolScope::Module(module.root_id), Symbol{

			




	
	
	
		
 

			




	
	
	
		
 
            if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(SymbolScope::Module(module.root_id), Symbol{

			




	
	
	
		
 
                name: alias_name,

			




	
	
	
		
 
                variant: SymbolVariant::Module(SymbolModule{

			




	
	
	
		
 
                    root_id: target_root_id,

			




	
	
	
		
 
                    introduced_at: import_id,

			




	
	
	
		
 
                }),

			




	
	
	
		
 
            });

			




	
	
	
		
 
            }) {

			




	
	
	
		
 
                return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol));

			




	
	
	
		
 
            }

			




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

			




	
	
	
		
 
            iter.consume();

			




	
	
	
		
 

			




	
	
	
		
 
            // Helper function to consume symbols, their alias, and the

			




	
	
	
		
 
            // definition the symbol is pointing to.

			




	
	
	
		
 
            fn consume_symbol_and_maybe_alias<'a>(

			




	
	
	
		
 
                source: &'a InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,

			




	
	
	
		
 
                module_name: &StringRef<'static>, module_root_id: RootId,

			




	
	
	
		
 
            ) -> Result<(AliasedSymbol, SymbolDefinition), ParseError> {

			




	
	
	
		
 
                // Consume symbol name and make sure it points to an existing definition

			




	
	
	
		
 
                let symbol_identifier = consume_ident_interned(source, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
                // Consume alias text if specified

			




	
	
	
		
 
                let alias_identifier = if peek_ident(source, iter) == Some(b"as") {

			




	
	
	
		
 
                    // Consume alias

			




	
	
	
		
 
                    iter.consume();

			




	
	
	
		
 
                    Some(consume_ident_interned(source, iter, ctx)?)

			




	
	
	
		
 
                } else {

			




	
	
	
		
 
                    None

			




	
	
	
		
 
                };

			




	
	
	
		
 

			




	
	
	
		
 
                let target = ctx.symbols.get_symbol_by_name_defined_in_scope(

			




	
	
	
		
 
                    SymbolScope::Module(module_root_id), symbol_identifier.value.as_bytes()

			




	
	
	
		
 
                );

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_symbols.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -70,48 +70,49 @@ impl PassSymbols {

			




	
	
	
		
 
        loop {

			




	
	
	
		
 
            let range_idx_usize = range_idx as usize;

			




	
	
	
		
 
            let cur_range = &module.tokens.ranges[range_idx_usize];

			




	
	
	
		
 
            let next_sibling_idx = cur_range.next_sibling_idx;

			




	
	
	
		
 
            let range_kind = cur_range.range_kind;

			




	
	
	
		
 

			




	
	
	
		
 
            // Parse if it is a definition or a pragma

			




	
	
	
		
 
            if range_kind == TokenRangeKind::Definition {

			




	
	
	
		
 
                self.visit_definition_range(modules, module_idx, ctx, range_idx_usize)?;

			




	
	
	
		
 
            } else if range_kind == TokenRangeKind::Pragma {

			




	
	
	
		
 
                self.visit_pragma_range(modules, module_idx, ctx, range_idx_usize)?;

			




	
	
	
		
 
            }

			




	
	
	
		
 

			




	
	
	
		
 
            if next_sibling_idx == NO_SIBLING {

			




	
	
	
		
 
                break;

			




	
	
	
		
 
            } else {

			




	
	
	
		
 
                range_idx = next_sibling_idx;

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Add the module's symbol scope and the symbols we just parsed

			




	
	
	
		
 
        let module_scope = SymbolScope::Module(root_id);

			




	
	
	
		
 
        ctx.symbols.insert_scope(None, module_scope);

			




	
	
	
		
 
        for symbol in self.symbols.drain(..) {

			




	
	
	
		
 
            ctx.symbols.insert_scope(Some(module_scope), SymbolScope::Definition(symbol.variant.as_definition().definition_id));

			




	
	
	
		
 
            if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(module_scope, symbol) {

			




	
	
	
		
 
                return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol))

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Modify the preallocated root

			




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

			




	
	
	
		
 
        root.pragmas.extend(self.pragmas.drain(..));

			




	
	
	
		
 
        root.definitions.extend(self.definitions.drain(..));

			




	
	
	
		
 

			




	
	
	
		
 
        let module = &mut modules[module_idx];

			




	
	
	
		
 
        module.phase = ModuleCompilationPhase::SymbolsScanned;

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_pragma_range(&mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize) -> Result<(), ParseError> {

			




	
	
	
		
 
        let module = &modules[module_idx];

			




	
	
	
		
 
        let range = &module.tokens.ranges[range_idx];

			




	
	
	
		
 
        let mut iter = module.tokens.iter_range(range);

			




	
	
	
		
 

			




	
	
	
		
 
        // Consume pragma name

			




	
	
	
		
 
        let (pragma_section, pragma_start, _) = consume_pragma(&module.source, &mut iter)?;

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_tokenizer.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -130,51 +130,52 @@ impl PassTokenizer {

			




	
	
	
		
 

			




	
	
	
		
 
        // End of file, check if our state is correct

			




	
	
	
		
 
        if let Some(error) = source.had_error.take() {

			




	
	
	
		
 
            return Err(error);

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        if !self.curly_stack.is_empty() {

			




	
	
	
		
 
            // Let's not add a lot of heuristics and just tell the programmer

			




	
	
	
		
 
            // that something is wrong

			




	
	
	
		
 
            let last_unmatched_open = self.curly_stack.pop().unwrap();

			




	
	
	
		
 
            return Err(ParseError::new_error_str_at_pos(

			




	
	
	
		
 
                source, last_unmatched_open, "unmatched opening curly brace '{'"

			




	
	
	
		
 
            ));

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Ranges that did not depend on curly braces may have missing tokens.

			




	
	
	
		
 
        // So close all of the active tokens

			




	
	
	
		
 
        while self.stack_idx != 0 {

			




	
	
	
		
 
            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 target.ranges[0].end != last_token_idx {

			




	
	
	
		
 

			




	
	
	
		
 
        if last_registered_idx != last_token_idx {

			




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

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // TODO: @remove once I'm sure the algorithm works. For now it is better

			




	
	
	
		
 
        //  if the debugging is a little more expedient

			




	
	
	
		
 
        if cfg!(debug_assertions) {

			




	
	
	
		
 
            // For each range make sure its children make sense

			




	
	
	
		
 
            for parent_idx in 0..target.ranges.len() {

			




	
	
	
		
 
                let cur_range = &target.ranges[parent_idx];

			




	
	
	
		
 
                if cur_range.num_child_ranges == 0 {

			




	
	
	
		
 
                    assert_eq!(cur_range.first_child_idx, NO_RELATION);

			




	
	
	
		
 
                    assert_eq!(cur_range.last_child_idx, NO_RELATION);

			




	
	
	
		
 
                } else {

			




	
	
	
		
 
                    assert_ne!(cur_range.first_child_idx, NO_RELATION);

			




	
	
	
		
 
                    assert_ne!(cur_range.last_child_idx, NO_RELATION);

			




	
	
	
		
 

			




	
	
	
		
 
                    let mut child_counter = 0u32;

			




	
	
	
		
 
                    let mut last_valid_child_idx = cur_range.first_child_idx;

			




	
	
	
		
 
                    let mut child_idx = cur_range.first_child_idx;

			




	
	
	
		
 
                    while child_idx != NO_RELATION {

			




	
	
	
		
 
                        let child_range = &target.ranges[child_idx as usize];

			




	
	
	
		
 
                        assert_eq!(child_range.parent_idx, parent_idx as i32);

			




	
	
	
		
 
                        last_valid_child_idx = child_idx;

			




	
	
	
		
 
                        child_idx = child_range.next_sibling_idx;

			




	
	
	
		
 
                        child_counter += 1;

			




	
	
		
 
@@ -620,95 +621,99 @@ impl PassTokenizer {

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    // a newline.

			




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

			




	
	
	
		
 
        debug_assert!(is_whitespace(source.next().unwrap()));

			




	
	
	
		
 

			




	
	
	
		
 
        let mut has_newline = false;

			




	
	
	
		
 
        while let Some(c) = source.next() {

			




	
	
	
		
 
            if !is_whitespace(c) {

			




	
	
	
		
 
                break;

			




	
	
	
		
 
            }

			




	
	
	
		
 

			




	
	
	
		
 
            if c == b'\n' {

			




	
	
	
		
 
                has_newline = true;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            source.consume();

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        has_newline

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn add_code_range(

			




	
	
	
		
 
        &mut self, target: &mut TokenBuffer, parent_idx: i32,

			




	
	
	
		
 
        code_start_idx: u32, code_end_idx: u32

			




	
	
	
		
 
    ) {

			




	
	
	
		
 
        let new_range_idx = target.ranges.len() as i32;

			




	
	
	
		
 
        let parent_range = &mut target.ranges[parent_idx as usize];

			




	
	
	
		
 
        debug_assert_ne!(parent_range.end, code_start_idx, "called push_code_range without a need to do so");

			




	
	
	
		
 

			




	
	
	
		
 
        let sibling_idx = parent_range.last_child_idx;

			




	
	
	
		
 

			




	
	
	
		
 
        parent_range.last_child_idx = new_range_idx;

			




	
	
	
		
 
        parent_range.end = code_end_idx;

			




	
	
	
		
 
        parent_range.num_child_ranges += 1;

			




	
	
	
		
 

			




	
	
	
		
 
        let curly_depth = self.curly_stack.len() as u32;

			




	
	
	
		
 
        target.ranges.push(TokenRange{

			




	
	
	
		
 
            parent_idx,

			




	
	
	
		
 
            range_kind: TokenRangeKind::Code,

			




	
	
	
		
 
            curly_depth,

			




	
	
	
		
 
            start: code_start_idx,

			




	
	
	
		
 
            end: code_end_idx,

			




	
	
	
		
 
            num_child_ranges: 0,

			




	
	
	
		
 
            first_child_idx: NO_RELATION,

			




	
	
	
		
 
            last_child_idx: NO_RELATION,

			




	
	
	
		
 
            next_sibling_idx: new_range_idx + 1, // we're going to push this range below

			




	
	
	
		
 
        });

			




	
	
	
		
 

			




	
	
	
		
 
        // Fix up the sibling indices

			




	
	
	
		
 
        if sibling_idx != NO_RELATION {

			




	
	
	
		
 
            let sibling_range = &mut target.ranges[sibling_idx as usize];

			




	
	
	
		
 
            sibling_range.next_sibling_idx = new_range_idx;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn push_range(&mut self, target: &mut TokenBuffer, range_kind: TokenRangeKind, first_token_idx: u32) {

			




	
	
	
		
 
        let new_range_idx = target.ranges.len() as i32;

			




	
	
	
		
 
        let parent_idx = self.stack_idx as i32;

			




	
	
	
		
 
        let parent_range = &mut target.ranges[self.stack_idx];

			




	
	
	
		
 
        let curly_depth = self.curly_stack.len() as u32;

			




	
	
	
		
 

			




	
	
	
		
 
        if parent_range.first_child_idx == NO_RELATION {

			




	
	
	
		
 
            parent_range.first_child_idx = new_range_idx;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        if parent_range.end != first_token_idx {

			




	
	
	
		
 
            // We popped a range, processed some intermediate tokens and now

			




	
	
	
		
 
            // enter a new range. Those intermediate tokens do not belong to a

			




	
	
	
		
 
            // particular range yet. So we put them in a "code" range.

			




	
	
	
		
 

			




	
	
	
		
 
            // Remember last sibling from parent (if any)

			




	
	
	
		
 
            let sibling_idx = parent_range.last_child_idx;

			




	
	
	
		
 

			




	
	
	
		
 
            // Push the code range

			




	
	
	
		
 
            let code_start_idx = parent_range.end;

			




	
	
	
		
 
            let code_end_idx = first_token_idx;

			




	
	
	
		
 

			




	
	
	
		
 
            parent_range.last_child_idx = new_range_idx;

			




	
	
	
		
 
            parent_range.end = code_end_idx;

			




	
	
	
		
 
            parent_range.num_child_ranges += 1;

			




	
	
	
		
 

			




	
	
	
		
 
            target.ranges.push(TokenRange{

			




	
	
	
		
 
                parent_idx,

			




	
	
	
		
 
                range_kind: TokenRangeKind::Code,

			




	
	
	
		
 
                curly_depth,

			




	
	
	
		
 
                start: code_start_idx,

			




	
	
	
		
 
                end: code_end_idx,

			




	
	
	
		
 
                num_child_ranges: 0,

			




	
	
	
		
 
                first_child_idx: NO_RELATION,

			




	
	
	
		
 
                last_child_idx: NO_RELATION,

			




	
	
	
		
 
                next_sibling_idx: new_range_idx + 1, // we're going to push this range below

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
            // Fix up the sibling indices

			




	
	
	
		
 
            if sibling_idx != NO_RELATION {

			




	
	
	
		
 
                let sibling_range = &mut target.ranges[sibling_idx as usize];

			




	
	
	
		
 
                sibling_range.next_sibling_idx = new_range_idx;

			




	
	
	
		
 
            }

			




	
	
	
		
 
        let last_registered_idx = parent_range.end;

			




	
	
	
		
 
        if last_registered_idx != first_token_idx {

			




	
	
	
		
 
            self.add_code_range(target, parent_idx, last_registered_idx, first_token_idx);

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Push the new range

			




	
	
	
		
 
        self.stack_idx = target.ranges.len();

			




	
	
	
		
 
        let curly_depth = self.curly_stack.len() as u32;

			




	
	
	
		
 
        target.ranges.push(TokenRange{

			




	
	
	
		
 
            parent_idx,

			




	
	
	
		
 
            range_kind,

			




	
	
	
		
 
            curly_depth,

			




	
	
	
		
 
            start: first_token_idx,

			




	
	
	
		
 
            end: first_token_idx, // modified when popped

			




	
	
	
		
 
            num_child_ranges: 0,

			




	
	
	
		
 
            first_child_idx: NO_RELATION,

			




	
	
	
		
 
            last_child_idx: NO_RELATION,

			




	
	
	
		
 
            next_sibling_idx: NO_RELATION

			




	
	
	
		
 
        })

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn pop_range(&mut self, target: &mut TokenBuffer, end_token_idx: u32) {

			




	
	
	
		
 
        let popped_idx = self.stack_idx as i32;

			




	
	
	
		
 
        let popped_range = &mut target.ranges[self.stack_idx];

			




	
	
	
		
 
        debug_assert!(self.stack_idx != 0, "attempting to pop top-level range");

			




	
	
	
		
 

			




	
	
	
		
 
        // Fix up the current range before going back to parent

			




	
	
	
		
 
        popped_range.end = end_token_idx;

			




	
	
	
		
 
        debug_assert_ne!(popped_range.start, end_token_idx);

			




	
	
	
		
 

			




	
	
	
		
 
        // Go back to parent and fix up its child pointers, but remember the

			




	
	
	
		
 
        // last child, so we can link it to the newly popped range.

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_typing.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -1911,103 +1911,103 @@ impl PassTyping {

			




	
	
	
		
 

			




	
	
	
		
 
                if progress_subject {

			




	
	
	
		
 
                    self.expr_queued.insert(subject_id);

			




	
	
	
		
 
                }

			




	
	
	
		
 
                

			




	
	
	
		
 
                // Apply to field's type

			




	
	
	
		
 
                let signature_type: *mut _ = &mut poly_data.returned;

			




	
	
	
		
 
                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
                let (_, progress_expr) = Self::apply_equal2_signature_constraint(

			




	
	
	
		
 
                    ctx, upcast_id, None, poly_data, &mut poly_progress, 

			




	
	
	
		
 
                    signature_type, 0, expr_type, 0

			




	
	
	
		
 
                )?;

			




	
	
	
		
 

			




	
	
	
		
 
                if progress_expr {

			




	
	
	
		
 
                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

			




	
	
	
		
 
                        self.expr_queued.insert(parent_id);

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 

			




	
	
	
		
 
                // Reapply progress in polymorphic variables to struct's type

			




	
	
	
		
 
                let signature_type: *mut _ = &mut poly_data.embedded[0];

			




	
	
	
		
 
                let subject_type: *mut _ = self.expr_types.get_mut(&subject_id).unwrap();

			




	
	
	
		
 
                

			




	
	
	
		
 
                let progress_subject = Self::apply_equal2_polyvar_constraint(&ctx.heap,

			




	
	
	
		
 
                let progress_subject = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                    poly_data, &poly_progress, signature_type, subject_type

			




	
	
	
		
 
                );

			




	
	
	
		
 

			




	
	
	
		
 
                let signature_type: *mut _ = &mut poly_data.returned;

			




	
	
	
		
 
                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
                let progress_expr = Self::apply_equal2_polyvar_constraint(&ctx.heap,

			




	
	
	
		
 
                let progress_expr = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                    poly_data, &poly_progress, signature_type, expr_type

			




	
	
	
		
 
                );

			




	
	
	
		
 

			




	
	
	
		
 
                (progress_subject, progress_expr)

			




	
	
	
		
 
            }

			




	
	
	
		
 
        };

			




	
	
	
		
 

			




	
	
	
		
 
        if progress_subject { self.queue_expr(subject_id); }

			




	
	
	
		
 
        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

			




	
	
	
		
 

			




	
	
	
		
 
        debug_log!(" * After:");

			




	
	
	
		
 
        debug_log!("   - Subject type [{}]: {}", progress_subject, self.expr_types.get(&subject_id).unwrap().display_name(&ctx.heap));

			




	
	
	
		
 
        debug_log!("   - Expr    type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn progress_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError> {

			




	
	
	
		
 
        let upcast_id = id.upcast();

			




	
	
	
		
 
        let expr = &ctx.heap[id];

			




	
	
	
		
 

			




	
	
	
		
 
        debug_log!("Literal expr: {}", upcast_id.index);

			




	
	
	
		
 
        debug_log!(" * Before:");

			




	
	
	
		
 
        debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

			




	
	
	
		
 

			




	
	
	
		
 
        let progress_expr = match &expr.value {

			




	
	
	
		
 
            Literal::Null => {

			




	
	
	
		
 
                self.apply_forced_constraint(ctx, upcast_id, &MESSAGE_TEMPLATE)?

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::Integer(_) => {

			




	
	
	
		
 
                self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::True | Literal::False => {

			




	
	
	
		
 
                self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::Character(_) => {

			




	
	
	
		
 
                self.apply_forced_constraint(ctx, upcast_id, &CHARACTER_TEMPLATE)?;

			




	
	
	
		
 
                todo!("check character literal type inference");

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::String(_) => {

			




	
	
	
		
 
                self.apply_forced_constraint(ctx, upcast_id, &STRING_TEMPLATE)?;

			




	
	
	
		
 
                todo!("check string literal type inference");

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::Struct(data) => {

			




	
	
	
		
 
                let extra = self.extra_data.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 
                for poly in &extra.poly_vars {

			




	
	
	
		
 
                    debug_log!(" * Poly: {}", poly.display_name(&ctx.heap));

			




	
	
	
		
 
                for _poly in &extra.poly_vars {

			




	
	
	
		
 
                    debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));

			




	
	
	
		
 
                }

			




	
	
	
		
 
                let mut poly_progress = HashSet::new();

			




	
	
	
		
 
                debug_assert_eq!(extra.embedded.len(), data.fields.len());

			




	
	
	
		
 

			




	
	
	
		
 
                debug_log!(" * During (inferring types from fields and struct type):");

			




	
	
	
		
 

			




	
	
	
		
 
                // Mutually infer field signature/expression types

			




	
	
	
		
 
                for (field_idx, field) in data.fields.iter().enumerate() {

			




	
	
	
		
 
                    let field_expr_id = field.value;

			




	
	
	
		
 
                    let signature_type: *mut _ = &mut extra.embedded[field_idx];

			




	
	
	
		
 
                    let field_type: *mut _ = self.expr_types.get_mut(&field_expr_id).unwrap();

			




	
	
	
		
 
                    let (_, progress_arg) = Self::apply_equal2_signature_constraint(

			




	
	
	
		
 
                        ctx, upcast_id, Some(field_expr_id), extra, &mut poly_progress,

			




	
	
	
		
 
                        signature_type, 0, field_type, 0

			




	
	
	
		
 
                    )?;

			




	
	
	
		
 

			




	
	
	
		
 
                    debug_log!(

			




	
	
	
		
 
                        "   - Field {} type | sig: {}, field: {}", field_idx,

			




	
	
	
		
 
                        unsafe{&*signature_type}.display_name(&ctx.heap),

			




	
	
	
		
 
                        unsafe{&*field_type}.display_name(&ctx.heap)

			




	
	
	
		
 
                    );

			




	
	
	
		
 

			




	
	
	
		
 
                    if progress_arg {

			




	
	
	
		
 
                        self.expr_queued.insert(field_expr_id);

			




	
	
		
 
@@ -2029,112 +2029,112 @@ impl PassTyping {

			




	
	
	
		
 
                    unsafe{&*signature_type}.display_name(&ctx.heap),

			




	
	
	
		
 
                    unsafe{&*expr_type}.display_name(&ctx.heap)

			




	
	
	
		
 
                );

			




	
	
	
		
 
                debug_log!("   - Ret poly progress | {:?}", poly_progress);

			




	
	
	
		
 

			




	
	
	
		
 
                if progress_expr {

			




	
	
	
		
 
                    // TODO: @cleanup, cannot call utility self.queue_parent thingo

			




	
	
	
		
 
                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

			




	
	
	
		
 
                        self.expr_queued.insert(parent_id);

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 

			




	
	
	
		
 
                // Check which expressions use the polymorphic arguments. If the

			




	
	
	
		
 
                // polymorphic variables have been progressed then we try to 

			




	
	
	
		
 
                // progress them inside the expression as well.

			




	
	
	
		
 
                debug_log!(" * During (reinferring from progressed polyvars):");

			




	
	
	
		
 

			




	
	
	
		
 
                // For all field expressions

			




	
	
	
		
 
                for field_idx in 0..extra.embedded.len() {

			




	
	
	
		
 
                    debug_assert_eq!(field_idx, data.fields[field_idx].field_idx, "confusing, innit?");

			




	
	
	
		
 
                    let signature_type: *mut _ = &mut extra.embedded[field_idx];

			




	
	
	
		
 
                    let field_expr_id = data.fields[field_idx].value;

			




	
	
	
		
 
                    let field_type: *mut _ = self.expr_types.get_mut(&field_expr_id).unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
                    let progress_arg = Self::apply_equal2_polyvar_constraint(&ctx.heap,

			




	
	
	
		
 
                    let progress_arg = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                        extra, &poly_progress, signature_type, field_type

			




	
	
	
		
 
                    );

			




	
	
	
		
 

			




	
	
	
		
 
                    debug_log!(

			




	
	
	
		
 
                        "   - Field {} type | sig: {}, field: {}", field_idx,

			




	
	
	
		
 
                        unsafe{&*signature_type}.display_name(&ctx.heap),

			




	
	
	
		
 
                        unsafe{&*field_type}.display_name(&ctx.heap)

			




	
	
	
		
 
                    );

			




	
	
	
		
 
                    if progress_arg {

			




	
	
	
		
 
                        self.expr_queued.insert(field_expr_id);

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 
                

			




	
	
	
		
 
                // For the return type

			




	
	
	
		
 
                let signature_type: *mut _ = &mut extra.returned;

			




	
	
	
		
 
                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
                let progress_expr = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                    &ctx.heap, extra, &poly_progress, signature_type, expr_type

			




	
	
	
		
 
                    extra, &poly_progress, signature_type, expr_type

			




	
	
	
		
 
                );

			




	
	
	
		
 

			




	
	
	
		
 
                progress_expr

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::Enum(_) => {

			




	
	
	
		
 
                let extra = self.extra_data.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 
                for poly in &extra.poly_vars {

			




	
	
	
		
 
                    debug_log!(" * Poly: {}", poly.display_name(&ctx.heap));

			




	
	
	
		
 
                for _poly in &extra.poly_vars {

			




	
	
	
		
 
                    debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));

			




	
	
	
		
 
                }

			




	
	
	
		
 
                let mut poly_progress = HashSet::new();

			




	
	
	
		
 
                

			




	
	
	
		
 
                debug_log!(" * During (inferring types from return type)");

			




	
	
	
		
 

			




	
	
	
		
 
                let signature_type: *mut _ = &mut extra.returned;

			




	
	
	
		
 
                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 
                let (_, progress_expr) = Self::apply_equal2_signature_constraint(

			




	
	
	
		
 
                    ctx, upcast_id, None, extra, &mut poly_progress,

			




	
	
	
		
 
                    signature_type, 0, expr_type, 0

			




	
	
	
		
 
                )?;

			




	
	
	
		
 

			




	
	
	
		
 
                debug_log!(

			




	
	
	
		
 
                    "   - Ret type | sig: {}, expr: {}",

			




	
	
	
		
 
                    unsafe{&*signature_type}.display_name(&ctx.heap),

			




	
	
	
		
 
                    unsafe{&*expr_type}.display_name(&ctx.heap)

			




	
	
	
		
 
                );

			




	
	
	
		
 

			




	
	
	
		
 
                if progress_expr {

			




	
	
	
		
 
                    // TODO: @cleanup

			




	
	
	
		
 
                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

			




	
	
	
		
 
                        self.expr_queued.insert(parent_id);

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 

			




	
	
	
		
 
                debug_log!(" * During (reinferring from progress polyvars):");

			




	
	
	
		
 
                let progress_expr = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                    &ctx.heap, extra, &poly_progress, signature_type, expr_type

			




	
	
	
		
 
                    extra, &poly_progress, signature_type, expr_type

			




	
	
	
		
 
                );

			




	
	
	
		
 

			




	
	
	
		
 
                progress_expr

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::Union(data) => {

			




	
	
	
		
 
                let extra = self.extra_data.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 
                for poly in &extra.poly_vars {

			




	
	
	
		
 
                    debug_log!(" * Poly: {}", poly.display_name(&ctx.heap));

			




	
	
	
		
 
                for _poly in &extra.poly_vars {

			




	
	
	
		
 
                    debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));

			




	
	
	
		
 
                }

			




	
	
	
		
 
                let mut poly_progress = HashSet::new();

			




	
	
	
		
 
                debug_assert_eq!(extra.embedded.len(), data.values.len());

			




	
	
	
		
 

			




	
	
	
		
 
                debug_log!(" * During (inferring types from variant values and union type):");

			




	
	
	
		
 

			




	
	
	
		
 
                // Mutually infer union variant values

			




	
	
	
		
 
                for (value_idx, value_expr_id) in data.values.iter().enumerate() {

			




	
	
	
		
 
                    let value_expr_id = *value_expr_id;

			




	
	
	
		
 
                    let signature_type: *mut _ = &mut extra.embedded[value_idx];

			




	
	
	
		
 
                    let value_type: *mut _ = self.expr_types.get_mut(&value_expr_id).unwrap();

			




	
	
	
		
 
                    let (_, progress_arg) = Self::apply_equal2_signature_constraint(

			




	
	
	
		
 
                        ctx, upcast_id, Some(value_expr_id), extra, &mut poly_progress,

			




	
	
	
		
 
                        signature_type, 0, value_type, 0 

			




	
	
	
		
 
                    )?;

			




	
	
	
		
 

			




	
	
	
		
 
                    debug_log!(

			




	
	
	
		
 
                        "   - Value {} type | sig: {}, field: {}", value_idx,

			




	
	
	
		
 
                        unsafe{&*signature_type}.display_name(&ctx.heap),

			




	
	
	
		
 
                        unsafe{&*value_type}.display_name(&ctx.heap)

			




	
	
	
		
 
                    );

			




	
	
	
		
 

			




	
	
	
		
 
                    if progress_arg {

			




	
	
	
		
 
                        self.expr_queued.insert(value_expr_id);

			




	
	
		
 
@@ -2153,67 +2153,67 @@ impl PassTyping {

			




	
	
	
		
 

			




	
	
	
		
 
                debug_log!(

			




	
	
	
		
 
                    "   - Ret type | sig: {}, expr: {}",

			




	
	
	
		
 
                    unsafe{&*signature_type}.display_name(&ctx.heap),

			




	
	
	
		
 
                    unsafe{&*expr_type}.display_name(&ctx.heap)

			




	
	
	
		
 
                );

			




	
	
	
		
 
                debug_log!("   - Ret poly progress | {:?}", poly_progress);

			




	
	
	
		
 

			




	
	
	
		
 
                if progress_expr {

			




	
	
	
		
 
                    // TODO: @cleanup, borrowing rules

			




	
	
	
		
 
                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

			




	
	
	
		
 
                        self.expr_queued.insert(parent_id);

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 

			




	
	
	
		
 
                debug_log!(" * During (reinferring from progress polyvars):");

			




	
	
	
		
 
            

			




	
	
	
		
 
                // For all embedded values of the union variant

			




	
	
	
		
 
                for value_idx in 0..extra.embedded.len() {

			




	
	
	
		
 
                    let signature_type: *mut _ = &mut extra.embedded[value_idx];

			




	
	
	
		
 
                    let value_expr_id = data.values[value_idx];

			




	
	
	
		
 
                    let value_type: *mut _ = self.expr_types.get_mut(&value_expr_id).unwrap();

			




	
	
	
		
 
                    

			




	
	
	
		
 
                    let progress_arg = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                        &ctx.heap, extra, &poly_progress, signature_type, value_type

			




	
	
	
		
 
                        extra, &poly_progress, signature_type, value_type

			




	
	
	
		
 
                    );

			




	
	
	
		
 

			




	
	
	
		
 
                    debug_log!(

			




	
	
	
		
 
                        "   - Value {} type | sig: {}, value: {}", value_idx,

			




	
	
	
		
 
                        unsafe{&*signature_type}.display_name(&ctx.heap),

			




	
	
	
		
 
                        unsafe{&*value_type}.display_name(&ctx.heap)

			




	
	
	
		
 
                    );

			




	
	
	
		
 
                    if progress_arg {

			




	
	
	
		
 
                        self.expr_queued.insert(value_expr_id);

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 

			




	
	
	
		
 
                // And for the union type itself

			




	
	
	
		
 
                let signature_type: *mut _ = &mut extra.returned;

			




	
	
	
		
 
                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
                let progress_expr = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                    &ctx.heap, extra, &poly_progress, signature_type, expr_type

			




	
	
	
		
 
                    extra, &poly_progress, signature_type, expr_type

			




	
	
	
		
 
                );

			




	
	
	
		
 

			




	
	
	
		
 
                progress_expr

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Literal::Array(data) => {

			




	
	
	
		
 
                let expr_elements = data.clone(); // TODO: @performance

			




	
	
	
		
 
                debug_log!("Array expr ({} elements): {}", expr_elements.len(), upcast_id.index);

			




	
	
	
		
 
                debug_log!(" * Before:");

			




	
	
	
		
 
                debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

			




	
	
	
		
 

			




	
	
	
		
 
                // All elements should have an equal type

			




	
	
	
		
 
                let progress = self.apply_equal_n_constraint(ctx, upcast_id, &expr_elements)?;

			




	
	
	
		
 
                for (progress_arg, arg_id) in progress.iter().zip(expr_elements.iter()) {

			




	
	
	
		
 
                    if *progress_arg {

			




	
	
	
		
 
                        self.queue_expr(*arg_id);

			




	
	
	
		
 
                    }

			




	
	
	
		
 
                }

			




	
	
	
		
 

			




	
	
	
		
 
                // And the output should be an array of the element types

			




	
	
	
		
 
                let mut progress_expr = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;

			




	
	
	
		
 
                if !expr_elements.is_empty() {

			




	
	
	
		
 
                    let first_arg_id = expr_elements[0];

			




	
	
	
		
 
                    let (inner_expr_progress, arg_progress) = self.apply_equal2_constraint(

			




	
	
	
		
 
                        ctx, upcast_id, upcast_id, 1, first_arg_id, 0

			




	
	
		
 
@@ -2284,79 +2284,79 @@ impl PassTyping {

			




	
	
	
		
 
        let signature_type: *mut _ = &mut extra.returned;

			




	
	
	
		
 
        let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 
        let (_, progress_expr) = Self::apply_equal2_signature_constraint(

			




	
	
	
		
 
            ctx, upcast_id, None, extra, &mut poly_progress,

			




	
	
	
		
 
            signature_type, 0, expr_type, 0

			




	
	
	
		
 
        )?;

			




	
	
	
		
 

			




	
	
	
		
 
        debug_log!(

			




	
	
	
		
 
            "   - Ret type | sig: {}, expr: {}", 

			




	
	
	
		
 
            unsafe{&*signature_type}.display_name(&ctx.heap), 

			




	
	
	
		
 
            unsafe{&*expr_type}.display_name(&ctx.heap)

			




	
	
	
		
 
        );

			




	
	
	
		
 

			




	
	
	
		
 
        if progress_expr {

			




	
	
	
		
 
            // TODO: @cleanup, cannot call utility self.queue_parent thingo

			




	
	
	
		
 
            if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

			




	
	
	
		
 
                self.expr_queued.insert(parent_id);

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // If we did not have an error in the polymorph inference above, then

			




	
	
	
		
 
        // reapplying the polymorph type to each argument type and the return

			




	
	
	
		
 
        // type should always succeed.

			




	
	
	
		
 
        debug_log!(" * During (reinferring from progressed polyvars):");

			




	
	
	
		
 
        for (poly_idx, poly_var) in extra.poly_vars.iter().enumerate() {

			




	
	
	
		
 
            debug_log!("   - Poly {} | sig: {}", poly_idx, poly_var.display_name(&ctx.heap));

			




	
	
	
		
 
        for (_poly_idx, _poly_var) in extra.poly_vars.iter().enumerate() {

			




	
	
	
		
 
            debug_log!("   - Poly {} | sig: {}", _poly_idx, _poly_var.display_name(&ctx.heap));

			




	
	
	
		
 
        }

			




	
	
	
		
 
        // TODO: @performance If the algorithm is changed to be more "on demand

			




	
	
	
		
 
        //  argument re-evaluation", instead of "all-argument re-evaluation",

			




	
	
	
		
 
        //  then this is no longer true

			




	
	
	
		
 
        for arg_idx in 0..extra.embedded.len() {

			




	
	
	
		
 
            let signature_type: *mut _ = &mut extra.embedded[arg_idx];

			




	
	
	
		
 
            let arg_expr_id = expr.arguments[arg_idx];

			




	
	
	
		
 
            let arg_type: *mut _ = self.expr_types.get_mut(&arg_expr_id).unwrap();

			




	
	
	
		
 
            

			




	
	
	
		
 
            let progress_arg = Self::apply_equal2_polyvar_constraint(&ctx.heap,

			




	
	
	
		
 
            let progress_arg = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
                extra, &poly_progress,

			




	
	
	
		
 
                signature_type, arg_type

			




	
	
	
		
 
            );

			




	
	
	
		
 
            

			




	
	
	
		
 
            debug_log!(

			




	
	
	
		
 
                "   - Arg {} type | sig: {}, arg: {}", arg_idx, 

			




	
	
	
		
 
                unsafe{&*signature_type}.display_name(&ctx.heap), 

			




	
	
	
		
 
                unsafe{&*arg_type}.display_name(&ctx.heap)

			




	
	
	
		
 
            );

			




	
	
	
		
 
            if progress_arg {

			




	
	
	
		
 
                self.expr_queued.insert(arg_expr_id);

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Once more for the return type

			




	
	
	
		
 
        let signature_type: *mut _ = &mut extra.returned;

			




	
	
	
		
 
        let ret_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
        let progress_ret = Self::apply_equal2_polyvar_constraint(&ctx.heap,

			




	
	
	
		
 
        let progress_ret = Self::apply_equal2_polyvar_constraint(

			




	
	
	
		
 
            extra, &poly_progress, signature_type, ret_type

			




	
	
	
		
 
        );

			




	
	
	
		
 
        debug_log!(

			




	
	
	
		
 
            "   - Ret type | sig: {}, arg: {}", 

			




	
	
	
		
 
            unsafe{&*signature_type}.display_name(&ctx.heap), 

			




	
	
	
		
 
            unsafe{&*ret_type}.display_name(&ctx.heap)

			




	
	
	
		
 
        );

			




	
	
	
		
 
        if progress_ret {

			




	
	
	
		
 
            self.queue_expr_parent(ctx, upcast_id);

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        debug_log!(" * After:");

			




	
	
	
		
 
        debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError> {

			




	
	
	
		
 
        let upcast_id = id.upcast();

			




	
	
	
		
 
        let var_expr = &ctx.heap[id];

			




	
	
	
		
 
        let var_id = var_expr.declaration.unwrap();

			




	
	
	
		
 

			




	
	
	
		
 
        debug_log!("Variable expr '{}': {}", ctx.heap[var_id].identifier().value.as_str(), upcast_id.index);

			




	
	
	
		
 
        debug_log!(" * Before:");

			




	
	
		
 
@@ -2579,49 +2579,48 @@ impl PassTyping {

			




	
	
	
		
 
                let polymorph_type = &mut polymorph_data.poly_vars[poly_idx];

			




	
	
	
		
 
                match Self::apply_forced_constraint_types(

			




	
	
	
		
 
                    polymorph_type, 0, poly_section, 0

			




	
	
	
		
 
                ) {

			




	
	
	
		
 
                    Ok(true) => { polymorph_progress.insert(poly_idx); },

			




	
	
	
		
 
                    Ok(false) => {},

			




	
	
	
		
 
                    Err(()) => { return Err(Self::construct_poly_arg_error(ctx, polymorph_data, outer_expr_id))}

			




	
	
	
		
 
                }

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
        Ok((progress_sig, progress_expr))

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    /// Applies equal2 constraints on the signature type for each of the 

			




	
	
	
		
 
    /// polymorphic variables. If the signature type is progressed then we 

			




	
	
	
		
 
    /// progress the expression type as well.

			




	
	
	
		
 
    ///

			




	
	
	
		
 
    /// This function assumes that the polymorphic variables have already been

			




	
	
	
		
 
    /// progressed as far as possible by calling 

			




	
	
	
		
 
    /// `apply_equal2_signature_constraint`. As such, we expect to not encounter

			




	
	
	
		
 
    /// any errors.

			




	
	
	
		
 
    ///

			




	
	
	
		
 
    /// This function returns true if the expression's type has been progressed

			




	
	
	
		
 
    fn apply_equal2_polyvar_constraint(

			




	
	
	
		
 
        heap: &Heap,

			




	
	
	
		
 
        polymorph_data: &ExtraData, _polymorph_progress: &HashSet<usize>,

			




	
	
	
		
 
        signature_type: *mut InferenceType, expr_type: *mut InferenceType

			




	
	
	
		
 
    ) -> bool {

			




	
	
	
		
 
        // Safety: all pointers should be distinct

			




	
	
	
		
 
        //         polymorph_data contains may not be modified

			




	
	
	
		
 
        debug_assert_ptrs_distinct!(signature_type, expr_type);

			




	
	
	
		
 
        let signature_type = unsafe{&mut *signature_type};

			




	
	
	
		
 
        let expr_type = unsafe{&mut *expr_type};

			




	
	
	
		
 

			




	
	
	
		
 
        // Iterate through markers in signature type to try and make progress

			




	
	
	
		
 
        // on the polymorphic variable        

			




	
	
	
		
 
        let mut seek_idx = 0;

			




	
	
	
		
 
        let mut modified_sig = false;

			




	
	
	
		
 
        

			




	
	
	
		
 
        while let Some((poly_idx, start_idx)) = signature_type.find_body_marker(seek_idx) {

			




	
	
	
		
 
            let end_idx = InferenceType::find_subtree_end_idx(&signature_type.parts, start_idx);

			




	
	
	
		
 
            // if polymorph_progress.contains(&poly_idx) {

			




	
	
	
		
 
                // Need to match subtrees

			




	
	
	
		
 
                let polymorph_type = &polymorph_data.poly_vars[poly_idx];

			




	
	
	
		
 
                debug_log!("   - DEBUG: Applying {} to '{}' from '{}'", polymorph_type.display_name(heap), InferenceType::partial_display_name(heap, &signature_type.parts[start_idx..]), signature_type.display_name(heap));

			




	
	
	
		
 
                let modified_at_marker = Self::apply_forced_constraint_types(

			




	
	
	
		
 
                    signature_type, start_idx, 

			




	
	
	
		
 
                    &polymorph_type.parts, 0

			




	
	
	
		
 
                ).expect("no failure when applying polyvar constraints");

			




        

    


    
    

    

        

                

                    src/protocol/parser/symbol_table.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -114,49 +114,49 @@ pub enum SymbolVariant {

			




	
	
	
		
 
impl SymbolVariant {

			




	
	
	
		
 
    /// Returns the span at which the item was introduced. For an imported

			




	
	
	
		
 
    /// item (all modules, and imported types) this returns the span of the

			




	
	
	
		
 
    /// import. For a defined type this returns the span of the identifier

			




	
	
	
		
 
    pub(crate) fn span_of_introduction(&self, heap: &Heap) -> InputSpan {

			




	
	
	
		
 
        match self {

			




	
	
	
		
 
            SymbolVariant::Module(v) => heap[v.introduced_at].span(),

			




	
	
	
		
 
            SymbolVariant::Definition(v) => if let Some(import_id) = v.imported_at {

			




	
	
	
		
 
                heap[import_id].span()

			




	
	
	
		
 
            } else {

			




	
	
	
		
 
                v.identifier_span

			




	
	
	
		
 
            },

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    pub(crate) fn as_definition(&self) -> &SymbolDefinition {

			




	
	
	
		
 
        match self {

			




	
	
	
		
 
            SymbolVariant::Module(_) => unreachable!("called 'as_definition' on {:?}", self),

			




	
	
	
		
 
            SymbolVariant::Definition(v) => v,

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
/// TODO: @Cleanup - remove clone everywhere

			




	
	
	
		
 
#[derive(Clone)]

			




	
	
	
		
 
#[derive(Debug, Clone)]

			




	
	
	
		
 
pub struct Symbol {

			




	
	
	
		
 
    pub name: StringRef<'static>,

			




	
	
	
		
 
    pub variant: SymbolVariant,

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
impl Symbol {

			




	
	
	
		
 
    pub(crate) fn class(&self) -> SymbolClass {

			




	
	
	
		
 
        match &self.variant {

			




	
	
	
		
 
            SymbolVariant::Module(_) => SymbolClass::Module,

			




	
	
	
		
 
            SymbolVariant::Definition(data) => data.class.as_symbol_class(),

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
pub struct SymbolTable {

			




	
	
	
		
 
    module_lookup: HashMap<StringRef<'static>, RootId>,

			




	
	
	
		
 
    scope_lookup: HashMap<SymbolScope, ScopedSymbols>,

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
impl SymbolTable {

			




	
	
	
		
 
    pub(crate) fn new() -> Self {

			




	
	
	
		
 
        Self{

			




	
	
	
		
 
            module_lookup: HashMap::new(),

			




	
	
	
		
 
            scope_lookup: HashMap::new(),

			




	
	
		
 
@@ -170,69 +170,72 @@ impl SymbolTable {

			




	
	
	
		
 
                Err(*v.get())

			




	
	
	
		
 
            },

			




	
	
	
		
 
            Entry::Vacant(v) => {

			




	
	
	
		
 
                v.insert(root_id);

			




	
	
	
		
 
                Ok(())

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    /// Retrieves module `RootId` by name

			




	
	
	
		
 
    pub(crate) fn get_module_by_name(&mut self, name: &[u8]) -> Option<RootId> {

			




	
	
	
		
 
        let string_ref = StringRef::new(name);

			




	
	
	
		
 
        self.module_lookup.get(&string_ref).map(|v| *v)

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    /// Inserts a new symbol scope. The parent must have been added to the

			




	
	
	
		
 
    /// symbol table before.

			




	
	
	
		
 
    pub(crate) fn insert_scope(&mut self, parent_scope: Option<SymbolScope>, new_scope: SymbolScope) {

			




	
	
	
		
 
        debug_assert!(

			




	
	
	
		
 
            parent_scope.is_none() || self.scope_lookup.contains_key(parent_scope.as_ref().unwrap()),

			




	
	
	
		
 
            "inserting scope {:?} but parent {:?} does not exist", new_scope, parent_scope

			




	
	
	
		
 
        );

			




	
	
	
		
 
        debug_assert!(!self.scope_lookup.contains_key(&new_scope), "inserting scope {:?}, but it already exists", new_scope);

			




	
	
	
		
 

			




	
	
	
		
 
        println!("DEBUG: Inserting scope {:?} with parent {:?}", new_scope, parent_scope);

			




	
	
	
		
 

			




	
	
	
		
 
        if let Some(parent_scope) = parent_scope {

			




	
	
	
		
 
            let parent = self.scope_lookup.get_mut(&parent_scope).unwrap();

			




	
	
	
		
 
            parent.child_scopes.push(new_scope);

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        let scope = ScopedSymbols {

			




	
	
	
		
 
            scope: new_scope,

			




	
	
	
		
 
            parent_scope,

			




	
	
	
		
 
            child_scopes: Vec::with_capacity(RESERVED_SYMBOLS),

			




	
	
	
		
 
            symbols: Vec::with_capacity(RESERVED_SYMBOLS)

			




	
	
	
		
 
        };

			




	
	
	
		
 
        self.scope_lookup.insert(new_scope, scope);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    /// Inserts a symbol into a particular scope. The symbol's name may not

			




	
	
	
		
 
    /// exist in the scope or any of its parents. If it does collide then the

			




	
	
	
		
 
    /// symbol will be returned, together with the symbol that has the same

			




	
	
	
		
 
    /// name.

			




	
	
	
		
 
    // Note: we do not return a reference because Rust doesn't like it.

			




	
	
	
		
 
    pub(crate) fn insert_symbol(&mut self, in_scope: SymbolScope, symbol: Symbol) -> Result<(), (Symbol, Symbol)> {

			




	
	
	
		
 
        debug_assert!(self.scope_lookup.contains_key(&in_scope), "inserting symbol {}, but scope {:?} does not exist", symbol.name.as_str(), in_scope);

			




	
	
	
		
 
        println!("DEBUG: Inserting symbol {:?} in scope {:?}", symbol, in_scope);

			




	
	
	
		
 
        let mut seek_scope = in_scope;

			




	
	
	
		
 
        loop {

			




	
	
	
		
 
            let scoped_symbols = self.scope_lookup.get(&seek_scope).unwrap();

			




	
	
	
		
 
            for existing_symbol in scoped_symbols.symbols.iter() {

			




	
	
	
		
 
                if symbol.name == existing_symbol.name {

			




	
	
	
		
 
                    return Err((symbol, existing_symbol.clone()))

			




	
	
	
		
 
                }

			




	
	
	
		
 
            }

			




	
	
	
		
 

			




	
	
	
		
 
            match scoped_symbols.parent_scope {

			




	
	
	
		
 
                Some(parent_scope) => { seek_scope = parent_scope; },

			




	
	
	
		
 
                None => { break; }

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // If here, then there is no collision

			




	
	
	
		
 
        let scoped_symbols = self.scope_lookup.get_mut(&in_scope).unwrap();

			




	
	
	
		
 
        scoped_symbols.symbols.push(symbol);

			




	
	
	
		
 
        Ok(())

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    /// Retrieves a symbol by name by searching in a particular scope and that scope's parents. The

			




	
	
	
		
 
    /// returned symbol may both be imported as defined within any of the searched scopes.

			




	
	
	
		
 
    pub(crate) fn get_symbol_by_name(

			




        

    


    
    

    

        

                

                    src/protocol/tests/parser_inference.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -138,103 +138,103 @@ fn test_struct_inference() {

			




	
	
	
		
 
        func test() -> s32 {

			




	
	
	
		
 
            auto first = 0;

			




	
	
	
		
 
            auto second = 1;

			




	
	
	
		
 
            auto pair = construct(first, second);

			




	
	
	
		
 
            fix_t1(pair);

			




	
	
	
		
 
            fix_t2(pair);

			




	
	
	
		
 
            return 0;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        "

			




	
	
	
		
 
    ).for_function("test", |f| { f

			




	
	
	
		
 
        .for_variable("first", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("s8");

			




	
	
	
		
 
        })

			




	
	
	
		
 
        .for_variable("second", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("s32");

			




	
	
	
		
 
        })

			




	
	
	
		
 
        .for_variable("pair", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("Pair<s8,s32>");

			




	
	
	
		
 
        });

			




	
	
	
		
 
    });

			




	
	
	
		
 

			




	
	
	
		
 
    Tester::new_single_source_expect_ok(

			




	
	
	
		
 
        "by field access",

			




	
	
	
		
 
        "

			




	
	
	
		
 
        struct Pair<T1, T2>{ T1 first, T2 second }

			




	
	
	
		
 
        func construct<T1, T2>(T1 first, T2 second) -> Pair<T1, T2> {

			




	
	
	
		
 
            return Pair{ first: first, second: second };

			




	
	
	
		
 
        }

			




	
	
	
		
 
        test() -> s32 {

			




	
	
	
		
 
            auto first = 0;

			




	
	
	
		
 
            auto second = 1;

			




	
	
	
		
 
            auto pair = construct(first, second);

			




	
	
	
		
 
            s8 assign_first = 0;

			




	
	
	
		
 
            s64 assign_second = 1;

			




	
	
	
		
 
            pair.first = assign_first;

			




	
	
	
		
 
            pair.second = assign_second;

			




	
	
	
		
 
            return 0;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        "

			




	
	
	
		
 
    ).for_function("test", |f| { f

			




	
	
	
		
 
        .for_variable("first", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("s8");

			




	
	
	
		
 
        })

			




	
	
	
		
 
        .for_variable("second", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("s64");

			




	
	
	
		
 
        })

			




	
	
	
		
 
        .for_variable("pair", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("Pair<s8,s64>");

			




	
	
	
		
 
        });

			




	
	
	
		
 
    });

			




	
	
	
		
 

			




	
	
	
		
 
    Tester::new_single_source_expect_ok(

			




	
	
	
		
 
        "by nested field access",

			




	
	
	
		
 
        "

			




	
	
	
		
 
        struct Node<T1, T2>{ T1 l, T2 r }

			




	
	
	
		
 
        func construct<T1, T2>(T1 l, T2 r) -> Node<T1, T2> {

			




	
	
	
		
 
            return Node{ l: l, r: r };

			




	
	
	
		
 
        }

			




	
	
	
		
 
        func fix_poly<T>(Node<T, T> a) -> s32 { return 0; }

			




	
	
	
		
 
        func test() -> s32 {

			




	
	
	
		
 
            s8 assigned = 0;

			




	
	
	
		
 
            auto thing = construct(assigned, construct(0, 1));

			




	
	
	
		
 
            fix_poly(thing.r);

			




	
	
	
		
 
            thing.r.r = assigned;

			




	
	
	
		
 
            return 0;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        ",

			




	
	
	
		
 
    ).for_function("test", |f| { f

			




	
	
	
		
 
        .for_variable("thing", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("Node<s8,Node<s8,s8>>");

			




	
	
	
		
 
        });

			




	
	
	
		
 
    });

			




	
	
	
		
 
    // Tester::new_single_source_expect_ok(

			




	
	
	
		
 
    //     "by field access",

			




	
	
	
		
 
    //     "

			




	
	
	
		
 
    //     struct Pair<T1, T2>{ T1 first, T2 second }

			




	
	
	
		
 
    //     func construct<T1, T2>(T1 first, T2 second) -> Pair<T1, T2> {

			




	
	
	
		
 
    //         return Pair{ first: first, second: second };

			




	
	
	
		
 
    //     }

			




	
	
	
		
 
    //     test() -> s32 {

			




	
	
	
		
 
    //         auto first = 0;

			




	
	
	
		
 
    //         auto second = 1;

			




	
	
	
		
 
    //         auto pair = construct(first, second);

			




	
	
	
		
 
    //         s8 assign_first = 0;

			




	
	
	
		
 
    //         s64 assign_second = 1;

			




	
	
	
		
 
    //         pair.first = assign_first;

			




	
	
	
		
 
    //         pair.second = assign_second;

			




	
	
	
		
 
    //         return 0;

			




	
	
	
		
 
    //     }

			




	
	
	
		
 
    //     "

			




	
	
	
		
 
    // ).for_function("test", |f| { f

			




	
	
	
		
 
    //     .for_variable("first", |v| { v

			




	
	
	
		
 
    //         .assert_parser_type("auto")

			




	
	
	
		
 
    //         .assert_concrete_type("s8");

			




	
	
	
		
 
    //     })

			




	
	
	
		
 
    //     .for_variable("second", |v| { v

			




	
	
	
		
 
    //         .assert_parser_type("auto")

			




	
	
	
		
 
    //         .assert_concrete_type("s64");

			




	
	
	
		
 
    //     })

			




	
	
	
		
 
    //     .for_variable("pair", |v| { v

			




	
	
	
		
 
    //         .assert_parser_type("auto")

			




	
	
	
		
 
    //         .assert_concrete_type("Pair<s8,s64>");

			




	
	
	
		
 
    //     });

			




	
	
	
		
 
    // });

			




	
	
	
		
 
    //

			




	
	
	
		
 
    // Tester::new_single_source_expect_ok(

			




	
	
	
		
 
    //     "by nested field access",

			




	
	
	
		
 
    //     "

			




	
	
	
		
 
    //     struct Node<T1, T2>{ T1 l, T2 r }

			




	
	
	
		
 
    //     func construct<T1, T2>(T1 l, T2 r) -> Node<T1, T2> {

			




	
	
	
		
 
    //         return Node{ l: l, r: r };

			




	
	
	
		
 
    //     }

			




	
	
	
		
 
    //     func fix_poly<T>(Node<T, T> a) -> s32 { return 0; }

			




	
	
	
		
 
    //     func test() -> s32 {

			




	
	
	
		
 
    //         s8 assigned = 0;

			




	
	
	
		
 
    //         auto thing = construct(assigned, construct(0, 1));

			




	
	
	
		
 
    //         fix_poly(thing.r);

			




	
	
	
		
 
    //         thing.r.r = assigned;

			




	
	
	
		
 
    //         return 0;

			




	
	
	
		
 
    //     }

			




	
	
	
		
 
    //     ",

			




	
	
	
		
 
    // ).for_function("test", |f| { f

			




	
	
	
		
 
    //     .for_variable("thing", |v| { v

			




	
	
	
		
 
    //         .assert_parser_type("auto")

			




	
	
	
		
 
    //         .assert_concrete_type("Node<s8,Node<s8,s8>>");

			




	
	
	
		
 
    //     });

			




	
	
	
		
 
    // });

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#[test]

			




	
	
	
		
 
fn test_enum_inference() {

			




	
	
	
		
 
    Tester::new_single_source_expect_ok(

			




	
	
	
		
 
        "no polymorphic vars",

			




	
	
	
		
 
        "

			




	
	
	
		
 
        enum Choice { A, B }

			




	
	
	
		
 
        test_instances() -> s32 {

			




	
	
	
		
 
            auto foo = Choice::A;

			




	
	
	
		
 
            auto bar = Choice::B;

			




	
	
	
		
 
            return 0;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        "

			




	
	
	
		
 
    ).for_function("test_instances", |f| { f

			




	
	
	
		
 
        .for_variable("foo", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("Choice");

			




	
	
	
		
 
        })

			




	
	
	
		
 
        .for_variable("bar", |v| { v

			




	
	
	
		
 
            .assert_parser_type("auto")

			




	
	
	
		
 
            .assert_concrete_type("Choice");

			




	
	
	
		
 
        });

			




	
	
	
		
 
    });

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








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