CSY/reowolf Changeset - 291ee7a49c03 · Centrum Wiskunde & Informatica (CWI)

Changeset - 291ee7a49c03

Parent rev.

Child rev.

[Not reviewed]

0 8 0

mh - 3 years ago 2022-02-15 14:58:17
contact@maxhenger.nl

Add concept of TypeId for builtin types as well

8 files changed with 133 insertions and 65 deletions:

src/collections/string_pool.rs

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/input_source.rs

src/protocol/mod.rs

src/protocol/parser/mod.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/type_table.rs

0 comments (0 inline, 0 general)

src/collections/string_pool.rs

➞

Show inline comments

@@ @@ -28,13 +28,13 @@ impl<'a> StringRef<'a> { @@
         let data = data.as_ptr();
         StringRef{ data, length, _phantom: PhantomData }
+    }
     /// `new_empty` creates a empty StringRef. It is a null pointer with a
     /// length of zero.
     pub(crate) fn new_empty() -> StringRef<'static> {
+    pub(crate) const fn new_empty() -> StringRef<'static> {
         StringRef{ data: null(), length: 0, _phantom: PhantomData }
+    }
     pub fn as_str(&self) -> &'a str {
         unsafe {
             let slice = std::slice::from_raw_parts::<'a, u8>(self.data, self.length);

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -342,13 +342,13 @@ pub struct ImportSymbols { @@
 pub struct Identifier {
     pub span: InputSpan,
     pub value: StringRef<'static>,
+}
 impl Identifier {
     pub(crate) fn new_empty(span: InputSpan) -> Identifier {
+    pub(crate) const fn new_empty(span: InputSpan) -> Identifier {
         return Identifier{
             span,
             value: StringRef::new_empty(),
         };
+    }
+}
@@ @@ -507,12 +507,13 @@ pub enum ConcreteTypePart { @@
     Character, String,
     // Builtin types with one nested type
     Array,
     Slice,
     Input,
     Output,
     Pointer,
     // Tuple: variable number of nested types, will never be 1
     Tuple(u32),
     // User defined type with any number of nested types
     Instance(DefinitionId, u32),    // instance of data type
     Function(DefinitionId, u32),    // instance of function
     Component(DefinitionId, u32),   // instance of a connector
@@ @@ -525,13 +526,13 @@ impl ConcreteTypePart { @@
         match self {
             Void | Message | Bool |
             UInt8 | UInt16 | UInt32 | UInt64 |
             SInt8 | SInt16 | SInt32 | SInt64 |
             Character | String =>
 ,
             Array | Slice | Input | Output =>
+            Array | Slice | Input | Output | Pointer =>
 ,
             Tuple(num_embedded) => *num_embedded,
             Instance(_, num_embedded) => *num_embedded,
             Function(_, num_embedded) => *num_embedded,
             Component(_, num_embedded) => *num_embedded,
+        }
@@ @@ -632,12 +633,16 @@ impl ConcreteType { @@
             CTP::Output => {
                 target.push_str(KW_TYPE_OUT_PORT_STR);
                 target.push('<');
                 idx = Self::render_type_part_at(parts, heap, idx, target);
                 target.push('>');
             },
             CTP::Pointer => {
                 target.push('*');
                 idx = Self::render_type_part_at(parts, heap, idx, target);
+            }
             CTP::Tuple(num_parts) => {
                 target.push('(');
                 if num_parts != 0 {
                     idx = Self::render_type_part_at(parts, heap, idx, target);
                     for _ in 1..num_parts {
                         target.push(',');

src/protocol/ast_printer.rs

➞

Show inline comments

             return idx;
+        }
         match &t.parts[idx] {
             CTP::Void => target.push_str("void"),
             CTP::Message => target.push_str("msg"),
-            CTP::Bool => target.push_str("bool"),
+            CTP::Bool => target.push_str(KW_TYPE_BOOL_STR),
             CTP::UInt8 => target.push_str(KW_TYPE_UINT8_STR),
             CTP::UInt16 => target.push_str(KW_TYPE_UINT16_STR),
             CTP::UInt32 => target.push_str(KW_TYPE_UINT32_STR),
             CTP::UInt64 => target.push_str(KW_TYPE_UINT64_STR),
             CTP::SInt8 => target.push_str(KW_TYPE_SINT8_STR),
             CTP::SInt16 => target.push_str(KW_TYPE_SINT16_STR),
             CTP::SInt32 => target.push_str(KW_TYPE_SINT32_STR),
             CTP::SInt64 => target.push_str(KW_TYPE_SINT64_STR),
             CTP::Character => target.push_str(KW_TYPE_CHAR_STR),
             CTP::String => target.push_str(KW_TYPE_STRING_STR),
             CTP::Pointer => target.push('*'),
             CTP::Array => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push_str("[]");
             },
             CTP::Slice => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);

src/protocol/input_source.rs

➞

Show inline comments

@@ @@ -21,13 +21,13 @@ pub struct InputSpan { @@
+}
 impl InputSpan {
     // This must only be used if you're sure that the span will not be involved
     // in creating an error message.
     #[inline]
     pub fn new() -> InputSpan {
+    pub const fn new() -> InputSpan {
         InputSpan{ begin: InputPosition{ line: 0, offset: 0 }, end: InputPosition{ line: 0, offset: 0 }}
+    }
     #[inline]
     pub fn from_positions(begin: InputPosition, end: InputPosition) -> Self {
         Self { begin, end }

src/protocol/mod.rs

➞

Show inline comments

@@ @@ -144,13 +144,13 @@ impl ProtocolDescription { @@
+    }
     fn verify_same_type(&self, expected: &ConcreteType, expected_idx: usize, arguments: &ValueGroup, argument: &Value) -> bool {
         use ConcreteTypePart as CTP;
         match &expected.parts[expected_idx] {
             CTP::Void | CTP::Message | CTP::Slice | CTP::Function(_, _) | CTP::Component(_, _) => unreachable!(),
+            CTP::Void | CTP::Message | CTP::Slice | CTP::Pointer | CTP::Function(_, _) | CTP::Component(_, _) => unreachable!(),
             CTP::Bool => if let Value::Bool(_) = argument { true } else { false },
             CTP::UInt8 => if let Value::UInt8(_) = argument { true } else { false },
             CTP::UInt16 => if let Value::UInt16(_) = argument { true } else { false },
             CTP::UInt32 => if let Value::UInt32(_) = argument { true } else { false },
             CTP::UInt64 => if let Value::UInt64(_) = argument { true } else { false },
             CTP::SInt8 => if let Value::SInt8(_) = argument { true } else { false },

src/protocol/parser/mod.rs

➞

Show inline comments

@@ @@ -22,18 +22,19 @@ use pass_imports::PassImport; @@
 use pass_definitions::PassDefinitions;
 use pass_validation_linking::PassValidationLinking;
 use pass_typing::{PassTyping, ResolveQueue};
 use pass_rewriting::PassRewriting;
 use pass_stack_size::PassStackSize;
 use symbol_table::*;
-use type_table::TypeTable;
+use type_table::*;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::ast_printer::ASTWriter;
 use crate::protocol::parser::type_table::PolymorphicVariable;
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ModuleCompilationPhase {
     Tokenized,              // source is tokenized
     SymbolsScanned,         // all definitions are linked to their type class
     ImportsResolved,        // all imports are added to the symbol table
@@ @@ -54,22 +55,56 @@ pub struct Module { @@
     pub root_id: RootId,
     pub name: Option<(PragmaId, StringRef<'static>)>,
     pub version: Option<(PragmaId, i64)>,
     pub phase: ModuleCompilationPhase,
+}
 // TODO: This is kind of wrong. Because when we're producing bytecode we would
 //       like the bytecode itself to not have the notion of the size of a pointer
 //       type. But until I figure out what we do want I'll just set everything
 //       to a 64-bit architecture.
 pub struct TargetArch {
     pub array_size_alignment: (usize, usize),
     pub slice_size_alignment: (usize, usize),
     pub string_size_alignment: (usize, usize),
     pub port_size_alignment: (usize, usize),
     pub pointer_size_alignment: (usize, usize),
     pub void_type_id: TypeId,
     pub message_type_id: TypeId,
     pub bool_type_id: TypeId,
     pub uint8_type_id: TypeId,
     pub uint16_type_id: TypeId,
     pub uint32_type_id: TypeId,
     pub uint64_type_id: TypeId,
     pub sint8_type_id: TypeId,
     pub sint16_type_id: TypeId,
     pub sint32_type_id: TypeId,
     pub sint64_type_id: TypeId,
     pub char_type_id: TypeId,
     pub string_type_id: TypeId,
     pub array_type_id: TypeId,
     pub slice_type_id: TypeId,
     pub input_type_id: TypeId,
     pub output_type_id: TypeId,
     pub pointer_type_id: TypeId,
+}
 impl TargetArch {
     fn new() -> Self {
         return Self{
             void_type_id: TypeId::new_invalid(),
             bool_type_id: TypeId::new_invalid(),
             message_type_id: TypeId::new_invalid(),
             uint8_type_id: TypeId::new_invalid(),
             uint16_type_id: TypeId::new_invalid(),
             uint32_type_id: TypeId::new_invalid(),
             uint64_type_id: TypeId::new_invalid(),
             sint8_type_id: TypeId::new_invalid(),
             sint16_type_id: TypeId::new_invalid(),
             sint32_type_id: TypeId::new_invalid(),
             sint64_type_id: TypeId::new_invalid(),
             char_type_id: TypeId::new_invalid(),
             string_type_id: TypeId::new_invalid(),
             array_type_id: TypeId::new_invalid(),
             slice_type_id: TypeId::new_invalid(),
             input_type_id: TypeId::new_invalid(),
             output_type_id: TypeId::new_invalid(),
             pointer_type_id: TypeId::new_invalid(),
+        }
+    }
+}
 pub struct PassCtx<'a> {
     heap: &'a mut Heap,
     symbols: &'a mut SymbolTable,
     pool: &'a mut StringPool,
@@ @@ -112,23 +147,39 @@ impl Parser { @@
             pass_definitions: PassDefinitions::new(),
             pass_validation: PassValidationLinking::new(),
             pass_typing: PassTyping::new(),
             pass_rewriting: PassRewriting::new(),
             pass_stack_size: PassStackSize::new(),
             write_ast_to: None,
             arch: TargetArch {
                 array_size_alignment: (3*8, 8), // pointer, length, capacity
                 slice_size_alignment: (2*8, 8), // pointer, length
                 string_size_alignment: (3*8, 8), // pointer, length, capacity
                 port_size_alignment: (3*4, 4), // two u32s: connector + port ID
                 pointer_size_alignment: (8, 8),
+            }
             arch: TargetArch::new(),
         };
         parser.symbol_table.insert_scope(None, SymbolScope::Global);
         // Insert builtin types
         // TODO: At some point use correct values for size/alignment
         parser.arch.void_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Void], false, 0, 1);
         parser.arch.message_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Message], false, 24, 8);
         parser.arch.bool_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Bool], false, 1, 1);
         parser.arch.uint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt8], false, 1, 1);
         parser.arch.uint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt16], false, 2, 2);
         parser.arch.uint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt32], false, 4, 4);
         parser.arch.uint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt64], false, 8, 8);
         parser.arch.sint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt8], false, 1, 1);
         parser.arch.sint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt16], false, 2, 2);
         parser.arch.sint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt32], false, 4, 4);
         parser.arch.sint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt64], false, 8, 8);
         parser.arch.char_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Character], false, 4, 4);
         parser.arch.string_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::String], false, 24, 8);
         parser.arch.array_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Array, ConcreteTypePart::Void], true, 24, 8);
         parser.arch.slice_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Slice, ConcreteTypePart::Void], true, 16, 4);
         parser.arch.input_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Input, ConcreteTypePart::Void], true, 8, 8);
         parser.arch.output_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Output, ConcreteTypePart::Void], true, 8, 8);
         parser.arch.pointer_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Pointer, ConcreteTypePart::Void], true, 8, 8);
         // Insert builtin functions
         fn quick_type(variants: &[ParserTypeVariant]) -> ParserType {
             let mut t = ParserType{ elements: Vec::with_capacity(variants.len()), full_span: InputSpan::new() };
             for variant in variants {
                 t.elements.push(ParserTypeElement{ element_span: InputSpan::new(), variant: variant.clone() });
+            }
+            t
@@ @@ -285,16 +336,32 @@ impl Parser { @@
+        }
         Ok(())
+    }
+}
 fn insert_builtin_type(type_table: &mut TypeTable, parts: Vec<ConcreteTypePart>, has_poly_var: bool, size: usize, alignment: usize) -> TypeId {
     const POLY_VARS: [PolymorphicVariable; 1] = [PolymorphicVariable{
         identifier: Identifier::new_empty(InputSpan::new()),
         is_in_use: false,
     }];
     let concrete_type = ConcreteType{ parts };
     let poly_var = if has_poly_var {
         POLY_VARS.as_slice()
     } else {
         &[]
     };
     return type_table.add_builtin_type(concrete_type, poly_var, size, alignment);
+}
 // Note: args and return type need to be a function because we need to know the function ID.
 fn insert_builtin_function<T: Fn(FunctionDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (
     p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T) {
     p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T
 ) {
     let mut poly_vars = Vec::with_capacity(polymorphic.len());
     for poly_var in polymorphic {
         poly_vars.push(Identifier{ span: InputSpan::new(), value: p.string_pool.intern(poly_var.as_bytes()) });
+    }
     let func_ident_ref = p.string_pool.intern(func_name.as_bytes());

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -3780,12 +3780,13 @@ impl PassTyping { @@
                     parser_type.push(ITP::Character)
                 },
                 CTP::Array => parser_type.push(ITP::Array),
                 CTP::Slice => parser_type.push(ITP::Slice),
                 CTP::Input => parser_type.push(ITP::Input),
                 CTP::Output => parser_type.push(ITP::Output),
                 CTP::Pointer => unreachable!("pointer type during concrete to inference type conversion"),
                 CTP::Tuple(num) => parser_type.push(ITP::Tuple(*num)),
                 CTP::Instance(id, num) => parser_type.push(ITP::Instance(*id, *num)),
                 CTP::Function(_, _) => unreachable!("function type during concrete to inference type conversion"),
                 CTP::Component(_, _) => unreachable!("component type during concrete to inference type conversion"),
+            }
+        }

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -137,14 +137,14 @@ impl DefinedTypeVariant { @@
             _ => unreachable!("Cannot convert {} to union variant", self.type_class())
+        }
+    }
+}
 pub struct PolymorphicVariable {
     identifier: Identifier,
     is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
     pub(crate) identifier: Identifier,
     pub(crate) is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
 /// compiler-defined, or a mix of the two. If a user assigns the same enum
 /// value multiple times, we assume the user is an expert and we consider both
@@ @@ -780,12 +780,13 @@ impl TypeTable { @@
     /// Adds a builtin type to the type table. As this is only called by the
     /// compiler during setup we assume it cannot fail.
     // TODO: Finish this train of thought, requires a little bit of design work
     pub(crate) fn add_builtin_type(&mut self, concrete_type: ConcreteType, poly_vars: &[PolymorphicVariable], size: usize, alignment: usize) -> TypeId {
         self.mono_search_key.set(&concrete_type.parts, poly_vars);
         debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));
         debug_assert_ne!(alignment, 0);
         let type_id = TypeId(self.mono_types.len() as i64);
         self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);
         self.mono_types.push(MonoType{
             type_id,
             concrete_type,
             size,
@@ @@ -1791,12 +1792,14 @@ impl TypeTable { @@
         // types only
         debug_assert!(self.type_loops.is_empty());
         debug_assert!(!self.encountered_types.is_empty());
         debug_assert!(self.memory_layout_breadcrumbs.is_empty());
         debug_assert!(self.size_alignment_stack.is_empty());
         let (ptr_size, ptr_align) = self.mono_types[arch.pointer_type_id.0 as usize].get_size_alignment().unwrap();
         // Push the first entry (the type we originally started with when we
         // were detecting type loops)
         let first_entry = &self.encountered_types[0];
         self.memory_layout_breadcrumbs.push(MemoryBreadcrumb{
             type_id: first_entry.type_id,
             next_member: 0,
@@ @@ -1873,13 +1876,12 @@ impl TypeTable { @@
                         // the tag size/alignment.
                         let mut variant_offset = union_type.tag_size;
                         let mut variant_alignment = union_type.tag_size;
                         if variant.lives_on_heap {
                             // Variant lives on heap, so just a pointer
                             let (ptr_size, ptr_align) = arch.pointer_size_alignment;
                             align_offset_to(&mut variant_offset, ptr_align);
                             variant_offset += ptr_size;
                             variant_alignment = variant_alignment.max(ptr_align);
                         } else {
                             // Variant lives on stack, so walk all embedded
@@ @@ -2104,70 +2106,62 @@ impl TypeTable { @@
         search_key: &mut MonoSearchKey, arch: &TargetArch, parts: &[ConcreteTypePart],
         size_alignment_stack_len: usize,
     ) -> MemoryLayoutResult {
         use ConcreteTypePart as CTP;
         debug_assert!(!parts.is_empty());
         let (builtin_size, builtin_alignment) = match parts[0] {
             CTP::Void   => (0, 1),
             CTP::Message => arch.array_size_alignment,
             CTP::Bool   => (1, 1),
             CTP::UInt8  => (1, 1),
             CTP::UInt16 => (2, 2),
             CTP::UInt32 => (4, 4),
             CTP::UInt64 => (8, 8),
             CTP::SInt8  => (1, 1),
             CTP::SInt16 => (2, 2),
             CTP::SInt32 => (4, 4),
             CTP::SInt64 => (8, 8),
             CTP::Character => (4, 4),
             CTP::String => arch.string_size_alignment,
             CTP::Array => arch.array_size_alignment,
             CTP::Slice => arch.array_size_alignment,
             CTP::Input => arch.port_size_alignment,
             CTP::Output => arch.port_size_alignment,
         let type_id = match parts[0] {
             CTP::Void      => arch.void_type_id,
             CTP::Message   => arch.message_type_id,
             CTP::Bool      => arch.bool_type_id,
             CTP::UInt8     => arch.uint8_type_id,
             CTP::UInt16    => arch.uint16_type_id,
             CTP::UInt32    => arch.uint32_type_id,
             CTP::UInt64    => arch.uint64_type_id,
             CTP::SInt8     => arch.sint8_type_id,
             CTP::SInt16    => arch.sint16_type_id,
             CTP::SInt32    => arch.sint32_type_id,
             CTP::SInt64    => arch.sint64_type_id,
             CTP::Character => arch.char_type_id,
             CTP::String    => arch.string_type_id,
             CTP::Array     => arch.array_type_id,
             CTP::Slice     => arch.slice_type_id,
             CTP::Input     => arch.input_type_id,
             CTP::Output    => arch.output_type_id,
             CTP::Pointer   => arch.pointer_type_id,
             CTP::Tuple(_) => {
                 Self::set_search_key_to_tuple(search_key, definition_map, parts);
                 let type_id = mono_type_map.get(&search_key).copied().unwrap();
                 let mono_type = &mono_types[type_id.0 as usize];
                 if let Some((size, alignment)) = mono_type.get_size_alignment() {
                     return MemoryLayoutResult::TypeExists(size, alignment);
                 } else {
                     return MemoryLayoutResult::PushBreadcrumb(MemoryBreadcrumb{
                         type_id,
                         next_member: 0,
                         next_embedded: 0,
                         first_size_alignment_idx: size_alignment_stack_len as u32,
                     })
+                }
                 type_id
             },
             CTP::Instance(definition_id, _) => {
                 // Retrieve entry and the specific monomorph index by applying
                 // the full concrete type.
                 let definition_type = definition_map.get(&definition_id).unwrap();
                 search_key.set(parts, &definition_type.poly_vars);
                 let type_id = mono_type_map.get(&search_key).copied().unwrap();
                 let mono_type = &mono_types[type_id.0 as usize];
                 type_id
             },
             CTP::Function(_, _) | CTP::Component(_, _) => {
                 todo!("storage for 'function pointers'");
+            }
         };
         let mono_type = &mono_types[type_id.0 as usize];
         if let Some((size, alignment)) = mono_type.get_size_alignment() {
             return MemoryLayoutResult::TypeExists(size, alignment);
         } else {
             return MemoryLayoutResult::PushBreadcrumb(MemoryBreadcrumb{
                 type_id,
                 next_member: 0,
                 next_embedded: 0,
                 first_size_alignment_idx: size_alignment_stack_len as u32,
             });
+        }
             },
             CTP::Function(_, _) | CTP::Component(_, _) => {
                 todo!("storage for 'function pointers'");
+            }
         };
         return MemoryLayoutResult::TypeExists(builtin_size, builtin_alignment);
+    }
     /// Returns tag concrete type (always a builtin integer type), the size of
     /// that type in bytes (and implicitly, its alignment)
     fn variant_tag_type_from_values(min_val: i64, max_val: i64) -> (ConcreteType, usize) {
         debug_assert!(min_val <= max_val);

0 comments (0 inline, 0 general)