wip polymorphism - vtables work

Author: ghaith

compiler/plc_diagnostics/src/diagnostics/diagnostics_registry.rs

@@ -129,7 +129,7 @@ lazy_static! {
         E025,   Error,      include_str!("./error_codes/E025.md"), // Missing return type
         E026,   Error,      include_str!("./error_codes/E026.md"),
         E027,   Error,      include_str!("./error_codes/E027.md"),
-        E028,   Error,      include_str!("./error_codes/E028.md"),
+        E028,   Info,       include_str!("./error_codes/E028.md"),
         E029,   Error,      include_str!("./error_codes/E029.md"),
         E030,   Error,      include_str!("./error_codes/E030.md"),
         E031,   Error,      include_str!("./error_codes/E031.md"),

compiler/plc_driver/src/pipelines.rs

@@ -263,7 +263,7 @@ impl<T: SourceContainer> BuildPipeline<T> {
             Box::new(InitParticipant::new(self.project.get_init_symbol_name(), self.context.provider())),
             Box::new(AggregateTypeLowerer::new(self.context.provider())),
             Box::new(InheritanceLowerer::new(self.context.provider())),
-            Box::new(VTableIndexer),
+            Box::new(VTableIndexer::new(self.context.provider())),
         ];
 
         for participant in mut_participants {

compiler/plc_driver/src/pipelines/participant.rs

@@ -11,13 +11,14 @@ use std::{
     sync::{Arc, Mutex, RwLock},
 };
 
-use ast::provider::IdProvider;
+use ast::ast::{DataType, DataTypeDeclaration, UserTypeDeclaration};
+use ast::{ast::Variable, provider::IdProvider};
 use plc::{
     codegen::GeneratedModule,
-    index::{ArgumentType, PouIndexEntry, VariableIndexEntry},
+    index::PouIndexEntry,
     lowering::calls::AggregateTypeLowerer,
     output::FormatOption,
-    typesystem::{DataType, DataTypeInformation, VOID_INTERNAL_NAME, VOID_TYPE},
+    typesystem::{VOID_INTERNAL_NAME, VOID_POINTER_TYPE},
     ConfigFormat, OnlineChange, Target,
 };
 use plc_diagnostics::diagnostics::Diagnostic;
@@ -286,66 +287,62 @@ impl PipelineParticipantMut for AggregateTypeLowerer {
     }
 }
 
-pub struct VTableIndexer;
+pub struct VTableIndexer {
+    id_provider: IdProvider,
+}
 
 impl VTableIndexer {
+    pub fn new(id_provider: IdProvider) -> Self {
+        Self { id_provider }
+    }
+
     fn get_vtable_name(name: &str) -> String {
         format!("__vtable_{name}")
     }
 
-    fn create_vtable(name: &str, methods: Vec<&PouIndexEntry>) -> DataType {
-        let mut members = Vec::new();
-        for (index, method) in methods.iter().enumerate() {
-            let entry = VariableIndexEntry::new(
-                method.get_name(),
-                method.get_name(),
-                VOID_INTERNAL_NAME,
-                ArgumentType::ByRef(plc::index::VariableType::Local),
-                index as u32,
-                SourceLocation::internal(),
-            );
-            members.push(entry);
-        }
-
-        let information = DataTypeInformation::Struct {
-            name: Self::get_vtable_name(name),
-            members,
-            source: plc::typesystem::StructSource::Internal(plc::typesystem::InternalType::VTable),
-        };
-
-        DataType {
-            information,
-            name: Self::get_vtable_name(name),
-            nature: ast::ast::TypeNature::Derived,
-            initial_value: None,
-            location: SourceLocation::internal(),
+    fn create_vtable(
+        name: &str,
+        methods: Vec<&PouIndexEntry>,
+        location: SourceLocation,
+    ) -> UserTypeDeclaration {
+        let mut variables = Vec::new();
+        for method in methods.iter() {
+            let variable = Variable {
+                name: method.get_name().to_string(),
+                data_type_declaration: DataTypeDeclaration::Reference {
+                    referenced_type: VOID_POINTER_TYPE.into(),
+                    location: method.get_location().clone(),
+                },
+                initializer: None,
+                address: None,
+                location: method.get_location().clone(),
+            };
+            variables.push(variable);
         }
+        let data_type = DataType::StructType { name: Some(Self::get_vtable_name(name)), variables };
+        UserTypeDeclaration { data_type, initializer: None, location, scope: Some(name.to_string()) }
     }
 }
 
 impl PipelineParticipantMut for VTableIndexer {
-    fn pre_annotate(&mut self, indexed_project: IndexedProject) -> IndexedProject {
+    fn post_index(&mut self, indexed_project: IndexedProject) -> IndexedProject {
         //For each class or interface, create a vtable type
         //and add it to the index
-        let IndexedProject { project, index, unresolvables } = indexed_project;
+        let IndexedProject { mut project, index, .. } = indexed_project;
         let mut vtables = Vec::new();
         for interface in index.get_interfaces().values() {
             let methods = interface.get_methods(&index);
-            let vtable = Self::create_vtable(interface.get_name(), methods);
+            let vtable = Self::create_vtable(interface.get_name(), methods, interface.get_location().clone());
             vtables.push(vtable);
         }
 
         for pou in index.get_pous().values().filter(|it| it.is_function_block() || it.is_class()) {
             let methods = index.get_methods(pou.get_name());
-            let vtable = Self::create_vtable(pou.get_name(), methods);
+            let vtable = Self::create_vtable(pou.get_name(), methods, pou.get_location().clone());
             vtables.push(vtable);
         }
 
-        let mut index = index;
-        for vtable in vtables {
-            index.register_type(vtable);
-        }
-
-        IndexedProject { project, index, unresolvables }
+        project.units.first_mut().unwrap().user_types.extend(vtables);
+        project.index(self.id_provider.clone())
     }
 }

src/typesystem.rs

@@ -91,6 +91,7 @@ pub const WCHAR_TYPE: &str = "WCHAR";
 pub const VOID_TYPE: &str = "VOID";
 pub const VOID_INTERNAL_NAME: &str = "__VOID";
 pub const __VLA_TYPE: &str = "__VLA";
+pub const VOID_POINTER_TYPE: &str = "VOID_POINTER";
 
 #[cfg(test)]
 mod tests;
@@ -845,6 +846,17 @@ pub fn get_builtin_types() -> Vec<DataType> {
             nature: TypeNature::Any,
             location: SourceLocation::internal(),
         },
+        DataType {
+            name: VOID_POINTER_TYPE.into(),
+            initial_value: None,
+            information: DataTypeInformation::Pointer {
+                name: VOID_POINTER_TYPE.into(),
+                inner_type_name: VOID_INTERNAL_NAME.into(),
+                auto_deref: None,
+            },
+            nature: TypeNature::Any,
+            location: SourceLocation::internal(),
+        },
         DataType {
             name: "__VLA".into(),
             initial_value: None,