POC: Polymorphism

.vscode/launch.json

@@ -4,6 +4,14 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "ST Debug oo test",
+            "program": "${workspaceFolder}/examples/oo_test",
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
         {
             "type": "lldb",
             "request": "launch",
@@ -20,7 +28,8 @@
                 }
             },
             "args": [
-                "target/demo.st"
+                "examples/oo_test.st",
+                "-g"
             ],
             "cwd": "${workspaceFolder}"
         },

compiler/plc_ast/src/ast.rs

@@ -37,6 +37,7 @@ pub struct Pou {
     pub poly_mode: Option<PolymorphismMode>,
     pub generics: Vec<GenericBinding>,
     pub linkage: LinkageType,
+    pub super_class: Option<String>,
 }
 
 #[derive(Debug, PartialEq, Eq)]

examples/oo_test.st

@@ -0,0 +1,34 @@
+    CLASS MyClass
+    VAR
+        x : DINT;
+        y : DINT;
+    END_VAR
+    END_CLASS
+
+    PROGRAM MyProg
+    VAR_IN_OUT
+        cls : MyClass;
+    END_VAR
+    VAR_OUTPUT
+        x : DINT;
+        y : DINT;
+    END_VAR
+    x := cls.x;
+    cls.y := y;
+    END_PROGRAM
+
+    FUNCTION main : DINT
+    VAR_TEMP
+        cls : MyClass;
+    END_VAR
+    VAR
+        x : DINT;
+        y : DINT;
+    END_VAR
+    cls.x := 2;
+    MyProg.y := 3;
+    MyProg(cls);
+    x := MyProg.x;
+    y := cls.y;
+    main := x + y;
+    END_FUNCTION

src/codegen/generators/data_type_generator.rs

@@ -13,6 +13,7 @@ use crate::{
     typesystem::DataType,
 };
 use indexmap::IndexSet;
+use inkwell::types::{AnyType, AnyTypeEnum};
 use inkwell::{
     types::{BasicType, BasicTypeEnum},
     values::{BasicValue, BasicValueEnum},
@@ -177,7 +178,20 @@ impl<'ink, 'b> DataTypeGenerator<'ink, 'b> {
             let members = members
                 .iter()
                 .filter(|it| !it.is_temp() && !it.is_return())
-                .map(|m| self.types_index.get_associated_type(m.get_type_name()))
+                .map(|m| {
+                    //Generate fat pointer if needed
+                    let type_name = self
+                        .index
+                        .find_effective_type_by_name(m.get_type_name())
+                        .and_then(|it| it.get_type_information().get_inner_pointer_type())
+                        .map(|it| format!("__fat_pointer_to_{}", it))
+                        .filter(|it| {
+                            m.get_declaration_type().is_by_ref() && self.index.find_type(it).is_some()
+                        })
+                        .unwrap_or_else(|| m.get_type_name().to_string());
+
+                    self.types_index.get_associated_type(&type_name)
+                })
                 .collect::<Result<Vec<BasicTypeEnum>, Diagnostic>>()?;
 
             let struct_type = match source {
@@ -215,9 +229,16 @@ impl<'ink, 'b> DataTypeGenerator<'ink, 'b> {
                 if dimensions.iter().any(|dimension| dimension.is_undetermined()) {
                     self.create_type(inner_type_name, self.index.get_type(inner_type_name)?)
                 } else {
-                    self.index
-                        .get_effective_type_by_name(inner_type_name)
-                        .and_then(|inner_type| self.create_type(inner_type_name, inner_type))
+                    let inner_type = if inner_type_name == "__FUNCTION_POINTER__" {
+                        Ok(self.llvm.context.i32_type().fn_type(&[], false).as_any_type_enum())
+                    } else {
+                        self.index
+                            .get_effective_type_by_name(inner_type_name)
+                            .and_then(|inner_type| self.create_type(inner_type_name, inner_type))
+                            .map(|inner_type| inner_type.as_any_type_enum())
+                    };
+
+                    inner_type
                         .and_then(|inner_type| self.create_nested_array_type(inner_type, dimensions))
                         .map(|it| it.as_basic_type_enum())
                 }
@@ -422,7 +443,7 @@ impl<'ink, 'b> DataTypeGenerator<'ink, 'b> {
     /// `arr: ARRAY[0..3] OF INT`.
     fn create_nested_array_type(
         &self,
-        inner_type: BasicTypeEnum<'ink>,
+        inner_type: AnyTypeEnum<'ink>,
         dimensions: &[Dimension],
     ) -> Result<BasicTypeEnum<'ink>, Diagnostic> {
         let len = dimensions
@@ -438,12 +459,14 @@ impl<'ink, 'b> DataTypeGenerator<'ink, 'b> {
             .ok_or_else(|| Diagnostic::codegen_error("Invalid array dimensions", SourceRange::undefined()))?;
 
         let result = match inner_type {
-            BasicTypeEnum::IntType(ty) => ty.array_type(len),
-            BasicTypeEnum::FloatType(ty) => ty.array_type(len),
-            BasicTypeEnum::StructType(ty) => ty.array_type(len),
-            BasicTypeEnum::ArrayType(ty) => ty.array_type(len),
-            BasicTypeEnum::PointerType(ty) => ty.array_type(len),
-            BasicTypeEnum::VectorType(ty) => ty.array_type(len),
+            AnyTypeEnum::IntType(ty) => ty.array_type(len),
+            AnyTypeEnum::FloatType(ty) => ty.array_type(len),
+            AnyTypeEnum::StructType(ty) => ty.array_type(len),
+            AnyTypeEnum::ArrayType(ty) => ty.array_type(len),
+            AnyTypeEnum::PointerType(ty) => ty.array_type(len),
+            AnyTypeEnum::VectorType(ty) => ty.array_type(len),
+            AnyTypeEnum::FunctionType(ty)  => ty.ptr_type(AddressSpace::default()).array_type(len),
+            AnyTypeEnum::VoidType(_) => unimplemented!()
         }
         .as_basic_type_enum();