feat: add a vtable type for every function block and interface

A new type is added for every function block, class or interface
this represents a vtable with the methods declared in the class.
If a class extends another class, the parent's class is also included.
If a class extends an interface, the interface is also included.

Author: ghaith

compiler/plc_driver/src/pipelines.rs

@@ -24,17 +24,15 @@ use plc::{
     codegen::{CodegenContext, GeneratedModule},
     index::{indexer, FxIndexSet, Index},
     linker::LinkerType,
-    lowering::{
-        property::PropertyLowerer,
-        {calls::AggregateTypeLowerer, InitVisitor},
-    },
+    lowering::{calls::AggregateTypeLowerer, property::PropertyLowerer, InitVisitor},
     output::FormatOption,
     parser::parse_file,
     resolver::{
         const_evaluator::UnresolvableConstant, AnnotationMapImpl, AstAnnotations, Dependency, StringLiterals,
         TypeAnnotator,
     },
     validation::Validator,
+    vtable::VTableIndexer,
     ConfigFormat, ErrorFormat, OnlineChange, Target, Threads,
 };
 use plc_diagnostics::{
@@ -263,6 +261,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::new(self.context.provider())),
         ];
 
         for participant in mut_participants {

compiler/plc_driver/src/pipelines/participant.rs

@@ -13,8 +13,8 @@ use std::{
 
 use ast::provider::IdProvider;
 use plc::{
-    codegen::GeneratedModule, lowering::calls::AggregateTypeLowerer, output::FormatOption, ConfigFormat,
-    OnlineChange, Target,
+    codegen::GeneratedModule, lowering::calls::AggregateTypeLowerer, output::FormatOption,
+    vtable::VTableIndexer, ConfigFormat, OnlineChange, Target,
 };
 use plc_diagnostics::diagnostics::Diagnostic;
 use plc_lowering::inheritance::InheritanceLowerer;
@@ -281,3 +281,24 @@ impl PipelineParticipantMut for AggregateTypeLowerer {
         indexed_project.annotate(self.id_provider.clone())
     }
 }
+
+impl PipelineParticipantMut for VTableIndexer {
+    // TODO: Don't track overridden methods in vtable, as they're part of the parent instance (same for interfaces)
+    fn post_index(&mut self, indexed_project: IndexedProject) -> IndexedProject {
+        let IndexedProject { mut project, index, .. } = indexed_project;
+
+        let vtables_pou = VTableIndexer::create_vtables_for_pous(&index);
+        let vtables_intf = VTableIndexer::create_vtables_for_interfaces(&index);
+        let (internal, external) = VTableIndexer::create_global_variables_for_vtable(&index);
+
+        //FIXME: should we create the vtable in the unit of its pou?
+        if let Some(unit) = project.units.first_mut() {
+            unit.user_types.extend(vtables_pou);
+            unit.user_types.extend(vtables_intf);
+            unit.global_vars.push(internal);
+            unit.global_vars.push(external);
+        }
+
+        project.index(self.id_provider.clone())
+    }
+}

compiler/plc_source/src/source_location.rs

@@ -289,6 +289,15 @@ impl SourceLocation {
         let SourceLocation { span, file } = self;
         SourceLocation { span, file: FileMarker::Internal(file.get_name().unwrap_or_default()) }
     }
+
+    pub fn into_internal_with_file(self) -> Self {
+        let SourceLocation { file, .. } = self;
+        SourceLocation {
+            span: CodeSpan::None,
+            file: FileMarker::Internal(file.get_name().unwrap_or_default()),
+        }
+    }
+
     /// Constructs an undefined SourceRange with a 0..0 range and no filename
     pub fn undefined() -> SourceLocation {
         SourceLocation { span: CodeSpan::None, file: FileMarker::default() }

src/codegen/debug.rs

@@ -20,7 +20,9 @@ use plc_source::source_location::SourceLocation;
 
 use crate::{
     index::{Index, PouIndexEntry, VariableIndexEntry},
-    typesystem::{DataType, DataTypeInformation, Dimension, StringEncoding, CHAR_TYPE, WCHAR_TYPE},
+    typesystem::{
+        DataType, DataTypeInformation, Dimension, StringEncoding, CHAR_TYPE, VOID_INTERNAL_NAME, WCHAR_TYPE,
+    },
     DebugLevel, OptimizationLevel,
 };
 
@@ -455,7 +457,21 @@ impl<'ink> DebugBuilder<'ink> {
         types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
         let inner_type = index.get_type(inner_type)?;
-        let inner_type = self.get_or_create_debug_type(inner_type, index, types_index)?;
+        //Skip void pointers debug info
+        let inner_type = if inner_type.is_void() {
+            DebugType::Basic(
+                self.debug_info
+                    .create_basic_type(
+                        VOID_INTERNAL_NAME,
+                        0,
+                        DebugEncoding::DW_ATE_unsigned as u32,
+                        DIFlagsConstants::PUBLIC,
+                    )
+                    .map_err(|err| Diagnostic::codegen_error(err, SourceLocation::undefined()))?,
+            )
+        } else {
+            self.get_or_create_debug_type(inner_type, index, types_index)?
+        };
         let llvm_type = types_index.get_associated_type(name)?;
         let align_bits = self.target_data.get_preferred_alignment(&llvm_type) * 8;
         let pointer_type = self.debug_info.create_pointer_type(

src/codegen/tests/oop_tests.rs

@@ -2,6 +2,7 @@ use test_utils::codegen;
 
 mod debug_tests;
 mod super_tests;
+mod vtable_tests;
 
 #[test]
 fn members_from_base_class_are_available_in_subclasses() {