wip: first working version, lowering / desugaring

Author: volsa

compiler/plc_ast/src/ast.rs

@@ -1242,6 +1242,20 @@ impl AstNode {
         )
     }
 
+    pub fn get_base(&self) -> Option<&AstNode> {
+        match &self.stmt {
+            AstStatement::ReferenceExpr(ReferenceExpr { base: Some(base), .. }) => Some(base.as_ref()),
+            _ => None,
+        }
+    }
+
+    pub fn get_base_mut(&mut self) -> Option<&mut AstNode> {
+        match &mut self.stmt {
+            AstStatement::ReferenceExpr(ReferenceExpr { base: Some(base), .. }) => Some(base.as_mut()),
+            _ => None,
+        }
+    }
+
     pub fn get_initial_base(&self) -> Option<&AstNode> {
         match &self.stmt {
             AstStatement::ReferenceExpr(ReferenceExpr { base, .. }, ..) => {

compiler/plc_driver/src/pipelines.rs

@@ -25,7 +25,8 @@ use plc::{
     index::{indexer, FxIndexSet, Index},
     linker::LinkerType,
     lowering::{
-        calls::AggregateTypeLowerer, property::PropertyLowerer, vtable::VTableGenerator, InitVisitor,
+        calls::AggregateTypeLowerer, polymorphism::PolymorphicCallDesugarer, property::PropertyLowerer,
+        vtable::VTableGenerator, InitVisitor,
     },
     output::FormatOption,
     parser::parse_file,
@@ -260,9 +261,13 @@ impl<T: SourceContainer> BuildPipeline<T> {
         let mut_participants: Vec<Box<dyn PipelineParticipantMut>> = vec![
             Box::new(PropertyLowerer::new(self.context.provider())),
             Box::new(InitParticipant::new(self.project.get_init_symbol_name(), self.context.provider())),
+            // XXX: The PolymorphicCallDesugarer must run before InheritanceLowerer because child classes
+            //      might access the parents __vtable, in which case the inheritance lowerer will patch the
+            //      access to something like __vtable_{parent name}. Ugh :/
+            Box::new(VTableGenerator::new(self.context.provider())),
+            Box::new(PolymorphicCallDesugarer::new(self.context.provider())),
             Box::new(AggregateTypeLowerer::new(self.context.provider())),
             Box::new(InheritanceLowerer::new(self.context.provider())),
-            Box::new(VTableGenerator::new(self.context.provider())),
         ];
 
         for participant in mut_participants {

compiler/plc_driver/src/pipelines/participant.rs

@@ -14,7 +14,9 @@ use std::{
 use ast::provider::IdProvider;
 use plc::{
     codegen::GeneratedModule,
-    lowering::{calls::AggregateTypeLowerer, vtable::VTableGenerator},
+    lowering::{
+        calls::AggregateTypeLowerer, polymorphism::PolymorphicCallDesugarer, vtable::VTableGenerator,
+    },
     output::FormatOption,
     ConfigFormat, OnlineChange, Target,
 };
@@ -294,3 +296,27 @@ impl PipelineParticipantMut for VTableGenerator {
         project.index(self.id_provider.clone())
     }
 }
+
+impl PipelineParticipantMut for PolymorphicCallDesugarer {
+    fn post_annotate(&mut self, annotated_project: AnnotatedProject) -> AnnotatedProject {
+        let AnnotatedProject { units, index, annotations } = annotated_project;
+        self.index = Some(index);
+        self.annotations = Some(annotations.annotation_map);
+
+        let units = units
+            .into_iter()
+            .map(|AnnotatedUnit { mut unit, .. }| {
+                self.desugar_unit(&mut unit);
+                unit
+            })
+            .collect();
+
+        let indexed_project = IndexedProject {
+            project: ParsedProject { units },
+            index: self.index.take().expect("Index"),
+            unresolvables: vec![],
+        };
+
+        indexed_project.annotate(self.ids.clone())
+    }
+}

src/codegen/generators/expression_generator.rs

@@ -232,7 +232,6 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 Ok(ExpressionValue::LValue(this_value))
             }
             AstStatement::ReferenceExpr(data) => {
-                dbg!(&data, &expression);
                 let res =
                     self.generate_reference_expression(&data.access, data.base.as_deref(), expression)?;
                 let val = match res {

src/codegen/tests/function_pointer_tests.rs

@@ -27,21 +27,23 @@ fn function_pointer_method_no_parameters() {
     target datalayout = "[filtered]"
     target triple = "[filtered]"
 
-    %FbA = type {}
+    %FbA = type { i32* }
 
     @__FbA__init = unnamed_addr constant %FbA zeroinitializer
 
     define void @FbA(%FbA* %0) {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
       ret void
     }
 
     define void @FbA__foo(%FbA* %0) {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
       ret void
     }
 
@@ -107,21 +109,23 @@ fn function_pointer_method_with_input_output_inout() {
     target datalayout = "[filtered]"
     target triple = "[filtered]"
 
-    %FbA = type {}
+    %FbA = type { i32* }
 
     @__FbA__init = unnamed_addr constant %FbA zeroinitializer
 
     define void @FbA(%FbA* %0) {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
       ret void
     }
 
     define void @FbA__foo(%FbA* %0, i16 %1, i16* %2, i16* %3) {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
       %in = alloca i16, align 2
       store i16 %1, i16* %in, align 2
       %out = alloca i16*, align 8
@@ -205,21 +209,23 @@ fn function_pointer_method_with_input_output_inout_shifted_position_to_right_by_
     target datalayout = "[filtered]"
     target triple = "[filtered]"
 
-    %FbA = type {}
+    %FbA = type { i32* }
 
     @__FbA__init = unnamed_addr constant %FbA zeroinitializer
 
     define void @FbA(%FbA* %0) {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
       ret void
     }
 
     define void @FbA__foo(%FbA* %0, i16 %1, i16* %2, i16* %3) {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
       %in = alloca i16, align 2
       store i16 %1, i16* %in, align 2
       %out = alloca i16*, align 8
@@ -312,7 +318,7 @@ fn void_pointer_casting() {
     target triple = "[filtered]"
 
     %UserDefinedVirtualTable = type { i32 (%FbA*, i16, i16*, i16*)* }
-    %FbA = type { i32* }
+    %FbA = type { i32*, i32* }
 
     @userDefinedVirtualTableInstance = global %UserDefinedVirtualTable zeroinitializer
     @__UserDefinedVirtualTable__init = unnamed_addr constant %UserDefinedVirtualTable zeroinitializer
@@ -322,7 +328,8 @@ fn void_pointer_casting() {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
-      %vt = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
+      %vt = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 1
       %FbA.foo = alloca i32, align 4
       %in = alloca i16, align 2
       store i16 %1, i16* %in, align 2
@@ -339,7 +346,8 @@ fn void_pointer_casting() {
     entry:
       %this = alloca %FbA*, align 8
       store %FbA* %0, %FbA** %this, align 8
-      %vt = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
+      %__vtable = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 0
+      %vt = getelementptr inbounds %FbA, %FbA* %0, i32 0, i32 1
       ret void
     }
 
@@ -358,7 +366,7 @@ fn void_pointer_casting() {
       store i16 789, i16* %localInOut, align 2
       store %FbA* %instanceFbA, %FbA** %refInstanceFbA, align 8
       %deref = load %FbA*, %FbA** %refInstanceFbA, align 8
-      %vt = getelementptr inbounds %FbA, %FbA* %deref, i32 0, i32 0
+      %vt = getelementptr inbounds %FbA, %FbA* %deref, i32 0, i32 1
       %deref1 = load i32*, i32** %vt, align 8
       %cast = bitcast i32* %deref1 to %UserDefinedVirtualTable*
       %methodPtr = getelementptr inbounds %UserDefinedVirtualTable, %UserDefinedVirtualTable* %cast, i32 0, i32 0

src/index.rs

@@ -1,6 +1,9 @@
 // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder
 
-use std::{collections::VecDeque, hash::BuildHasherDefault};
+use std::{
+    collections::VecDeque,
+    hash::{BuildHasherDefault, Hash},
+};
 
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
@@ -646,7 +649,7 @@ impl From<&Interface> for InterfaceIndexEntry {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Eq)]
 pub enum PouIndexEntry {
     Program {
         name: String,
@@ -2196,6 +2199,47 @@ impl Index {
             current_methods
         }
     }
+
+    /// Returns all methods defined in a container, including methods from super "classes". Thereby the result
+    /// is in fixed traversal order, meaning that the methods of the super class are always positioned before
+    /// the methods of any child class. This ordering is neccessary for virtual tables, where bitcasting them
+    /// from one type to another requires such an order to ensure that the correct method is called.
+    ///
+    /// For example, if class `A` has a method `foo` and class `B` inherits from `A` but adds another method
+    /// `bar` then the virtual table must have the form [`A.foo`] and [`B.foo`, `B.bar`] such that upcasting
+    /// `B` to `A` will still call method `foo` rather than `bar`. If not, e.g. [`B.bar`, `B.foo`] is used,
+    /// the upcasting to `A` would result calling `B.bar` when we have a call such as `reInstance^.foo()`
+    pub fn get_methods_in_fixed_order(&self, container: &str) -> Vec<&PouIndexEntry> {
+        let res = self.get_methods_recursive_in_fixed_order(container, FxIndexMap::default());
+        res.into_values().collect()
+    }
+
+    /// See [`Index::get_methods_in_fixed_order`]
+    fn get_methods_recursive_in_fixed_order<'b>(
+        &'b self,
+        container: &str,
+        mut collected: FxIndexMap<&'b str, &'b PouIndexEntry>,
+    ) -> FxIndexMap<&'b str, &'b PouIndexEntry> {
+        if let Some(pou) = self.find_pou(container) {
+            if let Some(super_class) = pou.get_super_class() {
+                // We want to recursively climb up the inheritance chain before collecting methods
+                collected = self.get_methods_recursive_in_fixed_order(super_class, collected);
+            }
+
+            let methods = self
+                .get_pous()
+                .values()
+                .filter(|pou| pou.is_method())
+                .filter(|pou| pou.get_parent_pou_name().is_some_and(|opt| opt == container));
+
+            for method in methods {
+                let name = method.get_name().split_once('.').unwrap().1;
+                collected.insert(name, method);
+            }
+        }
+
+        collected
+    }
 }
 
 /// Returns a default initialization name for a variable or type

src/index/tests/index_tests.rs

@@ -2207,3 +2207,58 @@ fn pou_with_recursive_type_fails() {
     let pou_type = index.find_pou_type("fb").unwrap();
     assert!(pou_type.get_type_information().get_size(&index).is_err());
 }
+
+#[test]
+fn fixed_order() {
+    let (_, index) = index(
+        r#"
+        FUNCTION_BLOCK A
+            METHOD foo
+            END_METHOD
+
+            METHOD bar
+            END_METHOD
+
+            METHOD baz
+            END_METHOD
+        END_FUNCTION_BLOCK
+
+        FUNCTION_BLOCK B EXTENDS A
+            METHOD foo
+            END_METHOD
+        END_FUNCTION_BLOCK
+
+        FUNCTION_BLOCK C EXTENDS A
+            METHOD foo
+            END_METHOD
+
+            METHOD baz
+            END_METHOD
+        END_FUNCTION_BLOCK
+
+        FUNCTION_BLOCK D EXTENDS B
+            METHOD baz
+            END_METHOD
+
+            METHOD qux
+            END_METHOD
+        END_FUNCTION_BLOCK
+        "#,
+    );
+
+    let methods_a =
+        index.get_methods_in_fixed_order("A").iter().map(|pou| pou.get_name()).collect::<Vec<_>>();
+    assert_eq!(methods_a, vec!["A.foo", "A.bar", "A.baz"]);
+
+    let methods_b =
+        index.get_methods_in_fixed_order("B").iter().map(|pou| pou.get_name()).collect::<Vec<_>>();
+    assert_eq!(methods_b, vec!["B.foo", "A.bar", "A.baz"]);
+
+    let methods_c =
+        index.get_methods_in_fixed_order("C").iter().map(|pou| pou.get_name()).collect::<Vec<_>>();
+    assert_eq!(methods_c, vec!["C.foo", "A.bar", "C.baz"]);
+
+    let methods_d =
+        index.get_methods_in_fixed_order("D").iter().map(|pou| pou.get_name()).collect::<Vec<_>>();
+    assert_eq!(methods_d, vec!["B.foo", "A.bar", "D.baz", "D.qux"]);
+}

src/lowering.rs

@@ -16,6 +16,7 @@ use rustc_hash::FxHashMap;
 
 pub mod calls;
 mod initializers;
+pub mod polymorphism;
 pub mod property;
 pub mod vtable;