wip polymorphism

Author: ghaith

compiler/plc_driver/src/pipelines.rs

@@ -19,7 +19,7 @@ use ast::{
 
 use itertools::Itertools;
 use log::debug;
-use participant::{PipelineParticipant, PipelineParticipantMut};
+use participant::{PipelineParticipant, PipelineParticipantMut, VTableIndexer};
 use plc::{
     codegen::{CodegenContext, GeneratedModule},
     index::{indexer, FxIndexSet, Index},
@@ -263,6 +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),
         ];
 
         for participant in mut_participants {

compiler/plc_driver/src/pipelines/participant.rs

@@ -13,13 +13,17 @@ use std::{
 
 use ast::provider::IdProvider;
 use plc::{
-    codegen::GeneratedModule, lowering::calls::AggregateTypeLowerer, output::FormatOption, ConfigFormat,
-    OnlineChange, Target,
+    codegen::GeneratedModule,
+    index::{ArgumentType, PouIndexEntry, VariableIndexEntry},
+    lowering::calls::AggregateTypeLowerer,
+    output::FormatOption,
+    typesystem::{DataType, DataTypeInformation, VOID_TYPE},
+    ConfigFormat, OnlineChange, Target,
 };
 use plc_diagnostics::diagnostics::Diagnostic;
 use plc_lowering::inheritance::InheritanceLowerer;
 use project::{object::Object, project::LibraryInformation};
-use source_code::SourceContainer;
+use source_code::{source_location::SourceLocation, SourceContainer};
 
 use super::{AnnotatedProject, AnnotatedUnit, GeneratedProject, IndexedProject, ParsedProject};
 
@@ -281,3 +285,67 @@ impl PipelineParticipantMut for AggregateTypeLowerer {
         indexed_project.annotate(self.id_provider.clone())
     }
 }
+
+pub struct VTableIndexer;
+
+impl VTableIndexer {
+
+    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_TYPE,
+                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),
+        };
+        let datatype = DataType {
+            information,
+            name: Self::get_vtable_name(name),
+            nature: ast::ast::TypeNature::Derived,
+            initial_value: None,
+            location: SourceLocation::internal(),
+        };
+        datatype
+    }
+}
+
+impl PipelineParticipantMut for VTableIndexer {
+    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 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);
+            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);
+            vtables.push(vtable);
+        }
+
+        let mut index = index;
+        for vtable in vtables {
+            index.register_type(vtable);
+        }
+        IndexedProject { project, index, unresolvables }
+    }
+}

src/codegen/generators/data_type_generator.rs

@@ -65,17 +65,20 @@ pub fn generate_data_types<'ink>(
     }
 
     for dep in dependencies {
-        if let Dependency::Datatype(name) = dep {
-            if let Some(pou) = index.find_pou(name) {
+            if let Some(pou) = dep.get_pou(index) {
                 if !pou.is_generic() && !pou.is_action() {
-                    pou_types.push((name.as_str(), pou.get_instance_struct_type_or_void(index)));
+                    pou_types.push((dep.get_name(), pou.get_instance_struct_type_or_void(index)));
                 }
-            } else if let Some(datatype) = index.find_type(name) {
+            } else if let Some(datatype) = dep.get_type(index) {
                 if !datatype.get_type_information().is_generic(index) {
-                    types.push((name, datatype))
+                    types.push((dep.get_name(), datatype))
+                }
+            }
+            if let Some(datatype) = dep.get_vtable(index) {
+                if !datatype.get_type_information().is_generic(index) {
+                    types.push((dep.get_name(), datatype))
                 }
             }
-        }
     }
 
     let mut generator =

src/resolver.rs

@@ -797,6 +797,25 @@ impl Dependency {
             Dependency::Datatype(name) | Dependency::Call(name) | Dependency::Variable(name) => name,
         }
     }
+
+    pub fn get_pou<'idx>(&self, index: &'idx Index) -> Option<&'idx PouIndexEntry> {
+        let Dependency::Datatype(name) = self else {
+            return None;
+        };
+        index.find_pou(name)
+    }
+    pub fn get_type<'idx>(&self, index: &'idx Index) -> Option<&'idx typesystem::DataType> {
+        let Dependency::Datatype(name) = self else {
+            return None;
+        };
+        index.find_type(name)
+    }
+    pub fn get_vtable<'idx>(&self, index: &'idx Index) -> Option<&'idx typesystem::DataType> {
+        let Dependency::Datatype(name) = self else {
+            return None;
+        };
+        index.find_type(&format!("__vtable_{name}"))
+    }
 }
 
 pub trait AnnotationMap {

src/typesystem.rs

@@ -378,6 +378,7 @@ impl StructSource {
 pub enum InternalType {
     VariableLengthArray { inner_type_name: String, ndims: usize },
     __VLA, // used for error-reporting only
+    VTable,
 }
 
 type TypeId = String;