CSY/reowolf Changeset - 28df9835906f · Centrum Wiskunde & Informatica (CWI)

Changeset - 28df9835906f

Parent rev.

Child rev.

[Not reviewed]

0 10 0

MH - 4 years ago 2021-04-02 14:05:27
contact@maxhenger.nl

Reimplement namespaced identifier to support polymorphic args

This is somewhat of a temporary hack, as a namespaced identifier should
not really refer to types or polymorphic arguments. But we need a
tokenizer and a prepass to properly distinguish identifiers from types.
So it works, but error messages may be cryptic.

10 files changed with 374 insertions and 195 deletions:

src/protocol/ast.rs

110

src/protocol/ast_printer.rs

src/protocol/lexer.rs

src/protocol/parser/mod.rs

src/protocol/parser/symbol_table.rs

src/protocol/parser/type_resolver.rs

src/protocol/parser/type_table.rs

src/protocol/parser/utils.rs

src/protocol/parser/visitor_linker.rs

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -672,80 +672,155 @@ impl NamespacedIdentifierPart { @@
 /// An identifier with optional namespaces and polymorphic variables. Note that
 /// we allow each identifier to be followed by polymorphic arguments during the
 /// parsing phase (e.g. Foo<A,B>::Bar<C,D>::Qux). But in our current language
 /// implementation we can only have valid namespaced identifier that contain one
 /// set of polymorphic arguments at the appropriate position.
 /// TODO: @tokens Reimplement/rename once we have a tokenizer
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NamespacedIdentifier2 {
     pub position: InputPosition,
     pub value: Vec<u8>, // Full name as it resides in the input source
     pub poly_args: Vec<ParserTypeId>, // All poly args littered throughout the namespaced identifier
     pub parts: Vec<NamespacedIdentifierPart>, // Indices into value/poly_args
+}
 impl NamespacedIdentifier2 {
     /// Returns the identifier value without any of the specific polymorphic
     /// arguments.
     pub fn strip_poly_args(&self) -> Vec<u8> {
         debug_assert!(!self.parts.is_empty() && self.parts[0].is_identifier());
         let mut result = Vec::with_capacity(self.value.len());
         let mut iter = self.iter();
         let (first_ident, _) = iter.next().unwrap();
         result.extend(first_ident);
         for (ident, _) in iter.next() {
             result.push(b':');
             result.push(b':');
             result.extend(ident);
+        }
         result
+    }
     /// Returns an iterator of the elements in the namespaced identifier
     pub fn iter(&self) -> NamespacedIdentifier2Iter {
         return NamespacedIdentifier2Iter{
             identifier: self,
             element_idx: 0
+        }
+    }
     pub fn has_poly_args(&self) -> bool {
         return !self.poly_args.is_empty();
     pub fn get_poly_args(&self) -> Option<&[ParserTypeId]> {
         let has_poly_args = self.parts.iter().any(|v| !v.is_identifier());
         if has_poly_args {
             Some(&self.poly_args)
         } else {
             None
+        }
+    }
+}
 impl PartialEq for NamespacedIdentifier2 {
     fn eq(&self, other: &Self) -> bool {
         return self.value == other.value
     // Check if two namespaced identifiers match eachother when not considering
     // the polymorphic arguments
     pub fn matches_namespaced_identifier(&self, other: &Self) -> bool {
         let mut iter_self = self.iter();
         let mut iter_other = other.iter();
         loop {
             let val_self = iter_self.next();
             let val_other = iter_other.next();
             if val_self.is_some() != val_other.is_some() {
                 // One is longer than the other
                 return false;
+            }
             if val_self.is_none() {
                 // Both are none
                 return true;
+            }
             // Both are something
             let (val_self, _) = val_self.unwrap();
             let (val_other, _) = val_other.unwrap();
             if val_self != val_other { return false; }
+        }
+    }
+}
 impl PartialEq<Identifier> for NamespacedIdentifier2 {
     fn eq(&self, other: &Identifier) -> bool {
         return self.value == other.value
     // Check if the namespaced identifier matches an identifier when not
     // considering the polymorphic arguments
     pub fn matches_identifier(&self, other: &Identifier) -> bool {
         let mut iter = self.iter();
         let (first_ident, _) = iter.next().unwrap();
         if first_ident != other.value {
             return false;
+        }
         if iter.next().is_some() {
             return false;
+        }
         return true;
+    }
+}
 /// Iterator over elements of the namespaced identifier. The element index will
 /// only ever be at the start of an identifier element.
 #[derive(Debug)]
 pub struct NamespacedIdentifier2Iter<'a> {
     identifier: &'a NamespacedIdentifier2,
     element_idx: usize,
+}
 impl<'a> Iterator for NamespacedIdentifier2Iter<'a> {
     type Item = (&'a [u8], Option<&'a [ParserTypeId]>);
     fn next(&mut self) -> Option<Self::Item> {
         match self.get(self.element_idx) {
-            Some(result) => {
+            Some((ident, poly)) => {
                 self.element_idx += 1;
                 Some(result)
                 if poly.is_some() {
                     self.element_idx += 1;
+                }
                 Some((ident, poly))
             },
             None => None
+        }
+    }
+}
 impl<'a> NamespacedIdentifier2Iter<'a> {
     /// Returns number of parts iterated over, may not correspond to number of
     /// times one called `next()` because returning an identifier with
     /// polymorphic arguments increments the internal counter by 2.
     pub fn num_returned(&self) -> usize {
         return self.element_idx;
+    }
     pub fn num_remaining(&self) -> usize {
         return self.identifier.parts.len() - self.element_idx;
+    }
     pub fn returned_section(&self) -> &[u8] {
         if self.element_idx == 0 { return &self.identifier.value[0..0]; }
         let last_idx = match &self.identifier.parts[self.element_idx - 1] {
             NamespacedIdentifierPart::Identifier{end, ..} => *end,
             NamespacedIdentifierPart::PolyArgs{end, ..} => *end,
         };
         return &self.identifier.value[..last_idx as usize];
+    }
     /// Returns a specific element from the namespaced identifier
     pub fn get(&self, idx: usize) -> Option<<Self as Iterator>::Item> {
         if idx >= self.identifier.parts.len() {
             return None
+        }
         let cur_part = &self.identifier.parts[idx];
         let next_part = self.identifier.parts.get(idx);
+        let next_part = self.identifier.parts.get(idx + 1);
         let (ident_start, ident_end) = cur_part.as_identifier();
         let poly_slice = match next_part {
             Some(part) => match part {
                 NamespacedIdentifierPart::Identifier{..} => None,
                 NamespacedIdentifierPart::PolyArgs{start, end} => Some(
@@ @@ -758,18 +833,35 @@ impl<'a> NamespacedIdentifier2Iter<'a> { @@
         Some((
             &self.identifier.value[ident_start as usize..ident_end as usize],
             poly_slice
         ))
+    }
     pub fn prev(&self) -> Option<<Self as Iterator>::Item> {
         if self.element_idx == 0 {
     /// Returns the previously returend index into the parts array of the
     /// identifier.
     pub fn prev_idx(&self) -> Option<usize> {
         if self.element_idx == 0 {
             return None;
         };
         if self.identifier.parts[self.element_idx - 1].is_identifier() {
             return Some(self.element_idx - 1);
+        }
         self.get(self.element_idx - 1)
         // Previous part had polymorphic arguments, so the one before that must
         // be an identifier (if well formed)
         debug_assert!(self.element_idx >= 2 && self.identifier.parts[self.element_idx - 2].is_identifier());
         return Some(self.element_idx - 2)
+    }
     /// Returns the previously returned result from `next()`
     pub fn prev(&self) -> Option<<Self as Iterator>::Item> {
         match self.prev_idx() {
             None => None,
             Some(idx) => self.get(idx)
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NamespacedIdentifier {
     pub position: InputPosition,
@@ @@ -909,12 +1001,13 @@ pub struct ParserType { @@
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SymbolicParserType {
     // Phase 1: parser
     pub identifier: NamespacedIdentifier2,
     // Phase 2: validation/linking (for types in function/component bodies) and
     //  type table construction (for embedded types of structs/unions)
     pub poly_args2: Vec<ParserTypeId>, // taken from identifier or inferred
     pub variant: Option<SymbolicParserTypeVariant>
+}
 /// Specifies whether the symbolic type points to an actual user-defined type,
 /// or whether it points to a polymorphic argument within the definition (e.g.
 /// a defined variable `T var` within a function `int func<T>()`
@@ @@ -1130,12 +1223,13 @@ pub struct LiteralStructField { @@
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LiteralStruct {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier2,
     pub(crate) fields: Vec<LiteralStructField>,
     // Phase 2: linker
     pub(crate) poly_args2: Vec<ParserTypeId>, // taken from identifier
     pub(crate) definition: Option<DefinitionId>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LiteralEnum {
     // Phase 1: parser

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -234,13 +234,13 @@ impl ASTWriter { @@
         match import {
             Import::Module(import) => {
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportModule");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);
                 self.kv(indent2).with_s_key("Alias").with_ascii_val(&import.alias);
+                self.kv(indent2).with_s_key("Alias").with_ascii_val(&import.alias.value);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
             },
             Import::Symbols(import) => {
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportSymbol");
@@ @@ -252,14 +252,14 @@ impl ASTWriter { @@
                 self.kv(indent2).with_s_key("Symbols");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for symbol in &import.symbols {
                     self.kv(indent3).with_s_key("AliasedSymbol");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&symbol.name);
                     self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias);
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&symbol.name.value);
                     self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias.value);
                     self.kv(indent4).with_s_key("Definition")
                         .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));
+                }
+            }
+        }
+    }
@@ @@ -627,15 +627,15 @@ impl ASTWriter { @@
                     Literal::Integer(data) => { val.with_disp_val(data); },
                     Literal::Struct(data) => {
                         val.with_s_val("Struct");
                         let indent4 = indent3 + 1;
                         // Polymorphic arguments
-                        if !data.poly_args.is_empty() {
+                        if !data.poly_args2.is_empty() {
                             self.kv(indent3).with_s_key("PolymorphicArguments");
-                            for poly_arg in &data.poly_args {
+                            for poly_arg in &data.poly_args2 {
                                 self.kv(indent4).with_s_key("Argument")
                                     .with_custom_val(|v| write_parser_type(v, heap, &heap[*poly_arg]));
+                            }
+                        }
                         for field in &data.fields {
                     target.push_str(&format!("{{def: {}}}", def_id.index));
                 },
                 None => {
                     target.push_str("{None}");
+                }
+            }
-            embedded.extend(&symbolic.poly_args);
+            embedded.extend(&symbolic.poly_args2);
+        }
     };
     if !embedded.is_empty() {
         target.push_str("<");
         for (idx, embedded_id) in embedded.into_iter().enumerate() {

src/protocol/lexer.rs

➞

Show inline comments

@@ @@ -3,16 +3,16 @@ use crate::protocol::inputsource::*; @@
 const MAX_LEVEL: usize = 128;
 const MAX_NAMESPACES: u8 = 8; // only three levels are supported at the moment
 macro_rules! debug_log {
     ($format:literal) => {
-        enabled_debug_print!(false, "lexer", $format);
+        enabled_debug_print!(true, "lexer", $format);
     };
     ($format:literal, $($args:expr),*) => {
-        enabled_debug_print!(false, "lexer", $format, $($args),*);
+        enabled_debug_print!(true, "lexer", $format, $($args),*);
     };
+}
 macro_rules! debug_line {
     ($source:expr) => {
+        {
@@ @@ -91,12 +91,25 @@ fn lowercase(x: u8) -> u8 { @@
         x - b'A' + b'a'
     } else {
+        x
+    }
+}
 fn identifier_as_namespaced(identifier: Identifier) -> NamespacedIdentifier2 {
     let identifier_len = identifier.value.len();
     debug_assert!(identifier_len < u16::max_value() as usize);
     NamespacedIdentifier2{
         position: identifier.position,
         value: identifier.value,
         poly_args: Vec::new(),
         parts: vec![
             NamespacedIdentifierPart::Identifier{start: 0, end: identifier_len as u16}
         ],
+    }
+}
 pub struct Lexer<'a> {
     source: &'a mut InputSource,
     level: usize,
+}
 impl Lexer<'_> {
@@ @@ -475,12 +488,16 @@ impl Lexer<'_> { @@
         if self.has_reserved() {
             return Err(self.error_at_pos("Encountered reserved keyword"));
+        }
         // Consumes a part of the namespaced identifier, returns a boolean
         // indicating whether polymorphic arguments were specified.
         // TODO: Continue here: if we fail to properly parse the polymorphic
         //  arguments, assume we have reached the end of the namespaced
         //  identifier and are instead dealing with a less-than operator. Ugly?
         //  Yes. Needs tokenizer? Yes.
         fn consume_part(
             l: &mut Lexer, h: &mut Heap, ident: &mut NamespacedIdentifier2,
             backup_pos: &mut InputPosition
         ) -> Result<(), ParseError2> {
             // Consume identifier
             let ident_start = ident.value.len();
@@ @@ -627,13 +644,13 @@ impl Lexer<'_> { @@
                     ParseError2::new_error(&self.source, pos, msg)
                 })?;
             ParserTypeVariant::Output(poly_arg)
         } else {
             // Must be a symbolic type
             let identifier = self.consume_namespaced_identifier2(h)?;
             ParserTypeVariant::Symbolic(SymbolicParserType{identifier, variant: None})
+            ParserTypeVariant::Symbolic(SymbolicParserType{identifier, variant: None, poly_args2: Vec::new()})
         };
         // If the type was a basic type (not supporting polymorphic type
         // arguments), then we make sure the user did not specify any of them.
         let mut backup_pos = self.source.pos();
         if !parser_type_variant.supports_polymorphic_args() {
@@ @@ -1554,12 +1571,13 @@ impl Lexer<'_> { @@
         Ok(h.alloc_literal_expression(|this| LiteralExpression{
             this,
             position,
             value: Literal::Struct(LiteralStruct{
                 identifier,
                 fields,
                 poly_args2: Vec::new(),
                 definition: None,
             }),
             parent: ExpressionParent::None,
             concrete_type: Default::default()
         }))
+    }
@@ @@ -1587,14 +1605,16 @@ impl Lexer<'_> { @@
         return result;
+    }
     fn consume_call_expression(&mut self, h: &mut Heap) -> Result<CallExpressionId, ParseError2> {
         let position = self.source.pos();
         // Consume method identifier
         // TODO: @token Replace this conditional polymorphic arg parsing once we have a tokenizer.
         debug_log!("consume_call_expression: {}", debug_line!(self.source));
         let method;
         let mut consume_poly_args_explicitly = true;
         if self.has_keyword(b"get") {
             self.consume_keyword(b"get")?;
             method = Method::Get;
         } else if self.has_keyword(b"put") {
             self.consume_keyword(b"put")?;
             method = Method::Put;
@@ @@ -1606,18 +1626,23 @@ impl Lexer<'_> { @@
             method = Method::Create;
         } else {
             let identifier = self.consume_namespaced_identifier2(h)?;
             method = Method::Symbolic(MethodSymbolic{
                 identifier,
                 definition: None
             })
+        }
             });
             consume_poly_args_explicitly = false;
         };
         // Consume polymorphic arguments
         self.consume_whitespace(false)?;
         let poly_args = self.consume_polymorphic_args(h, true)?.unwrap_or_default();
         let poly_args = if consume_poly_args_explicitly {
             self.consume_whitespace(false)?;
             self.consume_polymorphic_args(h, true)?.unwrap_or_default()
         } else {
             Vec::new()
         };
         // Consume arguments to call
         self.consume_whitespace(false)?;
         let mut arguments = Vec::new();
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
@@ @@ -1647,13 +1672,16 @@ impl Lexer<'_> { @@
     fn consume_variable_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<VariableExpressionId, ParseError2> {
         let position = self.source.pos();
         debug_log!("consume_variable_expression: {}", debug_line!(self.source));
         let identifier = self.consume_namespaced_identifier()?;
         // TODO: @token Reimplement when tokenizer is implemented, prevent ambiguities
         let identifier = identifier_as_namespaced(self.consume_identifier()?);
         Ok(h.alloc_variable_expression(|this| VariableExpression {
             this,
             position,
             identifier,
             declaration: None,
             parent: ExpressionParent::None,
@@ @@ -1908,17 +1936,13 @@ impl Lexer<'_> { @@
             variable,
             next: None,
         });
         let variable_expr_id = h.alloc_variable_expression(|this| VariableExpression{
             this,
             position: identifier.position.clone(),
             identifier: NamespacedIdentifier {
                 position: identifier.position.clone(),
                 num_namespaces: 1,
                 value: identifier.value.clone(),
             },
             identifier: identifier_as_namespaced(identifier),
             declaration: None,
             parent: ExpressionParent::None,
             concrete_type: Default::default()
         });
         let assignment_expr_id = h.alloc_assignment_expression(|this| AssignmentExpression{
             this,

src/protocol/parser/mod.rs

➞

Show inline comments

@@ @@ -164,13 +164,13 @@ impl Parser { @@
                     let target_module_id = self.symbol_table.resolve_module(&import.module_name)
                         .expect("symbol import's module is resolved by symbol table");
                     import.module_id = Some(target_module_id);
                     for symbol in &mut import.symbols {
                         debug_assert!(symbol.definition_id.is_none(), "symbol import already resolved");
-                        let (_, target_definition_id) = self.symbol_table.resolve_symbol(module_root_id, &symbol.alias)
+                        let (_, target_definition_id) = self.symbol_table.resolve_identifier(module_root_id, &symbol.alias)
                             .expect("symbol import is resolved by symbol table")
                             .as_definition()
                             .expect("symbol import does not resolve to namespace symbol");
                         symbol.definition_id = Some(target_definition_id);
+                    }
+                }

src/protocol/parser/symbol_table.rs

➞

Show inline comments

@@ @@ -20,26 +20,13 @@ struct SymbolKey { @@
 impl SymbolKey {
     fn from_identifier(module_id: RootId, symbol: &Identifier) -> Self {
         Self{ module_id, symbol_name: symbol.value.clone() }
+    }
     fn from_namespaced_identifier(module_id: RootId, symbol: &NamespacedIdentifier2) -> Self {
         // Strip polymorpic arguments from the identifier
         let symbol_name = Vec::with_capacity(symbol.value.len());
         debug_assert!(symbol.parts.len() > 0 && symbol.parts[0].is_identifier());
         let mut iter = symbol.iter();
         let (first_ident, _) = iter.next().unwrap();
         symbol_name.extend(first_ident);
         for (ident, _) in iter {
             symbol_name.push(b':');
             symbol_name.extend(ident);
+        }
         Self{ module_id, symbol_name }
         Self{ module_id, symbol_name: symbol.strip_poly_args() }
+    }
+}
 pub(crate) enum Symbol {
     Namespace(RootId),
     Definition((RootId, DefinitionId)),
@@ @@ -323,20 +310,34 @@ impl SymbolTable { @@
     /// Resolves a module by its defined name
     pub(crate) fn resolve_module(&self, identifier: &Vec<u8>) -> Option<RootId> {
         self.module_lookup.get(identifier).map(|v| *v)
+    }
     pub(crate) fn resolve_symbol<'t>(
         &'t self, root_module_id: RootId, identifier: &[u8]
     ) -> Option<&'t SymbolValue> {
         let lookup_key = SymbolKey{ module_id: root_module_id, symbol_name: Vec::from(identifier) };
         self.symbol_lookup.get(&lookup_key)
+    }
     pub(crate) fn resolve_identifier<'t>(
         &'t self, root_module_id: RootId, identifier: &Identifier
     ) -> Option<&'t SymbolValue> {
         let lookup_key = SymbolKey::from_identifier(root_module_id, identifier);
         self.symbol_lookup.get(&lookup_key)
+    }
     /// Resolves a namespaced symbol. This method will go as far as possible in
     /// going to the right symbol. It will halt the search when:
     /// 1. Polymorphic arguments are encountered on the identifier.
     /// 2. A non-namespace symbol is encountered.
     /// 3. A part of the identifier couldn't be resolved to anything
     /// The returned iterator will always point to the next symbol (even if
     /// nothing was found)
-    pub(crate) fn resolve_namespaced_symbol<'t, 'i>(
+    pub(crate) fn resolve_namespaced_identifier<'t, 'i>(
         &'t self, root_module_id: RootId, identifier: &'i NamespacedIdentifier2
     ) -> (Option<&'t SymbolValue>, NamespacedIdentifier2Iter<'i>) {
         let mut iter = identifier.iter();
         let mut symbol: Option<&SymbolValue> = None;
         let mut within_module_id = root_module_id;

src/protocol/parser/type_resolver.rs

➞

Show inline comments

@@ @@ -2764,15 +2764,15 @@ impl TypeResolvingVisitor { @@
         &mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId,
     ) {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_struct();
         // Handle polymorphic arguments
-        let mut poly_vars = Vec::with_capacity(literal.poly_args.len());
+        let mut poly_vars = Vec::with_capacity(literal.poly_args2.len());
         let mut total_num_poly_parts = 0;
-        for poly_arg_type_id in literal.poly_args.clone() { // TODO: @performance
+        for poly_arg_type_id in literal.poly_args2.clone() { // TODO: @performance
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, poly_arg_type_id, true
             );
             total_num_poly_parts += inference_type.parts.len();
             poly_vars.push(inference_type);
+        }
@@ @@ -2928,13 +2928,13 @@ impl TypeResolvingVisitor { @@
                 },
                 PTV::Symbolic(symbolic) => {
                     debug_assert!(symbolic.variant.is_some(), "symbolic variant not yet determined");
                     match symbolic.variant.as_ref().unwrap() {
                         SymbolicParserTypeVariant::PolyArg(_, arg_idx) => {
                             let arg_idx = *arg_idx;
-                            debug_assert!(symbolic.poly_args.is_empty()); // TODO: @hkt
+                            debug_assert!(symbolic.poly_args2.is_empty()); // TODO: @hkt
                             if parser_type_in_body {
                                 // Polymorphic argument refers to definition's
                                 // polymorphic variables
                                 debug_assert!(arg_idx < self.poly_vars.len());
                                 debug_assert!(!self.poly_vars[arg_idx].has_marker());
@@ @@ -2957,20 +2957,20 @@ impl TypeResolvingVisitor { @@
                                 debug_assert!(definition.is_struct() || definition.is_enum()); // TODO: @function_ptrs
                                 let num_poly = match definition {
                                     Definition::Struct(v) => v.poly_vars.len(),
                                     Definition::Enum(v) => v.poly_vars.len(),
                                     _ => unreachable!(),
                                 };
-                                debug_assert_eq!(symbolic.poly_args.len(), num_poly);
+                                debug_assert_eq!(symbolic.poly_args2.len(), num_poly);
+                            }
                             infer_type.push(ITP::Instance(*definition_id, symbolic.poly_args.len()));
                             let mut poly_arg_idx = symbolic.poly_args.len();
                             infer_type.push(ITP::Instance(*definition_id, symbolic.poly_args2.len()));
                             let mut poly_arg_idx = symbolic.poly_args2.len();
                             while poly_arg_idx > 0 {
                                 poly_arg_idx -= 1;
-                                to_consider.push_front(symbolic.poly_args[poly_arg_idx]);
+                                to_consider.push_front(symbolic.poly_args2[poly_arg_idx]);
+                            }
+                        }
+                    }
+                }
+            }
+        }

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -106,13 +106,13 @@ impl std::fmt::Display for TypeClass { @@
 /// field, enum variant, etc.). Otherwise the polymorphic argument is just a
 /// marker and does not influence the bytesize of the type.
 pub struct DefinedType {
     pub(crate) ast_root: RootId,
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
-    pub(crate) poly_args: Vec<PolyArg>,
+    pub(crate) poly_vars: Vec<PolyVar>,
     pub(crate) is_polymorph: bool,
     pub(crate) is_pointerlike: bool,
     // TODO: @optimize
     pub(crate) monomorphs: Vec<Vec<ConcreteType>>,
+}
@@ @@ -124,13 +124,13 @@ impl DefinedType { @@
     pub(crate) fn has_any_monomorph(&self) -> bool {
         !self.monomorphs.is_empty()
+    }
     pub(crate) fn has_monomorph(&self, types: &Vec<ConcreteType>) -> bool {
-        debug_assert_eq!(self.poly_args.len(), types.len(), "mismatch in number of polymorphic types");
+        debug_assert_eq!(self.poly_vars.len(), types.len(), "mismatch in number of polymorphic types");
         for monomorph in &self.monomorphs {
             if monomorph == types { return true; }
+        }
         return false;
+    }
@@ @@ -141,15 +141,15 @@ pub enum DefinedTypeVariant { @@
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
+}
-pub struct PolyArg {
+pub struct PolyVar {
     identifier: Identifier,
-    /// Whether the polymorphic argument is used directly in the definition of
+    /// Whether the polymorphic variables is used directly in the definition of
     /// the type (not including bodies of function/component types)
     is_in_use: bool,
+}
 impl DefinedTypeVariant {
     pub(crate) fn type_class(&self) -> TypeClass {
@@ @@ -494,13 +494,13 @@ impl TypeTable { @@
             // Ensure union names and polymorphic args do not conflict
             self.check_identifier_collision(
                 ctx, root_id, &variants, |variant| &variant.identifier, "enum variant"
             )?;
             self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
-            let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
+            let mut poly_args = self.create_initial_poly_vars(&definition.poly_vars);
             for variant in &variants {
                 if let Some(embedded) = variant.parser_type {
                     self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, embedded)?;
+                }
+            }
             let is_polymorph = poly_args.iter().any(|arg| arg.is_in_use);
@@ @@ -510,13 +510,13 @@ impl TypeTable { @@
                 ast_root: root_id,
                 ast_definition: definition_id,
                 definition: DefinedTypeVariant::Union(UnionType{
                     variants,
                     tag_representation: Self::enum_tag_type(-1, tag_value),
                 }),
                 poly_args,
+                poly_vars: poly_args,
                 is_polymorph,
                 is_pointerlike: false, // TODO: @cyclic_types
                 monomorphs: Vec::new()
             });
         } else {
             // Implement as a regular enum
@@ @@ -562,13 +562,13 @@ impl TypeTable { @@
                 ast_root: root_id,
                 ast_definition: definition_id,
                 definition: DefinedTypeVariant::Enum(EnumType{
                     variants,
                     representation: Self::enum_tag_type(min_enum_value, max_enum_value)
                 }),
-                poly_args: self.create_initial_poly_args(&definition.poly_vars),
+                poly_vars: self.create_initial_poly_vars(&definition.poly_vars),
                 is_polymorph: false,
                 is_pointerlike: false,
                 monomorphs: Vec::new()
             });
+        }
@@ @@ -605,26 +605,26 @@ impl TypeTable { @@
         self.check_identifier_collision(
             ctx, root_id, &fields, |field| &field.identifier, "struct field"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct representation of polymorphic arguments
-        let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
+        let mut poly_args = self.create_initial_poly_vars(&definition.poly_vars);
         for field in &fields {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, field.parser_type)?;
+        }
         let is_polymorph = poly_args.iter().any(|arg| arg.is_in_use);
         self.lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Struct(StructType{
                 fields,
             }),
             poly_args,
+            poly_vars: poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
@@ @@ -673,13 +673,13 @@ impl TypeTable { @@
         self.check_identifier_collision(
             ctx, root_id, &arguments, |arg| &arg.identifier, "function argument"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
-        let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
+        let mut poly_args = self.create_initial_poly_vars(&definition.poly_vars);
         let return_type_id = definition.return_type;
         self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, return_type_id)?;
         for argument in &arguments {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, argument.parser_type)?;
+        }
@@ @@ -690,13 +690,13 @@ impl TypeTable { @@
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Function(FunctionType{
                 return_type,
                 arguments,
             }),
             poly_args,
+            poly_vars: poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
@@ @@ -737,13 +737,13 @@ impl TypeTable { @@
         self.check_identifier_collision(
             ctx, root_id, &arguments, |arg| &arg.identifier, "component argument"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
-        let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
+        let mut poly_args = self.create_initial_poly_vars(&definition.poly_vars);
         for argument in &arguments {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, argument.parser_type)?;
+        }
         let is_polymorph = poly_args.iter().any(|v| v.is_in_use);
@@ @@ -752,13 +752,13 @@ impl TypeTable { @@
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Component(ComponentType{
                 variant: component_variant,
                 arguments,
             }),
             poly_args,
+            poly_vars: poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
@@ @@ -854,20 +854,20 @@ impl TypeTable { @@
                 // don't care about monomorphs yet.
                 PTV::Symbolic(symbolic) => {
                     // Check if the symbolic type is one of the definition's
                     // polymorphic arguments. If so then we can halt the
                     // execution
                     for (poly_arg_idx, poly_arg) in poly_vars.iter().enumerate() {
-                        if symbolic.identifier == *poly_arg {
+                        if symbolic.identifier.matches_identifier(poly_arg) {
                             set_resolve_result(ResolveResult::PolyArg(poly_arg_idx));
                             continue 'resolve_loop;
+                        }
+                    }
                     // Lookup the definition in the symbol table
-                    let (symbol, mut ident_iter) = ctx.symbols.resolve_namespaced_symbol(root_id, &symbolic.identifier);
+                    let (symbol, mut ident_iter) = ctx.symbols.resolve_namespaced_identifier(root_id, &symbolic.identifier);
                     if symbol.is_none() {
                         return Err(ParseError2::new_error(
                             &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,
                             "Could not resolve type"
                         ))
+                    }
@@ @@ -962,16 +962,16 @@ impl TypeTable { @@
         // If here then all types in the embedded type's tree were resolved.
         debug_assert!(resolve_result.is_some(), "faulty logic in ParserType resolver");
         return Ok(resolve_result.unwrap())
+    }
-    fn create_initial_poly_args(&self, poly_args: &[Identifier]) -> Vec<PolyArg> {
+    fn create_initial_poly_vars(&self, poly_args: &[Identifier]) -> Vec<PolyVar> {
         poly_args
             .iter()
-            .map(|v| PolyArg{ identifier: v.clone(), is_in_use: false })
+            .map(|v| PolyVar{ identifier: v.clone(), is_in_use: false })
             .collect()
+    }
     /// This function modifies the passed `poly_args` by checking the embedded
     /// type tree. This should be called after `resolve_base_parser_type` is
     /// called on each node in this tree: we assume that each symbolic type was
@@ @@ -984,13 +984,13 @@ impl TypeTable { @@
     /// Finally, for all embedded types (which includes function/component
     /// arguments and return types) in type definitions we will modify the AST
     /// when the embedded type is a polymorphic variable or points to another
     /// user-defined type.
     fn check_and_resolve_embedded_type_and_modify_poly_args(
         &mut self, ctx: &mut TypeCtx,
-        type_definition_id: DefinitionId, poly_args: &mut [PolyArg],
+        type_definition_id: DefinitionId, poly_args: &mut [PolyVar],
         root_id: RootId, embedded_type_id: ParserTypeId,
     ) -> Result<(), ParseError2> {
         use ParserTypeVariant as PTV;
         self.parser_type_iter.clear();
         self.parser_type_iter.push_back(embedded_type_id);
@@ @@ -1010,80 +1010,75 @@ impl TypeTable { @@
                     // debug_assert!(false, "encountered illegal parser type during ParserType/PolyArg modification");
                     // unreachable!();
                 },
                 PTV::Array(subtype_id) |
                 PTV::Input(subtype_id) |
                 PTV::Output(subtype_id) => {
-                    // Outer type is fixed, but inner type might be symbolix
+                    // Outer type is fixed, but inner type might be symbolic
                     self.parser_type_iter.push_back(*subtype_id);
                 },
                 PTV::Symbolic(symbolic) => {
                     for (poly_arg_idx, poly_arg) in poly_args.iter_mut().enumerate() {
-                        if symbolic.identifier == poly_arg.identifier {
+                        if symbolic.identifier.matches_identifier(&poly_arg.identifier) {
                             poly_arg.is_in_use = true;
                             // TODO: If we allow higher-kinded types in the future,
                             //  then we can't continue here, but must resolve the
                             //  polyargs as well
-                            debug_assert!(!symbolic.identifier.has_poly_args(), "got polymorphic arguments to a polymorphic variable");
+                            debug_assert!(symbolic.identifier.get_poly_args().is_none(), "got polymorphic arguments to a polymorphic variable");
                             debug_assert!(symbolic.variant.is_none(), "symbolic parser type's variant already resolved");
                             symbolic.variant = Some(SymbolicParserTypeVariant::PolyArg(type_definition_id, poly_arg_idx));
                             continue 'type_loop;
+                        }
+                    }
                     // Must match a definition
-                    let (symbol, _) = ctx.symbols.resolve_namespaced_symbol(root_id, &symbolic.identifier);
+                    let (symbol, ident_iter) = ctx.symbols.resolve_namespaced_identifier(root_id, &symbolic.identifier);
                     debug_assert!(symbol.is_some(), "could not resolve symbolic parser type when determining poly args");
-                    let (symbol, ident_iter) = symbol.unwrap();
                     let symbol = symbol.unwrap();
                     debug_assert_eq!(ident_iter.num_remaining(), 0, "no exact symbol match when determining poly args");
                     let (_root_id, definition_id) = symbol.as_definition().unwrap();
                     // Must be a struct, enum, or union, we checked this
                     let defined_type = self.lookup.get(&definition_id).unwrap();
                     let (_, poly_args) = ident_iter.prev().unwrap();
                     let poly_args = poly_args.unwrap_or_default();
                     if cfg!(debug_assertions) {
                         // Make sure type class is correct
                         // Everything here should already be checked in
                         // `resolve_base_parser_type`.
                         let type_class = defined_type.definition.type_class();
                         debug_assert!(
                             type_class == TypeClass::Struct || type_class == TypeClass::Enum || type_class == TypeClass::Union,
                             "embedded type's class is not struct, enum or union"
                         );
                         // Make sure polymorphic arguments occurred at the end
                         let num_poly = symbolic.identifier.iter()
                             .map(|(_, v)| v)
                             .filter(|v| v.is_some())
                             .count();
                         debug_assert!(num_poly <= 1, "more than one section with polymorphic arguments");
                         if num_poly == 1 {
                             let (_, poly_args) = symbolic.identifier.iter().last().unwrap();
                             debug_assert!(poly_args.is_some(), "got poly args, but not at end of identifier");
+                        }
                         debug_assert_eq!(poly_args.len(), symbolic.identifier.poly_args.len());
+                    }
-                    if symbolic.poly_args.len() != defined_type.poly_args.len() {
+                    if poly_args.len() != defined_type.poly_vars.len() {
                         // Mismatch in number of polymorphic arguments. This is
                         // not allowed in type definitions (no inference is
                         // allowed within type definitions, only in bodies of
                         // functions/components).
                         let module_source = &ctx.modules[root_id.index as usize].source;
-                        let number_args_msg = if defined_type.poly_args.is_empty() {
+                        let number_args_msg = if defined_type.poly_vars.is_empty() {
                             String::from("is not polymorphic")
                         } else {
-                            format!("accepts {} polymorphic arguments", defined_type.poly_args.len())
+                            format!("accepts {} polymorphic arguments", defined_type.poly_vars.len())
                         };
                         return Err(ParseError2::new_error(
                             module_source, symbolic.identifier.position,
                             &format!(
                                 "The type '{}' {}, but {} polymorphic arguments were provided",
                                 String::from_utf8_lossy(&symbolic.identifier.value),
                                 number_args_msg, symbolic.poly_args.len()
                                 String::from_utf8_lossy(&symbolic.identifier.strip_poly_args()),
                                 number_args_msg, poly_args.len()
+                            )
                         ));
+                    }
-                    self.parser_type_iter.extend(&symbolic.poly_args);
                     self.parser_type_iter.extend(poly_args);
                     debug_assert!(symbolic.variant.is_none(), "symbolic parser type's variant already resolved");
                     symbolic.variant = Some(SymbolicParserTypeVariant::Definition(definition_id));
+                }
+            }
+        }

src/protocol/parser/utils.rs

➞

Show inline comments

@@ @@ -3,27 +3,27 @@ use crate::protocol::inputsource::*; @@
 use super::symbol_table::*;
 use super::type_table::*;
 /// Utility result type.
 pub(crate) enum FindTypeResult<'t, 'i> {
     // Found the type exactly
     Found(&'t DefinedType),
+    Found((&'t DefinedType, NamespacedIdentifier2Iter<'i>)),
     // Could not match symbol
     SymbolNotFound{ident_pos: InputPosition},
     // Matched part of the namespaced identifier, but not completely
-    SymbolPartial{ident_pos: InputPosition, symbol_pos: InputPosition, ident_iter: NamespacedIdentifierIter<'i>},
+    SymbolPartial{ident_pos: InputPosition, symbol_pos: InputPosition, ident_iter: NamespacedIdentifier2Iter<'i>},
     // Symbol matched, but points to a namespace/module instead of a type
     SymbolNamespace{ident_pos: InputPosition, symbol_pos: InputPosition},
+}
 // TODO: @cleanup Find other uses of this pattern
 impl<'t, 'i> FindTypeResult<'t, 'i> {
     /// Utility function to transform the `FindTypeResult` into a `Result` where
     /// `Ok` contains the resolved type, and `Err` contains a `ParseError` which
     /// can be readily returned. This is the most common use.
     pub(crate) fn as_parse_error(self, module_source: &InputSource) -> Result<&'t DefinedType, ParseError2> {
+    pub(crate) fn as_parse_error(self, module_source: &InputSource) -> Result<(&'t DefinedType, NamespacedIdentifier2Iter<'i>), ParseError2> {
         match self {
             FindTypeResult::Found(defined_type) => Ok(defined_type),
             FindTypeResult::SymbolNotFound{ident_pos} => {
                 Err(ParseError2::new_error(
                     module_source, ident_pos,
                     "Could not resolve this identifier to a symbol"
@@ @@ -56,22 +56,22 @@ impl<'t, 'i> FindTypeResult<'t, 'i> { @@
 /// Attempt to find the type pointer to by a (root, identifier) combination. The
 /// type must match exactly (no parts in the namespace iterator remaining) and
 /// must be a type, not a namespace.
 pub(crate) fn find_type_definition<'t, 'i>(
     symbols: &SymbolTable, types: &'t TypeTable,
-    root_id: RootId, identifier: &'i NamespacedIdentifier
+    root_id: RootId, identifier: &'i NamespacedIdentifier2
 ) -> FindTypeResult<'t, 'i> {
     // Lookup symbol
-    let symbol = symbols.resolve_namespaced_symbol(root_id, identifier);
+    let (symbol, ident_iter) = symbols.resolve_namespaced_identifier(root_id, identifier);
     if symbol.is_none() {
         return FindTypeResult::SymbolNotFound{ident_pos: identifier.position};
+    }
     // Make sure we resolved it exactly
-    let (symbol, ident_iter) = symbol.unwrap();
     let symbol = symbol.unwrap();
     if ident_iter.num_remaining() != 0 {
         return FindTypeResult::SymbolPartial{
             ident_pos: identifier.position,
             symbol_pos: symbol.position,
             ident_iter
         };
@@ @@ -86,10 +86,91 @@ pub(crate) fn find_type_definition<'t, 'i>( @@
         },
         Symbol::Definition((_, definition_id)) => {
             // If this function is called correctly, then we should always be
             // able to match the definition's ID to an entry in the type table.
             let definition = types.get_base_definition(&definition_id);
             debug_assert!(definition.is_some());
             FindTypeResult::Found(definition.unwrap())
+            FindTypeResult::Found((definition.unwrap(), ident_iter))
+        }
+    }
+}
 pub(crate) enum MatchPolymorphResult<'t> {
     Matching,
     InferAll(usize),
     Mismatch{defined_type: &'t DefinedType, ident_position: InputPosition, num_specified: usize},
     NoneExpected{defined_type: &'t DefinedType, ident_position: InputPosition, num_specified: usize},
+}
 impl<'t> MatchPolymorphResult<'t> {
     pub(crate) fn as_parse_error(self, heap: &Heap, module_source: &InputSource) -> Result<usize, ParseError2> {
         match self {
             MatchPolymorphResult::Matching => Ok(0),
             MatchPolymorphResult::InferAll(count) => {
                 debug_assert!(count > 0);
                 Ok(count)
             },
             MatchPolymorphResult::Mismatch{defined_type, ident_position, num_specified} => {
                 let type_identifier = heap[defined_type.ast_definition].identifier();
                 let args_name = if defined_type.poly_vars.len() == 1 {
                     "argument"
                 } else {
                     "arguments"
                 };
                 return Err(ParseError2::new_error(
                     module_source, ident_position,
                     &format!(
                         "expected {} polymorphic {} (or none, to infer them) for the type {}, but {} were specified",
                         defined_type.poly_vars.len(), args_name,
                         &String::from_utf8_lossy(&type_identifier.value),
                         num_specified
+                    )
                 ))
             },
             MatchPolymorphResult::NoneExpected{defined_type, ident_position, ..} => {
                 let type_identifier = heap[defined_type.ast_definition].identifier();
                 return Err(ParseError2::new_error(
                     module_source, ident_position,
                     &format!(
                         "the type {} is not polymorphic",
                         &String::from_utf8_lossy(&type_identifier.value)
+                    )
                 ))
+            }
+        }
+    }
+}
 /// Attempt to match the polymorphic arguments to the number of polymorphic
 /// variables in the definition.
 pub(crate) fn match_polymorphic_args_to_vars<'t>(
     defined_type: &'t DefinedType, poly_args: Option<&[ParserTypeId]>, ident_position: InputPosition
 ) -> MatchPolymorphResult<'t> {
     if defined_type.poly_vars.is_empty() {
         // No polymorphic variables on type
         if poly_args.is_some() {
             return MatchPolymorphResult::NoneExpected{
                 defined_type,
                 ident_position,
                 num_specified: poly_args.unwrap().len()};
+        }
     } else {
         // Polymorphic variables on type
         let has_specified = poly_args.map_or(false, |a| a.len() != 0);
         if !has_specified {
             // Implicitly infer all of the polymorphic arguments
             return MatchPolymorphResult::InferAll(defined_type.poly_vars.len());
+        }
         let num_specified = poly_args.unwrap().len();
         if num_specified != defined_type.poly_vars.len() {
             return MatchPolymorphResult::Mismatch{
                 defined_type,
                 ident_position,
                 num_specified,
             };
+        }
+    }
     MatchPolymorphResult::Matching
+}
@@ \ No newline at end of file @@

src/protocol/parser/visitor_linker.rs

➞

Show inline comments

@@ @@ -1072,31 +1072,31 @@ impl ValidityAndLinkerVisitor { @@
                         DefinitionType::Composite(id) => (id.upcast(), &ctx.heap[id].poly_vars),
                         DefinitionType::Function(id) => (id.upcast(), &ctx.heap[id].poly_vars),
                     };
                     let mut symbolic_variant = None;
                     for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {
-                        if symbolic.identifier == *poly_var {
+                        if symbolic.identifier.matches_identifier(poly_var) {
                             // Type refers to a polymorphic variable.
                             // TODO: @hkt Maybe allow higher-kinded types?
-                            if !symbolic.poly_args.is_empty() {
+                            if symbolic.identifier.get_poly_args().is_some() {
                                 return Err(ParseError2::new_error(
                                     &ctx.module.source, symbolic.identifier.position,
                                     "Polymorphic arguments to a polymorphic variable (higher-kinded types) are not allowed (yet)"
                                 ));
+                            }
                             symbolic_variant = Some(SymbolicParserTypeVariant::PolyArg(definition_id, poly_var_idx));
+                        }
+                    }
                     if let Some(symbolic_variant) = symbolic_variant {
-                        // Identifier points to a symbolic type
+                        // Identifier points to a polymorphic argument
                         (symbolic.identifier.position, symbolic_variant, 0)
                     } else {
                         // Must be a user-defined type, otherwise an error
                         let found_type = find_type_definition(
+                        let (found_type, ident_iter) = find_type_definition(
                             &ctx.symbols, &ctx.types, ctx.module.root_id, &symbolic.identifier
                         ).as_parse_error(&ctx.module.source)?;
                         // TODO: @function_ptrs: Allow function pointers at some
                         //  point in the future
                         if found_type.definition.type_class().is_proc_type() {
@@ @@ -1110,46 +1110,28 @@ impl ValidityAndLinkerVisitor { @@
+                        }
                         // If the type is polymorphic then we have two cases: if
                         // the programmer did not specify the polyargs then we
                         // assume we're going to infer all of them. Otherwise we
                         // make sure that they match in count.
                         if !found_type.poly_args.is_empty() && symbolic.poly_args.is_empty() {
                             // All inferred
+                            (
                                 symbolic.identifier.position,
                                 SymbolicParserTypeVariant::Definition(found_type.ast_definition),
                                 found_type.poly_args.len()
+                            )
                         } else if symbolic.poly_args.len() != found_type.poly_args.len() {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 &format!(
                                     "Expected {} polymorphic arguments (or none, to infer them), but {} were specified",
                                     found_type.poly_args.len(), symbolic.poly_args.len()
+                                )
                             ))
                         } else {
                             // If here then the type is not polymorphic, or all
                             // types are properly specified by the user.
                             for specified_poly_arg in &symbolic.poly_args {
                                 self.parser_type_buffer.push(*specified_poly_arg);
+                            }
+                            (
                                 symbolic.identifier.position,
                                 SymbolicParserTypeVariant::Definition(found_type.ast_definition),
+                            )
+                        }
                         let (_, poly_args) = ident_iter.prev().unwrap();
                         let num_to_infer = match_polymorphic_args_to_vars(
                             found_type, poly_args, symbolic.identifier.position
                         ).as_parse_error(&ctx.heap, &ctx.module.source)?;
+                        (
                             symbolic.identifier.position,
                             SymbolicParserTypeVariant::Definition(found_type.ast_definition),
                             num_to_infer
+                        )
+                    }
+                }
             };
             // If here then type is symbolic, perform a mutable borrow to set
             // the target of the symbolic type.
             // If here then type is symbolic, perform a mutable borrow (and do
             // some rust shenanigans) to set the required information.
             for _ in 0..num_inferred_to_allocate {
                 // TODO: @hack, not very user friendly to manually allocate
                 //  `inferred` ParserTypes with the InputPosition of the
                 //  symbolic type's identifier.
                 // We reuse the `parser_type_buffer` to temporarily store these
                 // and we'll take them out later
@@ @@ -1158,14 +1140,19 @@ impl ValidityAndLinkerVisitor { @@
                     pos: symbolic_pos,
                     variant: ParserTypeVariant::Inferred,
                 }));
+            }
             if let PTV::Symbolic(symbolic) = &mut ctx.heap[parser_type_id].variant {
                 for _ in 0..num_inferred_to_allocate {
                     symbolic.poly_args.push(self.parser_type_buffer.pop().unwrap());
                 if num_inferred_to_allocate != 0 {
                     symbolic.poly_args2.reserve(num_inferred_to_allocate);
                     for _ in 0..num_inferred_to_allocate {
                         symbolic.poly_args2.push(self.parser_type_buffer.pop().unwrap());
+                    }
                 } else if !symbolic.identifier.poly_args.is_empty() {
                     symbolic.poly_args2.extend(&symbolic.identifier.poly_args)
+                }
                 symbolic.variant = Some(symbolic_variant);
             } else {
                 unreachable!();
+            }
+        }
@@ @@ -1249,20 +1236,15 @@ impl ValidityAndLinkerVisitor { @@
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
-    fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier) -> Result<VariableId, ParseError2> {
+    fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier2) -> Result<VariableId, ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         debug_assert!(identifier.num_namespaces > 0);
         // TODO: Update once globals are possible as well
         if identifier.num_namespaces > 1 {
             todo!("Implement namespaced constant seeking")
+        }
         debug_assert!(identifier.parts.len() == 1, "implement namespaced seeking of target associated with identifier");
         // TODO: May still refer to an alias of a global symbol using a single
         //  identifier in the namespace.
         // No need to use iterator over namespaces if here
         let mut scope = self.cur_scope.as_ref().unwrap();
@@ @@ -1270,13 +1252,13 @@ impl ValidityAndLinkerVisitor { @@
             debug_assert!(scope.is_block());
             let block = &ctx.heap[scope.to_block()];
             for local_id in &block.locals {
                 let local = &ctx.heap[*local_id];
-                if local.relative_pos_in_block < relative_pos && local.identifier == *identifier {
+                if local.relative_pos_in_block < relative_pos && identifier.matches_identifier(&local.identifier) {
                     return Ok(local_id.upcast());
+                }
+            }
             debug_assert!(block.parent_scope.is_some());
             scope = block.parent_scope.as_ref().unwrap();
@@ @@ -1284,13 +1266,13 @@ impl ValidityAndLinkerVisitor { @@
                 // Definition scope, need to check arguments to definition
                 match scope {
                     Scope::Definition(definition_id) => {
                         let definition = &ctx.heap[*definition_id];
                         for parameter_id in definition.parameters() {
                             let parameter = &ctx.heap[*parameter_id];
-                            if parameter.identifier == *identifier {
+                            if identifier.matches_identifier(&parameter.identifier) {
                                 return Ok(parameter_id.upcast());
+                            }
+                        }
                     },
                     _ => unreachable!(),
+                }
@@ @@ -1388,16 +1370,16 @@ impl ValidityAndLinkerVisitor { @@
     /// Finds a particular symbol in the symbol table which must correspond to
     /// a definition of a particular type.
     // Note: root_id, symbols and types passed in explicitly to prevent
     //  borrowing errors
     fn find_symbol_of_type<'a>(
         &self, source: &InputSource, root_id: RootId, symbols: &SymbolTable, types: &'a TypeTable,
-        identifier: &NamespacedIdentifier, expected_type_class: TypeClass
+        identifier: &NamespacedIdentifier2, expected_type_class: TypeClass
     ) -> Result<&'a DefinedType, ParseError2> {
         // Find symbol associated with identifier
         let find_result = find_type_definition(symbols, types, root_id, identifier)
+        let (find_result, _) = find_type_definition(symbols, types, root_id, identifier)
             .as_parse_error(source)?;
         let definition_type_class = find_result.definition.type_class();
         if expected_type_class != definition_type_class {
             return Err(ParseError2::new_error(
                 source, identifier.position,
@@ @@ -1494,12 +1476,20 @@ impl ValidityAndLinkerVisitor { @@
         Ok(target)
+    }
     // TODO: @cleanup, merge with function below
     fn visit_call_poly_args(&mut self, ctx: &mut Ctx, call_id: CallExpressionId) -> VisitorResult {
         // TODO: @token Revisit when tokenizer is implemented
         let call_expr = &mut ctx.heap[call_id];
         if let Method::Symbolic(symbolic) = &mut call_expr.method {
             if let Some(poly_args) = symbolic.identifier.get_poly_args() {
                 call_expr.poly_args.extend(poly_args);
+            }
+        }
         let call_expr = &ctx.heap[call_id];
         // Determine the polyarg signature
         let num_expected_poly_args = match &call_expr.method {
             Method::Create => {
@@ @@ -1511,12 +1501,15 @@ impl ValidityAndLinkerVisitor { @@
             },
             Method::Put => {
+            }
             Method::Symbolic(symbolic) => {
                 // Retrieve type and make sure number of specified polymorphic
                 // arguments is correct
                 let definition = &ctx.heap[symbolic.definition.unwrap()];
                 match definition {
                     Definition::Function(definition) => definition.poly_vars.len(),
                     Definition::Component(definition) => definition.poly_vars.len(),
                     _ => {
                         debug_assert!(false, "expected function or component definition while visiting call poly args");
@@ @@ -1568,74 +1561,65 @@ impl ValidityAndLinkerVisitor { @@
+                )
             ));
+        }
+    }
     fn visit_literal_poly_args(&mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId) -> VisitorResult {
         // TODO: @token Revisit when tokenizer is implemented
         let literal_expr = &mut ctx.heap[lit_id];
         if let Literal::Struct(literal) = &mut literal_expr.value {
             literal.poly_args2.extend(&literal.identifier.poly_args);
+        }
         let literal_expr = &ctx.heap[lit_id];
         let literal_pos = literal_expr.position;
-        let (num_specified, num_expected) = match &literal_expr.value {
+        let num_poly_args_to_infer = match &literal_expr.value {
             Literal::Null | Literal::False | Literal::True |
             Literal::Character(_) | Literal::Integer(_) => {
                 // Not really an error, but a programmer error as we're likely
                 // doing work twice
                 debug_assert!(false, "called visit_literal_poly_args on a non-polymorphic literal");
                 unreachable!();
             },
             Literal::Struct(literal) => {
                 let definition = &ctx.heap[literal.definition.unwrap()];
                 let num_expected = match definition {
                     Definition::Struct(definition) => definition.poly_vars.len(),
                     _ => {
                         debug_assert!(false, "expected struct literal while visiting literal poly args");
                         unreachable!();
+                    }
                 };
                 let num_specified = literal.poly_args.len();
                 // Visit all embedded parser types (they might not be of the
                 // correct length, but we check this below)
                 // Retrieve type and make sure number of specified polymorphic
                 // arguments is correct.
                 let defined_type = ctx.types.get_base_definition(literal.definition.as_ref().unwrap())
                     .unwrap();
                 let maybe_poly_args = literal.identifier.get_poly_args();
                 let num_to_infer = match_polymorphic_args_to_vars(
                     defined_type, maybe_poly_args, literal.identifier.position
                 ).as_parse_error(&ctx.heap, &ctx.module.source)?;
                 // Visit all specified parser types
                 let old_num_types = self.parser_type_buffer.len();
-                self.parser_type_buffer.extend(&literal.poly_args);
+                self.parser_type_buffer.extend(&literal.poly_args2);
                 while self.parser_type_buffer.len() > old_num_types {
                     let parser_type_id = self.parser_type_buffer.pop().unwrap();
                     self.visit_parser_type(ctx, parser_type_id)?;
+                }
                 self.parser_type_buffer.truncate(old_num_types);
-                (num_specified, num_expected)
+                num_to_infer
+            }
         };
         if num_specified == 0 {
             // None are specified
             if num_expected != 0 {
                 // So assumed to all be inferred
                 for _ in 0..num_expected {
                     self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType{
                         this, pos: literal_pos, variant: ParserTypeVariant::Inferred
                     }));
+                }
         if num_poly_args_to_infer != 0 {
             for _ in 0..num_poly_args_to_infer {
                 self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType{
                     this, pos: literal_pos, variant: ParserTypeVariant::Inferred
                 }));
+            }
                 let literal = match &mut ctx.heap[lit_id].value {
                     Literal::Struct(literal) => literal,
                     _ => unreachable!(),
                 };
                 literal.poly_args.reserve(num_expected);
                 for _ in 0..num_expected {
                     literal.poly_args.push(self.parser_type_buffer.pop().unwrap());
+                }
             let literal = match &mut ctx.heap[lit_id].value {
                 Literal::Struct(literal) => literal,
                 _ => unreachable!(),
             };
             literal.poly_args2.reserve(num_poly_args_to_infer);
             for _ in 0..num_poly_args_to_infer {
                 literal.poly_args2.push(self.parser_type_buffer.pop().unwrap());
+            }
         } else if num_specified != num_expected {
             // Incorrect specification of poly args
             return Err(ParseError2::new_error(
                 &ctx.module.source, literal_pos,
                 &format!(
                     "Expected {} polymorphic arguments (or none, to infer them), but {} were specified",
                     num_expected, num_specified
+                )
             ))
+        }
         Ok(())
+    }
+}
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

             buffer.push_str("out<");
             serialize_parser_type(buffer, heap, *sub_id);
             buffer.push('>');
         },
         PTV::Symbolic(symbolic) => {
             buffer.push_str(&String::from_utf8_lossy(&symbolic.identifier.value));
-            if symbolic.poly_args.len() > 0 {
+            if symbolic.poly_args2.len() > 0 {
                 buffer.push('<');
-                for (poly_idx, poly_arg) in symbolic.poly_args.iter().enumerate() {
+                for (poly_idx, poly_arg) in symbolic.poly_args2.iter().enumerate() {
                     if poly_idx != 0 { buffer.push(','); }
                     serialize_parser_type(buffer, heap, *poly_arg);
+                }
                 buffer.push('>');
+            }
+        }

0 comments (0 inline, 0 general)