Issue 375 add support for any type

Cargo.toml

@@ -2,7 +2,7 @@
 name = "rusty"
 version = "0.2.0"
 authors = ["Ghaith Hachem <[email protected]>", "Mathias Rieder <[email protected]>"]
-edition = "2018"
+edition = "2021"
 readme = "README.md"
 repository = "https://github.com/ghaith/rusty/"
 license = "LGPL-3.0-or-later"

src/ast.rs

@@ -10,6 +10,12 @@ mod pre_processor;
 
 pub type AstId = usize;
 
+#[derive(Clone, Debug, PartialEq)]
+pub struct GenericBinding {
+    pub name: String,
+    pub nature: TypeNature,
+}
+
 #[derive(PartialEq)]
 pub struct Pou {
     pub name: String,
@@ -18,6 +24,7 @@ pub struct Pou {
     pub return_type: Option<DataTypeDeclaration>,
     pub location: SourceRange,
     pub poly_mode: Option<PolymorphismMode>,
+    pub generics: Vec<GenericBinding>,
 }
 
 #[derive(Debug, PartialEq)]
@@ -35,6 +42,95 @@ pub enum DirectAccessType {
     DWord,
 }
 
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum TypeNature {
+    Any,
+    Derived,
+    Elementary,
+    Magnitude,
+    Num,
+    Real,
+    Int,
+    Signed,
+    Unsigned,
+    Duration,
+    Bit,
+    Chars,
+    String,
+    Char,
+    Date,
+}
+
+impl TypeNature {
+    pub fn derives(self, other: TypeNature) -> bool {
+        if other == self {
+            true
+        } else {
+            match self {
+                TypeNature::Any => true,
+                TypeNature::Derived => matches!(other, TypeNature::Any),
+                TypeNature::Elementary => matches!(other, TypeNature::Any),
+                TypeNature::Magnitude => matches!(other, TypeNature::Elementary | TypeNature::Any),
+                TypeNature::Num => matches!(
+                    other,
+                    TypeNature::Magnitude | TypeNature::Elementary | TypeNature::Any
+                ),
+                TypeNature::Real => matches!(
+                    other,
+                    TypeNature::Num
+                        | TypeNature::Magnitude
+                        | TypeNature::Elementary
+                        | TypeNature::Any
+                ),
+                TypeNature::Int => matches!(
+                    other,
+                    TypeNature::Num
+                        | TypeNature::Magnitude
+                        | TypeNature::Elementary
+                        | TypeNature::Any
+                ),
+                TypeNature::Signed => matches!(
+                    other,
+                    TypeNature::Int
+                        | TypeNature::Num
+                        | TypeNature::Magnitude
+                        | TypeNature::Elementary
+                        | TypeNature::Any
+                ),
+                TypeNature::Unsigned => matches!(
+                    other,
+                    TypeNature::Int
+                        | TypeNature::Num
+                        | TypeNature::Magnitude
+                        | TypeNature::Elementary
+                        | TypeNature::Any
+                ),
+                TypeNature::Duration => matches!(
+                    other,
+                    TypeNature::Num
+                        | TypeNature::Magnitude
+                        | TypeNature::Elementary
+                        | TypeNature::Any
+                ),
+                TypeNature::Bit => matches!(
+                    other,
+                    TypeNature::Magnitude | TypeNature::Elementary | TypeNature::Any
+                ),
+                TypeNature::Chars => matches!(other, TypeNature::Elementary | TypeNature::Any),
+                TypeNature::String => matches!(
+                    other,
+                    TypeNature::Chars | TypeNature::Elementary | TypeNature::Any
+                ),
+                TypeNature::Char => matches!(
+                    other,
+                    TypeNature::Chars | TypeNature::Elementary | TypeNature::Any
+                ),
+                TypeNature::Date => matches!(other, TypeNature::Elementary | TypeNature::Any),
+            }
+        }
+    }
+}
+
 impl DirectAccessType {
     /// Returns true if the current index is in the range for the given type
     pub fn is_in_range(&self, index: u64, data_type: &DataTypeInformation) -> bool {
@@ -64,12 +160,15 @@ impl DirectAccessType {
 
 impl Debug for Pou {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        f.debug_struct("POU")
-            .field("name", &self.name)
+        let mut str = f.debug_struct("POU");
+        str.field("name", &self.name)
             .field("variable_blocks", &self.variable_blocks)
             .field("pou_type", &self.pou_type)
-            .field("return_type", &self.return_type)
-            .finish()
+            .field("return_type", &self.return_type);
+        if !self.generics.is_empty() {
+            str.field("generics", &self.generics);
+        }
+        str.finish()
     }
 }
 
@@ -335,7 +434,7 @@ impl Debug for UserTypeDeclaration {
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum DataType {
     StructType {
         name: Option<String>, //maybe None for inline structs
@@ -367,88 +466,36 @@ pub enum DataType {
     VarArgs {
         referenced_type: Option<Box<DataTypeDeclaration>>,
     },
-}
-
-impl Debug for DataType {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        match self {
-            DataType::StructType { name, variables } => f
-                .debug_struct("StructType")
-                .field("name", name)
-                .field("variables", variables)
-                .finish(),
-            DataType::EnumType { name, elements } => f
-                .debug_struct("EnumType")
-                .field("name", name)
-                .field("elements", elements)
-                .finish(),
-            DataType::SubRangeType {
-                name,
-                referenced_type,
-                bounds,
-            } => f
-                .debug_struct("SubRangeType")
-                .field("name", name)
-                .field("referenced_type", referenced_type)
-                .field("bounds", bounds)
-                .finish(),
-            DataType::ArrayType {
-                name,
-                bounds,
-                referenced_type,
-            } => f
-                .debug_struct("ArrayType")
-                .field("name", name)
-                .field("bounds", bounds)
-                .field("referenced_type", referenced_type)
-                .finish(),
-            DataType::PointerType {
-                name,
-                referenced_type,
-            } => f
-                .debug_struct("PointerType")
-                .field("name", name)
-                .field("referenced_type", referenced_type)
-                .finish(),
-            DataType::StringType {
-                name,
-                is_wide,
-                size,
-            } => f
-                .debug_struct("StringType")
-                .field("name", name)
-                .field("is_wide", is_wide)
-                .field("size", size)
-                .finish(),
-            DataType::VarArgs { referenced_type } => f
-                .debug_struct("VarArgs")
-                .field("referenced_type", referenced_type)
-                .finish(),
-        }
-    }
+    GenericType {
+        name: String,
+        generic_symbol: String,
+        nature: TypeNature,
+    },
 }
 
 impl DataType {
     pub fn set_name(&mut self, new_name: String) {
         match self {
-            DataType::StructType { name, variables: _ } => *name = Some(new_name),
-            DataType::EnumType { name, elements: _ } => *name = Some(new_name),
-            DataType::SubRangeType { name, .. } => *name = Some(new_name),
-            DataType::ArrayType { name, .. } => *name = Some(new_name),
-            DataType::PointerType { name, .. } => *name = Some(new_name),
-            DataType::StringType { name, .. } => *name = Some(new_name),
+            DataType::StructType { name, .. }
+            | DataType::EnumType { name, .. }
+            | DataType::SubRangeType { name, .. }
+            | DataType::ArrayType { name, .. }
+            | DataType::PointerType { name, .. }
+            | DataType::StringType { name, .. } => *name = Some(new_name),
+            DataType::GenericType { name, .. } => *name = new_name,
             DataType::VarArgs { .. } => {} //No names on varargs
         }
     }
 
     pub fn get_name(&self) -> Option<&str> {
-        match self {
-            DataType::StructType { name, variables: _ } => name.as_ref().map(|x| x.as_str()),
-            DataType::EnumType { name, elements: _ } => name.as_ref().map(|x| x.as_str()),
-            DataType::ArrayType { name, .. } => name.as_ref().map(|x| x.as_str()),
-            DataType::PointerType { name, .. } => name.as_ref().map(|x| x.as_str()),
-            DataType::StringType { name, .. } => name.as_ref().map(|x| x.as_str()),
-            DataType::SubRangeType { name, .. } => name.as_ref().map(|x| x.as_str()),
+        match &self {
+            DataType::StructType { name, .. }
+            | DataType::EnumType { name, .. }
+            | DataType::ArrayType { name, .. }
+            | DataType::PointerType { name, .. }
+            | DataType::StringType { name, .. }
+            | DataType::SubRangeType { name, .. } => name.as_ref().map(|x| x.as_str()),
+            DataType::GenericType { name, .. } => Some(name.as_str()),
             DataType::VarArgs { .. } => None,
         }
     }

src/ast/pre_processor.rs

@@ -1,14 +1,48 @@
 // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder
 
+use crate::ast::DataTypeDeclaration;
+
 use super::{
-    super::ast::{CompilationUnit, DataType, DataTypeDeclaration, UserTypeDeclaration, Variable},
+    super::ast::{CompilationUnit, DataType, UserTypeDeclaration, Variable},
     Pou, SourceRange,
 };
-use std::vec;
+use std::{collections::HashMap, vec};
 
 pub fn pre_process(unit: &mut CompilationUnit) {
     //process all local variables from POUs
     for mut pou in unit.units.iter_mut() {
+        //Find all generic types in that pou
+        let mut generic_types = HashMap::new();
+        for binding in &pou.generics {
+            let new_name = format!("__{}__{}", pou.name, binding.name);
+            //Generate a type for the generic
+            let data_type = UserTypeDeclaration {
+                data_type: DataType::GenericType {
+                    name: new_name.clone(),
+                    generic_symbol: binding.name.clone(),
+                    nature: binding.nature,
+                },
+                initializer: None,
+                scope: Some(pou.name.clone()),
+                location: pou.location.clone(),
+            };
+            unit.types.push(data_type);
+            generic_types.insert(binding.name.clone(), new_name);
+        }
+        //Find all variables that reference a generic type
+        //Replace the reference with the generic type's name
+        for var in pou
+            .variable_blocks
+            .iter_mut()
+            .flat_map(|it| it.variables.iter_mut())
+        {
+            replace_generic_type_name(&mut var.data_type, &generic_types);
+        }
+        //Replace the return type's reference if needed
+        if let Some(datatype) = pou.return_type.as_mut() {
+            replace_generic_type_name(datatype, &generic_types);
+        }
+
         let all_variables = pou
             .variable_blocks
             .iter_mut()
@@ -39,7 +73,9 @@ pub fn pre_process(unit: &mut CompilationUnit) {
     for dt in unit.types.iter_mut() {
         {
             match &mut dt.data_type {
-                DataType::StructType { name, variables } => {
+                DataType::StructType {
+                    name, variables, ..
+                } => {
                     let name: &str = name.as_ref().map(|it| it.as_str()).unwrap_or("undefined");
                     variables
                         .iter_mut()
@@ -185,3 +221,24 @@ fn add_nested_datatypes(
         });
     }
 }
+
+fn replace_generic_type_name(dt: &mut DataTypeDeclaration, generics: &HashMap<String, String>) {
+    match dt {
+        DataTypeDeclaration::DataTypeDefinition { data_type, .. } => match data_type {
+            DataType::ArrayType {
+                referenced_type, ..
+            }
+            | DataType::PointerType {
+                referenced_type, ..
+            } => replace_generic_type_name(referenced_type.as_mut(), generics),
+            _ => {}
+        },
+        DataTypeDeclaration::DataTypeReference {
+            referenced_type, ..
+        } => {
+            if let Some(type_name) = generics.get(referenced_type) {
+                *referenced_type = type_name.clone();
+            }
+        }
+    }
+}

src/codegen.rs

@@ -89,7 +89,11 @@ impl<'ink> CodeGen<'ink> {
         //Generate the POU stubs in the first go to make sure they can be referenced.
         for implementation in &unit.implementations {
             //Don't generate external functions
-            if implementation.linkage != LinkageType::External {
+            if implementation.linkage != LinkageType::External
+                && !global_index
+                    .get_type_information_or_void(&implementation.type_name)
+                    .is_generic()
+            {
                 pou_generator.generate_implementation(implementation)?;
             }
         }