feat: added analyzer for new definition types

Author: raphael-goetz

crates/cli/src/analyser/core.rs

@@ -1,8 +1,12 @@
 use crate::diagnostics::diagnose::Diagnose;
 use crate::diagnostics::kinds::DiagnosticKind;
 use crate::diagnostics::reporter::Reporter;
+use crate::parser::ModuleConfiguration;
 use crate::{analyser::index_identifier::IdentifierIndex, reader::Meta};
-use tucana::shared::{DefinitionDataType, FlowType, RuntimeFunctionDefinition};
+use tucana::shared::{
+    DefinitionDataType, FlowType, FunctionDefinition, ModuleConfigurationDefinition,
+    RuntimeFlowType, RuntimeFunctionDefinition,
+};
 
 #[derive(Clone)]
 pub struct AnalysableDataType {
@@ -25,12 +29,44 @@ pub struct AnalysableFunction {
     pub id: i16,
 }
 
+#[derive(Clone)]
+pub struct AnalysableRuntimeFlowType {
+    pub original_definition: Meta,
+    pub runtime_flow_type: RuntimeFlowType,
+    pub id: i16,
+}
+
+#[derive(Clone)]
+pub struct AnalysableFunctionDefinition {
+    pub original_definition: Meta,
+    pub function_definition: FunctionDefinition,
+    pub id: i16,
+}
+
+#[derive(Clone)]
+pub struct AnalysableModuleConfigurationDefinition {
+    pub original_definition: Meta,
+    pub module_configuration_definition: ModuleConfigurationDefinition,
+    pub id: i16,
+}
+
+#[derive(Clone)]
+pub struct AnalysableModuleDefinition {
+    pub original_definition: Meta,
+    pub module_definition: ModuleConfiguration,
+    pub id: i16,
+}
+
 pub struct Analyser {
     pub reporter: Reporter,
     pub(crate) index: IdentifierIndex,
     pub data_types: Vec<AnalysableDataType>,
     pub flow_types: Vec<AnalysableFlowType>,
     pub functions: Vec<AnalysableFunction>,
+    pub runtime_flow_types: Vec<AnalysableRuntimeFlowType>,
+    pub function_definitions: Vec<AnalysableFunctionDefinition>,
+    pub module_configuration_definitions: Vec<AnalysableModuleConfigurationDefinition>,
+    pub module_definitions: Vec<AnalysableModuleDefinition>,
 }
 
 impl Analyser {
@@ -49,6 +85,18 @@ impl Analyser {
         for f in self.functions.clone() {
             self.analyse_runtime_function(&f);
         }
+        for rft in self.runtime_flow_types.clone() {
+            self.analyse_runtime_flow_type(&rft);
+        }
+        for f in self.function_definitions.clone() {
+            self.analyse_function_definition(&f);
+        }
+        for config in self.module_configuration_definitions.clone() {
+            self.analyse_module_configuration_definition(&config);
+        }
+        for module in self.module_definitions.clone() {
+            self.analyse_module_definition(&module);
+        }
         self.reporter.print(will_exit, true, with_warning);
     }
 

crates/cli/src/analyser/function_definition.rs

@@ -0,0 +1,141 @@
+use crate::analyser::core::{AnalysableFunctionDefinition, Analyser};
+use crate::diagnostics::diagnose::Diagnose;
+use crate::diagnostics::kinds::DiagnosticKind;
+
+impl Analyser {
+    pub fn analyse_function_definition(&mut self, afd: &AnalysableFunctionDefinition) {
+        let name = afd.function_definition.runtime_name.clone();
+        let function = &afd.function_definition;
+        let original = afd.original_definition.clone();
+
+        for linked in function.linked_data_type_identifiers.clone() {
+            if !self.data_type_identifier_exists(linked.as_str(), None) {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedDataTypeIdentifier {
+                        identifier: linked.clone(),
+                    },
+                ));
+            }
+        }
+
+        if function.display_icon.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::NullField {
+                    field_name: "displayIcon".into(),
+                },
+            ))
+        }
+
+        if function.alias.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::MissingTranslation {
+                    translation_field: "alias".into(),
+                },
+            ));
+        }
+
+        if function.display_message.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::MissingTranslation {
+                    translation_field: "displayMessage".into(),
+                },
+            ));
+        }
+
+        if function.name.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::UndefinedTranslation {
+                    translation_field: "name".into(),
+                },
+            ));
+        }
+        if function.description.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::UndefinedTranslation {
+                    translation_field: "description".into(),
+                },
+            ));
+        }
+        if function.documentation.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::UndefinedTranslation {
+                    translation_field: "documentation".into(),
+                },
+            ));
+        }
+
+        if function.signature.is_empty() {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::NullField {
+                    field_name: "signature".into(),
+                },
+            ));
+        }
+
+        let mut param_names: Vec<String> = vec![];
+        for parameter in &function.parameter_definitions {
+            if parameter.name.is_empty() {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedTranslation {
+                        translation_field: "name".into(),
+                    },
+                ));
+            }
+            if parameter.description.is_empty() {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedTranslation {
+                        translation_field: "description".into(),
+                    },
+                ));
+            }
+            if parameter.documentation.is_empty() {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::UndefinedTranslation {
+                        translation_field: "documentation".into(),
+                    },
+                ));
+            }
+
+            if param_names.contains(&parameter.runtime_name) {
+                self.reporter.add(Diagnose::new(
+                    name.clone(),
+                    original.clone(),
+                    DiagnosticKind::DuplicateRuntimeParameterIdentifier {
+                        identifier: parameter.runtime_name.clone(),
+                    },
+                ));
+            }
+            param_names.push(parameter.runtime_name.clone());
+        }
+
+        if self.index.has_function_definition(&name, Some(afd.id)) {
+            self.reporter.add(Diagnose::new(
+                name.clone(),
+                original.clone(),
+                DiagnosticKind::DuplicateFunctionIdentifier { identifier: name },
+            ));
+        }
+    }
+}

crates/cli/src/analyser/index_identifier.rs

@@ -4,7 +4,10 @@ use std::collections::HashMap;
 pub struct IdentifierIndex {
     data_types: HashMap<String, i16>,
     flow_types: HashMap<String, i16>,
+    runtime_flow_types: HashMap<String, i16>,
     functions: HashMap<String, i16>,
+    function_definitions: HashMap<String, i16>,
+    module_configuration_definitions: HashMap<String, i16>,
 }
 
 fn normalize(s: &str) -> String {
@@ -18,9 +21,19 @@ impl IdentifierIndex {
     pub fn insert_flow_type(&mut self, name: &str, id: i16) -> Option<i16> {
         self.flow_types.insert(normalize(name), id)
     }
+    pub fn insert_runtime_flow_type(&mut self, name: &str, id: i16) -> Option<i16> {
+        self.runtime_flow_types.insert(normalize(name), id)
+    }
     pub fn insert_function(&mut self, name: &str, id: i16) -> Option<i16> {
         self.functions.insert(normalize(name), id)
     }
+    pub fn insert_function_definition(&mut self, name: &str, id: i16) -> Option<i16> {
+        self.function_definitions.insert(normalize(name), id)
+    }
+    pub fn insert_module_configuration_definition(&mut self, name: &str, id: i16) -> Option<i16> {
+        self.module_configuration_definitions
+            .insert(normalize(name), id)
+    }
 
     pub fn has_data_type(&self, name: &str, except: Option<i16>) -> bool {
         self.data_types
@@ -35,4 +48,25 @@ impl IdentifierIndex {
             .map(|found| except.map(|e| *found != e).unwrap_or(true))
             .unwrap_or(false)
     }
+
+    pub fn has_runtime_flow_type(&self, name: &str, except: Option<i16>) -> bool {
+        self.runtime_flow_types
+            .get(&normalize(name))
+            .map(|found| except.map(|e| *found != e).unwrap_or(true))
+            .unwrap_or(false)
+    }
+
+    pub fn has_function_definition(&self, name: &str, except: Option<i16>) -> bool {
+        self.function_definitions
+            .get(&normalize(name))
+            .map(|found| except.map(|e| *found != e).unwrap_or(true))
+            .unwrap_or(false)
+    }
+
+    pub fn has_module_configuration_definition(&self, name: &str, except: Option<i16>) -> bool {
+        self.module_configuration_definitions
+            .get(&normalize(name))
+            .map(|found| except.map(|e| *found != e).unwrap_or(true))
+            .unwrap_or(false)
+    }
 }