CSY/reowolf Changeset - 012b61623f5a · Centrum Wiskunde & Informatica (CWI)

Changeset - 012b61623f5a

Parent rev.

Child rev.

[Not reviewed]

6 21 2

MH - 4 years ago 2021-04-30 19:01:30
contact@maxhenger.nl

WIP on fixing a lot of compiler errors

12 files changed:

src/collections/scoped_buffer.rs

src/collections/string_pool.rs

src/ffi/pseudo_socket_api.rs

src/lib.rs

src/protocol/ast.rs

src/protocol/ast_printer.rs

152

151

src/protocol/eval.rs

src/protocol/input_source.rs

src/protocol/inputsource.rs

305

src/protocol/lexer.rs

2670

src/protocol/mod.rs

src/protocol/parser/depth_visitor.rs

596

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)

src/collections/scoped_buffer.rs

➞

Show inline comments

@@ @@ -92,19 +92,19 @@ impl<T: Sized + Copy> ScopedSection<T> { @@
+}
 impl<T: Sized + Copy> 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 + Copy> Drop for ScopedBuffer<T> {
+impl<T: Sized + Copy> Drop for ScopedSection<T> {
     fn drop(&mut self) {
         // Make sure that the data was actually taken out of the scoped section
         let vec = unsafe{&*self.inner};
         debug_assert_eq!(vec.len(), self.start_size as usize);
+    }
+}
@@ \ No newline at end of file @@

src/collections/string_pool.rs

➞

Show inline comments

 use std::ptr::null_mut;
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
-const SLAB_SIZE: usize = u16::max_value() as usize;
+const SLAB_SIZE: usize = u16::MAX as usize;
 #[derive(Clone)]
 pub struct StringRef<'a> {
     data: *const u8,
     length: usize,
     _phantom: PhantomData<&'a [u8]>,
+}
 impl<'a> StringRef<'a> {
     /// `new` constructs a new StringRef whose data is not owned by the
     /// `StringPool`, hence cannot have a `'static` lifetime.
     pub(crate) fn new(data: &'a [u8]) -> StringRef<'a> {
@@ @@ -30,36 +29,36 @@ impl<'a> StringRef<'a> { @@
             let slice = std::slice::from_raw_parts::<'a, u8>(self.data, self.length);
             std::str::from_utf8_unchecked(slice)
+        }
+    }
     pub fn as_bytes(&self) -> &'a [u8] {
         unsafe {
             std::slice::from_raw_parts::<'a, u8>(self.data, self.length)
+        }
+    }
+}
 impl PartialEq for StringRef {
+impl PartialEq for StringRef<'_> {
     fn eq(&self, other: &StringRef) -> bool {
         self.as_str() == other.as_str()
+    }
+}
 impl Eq for StringRef {}
+impl Eq for StringRef<'_> {}
 impl Hash for StringRef {
+impl Hash for StringRef<'_> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         unsafe{
-            state.write(std::slice::from_raw_parts(self.data, self.length));
+            state.write(self.as_bytes());
+        }
+    }
+}
 struct StringPoolSlab {
     prev: *mut StringPoolSlab,
     data: Vec<u8>,
     remaining: usize,
+}
 impl StringPoolSlab {
     fn new(prev: *mut StringPoolSlab) -> Self {

src/ffi/pseudo_socket_api.rs

➞

Show inline comments

@@ @@ -52,49 +52,53 @@ impl FdAllocator { @@
         if let Some(fd) = self.next {
             self.next = fd.checked_add(1);
             return fd;
+        }
         panic!("No more Connector FDs to allocate!")
+    }
     fn free(&mut self, fd: c_int) {
         self.freed.push(fd);
+    }
+}
 lazy_static::lazy_static! {
     static ref CC_MAP: RwLock<CcMap> = Default::default();
     static ref TRIVIAL_PD: Arc<ProtocolDescription> = {
         Arc::new(ProtocolDescription::parse(b"").unwrap())
     };
+}
 impl ConnectorComplex {
     fn try_become_connected(&mut self) {
         match self.phased {
             ConnectorComplexPhased::Setup { local: Some(local), peer: Some(peer) } => {
                 // complete setup
                 let [putter, getter] =
                     self.connector.new_udp_mediator_component(local, peer).unwrap();
                 self.connector.connect(None).unwrap();
                 self.phased = ConnectorComplexPhased::Communication { putter, getter }
+            }
             _ => {} // setup incomplete
+        }
+    }
+}
 /////////////////////////////////
 #[no_mangle]
 pub extern "C" fn rw_socket(_domain: c_int, _type: c_int, _protocol: c_int) -> c_int {
     // get writer lock
     let mut w = if let Ok(w) = CC_MAP.write() { w } else { return RW_LOCK_POISONED };
     let fd = w.fd_allocator.alloc();
     let cc = ConnectorComplex {
         connector: Connector::new(
             Box::new(crate::DummyLogger),
-            crate::TRIVIAL_PD.clone(),
             TRIVIAL_PD.clone(),
             Connector::random_id(),
         ),
         phased: ConnectorComplexPhased::Setup { local: None, peer: None },
     };
     w.fd_to_cc.insert(fd, Mutex::new(cc));
     fd
+}
 #[no_mangle]
 pub extern "C" fn rw_close(fd: c_int, _how: c_int) -> c_int {
     // ignoring HOW
     // get writer lock
     let mut w = if let Ok(w) = CC_MAP.write() { w } else { return RW_LOCK_POISONED };

src/lib.rs

➞

Show inline comments

 #[macro_use]
 mod macros;
 mod common;
 mod protocol;
 mod runtime;
 mod collections;
 pub use common::{ConnectorId, EndpointPolarity, Payload, Polarity, PortId};
-pub use protocol::{ProtocolDescription, TRIVIAL_PD};
 pub use protocol::ProtocolDescription;
 pub use runtime::{error, Connector, DummyLogger, FileLogger, VecLogger};
 // TODO: Remove when not benchmarking
-pub use protocol::inputsource::InputSource;
+pub use protocol::input_source::InputSource;
 pub use protocol::ast::Heap;
 pub use protocol::lexer::Lexer;
 #[cfg(feature = "ffi")]
 pub mod ffi;

src/protocol/ast.rs

➞

Show inline comments

 // TODO: @cleanup, rigorous cleanup of dead code and silly object-oriented
 //  trait impls where I deem them unfit.
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::{Index, IndexMut};
 use super::arena::{Arena, Id};
 use crate::collections::StringRef;
 use crate::protocol::inputsource::*;
 use crate::protocol::input_source2::{InputPosition2, InputSpan};
 use crate::protocol::input_source::InputSpan;
 /// Helper macro that defines a type alias for a AST element ID. In this case
 /// only used to alias the `Id<T>` types.
 macro_rules! define_aliased_ast_id {
     // Variant where we just defined the alias, without any indexing
     ($name:ident, $parent:ty) => {
         pub type $name = $parent;
     };
     // Variant where we define the type, and the Index and IndexMut traits
+    (
         $name:ident, $parent:ty,
         index($indexed_type:ty, $indexed_arena:ident)
@@ @@ -51,25 +50,25 @@ macro_rules! define_aliased_ast_id { @@
     };
+}
 /// Helper macro that defines a wrapper type for a particular variant of an AST
 /// element ID. Only used to define single-wrapping IDs.
 macro_rules! define_new_ast_id {
     // Variant where we just defined the new type, without any indexing
     ($name:ident, $parent:ty) => {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
         pub struct $name (pub(crate) $parent);
         impl $name {
             pub(crate) fn new_invalid() -> Self     { Self($parent::new_invalid()) }
+            pub(crate) fn new_invalid() -> Self     { Self(<$parent>::new_invalid()) }
             pub(crate) fn is_invalid(&self) -> bool { self.0.is_invalid() }
             pub fn upcast(self) -> $parent          { self.0 }
+        }
     };
     // Variant where we define the type, and the Index and IndexMut traits
+    (
         $name:ident, $parent:ty,
         index($indexed_type:ty, $wrapper_type:path, $indexed_arena:ident)
     ) => {
         define_new_ast_id!($name, $parent);
         impl Index<$name> for Heap {
             type Output = $indexed_type;
@@ @@ -348,25 +347,25 @@ pub struct Identifier { @@
 impl PartialEq for Identifier {
     fn eq(&self, other: &Self) -> bool {
         return self.value == other.value
+    }
+}
 impl Display for Identifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.value.as_str())
+    }
+}
 #[derive(Debug, Clone, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
 pub enum ParserTypeVariant {
     // Basic builtin
     Message,
     Bool,
     UInt8, UInt16, UInt32, UInt64,
     SInt8, SInt16, SInt32, SInt64,
     Character, String,
     // Literals (need to get concrete builtin type during typechecking)
     IntegerLiteral,
     // Marker for inference
     Inferred,
     // Builtins expecting one subsequent type
@@ @@ -420,29 +419,27 @@ pub enum SymbolicParserTypeVariant { @@
 /// and performing type inference
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum ConcreteTypePart {
     // Markers for the use of polymorphic types within a procedure's body that
     // refer to polymorphic variables on the procedure's definition. Different
     // from markers in the `InferenceType`, these will not contain nested types.
     Marker(usize),
     // Special types (cannot be explicitly constructed by the programmer)
     Void,
     // Builtin types without nested types
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     UInt8, UInt16, UInt32, UInt64,
     SInt8, SInt16, SInt32, SInt64,
     Character, String,
     // Builtin types with one nested type
     Array,
     Slice,
     Input,
     Output,
     // User defined type with any number of nested types
     Instance(DefinitionId, usize),
+}
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ConcreteType {
     pub(crate) parts: Vec<ConcreteTypePart>
@@ @@ -1007,30 +1004,24 @@ impl Statement { @@
     pub fn as_local(&self) -> &LocalStatement {
         match self {
             Statement::Local(result) => result,
             _ => panic!("Unable to cast `Statement` to `LocalStatement`"),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         self.as_local().as_memory()
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         self.as_local().as_channel()
+    }
     pub fn as_skip(&self) -> &SkipStatement {
         match self {
             Statement::Skip(result) => result,
             _ => panic!("Unable to cast `Statement` to `SkipStatement`"),
+        }
+    }
     pub fn as_labeled(&self) -> &LabeledStatement {
         match self {
             Statement::Labeled(result) => result,
             _ => panic!("Unable to cast `Statement` to `LabeledStatement`"),
+        }
+    }
     pub fn as_labeled_mut(&mut self) -> &mut LabeledStatement {
         match self {
             Statement::Labeled(result) => result,
             _ => panic!("Unable to cast `Statement` to `LabeledStatement`"),
+        }
+    }
@@ @@ -1486,36 +1477,24 @@ impl Expression { @@
     pub fn as_slicing(&self) -> &SlicingExpression {
         match self {
             Expression::Slicing(result) => result,
             _ => panic!("Unable to cast `Expression` to `SlicingExpression`"),
+        }
+    }
     pub fn as_select(&self) -> &SelectExpression {
         match self {
             Expression::Select(result) => result,
             _ => panic!("Unable to cast `Expression` to `SelectExpression`"),
+        }
+    }
     pub fn as_array(&self) -> &ArrayExpression {
         match self {
             Expression::Array(result) => result,
             _ => panic!("Unable to cast `Expression` to `ArrayExpression`"),
+        }
+    }
     pub fn as_constant(&self) -> &LiteralExpression {
         match self {
             Expression::Literal(result) => result,
             _ => panic!("Unable to cast `Expression` to `ConstantExpression`"),
+        }
+    }
     pub fn as_call(&self) -> &CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_call_mut(&mut self) -> &mut CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
@@ @@ -1784,25 +1763,25 @@ pub struct CallExpression { @@
     // Phase 1: parser
     pub span: InputSpan,
     pub parser_type: ParserType, // of the function call
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub definition: DefinitionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Method {
     // Builtin
     Get,
     Put,
     Fires,
     Create,
     Length,
     Assert,
     UserFunction,
     UserComponent,
+}
@@ @@ -1866,25 +1845,25 @@ impl Literal { @@
     pub(crate) fn as_union(&self) -> &LiteralUnion {
         if let Literal::Union(literal) = self {
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Union", self)
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct LiteralInteger {
     pub(crate) unsigned_value: u64,
     pub(crate) negated: bool, // for constant expression evaluation, TODO
+    pub(crate) negated: bool, // for constant expression evaluation, TODO: @Int
+}
 #[derive(Debug, Clone)]
 pub struct LiteralStructField {
     // Phase 1: parser
     pub(crate) identifier: Identifier,
     pub(crate) value: ExpressionId,
     // Phase 2: linker
     pub(crate) field_idx: usize, // in struct definition
+}
 #[derive(Debug, Clone)]

src/protocol/ast_printer.rs

➞

Show inline comments

 use std::fmt::{Debug, Display, Write};
 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 ";
@@ @@ -39,51 +40,50 @@ const PREFIX_ASSERT_STMT_ID: &'static str = "SAsr"; @@
 const PREFIX_GOTO_STMT_ID: &'static str = "SGot";
 const PREFIX_NEW_STMT_ID: &'static str = "SNew";
 const PREFIX_PUT_STMT_ID: &'static str = "SPut";
 const PREFIX_EXPR_STMT_ID: &'static str = "SExp";
 const PREFIX_ASSIGNMENT_EXPR_ID: &'static str = "EAsi";
 const PREFIX_BINDING_EXPR_ID: &'static str = "EBnd";
 const PREFIX_CONDITIONAL_EXPR_ID: &'static str = "ECnd";
 const PREFIX_BINARY_EXPR_ID: &'static str = "EBin";
 const PREFIX_UNARY_EXPR_ID: &'static str = "EUna";
 const PREFIX_INDEXING_EXPR_ID: &'static str = "EIdx";
 const PREFIX_SLICING_EXPR_ID: &'static str = "ESli";
 const PREFIX_SELECT_EXPR_ID: &'static str = "ESel";
 const PREFIX_ARRAY_EXPR_ID: &'static str = "EArr";
 const PREFIX_CONST_EXPR_ID: &'static str = "ECns";
 const PREFIX_LITERAL_EXPR_ID: &'static str = "ELit";
 const PREFIX_CALL_EXPR_ID: &'static str = "ECll";
 const PREFIX_VARIABLE_EXPR_ID: &'static str = "EVar";
 struct KV<'a> {
     buffer: &'a mut String,
-    prefix: Option<(&'static str, u32)>,
+    prefix: Option<(&'static str, i32)>,
     indent: usize,
     temp_key: &'a mut String,
     temp_val: &'a mut String,
+}
 impl<'a> KV<'a> {
     fn new(buffer: &'a mut String, temp_key: &'a mut String, temp_val: &'a mut String, indent: usize) -> Self {
         temp_key.clear();
         temp_val.clear();
         KV{
             buffer,
             prefix: None,
             indent,
             temp_key,
             temp_val
+        }
+    }
-    fn with_id(mut self, prefix: &'static str, id: u32) -> Self {
+    fn with_id(mut self, prefix: &'static str, id: i32) -> Self {
         self.prefix = Some((prefix, id));
         self
+    }
     fn with_s_key(self, key: &str) -> Self {
         self.temp_key.push_str(key);
         self
+    }
     fn with_d_key<D: Display>(self, key: &D) -> Self {
         self.temp_key.push_str(&key.to_string());
         self
@@ @@ -95,42 +95,42 @@ impl<'a> KV<'a> { @@
+    }
     fn with_disp_val<D: Display>(self, val: &D) -> Self {
         self.temp_val.push_str(&format!("{}", val));
         self
+    }
     fn with_debug_val<D: Debug>(self, val: &D) -> Self {
         self.temp_val.push_str(&format!("{:?}", val));
         self
+    }
     fn with_ascii_val(self, val: &[u8]) -> Self {
         self.temp_val.push_str(&*String::from_utf8_lossy(val));
     fn with_identifier_val(self, val: &Identifier) -> Self {
         self.temp_val.push_str(val.value.as_str());
         self
+    }
     fn with_opt_disp_val<D: Display>(self, val: Option<&D>) -> Self {
         match val {
             Some(v) => { self.temp_val.push_str(&format!("Some({})", v)); },
             None => { self.temp_val.push_str("None"); }
+        }
         self
+    }
-    fn with_opt_ascii_val(self, val: Option<&[u8]>) -> Self {
+    fn with_opt_identifier_val(self, val: Option<&Identifier>) -> Self {
         match val {
             Some(v) => {
                 self.temp_val.push_str("Some(");
-                self.temp_val.push_str(&*String::from_utf8_lossy(v));
+                self.temp_val.push_str(v.value.as_str());
                 self.temp_val.push(')');
             },
             None => {
                 self.temp_val.push_str("None");
+            }
+        }
         self
+    }
     fn with_custom_val<F: Fn(&mut String)>(mut self, val_fn: F) -> Self {
         val_fn(&mut self.temp_val);
         self
@@ @@ -215,208 +215,199 @@ impl ASTWriter { @@
+    }
     fn write_pragma(&mut self, heap: &Heap, pragma_id: PragmaId, indent: usize) {
         match &heap[pragma_id] {
             Pragma::Version(pragma) => {
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaVersion")
                     .with_disp_val(&pragma.version);
             },
             Pragma::Module(pragma) => {
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaModule")
-                    .with_ascii_val(&pragma.value);
+                    .with_identifier_val(&pragma.value);
+            }
+        }
+    }
     fn write_import(&mut self, heap: &Heap, import_id: ImportId, indent: usize) {
         let import = &heap[import_id];
         let indent2 = indent + 1;
         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);
                 self.kv(indent2).with_s_key("Alias").with_ascii_val(&import.alias.value);
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&import.module);
                 self.kv(indent2).with_s_key("Alias").with_identifier_val(&import.alias);
                 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");
-                self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module);
+                self.kv(indent2).with_s_key("Name").with_identifier_val(&import.module);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
                 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.value);
                     self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias.value);
                     self.kv(indent4).with_s_key("Name").with_identifier_val(&symbol.name);
                     self.kv(indent4).with_s_key("Alias").with_opt_identifier_val(symbol.alias.as_ref());
                     self.kv(indent4).with_s_key("Definition")
                         .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));
+                }
+            }
+        }
+    }
     //--------------------------------------------------------------------------
     // Top-level definition writing
     //--------------------------------------------------------------------------
     fn write_definition(&mut self, heap: &Heap, def_id: DefinitionId, indent: usize) {
         self.cur_definition = Some(def_id);
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         let indent4 = indent3 + 1;
         match &heap[def_id] {
             Definition::Struct(def) => {
                 self.kv(indent).with_id(PREFIX_STRUCT_ID, def.this.0.index)
                     .with_s_key("DefinitionStruct");
-                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
+                self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
-                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                    self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Fields");
                 for field in &def.fields {
                     self.kv(indent3).with_s_key("Field");
                     self.kv(indent4).with_s_key("Name")
-                        .with_ascii_val(&field.field.value);
+                        .with_identifier_val(&field.field);
                     self.kv(indent4).with_s_key("Type")
-                        .with_custom_val(|s| write_parser_type(s, heap, &heap[field.parser_type]));
                         .with_custom_val(|s| write_parser_type(s, heap, &field.parser_type));
+                }
             },
             Definition::Enum(def) => {
                 self.kv(indent).with_id(PREFIX_ENUM_ID, def.this.0.index)
                     .with_s_key("DefinitionEnum");
-                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
+                self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
-                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                    self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
-                        .with_ascii_val(&variant.identifier.value);
+                        .with_identifier_val(&variant.identifier);
                     let variant_value = self.kv(indent4).with_s_key("Value");
                     match &variant.value {
                         EnumVariantValue::None => variant_value.with_s_val("None"),
                         EnumVariantValue::Integer(value) => variant_value.with_disp_val(value),
                     };
+                }
             },
             Definition::Union(def) => {
                 self.kv(indent).with_id(PREFIX_UNION_ID, def.this.0.index)
                     .with_s_key("DefinitionUnion");
-                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
+                self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
-                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                    self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
-                        .with_ascii_val(&variant.identifier.value);
+                        .with_identifier_val(&variant.identifier);
                     match &variant.value {
                         UnionVariantValue::None => {
                             self.kv(indent4).with_s_key("Value").with_s_val("None");
+                        }
                         UnionVariantValue::Embedded(embedded) => {
                             self.kv(indent4).with_s_key("Values");
                             for embedded in embedded {
                                 self.kv(indent4+1).with_s_key("Value")
-                                    .with_custom_val(|v| write_parser_type(v, heap, &heap[*embedded]));
                                     .with_custom_val(|v| write_parser_type(v, heap, embedded));
+                            }
+                        }
+                    }
+                }
+            }
             Definition::Function(def) => {
                 self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)
                     .with_s_key("DefinitionFunction");
-                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
+                self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
-                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                    self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("ReturnParserType").with_custom_val(|s| write_parser_type(s, heap, &heap[def.return_type]));
                 self.kv(indent2).with_s_key("ReturnParserTypes");
                 for return_type in &def.return_types {
                     self.kv(indent3).with_s_key("ReturnParserType")
                         .with_custom_val(|s| write_parser_type(s, heap, return_type));
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for param_id in &def.parameters {
                     self.write_parameter(heap, *param_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body, indent3);
+                self.write_stmt(heap, def.body.upcast(), indent3);
             },
             Definition::Component(def) => {
                 self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)
                     .with_s_key("DefinitionComponent");
-                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
+                self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);
                 self.kv(indent2).with_s_key("PolymorphicVariables");
                 for poly_var_id in &def.poly_vars {
-                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                    self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for param_id in &def.parameters {
                     self.write_parameter(heap, *param_id, indent3)
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body, indent3);
+                self.write_stmt(heap, def.body.upcast(), indent3);
+            }
+        }
+    }
     fn write_parameter(&mut self, heap: &Heap, param_id: ParameterId, indent: usize) {
         let indent2 = indent + 1;
         let param = &heap[param_id];
         self.kv(indent).with_id(PREFIX_PARAMETER_ID, param_id.0.index)
             .with_s_key("Parameter");
         self.kv(indent2).with_s_key("Name").with_ascii_val(&param.identifier.value);
         self.kv(indent2).with_s_key("ParserType").with_custom_val(|w| write_parser_type(w, heap, &heap[param.parser_type]));
+    }
     fn write_poly_args(&mut self, heap: &Heap, poly_args: &[ParserTypeId], indent: usize) {
         if poly_args.is_empty() {
             return
+        }
         let indent2 = indent + 1;
         self.kv(indent).with_s_key("PolymorphicArguments");
         for poly_arg in poly_args {
             self.kv(indent2).with_s_key("Argument")
                 .with_custom_val(|v| write_parser_type(v, heap, &heap[*poly_arg]));
+        }
         self.kv(indent2).with_s_key("Name").with_identifier_val(&param.identifier);
         self.kv(indent2).with_s_key("ParserType").with_custom_val(|w| write_parser_type(w, heap, &param.parser_type));
+    }
     fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {
         let stmt = &heap[stmt_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match stmt {
             Statement::Block(stmt) => {
                 self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Block");
@@ @@ -439,130 +430,118 @@ impl ASTWriter { @@
                     },
                     LocalStatement::Memory(stmt) => {
                         self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalMemory");
                         self.kv(indent2).with_s_key("Variable");
                         self.write_local(heap, stmt.variable, indent3);
                         self.kv(indent2).with_s_key("Next")
                             .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
+                    }
+                }
             },
             Statement::Skip(stmt) => {
                 self.kv(indent).with_id(PREFIX_SKIP_STMT_ID, stmt.this.0.index)
                     .with_s_key("Skip");
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Labeled(stmt) => {
                 self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.index)
                     .with_s_key("Labeled");
-                self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
+                self.kv(indent2).with_s_key("Label").with_identifier_val(&stmt.label);
                 self.kv(indent2).with_s_key("Statement");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::If(stmt) => {
                 self.kv(indent).with_id(PREFIX_IF_STMT_ID, stmt.this.0.index)
                     .with_s_key("If");
                 self.kv(indent2).with_s_key("EndIf")
                     .with_opt_disp_val(stmt.end_if.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("TrueBody");
                 self.write_stmt(heap, stmt.true_body, indent3);
+                self.write_stmt(heap, stmt.true_body.upcast(), indent3);
                 self.kv(indent2).with_s_key("FalseBody");
                 self.write_stmt(heap, stmt.false_body, indent3);
                 if let Some(false_body) = stmt.false_body {
                     self.kv(indent2).with_s_key("FalseBody");
                     self.write_stmt(heap, false_body.upcast(), indent3);
+                }
             },
             Statement::EndIf(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDIF_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndIf");
                 self.kv(indent2).with_s_key("StartIf").with_disp_val(&stmt.start_if.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::While(stmt) => {
                 self.kv(indent).with_id(PREFIX_WHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("While");
                 self.kv(indent2).with_s_key("EndWhile")
                     .with_opt_disp_val(stmt.end_while.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("InSync")
                     .with_opt_disp_val(stmt.in_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
+                self.write_stmt(heap, stmt.body.upcast(), indent3);
             },
             Statement::EndWhile(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDWHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndWhile");
                 self.kv(indent2).with_s_key("StartWhile").with_disp_val(&stmt.start_while.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Break(stmt) => {
                 self.kv(indent).with_id(PREFIX_BREAK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Break");
                 self.kv(indent2).with_s_key("Label")
-                    .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
+                    .with_opt_identifier_val(stmt.label.as_ref());
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Continue(stmt) => {
                 self.kv(indent).with_id(PREFIX_CONTINUE_STMT_ID, stmt.this.0.index)
                     .with_s_key("Continue");
                 self.kv(indent2).with_s_key("Label")
-                    .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
+                    .with_opt_identifier_val(stmt.label.as_ref());
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Synchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("Synchronous");
                 self.kv(indent2).with_s_key("EndSync")
                     .with_opt_disp_val(stmt.end_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
+                self.write_stmt(heap, stmt.body.upcast(), indent3);
             },
             Statement::EndSynchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSynchronous");
                 self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Return(stmt) => {
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
             },
             Statement::Assert(stmt) => {
                 self.kv(indent).with_id(PREFIX_ASSERT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Assert");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Goto(stmt) => {
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
-                self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
+                self.kv(indent2).with_s_key("Label").with_identifier_val(&stmt.label);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::New(stmt) => {
                 self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.index)
                     .with_s_key("New");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression.upcast(), indent3);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Expression(stmt) => {
@@ @@ -673,162 +652,162 @@ impl ASTWriter { @@
             },
             Expression::Select(expr) => {
                 self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.index)
                     .with_s_key("SelectExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 match &expr.field {
                     Field::Length => {
                         self.kv(indent2).with_s_key("Field").with_s_val("length");
                     },
                     Field::Symbolic(field) => {
-                        self.kv(indent2).with_s_key("Field").with_ascii_val(&field.identifier.value);
+                        self.kv(indent2).with_s_key("Field").with_identifier_val(&field.identifier);
                         self.kv(indent3).with_s_key("Definition").with_opt_disp_val(field.definition.as_ref().map(|v| &v.index));
                         self.kv(indent3).with_s_key("Index").with_disp_val(&field.field_idx);
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, def_id, &expr.concrete_type));
             },
             Expression::Array(expr) => {
                 self.kv(indent).with_id(PREFIX_ARRAY_EXPR_ID, expr.this.0.index)
                     .with_s_key("ArrayExpr");
                 self.kv(indent2).with_s_key("Elements");
                 for expr_id in &expr.elements {
                     self.write_expr(heap, *expr_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, def_id, &expr.concrete_type));
             },
             Expression::Literal(expr) => {
                 self.kv(indent).with_id(PREFIX_CONST_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConstantExpr");
                 self.kv(indent).with_id(PREFIX_LITERAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("LiteralExpr");
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Literal::Null => { val.with_s_val("null"); },
                     Literal::True => { val.with_s_val("true"); },
                     Literal::False => { val.with_s_val("false"); },
                     Literal::Character(data) => { val.with_ascii_val(data); },
                     Literal::Integer(data) => { val.with_disp_val(data); },
                     Literal::Character(data) => { val.with_disp_val(data); },
                     Literal::String(data) => { val.with_disp_val(data.as_str()); },
                     Literal::Integer(data) => { val.with_debug_val(data); },
                     Literal::Struct(data) => {
                         val.with_s_val("Struct");
                         let indent4 = indent3 + 1;
                         self.write_poly_args(heap, &data.poly_args2, indent3);
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index));
                         });
                         for field in &data.fields {
                             self.kv(indent3).with_s_key("Field");
-                            self.kv(indent4).with_s_key("Name").with_ascii_val(&field.identifier.value);
+                            self.kv(indent4).with_s_key("Name").with_identifier_val(&field.identifier);
                             self.kv(indent4).with_s_key("Index").with_disp_val(&field.field_idx);
                             self.kv(indent4).with_s_key("ParserType");
                             self.write_expr(heap, field.value, indent4 + 1);
+                        }
                     },
                     Literal::Enum(data) => {
                         val.with_s_val("Enum");
                         self.write_poly_args(heap, &data.poly_args2, indent3);
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index))
                         });
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                     },
                     Literal::Union(data) => {
                         val.with_s_val("Union");
                         let indent4 = indent3 + 1;
                         self.write_poly_args(heap, &data.poly_args2, indent3);
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index));
                         });
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                         for value in &data.values {
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
+                    }
                     Literal::Array(data) => {
                         val.with_s_val("Array");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, def_id, &expr.concrete_type));
             },
             Expression::Call(expr) => {
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 // Method
                 let method = self.kv(indent2).with_s_key("Method");
                 match &expr.method {
                     Method::Get => { method.with_s_val("get"); },
                     Method::Put => { method.with_s_val("put"); },
                     Method::Fires => { method.with_s_val("fires"); },
                     Method::Create => { method.with_s_val("create"); },
                     Method::Symbolic(symbolic) => {
                         method.with_s_val("symbolic");
                         self.kv(indent3).with_s_key("Name").with_ascii_val(&symbolic.identifier.value);
                         self.kv(indent3).with_s_key("Definition")
                             .with_opt_disp_val(symbolic.definition.as_ref().map(|v| &v.index));
+                    }
                 let definition = &heap[expr.definition];
                 match definition {
                     Definition::Component(definition) => {
                         self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&false);
                         self.kv(indent2).with_s_key("Variant").with_debug_val(&definition.variant);
                     },
                     Definition::Function(definition) => {
                         self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&definition.builtin);
                         self.kv(indent2).with_s_key("Variant").with_s_val("Function");
                     },
                     _ => unreachable!()
+                }
                 self.write_poly_args(heap, &expr.poly_args, indent2);
                 self.kv(indent2).with_s_key("MethodName").with_identifier_val(definition.identifier());
                 self.kv(indent2).with_s_key("ParserType")
                     .with_custom_val(|t| write_parser_type(t, heap, &expr.parser_type));
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
                 // Parent
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, def_id, &expr.concrete_type));
             },
             Expression::Variable(expr) => {
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
-                self.kv(indent2).with_s_key("Name").with_ascii_val(&expr.identifier.value);
+                self.kv(indent2).with_s_key("Name").with_identifier_val(&expr.identifier);
                 self.kv(indent2).with_s_key("Definition")
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, def_id, &expr.concrete_type));
+            }
+        }
+    }
     fn write_local(&mut self, heap: &Heap, local_id: LocalId, indent: usize) {
         let local = &heap[local_id];
         let indent2 = indent + 1;
         self.kv(indent).with_id(PREFIX_LOCAL_ID, local_id.0.index)
             .with_s_key("Local");
-        self.kv(indent2).with_s_key("Name").with_ascii_val(&local.identifier.value);
+        self.kv(indent2).with_s_key("Name").with_identifier_val(&local.identifier);
         self.kv(indent2).with_s_key("ParserType")
-            .with_custom_val(|w| write_parser_type(w, heap, &heap[local.parser_type]));
             .with_custom_val(|w| write_parser_type(w, heap, &local.parser_type));
+    }
     //--------------------------------------------------------------------------
     // Printing Utilities
     //--------------------------------------------------------------------------
     fn kv(&mut self, indent: usize) -> KV {
         KV::new(&mut self.buffer, &mut self.temp1, &mut self.temp2, indent)
+    }
     fn flush<W: IOWrite>(&mut self, w: &mut W) {
         w.write(self.buffer.as_bytes()).unwrap();
@@ @@ -838,83 +817,105 @@ impl ASTWriter { @@
 fn write_option<V: Display>(target: &mut String, value: Option<V>) {
     target.clear();
     match &value {
         Some(v) => target.push_str(&format!("Some({})", v)),
         None => target.push_str("None")
     };
+}
 fn write_parser_type(target: &mut String, heap: &Heap, t: &ParserType) {
     use ParserTypeVariant as PTV;
     let mut embedded = Vec::new();
     match &t.variant {
         PTV::Input(id) => { target.push_str("in"); embedded.push(*id); }
         PTV::Output(id) => { target.push_str("out"); embedded.push(*id) }
         PTV::Array(id) => { target.push_str("array"); embedded.push(*id) }
         PTV::Message => { target.push_str("msg"); }
         PTV::Bool => { target.push_str("bool"); }
         PTV::Byte => { target.push_str("byte"); }
         PTV::Short => { target.push_str("short"); }
         PTV::Int => { target.push_str("int"); }
         PTV::Long => { target.push_str("long"); }
         PTV::String => { target.push_str("str"); }
         PTV::IntegerLiteral => { target.push_str("int_lit"); }
         PTV::Inferred => { target.push_str("auto"); }
         PTV::Symbolic(symbolic) => {
             target.push_str(&String::from_utf8_lossy(&symbolic.identifier.value));
             match symbolic.variant {
                 Some(SymbolicParserTypeVariant::PolyArg(def_id, idx)) => {
                     target.push_str(&format!("{{def: {}, idx: {}}}", def_id.index, idx));
                 },
                 Some(SymbolicParserTypeVariant::Definition(def_id)) => {
                     target.push_str(&format!("{{def: {}}}", def_id.index));
                 },
                 None => {
                     target.push_str("{None}");
     fn push_bytes(target: &mut String, msg: &[u8]) {
         target.push_str(&String::from_utf8_lossy(msg));
+    }
     fn write_element(target: &mut String, heap: &Heap, t: &ParserType, mut element_idx: usize) -> usize {
         let element = &t.elements[element_idx];
         match &element.variant {
             PTV::Message => { push_bytes(target, KW_TYPE_MESSAGE); },
             PTV::Bool => { push_bytes(target, KW_TYPE_BOOL); },
             PTV::UInt8 => { push_bytes(target, KW_TYPE_UINT8); },
             PTV::UInt16 => { push_bytes(target, KW_TYPE_UINT16); },
             PTV::UInt32 => { push_bytes(target, KW_TYPE_UINT32); },
             PTV::UInt64 => { push_bytes(target, KW_TYPE_UINT64); },
             PTV::SInt8 => { push_bytes(target, KW_TYPE_SINT8); },
             PTV::SInt16 => { push_bytes(target, KW_TYPE_SINT16); },
             PTV::SInt32 => { push_bytes(target, KW_TYPE_SINT32); },
             PTV::SInt64 => { push_bytes(target, KW_TYPE_SINT64); },
             PTV::Character => { push_bytes(target, KW_TYPE_CHAR); },
             PTV::String => { push_bytes(target, KW_TYPE_STRING); },
             PTV::IntegerLiteral => { target.push_str("int_literal"); },
             PTV::Inferred => { push_bytes(target, KW_TYPE_INFERRED); },
             PTV::Array => {
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push_str("[]");
             },
             PTV::Input => {
                 push_bytes(target, KW_TYPE_IN_PORT);
                 target.push('<');
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::Output => {
                 push_bytes(target, KW_TYPE_OUT_PORT);
                 target.push('<');
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::PolymorphicArgument(definition_id, arg_idx) => {
                 let definition = &heap[*definition_id];
                 let poly_var = &definition.poly_vars()[*arg_idx].value;
                 target.write_str(poly_var.as_str());
             },
             PTV::Definition(definition_id, num_embedded) => {
                 let definition = &heap[*definition_id];
                 let definition_ident = definition.identifier().value.as_str();
                 target.write_str(definition_ident);
                 let num_embedded = *num_embedded;
                 if num_embedded != 0 {
                     target.push('<');
                     for embedded_idx in 0..num_embedded {
                         if embedded_idx != 0 {
                             target.push(',');
+                        }
                         element_idx = write_element(target, heap, t, element_idx + 1);
+                    }
                     target.push('>');
+                }
+            }
             embedded.extend(&symbolic.poly_args2);
+        }
     };
     if !embedded.is_empty() {
         target.push_str("<");
         for (idx, embedded_id) in embedded.into_iter().enumerate() {
             if idx != 0 { target.push_str(", "); }
             write_parser_type(target, heap, &heap[embedded_id]);
+        }
         target.push_str(">");
         element_idx
+    }
     write_element(target, heap, t, 0);
+}
 fn write_concrete_type(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType) {
     use ConcreteTypePart as CTP;
     fn write_concrete_part(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType, mut idx: usize) -> usize {
         if idx >= t.parts.len() {
             return idx;
+        }
         match &t.parts[idx] {
             CTP::Marker(marker) => {
                 // Marker points to polymorphic variable index
                 let definition = &heap[def_id];
                 let poly_var_ident = match definition {
                     Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => unreachable!(),
                     Definition::Function(definition) => &definition.poly_vars[*marker].value,
                     Definition::Component(definition) => &definition.poly_vars[*marker].value,
                 };
                 target.push_str(&String::from_utf8_lossy(&poly_var_ident));
                 let poly_var_ident = &definition.poly_vars()[*marker];
                 target.push_str(poly_var_ident.value.as_str());
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
             },
             CTP::Void => target.push_str("void"),
             CTP::Message => target.push_str("msg"),
             CTP::Bool => target.push_str("bool"),
             CTP::Byte => target.push_str("byte"),
             CTP::Short => target.push_str("short"),
             CTP::Int => target.push_str("int"),
             CTP::Long => target.push_str("long"),
             CTP::String => target.push_str("string"),
             CTP::Array => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
             CTP::Input => {
                 target.push_str("in<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>');
             },
             CTP::Output => {
                 target.push_str("out<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>')
             },
             CTP::Instance(definition_id, num_embedded) => {
                 let identifier = heap[*definition_id].identifier();
-                target.push_str(&String::from_utf8_lossy(&identifier.value));
+                target.push_str(identifier.value.as_str());
                 target.push('<');
                 for idx_embedded in 0..*num_embedded {
                     if idx_embedded != 0 {
                         target.push_str(", ");
+                    }
                     idx = write_concrete_part(target, heap, def_id, t, idx + 1);
+                }
                 target.push('>');
+            }
+        }
         idx + 1

src/protocol/eval.rs

➞

Show inline comments

@@ @@ -66,39 +66,43 @@ impl Value { @@
+                }
+            }
             _ => unimplemented!(),
+        }
+    }
     fn from_constant(constant: &Literal) -> Value {
         match constant {
             Literal::Null => Value::Message(MessageValue(None)),
             Literal::True => Value::Boolean(BooleanValue(true)),
             Literal::False => Value::Boolean(BooleanValue(false)),
             Literal::Integer(val) => {
                 // Convert raw ASCII data to UTF-8 string
                 let val = *val;
                 if val >= BYTE_MIN && val <= BYTE_MAX {
                     Value::Byte(ByteValue(val as i8))
                 } else if val >= SHORT_MIN && val <= SHORT_MAX {
                     Value::Short(ShortValue(val as i16))
                 } else if val >= INT_MIN && val <= INT_MAX {
                     Value::Int(IntValue(val as i32))
                 let mut integer_value = val.unsigned_value as i64; // TODO: @Int
                 if val.negated { integer_value = -integer_value; };
                 if integer_value >= BYTE_MIN && integer_value <= BYTE_MAX {
                     Value::Byte(ByteValue(integer_value as i8))
                 } else if integer_value >= SHORT_MIN && integer_value <= SHORT_MAX {
                     Value::Short(ShortValue(integer_value as i16))
                 } else if integer_value >= INT_MIN && integer_value <= INT_MAX {
                     Value::Int(IntValue(integer_value as i32))
                 } else {
-                    Value::Long(LongValue(val))
+                    Value::Long(LongValue(integer_value))
+                }
+            }
             Literal::Character(_data) => unimplemented!(),
             Literal::String(_data) => unimplemented!(),
             Literal::Struct(_data) => unimplemented!(),
             Literal::Enum(_data) => unimplemented!(),
             Literal::Union(_data) => unimplemented!(),
             Literal::Array(expressions) => unimplemented!(),
+        }
+    }
     fn set(&mut self, index: &Value, value: &Value) -> Option<Value> {
         // The index must be of integer type, and non-negative
         let the_index: usize;
         match index {
             Value::Byte(_) | Value::Short(_) | Value::Int(_) | Value::Long(_) => {
                 let index = i64::from(index);
                 if index < 0 || index >= MESSAGE_MAX_LENGTH {
                     // It is inconsistent to update out of bounds
                     return None;
+                }
@@ @@ -904,47 +908,47 @@ impl Display for InputValue { @@
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "#in")
+    }
+}
 impl ValueImpl for InputValue {
     fn exact_type(&self) -> Type {
         Type::INPUT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match &t.variant {
-            Input(_) | Inferred | Symbolic(_) => true,
+            Input | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct OutputValue(pub PortId);
 impl Display for OutputValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "#out")
+    }
+}
 impl ValueImpl for OutputValue {
     fn exact_type(&self) -> Type {
         Type::OUTPUT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match &t.variant {
             Output(_) | Inferred | Symbolic(_) => true,
         match &t.elements[0].variant {
             Output | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct MessageValue(pub Option<Payload>);
 impl Display for MessageValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match &self.0 {
             None => write!(f, "null"),
@@ @@ -957,145 +961,154 @@ impl Display for MessageValue { @@
                 f.debug_list().entries(slice.iter().copied()).finish()
+            }
+        }
+    }
+}
 impl ValueImpl for MessageValue {
     fn exact_type(&self) -> Type {
         Type::MESSAGE
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match &t.variant {
             Message | Inferred | Symbolic(_) => true,
         match &t.elements[0].variant {
             Message | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BooleanValue(bool);
 impl Display for BooleanValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for BooleanValue {
     fn exact_type(&self) -> Type {
         Type::BOOLEAN
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Symbolic(_) | Inferred | Bool | Byte | Short | Int | Long => true,
         match t.elements[0].variant {
             Definition(_, _) | Inferred | Bool |
             UInt8 | UInt16 | UInt32 | UInt64 |
             SInt8 | SInt16 | SInt32 | SInt64 => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ByteValue(i8);
 impl Display for ByteValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for ByteValue {
     fn exact_type(&self) -> Type {
         Type::BYTE
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Symbolic(_) | Inferred | Byte | Short | Int | Long => true,
         match t.elements[0].variant {
             Definition(_, _) | Inferred |
             UInt8 | UInt16 | UInt32 | UInt64 |
             SInt8 | SInt16 | SInt32 | SInt64 => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ShortValue(i16);
 impl Display for ShortValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for ShortValue {
     fn exact_type(&self) -> Type {
         Type::SHORT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Symbolic(_) | Inferred | Short | Int | Long => true,
         match t.elements[0].variant {
             Definition(_, _) | Inferred |
             UInt16 | UInt32 | UInt64 |
             SInt16 | SInt32 | SInt64=> true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct IntValue(i32);
 impl Display for IntValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for IntValue {
     fn exact_type(&self) -> Type {
         Type::INT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Symbolic(_) | Inferred | Int | Long => true,
         match t.elements[0].variant {
             Definition(_, _) | Inferred |
             UInt32 | UInt64 |
             SInt32 | SInt64 => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct LongValue(i64);
 impl Display for LongValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for LongValue {
     fn exact_type(&self) -> Type {
         Type::LONG
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match &t.variant {
             Long | Inferred | Symbolic(_) => true,
         match &t.elements[0].variant {
             UInt64 | SInt64 | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
 fn get_array_inner(t: &ParserType) -> Option<ParserTypeId> {
     match t.variant {
         ParserTypeVariant::Array(inner) => Some(inner),
         _ => None
 fn get_array_inner(t: &ParserType) -> Option<ParserTypeVariant> {
     if t.elements[0].variant == ParserTypeVariant::Array {
         return Some(t.elements[1].variant.clone())
     } else {
         return None;
+    }
+}
 #[derive(Debug, Clone)]
 pub struct InputArrayValue(Vec<InputValue>);
 impl Display for InputArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
@@ @@ -1324,47 +1337,46 @@ impl ValueImpl for LongArrayValue { @@
 #[derive(Debug, Clone)]
 struct Store {
     map: HashMap<VariableId, Value>,
+}
 impl Store {
     fn new() -> Self {
         Store { map: HashMap::new() }
+    }
     fn initialize(&mut self, h: &Heap, var: VariableId, value: Value) {
         // Ensure value is compatible with type of variable
         let parser_type = match &h[var] {
             Variable::Local(v) => v.parser_type,
             Variable::Parameter(v) => v.parser_type,
             Variable::Local(v) => &v.parser_type,
             Variable::Parameter(v) => &v.parser_type,
         };
-        assert!(value.is_type_compatible(h, &h[parser_type]));
         assert!(value.is_type_compatible(h, parser_type));
         // Overwrite mapping
         self.map.insert(var, value.clone());
+    }
     fn update(
         &mut self,
         h: &Heap,
         ctx: &mut EvalContext,
         lexpr: ExpressionId,
         value: Value,
     ) -> EvalResult {
         match &h[lexpr] {
             Expression::Variable(var) => {
                 let var = var.declaration.unwrap();
                 // Ensure value is compatible with type of variable
                 let parser_type_id = match &h[var] {
                     Variable::Local(v) => v.parser_type,
                     Variable::Parameter(v) => v.parser_type
                 let parser_type = match &h[var] {
                     Variable::Local(v) => &v.parser_type,
                     Variable::Parameter(v) => &v.parser_type
                 };
                 let parser_type = &h[parser_type_id];
                 assert!(value.is_type_compatible(h, parser_type));
                 // Overwrite mapping
                 self.map.insert(var, value.clone());
                 Ok(value)
+            }
             Expression::Indexing(indexing) => {
                 // Evaluate index expression, which must be some integral type
                 let index = self.eval(h, ctx, indexing.index)?;
                 // Mutable reference to the subject
                 let subject;
                 match &h[indexing.subject] {
                     Expression::Variable(var) => {
@@ @@ -1379,25 +1391,25 @@ impl Store { @@
+                }
+            }
             _ => unimplemented!("{:?}", h[lexpr]),
+        }
+    }
     fn get(&mut self, h: &Heap, ctx: &mut EvalContext, rexpr: ExpressionId) -> EvalResult {
         match &h[rexpr] {
             Expression::Variable(var) => {
                 let var_id = var.declaration.unwrap();
                 let value = self
                     .map
                     .get(&var_id)
-                    .expect(&format!("Uninitialized variable {:?}", String::from_utf8_lossy(&var.identifier.value)));
+                    .expect(&format!("Uninitialized variable {:?}", var.identifier.value.as_str()));
                 Ok(value.clone())
+            }
             Expression::Indexing(indexing) => {
                 // Evaluate index expression, which must be some integral type
                 let index = self.eval(h, ctx, indexing.index)?;
                 // Reference to subject
                 let subject;
                 match &h[indexing.subject] {
                     Expression::Variable(var) => {
                         let var = var.declaration.unwrap();
                         subject = self.map.get(&var).unwrap();
+                    }
@@ @@ -1507,31 +1519,24 @@ impl Store { @@
+                    }
                     UnaryOperation::PreDecrement => {
                         value = value.minus(&ONE);
                         self.update(h, ctx, expr.expression, value.clone())?;
+                    }
                     _ => unimplemented!(),
+                }
                 Ok(value)
+            }
             Expression::Indexing(expr) => self.get(h, ctx, expr.this.upcast()),
             Expression::Slicing(_expr) => unimplemented!(),
             Expression::Select(expr) => self.get(h, ctx, expr.this.upcast()),
             Expression::Array(expr) => {
                 let mut elements = Vec::new();
                 for &elem in expr.elements.iter() {
                     elements.push(self.eval(h, ctx, elem)?);
+                }
                 todo!()
+            }
             Expression::Literal(expr) => Ok(Value::from_constant(&expr.value)),
             Expression::Call(expr) => match &expr.method {
                 Method::Get => {
                     assert_eq!(1, expr.arguments.len());
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.get(value.clone()) {
                         None => Err(EvalContinuation::BlockGet(value)),
                         Some(result) => Ok(result),
+                    }
+                }
                 Method::Put => {
                     assert_eq!(2, expr.arguments.len());
@@ @@ -1578,36 +1583,35 @@ pub enum EvalContinuation { @@
+}
 #[derive(Debug, Clone)]
 pub(crate) struct Prompt {
     definition: DefinitionId,
     store: Store,
     position: Option<StatementId>,
+}
 impl Prompt {
     pub fn new(h: &Heap, def: DefinitionId, args: &Vec<Value>) -> Self {
         let mut prompt =
             Prompt { definition: def, store: Store::new(), position: Some((&h[def]).body()) };
+            Prompt { definition: def, store: Store::new(), position: Some((&h[def]).body().upcast()) };
         prompt.set_arguments(h, args);
         prompt
+    }
     fn set_arguments(&mut self, h: &Heap, args: &Vec<Value>) {
         let def = &h[self.definition];
         let params = def.parameters();
         assert_eq!(params.len(), args.len());
         for (param, value) in params.iter().zip(args.iter()) {
             let hparam = &h[*param];
             let parser_type = &h[hparam.parser_type];
             assert!(value.is_type_compatible(h, parser_type));
             assert!(value.is_type_compatible(h, &hparam.parser_type));
             self.store.initialize(h, param.upcast(), value.clone());
+        }
+    }
     pub fn step(&mut self, h: &Heap, ctx: &mut EvalContext) -> EvalResult {
         if self.position.is_none() {
             return Err(EvalContinuation::Terminal);
+        }
         let stmt = &h[self.position.unwrap()];
         match stmt {
             Statement::Block(stmt) => {
                 // Continue to first statement
@@ @@ -1637,54 +1641,57 @@ impl Prompt { @@
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Labeled(stmt) => {
                 // Continue to next statement
                 self.position = Some(stmt.body);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::If(stmt) => {
                 // Evaluate test
                 let value = self.store.eval(h, ctx, stmt.test)?;
                 // Continue with either branch
                 if value.as_boolean().0 {
                     self.position = Some(stmt.true_body);
                     self.position = Some(stmt.true_body.upcast());
                 } else if let Some(false_body) = stmt.false_body {
                     self.position = Some(false_body.upcast());
                 } else {
                     self.position = Some(stmt.false_body);
                     // No false body
                     self.position = Some(stmt.end_if.unwrap().upcast());
+                }
                 Err(EvalContinuation::Stepping)
+            }
             Statement::EndIf(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::While(stmt) => {
                 // Evaluate test
                 let value = self.store.eval(h, ctx, stmt.test)?;
                 // Either continue with body, or go to next
                 if value.as_boolean().0 {
                     self.position = Some(stmt.body);
+                    self.position = Some(stmt.body.upcast());
                 } else {
                     self.position = stmt.end_while.map(|x| x.upcast());
+                }
                 Err(EvalContinuation::Stepping)
+            }
             Statement::EndWhile(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Synchronous(stmt) => {
                 // Continue to next statement, and signal upward
                 self.position = Some(stmt.body);
+                self.position = Some(stmt.body.upcast());
                 Err(EvalContinuation::SyncBlockStart)
+            }
             Statement::EndSynchronous(stmt) => {
                 // Continue to next statement, and signal upward
                 self.position = stmt.next;
                 Err(EvalContinuation::SyncBlockEnd)
+            }
             Statement::Break(stmt) => {
                 // Continue to end of while
                 self.position = stmt.target.map(EndWhileStatementId::upcast);
                 Err(EvalContinuation::Stepping)
+            }

src/protocol/input_source.rs

➞

Show inline comments

@@ file renamed from src/protocol/input_source2.rs to src/protocol/input_source.rs @@
 use std::fmt;
 use std::cell::{Ref, RefCell};
 use std::fmt::Write;
 #[derive(Debug, Clone, Copy)]
-pub struct InputPosition2 {
+pub struct InputPosition {
     pub line: u32,
     pub offset: u32,
+}
-impl InputPosition2 {
+impl InputPosition {
     pub(crate) fn with_offset(&self, offset: u32) -> Self {
-        InputPosition2{ line: self.line, offset: self.offset + offset }
+        InputPosition { line: self.line, offset: self.offset + offset }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub struct InputSpan {
     pub begin: InputPosition2,
     pub end: InputPosition2,
     pub begin: InputPosition,
     pub end: InputPosition,
+}
 impl InputSpan {
     #[inline]
-    pub fn from_positions(begin: InputPosition2, end: InputPosition2) -> Self {
+    pub fn from_positions(begin: InputPosition, end: InputPosition) -> Self {
         Self { begin, end }
+    }
+}
 /// Wrapper around source file with optional filename. Ensures that the file is
 /// only scanned once.
-pub struct InputSource2 {
+pub struct InputSource {
     pub(crate) filename: String,
     pub(crate) input: Vec<u8>,
     // Iteration
     line: u32,
     offset: usize,
     // State tracking
     pub(crate) had_error: Option<ParseError>,
     // The offset_lookup is built on-demand upon attempting to report an error.
     // As the compiler is currently not multithreaded, we simply put it in a
     // RefCell to allow interior mutability.
     offset_lookup: RefCell<Vec<u32>>,
+}
-impl InputSource2 {
+impl InputSource {
     pub fn new(filename: String, input: Vec<u8>) -> Self {
         Self{
             filename,
             input,
             line: 1,
             offset: 0,
             had_error: None,
             offset_lookup: RefCell::new(Vec::new()),
+        }
+    }
     #[cfg(test)]
     pub fn new_test(input: &str) -> Self {
         let bytes = Vec::from(input.as_bytes());
         return Self::new(String::from("test"), bytes)
+    }
     #[inline]
     pub fn pos(&self) -> InputPosition2 {
         InputPosition2{ line: self.line, offset: self.offset as u32 }
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, offset: self.offset as u32 }
+    }
     pub fn next(&self) -> Option<u8> {
         if self.offset < self.input.len() {
             Some(self.input[self.offset])
         } else {
             None
+        }
+    }
     pub fn lookahead(&self, offset: usize) -> Option<u8> {
         let offset_pos = self.offset + offset;
         if offset_pos < self.input.len() {
             Some(self.input[offset_pos])
         } else {
             None
+        }
+    }
     #[inline]
-    pub fn section_at_pos(&self, start: InputPosition2, end: InputPosition2) -> &[u8] {
+    pub fn section_at_pos(&self, start: InputPosition, end: InputPosition) -> &[u8] {
         &self.input[start.offset as usize..end.offset as usize]
+    }
     #[inline]
     pub fn section_at_span(&self, span: InputSpan) -> &[u8] {
         &self.input[span.begin.offset as usize..span.end.offset as usize]
+    }
     // Consumes the next character. Will check well-formedness of newlines: \r
     // must be followed by a \n, because this is used for error reporting. Will
     // not check for ascii-ness of the file, better left to a tokenizer.
     pub fn consume(&mut self) {
@@ @@ -116,25 +116,25 @@ impl InputSource2 { @@
                 self.offset += 1;
+            }
             None => {}
+        }
         // Maybe we actually want to check this in release mode. Then again:
         // a 4 gigabyte source file... Really?
         debug_assert!(self.offset < u32::max_value() as usize);
+    }
     fn set_error(&mut self, msg: &str) {
         if self.had_error.is_none() {
-            self.had_error = Some(ParseError::new_error(self, self.pos(), msg));
+            self.had_error = Some(ParseError::new_error_str_at_pos(self, self.pos(), msg));
+        }
+    }
     fn get_lookup(&self) -> Ref<Vec<u32>> {
         // Once constructed the lookup always contains one element. We use this
         // to see if it is constructed already.
         let lookup = self.offset_lookup.borrow();
         if !lookup.is_empty() {
             return lookup;
+        }
         // Build the line number (!) to offset lookup, so offset by 1. We
@@ @@ -202,46 +202,46 @@ pub struct ParseErrorStatement { @@
     pub(crate) statement_kind: StatementKind,
     pub(crate) context_kind: ContextKind,
     pub(crate) start_line: u32,
     pub(crate) start_column: u32,
     pub(crate) end_line: u32,
     pub(crate) end_column: u32,
     pub(crate) filename: String,
     pub(crate) context: String,
     pub(crate) message: String,
+}
 impl ParseErrorStatement {
-    fn from_source_at_pos(statement_kind: StatementKind, source: &InputSource2, position: InputPosition2, message: String) -> Self {
+    fn from_source_at_pos(statement_kind: StatementKind, source: &InputSource, position: InputPosition, message: String) -> Self {
         // Seek line start and end
         let line_start = source.lookup_line_start_offset(position.line);
         let line_end = source.lookup_line_end_offset(position.line);
         let context = Self::create_context(source, line_start as usize, line_end as usize);
         debug_assert!(position.offset >= line_start);
         let column = position.offset - line_start + 1;
         Self{
             statement_kind,
             context_kind: ContextKind::SingleLine,
             start_line: position.line,
             start_column: column,
             end_line: position.line,
             end_column: column + 1,
             filename: source.filename.clone(),
             context,
             message,
+        }
+    }
-    fn from_source_at_span(statement_kind: StatementKind, source: &InputSource2, span: InputSpan, message: String) -> Self {
+    fn from_source_at_span(statement_kind: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {
         debug_assert!(span.end.line >= span.begin.line);
         debug_assert!(span.end.offset >= span.begin.offset);
         let first_line_start = source.lookup_line_start_offset(span.begin.line);
         let last_line_start = source.lookup_line_start_offset(span.end.line);
         let last_line_end = source.lookup_line_end_offset(span.end.line);
         let context = Self::create_context(source, first_line_start as usize, last_line_end as usize);
         debug_assert!(span.begin.offset >= first_line_start);
         let start_column = span.begin.offset - first_line_start + 1;
         let end_column = span.end.offset - last_line_start + 1;
         let context_kind = if span.begin.line == span.end.line {
@@ @@ -255,25 +255,25 @@ impl ParseErrorStatement { @@
             context_kind,
             start_line: first_line_start,
             start_column,
             end_line: last_line_start,
             end_column,
             filename: source.filename.clone(),
             context,
             message,
+        }
+    }
     /// Produces context from source
-    fn create_context(source: &InputSource2, start: usize, end: usize) -> String {
+    fn create_context(source: &InputSource, start: usize, end: usize) -> String {
         let context_raw = &source.input[start..end];
         String::from_utf8_lossy(context_raw).to_string()
+    }
+}
 impl fmt::Display for ParseErrorStatement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Write kind of statement and message
         match self.statement_kind {
             StatementKind::Info => f.write_str(" INFO: ")?,
             StatementKind::Error => f.write_str("ERROR: ")?,
+        }
@@ @@ -327,44 +327,44 @@ impl fmt::Display for ParseErrorStatement { @@
         let mut context = String::with_capacity(128);
         let mut annotation = String::with_capacity(128);
         match self.context_kind {
             ContextKind::SingleLine => {
                 // Write single line of context with indicator for the offending
                 // span underneath.
                 transform_context(&self.context, &mut context);
                 context.push('\n');
                 f.write_str(&context)?;
                 annotation.push_str(" | ");
                 extend_annotation(1, self.start_column, &self.source, &mut annotation, ' ');
                 extend_annotation(self.start_column, self.end_column, &self.source, &mut annotation, '~');
                 extend_annotation(1, self.start_column, &self.context, &mut annotation, ' ');
                 extend_annotation(self.start_column, self.end_column, &self.context, &mut annotation, '~');
                 annotation.push('\n');
                 f.write_str(&annotation)?;
             },
             ContextKind::MultiLine => {
                 // Annotate all offending lines
                 // - first line
                 let mut lines = self.context.lines();
                 let first_line = lines.next().unwrap();
                 transform_context(first_line, &mut context);
                 writeln!(" |- {}", &context)?;
+                writeln!(f, " |- {}", &context)?;
                 // - remaining lines
                 let mut last_line = first_line;
                 while let Some(cur_line) = lines.next() {
                     context.clear();
                     transform_context(cur_line, &mut context);
                     writeln!(" |  {}", &context);
+                    writeln!(f, " |  {}", &context);
                     last_line = cur_line;
+                }
                 // - underline beneath last line
                 annotation.push_str(" \\__");
                 extend_annotation(1, self.end_column, &last_line, &mut annotation, '_');
                 annotation.push_str("/\n");
                 f.write_str(&annotation)?;
+            }
+        }
         Ok(())
@@ @@ -388,62 +388,62 @@ impl fmt::Display for ParseError { @@
             statement.fmt(f)?;
+        }
         Ok(())
+    }
+}
 impl ParseError {
     pub fn empty() -> Self {
         Self{ statements: Vec::new() }
+    }
-    pub fn new_error_at_pos(source: &InputSource2, position: InputPosition2, message: String) -> Self {
+    pub fn new_error_at_pos(source: &InputSource, position: InputPosition, message: String) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_pos(
             StatementKind::Error, source, position, message
         )) }
+    }
-    pub fn new_error_str_at_pos(source: &InputSource2, position: InputPosition2, message: &str) -> Self {
+    pub fn new_error_str_at_pos(source: &InputSource, position: InputPosition, message: &str) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_pos(
             StatementKind::Error, source, position, message.to_string()
         )) }
+    }
-    pub fn new_error_at_span(source: &InputSource2, span: InputSpan, message: String) -> Self {
+    pub fn new_error_at_span(source: &InputSource, span: InputSpan, message: String) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_span(
             StatementKind::Error, source, span, message
         )) }
+    }
-    pub fn new_error_str_at_span(source: &InputSource2, span: InputSpan, message: &str) -> Self {
+    pub fn new_error_str_at_span(source: &InputSource, span: InputSpan, message: &str) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_span(
             StatementKind::Error, source, span, message.to_string()
         )) }
+    }
-    pub fn with_at_pos(mut self, error_type: StatementKind, source: &InputSource2, position: InputPosition2, message: String) -> Self {
+    pub fn with_at_pos(mut self, error_type: StatementKind, source: &InputSource, position: InputPosition, message: String) -> Self {
         self.statements.push(ParseErrorStatement::from_source_at_pos(error_type, source, position, message));
         self
+    }
-    pub fn with_at_span(mut self, error_type: StatementKind, source: &InputSource2, span: InputSpan, message: String) -> Self {
+    pub fn with_at_span(mut self, error_type: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {
         self.statements.push(ParseErrorStatement::from_source_at_span(error_type, source, span, message.to_string()));
         self
+    }
-    pub fn with_info_at_pos(self, source: &InputSource2, position: InputPosition2, msg: String) -> Self {
+    pub fn with_info_at_pos(self, source: &InputSource, position: InputPosition, msg: String) -> Self {
         self.with_at_pos(StatementKind::Info, source, position, msg)
+    }
-    pub fn with_info_str_at_pos(self, source: &InputSource2, position: InputPosition2, msg: &str) -> Self {
+    pub fn with_info_str_at_pos(self, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.with_at_pos(StatementKind::Info, source, position, msg.to_string())
+    }
-    pub fn with_info_at_span(self, source: &InputSource2, span: InputSpan, msg: String) -> Self {
+    pub fn with_info_at_span(self, source: &InputSource, span: InputSpan, msg: String) -> Self {
         self.with_at_span(StatementKind::Info, source, span, msg)
+    }
-    pub fn with_info_str_at_span(self, source: &InputSource2, span: InputSpan, msg: &str) -> Self {
+    pub fn with_info_str_at_span(self, source: &InputSource, span: InputSpan, msg: &str) -> Self {
         self.with_at_span(StatementKind::Info, source, span, msg.to_string())
+    }
+}

src/protocol/inputsource.rs

➞

Show inline comments

deleted file

src/protocol/lexer.rs

➞

Show inline comments

deleted file

src/protocol/mod.rs

➞

Show inline comments

 mod arena;
 // mod ast;
 mod eval;
 pub(crate) mod inputsource;
 pub(crate) mod input_source2;
 // mod lexer;
 pub(crate) mod input_source;
 mod parser;
 #[cfg(test)] mod tests;
 // TODO: Remove when not benchmarking
 pub(crate) mod ast;
 pub(crate) mod ast_printer;
 pub(crate) mod lexer;
 lazy_static::lazy_static! {
     /// Conveniently-provided protocol description initialized with a zero-length PDL string.
     /// Exposed to minimize repeated initializations of this common protocol description.
     pub static ref TRIVIAL_PD: std::sync::Arc<ProtocolDescription> = {
         std::sync::Arc::new(ProtocolDescription::parse(b"").unwrap())
     };
+}
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
-use crate::protocol::inputsource::*;
+use crate::protocol::input_source::*;
 use crate::protocol::parser::*;
 /// Description of a protocol object, used to configure new connectors.
 #[repr(C)]
 pub struct ProtocolDescription {
     heap: Heap,
     source: InputSource,
     root: RootId,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct ComponentState {
     prompt: Prompt,
@@ @@ -45,71 +32,73 @@ pub(crate) enum EvalContext<'a> { @@
 //////////////////////////////////////////////
 impl std::fmt::Debug for ProtocolDescription {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "(An opaque protocol description)")
+    }
+}
 impl ProtocolDescription {
     // TODO: Allow for multi-file compilation
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         // TODO: @fixme, keep code compilable, but needs support for multiple
         //  input files.
-        let source = InputSource::from_buffer(buffer).unwrap();
+        let source = InputSource::new(String::new(), Vec::from(buffer));
         let mut parser = Parser::new();
-        parser.feed(source).expect("failed to lex source");
+        parser.feed(source).expect("failed to feed source");
         if let Err(err) = parser.parse() {
             println!("ERROR:\n{}", err);
             return Err(format!("{}", err))
+        }
         debug_assert_eq!(parser.modules.len(), 1, "only supporting one module here for now");
         let root = parser.modules[0].root_id;
         return Ok(ProtocolDescription { heap: parser.heap, source: parser.modules[0].source.clone(), root });
         let module = parser.modules.remove(0);
         let root = module.root_id;
         let source = module.source;
         return Ok(ProtocolDescription { heap: parser.heap, source, root });
+    }
     pub(crate) fn component_polarities(
         &self,
         identifier: &[u8],
     ) -> Result<Vec<Polarity>, AddComponentError> {
         use AddComponentError::*;
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier);
         if def.is_none() {
             return Err(NoSuchComponent);
+        }
         let def = &h[def.unwrap()];
         if !def.is_component() {
             return Err(NoSuchComponent);
+        }
         for &param in def.parameters().iter() {
             let param = &h[param];
-            let parser_type = &h[param.parser_type];
+            let first_element = &param.parser_type.elements[0];
             match parser_type.variant {
                 ParserTypeVariant::Input(_) | ParserTypeVariant::Output(_) => continue,
             match first_element.variant {
                 ParserTypeVariant::Input | ParserTypeVariant::Output => continue,
                 _ => {
                     return Err(NonPortTypeParameters);
+                }
+            }
+        }
         let mut result = Vec::new();
         for &param in def.parameters().iter() {
             let param = &h[param];
-            let parser_type = &h[param.parser_type];
+            let first_element = &param.parser_type.elements[0];
-            if let ParserTypeVariant::Input(_) = parser_type.variant {
+            if first_element.variant == ParserTypeVariant::Input {
                 result.push(Polarity::Getter)
-            } else if let ParserTypeVariant::Output(_) = parser_type.variant {
+            } else if first_element.variant == ParserTypeVariant::Output {
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     // expects port polarities to be correct
     pub(crate) fn new_component(&self, identifier: &[u8], ports: &[PortId]) -> ComponentState {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
             match y {

src/protocol/parser/depth_visitor.rs

➞

Show inline comments

 use crate::protocol::ast::*;
-use crate::protocol::inputsource::*;
+use crate::protocol::input_source::*;
 // The following indirection is needed due to a bug in the cbindgen tool.
 type Unit = ();
 pub(crate) type VisitorError = (InputPosition, String); // TODO: Revise when multi-file compiling is in place
 pub(crate) type VisitorResult = Result<Unit, VisitorError>;
 pub(crate) trait Visitor: Sized {
     fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {
         recursive_protocol_description(self, h, pd)
+    }
     fn visit_pragma(&mut self, _h: &mut Heap, _pragma: PragmaId) -> VisitorResult {
         Ok(())
+    }
     fn visit_import(&mut self, _h: &mut Heap, _import: ImportId) -> VisitorResult {
         Ok(())
+    }
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         recursive_symbol_definition(self, h, def)
+    }
-    fn visit_struct_definition(&mut self, _h: &mut Heap, _def: StructId) -> VisitorResult {
+    fn visit_struct_definition(&mut self, _h: &mut Heap, _def: StructDefinitionId) -> VisitorResult {
         Ok(())
+    }
-    fn visit_enum_definition(&mut self, _h: &mut Heap, _def: EnumId) -> VisitorResult {
+    fn visit_enum_definition(&mut self, _h: &mut Heap, _def: EnumDefinitionId) -> VisitorResult {
         Ok(())
+    }
-    fn visit_union_definition(&mut self, _h: &mut Heap, _def: UnionId) -> VisitorResult {
+    fn visit_union_definition(&mut self, _h: &mut Heap, _def: UnionDefinitionId) -> VisitorResult {
         Ok(())
+    }
     fn visit_component_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         recursive_component_definition(self, h, def)
+    }
     fn visit_composite_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         recursive_composite_definition(self, h, def)
+    }
     fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         recursive_primitive_definition(self, h, def)
+    }
-    fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionId) -> VisitorResult {
+    fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionDefinitionId) -> VisitorResult {
         recursive_function_definition(self, h, def)
+    }
     fn visit_variable_declaration(&mut self, h: &mut Heap, decl: VariableId) -> VisitorResult {
         recursive_variable_declaration(self, h, decl)
+    }
     fn visit_parameter_declaration(&mut self, _h: &mut Heap, _decl: ParameterId) -> VisitorResult {
         Ok(())
+    }
     fn visit_local_declaration(&mut self, _h: &mut Heap, _decl: LocalId) -> VisitorResult {
         Ok(())
+    }
@@ @@ -65,27 +65,24 @@ pub(crate) trait Visitor: Sized { @@
         &mut self,
         _h: &mut Heap,
         _stmt: ChannelStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         recursive_block_statement(self, h, stmt)
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_skip_statement(&mut self, _h: &mut Heap, _stmt: SkipStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         recursive_if_statement(self, h, stmt)
+    }
     fn visit_end_if_statement(&mut self, _h: &mut Heap, _stmt: EndIfStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         recursive_while_statement(self, h, stmt)
+    }
     fn visit_end_while_statement(&mut self, _h: &mut Heap, _stmt: EndWhileStatementId) -> VisitorResult {
         Ok(())
+    }
@@ @@ -103,33 +100,30 @@ pub(crate) trait Visitor: Sized { @@
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         recursive_synchronous_statement(self, h, stmt)
+    }
     fn visit_end_synchronous_statement(&mut self, _h: &mut Heap, _stmt: EndSynchronousStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_return_statement(&mut self, h: &mut Heap, stmt: ReturnStatementId) -> VisitorResult {
         recursive_return_statement(self, h, stmt)
+    }
     fn visit_assert_statement(&mut self, h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {
         recursive_assert_statement(self, h, stmt)
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         recursive_new_statement(self, h, stmt)
+    }
     fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         recursive_new_statement(self, h, stmt)
+    }
     fn visit_expression_statement(
         &mut self,
         h: &mut Heap,
         stmt: ExpressionStatementId,
     ) -> VisitorResult {
         recursive_expression_statement(self, h, stmt)
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         recursive_expression(self, h, expr)
+    }
     fn visit_assignment_expression(
@@ @@ -167,27 +161,24 @@ pub(crate) trait Visitor: Sized { @@
         recursive_indexing_expression(self, h, expr)
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         recursive_slicing_expression(self, h, expr)
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         recursive_select_expression(self, h, expr)
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         recursive_array_expression(self, h, expr)
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         recursive_call_expression(self, h, expr)
+    }
     fn visit_constant_expression(
         &mut self,
         _h: &mut Heap,
         _expr: LiteralExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
@@ @@ -285,56 +276,54 @@ fn recursive_primitive_definition<T: Visitor>( @@
     h: &mut Heap,
     def: ComponentDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_block_statement(h, h[def].body)
+}
 fn recursive_function_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
-    def: FunctionId,
+    def: FunctionDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
-    this.visit_statement(h, h[def].body)
+    this.visit_block_statement(h, h[def].body)
+}
 fn recursive_variable_declaration<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     decl: VariableId,
 ) -> VisitorResult {
     match h[decl].clone() {
         Variable::Parameter(decl) => this.visit_parameter_declaration(h, decl.this),
         Variable::Local(decl) => this.visit_local_declaration(h, decl.this),
+    }
+}
 fn recursive_statement<T: Visitor>(this: &mut T, h: &mut Heap, stmt: StatementId) -> VisitorResult {
     match h[stmt].clone() {
         Statement::Block(stmt) => this.visit_block_statement(h, stmt.this),
         Statement::Local(stmt) => this.visit_local_statement(h, stmt.this()),
         Statement::Skip(stmt) => this.visit_skip_statement(h, stmt.this),
         Statement::Labeled(stmt) => this.visit_labeled_statement(h, stmt.this),
         Statement::If(stmt) => this.visit_if_statement(h, stmt.this),
         Statement::While(stmt) => this.visit_while_statement(h, stmt.this),
         Statement::Break(stmt) => this.visit_break_statement(h, stmt.this),
         Statement::Continue(stmt) => this.visit_continue_statement(h, stmt.this),
         Statement::Synchronous(stmt) => this.visit_synchronous_statement(h, stmt.this),
         Statement::Return(stmt) => this.visit_return_statement(h, stmt.this),
         Statement::Assert(stmt) => this.visit_assert_statement(h, stmt.this),
         Statement::Goto(stmt) => this.visit_goto_statement(h, stmt.this),
         Statement::New(stmt) => this.visit_new_statement(h, stmt.this),
         Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),
         Statement::EndSynchronous(stmt) => this.visit_end_synchronous_statement(h, stmt.this),
         Statement::EndWhile(stmt) => this.visit_end_while_statement(h, stmt.this),
         Statement::EndIf(stmt) => this.visit_end_if_statement(h, stmt.this),
+    }
+}
 fn recursive_block_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
@@ @@ -398,33 +387,26 @@ fn recursive_synchronous_statement<T: Visitor>( @@
     // TODO: Check where this was used for
     // for &param in h[stmt].parameters.clone().iter() {
     //     recursive_parameter_as_variable(this, h, param)?;
     // }
     this.visit_block_statement(h, h[stmt].body)
+}
 fn recursive_return_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ReturnStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_assert_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: AssertStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
     debug_assert_eq!(h[stmt].expressions.len(), 1);
     this.visit_expression(h, h[stmt].expressions[0])
+}
 fn recursive_new_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: NewStatementId,
 ) -> VisitorResult {
     recursive_call_expression_as_expression(this, h, h[stmt].expression)
+}
 fn recursive_expression_statement<T: Visitor>(
     this: &mut T,
@@ @@ -439,25 +421,24 @@ fn recursive_expression<T: Visitor>( @@
     h: &mut Heap,
     expr: ExpressionId,
 ) -> VisitorResult {
     match h[expr].clone() {
         Expression::Assignment(expr) => this.visit_assignment_expression(h, expr.this),
         Expression::Binding(expr) => this.visit_binding_expression(h, expr.this),
         Expression::Conditional(expr) => this.visit_conditional_expression(h, expr.this),
         Expression::Binary(expr) => this.visit_binary_expression(h, expr.this),
         Expression::Unary(expr) => this.visit_unary_expression(h, expr.this),
         Expression::Indexing(expr) => this.visit_indexing_expression(h, expr.this),
         Expression::Slicing(expr) => this.visit_slicing_expression(h, expr.this),
         Expression::Select(expr) => this.visit_select_expression(h, expr.this),
         Expression::Array(expr) => this.visit_array_expression(h, expr.this),
         Expression::Literal(expr) => this.visit_constant_expression(h, expr.this),
         Expression::Call(expr) => this.visit_call_expression(h, expr.this),
         Expression::Variable(expr) => this.visit_variable_expression(h, expr.this),
+    }
+}
 fn recursive_assignment_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: AssignmentExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
@@ @@ -518,331 +499,39 @@ fn recursive_slicing_expression<T: Visitor>( @@
     this.visit_expression(h, h[expr].from_index)?;
     this.visit_expression(h, h[expr].to_index)
+}
 fn recursive_select_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: SelectExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)
+}
 fn recursive_array_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ArrayExpressionId,
 ) -> VisitorResult {
     for &expr in h[expr].elements.clone().iter() {
         this.visit_expression(h, expr)?;
+    }
     Ok(())
+}
 fn recursive_call_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: CallExpressionId,
 ) -> VisitorResult {
     for &expr in h[expr].arguments.clone().iter() {
         this.visit_expression(h, expr)?;
+    }
     Ok(())
+}
 // ====================
 // Grammar Rules
 // ====================
 pub(crate) struct NestedSynchronousStatements {
     illegal: bool,
+}
 impl NestedSynchronousStatements {
     pub(crate) fn new() -> Self {
         NestedSynchronousStatements { illegal: false }
+    }
+}
 impl Visitor for NestedSynchronousStatements {
     fn visit_composite_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         assert!(!self.illegal);
         self.illegal = true;
         recursive_composite_definition(self, h, def)?;
         self.illegal = false;
         Ok(())
+    }
     fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionDefinitionId) -> VisitorResult {
         assert!(!self.illegal);
         self.illegal = true;
         recursive_function_definition(self, h, def)?;
         self.illegal = false;
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         if self.illegal {
             return Err((
                 h[stmt].position(),
                 "Illegal nested synchronous statement".to_string(),
             ));
+        }
         self.illegal = true;
         recursive_synchronous_statement(self, h, stmt)?;
         self.illegal = false;
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct ChannelStatementOccurrences {
     illegal: bool,
+}
 impl ChannelStatementOccurrences {
     pub(crate) fn new() -> Self {
         ChannelStatementOccurrences { illegal: false }
+    }
+}
 impl Visitor for ChannelStatementOccurrences {
     fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         assert!(!self.illegal);
         self.illegal = true;
         recursive_primitive_definition(self, h, def)?;
         self.illegal = false;
         Ok(())
+    }
     fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionId) -> VisitorResult {
         assert!(!self.illegal);
         self.illegal = true;
         recursive_function_definition(self, h, def)?;
         self.illegal = false;
         Ok(())
+    }
     fn visit_channel_statement(&mut self, h: &mut Heap, stmt: ChannelStatementId) -> VisitorResult {
         if self.illegal {
             return Err((h[stmt].position(), "Illegal channel declaration".to_string()));
+        }
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct FunctionStatementReturns {}
 impl FunctionStatementReturns {
     pub(crate) fn new() -> Self {
         FunctionStatementReturns {}
+    }
     fn function_error(&self, position: InputPosition) -> VisitorResult {
         Err((position, "Function definition must return".to_string()))
+    }
+}
 impl Visitor for FunctionStatementReturns {
     fn visit_component_definition(&mut self, _h: &mut Heap, _def: ComponentDefinitionId) -> VisitorResult {
         Ok(())
+    }
     fn visit_variable_declaration(&mut self, _h: &mut Heap, _decl: VariableId) -> VisitorResult {
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, block: BlockStatementId) -> VisitorResult {
         let len = h[block].statements.len();
         assert!(len > 0);
         self.visit_statement(h, h[block].statements[len - 1])
+    }
     fn visit_skip_statement(&mut self, h: &mut Heap, stmt: SkipStatementId) -> VisitorResult {
         self.function_error(h[stmt].position)
+    }
     fn visit_break_statement(&mut self, h: &mut Heap, stmt: BreakStatementId) -> VisitorResult {
         self.function_error(h[stmt].position)
+    }
     fn visit_continue_statement(
         &mut self,
         h: &mut Heap,
         stmt: ContinueStatementId,
     ) -> VisitorResult {
         self.function_error(h[stmt].position)
+    }
     fn visit_assert_statement(&mut self, h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {
         self.function_error(h[stmt].position)
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         self.function_error(h[stmt].position)
+    }
     fn visit_expression_statement(
         &mut self,
         h: &mut Heap,
         stmt: ExpressionStatementId,
     ) -> VisitorResult {
         self.function_error(h[stmt].position)
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct ComponentStatementReturnNew {
     illegal_new: bool,
     illegal_return: bool,
+}
 impl ComponentStatementReturnNew {
     pub(crate) fn new() -> Self {
         ComponentStatementReturnNew { illegal_new: false, illegal_return: false }
+    }
+}
 impl Visitor for ComponentStatementReturnNew {
     fn visit_component_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         assert!(!(self.illegal_new || self.illegal_return));
         self.illegal_return = true;
         recursive_component_definition(self, h, def)?;
         self.illegal_return = false;
         Ok(())
+    }
     fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         assert!(!self.illegal_new);
         self.illegal_new = true;
         recursive_primitive_definition(self, h, def)?;
         self.illegal_new = false;
         Ok(())
+    }
     fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionId) -> VisitorResult {
         assert!(!(self.illegal_new || self.illegal_return));
         self.illegal_new = true;
         recursive_function_definition(self, h, def)?;
         self.illegal_new = false;
         Ok(())
+    }
     fn visit_variable_declaration(&mut self, _h: &mut Heap, _decl: VariableId) -> VisitorResult {
         Ok(())
+    }
     fn visit_return_statement(&mut self, h: &mut Heap, stmt: ReturnStatementId) -> VisitorResult {
         if self.illegal_return {
             Err((h[stmt].position, "Component definition must not return".to_string()))
         } else {
             recursive_return_statement(self, h, stmt)
+        }
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         if self.illegal_new {
             Err((
                 h[stmt].position,
                 "Symbol definition contains illegal new statement".to_string(),
             ))
         } else {
             recursive_new_statement(self, h, stmt)
+        }
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct CheckBuiltinOccurrences {
     legal: bool,
+}
 impl CheckBuiltinOccurrences {
     pub(crate) fn new() -> Self {
         CheckBuiltinOccurrences { legal: false }
+    }
+}
 impl Visitor for CheckBuiltinOccurrences {
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(!self.legal);
         self.legal = true;
         recursive_synchronous_statement(self, h, stmt)?;
         self.legal = false;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         match h[expr].method {
             Method::Get | Method::Fires => {
                 if !self.legal {
                     return Err((h[expr].position, "Illegal built-in occurrence".to_string()));
+                }
+            }
             _ => {}
+        }
         recursive_call_expression(self, h, expr)
+    }
+}
 pub(crate) struct BuildScope {
     scope: Option<Scope>,
+}
 impl BuildScope {
     pub(crate) fn new() -> Self {
         BuildScope { scope: None }
+    }
+}
 impl Visitor for BuildScope {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.scope.is_none());
         self.scope = Some(Scope::Definition(def));
         recursive_symbol_definition(self, h, def)?;
         self.scope = None;
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         // First store the current scope
         h[stmt].parent_scope = self.scope;
         // Then move scope down to current block
         self.scope = Some(Scope::Regular(stmt));
         recursive_block_statement(self, h, stmt)?;
         // Move scope back up
         self.scope = old;
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         // First store the current scope
         h[stmt].parent_scope = self.scope;
         // Then move scope down to current sync
         // TODO: Should be legal-ish, but very wrong
         self.scope = Some(Scope::Synchronous((stmt, BlockStatementId(stmt.upcast()))));
         recursive_synchronous_statement(self, h, stmt)?;
         // Move scope back up
         self.scope = old;
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct UniqueStatementId(StatementId);
 pub(crate) struct LinkStatements {
     prev: Option<UniqueStatementId>,
+}
 impl LinkStatements {
     pub(crate) fn new() -> Self {
         LinkStatements { prev: None }
+    }
+}
@@ @@ -858,28 +547,24 @@ impl Visitor for LinkStatements { @@
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt);
+        }
         recursive_statement(self, h, stmt)
+    }
     fn visit_local_statement(&mut self, _h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_skip_statement(&mut self, _h: &mut Heap, stmt: SkipStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         // Link the two branches to the corresponding EndIf pseudo-statement
         let end_if_id = h[stmt].end_if;
         assert!(end_if_id.is_some());
         let end_if_id = end_if_id.unwrap();
         assert!(self.prev.is_none());
         self.visit_block_statement(h, h[stmt].true_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(end_if_id.upcast());
+        }
@@ @@ -954,328 +639,93 @@ impl Visitor for LinkStatements { @@
         // Use the pseudo-statement as the statement where the next pointer is updated
         // self.prev = Some(UniqueStatementId(end_sync_id.upcast()));
         Ok(())
+    }
     fn visit_end_synchronous_statement(&mut self, _h: &mut Heap, stmt: EndSynchronousStatementId) -> VisitorResult {
         assert!(self.prev.is_none());
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_return_statement(&mut self, _h: &mut Heap, _stmt: ReturnStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_assert_statement(&mut self, _h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_new_statement(&mut self, _h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression_statement(
         &mut self,
         _h: &mut Heap,
         stmt: ExpressionStatementId,
     ) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct BuildLabels {
     block: Option<BlockStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl BuildLabels {
     pub(crate) fn new() -> Self {
         BuildLabels { block: None, sync_enclosure: None }
+    }
+}
 impl Visitor for BuildLabels {
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert_eq!(self.block, h[stmt].parent_block(h));
         let old = self.block;
         self.block = Some(stmt);
         recursive_block_statement(self, h, stmt)?;
         self.block = old;
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         assert!(!self.block.is_none());
         // Store label in current block (on the fly)
         h[self.block.unwrap()].labels.push(stmt);
         // Update synchronous scope of label
         h[stmt].in_sync = self.sync_enclosure;
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         h[stmt].in_sync = self.sync_enclosure;
         recursive_while_statement(self, h, stmt)
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(self.sync_enclosure.is_none());
         self.sync_enclosure = Some(stmt);
         recursive_synchronous_statement(self, h, stmt)?;
         self.sync_enclosure = None;
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct ResolveLabels {
     block: Option<BlockStatementId>,
     while_enclosure: Option<WhileStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl ResolveLabels {
     pub(crate) fn new() -> Self {
         ResolveLabels { block: None, while_enclosure: None, sync_enclosure: None }
+    }
     fn check_duplicate_impl(
         h: &Heap,
         block: Option<BlockStatementId>,
         stmt: LabeledStatementId,
     ) -> VisitorResult {
         if let Some(block) = block {
             // Checking the parent first is important. Otherwise, labels
             // overshadow previously defined labels: and this is illegal!
             ResolveLabels::check_duplicate_impl(h, h[block].parent_block(h), stmt)?;
             // For the current block, check for a duplicate.
             for &other_stmt in h[block].labels.iter() {
                 if other_stmt == stmt {
                     continue;
                 } else {
                     if h[other_stmt].label == h[stmt].label {
                         return Err((h[stmt].position, "Duplicate label".to_string()));
+                    }
+                }
+            }
+        }
         Ok(())
+    }
     fn check_duplicate(&self, h: &Heap, stmt: LabeledStatementId) -> VisitorResult {
         ResolveLabels::check_duplicate_impl(h, self.block, stmt)
+    }
     fn get_target(
         &self,
         h: &Heap,
         id: &Identifier,
     ) -> Result<LabeledStatementId, VisitorError> {
         if let Some(stmt) = ResolveLabels::find_target(h, self.block, id) {
             Ok(stmt)
         } else {
             Err((id.position, "Unresolved label".to_string()))
+        }
+    }
     fn find_target(
         h: &Heap,
         block: Option<BlockStatementId>,
         id: &Identifier,
     ) -> Option<LabeledStatementId> {
         if let Some(block) = block {
             // It does not matter in what order we find the labels.
             // If there are duplicates: that is checked elsewhere.
             for &stmt in h[block].labels.iter() {
                 if h[stmt].label == *id {
                     return Some(stmt);
+                }
+            }
             if let Some(stmt) = ResolveLabels::find_target(h, h[block].parent_block(h), id) {
                 return Some(stmt);
+            }
+        }
         None
+    }
+}
 impl Visitor for ResolveLabels {
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert_eq!(self.block, h[stmt].parent_block(h));
         let old = self.block;
         self.block = Some(stmt);
         recursive_block_statement(self, h, stmt)?;
         self.block = old;
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         assert!(!self.block.is_none());
         self.check_duplicate(h, stmt)?;
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         let old = self.while_enclosure;
         self.while_enclosure = Some(stmt);
         recursive_while_statement(self, h, stmt)?;
         self.while_enclosure = old;
         Ok(())
+    }
     fn visit_break_statement(&mut self, h: &mut Heap, stmt: BreakStatementId) -> VisitorResult {
         let the_while;
         if let Some(label) = &h[stmt].label {
             let target = self.get_target(h, label)?;
             let target = &h[h[target].body];
             if !target.is_while() {
                 return Err((
                     h[stmt].position,
                     "Illegal break: target not a while statement".to_string(),
                 ));
+            }
             the_while = target.as_while();
             // TODO: check if break is nested under while
         } else {
             if self.while_enclosure.is_none() {
                 return Err((
                     h[stmt].position,
                     "Illegal break: no surrounding while statement".to_string(),
                 ));
+            }
             the_while = &h[self.while_enclosure.unwrap()];
             // break is always nested under while, by recursive vistor
+        }
         if the_while.in_sync != self.sync_enclosure {
             return Err((
                 h[stmt].position,
                 "Illegal break: synchronous statement escape".to_string(),
             ));
+        }
         h[stmt].target = the_while.end_while;
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         h: &mut Heap,
         stmt: ContinueStatementId,
     ) -> VisitorResult {
         let the_while;
         if let Some(label) = &h[stmt].label {
             let target = self.get_target(h, label)?;
             let target = &h[h[target].body];
             if !target.is_while() {
                 return Err((
                     h[stmt].position,
                     "Illegal continue: target not a while statement".to_string(),
                 ));
+            }
             the_while = target.as_while();
             // TODO: check if continue is nested under while
         } else {
             if self.while_enclosure.is_none() {
                 return Err((
                     h[stmt].position,
                     "Illegal continue: no surrounding while statement".to_string(),
                 ));
+            }
             the_while = &h[self.while_enclosure.unwrap()];
             // continue is always nested under while, by recursive vistor
+        }
         if the_while.in_sync != self.sync_enclosure {
             return Err((
                 h[stmt].position,
                 "Illegal continue: synchronous statement escape".to_string(),
             ));
+        }
         h[stmt].target = Some(the_while.this);
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(self.sync_enclosure.is_none());
         self.sync_enclosure = Some(stmt);
         recursive_synchronous_statement(self, h, stmt)?;
         self.sync_enclosure = None;
         Ok(())
+    }
     fn visit_goto_statement(&mut self, h: &mut Heap, stmt: GotoStatementId) -> VisitorResult {
         let target = self.get_target(h, &h[stmt].label)?;
         if h[target].in_sync != self.sync_enclosure {
             return Err((
                 h[stmt].position,
                 "Illegal goto: synchronous statement escape".to_string(),
             ));
+        }
         h[stmt].target = Some(target);
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct AssignableExpressions {
     assignable: bool,
+}
 impl AssignableExpressions {
     pub(crate) fn new() -> Self {
         AssignableExpressions { assignable: false }
+    }
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err((position, "Unassignable expression".to_string()))
+    }
+}
 impl Visitor for AssignableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         if self.assignable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             self.assignable = true;
             self.visit_expression(h, h[expr].left)?;
             self.assignable = false;
             self.visit_expression(h, h[expr].right)
+        }
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         if self.assignable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_conditional_expression(self, h, expr)
+        }
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.assignable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.assignable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             match h[expr].operation {
                 UnaryOperation::PostDecrement
                 | UnaryOperation::PreDecrement
                 | UnaryOperation::PostIncrement
                 | UnaryOperation::PreIncrement => {
                     self.assignable = true;
                     recursive_unary_expression(self, h, expr)?;
                     self.assignable = false;
                     Ok(())
+                }
                 _ => recursive_unary_expression(self, h, expr),
@@ @@ -1297,53 +747,46 @@ impl Visitor for AssignableExpressions { @@
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         let old = self.assignable;
         self.assignable = false;
         recursive_slicing_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         if h[expr].field.is_length() && self.assignable {
-            return self.error(h[expr].position);
+            return self.error(h[expr].span.begin);
+        }
         let old = self.assignable;
         self.assignable = false;
         recursive_select_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_array_expression(self, h, expr)
+        }
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         if self.assignable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_call_expression(self, h, expr)
+        }
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: LiteralExpressionId,
     ) -> VisitorResult {
         if self.assignable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             Ok(())
+        }
+    }
     fn visit_variable_expression(
         &mut self,
         _h: &mut Heap,
         _expr: VariableExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
+}
@@ @@ -1359,51 +802,51 @@ impl IndexableExpressions { @@
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err((position, "Unindexable expression".to_string()))
+    }
+}
 impl Visitor for IndexableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         if self.indexable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_assignment_expression(self, h, expr)
+        }
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         self.visit_expression(h, h[expr].test)?;
         self.indexable = old;
         self.visit_expression(h, h[expr].true_expression)?;
         self.visit_expression(h, h[expr].false_expression)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.indexable && h[expr].operation != BinaryOperator::Concatenate {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.indexable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_unary_expression(self, h, expr)
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
         self.indexable = true;
         self.visit_expression(h, h[expr].subject)?;
@@ @@ -1424,45 +867,38 @@ impl Visitor for IndexableExpressions { @@
         self.visit_expression(h, h[expr].from_index)?;
         self.visit_expression(h, h[expr].to_index)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_select_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_array_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_call_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: LiteralExpressionId,
     ) -> VisitorResult {
         if self.indexable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             Ok(())
+        }
+    }
+}
 pub(crate) struct SelectableExpressions {
     selectable: bool,
+}
 impl SelectableExpressions {
     pub(crate) fn new() -> Self {
@@ @@ -1491,32 +927,32 @@ impl Visitor for SelectableExpressions { @@
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         self.visit_expression(h, h[expr].test)?;
         self.selectable = old;
         self.visit_expression(h, h[expr].true_expression)?;
         self.visit_expression(h, h[expr].false_expression)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.selectable && h[expr].operation != BinaryOperator::Concatenate {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.selectable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             recursive_unary_expression(self, h, expr)
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_indexing_expression(self, h, expr)?;
@@ @@ -1532,38 +968,31 @@ impl Visitor for SelectableExpressions { @@
         self.selectable = false;
         recursive_slicing_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_select_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_array_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_call_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: LiteralExpressionId,
     ) -> VisitorResult {
         if self.selectable {
-            self.error(h[expr].position)
+            self.error(h[expr].span.begin)
         } else {
             Ok(())
+        }
+    }
+}

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)