CSY/reowolf Changeset - 379cffa23df8 · Centrum Wiskunde & Informatica (CWI)

Changeset - 379cffa23df8

Parent rev.

Child rev.

[Not reviewed]

0 8 0

mh - 4 years ago 2021-01-15 18:21:28
contact@maxhenger.nl

WIP on type table

7 files changed:

language_spec.md

src/protocol/arena.rs

src/protocol/ast.rs

136

src/protocol/containers.rs

src/protocol/lexer.rs

101

src/protocol/parser/depth_visitor.rs

src/protocol/parser/symbol_table.rs

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

0 comments (0 inline, 0 general)

language_spec.md

➞

Show inline comments

 # Protocol Description Language
 ## Introduction
 ## Grammar
 Beginning with the basics from which we'll construct the grammar, various characters and special variations thereof:
 ```
 SP = " " // space
 HTAB = 0x09 // horizontal tab
 VCHAR = 0x21-0x7E // visible ASCII character
 VCHAR-ESCLESS = 0x20-0x5B | 0x5D-0x7E // visible ASCII character without "\"
 WSP = SP | HTAB // whitespace
 ALPHA = 0x41-0x5A | 0x61-0x7A // characters (lower and upper case)
 DIGIT = 0x30-0x39 // digit
 NEWLINE = (0x15 0x0A) | 0x0A // carriage return and line feed, or just line feed
 // Classic backslash escaping to produce particular ASCII charcters
 ESCAPE_CHAR = "\"
 ESCAPED_CHARS =
     ESCAPE_CHAR ESCAPE_CHAR |
     ESCAPE_CHAR "t" |
     ESCAPE_CHAR "r" |
     ESCAPE_CHAR "n" |
     ESCAPE_CHAR "0" |
     ESCAPE_CHAR "'" |
     ESCAPE_CHAR """
 ```
 Which are composed into the following components of an input file that do not directly contribute towards the AST:
 ```
 // asterisk followed by any ASCII char, excluding "/", or just any ASCII char without "*"
 block-comment-contents = "*" (0x00-0x2E | 0x30-0x7E) | (0x20-0x29 | 0x2B-0x7E)
 block-comment = "/*" block-comment-contents* "*/"
 line-comment = "//" (WSP | VCHAR)* NEWLINE
 comment = block-comment | line-comment
 cw = (comment | WSP | NEWLINE)*
 cwb = (comment | WSP | newline)+
 ```
 Where it should be noted that the `cw` rule allows for not encountering any of the indicated characters, while the `cwb` rule expects at least one instance.
 The following operators are defined:
 ```
 binary-operator = "||" | "&&" |
                   "!=" | "==" | "<=" | ">=" | "<" | ">" |
                   "|" | "&" | "^" | "<<" | ">>" |
                   "+" | "-" | "*" | "/" | "%"
 assign-operator = "=" |
                   "|=" | "&=" | "^=" | "<<=" | ">>=" |
                   "+=" | "-=" | "*=" | "/=" | "%="
 unary-operator = "++" | "--" | "+" | "-" | "~" | "!"
 ```
 **QUESTION**: Do we include the pre/postfix "++" and "--" operators? They were introduced in C to reduce the amount of required characters. But is still necessary?
 And to define various constants in the language, we allow for the following:
 ```
 // Various integer constants, binary, octal, decimal, or hexadecimal, with a
 // utility underscore to enhance humans reading the characters. Allowing use to
 // write something like 100_000_256 or 0xDEAD_BEEF
 int-bin-char = "0" | "1"
 int-bin-constant = "0b" int-bin-char (int-bin-char | "_")* // 0b0100_1110
 int-oct-char = "0"-"7"
 int-oct-constant = "0o" int-oct-char (int-oct-char | "_")* // 0o777
 int-dec-constant = DIGIT (DIGIT | "_")* //
 int-hex-char = DIGIT | "a"-"f" | "A"-"F"
 int-hex-constant = "0x" int-hex-char (int-hex-char | "_")* // 0xFEFE_1337
 int-constant = int-bin-constant | int-oct-constant | int-dec-constant | int-hex-constant
 // Floating point numbers
 // TODO: Maybe support exponential notation? Seems silly for a networking
 //  language, but might be useful?
 float-constant = DIGIT* "." DIGIT+
 // Character constants: a single character. Its element may be an escaped
 // character or a VCHAR (excluding "'" and "\")
 char-element = ESCAPED_CHARS | (0x20-0x26 | 0x28-0x5B | 0x5D-0x7E)
 char-constant = "'" char-element "'"
 // Same thing for strings, but these may contain 0 or more characters
 str-element = ESCAPED_CHARS | (0x20-0x21 | 0x23-0x5B | 0x5D-0x7E)
 str-constant = """ str-element* """
 ```
 Note that the integer characters are forced, somewhat arbitrarily without hampering the programmer's expressiveness, to start with a valid digit. Only then may one introduce the `_` character. And non-rigorously speaking characters may not contain an unescaped `'`-character, and strings may not contain an unescaped `"`-character.
 We now introduce the various identifiers that exist within the language, we make a distinction between "any identifier" and "any identifier except for the builtin ones". Because we h
 ```
 identifier-any = ALPHA | (ALPHA | DIGIT | "_")*
 keyword =
     "composite" | "primitive" |
     type-primitive | "true" | "false" | "null" |
     "struct" | "enum" |
     "if" | "else" |
     "while" | "break" | "continue" | "return" |
     "synchronous" | "assert" |
     "goto" | "skip" | "new" | "let"
-builtin = "put" | "get" | "fires" | "create" | "sizeof" | "assert"
 builtin = "put" | "get" | "fires" | "create" | "assert"
 identifier = identifier-any WITHOUT (keyword | builtin)
 // Identifier with any number of prefixed namespaces
 ns-identifier = (identifier "::")* identifier
 ```
 We then start introducing the type system. Learning from the "mistake" of C/C++ of having types like `byte` and `short` with unspecified and compiler-dependent byte-sizes (followed by everyone using `stdint.h`), we use the Rust/Zig-like `u8`, `i16`, etc. Currently we will limit the programmer to not produce integers which take up more than 64 bits. Furthermore, as one is writing network code, it would be quite neat to be able to put non-byte-aligned integers into a struct in order to directly access meaningful bits. Hence, with restrictions introduced later, we will allow for types like `i4` or `u1`. When actually retrieving them or performing computations with them we will use the next-largest byte-size to operate on them in "registers".
 **Question**: Difference between u1 and bool? Do we allow assignments between them? What about i1 and bool?
 As the language semantics are value-based, we are prevented from returning information from functions through its arguments. We may only return information through its (single) return value. If we consider the common case of having to parse a series of bytes into a meaningful struct, we cannot return both the struct and a value as a success indicator. For this reason, we introduce algebraic datatypes (or: tagged unions, or: enums) as well.
 Lastly, since functions are currently without internal side-effects (since functions cannot perform communication with components, and there is no functionality to interact "with the outside world" from within a function), it does not make sense to introduce the "void" type, as found in C/C++ to indicate that a function doesn't return anything of importance. However, internally we will allow for a "void" type, this will allow treating builtins such as "assert" and "put" like functions while constructing and evaluating the AST.
 ```
 // The digits 1-64, without any leading zeros allowed, to allow specifying the
 // signed and unsigned integer types
 number-1-64 = NZ-DIGIT | (0x31-0x35 DIGIT) | ("6" 0x30-0x34)
 type-signed-int = "i" number-1-64 // i1 through i64
 type-unsigned-int = "u" number-1-64 // u1 through u64
 // Standard floats and bools
 type-float = "f32" | "f64"
 type-bool = "bool"
 // Messages, may be removed later
 type-msg = "msg"
 // Indicators of port types
 type-port = "in" | "out"
 // Unions and tagged unions, so we allow:
 // enum SpecialBool { True, False }
 // enum SpecialBool{True,False,}
 // enum Tagged{Boolean(bool),SignedInt(i64),UnsignedInt(u64),Nothing}
 type-union-element = identifier cw (("(" cw type cw ")") | ("=" cw int-constant))?
 type-union-def = "enum" cwb identifier cw "{" cw type-union-element (cw "," cw type-union-element)* (cw ",")? cw "}"
 // Structs, so we allow:
 // struct { u8 type, u2 flag0, u6 reserved }
 type-struct-element = type cwb identifier
 type-struct-def = "struct" cwb identifier cw "{" cw type-struct-element (cw "," cw type-struct-element)* (cw ",")? cw "}"
 type-primitive = type-signed-int |
     type-unsigned-int |
     type-float |
     type-bool |
     type-msg |
     type-port
 // A type may be a user-defined type (e.g. "struct Bla"), a namespaced
 // user type (e.g. "Module::Bla"), or a non-namespaced primitive type. We
 // currently have no way (yet) to access nested modules, so we don't need to
 // care about identifier nesting.
 type = type-primitive | ns-identifier
 ```
 With these types, we need to introduce some extra constant types. Ones that are used to construct struct instances and ones that are used to construct/assign enums. These are constructed as:
 ```
 // Struct literals
 struct-constant-element = identifier cw ":" cw expr
 struct-constant = ns-identifier cw "{" cw struct-constant-element (cw "," struct-constant-element)* cw "}"
 enum-constant = ns-identifier "::" identifier cw "(" cw expr cw ")"
 ```
 Finally, we declare methods and field accessors as:
 ```
 method = builtin | ns-identifier
 field = "length" | identifier
 ```
 **Question**: This requires some discussion. We allow for a "length" field on messages, and allow the definition of arrays. But if we wish to perform computation in a simple fashion, we need to allow for variable-length arrays of custom types. This requires builtin methods like "push", "pop", etc. But I suppose there is a much nicer way... In any case, this reminds me of programming in Fortran, which I definitely don't want to impose on other people (that, or I will force 72-character line lengths on them as well)
 When we parse a particular source file, we may expect the following "pragmas" to be sprinkled at the top of the source
 file. They may exist at any position in the global scope of a source file.
 ```
 // A domain identifier is a dot-separated sequence of identifiers. As these are
 // only used to identify modules we allow any identifier to be used in them.
 // The exception is the last identifier, which we, due to namespacing rules,
 // force to be a non-reserved identifier.
 domain-identifier = (identifier-any ".")* identifier
 pragma-version = "#version" cwb int-constant cw ";" // e.g. #version 500
 pragma-module = "#module" cwb domain-identifier cw ";" // e.g. #module hello.there
 // Import, e.g.
 // #import module.submodule // access through submodule::function(), or submodule::Type
 // #import module.submodule as Sub // access through Sub::function(), or Sub::type
 // #import module.submodule::* // access through function(), or Type
 // #import module.submodule::{function} // access through function()
 // #import module.submodule::{function as func, type} // access through func() or type
 pragma-import-alias = cwb "as" cwb identifier
 pragma-import-all = "::*"
 pragma-import-single-symbol = "::" identifier pragma-import-alias?
 pragma-import-multi-symbol = "::{" ...
     cw identifier pragma-import-alias? ...
     (cw "," cw identifier pragma-import-alias?)* ...
     (cw ",")? cw "}"
 pragma-import = "#import" cwb domain-identifier ...
     (pragma-import-alias | pragma-import-all | pragma-import-single-symbol | pragma-import-multi-symbol)?
 // Custom pragmas for people which may be using (sometime, somewhere)
 // metaprogramming with pragmas
 pragma-custom = "#" identifier-any (cwb VCHAR (VCHAR | WS)*) cw ";"
 // Finally, a pragma may be any of the ones above
 pragma = pragma-version | pragma-module | pragma-import | pragma-custom
 ```
 Note that, different from C-like languages, we do require semicolons to exist at the end of a pragma statement. The reason is to prevent future hacks using the "\" character to indicate an end-of-line-but-not-really-end-of-line statements.
 Apart from these pragmas, we can have component definitions, type definitions and function definitions within the source file. The grammar for these may be formulated as:
 ```
 // Annotated types and function/component arguments
 type-annotation = type (cw [])?
 var-declaration = type-annotation cwb identifier
 params-list = "(" cw (var-declaration (cw "," cw var-declaration)*)? cw ")"
 // Functions and components
 function-def = type-annotation cwb identifier cw params-list cw block
 composite-def = "composite" cwb identifier cw params-list cw block
 primitive-def = "primitive" cwb identifier cw params-list cw block
 component-def = composite-def | primitive-def
 // Symbol definitions now become
 symbol-def = type-union-def | type-struct-def | function-def | component-def
 ```
 Using these rules, we can now describe the grammar of a single file as:
 ```
 file = cw (pragma | symbol-def)* cw
 ```
 Of course, we currently cannot do anything useful with our grammar, hence we have to describe blocks to let the functions and component definitions do something. To do so, we proceed as:
 ```
 // channel a->b;, or channel a -> b;
 channel-decl = channel cwb identifier cw "->" cw identifier cw ";"
 // int a = 5, b = 2 + 3;
 memory-decl = var-declaration cw "=" cw expression (cw "," cw identifier cw "=" cw expression)* cw ";"
 stmt = block |
     identifier cw ":" cw stmt | // label
     "if" cw pexpr cw stmt (cw "else" cwb stmt)? |
     "while" cw pexpr cw stmt |
     "break" (cwb identifier)? cw ";" |
     "continue" (cwb identifier)? cw ";" |
     "synchronous" stmt |
     "return" cwb identifier cw ";" |
     "goto" cwb identifier cw ";" |
     "skip" cw ";" |
     "new" cwb method-expr cw ";" |
     expr cw ";"
 // TODO: Add all the other expressions
 // TODO: Also: add struct construction and enum construction
 method-params-list = "(" cw (expr (cw "," cw expr)* )? cw ")"
 method-expr = method cw method-params-list
 enum-destructure-expr = "let" cw ns-identifier "::" identifier cw "(" cw identifier cw ")" cw "=" expr
 enum-test-expr = ns-identifier "::" identifier cw "==" cw expr
 block = "{" (cw (channel-decl | memory-decl | stmt))* cw "}"
 ```
 Note that we have a potential collision of various expressions/statements. The following cases are of importance:
 . An empty block is written as `{}`, while an empty array construction is also written as `{}`.
 . Both function calls as enum constants feature the same construction syntax. That is: `foo::bar(expression)` may refer to a function call to `bar` in the namespace `foo`, but may also be the construction of enum `foo`'s `bar` variant (containing a value `expression`). These may be disambiguated using the type system.
 . The enumeration destructuring expression may collide with the constant enumeration literal. These may be disambiguated by looking at the inner value. If the inner value is an identifier and not yet defined as a variable, then it is a destructuring expression. Otherwise it must be interpreted as a constant enumeration. The enumeration destructuring expression must then be completed by it being a child of an binary equality operator. If not, then it is invalid syntax.
 Finally, for consistency, there are additional rules to the enumeration destructuring. As a preamble: the language should allow programmers to express any kind of trickery they want, as long as it is correct. But programmers should be prevented from expressing something that is by definition incorrect/illogical. So enumeration destructuring (e.g. `Enum::Variant(bla) == expression`) should return a value with a special type (e.g. `EnumDestructureBool`) that may only reside within the testing expressions of `if` and `while` statements. Furthermore, this special boolean type only supports the logical-and (`&&`) operator. This way we prevent invalid expressions such as `if (Enum::Variant1(foo) == expr || Enum::Variant2(bar) == expr) { ... }`, but we do allow potentially valid expressions like `if (Enum::Variant1(foo) == expr_foo && Enum::Variant2(bar) == expr_bar) { ... }`.
 **Question**: In the documentation for V1.0 we find the `synchronous cw (params-list cw stmt | block)` rule. Why the `params-list`?
 **TODO**: Release constructions on memory declarations: as long as we have a write to it before a read we should be fine. Can be done once we add semantic analysis in order to optimize putting and getting port values.
 **TODO**: Implement type inference, should be simpler once I figure out how to write a typechecker.
 **TODO**: Add constants assigned in the global scope.
 **TODO**: Add a runtime expression evaluator (probably before constants in global scope) to simplify expressions and/or remove impossible branches.
@@ \ No newline at end of file @@

src/protocol/arena.rs

➞

Show inline comments

 use crate::common::*;
 use core::hash::Hash;
 use core::marker::PhantomData;
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Id<T> {
     pub(crate) index: u32,
     _phantom: PhantomData<T>,
+}
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub(crate) struct Arena<T> {
     store: Vec<T>,
+}
 //////////////////////////////////
 impl<T> Debug for Id<T> {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         f.debug_struct("Id").field("index", &self.index).finish()
+    }
+}
 impl<T> Clone for Id<T> {
     fn clone(&self) -> Self {
         *self
+    }
+}
 impl<T> Copy for Id<T> {}
 impl<T> PartialEq for Id<T> {
     fn eq(&self, other: &Self) -> bool {
         self.index.eq(&other.index)
+    }
+}
 impl<T> Eq for Id<T> {}
 impl<T> Hash for Id<T> {
     fn hash<H: std::hash::Hasher>(&self, h: &mut H) {
         self.index.hash(h);
+    }
+}
 impl<T> Arena<T> {
     pub fn new() -> Self {
         Self { store: vec![] }
+    }
     pub fn alloc_with_id(&mut self, f: impl FnOnce(Id<T>) -> T) -> Id<T> {
         use std::convert::TryFrom;
         let id = Id {
             index: u32::try_from(self.store.len()).expect("Out of capacity!"),
             _phantom: Default::default(),
         };
         self.store.push(f(id));
         id
+    }
     pub fn iter(&self) -> impl Iterator<Item = &T> {
         self.store.iter()
+    }
     pub fn len(&self) -> usize {
         self.store.len()
+    }
+}
 impl<T> core::ops::Index<Id<T>> for Arena<T> {
     type Output = T;
     fn index(&self, id: Id<T>) -> &Self::Output {
         self.store.index(id.index as usize)
+    }
+}
 impl<T> core::ops::IndexMut<Id<T>> for Arena<T> {
     fn index_mut(&mut self, id: Id<T>) -> &mut Self::Output {
         self.store.index_mut(id.index as usize)
+    }
+}
@@ \ No newline at end of file @@

src/protocol/ast.rs

➞

Show inline comments

 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::{Index, IndexMut};
 use super::arena::{Arena, Id};
 // use super::containers::StringAllocator;
 use crate::protocol::inputsource::*;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct RootId(pub(crate) Id<Root>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PragmaId(Id<Pragma>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ImportId(Id<Import>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct TypeAnnotationId(Id<TypeAnnotation>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct VariableId(Id<Variable>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct ParameterId(VariableId);
 impl ParameterId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct LocalId(VariableId);
 impl LocalId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct DefinitionId(Id<Definition>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct StructId(DefinitionId);
 impl StructId {
     pub fn upcast(self) -> DefinitionId{
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EnumId(DefinitionId);
 impl EnumId {
     pub fn upcast(self) -> DefinitionId{
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ComponentId(DefinitionId);
 impl ComponentId {
     pub fn upcast(self) -> DefinitionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct FunctionId(DefinitionId);
 impl FunctionId {
     pub fn upcast(self) -> DefinitionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct CompositeId(ComponentId);
 impl CompositeId {
     pub fn upcast(self) -> ComponentId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PrimitiveId(ComponentId);
 impl PrimitiveId {
     pub fn upcast(self) -> ComponentId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct StatementId(Id<Statement>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BlockStatementId(StatementId);
 impl BlockStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct LocalStatementId(StatementId);
 impl LocalStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct MemoryStatementId(LocalStatementId);
 impl MemoryStatementId {
     pub fn upcast(self) -> LocalStatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ChannelStatementId(LocalStatementId);
 impl ChannelStatementId {
     pub fn upcast(self) -> LocalStatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SkipStatementId(StatementId);
 impl SkipStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct LabeledStatementId(StatementId);
 impl LabeledStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct IfStatementId(StatementId);
 impl IfStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndIfStatementId(StatementId);
 impl EndIfStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct WhileStatementId(StatementId);
 impl WhileStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndWhileStatementId(StatementId);
 impl EndWhileStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BreakStatementId(StatementId);
 impl BreakStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ContinueStatementId(StatementId);
 impl ContinueStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SynchronousStatementId(StatementId);
 impl SynchronousStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndSynchronousStatementId(StatementId);
 impl EndSynchronousStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ReturnStatementId(StatementId);
 impl ReturnStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct AssertStatementId(StatementId);
 impl AssertStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct GotoStatementId(StatementId);
 impl GotoStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct NewStatementId(StatementId);
 impl NewStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PutStatementId(StatementId);
 impl PutStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionStatementId(StatementId);
 impl ExpressionStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionId(Id<Expression>);
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub struct AssignmentExpressionId(ExpressionId);
 impl AssignmentExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ConditionalExpressionId(ExpressionId);
 impl ConditionalExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BinaryExpressionId(ExpressionId);
 impl BinaryExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct UnaryExpressionId(ExpressionId);
 impl UnaryExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct IndexingExpressionId(ExpressionId);
 impl IndexingExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SlicingExpressionId(ExpressionId);
 impl SlicingExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SelectExpressionId(ExpressionId);
 impl SelectExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ArrayExpressionId(ExpressionId);
 impl ArrayExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ConstantExpressionId(ExpressionId);
 impl ConstantExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct CallExpressionId(ExpressionId);
 impl CallExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct VariableExpressionId(ExpressionId);
 impl VariableExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DeclarationId(Id<Declaration>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DefinedDeclarationId(DeclarationId);
 impl DefinedDeclarationId {
     pub fn upcast(self) -> DeclarationId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ImportedDeclarationId(DeclarationId);
 impl ImportedDeclarationId {
     pub fn upcast(self) -> DeclarationId {
         self.0
+    }
+}
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct Heap {
     // Allocators
-    // #[serde[skip]] string_alloc: StringAllocator,
+    // #[serde(skip)] string_alloc: StringAllocator,
     // Root arena, contains the entry point for different modules. Each root
     // contains lists of IDs that correspond to the other arenas.
     protocol_descriptions: Arena<Root>,
     // Contents of a file, these are the elements the `Root` elements refer to
     pragmas: Arena<Pragma>,
     pub(crate) imports: Arena<Import>,
     identifiers: Arena<Identifier>,
     type_annotations: Arena<TypeAnnotation>,
     variables: Arena<Variable>,
     pub(crate) definitions: Arena<Definition>,
     statements: Arena<Statement>,
     expressions: Arena<Expression>,
     declarations: Arena<Declaration>,
+}
 impl Heap {
     pub fn new() -> Heap {
         Heap {
             // string_alloc: StringAllocator::new(),
             protocol_descriptions: Arena::new(),
             pragmas: Arena::new(),
             imports: Arena::new(),
             identifiers: Arena::new(),
             type_annotations: Arena::new(),
             variables: Arena::new(),
             definitions: Arena::new(),
             statements: Arena::new(),
             expressions: Arena::new(),
             declarations: Arena::new(),
+        }
+    }
     pub fn alloc_type_annotation(
         &mut self,
         f: impl FnOnce(TypeAnnotationId) -> TypeAnnotation,
     ) -> TypeAnnotationId {
         TypeAnnotationId(self.type_annotations.alloc_with_id(|id| f(TypeAnnotationId(id))))
+    }
     pub fn alloc_parameter(&mut self, f: impl FnOnce(ParameterId) -> Parameter) -> ParameterId {
         ParameterId(VariableId(
             self.variables.alloc_with_id(|id| Variable::Parameter(f(ParameterId(VariableId(id))))),
         ))
+    }
     pub fn alloc_local(&mut self, f: impl FnOnce(LocalId) -> Local) -> LocalId {
         LocalId(VariableId(
             self.variables.alloc_with_id(|id| Variable::Local(f(LocalId(VariableId(id))))),
         ))
+    }
     pub fn alloc_assignment_expression(
         &mut self,
         f: impl FnOnce(AssignmentExpressionId) -> AssignmentExpression,
     ) -> AssignmentExpressionId {
         AssignmentExpressionId(ExpressionId(self.expressions.alloc_with_id(|id| {
             Expression::Assignment(f(AssignmentExpressionId(ExpressionId(id))))
         })))
+    }
     pub fn alloc_conditional_expression(
         &mut self,
         f: impl FnOnce(ConditionalExpressionId) -> ConditionalExpression,
     ) -> ConditionalExpressionId {
         ConditionalExpressionId(ExpressionId(self.expressions.alloc_with_id(|id| {
             Expression::Conditional(f(ConditionalExpressionId(ExpressionId(id))))
         })))
+    }
     pub fn alloc_binary_expression(
         &mut self,
         f: impl FnOnce(BinaryExpressionId) -> BinaryExpression,
     ) -> BinaryExpressionId {
         BinaryExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Binary(f(BinaryExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_unary_expression(
         &mut self,
         f: impl FnOnce(UnaryExpressionId) -> UnaryExpression,
     ) -> UnaryExpressionId {
         UnaryExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Unary(f(UnaryExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_slicing_expression(
         &mut self,
         f: impl FnOnce(SlicingExpressionId) -> SlicingExpression,
     ) -> SlicingExpressionId {
         SlicingExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Slicing(f(SlicingExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_indexing_expression(
         &mut self,
         f: impl FnOnce(IndexingExpressionId) -> IndexingExpression,
     ) -> IndexingExpressionId {
         IndexingExpressionId(ExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Indexing(f(IndexingExpressionId(ExpressionId(id))))
             }),
         ))
+    }
     pub fn alloc_select_expression(
         &mut self,
         f: impl FnOnce(SelectExpressionId) -> SelectExpression,
     ) -> SelectExpressionId {
         SelectExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Select(f(SelectExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_array_expression(
         &mut self,
         f: impl FnOnce(ArrayExpressionId) -> ArrayExpression,
     ) -> ArrayExpressionId {
         ArrayExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Array(f(ArrayExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_constant_expression(
         &mut self,
         f: impl FnOnce(ConstantExpressionId) -> ConstantExpression,
     ) -> ConstantExpressionId {
         ConstantExpressionId(ExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Constant(f(ConstantExpressionId(ExpressionId(id))))
             }),
         ))
+    }
     pub fn alloc_call_expression(
         &mut self,
         f: impl FnOnce(CallExpressionId) -> CallExpression,
     ) -> CallExpressionId {
         CallExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Call(f(CallExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_variable_expression(
         &mut self,
         f: impl FnOnce(VariableExpressionId) -> VariableExpression,
     ) -> VariableExpressionId {
         VariableExpressionId(ExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Variable(f(VariableExpressionId(ExpressionId(id))))
             }),
         ))
+    }
     pub fn alloc_block_statement(
         &mut self,
         f: impl FnOnce(BlockStatementId) -> BlockStatement,
     ) -> BlockStatementId {
         BlockStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Block(f(BlockStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_memory_statement(
         &mut self,
         f: impl FnOnce(MemoryStatementId) -> MemoryStatement,
     ) -> MemoryStatementId {
         MemoryStatementId(LocalStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Memory(f(MemoryStatementId(LocalStatementId(
                 StatementId(id),
             )))))
         }))))
+    }
     pub fn alloc_channel_statement(
         &mut self,
         f: impl FnOnce(ChannelStatementId) -> ChannelStatement,
     ) -> ChannelStatementId {
         ChannelStatementId(LocalStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Channel(f(ChannelStatementId(LocalStatementId(
                 StatementId(id),
             )))))
         }))))
+    }
     pub fn alloc_skip_statement(
         &mut self,
         f: impl FnOnce(SkipStatementId) -> SkipStatement,
     ) -> SkipStatementId {
         SkipStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Skip(f(SkipStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_if_statement(
         &mut self,
         f: impl FnOnce(IfStatementId) -> IfStatement,
     ) -> IfStatementId {
         IfStatementId(StatementId(
             self.statements.alloc_with_id(|id| Statement::If(f(IfStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_end_if_statement(
         &mut self,
         f: impl FnOnce(EndIfStatementId) -> EndIfStatement,
     ) -> EndIfStatementId {
         EndIfStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::EndIf(f(EndIfStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_while_statement(
         &mut self,
         f: impl FnOnce(WhileStatementId) -> WhileStatement,
     ) -> WhileStatementId {
         WhileStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::While(f(WhileStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_end_while_statement(
         &mut self,
         f: impl FnOnce(EndWhileStatementId) -> EndWhileStatement,
     ) -> EndWhileStatementId {
         EndWhileStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::EndWhile(f(EndWhileStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_break_statement(
         &mut self,
         f: impl FnOnce(BreakStatementId) -> BreakStatement,
     ) -> BreakStatementId {
         BreakStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Break(f(BreakStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_continue_statement(
         &mut self,
         f: impl FnOnce(ContinueStatementId) -> ContinueStatement,
     ) -> ContinueStatementId {
         ContinueStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Continue(f(ContinueStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_synchronous_statement(
         &mut self,
         f: impl FnOnce(SynchronousStatementId) -> SynchronousStatement,
     ) -> SynchronousStatementId {
         SynchronousStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::Synchronous(f(SynchronousStatementId(StatementId(id))))
         })))
+    }
     pub fn alloc_end_synchronous_statement(
         &mut self,
         f: impl FnOnce(EndSynchronousStatementId) -> EndSynchronousStatement,
     ) -> EndSynchronousStatementId {
         EndSynchronousStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::EndSynchronous(f(EndSynchronousStatementId(StatementId(id))))
         })))
+    }
     pub fn alloc_return_statement(
         &mut self,
         f: impl FnOnce(ReturnStatementId) -> ReturnStatement,
     ) -> ReturnStatementId {
         ReturnStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Return(f(ReturnStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_assert_statement(
         &mut self,
         f: impl FnOnce(AssertStatementId) -> AssertStatement,
     ) -> AssertStatementId {
         AssertStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Assert(f(AssertStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_goto_statement(
         &mut self,
         f: impl FnOnce(GotoStatementId) -> GotoStatement,
     ) -> GotoStatementId {
         GotoStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Goto(f(GotoStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_new_statement(
         &mut self,
         f: impl FnOnce(NewStatementId) -> NewStatement,
     ) -> NewStatementId {
         NewStatementId(StatementId(
             self.statements.alloc_with_id(|id| Statement::New(f(NewStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_put_statement(
         &mut self,
         f: impl FnOnce(PutStatementId) -> PutStatement,
     ) -> PutStatementId {
         PutStatementId(StatementId(
             self.statements.alloc_with_id(|id| Statement::Put(f(PutStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_labeled_statement(
         &mut self,
         f: impl FnOnce(LabeledStatementId) -> LabeledStatement,
     ) -> LabeledStatementId {
         LabeledStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Labeled(f(LabeledStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_expression_statement(
         &mut self,
         f: impl FnOnce(ExpressionStatementId) -> ExpressionStatement,
     ) -> ExpressionStatementId {
         ExpressionStatementId(StatementId(
             self.statements.alloc_with_id(|id| {
                 Statement::Expression(f(ExpressionStatementId(StatementId(id))))
             }),
         ))
+    }
     pub fn alloc_struct_definition(&mut self, f: impl FnOnce(StructId) -> StructDefinition) -> StructId {
         StructId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Struct(f(StructId(DefinitionId(id))))
         })))
+    }
     pub fn alloc_enum_definition(&mut self, f: impl FnOnce(EnumId) -> EnumDefinition) -> EnumId {
         EnumId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Enum(f(EnumId(DefinitionId(id))))
         })))
+    }
     pub fn alloc_composite(&mut self, f: impl FnOnce(CompositeId) -> Composite) -> CompositeId {
         CompositeId(ComponentId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Component(Component::Composite(f(CompositeId(ComponentId(DefinitionId(
                 id,
             ))))))
         }))))
+    }
     pub fn alloc_primitive(&mut self, f: impl FnOnce(PrimitiveId) -> Primitive) -> PrimitiveId {
         PrimitiveId(ComponentId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Component(Component::Primitive(f(PrimitiveId(ComponentId(DefinitionId(
                 id,
             ))))))
         }))))
     pub fn alloc_component(&mut self, f: impl FnOnce(ComponentId) -> Component) -> ComponentId {
         ComponentId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Component(f(ComponentId(
                 DefinitionId(id),
             )))
         })))
+    }
     pub fn alloc_function(&mut self, f: impl FnOnce(FunctionId) -> Function) -> FunctionId {
         FunctionId(DefinitionId(
             self.definitions
                 .alloc_with_id(|id| Definition::Function(f(FunctionId(DefinitionId(id))))),
         ))
+    }
     pub fn alloc_pragma(&mut self, f: impl FnOnce(PragmaId) -> Pragma) -> PragmaId {
         PragmaId(self.pragmas.alloc_with_id(|id| f(PragmaId(id))))
+    }
     pub fn alloc_import(&mut self, f: impl FnOnce(ImportId) -> Import) -> ImportId {
         ImportId(self.imports.alloc_with_id(|id| f(ImportId(id))))
+    }
     pub fn alloc_protocol_description(&mut self, f: impl FnOnce(RootId) -> Root) -> RootId {
         RootId(self.protocol_descriptions.alloc_with_id(|id| f(RootId(id))))
+    }
     pub fn alloc_imported_declaration(
         &mut self,
         f: impl FnOnce(ImportedDeclarationId) -> ImportedDeclaration,
     ) -> ImportedDeclarationId {
         ImportedDeclarationId(DeclarationId(self.declarations.alloc_with_id(|id| {
             Declaration::Imported(f(ImportedDeclarationId(DeclarationId(id))))
         })))
+    }
     pub fn alloc_defined_declaration(
         &mut self,
         f: impl FnOnce(DefinedDeclarationId) -> DefinedDeclaration,
     ) -> DefinedDeclarationId {
         DefinedDeclarationId(DeclarationId(
             self.declarations.alloc_with_id(|id| {
                 Declaration::Defined(f(DefinedDeclarationId(DeclarationId(id))))
             }),
         ))
+    }
+}
 impl Index<RootId> for Heap {
     type Output = Root;
     fn index(&self, index: RootId) -> &Self::Output {
         &self.protocol_descriptions[index.0]
+    }
+}
 impl IndexMut<RootId> for Heap {
     fn index_mut(&mut self, index: RootId) -> &mut Self::Output {
         &mut self.protocol_descriptions[index.0]
+    }
+}
 impl Index<PragmaId> for Heap {
     type Output = Pragma;
     fn index(&self, index: PragmaId) -> &Self::Output {
         &self.pragmas[index.0]
+    }
+}
 impl Index<ImportId> for Heap {
     type Output = Import;
     fn index(&self, index: ImportId) -> &Self::Output {
         &self.imports[index.0]
+    }
+}
 impl IndexMut<ImportId> for Heap {
     fn index_mut(&mut self, index: ImportId) -> &mut Self::Output {
         &mut self.imports[index.0]
+    }
+}
 impl Index<TypeAnnotationId> for Heap {
     type Output = TypeAnnotation;
     fn index(&self, index: TypeAnnotationId) -> &Self::Output {
         &self.type_annotations[index.0]
+    }
+}
 impl Index<VariableId> for Heap {
     type Output = Variable;
     fn index(&self, index: VariableId) -> &Self::Output {
         &self.variables[index.0]
+    }
+}
 impl Index<ParameterId> for Heap {
     type Output = Parameter;
     fn index(&self, index: ParameterId) -> &Self::Output {
         &self.variables[(index.0).0].as_parameter()
+    }
+}
 impl Index<LocalId> for Heap {
     type Output = Local;
     fn index(&self, index: LocalId) -> &Self::Output {
         &self.variables[(index.0).0].as_local()
+    }
+}
 impl Index<DefinitionId> for Heap {
     type Output = Definition;
     fn index(&self, index: DefinitionId) -> &Self::Output {
         &self.definitions[index.0]
+    }
+}
 impl Index<ComponentId> for Heap {
     type Output = Component;
     fn index(&self, index: ComponentId) -> &Self::Output {
         &self.definitions[(index.0).0].as_component()
+    }
+}
 impl Index<FunctionId> for Heap {
     type Output = Function;
     fn index(&self, index: FunctionId) -> &Self::Output {
         &self.definitions[(index.0).0].as_function()
+    }
+}
 impl Index<CompositeId> for Heap {
     type Output = Composite;
     fn index(&self, index: CompositeId) -> &Self::Output {
         &self.definitions[((index.0).0).0].as_composite()
+    }
+}
 impl Index<PrimitiveId> for Heap {
     type Output = Primitive;
     fn index(&self, index: PrimitiveId) -> &Self::Output {
         &self.definitions[((index.0).0).0].as_primitive()
+    }
+}
 impl Index<StatementId> for Heap {
     type Output = Statement;
     fn index(&self, index: StatementId) -> &Self::Output {
         &self.statements[index.0]
+    }
+}
 impl IndexMut<StatementId> for Heap {
     fn index_mut(&mut self, index: StatementId) -> &mut Self::Output {
         &mut self.statements[index.0]
+    }
+}
 impl Index<BlockStatementId> for Heap {
     type Output = BlockStatement;
     fn index(&self, index: BlockStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_block()
+    }
+}
 impl IndexMut<BlockStatementId> for Heap {
     fn index_mut(&mut self, index: BlockStatementId) -> &mut Self::Output {
         (&mut self.statements[(index.0).0]).as_block_mut()
+    }
+}
 impl Index<LocalStatementId> for Heap {
     type Output = LocalStatement;
     fn index(&self, index: LocalStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_local()
+    }
+}
 impl Index<MemoryStatementId> for Heap {
     type Output = MemoryStatement;
     fn index(&self, index: MemoryStatementId) -> &Self::Output {
         &self.statements[((index.0).0).0].as_memory()
+    }
+}
 impl Index<ChannelStatementId> for Heap {
     type Output = ChannelStatement;
     fn index(&self, index: ChannelStatementId) -> &Self::Output {
         &self.statements[((index.0).0).0].as_channel()
+    }
+}
 impl Index<SkipStatementId> for Heap {
     type Output = SkipStatement;
     fn index(&self, index: SkipStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_skip()
+    }
+}
 impl Index<LabeledStatementId> for Heap {
     type Output = LabeledStatement;
     fn index(&self, index: LabeledStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_labeled()
+    }
+}
 impl IndexMut<LabeledStatementId> for Heap {
     fn index_mut(&mut self, index: LabeledStatementId) -> &mut Self::Output {
         (&mut self.statements[(index.0).0]).as_labeled_mut()
+    }
+}
 impl Index<IfStatementId> for Heap {
     type Output = IfStatement;
     fn index(&self, index: IfStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_if()
+    }
+}
 impl Index<EndIfStatementId> for Heap {
     type Output = EndIfStatement;
     fn index(&self, index: EndIfStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_end_if()
+    }
+}
 impl Index<WhileStatementId> for Heap {
     type Output = WhileStatement;
     fn index(&self, index: WhileStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_while()
+    }
+}
 impl IndexMut<WhileStatementId> for Heap {
     fn index_mut(&mut self, index: WhileStatementId) -> &mut Self::Output {
         (&mut self.statements[(index.0).0]).as_while_mut()
+    }
+}
 impl Index<BreakStatementId> for Heap {
     type Output = BreakStatement;
     fn index(&self, index: BreakStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_break()
+    }
+}
 impl IndexMut<BreakStatementId> for Heap {
     fn index_mut(&mut self, index: BreakStatementId) -> &mut Self::Output {
         (&mut self.statements[(index.0).0]).as_break_mut()
+    }
+}
 impl Index<ContinueStatementId> for Heap {
     type Output = ContinueStatement;
     fn index(&self, index: ContinueStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_continue()
+    }
+}
 impl IndexMut<ContinueStatementId> for Heap {
     fn index_mut(&mut self, index: ContinueStatementId) -> &mut Self::Output {
         (&mut self.statements[(index.0).0]).as_continue_mut()
+    }
+}
 impl Index<SynchronousStatementId> for Heap {
     type Output = SynchronousStatement;
     fn index(&self, index: SynchronousStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_synchronous()
+    }
+}
 impl IndexMut<SynchronousStatementId> for Heap {
     fn index_mut(&mut self, index: SynchronousStatementId) -> &mut Self::Output {
         (&mut self.statements[(index.0).0]).as_synchronous_mut()
+    }
+}
 impl Index<EndSynchronousStatementId> for Heap {
     type Output = EndSynchronousStatement;
     fn index(&self, index: EndSynchronousStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_end_synchronous()
+    }
+}
 impl Index<ReturnStatementId> for Heap {
     type Output = ReturnStatement;
     fn index(&self, index: ReturnStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_return()
+    }
+}
 impl Index<AssertStatementId> for Heap {
     type Output = AssertStatement;
     fn index(&self, index: AssertStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_assert()
+    }
+}
 impl Index<GotoStatementId> for Heap {
     type Output = GotoStatement;
     fn index(&self, index: GotoStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_goto()
+    }
+}
 impl IndexMut<GotoStatementId> for Heap {
     fn index_mut(&mut self, index: GotoStatementId) -> &mut Self::Output {
         (&mut self.statements[(index.0).0]).as_goto_mut()
+    }
+}
 impl Index<NewStatementId> for Heap {
     type Output = NewStatement;
     fn index(&self, index: NewStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_new()
+    }
+}
 impl Index<PutStatementId> for Heap {
     type Output = PutStatement;
     fn index(&self, index: PutStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_put()
+    }
+}
 impl Index<ExpressionStatementId> for Heap {
     type Output = ExpressionStatement;
     fn index(&self, index: ExpressionStatementId) -> &Self::Output {
         &self.statements[(index.0).0].as_expression()
+    }
+}
 impl Index<ExpressionId> for Heap {
     type Output = Expression;
     fn index(&self, index: ExpressionId) -> &Self::Output {
         &self.expressions[index.0]
+    }
+}
 impl Index<AssignmentExpressionId> for Heap {
     type Output = AssignmentExpression;
     fn index(&self, index: AssignmentExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_assignment()
+    }
+}
 impl Index<ConditionalExpressionId> for Heap {
     type Output = ConditionalExpression;
     fn index(&self, index: ConditionalExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_conditional()
+    }
+}
 impl Index<BinaryExpressionId> for Heap {
     type Output = BinaryExpression;
     fn index(&self, index: BinaryExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_binary()
+    }
+}
 impl Index<UnaryExpressionId> for Heap {
     type Output = UnaryExpression;
     fn index(&self, index: UnaryExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_unary()
+    }
+}
 impl Index<IndexingExpressionId> for Heap {
     type Output = IndexingExpression;
     fn index(&self, index: IndexingExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_indexing()
+    }
+}
 impl Index<SlicingExpressionId> for Heap {
     type Output = SlicingExpression;
     fn index(&self, index: SlicingExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_slicing()
+    }
+}
 impl Index<SelectExpressionId> for Heap {
     type Output = SelectExpression;
     fn index(&self, index: SelectExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_select()
+    }
+}
 impl Index<ArrayExpressionId> for Heap {
     type Output = ArrayExpression;
     fn index(&self, index: ArrayExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_array()
+    }
+}
 impl Index<ConstantExpressionId> for Heap {
     type Output = ConstantExpression;
     fn index(&self, index: ConstantExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_constant()
+    }
+}
 impl Index<CallExpressionId> for Heap {
     type Output = CallExpression;
     fn index(&self, index: CallExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_call()
+    }
+}
 impl IndexMut<CallExpressionId> for Heap {
     fn index_mut(&mut self, index: CallExpressionId) -> &mut Self::Output {
         (&mut self.expressions[(index.0).0]).as_call_mut()
+    }
+}
 impl Index<VariableExpressionId> for Heap {
     type Output = VariableExpression;
     fn index(&self, index: VariableExpressionId) -> &Self::Output {
         &self.expressions[(index.0).0].as_variable()
+    }
+}
 impl IndexMut<VariableExpressionId> for Heap {
     fn index_mut(&mut self, index: VariableExpressionId) -> &mut Self::Output {
         (&mut self.expressions[(index.0).0]).as_variable_mut()
+    }
+}
 impl Index<DeclarationId> for Heap {
     type Output = Declaration;
     fn index(&self, index: DeclarationId) -> &Self::Output {
         &self.declarations[index.0]
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Root {
     pub this: RootId,
     // Phase 1: parser
     pub position: InputPosition,
     pub pragmas: Vec<PragmaId>,
     pub imports: Vec<ImportId>,
     pub definitions: Vec<DefinitionId>,
     // Pase 2: linker
     pub declarations: Vec<DeclarationId>,
+}
 impl Root {
     pub fn get_definition_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {
         for &def in self.definitions.iter() {
             if h[def].identifier().value == id {
                 return Some(def);
+            }
+        }
         None
+    }
     pub fn get_declaration(&self, h: &Heap, id: &Identifier) -> Option<DeclarationId> {
         for declaration_id in self.declarations.iter() {
             let declaration = &h[*declaration_id];
             if declaration.identifier().value == id.value {
                 return Some(*declaration_id);
+            }
+        }
         None
+    }
     pub fn get_declaration_namespaced(&self, h: &Heap, id: &NamespacedIdentifier) -> Option<DeclarationId> {
         for declaration_id in self.declarations.iter() {
             let declaration = &h[*declaration_id];
             // TODO: @fixme
             if declaration.identifier().value == id.value {
                 return Some(*declaration_id);
+            }
+        }
         None
+    }
+}
 impl SyntaxElement for Root {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Pragma {
     Version(PragmaVersion),
     Module(PragmaModule)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaVersion {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub version: u64,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaModule {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaOld {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
 impl SyntaxElement for PragmaOld {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Import {
     Module(ImportModule),
     Symbols(ImportSymbols)
+}
 impl Import {
     pub(crate) fn as_module(&self) -> &ImportModule {
         match self {
             Import::Module(m) => m,
             _ => panic!("Unable to cast 'Import' to 'ImportModule'")
+        }
+    }
     pub(crate) fn as_symbols(&self) -> &ImportSymbols {
         match self {
             Import::Symbols(m) => m,
             _ => panic!("Unable to cast 'Import' to 'ImportSymbols'")
+        }
+    }
+}
 impl SyntaxElement for Import {
     fn position(&self) -> InputPosition {
         match self {
             Import::Module(m) => m.position,
             Import::Symbols(m) => m.position
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportModule {
     pub this: ImportId,
     // Phase 1: parser
     pub position: InputPosition,
     pub module_name: Vec<u8>,
     pub alias: Vec<u8>,
     // Phase 2: module resolving
     pub module_id: Option<RootId>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AliasedSymbol {
     // Phase 1: parser
     pub position: InputPosition,
     pub name: Vec<u8>,
     pub alias: Vec<u8>,
     // Phase 2: symbol resolving
     pub definition_id: Option<DefinitionId>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportSymbols {
     pub this: ImportId,
     // Phase 1: parser
     pub position: InputPosition,
     pub module_name: Vec<u8>,
     // Phase 2: module resolving
     pub module_id: Option<RootId>,
     // Phase 1&2
     // if symbols is empty, then we implicitly import all symbols without any
     // aliases for them. If it is not empty, then symbols are explicitly
     // specified, and optionally given an alias.
     pub symbols: Vec<AliasedSymbol>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Identifier {
     pub position: InputPosition,
     pub value: Vec<u8>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NamespacedIdentifier {
     pub position: InputPosition,
     pub num_namespaces: u8,
     pub value: Vec<u8>,
+}
 impl NamespacedIdentifier {
     fn iter(&self) -> NamespacedIdentifierIter {
+    pub(crate) fn iter(&self) -> NamespacedIdentifierIter {
         NamespacedIdentifierIter{
             value: &self.value,
             cur_offset: 0,
             num_returned: 0,
             num_total: self.num_namespaces
+        }
+    }
+}
 struct NamespacedIdentifierIter<'a> {
 impl PartialEq for NamespacedIdentifier {
     fn eq(&self, other: &Self) -> bool {
         return self.value == other.value
+    }
+}
 impl Eq for NamespacedIdentifier{}
 // TODO: Just keep ref to NamespacedIdentifier
 pub(crate) struct NamespacedIdentifierIter<'a> {
     value: &'a Vec<u8>,
     cur_offset: usize,
     num_returned: u8,
     num_total: u8,
+}
 impl<'a> NamespacedIdentifierIter<'a> {
     pub(crate) fn num_returned(&self) -> u8 {
         return self.num_returned;
+    }
     pub(crate) fn num_remaining(&self) -> u8 {
         return self.num_total - self.num_returned
+    }
+}
 impl<'a> Iterator for NamespacedIdentifierIter<'a> {
     type Item = &'a [u8];
     fn next(&mut self) -> Option<Self::Item> {
         if self.cur_offset >= self.value.len() {
             debug_assert_eq!(self.num_returned, self.num_total);
             None
         } else {
             debug_assert!(self.num_returned < self.num_total);
             let start = self.cur_offset;
             let mut end = start;
             while end < self.value.len() - 1 {
                 if self.value[end] == b':' && self.value[end + 1] == b':' {
                     self.cur_offset = end + 2;
                     self.num_returned += 1;
                     return Some(&self.value[start..end]);
+                }
                 end += 1;
+            }
             // If NamespacedIdentifier is constructed properly, then we cannot
             // end with "::" in the value, so
             debug_assert!(end == 0 || (self.value[end - 1] != b':' && self.value[end] != b':'));
             debug_assert_eq!(self.num_returned + 1, self.num_total);
             self.cur_offset = self.value.len();
             self.num_returned += 1;
             return Some(&self.value[start..]);
+        }
+    }
+}
 impl Display for Identifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // A source identifier is in ASCII range.
         write!(f, "{}", String::from_utf8_lossy(&self.value))
+    }
+}
 type TypeData = Vec<u8>;
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum PrimitiveType {
     Input,
     Output,
     Message,
     Boolean,
     Byte,
     Short,
     Int,
     Long,
     Symbolic(TypeData),
     Symbolic(PrimitiveSymbolic)
+}
 // TODO: @cleanup, remove PartialEq implementations
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PrimitiveSymbolic {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
     // Phase 2: typing
     pub(crate) definition: Option<DefinitionId>
+}
 impl PartialEq for PrimitiveSymbolic {
     fn eq(&self, other: &Self) -> bool {
         self.identifier == other.identifier
+    }
+}
 impl Eq for PrimitiveSymbolic{}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
+}
 #[allow(dead_code)]
 impl Type {
     pub const INPUT: Type = Type { primitive: PrimitiveType::Input, array: false };
     pub const OUTPUT: Type = Type { primitive: PrimitiveType::Output, array: false };
     pub const MESSAGE: Type = Type { primitive: PrimitiveType::Message, array: false };
     pub const BOOLEAN: Type = Type { primitive: PrimitiveType::Boolean, array: false };
     pub const BYTE: Type = Type { primitive: PrimitiveType::Byte, array: false };
     pub const SHORT: Type = Type { primitive: PrimitiveType::Short, array: false };
     pub const INT: Type = Type { primitive: PrimitiveType::Int, array: false };
     pub const LONG: Type = Type { primitive: PrimitiveType::Long, array: false };
     pub const INPUT_ARRAY: Type = Type { primitive: PrimitiveType::Input, array: true };
     pub const OUTPUT_ARRAY: Type = Type { primitive: PrimitiveType::Output, array: true };
     pub const MESSAGE_ARRAY: Type = Type { primitive: PrimitiveType::Message, array: true };
     pub const BOOLEAN_ARRAY: Type = Type { primitive: PrimitiveType::Boolean, array: true };
     pub const BYTE_ARRAY: Type = Type { primitive: PrimitiveType::Byte, array: true };
     pub const SHORT_ARRAY: Type = Type { primitive: PrimitiveType::Short, array: true };
     pub const INT_ARRAY: Type = Type { primitive: PrimitiveType::Int, array: true };
     pub const LONG_ARRAY: Type = Type { primitive: PrimitiveType::Long, array: true };
+}
 impl Display for Type {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match &self.primitive {
             PrimitiveType::Input => {
                 write!(f, "in")?;
+            }
             PrimitiveType::Output => {
                 write!(f, "out")?;
+            }
             PrimitiveType::Message => {
                 write!(f, "msg")?;
+            }
             PrimitiveType::Boolean => {
                 write!(f, "boolean")?;
+            }
             PrimitiveType::Byte => {
                 write!(f, "byte")?;
+            }
             PrimitiveType::Short => {
                 write!(f, "short")?;
+            }
             PrimitiveType::Int => {
                 write!(f, "int")?;
+            }
             PrimitiveType::Long => {
                 write!(f, "long")?;
+            }
             PrimitiveType::Symbolic(data) => {
                 // Type data is in ASCII range.
                 write!(f, "{}", String::from_utf8_lossy(&data))?;
                 if let Some(id) = &data.definition {
                     write!(
                         f, "Symbolic({}, id: {})",
                         String::from_utf8_lossy(&data.identifier.value),
                         id.0.index
                     )?;
                 } else {
                     write!(
                         f, "Symbolic({}, id: Unresolved)",
                         String::from_utf8_lossy(&data.identifier.value)
                     )?;
+                }
+            }
+        }
         if self.array {
             write!(f, "[]")
         } else {
             Ok(())
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct TypeAnnotation {
     pub this: TypeAnnotationId,
     // Phase 1: parser
     pub position: InputPosition,
     pub the_type: Type,
+}
 impl SyntaxElement for TypeAnnotation {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 type CharacterData = Vec<u8>;
 type IntegerData = i64;
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Constant {
     Null, // message
     True,
     False,
     Character(CharacterData),
     Integer(IntegerData),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Method {
     Get,
     Fires,
     Create,
     Symbolic(Identifier),
     Symbolic(MethodSymbolic)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct MethodSymbolic {
     pub(crate) identifier: NamespacedIdentifier,
     pub(crate) definition: Option<DefinitionId>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Field {
     Length,
     Symbolic(Identifier),
+}
 impl Field {
     pub fn is_length(&self) -> bool {
         match self {
             Field::Length => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum Scope {
     Definition(DefinitionId),
     Block(BlockStatementId),
     Synchronous(SynchronousStatementId),
+}
 impl Scope {
     pub fn to_block(&self) -> BlockStatementId {
         match &self {
             Scope::Block(id) => *id,
             _ => panic!("Unable to cast `Scope` to `BlockStatement`"),
+        }
+    }
+}
 pub trait VariableScope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope>;
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId>;
+}
 impl VariableScope for Scope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope> {
         match self {
             Scope::Definition(def) => h[*def].parent_scope(h),
             Scope::Block(stmt) => h[*stmt].parent_scope(h),
             Scope::Synchronous(stmt) => h[*stmt].parent_scope(h),
+        }
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         match self {
             Scope::Definition(def) => h[*def].get_variable(h, id),
             Scope::Block(stmt) => h[*stmt].get_variable(h, id),
             Scope::Synchronous(stmt) => h[*stmt].get_variable(h, id),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Variable {
     Parameter(Parameter),
     Local(Local),
+}
 impl Variable {
     pub fn identifier(&self) -> &Identifier {
         match self {
             Variable::Parameter(var) => &var.identifier,
             Variable::Local(var) => &var.identifier,
+        }
+    }
     pub fn is_parameter(&self) -> bool {
         match self {
             Variable::Parameter(_) => true,
             _ => false,
+        }
+    }
     pub fn as_parameter(&self) -> &Parameter {
         match self {
             Variable::Parameter(result) => result,
             _ => panic!("Unable to cast `Variable` to `Parameter`"),
+        }
+    }
     pub fn as_local(&self) -> &Local {
         match self {
             Variable::Local(result) => result,
             _ => panic!("Unable to cast `Variable` to `Local`"),
+        }
+    }
     pub fn the_type<'b>(&self, h: &'b Heap) -> &'b Type {
         match self {
             Variable::Parameter(param) => &h[param.type_annotation].the_type,
             Variable::Local(local) => &h[local.type_annotation].the_type,
+        }
+    }
+}
 impl SyntaxElement for Variable {
     fn position(&self) -> InputPosition {
         match self {
             Variable::Parameter(decl) => decl.position(),
             Variable::Local(decl) => decl.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Parameter {
     pub this: ParameterId,
     // Phase 1: parser
     pub position: InputPosition,
     pub type_annotation: TypeAnnotationId,
     pub identifier: Identifier,
+}
 impl SyntaxElement for Parameter {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Local {
     pub this: LocalId,
     // Phase 1: parser
     pub position: InputPosition,
     pub type_annotation: TypeAnnotationId,
     pub identifier: Identifier,
+}
 impl SyntaxElement for Local {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Component(Component),
     Function(Function),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
             _ => false
+        }
+    }
     pub fn as_struct(&self) -> &StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub fn is_enum(&self) -> bool {
         match self {
             Definition::Enum(_) => true,
             _ => false,
+        }
+    }
     pub fn as_enum(&self) -> &EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Definition::Component(_) => true,
             _ => false,
+        }
+    }
     pub fn as_component(&self) -> &Component {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub fn as_function(&self) -> &Function {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn as_composite(&self) -> &Composite {
         self.as_component().as_composite()
+    }
     pub fn as_primitive(&self) -> &Primitive {
         self.as_component().as_primitive()
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
-            Definition::Component(com) => com.identifier(),
+            Definition::Component(com) => &com.identifier,
             Definition::Function(fun) => &fun.identifier,
+        }
+    }
     pub fn parameters(&self) -> &Vec<ParameterId> {
         // TODO: Fix this
         static EMPTY_VEC: Vec<ParameterId> = Vec::new();
         match self {
-            Definition::Component(com) => com.parameters(),
+            Definition::Component(com) => &com.parameters,
             Definition::Function(fun) => &fun.parameters,
             _ => &EMPTY_VEC,
+        }
+    }
     pub fn body(&self) -> StatementId {
         // TODO: Fix this
         match self {
-            Definition::Component(com) => com.body(),
             Definition::Component(com) => com.body,
             Definition::Function(fun) => fun.body,
             _ => panic!("cannot retrieve body (for EnumDefinition or StructDefinition)")
+        }
+    }
+}
 impl SyntaxElement for Definition {
     fn position(&self) -> InputPosition {
         match self {
             Definition::Struct(def) => def.position,
             Definition::Enum(def) => def.position,
             Definition::Component(def) => def.position(),
             Definition::Function(def) => def.position(),
+        }
+    }
+}
 impl VariableScope for Definition {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         None
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         for &parameter_id in self.parameters().iter() {
             let parameter = &h[parameter_id];
             if parameter.identifier.value == id.value {
                 return Some(parameter_id.0);
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct StructFieldDefinition {
     pub position: InputPosition,
     pub field: Identifier,
     pub the_type: TypeAnnotationId,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct StructDefinition {
     pub this: StructId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub fields: Vec<StructFieldDefinition>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
     Type(TypeAnnotationId),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EnumVariantDefinition {
     pub position: InputPosition,
     pub identifier: Identifier,
     pub value: EnumVariantValue,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EnumDefinition {
     pub this: EnumId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub variants: Vec<EnumVariantDefinition>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Component {
     Composite(Composite),
     Primitive(Primitive),
+}
 impl Component {
     pub fn this(&self) -> ComponentId {
         match self {
             Component::Composite(com) => com.this.upcast(),
             Component::Primitive(prim) => prim.this.upcast(),
+        }
+    }
     pub fn as_composite(&self) -> &Composite {
         match self {
             Component::Composite(result) => result,
             _ => panic!("Unable to cast `Component` to `Composite`"),
+        }
+    }
     pub fn as_primitive(&self) -> &Primitive {
         match self {
             Component::Primitive(result) => result,
             _ => panic!("Unable to cast `Component` to `Primitive`"),
+        }
+    }
     fn identifier(&self) -> &Identifier {
         match self {
             Component::Composite(com) => &com.identifier,
             Component::Primitive(prim) => &prim.identifier,
+        }
+    }
     pub fn parameters(&self) -> &Vec<ParameterId> {
         match self {
             Component::Composite(com) => &com.parameters,
             Component::Primitive(prim) => &prim.parameters,
+        }
+    }
     pub fn body(&self) -> StatementId {
         match self {
             Component::Composite(com) => com.body,
             Component::Primitive(prim) => prim.body,
+        }
+    }
+}
 impl SyntaxElement for Component {
     fn position(&self) -> InputPosition {
         match self {
             Component::Composite(def) => def.position(),
             Component::Primitive(def) => def.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Composite {
     pub this: CompositeId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
 impl SyntaxElement for Composite {
     fn position(&self) -> InputPosition {
         self.position
+    }
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum ComponentVariant {
     Primitive,
     Composite,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Primitive {
     pub this: PrimitiveId,
 pub struct Component {
     pub this: ComponentId,
     // Phase 1: parser
     pub position: InputPosition,
     pub variant: ComponentVariant,
     pub identifier: Identifier,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
-impl SyntaxElement for Primitive {
+impl SyntaxElement for Component {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Function {
     pub this: FunctionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub return_type: TypeAnnotationId,
     pub identifier: Identifier,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
 impl SyntaxElement for Function {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Declaration {
     Defined(DefinedDeclaration),
     Imported(ImportedDeclaration),
+}
 impl Declaration {
     pub fn signature(&self) -> &Signature {
         match self {
             Declaration::Defined(decl) => &decl.signature,
             Declaration::Imported(decl) => &decl.signature,
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         self.signature().identifier()
+    }
     pub fn is_component(&self) -> bool {
         self.signature().is_component()
+    }
     pub fn is_function(&self) -> bool {
         self.signature().is_function()
+    }
     pub fn as_defined(&self) -> &DefinedDeclaration {
         match self {
             Declaration::Defined(result) => result,
             _ => panic!("Unable to cast `Declaration` to `DefinedDeclaration`"),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct DefinedDeclaration {
     pub this: DefinedDeclarationId,
     // Phase 2: linker
     pub definition: DefinitionId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportedDeclaration {
     pub this: ImportedDeclarationId,
     // Phase 2: linker
     pub import: ImportId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Signature {
     Component(ComponentSignature),
     Function(FunctionSignature),
+}
 impl Signature {
     pub fn from_definition(h: &Heap, def: DefinitionId) -> Signature {
         // TODO: Fix this
         match &h[def] {
             Definition::Component(com) => Signature::Component(ComponentSignature {
                 identifier: com.identifier().clone(), // TODO: @fix
                 arity: Signature::convert_parameters(h, com.parameters()),
                 identifier: com.identifier.clone(), // TODO: @fix
                 arity: Signature::convert_parameters(h, &com.parameters),
             }),
             Definition::Function(fun) => Signature::Function(FunctionSignature {
                 return_type: h[fun.return_type].the_type.clone(),
                 identifier: fun.identifier.clone(), // TODO: @fix
                 arity: Signature::convert_parameters(h, &fun.parameters),
             }),
             _ => panic!("cannot retrieve signature (for StructDefinition or EnumDefinition)")
+        }
+    }
     fn convert_parameters(h: &Heap, params: &Vec<ParameterId>) -> Vec<Type> {
         let mut result = Vec::new();
         for &param in params.iter() {
             result.push(h[h[param].type_annotation].the_type.clone());
+        }
         result
+    }
     fn identifier(&self) -> &Identifier {
         match self {
             Signature::Component(com) => &com.identifier,
             Signature::Function(fun) => &fun.identifier,
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Signature::Component(_) => true,
             Signature::Function(_) => false,
+        }
+    }
     pub fn is_function(&self) -> bool {
         match self {
             Signature::Component(_) => false,
             Signature::Function(_) => true,
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ComponentSignature {
     pub identifier: Identifier,
     pub arity: Vec<Type>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct FunctionSignature {
     pub return_type: Type,
     pub identifier: Identifier,
     pub arity: Vec<Type>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Statement {
     Block(BlockStatement),
     Local(LocalStatement),
     Skip(SkipStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Return(ReturnStatement),
     Assert(AssertStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Put(PutStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_block(&self) -> &BlockStatement {
         match self {
             Statement::Block(result) => result,
             _ => panic!("Unable to cast `Statement` to `BlockStatement`"),
+        }
+    }
     pub fn as_block_mut(&mut self) -> &mut BlockStatement {
         match self {
             Statement::Block(result) => result,
             _ => panic!("Unable to cast `Statement` to `BlockStatement`"),
+        }
+    }
     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`"),
+        }
+    }
     pub fn as_if(&self) -> &IfStatement {
         match self {
             Statement::If(result) => result,
             _ => panic!("Unable to cast `Statement` to `IfStatement`"),
+        }
+    }
     pub fn as_end_if(&self) -> &EndIfStatement {
         match self {
             Statement::EndIf(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndIfStatement`"),
+        }
+    }
     pub fn is_while(&self) -> bool {
         match self {
             Statement::While(_) => true,
             _ => false,
+        }
+    }
     pub fn as_while(&self) -> &WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_while_mut(&mut self) -> &mut WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_end_while(&self) -> &EndWhileStatement {
         match self {
             Statement::EndWhile(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndWhileStatement`"),
+        }
+    }
     pub fn as_break(&self) -> &BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_break_mut(&mut self) -> &mut BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_continue(&self) -> &ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_continue_mut(&mut self) -> &mut ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_synchronous(&self) -> &SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_synchronous_mut(&mut self) -> &mut SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_end_synchronous(&self) -> &EndSynchronousStatement {
         match self {
             Statement::EndSynchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndSynchronousStatement`"),
+        }
+    }

src/protocol/containers.rs

➞

Show inline comments

 /// Containers.rs
 ///
 /// Contains specialized containers for the parser/compiler
 /// TODO: Actually implement, I really want to remove all of the identifier
 ///     allocations.
 use std::collections::LinkedList;
 const PAGE_SIZE: usize = 4096;
 struct StringPage {
     buffer: [u8; PAGE_SIZE],
     remaining: usize,
     next_page: Option<Box<StringPage>>,
+}
 impl StringPage {
     fn new() -> Self{
-        let res = Self{
         Self{
             buffer: [0; PAGE_SIZE],
             remaining: PAGE_SIZE,
             next_page: None
         };
         res
+        }
+    }
+}
 /// Custom allocator for strings that are copied and remain valid during the
 /// complete compilation phase. May perform multiple allocations but the
 /// previously allocated strings remain valid. Because we will usually allocate
 /// quite a number of these we will allocate a buffer upon construction of the
 /// StringAllocator.
 pub(crate) struct StringAllocator {
     first_page: Box<StringPage>,
     last_page: *mut StringPage,
+}
 unsafe impl Send for StringAllocator {}
 impl StringAllocator {
     pub(crate) fn new() -> StringAllocator {
         let mut page = Box::new(StringPage::new());
         let page_ptr = unsafe { page.as_mut() as *mut StringPage };
         StringAllocator{
             first_page: page,
             last_page: page_ptr,
+        }
+    }
     pub(crate) fn alloc(&mut self, data: &[u8]) -> Result<&'static str, String> {
         let data_len = data.len();
         if data_len > PAGE_SIZE {
             return Err(format!(
                 "string is too large ({} bytes exceeds the maximum of {})",
                 data_len, PAGE_SIZE
             ));
+        }
         // Because we're doing a copy anyway, we might as well perform the
         // UTF-8 checking now. Such that it is safe to do an unchecked
         // `from_utf8_unchecked` later.
         let data = std::str::from_utf8(data);
         if let Err(_) = data {
             return Err(format!("invalid utf8-string"));
+        }
         let data = data.unwrap();
         unsafe {
             if data_len > (*self.last_page).remaining {
                 // Allocate new page
                 let mut new_page = Box::new(StringPage::new());
                 let new_page_ptr = new_page.as_mut() as *mut StringPage;
                 (*self.last_page).next_page = Some(new_page);
                 self.last_page = new_page_ptr;
+            }
             let remaining = (*self.last_page).remaining;
             debug_assert!(data_len <= remaining);
             let start = PAGE_SIZE - remaining;
             (*self.last_page).buffer[start..start+data_len].copy_from_slice(data.as_bytes());
             (*self.last_page).remaining -= data_len;
             Ok(std::str::from_utf8_unchecked(&(*self.last_page).buffer[start..start+data_len]))
+        }
+    }
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     #[test]
     fn test_alloc() {
         // Make sure pointers are somewhat correct
         let mut alloc = StringAllocator::new();
         assert!(alloc.first_page.next_page.is_none());
         assert_eq!(alloc.first_page.as_ref() as *const StringPage, alloc.last_page);
         // Insert and make page full, should not allocate another page yet
         let input = "I am a simple static string";
         let filler = " ".repeat(PAGE_SIZE - input.len());
         let ref_first = alloc.alloc(input.as_bytes()).expect("alloc first");
         let ref_filler = alloc.alloc(filler.as_bytes()).expect("alloc filler");
         assert!(alloc.first_page.next_page.is_none());
         assert_eq!(alloc.first_page.as_ref() as *const StringPage, alloc.last_page);
         let ref_second = alloc.alloc(input.as_bytes()).expect("alloc second");
         assert!(alloc.first_page.next_page.is_some());
         assert!(alloc.first_page.next_page.as_ref().unwrap().next_page.is_none());
         let last_page_ptr = alloc.first_page.next_page.as_ref().unwrap().as_ref() as *const StringPage;
         assert_eq!(last_page_ptr, alloc.last_page);
         assert_eq!(ref_first, input);
         assert_eq!(ref_filler, filler);
         assert_eq!(ref_second, input);
+    }
+}
@@ \ No newline at end of file @@

src/protocol/lexer.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 const MAX_LEVEL: usize = 128;
 const MAX_NAMESPACES: u8 = 8; // only three levels are supported at the moment
 fn is_vchar(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= 0x21 && c <= 0x7E
     } else {
         false
+    }
+}
 fn is_wsp(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c == b' ' || c == b'\t'
     } else {
         false
+    }
+}
 fn is_ident_start(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'A' && c <= b'Z' || c >= b'a' && c <= b'z'
     } else {
         false
+    }
+}
 fn is_ident_rest(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'A' && c <= b'Z' || c >= b'a' && c <= b'z' || c >= b'0' && c <= b'9' || c == b'_'
     } else {
         false
+    }
+}
 fn is_constant(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'0' && c <= b'9' || c == b'\''
     } else {
         false
+    }
+}
 fn is_integer_start(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'0' && c <= b'9'
     } else {
         false
+    }
+}
 fn is_integer_rest(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'0' && c <= b'9'
             || c >= b'a' && c <= b'f'
             || c >= b'A' && c <= b'F'
             || c == b'x'
             || c == b'o'
     } else {
         false
+    }
+}
 fn lowercase(x: u8) -> u8 {
     if x >= b'A' && x <= b'Z' {
         x - b'A' + b'a'
     } else {
+        x
+    }
+}
 pub struct Lexer<'a> {
     source: &'a mut InputSource,
     level: usize,
+}
 impl Lexer<'_> {
     pub fn new(source: &mut InputSource) -> Lexer {
         Lexer { source, level: 0 }
+    }
     fn error_at_pos(&self, msg: &str) -> ParseError2 {
         ParseError2::new_error(self.source, self.source.pos(), msg)
+    }
     fn consume_line(&mut self) -> Result<Vec<u8>, ParseError2> {
         let mut result: Vec<u8> = Vec::new();
         let mut next = self.source.next();
         while next.is_some() && next != Some(b'\n') && next != Some(b'\r') {
             if !(is_vchar(next) || is_wsp(next)) {
                 return Err(self.error_at_pos("Expected visible character or whitespace"));
+            }
             result.push(next.unwrap());
             self.source.consume();
             next = self.source.next();
+        }
         if next.is_some() {
             self.source.consume();
+        }
         if next == Some(b'\r') && self.source.next() == Some(b'\n') {
             self.source.consume();
+        }
         Ok(result)
+    }
     fn consume_whitespace(&mut self, expected: bool) -> Result<(), ParseError2> {
         let mut found = false;
         let mut next = self.source.next();
         while next.is_some() {
             if next == Some(b' ')
                 || next == Some(b'\t')
                 || next == Some(b'\r')
                 || next == Some(b'\n')
+            {
                 self.source.consume();
                 next = self.source.next();
                 found = true;
                 continue;
+            }
             if next == Some(b'/') {
                 next = self.source.lookahead(1);
                 if next == Some(b'/') {
                     self.source.consume(); // slash
                     self.source.consume(); // slash
                     self.consume_line()?;
                     next = self.source.next();
                     found = true;
                     continue;
+                }
                 if next == Some(b'*') {
                     self.source.consume(); // slash
                     self.source.consume(); // star
                     next = self.source.next();
                     while next.is_some() {
                         if next == Some(b'*') {
                             next = self.source.lookahead(1);
                             if next == Some(b'/') {
                                 self.source.consume(); // star
                                 self.source.consume(); // slash
                                 break;
+                            }
+                        }
                         self.source.consume();
                         next = self.source.next();
+                    }
                     next = self.source.next();
                     found = true;
                     continue;
+                }
+            }
             break;
+        }
         if expected && !found {
             Err(self.error_at_pos("Expected whitespace"))
         } else {
             Ok(())
+        }
+    }
     fn has_keyword(&self, keyword: &[u8]) -> bool {
         if !self.source.has(keyword) {
             return false;
+        }
         // Word boundary
         if let Some(next) = self.source.lookahead(keyword.len()) {
             !(next >= b'A' && next <= b'Z' || next >= b'a' && next <= b'z')
         } else {
             true
+        }
+    }
     fn consume_keyword(&mut self, keyword: &[u8]) -> Result<(), ParseError2> {
         let len = keyword.len();
         for i in 0..len {
             let expected = Some(lowercase(keyword[i]));
             let next = self.source.next();
             if next != expected {
                 return Err(self.error_at_pos(&format!("Expected keyword '{}'", String::from_utf8_lossy(keyword))));
+            }
             self.source.consume();
+        }
         if let Some(next) = self.source.next() {
             if next >= b'A' && next <= b'Z' || next >= b'a' && next <= b'z' || next >= b'0' && next <= b'9' {
                 return Err(self.error_at_pos(&format!("Expected word boundary after '{}'", String::from_utf8_lossy(keyword))));
+            }
+        }
         Ok(())
+    }
     fn has_string(&self, string: &[u8]) -> bool {
         self.source.has(string)
+    }
     fn consume_string(&mut self, string: &[u8]) -> Result<(), ParseError2> {
         let len = string.len();
         for i in 0..len {
             let expected = Some(string[i]);
             let next = self.source.next();
             if next != expected {
                 return Err(self.error_at_pos(&format!("Expected {}", String::from_utf8_lossy(string))));
+            }
             self.source.consume();
+        }
         Ok(())
+    }
     fn consume_ident(&mut self) -> Result<Vec<u8>, ParseError2> {
         if !self.has_identifier() {
             return Err(self.error_at_pos("Expected identifier"));
+        }
         let mut result = Vec::new();
         let mut next = self.source.next();
         result.push(next.unwrap());
         self.source.consume();
         next = self.source.next();
         while is_ident_rest(next) {
             result.push(next.unwrap());
             self.source.consume();
             next = self.source.next();
+        }
         Ok(result)
+    }
     fn has_integer(&mut self) -> bool {
         is_integer_start(self.source.next())
+    }
     fn consume_integer(&mut self) -> Result<i64, ParseError2> {
         let position = self.source.pos();
         let mut data = Vec::new();
         let mut next = self.source.next();
         while is_integer_rest(next) {
             data.push(next.unwrap());
             self.source.consume();
             next = self.source.next();
+        }
         let data_len = data.len();
         debug_assert_ne!(data_len, 0);
         if data_len == 1 {
             debug_assert!(data[0] >= b'0' && data[0] <= b'9');
             return Ok((data[0] - b'0') as i64);
         } else {
             // TODO: Fix, u64 should be supported as well
             let parsed = if data[1] == b'b' {
                 let data = String::from_utf8_lossy(&data[2..]);
                 i64::from_str_radix(&data, 2)
             } else if data[1] == b'o' {
                 let data = String::from_utf8_lossy(&data[2..]);
                 i64::from_str_radix(&data, 8)
             } else if data[1] == b'x' {
                 let data = String::from_utf8_lossy(&data[2..]);
                 i64::from_str_radix(&data, 16)
             } else {
                 // Assume decimal
                 let data = String::from_utf8_lossy(&data);
                 i64::from_str_radix(&data, 10)
             };
             if let Err(_err) = parsed {
                 return Err(ParseError2::new_error(&self.source, position, "Invalid integer constant"));
+            }
             Ok(parsed.unwrap())
+        }
+    }
     // Statement keywords
+    // TODO: Clean up these functions
     fn has_statement_keyword(&self) -> bool {
         self.has_keyword(b"channel")
             || self.has_keyword(b"skip")
             || self.has_keyword(b"if")
             || self.has_keyword(b"while")
             || self.has_keyword(b"break")
             || self.has_keyword(b"continue")
             || self.has_keyword(b"synchronous")
             || self.has_keyword(b"return")
             || self.has_keyword(b"assert")
             || self.has_keyword(b"goto")
             || self.has_keyword(b"new")
             || self.has_keyword(b"put")
+            || self.has_keyword(b"put") // TODO: @fix, should be a function, even though it has sideeffects
+    }
     fn has_type_keyword(&self) -> bool {
         self.has_keyword(b"in")
             || self.has_keyword(b"out")
             || self.has_keyword(b"msg")
             || self.has_keyword(b"boolean")
             || self.has_keyword(b"byte")
             || self.has_keyword(b"short")
             || self.has_keyword(b"int")
             || self.has_keyword(b"long")
+    }
     fn has_builtin_keyword(&self) -> bool {
         self.has_keyword(b"get")
             || self.has_keyword(b"fires")
             || self.has_keyword(b"create")
             || self.has_keyword(b"length")
+    }
     fn has_reserved(&self) -> bool {
         self.has_statement_keyword()
             || self.has_type_keyword()
             || self.has_builtin_keyword()
             || self.has_keyword(b"let")
             || self.has_keyword(b"struct")
             || self.has_keyword(b"enum")
             || self.has_keyword(b"true")
             || self.has_keyword(b"false")
             || self.has_keyword(b"null")
+    }
     // Identifiers
     fn has_identifier(&self) -> bool {
         if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {
             return false;
+        }
         let next = self.source.next();
         is_ident_start(next)
+    }
-    fn consume_identifier(&mut self, h: &mut Heap) -> Result<Identifier, ParseError2> {
     fn consume_identifier(&mut self) -> Result<Identifier, ParseError2> {
         if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {
             return Err(self.error_at_pos("Expected identifier"));
+        }
         let position = self.source.pos();
         let value = self.consume_ident()?;
         Ok(Identifier{ position, value })
+    }
     fn consume_identifier_spilled(&mut self) -> Result<(), ParseError2> {
         if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {
             return Err(self.error_at_pos("Expected identifier"));
+        }
         self.consume_ident()?;
         Ok(())
+    }
     fn has_namespaced_identifier(&self) -> bool {
         self.has_identifier()
+    }
     fn consume_namespaced_identifier(&mut self) -> Result<NamespacedIdentifier, ParseError2> {
         if self.has_reserved() {
             return Err(self.error_at_pos("Encountered reserved keyword"));
+        }
     // Types and type annotations
         let position = self.source.pos();
         let mut ns_ident = self.consume_ident()?;
         let mut num_namespaces = 1;
         while self.has_string(b"::") {
             if num_namespaces >= MAX_NAMESPACES {
                 return Err(self.error_at_pos("Too many namespaces in identifier"));
+            }
             let new_ident = self.consume_ident()?;
             num_namespaces += 1;
+        }
         Ok(NamespacedIdentifier{
             position,
             value: ns_ident,
             num_namespaces,
         })
+    }
     // Types and type annotations
     fn consume_primitive_type(&mut self) -> Result<PrimitiveType, ParseError2> {
         if self.has_keyword(b"in") {
             self.consume_keyword(b"in")?;
             Ok(PrimitiveType::Input)
         } else if self.has_keyword(b"out") {
             self.consume_keyword(b"out")?;
             Ok(PrimitiveType::Output)
         } else if self.has_keyword(b"msg") {
             self.consume_keyword(b"msg")?;
             Ok(PrimitiveType::Message)
         } else if self.has_keyword(b"boolean") {
             self.consume_keyword(b"boolean")?;
             Ok(PrimitiveType::Boolean)
         } else if self.has_keyword(b"byte") {
             self.consume_keyword(b"byte")?;
             Ok(PrimitiveType::Byte)
         } else if self.has_keyword(b"short") {
             self.consume_keyword(b"short")?;
             Ok(PrimitiveType::Short)
         } else if self.has_keyword(b"int") {
             self.consume_keyword(b"int")?;
             Ok(PrimitiveType::Int)
         } else if self.has_keyword(b"long") {
             self.consume_keyword(b"long")?;
             Ok(PrimitiveType::Long)
         } else if self.has_keyword(b"let") {
             return Err(self.error_at_pos("inferred types using 'let' are reserved, but not yet implemented"));
         } else {
             let data = self.consume_ident()?;
             Ok(PrimitiveType::Symbolic(data))
             let identifier = self.consume_namespaced_identifier()?;
             Ok(PrimitiveType::Symbolic(PrimitiveSymbolic{
                 identifier,
                 definition: None
             }))
+        }
+    }
     fn has_array(&mut self) -> bool {
         let backup_pos = self.source.pos();
         let mut result = false;
         match self.consume_whitespace(false) {
             Ok(_) => result = self.has_string(b"["),
             Err(_) => {}
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_type(&mut self) -> Result<Type, ParseError2> {
         let primitive = self.consume_primitive_type()?;
         let array;
         if self.has_array() {
             self.consume_string(b"[]")?;
             array = true;
         } else {
             array = false;
+        }
         Ok(Type { primitive, array })
+    }
     fn create_type_annotation_input(&self, h: &mut Heap) -> Result<TypeAnnotationId, ParseError2> {
         let position = self.source.pos();
         let the_type = Type::INPUT;
         let id = h.alloc_type_annotation(|this| TypeAnnotation { this, position, the_type });
         Ok(id)
+    }
     fn create_type_annotation_output(&self, h: &mut Heap) -> Result<TypeAnnotationId, ParseError2> {
         let position = self.source.pos();
         let the_type = Type::OUTPUT;
         let id = h.alloc_type_annotation(|this| TypeAnnotation { this, position, the_type });
         Ok(id)
+    }
     fn consume_type_annotation(&mut self, h: &mut Heap) -> Result<TypeAnnotationId, ParseError2> {
         let position = self.source.pos();
         let the_type = self.consume_type()?;
         let id = h.alloc_type_annotation(|this| TypeAnnotation { this, position, the_type });
         Ok(id)
+    }
     fn consume_type_annotation_spilled(&mut self) -> Result<(), ParseError2> {
         self.consume_type()?;
         Ok(())
+    }
     // Parameters
     fn consume_parameter(&mut self, h: &mut Heap) -> Result<ParameterId, ParseError2> {
         let position = self.source.pos();
         let type_annotation = self.consume_type_annotation(h)?;
         self.consume_whitespace(true)?;
-        let identifier = self.consume_identifier(h)?;
         let identifier = self.consume_identifier()?;
         let id =
             h.alloc_parameter(|this| Parameter { this, position, type_annotation, identifier });
         Ok(id)
+    }
     fn consume_parameters(
         &mut self,
         h: &mut Heap,
         params: &mut Vec<ParameterId>,
     ) -> Result<(), ParseError2> {
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b")") {
             while self.source.next().is_some() {
                 params.push(self.consume_parameter(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b")") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?;
+            }
+        }
         self.consume_string(b")")?;
         Ok(())
+    }
     // ====================
     // Expressions
     // ====================
     fn consume_paren_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         let result = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b")")?;
         Ok(result)
+    }
     fn consume_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         if self.level >= MAX_LEVEL {
             return Err(self.error_at_pos("Too deeply nested expression"));
+        }
         self.level += 1;
         let result = self.consume_assignment_expression(h);
         self.level -= 1;
         result
+    }
     fn consume_assignment_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let result = self.consume_conditional_expression(h)?;
         self.consume_whitespace(false)?;
         if self.has_assignment_operator() {
             let position = self.source.pos();
             let left = result;
             let operation = self.consume_assignment_operator()?;
             self.consume_whitespace(false)?;
             let right = self.consume_expression(h)?;
             Ok(h.alloc_assignment_expression(|this| AssignmentExpression {
                 this,
                 position,
                 left,
                 operation,
                 right,
             })
             .upcast())
         } else {
             Ok(result)
+        }
+    }
     fn has_assignment_operator(&self) -> bool {
         self.has_string(b"=")
             || self.has_string(b"*=")
             || self.has_string(b"/=")
             || self.has_string(b"%=")
             || self.has_string(b"+=")
             || self.has_string(b"-=")
             || self.has_string(b"<<=")
             || self.has_string(b">>=")
             || self.has_string(b"&=")
             || self.has_string(b"^=")
             || self.has_string(b"|=")
+    }
     fn consume_assignment_operator(&mut self) -> Result<AssignmentOperator, ParseError2> {
         if self.has_string(b"=") {
             self.consume_string(b"=")?;
             Ok(AssignmentOperator::Set)
         } else if self.has_string(b"*=") {
             self.consume_string(b"*=")?;
             Ok(AssignmentOperator::Multiplied)
         } else if self.has_string(b"/=") {
             self.consume_string(b"/=")?;
             Ok(AssignmentOperator::Divided)
         } else if self.has_string(b"%=") {
             self.consume_string(b"%=")?;
             Ok(AssignmentOperator::Remained)
         } else if self.has_string(b"+=") {
             self.consume_string(b"+=")?;
             Ok(AssignmentOperator::Added)
         } else if self.has_string(b"-=") {
             self.consume_string(b"-=")?;
             Ok(AssignmentOperator::Subtracted)
         } else if self.has_string(b"<<=") {
             self.consume_string(b"<<=")?;
             Ok(AssignmentOperator::ShiftedLeft)
         } else if self.has_string(b">>=") {
             self.consume_string(b">>=")?;
             Ok(AssignmentOperator::ShiftedRight)
         } else if self.has_string(b"&=") {
             self.consume_string(b"&=")?;
             Ok(AssignmentOperator::BitwiseAnded)
         } else if self.has_string(b"^=") {
             self.consume_string(b"^=")?;
             Ok(AssignmentOperator::BitwiseXored)
         } else if self.has_string(b"|=") {
             self.consume_string(b"|=")?;
             Ok(AssignmentOperator::BitwiseOred)
         } else {
             Err(self.error_at_pos("Expected assignment operator"))
+        }
+    }
     fn consume_conditional_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let result = self.consume_concat_expression(h)?;
         self.consume_whitespace(false)?;
         if self.has_string(b"?") {
             let position = self.source.pos();
             let test = result;
             self.consume_string(b"?")?;
             self.consume_whitespace(false)?;
             let true_expression = self.consume_expression(h)?;
             self.consume_whitespace(false)?;
             self.consume_string(b":")?;
             self.consume_whitespace(false)?;
             let false_expression = self.consume_expression(h)?;
             Ok(h.alloc_conditional_expression(|this| ConditionalExpression {
                 this,
                 position,
                 test,
                 true_expression,
                 false_expression,
             })
             .upcast())
         } else {
             Ok(result)
+        }
+    }
     fn consume_concat_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_lor_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"@") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"@")?;
             let operation = BinaryOperator::Concatenate;
             self.consume_whitespace(false)?;
             let right = self.consume_lor_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_lor_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_land_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"||") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"||")?;
             let operation = BinaryOperator::LogicalOr;
             self.consume_whitespace(false)?;
             let right = self.consume_land_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_land_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
@@ @@ -790,1485 +831,1511 @@ impl Lexer<'_> { @@
             let position = self.source.pos();
             let left = result;
             let operation;
             if self.has_string(b"+") {
                 self.consume_string(b"+")?;
                 operation = BinaryOperator::Add;
             } else {
                 self.consume_string(b"-")?;
                 operation = BinaryOperator::Subtract;
+            }
             self.consume_whitespace(false)?;
             let right = self.consume_mul_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_mul_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_prefix_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"*") && !self.has_string(b"*=")
             || self.has_string(b"/") && !self.has_string(b"/=")
             || self.has_string(b"%") && !self.has_string(b"%=")
+        {
             let position = self.source.pos();
             let left = result;
             let operation;
             if self.has_string(b"*") {
                 self.consume_string(b"*")?;
                 operation = BinaryOperator::Multiply;
             } else if self.has_string(b"/") {
                 self.consume_string(b"/")?;
                 operation = BinaryOperator::Divide;
             } else {
                 self.consume_string(b"%")?;
                 operation = BinaryOperator::Remainder;
+            }
             self.consume_whitespace(false)?;
             let right = self.consume_prefix_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_prefix_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         if self.has_string(b"+")
             || self.has_string(b"-")
             || self.has_string(b"~")
             || self.has_string(b"!")
+        {
             let position = self.source.pos();
             let operation;
             if self.has_string(b"+") {
                 self.consume_string(b"+")?;
                 if self.has_string(b"+") {
                     self.consume_string(b"+")?;
                     operation = UnaryOperation::PreIncrement;
                 } else {
                     operation = UnaryOperation::Positive;
+                }
             } else if self.has_string(b"-") {
                 self.consume_string(b"-")?;
                 if self.has_string(b"-") {
                     self.consume_string(b"-")?;
                     operation = UnaryOperation::PreDecrement;
                 } else {
                     operation = UnaryOperation::Negative;
+                }
             } else if self.has_string(b"~") {
                 self.consume_string(b"~")?;
                 operation = UnaryOperation::BitwiseNot;
             } else {
                 self.consume_string(b"!")?;
                 operation = UnaryOperation::LogicalNot;
+            }
             self.consume_whitespace(false)?;
             if self.level >= MAX_LEVEL {
                 return Err(self.error_at_pos("Too deeply nested expression"));
+            }
             self.level += 1;
             let result = self.consume_prefix_expression(h);
             self.level -= 1;
             let expression = result?;
             return Ok(h
                 .alloc_unary_expression(|this| UnaryExpression {
                     this,
                     position,
                     operation,
                     expression,
                 })
                 .upcast());
+        }
         self.consume_postfix_expression(h)
+    }
     fn consume_postfix_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_primary_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"++")
             || self.has_string(b"--")
             || self.has_string(b"[")
             || (self.has_string(b".") && !self.has_string(b".."))
+        {
             let mut position = self.source.pos();
             if self.has_string(b"++") {
                 self.consume_string(b"++")?;
                 let operation = UnaryOperation::PostIncrement;
                 let expression = result;
                 self.consume_whitespace(false)?;
                 result = h
                     .alloc_unary_expression(|this| UnaryExpression {
                         this,
                         position,
                         operation,
                         expression,
                     })
                     .upcast();
             } else if self.has_string(b"--") {
                 self.consume_string(b"--")?;
                 let operation = UnaryOperation::PostDecrement;
                 let expression = result;
                 self.consume_whitespace(false)?;
                 result = h
                     .alloc_unary_expression(|this| UnaryExpression {
                         this,
                         position,
                         operation,
                         expression,
                     })
                     .upcast();
             } else if self.has_string(b"[") {
                 self.consume_string(b"[")?;
                 self.consume_whitespace(false)?;
                 let subject = result;
                 let index = self.consume_expression(h)?;
                 self.consume_whitespace(false)?;
                 if self.has_string(b"..") || self.has_string(b":") {
                     position = self.source.pos();
                     if self.has_string(b"..") {
                         self.consume_string(b"..")?;
                     } else {
                         self.consume_string(b":")?;
+                    }
                     self.consume_whitespace(false)?;
                     let to_index = self.consume_expression(h)?;
                     self.consume_whitespace(false)?;
                     result = h
                         .alloc_slicing_expression(|this| SlicingExpression {
                             this,
                             position,
                             subject,
                             from_index: index,
                             to_index,
                         })
                         .upcast();
                 } else {
                     result = h
                         .alloc_indexing_expression(|this| IndexingExpression {
                             this,
                             position,
                             subject,
                             index,
                         })
                         .upcast();
+                }
                 self.consume_string(b"]")?;
                 self.consume_whitespace(false)?;
             } else {
                 assert!(self.has_string(b"."));
                 self.consume_string(b".")?;
                 self.consume_whitespace(false)?;
                 let subject = result;
                 let field;
                 if self.has_keyword(b"length") {
                     self.consume_keyword(b"length")?;
                     field = Field::Length;
                 } else {
-                    field = Field::Symbolic(self.consume_identifier(h)?);
                     field = Field::Symbolic(self.consume_identifier()?);
+                }
                 result = h
                     .alloc_select_expression(|this| SelectExpression {
                         this,
                         position,
                         subject,
                         field,
                     })
                     .upcast();
+            }
+        }
         Ok(result)
+    }
     fn consume_primary_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         if self.has_string(b"(") {
             return self.consume_paren_expression(h);
+        }
         if self.has_string(b"{") {
             return Ok(self.consume_array_expression(h)?.upcast());
+        }
         if self.has_constant()
             || self.has_keyword(b"null")
             || self.has_keyword(b"true")
             || self.has_keyword(b"false")
+        {
             return Ok(self.consume_constant_expression(h)?.upcast());
+        }
         if self.has_call_expression() {
             return Ok(self.consume_call_expression(h)?.upcast());
+        }
         Ok(self.consume_variable_expression(h)?.upcast())
+    }
     fn consume_array_expression(&mut self, h: &mut Heap) -> Result<ArrayExpressionId, ParseError2> {
         let position = self.source.pos();
         let mut elements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b"}") {
             while self.source.next().is_some() {
                 elements.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b"}") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?;
+            }
+        }
         self.consume_string(b"}")?;
         Ok(h.alloc_array_expression(|this| ArrayExpression { this, position, elements }))
+    }
     fn has_constant(&self) -> bool {
         is_constant(self.source.next())
+    }
     fn consume_constant_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<ConstantExpressionId, ParseError2> {
         let position = self.source.pos();
         let value;
         if self.has_keyword(b"null") {
             self.consume_keyword(b"null")?;
             value = Constant::Null;
         } else if self.has_keyword(b"true") {
             self.consume_keyword(b"true")?;
             value = Constant::True;
         } else if self.has_keyword(b"false") {
             self.consume_keyword(b"false")?;
             value = Constant::False;
         } else if self.source.next() == Some(b'\'') {
             self.source.consume();
             let mut data = Vec::new();
             let mut next = self.source.next();
             while next != Some(b'\'') && (is_vchar(next) || next == Some(b' ')) {
                 data.push(next.unwrap());
                 self.source.consume();
                 next = self.source.next();
+            }
             if next != Some(b'\'') || data.is_empty() {
                 return Err(self.error_at_pos("Expected character constant"));
+            }
             self.source.consume();
             value = Constant::Character(data);
         } else {
             if !self.has_integer() {
                 return Err(self.error_at_pos("Expected integer constant"));
+            }
             value = Constant::Integer(self.consume_integer()?);
+        }
         Ok(h.alloc_constant_expression(|this| ConstantExpression { this, position, value }))
+    }
     fn has_call_expression(&mut self) -> bool {
         /* We prevent ambiguity with variables, by looking ahead
         the identifier to see if we can find an opening
         parenthesis: this signals a call expression. */
         if self.has_builtin_keyword() {
             return true;
+        }
         let backup_pos = self.source.pos();
         let mut result = false;
         match self.consume_identifier_spilled() {
             Ok(_) => match self.consume_whitespace(false) {
                 Ok(_) => {
                     result = self.has_string(b"(");
+                }
                 Err(_) => {}
             },
             Err(_) => {}
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_call_expression(&mut self, h: &mut Heap) -> Result<CallExpressionId, ParseError2> {
         let position = self.source.pos();
         let method;
         if self.has_keyword(b"get") {
             self.consume_keyword(b"get")?;
             method = Method::Get;
         } else if self.has_keyword(b"fires") {
             self.consume_keyword(b"fires")?;
             method = Method::Fires;
         } else if self.has_keyword(b"create") {
             self.consume_keyword(b"create")?;
             method = Method::Create;
         } else {
             let identifier = self.consume_identifier(h)?;
             method = Method::Symbolic(identifier)
             let identifier = self.consume_namespaced_identifier()?;
             method = Method::Symbolic(MethodSymbolic{
                 identifier,
                 definition: None
             })
+        }
         self.consume_whitespace(false)?;
         let mut arguments = Vec::new();
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b")") {
             while self.source.next().is_some() {
                 arguments.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b")") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?
+            }
+        }
         self.consume_string(b")")?;
         Ok(h.alloc_call_expression(|this| CallExpression {
             this,
             position,
             method,
             arguments,
             declaration: None,
         }))
+    }
     fn consume_variable_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<VariableExpressionId, ParseError2> {
         let position = self.source.pos();
-        let identifier = self.consume_identifier(h)?;
         let identifier = self.consume_identifier()?;
         Ok(h.alloc_variable_expression(|this| VariableExpression {
             this,
             position,
             identifier,
             declaration: None,
         }))
+    }
     // ====================
     // Statements
     // ====================
     fn consume_statement(&mut self, h: &mut Heap) -> Result<StatementId, ParseError2> {
         if self.level >= MAX_LEVEL {
             return Err(self.error_at_pos("Too deeply nested statement"));
+        }
         self.level += 1;
         let result = self.consume_statement_impl(h);
         self.level -= 1;
         result
+    }
     fn has_label(&mut self) -> bool {
         /* To prevent ambiguity with expression statements consisting
         only of an identifier, we look ahead and match the colon
         that signals a labeled statement. */
         let backup_pos = self.source.pos();
         let mut result = false;
         match self.consume_identifier_spilled() {
             Ok(_) => match self.consume_whitespace(false) {
                 Ok(_) => {
                     result = self.has_string(b":");
+                }
                 Err(_) => {}
             },
             Err(_) => {}
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_statement_impl(&mut self, h: &mut Heap) -> Result<StatementId, ParseError2> {
         if self.has_string(b"{") {
             Ok(self.consume_block_statement(h)?)
         } else if self.has_keyword(b"skip") {
             Ok(self.consume_skip_statement(h)?.upcast())
         } else if self.has_keyword(b"if") {
             Ok(self.consume_if_statement(h)?.upcast())
         } else if self.has_keyword(b"while") {
             Ok(self.consume_while_statement(h)?.upcast())
         } else if self.has_keyword(b"break") {
             Ok(self.consume_break_statement(h)?.upcast())
         } else if self.has_keyword(b"continue") {
             Ok(self.consume_continue_statement(h)?.upcast())
         } else if self.has_keyword(b"synchronous") {
             Ok(self.consume_synchronous_statement(h)?.upcast())
         } else if self.has_keyword(b"return") {
             Ok(self.consume_return_statement(h)?.upcast())
         } else if self.has_keyword(b"assert") {
             Ok(self.consume_assert_statement(h)?.upcast())
         } else if self.has_keyword(b"goto") {
             Ok(self.consume_goto_statement(h)?.upcast())
         } else if self.has_keyword(b"new") {
             Ok(self.consume_new_statement(h)?.upcast())
         } else if self.has_keyword(b"put") {
             Ok(self.consume_put_statement(h)?.upcast())
         } else if self.has_label() {
             Ok(self.consume_labeled_statement(h)?.upcast())
         } else {
             Ok(self.consume_expression_statement(h)?.upcast())
+        }
+    }
     fn has_local_statement(&mut self) -> bool {
         /* To avoid ambiguity, we look ahead to find either the
         channel keyword that signals a variable declaration, or
         a type annotation followed by another identifier.
         Example:
           my_type[] x = {5}; // memory statement
           my_var[5] = x; // assignment expression, expression statement
         Note how both the local and the assignment
         start with arbitrary identifier followed by [. */
         if self.has_keyword(b"channel") {
             return true;
+        }
         if self.has_statement_keyword() {
             return false;
+        }
         let backup_pos = self.source.pos();
         let mut result = false;
         if let Ok(_) = self.consume_type_annotation_spilled() {
             if let Ok(_) = self.consume_whitespace(false) {
                 result = self.has_identifier();
+            }
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_block_statement(&mut self, h: &mut Heap) -> Result<StatementId, ParseError2> {
         let position = self.source.pos();
         let mut statements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         while self.has_local_statement() {
             statements.push(self.consume_local_statement(h)?.upcast());
             self.consume_whitespace(false)?;
+        }
         while !self.has_string(b"}") {
             statements.push(self.consume_statement(h)?);
             self.consume_whitespace(false)?;
+        }
         self.consume_string(b"}")?;
         if statements.is_empty() {
             Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }).upcast())
         } else {
             Ok(h.alloc_block_statement(|this| BlockStatement {
                 this,
                 position,
                 statements,
                 parent_scope: None,
                 locals: Vec::new(),
                 labels: Vec::new(),
             })
             .upcast())
+        }
+    }
     fn consume_local_statement(&mut self, h: &mut Heap) -> Result<LocalStatementId, ParseError2> {
         if self.has_keyword(b"channel") {
             Ok(self.consume_channel_statement(h)?.upcast())
         } else {
             Ok(self.consume_memory_statement(h)?.upcast())
+        }
+    }
     fn consume_channel_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ChannelStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"channel")?;
         self.consume_whitespace(true)?;
         let from_annotation = self.create_type_annotation_output(h)?;
-        let from_identifier = self.consume_identifier(h)?;
         let from_identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b"->")?;
         self.consume_whitespace(false)?;
         let to_annotation = self.create_type_annotation_input(h)?;
-        let to_identifier = self.consume_identifier(h)?;
         let to_identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         let from = h.alloc_local(|this| Local {
             this,
             position,
             type_annotation: from_annotation,
             identifier: from_identifier,
         });
         let to = h.alloc_local(|this| Local {
             this,
             position,
             type_annotation: to_annotation,
             identifier: to_identifier,
         });
         Ok(h.alloc_channel_statement(|this| ChannelStatement {
             this,
             position,
             from,
             to,
             next: None,
         }))
+    }
     fn consume_memory_statement(&mut self, h: &mut Heap) -> Result<MemoryStatementId, ParseError2> {
         let position = self.source.pos();
         let type_annotation = self.consume_type_annotation(h)?;
         self.consume_whitespace(true)?;
-        let identifier = self.consume_identifier(h)?;
         let identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b"=")?;
         self.consume_whitespace(false)?;
         let initial = self.consume_expression(h)?;
         let variable = h.alloc_local(|this| Local { this, position, type_annotation, identifier });
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_memory_statement(|this| MemoryStatement {
             this,
             position,
             variable,
             initial,
             next: None,
         }))
+    }
     fn consume_labeled_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<LabeledStatementId, ParseError2> {
         let position = self.source.pos();
-        let label = self.consume_identifier(h)?;
         let label = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b":")?;
         self.consume_whitespace(false)?;
         let body = self.consume_statement(h)?;
         Ok(h.alloc_labeled_statement(|this| LabeledStatement {
             this,
             position,
             label,
             body,
             in_sync: None,
         }))
+    }
     fn consume_skip_statement(&mut self, h: &mut Heap) -> Result<SkipStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"skip")?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }))
+    }
     fn consume_if_statement(&mut self, h: &mut Heap) -> Result<IfStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"if")?;
         self.consume_whitespace(false)?;
         let test = self.consume_paren_expression(h)?;
         self.consume_whitespace(false)?;
         let true_body = self.consume_statement(h)?;
         self.consume_whitespace(false)?;
         let false_body = if self.has_keyword(b"else") {
             self.consume_keyword(b"else")?;
             self.consume_whitespace(false)?;
             self.consume_statement(h)?
         } else {
             h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }).upcast()
         };
         Ok(h.alloc_if_statement(|this| IfStatement { this, position, test, true_body, false_body }))
+    }
     fn consume_while_statement(&mut self, h: &mut Heap) -> Result<WhileStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"while")?;
         self.consume_whitespace(false)?;
         let test = self.consume_paren_expression(h)?;
         self.consume_whitespace(false)?;
         let body = self.consume_statement(h)?;
         Ok(h.alloc_while_statement(|this| WhileStatement {
             this,
             position,
             test,
             body,
             next: None,
             in_sync: None,
         }))
+    }
     fn consume_break_statement(&mut self, h: &mut Heap) -> Result<BreakStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"break")?;
         self.consume_whitespace(false)?;
         let label;
         if self.has_identifier() {
-            label = Some(self.consume_identifier(h)?);
             label = Some(self.consume_identifier()?);
             self.consume_whitespace(false)?;
         } else {
             label = None;
+        }
         self.consume_string(b";")?;
         Ok(h.alloc_break_statement(|this| BreakStatement { this, position, label, target: None }))
+    }
     fn consume_continue_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ContinueStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"continue")?;
         self.consume_whitespace(false)?;
         let label;
         if self.has_identifier() {
-            label = Some(self.consume_identifier(h)?);
             label = Some(self.consume_identifier()?);
             self.consume_whitespace(false)?;
         } else {
             label = None;
+        }
         self.consume_string(b";")?;
         Ok(h.alloc_continue_statement(|this| ContinueStatement {
             this,
             position,
             label,
             target: None,
         }))
+    }
     fn consume_synchronous_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<SynchronousStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"synchronous")?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         if self.has_string(b"(") {
             self.consume_parameters(h, &mut parameters)?;
             self.consume_whitespace(false)?;
         } else if !self.has_keyword(b"skip") && !self.has_string(b"{") {
             return Err(self.error_at_pos("Expected block statement"));
+        }
         let body = self.consume_statement(h)?;
         Ok(h.alloc_synchronous_statement(|this| SynchronousStatement {
             this,
             position,
             parameters,
             body,
             parent_scope: None,
         }))
+    }
     fn consume_return_statement(&mut self, h: &mut Heap) -> Result<ReturnStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"return")?;
         self.consume_whitespace(false)?;
         let expression = if self.has_string(b"(") {
             self.consume_paren_expression(h)
         } else {
             self.consume_expression(h)
         }?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_return_statement(|this| ReturnStatement { this, position, expression }))
+    }
     fn consume_assert_statement(&mut self, h: &mut Heap) -> Result<AssertStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"assert")?;
         self.consume_whitespace(false)?;
         let expression = if self.has_string(b"(") {
             self.consume_paren_expression(h)
         } else {
             self.consume_expression(h)
         }?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_assert_statement(|this| AssertStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     fn consume_goto_statement(&mut self, h: &mut Heap) -> Result<GotoStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"goto")?;
         self.consume_whitespace(false)?;
-        let label = self.consume_identifier(h)?;
         let label = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_goto_statement(|this| GotoStatement { this, position, label, target: None }))
+    }
     fn consume_new_statement(&mut self, h: &mut Heap) -> Result<NewStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"new")?;
         self.consume_whitespace(false)?;
         let expression = self.consume_call_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_new_statement(|this| NewStatement { this, position, expression, next: None }))
+    }
     fn consume_put_statement(&mut self, h: &mut Heap) -> Result<PutStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"put")?;
         self.consume_whitespace(false)?;
         self.consume_string(b"(")?;
         let port = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b",")?;
         self.consume_whitespace(false)?;
         let message = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b")")?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_put_statement(|this| PutStatement { this, position, port, message, next: None }))
+    }
     fn consume_expression_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ExpressionStatementId, ParseError2> {
         let position = self.source.pos();
         let expression = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_expression_statement(|this| ExpressionStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     // ====================
     // Symbol definitions
     // ====================
     fn has_symbol_definition(&self) -> bool {
         self.has_keyword(b"composite")
             || self.has_keyword(b"primitive")
             || self.has_type_keyword()
             || self.has_identifier()
+    }
     fn consume_symbol_definition(&mut self, h: &mut Heap) -> Result<DefinitionId, ParseError2> {
         if self.has_keyword(b"struct") {
             Ok(self.consume_struct_definition(h)?.upcast())
         } else if self.has_keyword(b"enum") {
             Ok(self.consume_enum_definition(h)?.upcast())
         } else if self.has_keyword(b"composite") || self.has_keyword(b"primitive") {
             Ok(self.consume_component_definition(h)?.upcast())
         } else {
             Ok(self.consume_function_definition(h)?.upcast())
+        }
+    }
     fn consume_struct_definition(&mut self, h: &mut Heap) -> Result<StructId, ParseError2> {
         // Parse "struct" keyword and its identifier
         let struct_pos = self.source.pos();
         self.consume_keyword(b"struct")?;
         self.consume_whitespace(true)?;
-        let struct_ident = self.consume_identifier(h)?;
         let struct_ident = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         // Parse struct fields
         self.consume_string(b"{")?;
         let mut next = self.source.next();
         let mut fields = Vec::new();
         while next.is_some() {
             let char = next.unwrap();
             if char == b'}' {
                 break;
+            }
             // Consume field definition
             self.consume_whitespace(false)?;
             let field_position = self.source.pos();
             let field_type = self.consume_type_annotation(h)?;
             self.consume_whitespace(true)?;
-            let field_ident = self.consume_identifier(h)?;
             let field_ident = self.consume_identifier()?;
             self.consume_whitespace(false)?;
             fields.push(StructFieldDefinition{
                 position: field_position,
                 field: field_ident,
                 the_type: field_type,
             });
             // If we have a comma, then we may or may not have another field
             // definition. Otherwise we expect the struct to be fully defined
             // and expect a closing brace
             next = self.source.next();
             if let Some(b',') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 next = self.source.next();
             } else {
                 break;
+            }
+        }
         // End of struct definition, so we expect a closing brace
         self.consume_string(b"}")?;
         // Valid struct definition
         Ok(h.alloc_struct_definition(|this| StructDefinition{
             this,
             position: struct_pos,
             identifier: struct_ident,
             fields,
         }))
+    }
     fn consume_enum_definition(&mut self, h: &mut Heap) -> Result<EnumId, ParseError2> {
         // Parse "enum" keyword and its identifier
         let enum_pos = self.source.pos();
         self.consume_keyword(b"enum")?;
         self.consume_whitespace(true)?;
-        let enum_ident = self.consume_identifier(h)?;
         let enum_ident = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         // Parse enum variants
         self.consume_string(b"{")?;
         let mut next = self.source.next();
         let mut variants = Vec::new();
         while next.is_some() {
             let char = next.unwrap();
             if char == b'}' {
                 break;
+            }
             // Consume variant identifier
             self.consume_whitespace(false)?;
             let variant_position = self.source.pos();
-            let variant_ident = self.consume_identifier(h)?;
             let variant_ident = self.consume_identifier()?;
             self.consume_whitespace(false)?;
             // Consume variant (tag) value: may be nothing, in which case it is
             // assigned automatically, may be a constant integer, or an embedded
             // type as value, resulting in a tagged union
             next = self.source.next();
             let variant_value = if let Some(b',') = next {
                 EnumVariantValue::None
             } else if let Some(b'=') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 if !self.has_integer() {
                     return Err(self.error_at_pos("expected integer"));
+                }
                 let variant_int = self.consume_integer()?;
                 self.consume_whitespace(false)?;
                 EnumVariantValue::Integer(variant_int)
             } else if let Some(b'(') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 let variant_type = self.consume_type_annotation(h)?;
                 self.consume_whitespace(false)?;
                 self.consume_string(b")")?;
                 self.consume_whitespace(false)?;
                 EnumVariantValue::Type(variant_type)
             } else {
                 return Err(self.error_at_pos("expected ',', '=', or '('"));
             };
             variants.push(EnumVariantDefinition{
                 position: variant_position,
                 identifier: variant_ident,
                 value: variant_value
             });
             // If we have a comma, then we may or may not have another variant,
             // otherwise we expect the enum is fully defined
             next = self.source.next();
             if let Some(b',') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 next = self.source.next();
             } else {
                 break;
+            }
+        }
         self.consume_string(b"}")?;
         // An enum without variants is somewhat valid, but completely useless
         // within the language
         if variants.is_empty() {
             return Err(ParseError2::new_error(self.source, enum_pos, "enum definition without variants"));
+        }
         Ok(h.alloc_enum_definition(|this| EnumDefinition{
             this,
             position: enum_pos,
             identifier: enum_ident,
             variants,
         }))
+    }
     fn consume_component_definition(&mut self, h: &mut Heap) -> Result<ComponentId, ParseError2> {
         // TODO: Cleanup
         if self.has_keyword(b"composite") {
-            Ok(self.consume_composite_definition(h)?.upcast())
             Ok(self.consume_composite_definition(h)?)
         } else {
-            Ok(self.consume_primitive_definition(h)?.upcast())
             Ok(self.consume_primitive_definition(h)?)
+        }
+    }
-    fn consume_composite_definition(&mut self, h: &mut Heap) -> Result<CompositeId, ParseError2> {
+    fn consume_composite_definition(&mut self, h: &mut Heap) -> Result<ComponentId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"composite")?;
         self.consume_whitespace(true)?;
-        let identifier = self.consume_identifier(h)?;
         let identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_composite(|this| Composite { this, position, identifier, parameters, body }))
         Ok(h.alloc_component(|this| Component {
             this, variant: ComponentVariant::Composite, position, identifier, parameters, body
         }))
+    }
-    fn consume_primitive_definition(&mut self, h: &mut Heap) -> Result<PrimitiveId, ParseError2> {
+    fn consume_primitive_definition(&mut self, h: &mut Heap) -> Result<ComponentId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"primitive")?;
         self.consume_whitespace(true)?;
-        let identifier = self.consume_identifier(h)?;
         let identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_primitive(|this| Primitive { this, position, identifier, parameters, body }))
         Ok(h.alloc_component(|this| Component {
             this, variant: ComponentVariant::Primitive, position, identifier, parameters, body
         }))
+    }
     fn consume_function_definition(&mut self, h: &mut Heap) -> Result<FunctionId, ParseError2> {
         let position = self.source.pos();
         let return_type = self.consume_type_annotation(h)?;
         self.consume_whitespace(true)?;
-        let identifier = self.consume_identifier(h)?;
         let identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_function(|this| Function {
             this,
             position,
             return_type,
             identifier,
             parameters,
             body,
         }))
+    }
     fn has_pragma(&self) -> bool {
         if let Some(c) = self.source.next() {
             c == b'#'
         } else {
             false
+        }
+    }
     fn consume_pragma(&mut self, h: &mut Heap) -> Result<PragmaId, ParseError2> {
         let position = self.source.pos();
         let next = self.source.next();
         if next != Some(b'#') {
             return Err(self.error_at_pos("Expected pragma"));
+        }
         self.source.consume();
         if !is_vchar(self.source.next()) {
             return Err(self.error_at_pos("Expected pragma"));
+        }
         if self.has_string(b"version") {
             self.consume_string(b"version")?;
             self.consume_whitespace(true)?;
             if !self.has_integer() {
                 return Err(self.error_at_pos("Expected integer constant"));
+            }
             let version = self.consume_integer()?;
             debug_assert!(version >= 0);
             return Ok(h.alloc_pragma(|this| Pragma::Version(PragmaVersion{
                 this, position, version: version as u64
             })))
         } else if self.has_string(b"module") {
             self.consume_string(b"module")?;
             self.consume_whitespace(true)?;
             if !self.has_identifier() {
                 return Err(self.error_at_pos("Expected identifier"));
+            }
             let mut value = Vec::new();
             let mut ident = self.consume_ident()?;
             value.append(&mut ident);
             while self.has_string(b".") {
                 self.consume_string(b".")?;
                 value.push(b'.');
                 ident = self.consume_ident()?;
                 value.append(&mut ident);
+            }
             return Ok(h.alloc_pragma(|this| Pragma::Module(PragmaModule{
                 this, position, value
             })));
         } else {
             return Err(self.error_at_pos("Unknown pragma"));
+        }
+    }
     fn has_import(&self) -> bool {
         self.has_keyword(b"import")
+    }
     fn consume_import(&mut self, h: &mut Heap) -> Result<ImportId, ParseError2> {
         // Parse the word "import" and the name of the module
         let position = self.source.pos();
         self.consume_keyword(b"import")?;
         self.consume_whitespace(true)?;
         let mut value = Vec::new();
         let mut ident = self.consume_ident()?;
         value.append(&mut ident);
         let mut last_ident_start = 0;
         while self.has_string(b".") {
             self.consume_string(b".")?;
             value.push(b'.');
             ident = self.consume_ident()?;
             last_ident_start = value.len();
             value.append(&mut ident);
+        }
         self.consume_whitespace(false)?;
         // Check for the potential aliasing or specific module imports
         let import = if self.has_string(b"as") {
             self.consume_string(b"as")?;
             self.consume_whitespace(true)?;
             let alias = self.consume_ident()?;
             h.alloc_import(|this| Import::Module(ImportModule{
                 this,
                 position,
                 module_name: value,
                 alias,
                 module_id: None,
             }))
         } else if self.has_string(b"::") {
             self.consume_string(b"::")?;
             self.consume_whitespace(false)?;
             if let Some(b'{') = self.source.next() {
                 // Import specific symbols, optionally with an alias
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 let mut symbols = Vec::new();
                 let mut next = self.source.next();
                 while next.is_some() {
                     let char = next.unwrap();
                     if char == b'}' {
                         break;
+                    }
                     let symbol_position = self.source.pos();
                     let symbol_name = self.consume_ident()?;
                     self.consume_whitespace(false)?;
                     if self.has_string(b"as") {
                         // Symbol has an alias
                         self.consume_string(b"as")?;
                         self.consume_whitespace(true)?;
                         let symbol_alias = self.consume_ident()?;
                         symbols.push(AliasedSymbol{
                             position: symbol_position,
                             name: symbol_name,
                             alias: symbol_alias,
                             definition_id: None,
                         });
                     } else {
                         // Symbol does not have an alias
                         symbols.push(AliasedSymbol{
                             position: symbol_position,
                             name: symbol_name.clone(),
                             alias: symbol_name,
                             definition_id: None,
                         });
+                    }
                     // A comma indicates that we may have another symbol coming
                     // up (not necessary), but if not present then we expect the
                     // end of the symbol list
                     self.consume_whitespace(false)?;
                     next = self.source.next();
                     if let Some(b',') = next {
                         self.source.consume();
                         self.consume_whitespace(false)?;
                         next = self.source.next();
                     } else {
                         break;
+                    }
+                }
                 if let Some(b'}') = next {
                     // We are fine, push the imported symbols
                     self.source.consume();
                     if symbols.is_empty() {
                         return Err(ParseError2::new_error(self.source, position, "empty symbol import list"));
+                    }
                     h.alloc_import(|this| Import::Symbols(ImportSymbols{
                         this,
                         position,
                         module_name: value,
                         module_id: None,
                         symbols,
                     }))
                 } else {
                     return Err(self.error_at_pos("Expected '}'"));
+                }
             } else if let Some(b'*') = self.source.next() {
                 // Import all symbols without alias
                 self.source.consume();
                 h.alloc_import(|this| Import::Symbols(ImportSymbols{
                     this,
                     position,
                     module_name: value,
                     module_id: None,
                     symbols: Vec::new()
                 }))
             } else {
                 return Err(self.error_at_pos("Expected '*' or '{'"));
+            }
         } else {
             // No explicit alias or subimports, so implicit alias
             let alias = Vec::from(&value[last_ident_start..]);
             h.alloc_import(|this| Import::Module(ImportModule{
                 this,
                 position,
                 module_name: value,
                 alias,
                 module_id: None,
             }))
         };
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(import)
+    }
     pub fn consume_protocol_description(&mut self, h: &mut Heap) -> Result<RootId, ParseError2> {
         let position = self.source.pos();
         let mut pragmas = Vec::new();
         let mut imports = Vec::new();
         let mut definitions = Vec::new();
         self.consume_whitespace(false)?;
         while self.has_pragma() {
             let pragma = self.consume_pragma(h)?;
             pragmas.push(pragma);
             self.consume_whitespace(false)?;
+        }
         while self.has_import() {
             let import = self.consume_import(h)?;
             imports.push(import);
             self.consume_whitespace(false)?;
+        }
         while self.has_symbol_definition() {
             let def = self.consume_symbol_definition(h)?;
             definitions.push(def);
             self.consume_whitespace(false)?;
+        }
         // end of file
         if !self.source.is_eof() {
             return Err(self.error_at_pos("Expected end of file"));
+        }
         Ok(h.alloc_protocol_description(|this| Root {
             this,
             position,
             pragmas,
             imports,
             definitions,
             declarations: Vec::new(),
         }))
+    }
+}
 #[cfg(test)]
 mod tests {
     use crate::protocol::ast::*;
     use crate::protocol::{ast, lexer::*};
     use crate::protocol::inputsource::*;
     #[test]
     fn test_pragmas() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         #version 0o7777
         #module something.dot.separated
         ").expect("new InputSource");
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h)
             .expect("lex input source");
         let root = &h[lexed];
         assert_eq!(root.pragmas.len(), 2);
         let pv = &h[root.pragmas[0]];
         let pm = &h[root.pragmas[1]];
         if let Pragma::Version(v) = pv {
             assert_eq!(v.version, 0o7777)
         } else {
             assert!(false, "first pragma not version");
+        }
         if let Pragma::Module(m) = pm {
             assert_eq!(m.value, b"something.dot.separated");
         } else {
             assert!(false, "second pragma not module");
+        }
+    }
     #[test]
     fn test_import() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         // Module imports, with optional and explicit aliasing
         import single_module;
         import std.reo;
         import something.other as alias;
         // Symbol imports
         import some_module::*;
         import some_module::{Foo as Bar, Qux, Dix as Flu};
         import std.reo::{
             Foo as Bar, // because thing
             Qux as Mox, // more explanations
             Dix, /* yesh, import me */
         };
         ").unwrap();
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h).unwrap();
         let root = &h[lexed];
         assert_eq!(root.imports.len(), 6);
         let no_alias_single = h[root.imports[0]].as_module();
         let no_alias_multi = h[root.imports[1]].as_module();
         let with_alias = h[root.imports[2]].as_module();
         assert_eq!(no_alias_single.module_name, b"single_module");
         assert_eq!(no_alias_single.alias, b"single_module");
         assert_eq!(no_alias_multi.module_name, b"std.reo");
         assert_eq!(no_alias_multi.alias, b"reo");
         assert_eq!(with_alias.module_name, b"something.other");
         assert_eq!(with_alias.alias, b"alias");
         let all_symbols = h[root.imports[3]].as_symbols();
         let single_line_symbols = h[root.imports[4]].as_symbols();
         let multi_line_symbols = h[root.imports[5]].as_symbols();
         assert_eq!(all_symbols.module_name, b"some_module");
         assert!(all_symbols.symbols.is_empty());
         assert_eq!(single_line_symbols.module_name, b"some_module");
         assert_eq!(single_line_symbols.symbols.len(), 3);
         assert_eq!(single_line_symbols.symbols[0].name, b"Foo");
         assert_eq!(single_line_symbols.symbols[0].alias, b"Bar");
         assert_eq!(single_line_symbols.symbols[1].name, b"Qux");
         assert_eq!(single_line_symbols.symbols[1].alias, b"Qux");
         assert_eq!(single_line_symbols.symbols[2].name, b"Dix");
         assert_eq!(single_line_symbols.symbols[2].alias, b"Flu");
         assert_eq!(multi_line_symbols.module_name, b"std.reo");
         assert_eq!(multi_line_symbols.symbols.len(), 3);
         assert_eq!(multi_line_symbols.symbols[0].name, b"Foo");
         assert_eq!(multi_line_symbols.symbols[0].alias, b"Bar");
         assert_eq!(multi_line_symbols.symbols[1].name, b"Qux");
         assert_eq!(multi_line_symbols.symbols[1].alias, b"Mox");
         assert_eq!(multi_line_symbols.symbols[2].name, b"Dix");
         assert_eq!(multi_line_symbols.symbols[2].alias, b"Dix");
+    }
     #[test]
     fn test_struct_definition() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         struct Foo {
             byte one,
             short two,
             Bar three,
+        }
         struct Bar{int[] one, int[] two, Qux[] three}
         ").unwrap();
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h);
         if let Err(err) = &lexed {
             println!("{}", err);
+        }
         let lexed = lexed.unwrap();
         let root = &h[lexed];
         assert_eq!(root.definitions.len(), 2);
         let symbolic_type = |v: &PrimitiveType| -> Vec<u8> {
             if let PrimitiveType::Symbolic(v) = v {
                 v.identifier.value.clone()
             } else {
                 assert!(false);
                 unreachable!();
+            }
         };
         let foo_def = h[root.definitions[0]].as_struct();
         assert_eq!(foo_def.identifier.value, b"Foo");
         assert_eq!(foo_def.fields.len(), 3);
         assert_eq!(foo_def.fields[0].field.value, b"one");
         assert_eq!(h[foo_def.fields[0].the_type].the_type, Type::BYTE);
         assert_eq!(foo_def.fields[1].field.value, b"two");
         assert_eq!(h[foo_def.fields[1].the_type].the_type, Type::SHORT);
         assert_eq!(foo_def.fields[2].field.value, b"three");
         assert_eq!(h[foo_def.fields[2].the_type].the_type.primitive, PrimitiveType::Symbolic(Vec::from("Bar".as_bytes())));
         assert_eq!(
             symbolic_type(&h[foo_def.fields[2].the_type].the_type.primitive),
             Vec::from("Bar".as_bytes())
         );
         let bar_def = h[root.definitions[1]].as_struct();
         assert_eq!(bar_def.identifier.value, b"Bar");
         assert_eq!(bar_def.fields.len(), 3);
         assert_eq!(bar_def.fields[0].field.value, b"one");
         assert_eq!(h[bar_def.fields[0].the_type].the_type, Type::INT_ARRAY);
         assert_eq!(bar_def.fields[1].field.value, b"two");
         assert_eq!(h[bar_def.fields[1].the_type].the_type, Type::INT_ARRAY);
         assert_eq!(bar_def.fields[2].field.value, b"three");
         assert_eq!(h[bar_def.fields[2].the_type].the_type.array, true);
         assert_eq!(h[bar_def.fields[2].the_type].the_type.primitive, PrimitiveType::Symbolic(Vec::from("Qux".as_bytes())));
         assert_eq!(
             symbolic_type(&h[bar_def.fields[2].the_type].the_type.primitive),
             Vec::from("Qux".as_bytes())
         );
+    }
     #[test]
     fn test_enum_definition() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         enum Foo {
             A = 0,
             B = 5,
             C,
             D = 0xFF,
+        }
         enum Bar { Ayoo, Byoo, Cyoo,}
         enum Qux { A(byte[]), B(Bar[]), C(byte)
+        }
         ").unwrap();
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h).unwrap();
         let root = &h[lexed];
         assert_eq!(root.definitions.len(), 3);
         let foo_def = h[root.definitions[0]].as_enum();
         assert_eq!(foo_def.identifier.value, b"Foo");
         assert_eq!(foo_def.variants.len(), 4);
         assert_eq!(foo_def.variants[0].identifier.value, b"A");
         assert_eq!(foo_def.variants[0].value, EnumVariantValue::Integer(0));
         assert_eq!(foo_def.variants[1].identifier.value, b"B");
         assert_eq!(foo_def.variants[1].value, EnumVariantValue::Integer(5));
         assert_eq!(foo_def.variants[2].identifier.value, b"C");
         assert_eq!(foo_def.variants[2].value, EnumVariantValue::None);
         assert_eq!(foo_def.variants[3].identifier.value, b"D");
         assert_eq!(foo_def.variants[3].value, EnumVariantValue::Integer(0xFF));
         let bar_def = h[root.definitions[1]].as_enum();
         assert_eq!(bar_def.identifier.value, b"Bar");
         assert_eq!(bar_def.variants.len(), 3);
         assert_eq!(bar_def.variants[0].identifier.value, b"Ayoo");
         assert_eq!(bar_def.variants[0].value, EnumVariantValue::None);
         assert_eq!(bar_def.variants[1].identifier.value, b"Byoo");
         assert_eq!(bar_def.variants[1].value, EnumVariantValue::None);
         assert_eq!(bar_def.variants[2].identifier.value, b"Cyoo");
         assert_eq!(bar_def.variants[2].value, EnumVariantValue::None);
         let qux_def = h[root.definitions[2]].as_enum();
         let enum_type = |value: &EnumVariantValue| -> &TypeAnnotation {
             if let EnumVariantValue::Type(t) = value {
                 &h[*t]
             } else {
                 assert!(false);
                 unreachable!();
+            }
         };
         assert_eq!(qux_def.identifier.value, b"Qux");
         assert_eq!(qux_def.variants.len(), 3);
         assert_eq!(qux_def.variants[0].identifier.value, b"A");
         assert_eq!(enum_type(&qux_def.variants[0].value).the_type, Type::BYTE_ARRAY);
         assert_eq!(qux_def.variants[1].identifier.value, b"B");
         assert_eq!(enum_type(&qux_def.variants[1].value).the_type.array, true);
         assert_eq!(enum_type(&qux_def.variants[1].value).the_type.primitive, PrimitiveType::Symbolic(Vec::from("Bar".as_bytes())));
         if let PrimitiveType::Symbolic(t) = &enum_type(&qux_def.variants[1].value).the_type.primitive {
             assert_eq!(t.identifier.value, Vec::from("Bar".as_bytes()));
         } else { assert!(false) }
         assert_eq!(qux_def.variants[2].identifier.value, b"C");
         assert_eq!(enum_type(&qux_def.variants[2].value).the_type, Type::BYTE);
+    }
 //     #[test]
 //     fn test_lowercase() {
 //         assert_eq!(lowercase(b'a'), b'a');
 //         assert_eq!(lowercase(b'A'), b'a');
 //         assert_eq!(lowercase(b'z'), b'z');
 //         assert_eq!(lowercase(b'Z'), b'z');
 //     }
 //     #[test]
 //     fn test_basic_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("a+b;").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:?}", expr);
 //                 if let Binary(bin) = &h[expr] {
 //                     if let Variable(left) = &h[bin.left] {
 //                         if let Variable(right) = &h[bin.right] {
 //                             assert_eq!("a", format!("{}", h[left.identifier]));
 //                             assert_eq!("b", format!("{}", h[right.identifier]));
 //                             assert_eq!(Some(b';'), is.next());
 //                             return;
 //                         }
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_paren_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("(true)").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_paren_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:#?}", expr);
 //                 if let Constant(con) = &h[expr] {
 //                     if let ast::Constant::True = con.value {
 //                         return;
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("(x(1+5,get(y))-w[5])+z++\n").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:#?}", expr);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_basic_statement() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("while (true) { skip; }").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_statement(&mut h) {
 //             Ok(stmt) => {
 //                 println!("{:#?}", stmt);
 //                 if let Statement::While(w) = &h[stmt] {
 //                     if let Expression::Constant(_) = h[w.test] {
 //                         if let Statement::Block(_) = h[w.body] {
 //                             return;
 //                         }
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_statement() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string(
 //             "label: while (true) { if (x++ > y[0]) break label; else continue; }\n",
 //         )
 //         .unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_statement(&mut h) {
 //             Ok(stmt) => {
 //                 println!("{:#?}", stmt);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
+}

src/protocol/parser/depth_visitor.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::library;
 // 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 {
         Ok(())
+    }
     fn visit_enum_definition(&mut self, h: &mut Heap, def: EnumId) -> VisitorResult {
         Ok(())
+    }
     fn visit_component_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {
         recursive_component_definition(self, h, def)
+    }
-    fn visit_composite_definition(&mut self, h: &mut Heap, def: CompositeId) -> VisitorResult {
+    fn visit_composite_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {
         recursive_composite_definition(self, h, def)
+    }
-    fn visit_primitive_definition(&mut self, h: &mut Heap, def: PrimitiveId) -> VisitorResult {
+    fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {
         recursive_primitive_definition(self, h, def)
+    }
     fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionId) -> 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(())
+    }
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
         recursive_statement(self, h, stmt)
+    }
     fn visit_local_statement(&mut self, h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         recursive_local_statement(self, h, stmt)
+    }
     fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {
         recursive_memory_statement(self, h, stmt)
+    }
     fn visit_channel_statement(
         &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_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         recursive_while_statement(self, h, stmt)
+    }
     fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ContinueStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         recursive_synchronous_statement(self, h, stmt)
+    }
     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_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_put_statement(&mut self, h: &mut Heap, stmt: PutStatementId) -> VisitorResult {
         recursive_put_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(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         recursive_assignment_expression(self, h, expr)
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         recursive_conditional_expression(self, h, expr)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         recursive_binary_expression(self, h, expr)
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         recursive_unary_expression(self, h, expr)
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         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: ConstantExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
         _h: &mut Heap,
         _expr: VariableExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
+}
 // Bubble-up helpers
 fn recursive_parameter_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     param: ParameterId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, param.upcast())
+}
 fn recursive_local_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     local: LocalId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, local.upcast())
+}
 fn recursive_call_expression_as_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     call: CallExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, call.upcast())
+}
 // Recursive procedures
 fn recursive_protocol_description<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     pd: RootId,
 ) -> VisitorResult {
     for &pragma in h[pd].pragmas.clone().iter() {
         this.visit_pragma(h, pragma)?;
+    }
     for &import in h[pd].imports.clone().iter() {
         this.visit_import(h, import)?;
+    }
     for &def in h[pd].definitions.clone().iter() {
         this.visit_symbol_definition(h, def)?;
+    }
     Ok(())
+}
 fn recursive_symbol_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: DefinitionId,
 ) -> VisitorResult {
     // We clone the definition in case it is modified
     // TODO: Fix me
     match h[def].clone() {
         Definition::Struct(def) => this.visit_struct_definition(h, def.this),
         Definition::Enum(def) => this.visit_enum_definition(h, def.this),
-        Definition::Component(cdef) => this.visit_component_definition(h, cdef.this()),
         Definition::Component(cdef) => this.visit_component_definition(h, cdef.this),
         Definition::Function(fdef) => this.visit_function_definition(h, fdef.this),
+    }
+}
 fn recursive_component_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentId,
 ) -> VisitorResult {
     match h[def].clone() {
         Component::Composite(cdef) => this.visit_composite_definition(h, cdef.this),
         Component::Primitive(pdef) => this.visit_primitive_definition(h, pdef.this),
     let component_variant = h[def].variant;
     match component_variant {
         ComponentVariant::Primitive => this.visit_primitive_definition(h, def),
         ComponentVariant::Composite => this.visit_composite_definition(h, def),
+    }
+}
 fn recursive_composite_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
-    def: CompositeId,
+    def: ComponentId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_primitive_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
-    def: PrimitiveId,
+    def: ComponentId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_function_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: FunctionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_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::Put(stmt) => this.visit_put_statement(h, stmt.this),
         Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),
         Statement::EndSynchronous(_) | Statement::EndWhile(_) | Statement::EndIf(_) => {
             unreachable!() // pseudo-statement
+        }
+    }
+}
 fn recursive_block_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     block: BlockStatementId,
 ) -> VisitorResult {
     for &local in h[block].locals.clone().iter() {
         recursive_local_as_variable(this, h, local)?;
+    }
     for &stmt in h[block].statements.clone().iter() {
         this.visit_statement(h, stmt)?;
+    }
     Ok(())
+}
 fn recursive_local_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LocalStatementId,
 ) -> VisitorResult {
     match h[stmt].clone() {
         LocalStatement::Channel(stmt) => this.visit_channel_statement(h, stmt.this),
         LocalStatement::Memory(stmt) => this.visit_memory_statement(h, stmt.this),
+    }
+}
 fn recursive_memory_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: MemoryStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].initial)
+}
 fn recursive_labeled_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LabeledStatementId,
 ) -> VisitorResult {
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_if_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: IfStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_statement(h, h[stmt].true_body)?;
     this.visit_statement(h, h[stmt].false_body)
+}
 fn recursive_while_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: WhileStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_synchronous_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: SynchronousStatementId,
 ) -> VisitorResult {
     for &param in h[stmt].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_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)
+}
 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_put_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: PutStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].port)?;
     this.visit_expression(h, h[stmt].message)
+}
 fn recursive_expression_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ExpressionStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ExpressionId,
 ) -> VisitorResult {
     match h[expr].clone() {
         Expression::Assignment(expr) => this.visit_assignment_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::Constant(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)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_conditional_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ConditionalExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].test)?;
     this.visit_expression(h, h[expr].true_expression)?;
     this.visit_expression(h, h[expr].false_expression)
+}
 fn recursive_binary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: BinaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_unary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: UnaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].expression)
+}
 fn recursive_indexing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: IndexingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     this.visit_expression(h, h[expr].index)
+}
 fn recursive_slicing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: SlicingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     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: CompositeId) -> VisitorResult {
+    fn visit_composite_definition(&mut self, h: &mut Heap, def: ComponentId) -> 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: FunctionId) -> 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: PrimitiveId) -> VisitorResult {
+    fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentId) -> 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: ComponentId) -> 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: ComponentId) -> 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: PrimitiveId) -> VisitorResult {
+    fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentId) -> 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 BuildSymbolDeclarations {
     declarations: Vec<DeclarationId>,
+}
 impl BuildSymbolDeclarations {
     pub(crate) fn new() -> Self {
         BuildSymbolDeclarations { declarations: Vec::new() }
+    }
     fn checked_add(&mut self, h: &mut Heap, decl: DeclarationId) -> VisitorResult {
         for &old in self.declarations.iter() {
             let id = h[decl].identifier();
             if id.value == h[old].identifier().value {
                 return match h[decl].clone() {
                     Declaration::Defined(defined) => Err((
                         h[defined.definition].position(),
                         format!("Defined symbol clash: {}", String::from_utf8_lossy(&id.value)),
                     )),
                     Declaration::Imported(imported) => Err((
                         h[imported.import].position(),
                         format!("Imported symbol clash: {}", String::from_utf8_lossy(&id.value)),
                     )),
                 };
+            }
+        }
         self.declarations.push(decl);
         Ok(())
+    }
+}
 impl Visitor for BuildSymbolDeclarations {
     fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {
         recursive_protocol_description(self, h, pd)?;
         // Move all collected declarations to the protocol description
         h[pd].declarations.append(&mut self.declarations);
         Ok(())
+    }
     fn visit_import(&mut self, h: &mut Heap, import: ImportId) -> VisitorResult {
         // println!("DEBUG: Warning (at {}:{}), import actually not yet implemented", file!(), line!());
         // TODO: Implement
         let vec = library::get_declarations(h, import);
         if let Err(_err)= vec {
             return Err((h[import].position(), "Failed to perform import".to_string()))
+        }
         // Destructively iterate over the vector
         for decl in vec.unwrap() {
             self.checked_add(h, decl)?;
+        }
         Ok(())
+    }
     fn visit_symbol_definition(&mut self, h: &mut Heap, definition: DefinitionId) -> VisitorResult {
         let signature = Signature::from_definition(h, definition);
         let decl = h
             .alloc_defined_declaration(|this| DefinedDeclaration { this, definition, signature })
             .upcast();
         self.checked_add(h, decl)?;
         Ok(())
+    }
+}
 pub(crate) struct LinkCallExpressions {
     pd: Option<RootId>,
     composite: bool,
     new_statement: bool,
+}
 impl LinkCallExpressions {
     pub(crate) fn new() -> Self {
         LinkCallExpressions { pd: None, composite: false, new_statement: false }
+    }
     fn get_declaration(
         &self,
         h: &Heap,
         id: &Identifier,
     ) -> Result<DeclarationId, VisitorError> {
         match h[self.pd.unwrap()].get_declaration(h, &id) {
             Some(id) => Ok(id),
             None => Err((id.position, "Unresolved method".to_string())),
+        }
+    }
     fn get_declaration_namespaced(
         &self, h: &Heap, id: &NamespacedIdentifier
     ) -> Result<DeclarationId, VisitorError> {
         // TODO: @fixme
         match h[self.pd.unwrap()].get_declaration_namespaced(h, id) {
             Some(id) => Ok(id),
             None => Err((id.position, "Unresolved method".to_string()))
+        }
+    }
+}
 impl Visitor for LinkCallExpressions {
     fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {
         self.pd = Some(pd);
         recursive_protocol_description(self, h, pd)?;
         self.pd = None;
         Ok(())
+    }
-    fn visit_composite_definition(&mut self, h: &mut Heap, def: CompositeId) -> VisitorResult {
+    fn visit_composite_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {
         assert!(!self.composite);
         self.composite = true;
         recursive_composite_definition(self, h, def)?;
         self.composite = false;
         Ok(())
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         assert!(self.composite);
         assert!(!self.new_statement);
         self.new_statement = true;
         recursive_new_statement(self, h, stmt)?;
         self.new_statement = false;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         if let Method::Symbolic(id) = &h[expr].method {
             // TODO: @symbol_table
-            let decl = self.get_declaration(h, id)?;
+            let decl = self.get_declaration_namespaced(h, &id.identifier)?;
             if self.new_statement && h[decl].is_function() {
                 return Err((id.position, "Illegal call expression".to_string()));
+                return Err((id.identifier.position, "Illegal call expression".to_string()));
+            }
             if !self.new_statement && h[decl].is_component() {
                 return Err((id.position, "Illegal call expression".to_string()));
+                return Err((id.identifier.position, "Illegal call expression".to_string()));
+            }
             // Set the corresponding declaration of the call
             h[expr].declaration = Some(decl);
+        }
         // A new statement's call expression may have as arguments function calls
         let old = self.new_statement;
         self.new_statement = false;
         recursive_call_expression(self, h, expr)?;
         self.new_statement = old;
         Ok(())
+    }
+}
 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::Block(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
         self.scope = Some(Scope::Synchronous(stmt));
         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 ResolveVariables {
     scope: Option<Scope>,
+}
 impl ResolveVariables {
     pub(crate) fn new() -> Self {
         ResolveVariables { scope: None }
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Result<VariableId, VisitorError> {
         if let Some(var) = self.find_variable(h, id) {
             Ok(var)
         } else {
             Err((id.position, "Unresolved variable".to_string()))
+        }
+    }
     fn find_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         ResolveVariables::find_variable_impl(h, self.scope, id)
+    }
     fn find_variable_impl(
         h: &Heap,
         scope: Option<Scope>,
         id: &Identifier,
     ) -> Option<VariableId> {
         if let Some(scope) = scope {
             // The order in which we check for variables is important:
             // otherwise, two variables with the same name are shadowed.
             if let Some(var) = ResolveVariables::find_variable_impl(h, scope.parent_scope(h), id) {
                 Some(var)
             } else {
                 scope.get_variable(h, id)
+            }
         } else {
             None
+        }
+    }
+}
 impl Visitor for ResolveVariables {
     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_variable_declaration(&mut self, h: &mut Heap, decl: VariableId) -> VisitorResult {
         // This is only called for parameters of definitions and synchronous statements,
         // since the local variables of block statements are still empty
         // the moment it is traversed. After resolving variables, this
         // function is also called for every local variable declaration.
         // We want to make sure that the resolved variable is the variable declared itself;
         // otherwise, there is some variable defined in the parent scope. This check
         // imposes that the order in which find_variable looks is significant!
         let id = h[decl].identifier();
         let check_same = self.find_variable(h, id);
         if let Some(check_same) = check_same {
             if check_same != decl {
                 return Err((id.position, "Declared variable clash".to_string()));
+            }
+        }
         recursive_variable_declaration(self, h, decl)
+    }
     fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let var = h[stmt].variable;
         let id = &h[var].identifier;
         // First check whether variable with same identifier is in scope
         let check_duplicate = self.find_variable(h, id);
         if check_duplicate.is_some() {
             return Err((id.position, "Declared variable clash".to_string()));
+        }
         // Then check the expression's variables (this should not refer to own variable)
         recursive_memory_statement(self, h, stmt)?;
         // Finally, we may add the variable to the scope, which is guaranteed to be a block
+        {
             let block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         Ok(())
+    }
     fn visit_channel_statement(&mut self, h: &mut Heap, stmt: ChannelStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         // First handle the from variable
+        {
             let var = h[stmt].from;
             let id = &h[var].identifier;
             let check_duplicate = self.find_variable(h, id);
             if check_duplicate.is_some() {
                 return Err((id.position, "Declared variable clash".to_string()));
+            }
             let block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         // Then handle the to variable (which may not be the same as the from)
+        {
             let var = h[stmt].to;
             let id = &h[var].identifier;
             let check_duplicate = self.find_variable(h, id);
             if check_duplicate.is_some() {
                 return Err((id.position, "Declared variable clash".to_string()));
+            }
             let block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         self.scope = Some(Scope::Block(stmt));
         recursive_block_statement(self, h, stmt)?;
         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;
         self.scope = Some(Scope::Synchronous(stmt));
         recursive_synchronous_statement(self, h, stmt)?;
         self.scope = old;
         Ok(())
+    }
     fn visit_variable_expression(

src/protocol/parser/symbol_table.rs

➞

Show inline comments

 // TODO: Maybe allow namespaced-aliased imports. It is currently not possible
 //  to express the following:
 //      import Module.Submodule as SubMod
 //      import SubMod::{Symbol}
 //  And it is especially not possible to express the following:
 //      import SubMod::{Symbol}
 //      import Module.Submodule as SubMod
 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use std::collections::{HashMap, hash_map::Entry};
 use crate::protocol::parser::LexedModule;
 #[derive(PartialEq, Eq, Hash)]
 struct SymbolKey {
     module_id: RootId,
     symbol_name: Vec<u8>,
+}
 pub(crate) enum Symbol {
     Namespace(RootId),
     Definition((RootId, DefinitionId)),
+}
 pub(crate) struct SymbolValue {
     // Position refers to the origin of the symbol definition (i.e. the module's
     // RootId that is in the key being used to lookup this value)
     position: InputPosition,
     symbol: Symbol,
     pub(crate) position: InputPosition,
     pub(crate) symbol: Symbol,
+}
 impl SymbolValue {
     pub(crate) fn is_namespace(&self) -> bool {
         match &self.symbol {
             Symbol::Namespace(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn as_namespace(&self) -> Option<RootId> {
         match &self.symbol {
             Symbol::Namespace(root_id) => Some(*root_id),
             _ => None,
+        }
+    }
     pub(crate) fn as_definition(&self) -> Option<(RootId, DefinitionId)> {
         match &self.symbol {
             Symbol::Definition((root_id, definition_id)) => Some((*root_id, *definition_id)),
             _ => None,
+        }
+    }
+}
 /// `SymbolTable` is responsible for two parts of the parsing process: firstly
 /// it ensures that there are no clashing symbol definitions within each file,
 /// and secondly it will resolve all symbols within a module to their
 /// appropriate definitions (in case of enums, functions, etc.) and namespaces
 /// (currently only external modules can act as namespaces). If a symbol clashes
 /// or if a symbol cannot be resolved this will be an error.
 ///
 /// Within the compilation process the symbol table is responsible for resolving
 /// namespaced identifiers (e.g. Module::Enum::EnumVariant) to the appropriate
 /// definition (i.e. not namespaces; as the language has no way to use
 /// namespaces except for using them in namespaced identifiers).
 // TODO: Maybe allow namespaced-aliased imports. It is currently not possible
 //  to express the following:
 //  import Module.Submodule as ModSub
 //  import SubMod::{Symbol}
 pub(crate) struct SymbolTable {
     // Lookup from module name (not any aliases) to the root id
     module_lookup: HashMap<Vec<u8>, RootId>,
     // Lookup from within a module, to a particular imported (potentially
     // aliased) or defined symbol. Basically speaking: if the source code of a
     // module contains correctly imported/defined symbols, then this lookup
     // will always return the corresponding definition
     symbol_lookup: HashMap<SymbolKey, SymbolValue>,
+}
 impl SymbolTable {
     pub(crate) fn new(heap: &Heap, modules: &[LexedModule]) -> Result<Self, ParseError2> {
         // Sanity check
         if cfg!(debug_assertions) {
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(
                     index, module.root_id.0.index as usize,
                     "module RootId does not correspond to LexedModule index"
+                )
+            }
+        }
         // Preparation: create a lookup from module name to root id. This does
         // not take aliasing into account.
         let mut module_lookup = HashMap::with_capacity(modules.len());
         for module in modules {
             // TODO: Maybe put duplicate module name checking here?
             // TODO: @string
             module_lookup.insert(module.module_name.clone(), module.root_id);
+        }
         // Preparation: determine total number of imports we will be inserting
         // into the lookup table. We could just iterate over the arena, but then
         // we don't know the source file the import belongs to.
         let mut lookup_reserve_size = 0;
         for module in modules {
             let module_root = &heap[module.root_id];
             for import_id in &module_root.imports {
                 match &heap[*import_id] {
                     Import::Module(_) => lookup_reserve_size += 1,
                     Import::Symbols(import) => {
                         if import.symbols.is_empty() {
                             // Add all symbols from the other module
                             match module_lookup.get(&import.module_name) {
                                 Some(target_module_id) => {
                                     lookup_reserve_size += heap[*target_module_id].definitions.len()
                                 },
                                 None => {
                                     return Err(
                                         ParseError2::new_error(&module.source, import.position, "Cannot resolve module")
                                     );
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
         let mut table = Self{
             module_lookup,
             symbol_lookup: HashMap::with_capacity(lookup_reserve_size)
         };
         // First pass: we go through all of the modules and add lookups to
         // symbols that are defined within that module. Cross-module imports are
         // not yet resolved
         for module in modules {
             let root = &heap[module.root_id];
             for definition_id in &root.definitions {
                 let definition = &heap[*definition_id];
                 let identifier = definition.identifier();
                 if let Err(previous_position) = table.add_definition_symbol(
                     module.root_id, identifier.position, &identifier.value,
                     module.root_id, *definition_id
                 ) {
                     return Err(
                         ParseError2::new_error(&module.source, definition.position(), "Symbol is multiply defined")
                             .with_postfixed_info(&module.source, previous_position, "Previous definition was here")
+                    )
+                }
+            }
+        }
         // Second pass: now that we can find symbols in modules, we can resolve
         // all imports (if they're correct, that is)
         for module in modules {
             let root = &heap[module.root_id];
             for import_id in &root.imports {
                 let import = &heap[*import_id];
                 match import {
                     Import::Module(import) => {
                         // Find the module using its name
                         let target_root_id = table.resolve_module(&import.module_name);
                         if target_root_id.is_none() {
                             return Err(ParseError2::new_error(&module.source, import.position, "Could not resolve module"));
+                        }
                         let target_root_id = target_root_id.unwrap();
                         if target_root_id == module.root_id {
                             return Err(ParseError2::new_error(&module.source, import.position, "Illegal import of self"));
+                        }
                         // Add the target module under its alias
                         if let Err(previous_position) = table.add_namespace_symbol(
                             module.root_id, import.position,
                             &import.alias, target_root_id
                         ) {
                             return Err(
                                 ParseError2::new_error(&module.source, import.position, "Symbol is multiply defined")
                                     .with_postfixed_info(&module.source, previous_position, "Previous definition was here")
                             );
+                        }
                     },
                     Import::Symbols(import) => {
                         // Find the target module using its name
                         let target_root_id = table.resolve_module(&import.module_name);
                         if target_root_id.is_none() {
                             return Err(ParseError2::new_error(&module.source, import.position, "Could not resolve module of symbol imports"));
+                        }
                         let target_root_id = target_root_id.unwrap();
                         if target_root_id == module.root_id {
                             return Err(ParseError2::new_error(&module.source, import.position, "Illegal import of self"));
+                        }
                         // Determine which symbols to import
                         if import.symbols.is_empty() {
                             // Import of all symbols, not using any aliases
                             for definition_id in &heap[target_root_id].definitions {
                                 let definition = &heap[*definition_id];
                                 let identifier = definition.identifier();
                                 if let Err(previous_position) = table.add_definition_symbol(
                                     module.root_id, import.position, &identifier.value,
                                     target_root_id, *definition_id
                                 ) {
                                     return Err(
                                         ParseError2::new_error(
                                             &module.source, import.position,
                                             &format!("Imported symbol '{}' is already defined", String::from_utf8_lossy(&identifier.value))
+                                        )
                                         .with_postfixed_info(
                                             &modules[target_root_id.0.index as usize].source,
                                             definition.position(),
                                             "The imported symbol is defined here"
+                                        )
                                         .with_postfixed_info(
                                             &module.source, previous_position, "And is previously defined here"
+                                        )
+                                    )
+                                }
+                            }
                         } else {
                             // Import of specific symbols, optionally using aliases
                             for symbol in &import.symbols {
                                 // Because we have already added per-module definitions, we can use
                                 // the table to lookup this particular symbol. Note: within a single
                                 // module a namespace-import and a symbol-import may not collide.
                                 // Hence per-module symbols are unique.
                                 // However: if we import a symbol from another module, we don't want
                                 // to "import a module's imported symbol". And so if we do find
                                 // a symbol match, we need to make sure it is a definition from
                                 // within that module by checking `source_root_id == target_root_id`
                                 let target_symbol = table.resolve_symbol(target_root_id, &symbol.name);
                                 let symbol_definition_id = match target_symbol {
                                     Some(target_symbol) => {
                                         match target_symbol.symbol {
                                             Symbol::Definition((symbol_root_id, symbol_definition_id)) => {
                                                 if symbol_root_id == target_root_id {
                                                     Some(symbol_definition_id)
                                                 } else {
                                                     // This is imported within the target module, and not
                                                     // defined within the target module
                                                     None
+                                                }
                                             },
                                             Symbol::Namespace(_) => {
                                                 // We don't import a module's "module import"
                                                 None
+                                            }
+                                        }
                                     },
                                     None => None
                                 };
                                 if symbol_definition_id.is_none() {
                                     return Err(
                                         ParseError2::new_error(&module.source, symbol.position, "Could not resolve symbol")
+                                    )
+                                }
                                 let symbol_definition_id = symbol_definition_id.unwrap();
                                 if let Err(previous_position) = table.add_definition_symbol(
                                     module.root_id, symbol.position, &symbol.alias,
                                     target_root_id, symbol_definition_id
                                 ) {
                                     return Err(
                                         ParseError2::new_error(&module.source, symbol.position, "Symbol is multiply defined")
                                             .with_postfixed_info(&module.source, previous_position, "Previous definition was here")
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
         debug_assert_eq!(
             table.symbol_lookup.len(), lookup_reserve_size,
             "miscalculated reserved size for symbol lookup table"
         );
         Ok(table)
+    }
     /// Resolves a module by its defined name
     pub(crate) fn resolve_module(&self, identifier: &Vec<u8>) -> Option<RootId> {
         self.module_lookup.get(identifier).map(|v| *v)
+    }
     /// Resolves a symbol within a particular module, indicated by its RootId,
     /// with a single non-namespaced identifier
     pub(crate) fn resolve_symbol(&self, within_module_id: RootId, identifier: &Vec<u8>) -> Option<&SymbolValue> {
         self.symbol_lookup.get(&SymbolKey{ module_id: within_module_id, symbol_name: identifier.clone() })
+    }
     /// Resolves a namespaced symbol. It will try to go as far as possible in
     /// actually finding a definition or a namespace. So a namespace might be
     /// resolved, after it which it finds an actual definition. It may be that
     /// the namespaced identifier has more elements that should be checked
     /// (i.e. an enum variant, or simply an erroneous instance of too many
     /// chained identifiers). This function will return None if nothing could be
     /// resolved at all.
     pub(crate) fn resolve_namespaced_symbol(&self, _within_module_id: RootId) {
         todo!("implement")
     pub(crate) fn resolve_namespaced_symbol<'t, 'i>(
         &'t self, root_module_id: RootId, identifier: &'i NamespacedIdentifier
     ) -> Option<(&SymbolValue, NamespacedIdentifierIter<'i>)> {
         let mut iter = identifier.iter();
         let mut symbol: Option<&SymbolValue> = None;
         let mut within_module_id = root_module_id;
         while let Some(partial) = iter.next() {
             // Lookup the symbol within the currently iterated upon module
             let lookup_key = SymbolKey{ module_id: within_module_id, symbol_name: Vec::from(partial) };
             let new_symbol = self.symbol_lookup.get(&lookup_key);
             match new_symbol {
                 None => {
                     // Can't find anything
                     break;
                 },
                 Some(new_symbol) => {
                     // Found something, but if we already moved to another
                     // module then we don't want to keep jumping across modules,
                     // we're only interested in symbols defined within that
                     // module.
                     match &new_symbol.symbol {
                         Symbol::Namespace(new_root_id) => {
                             if root_module_id != within_module_id {
                                 // Don't jump from module to module, keep the
                                 // old symbol (which must be a Namespace) and
                                 // break
                                 debug_assert!(symbol.is_some());
                                 debug_assert!(symbol.unwrap().is_namespace());
                                 debug_assert!(iter.num_returned() > 1);
                                 // For handling this error, we need to revert
                                 // the iterator by one
                                 let to_skip = iter.num_returned() - 1;
                                 iter = identifier.iter();
                                 for _ in 0..to_skip { iter.next(); }
                                 break;
+                            }
                             within_module_id = *new_root_id;
                             symbol = Some(new_symbol);
                         },
                         Symbol::Definition((definition_root_id, _)) => {
                             // Found a definition, but if we already jumped
                             // modules, then this must be defined within that
                             // module.
                             if root_module_id != within_module_id && within_module_id != *definition_root_id {
                                 // This is an imported definition within the module
                                 // TODO: Maybe factor out? Dunno...
                                 debug_assert!(symbol.is_some());
                                 debug_assert!(symbol.unwrap().is_namespace());
                                 debug_assert!(iter.num_returned() > 1);
                                 let to_skip = iter.num_returned() - 1;
                                 iter = identifier.iter();
                                 for _ in 0..to_skip { iter.next(); }
                                 break;
+                            }
                             symbol = Some(new_symbol);
                             break;
+                        }
+                    }
+                }
+            }
+        }
         match symbol {
             None => None,
             Some(symbol) => Some((symbol, iter))
+        }
+    }
     /// Attempts to add a namespace symbol. Returns `Ok` if the symbol was
     /// inserted. If the symbol already exists then `Err` will be returned
     /// together with the previous definition's source position (in the origin
     /// module's source file).
     // Note: I would love to return a reference to the value, but Rust is
     // preventing me from doing so...
+    // preventing me from doing so... That, or I'm not smart enough...
     fn add_namespace_symbol(
         &mut self, origin_module_id: RootId, origin_position: InputPosition, symbol_name: &Vec<u8>, target_module_id: RootId
     ) -> Result<(), InputPosition> {
         let key = SymbolKey{
             module_id: origin_module_id,
             symbol_name: symbol_name.clone()
         };
         match self.symbol_lookup.entry(key) {
             Entry::Occupied(o) => Err(o.get().position),
             Entry::Vacant(v) => {
                 v.insert(SymbolValue{
                     position: origin_position,
                     symbol: Symbol::Namespace(target_module_id)
                 });
                 Ok(())
+            }
+        }
+    }
     /// Attempts to add a definition symbol. Returns `Ok` if the symbol was
     /// inserted. If the symbol already exists then `Err` will be returned
     /// together with the previous definition's source position (in the origin
     /// module's source file).
     fn add_definition_symbol(
         &mut self, origin_module_id: RootId, origin_position: InputPosition, symbol_name: &Vec<u8>,
         target_module_id: RootId, target_definition_id: DefinitionId,
     ) -> Result<(), InputPosition> {
         let key = SymbolKey{
             module_id: origin_module_id,
             symbol_name: symbol_name.clone()
         };
         match self.symbol_lookup.entry(key) {
             Entry::Occupied(o) => Err(o.get().position),
             Entry::Vacant(v) => {
                 v.insert(SymbolValue {
                     position: origin_position,
                     symbol: Symbol::Definition((target_module_id, target_definition_id))
                 });
                 Ok(())
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

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

0 comments (0 inline, 0 general)