refactor: Simplify pre_linter types

Merged `FunctionMap` and `SubMap` into one type `SignatureMap`.

Merged `FunctionSignature` and `SubSignature` into one type `Signature`.

Merged `FunctionContext` and `SubContext` into one type `SubprogramContext`.

Improved documentation.

Author: ngeor

rusty_linter/src/converter/common/context.rs

@@ -1,6 +1,4 @@
-use crate::core::TypeResolver;
-use crate::core::TypeResolverImpl;
-use crate::core::{FunctionMap, HasFunctions, HasSubs, HasUserDefinedTypes, SubMap};
+use crate::core::*;
 use crate::names::Names;
 use crate::pre_linter::PreLinterResult;
 use rusty_parser::*;
@@ -19,13 +17,13 @@ impl TypeResolver for Context {
 }
 
 impl HasFunctions for Context {
-    fn functions(&self) -> &FunctionMap {
+    fn functions(&self) -> &SignatureMap {
         self.pre_linter_result.functions()
     }
 }
 
 impl HasSubs for Context {
-    fn subs(&self) -> &SubMap {
+    fn subs(&self) -> &SignatureMap {
         self.pre_linter_result.subs()
     }
 }
@@ -58,6 +56,6 @@ impl Context {
     pub fn function_qualifier(&self, bare_name: &BareName) -> Option<TypeQualifier> {
         self.functions()
             .get(bare_name)
-            .map(|function_signature_pos| function_signature_pos.element.qualifier())
+            .and_then(|function_signature_pos| function_signature_pos.element.qualifier())
     }
 }

rusty_linter/src/core/traits.rs

@@ -1,14 +1,14 @@
-use crate::core::{FunctionMap, ResolvedParamType, SubMap};
+use crate::core::{ResolvedParamType, SignatureMap};
 use rusty_parser::{
     Expression, ExpressionPos, ExpressionType, HasExpressionType, TypeQualifier, UserDefinedTypes,
 };
 
 pub trait HasFunctions {
-    fn functions(&self) -> &FunctionMap;
+    fn functions(&self) -> &SignatureMap;
 }
 
 pub trait HasSubs {
-    fn subs(&self) -> &SubMap;
+    fn subs(&self) -> &SignatureMap;
 }
 
 pub trait HasUserDefinedTypes {

rusty_linter/src/core/types.rs

@@ -1,10 +1,7 @@
-use crate::pre_linter::{FunctionSignature, SubSignature};
-use rusty_common::Positioned;
-use rusty_parser::{BareName, BuiltInStyle, QualifiedName, TypeQualifier};
 use std::collections::HashMap;
 
-pub type SubMap = HashMap<BareName, Positioned<SubSignature>>;
-pub type FunctionMap = HashMap<BareName, Positioned<FunctionSignature>>;
+use rusty_common::Positioned;
+use rusty_parser::{BareName, BuiltInStyle, QualifiedName, TypeQualifier};
 
 /// Holds the resolved name of a subprogram.
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
@@ -23,9 +20,73 @@ pub enum NameContext {
     Function,
 }
 
-#[derive(Eq, PartialEq)]
+/// A resolved parameter type.
+#[derive(PartialEq)]
 pub enum ResolvedParamType {
+    /// A built-in type.
+    /// The type qualifier indicates the type.
+    /// The style indicates how the parameter was declared:
+    /// Compact: e.g. `A$` or Extended e.g. `A AS STRING`
     BuiltIn(TypeQualifier, BuiltInStyle),
+
+    /// A user defined type.
     UserDefined(BareName),
+
+    /// An array type.
+    /// Dimensions are not allowed for parameter types.
     Array(Box<Self>),
 }
+
+/// A collection of resolved parameter types.
+pub type ResolvedParamTypes = Vec<ResolvedParamType>;
+
+/// The signature of a FUNCTION or SUB.
+/// Consists of the resolved parameter types and, in case of a FUNCTION, the return type.
+#[derive(PartialEq)]
+pub struct Signature {
+    /// The return type of a FUNCTION, or None if this is the signature of a SUB.
+    q: Option<TypeQualifier>,
+
+    /// The resolved parameter types.
+    param_types: ResolvedParamTypes,
+}
+
+impl Signature {
+    pub fn new_sub(param_types: ResolvedParamTypes) -> Self {
+        Self {
+            q: None,
+            param_types,
+        }
+    }
+
+    pub fn new_function(q: TypeQualifier, param_types: ResolvedParamTypes) -> Self {
+        Self {
+            q: Some(q),
+            param_types,
+        }
+    }
+
+    pub fn qualifier(&self) -> Option<TypeQualifier> {
+        self.q.as_ref().copied()
+    }
+
+    pub fn param_types(&self) -> &ResolvedParamTypes {
+        &self.param_types
+    }
+}
+
+// Equality between a Signature and a TypeQualifier.
+// Equality is done against the return type of the Signature,
+// which always fails for a SUB.
+
+impl PartialEq<TypeQualifier> for Signature {
+    fn eq(&self, other: &TypeQualifier) -> bool {
+        match &self.q {
+            Some(q) => q == other,
+            _ => false,
+        }
+    }
+}
+
+/// A map of (bare) subprogram names to their respective signatures.
+pub type SignatureMap = HashMap<BareName, Positioned<Signature>>;

rusty_linter/src/post_linter/user_defined_function_linter.rs

@@ -1,6 +1,4 @@
-use crate::core::{CanCastTo, HasFunctions, ResolvedParamType};
-use crate::core::{LintError, LintErrorPos};
-use crate::pre_linter::ResolvedParamTypes;
+use crate::core::*;
 use rusty_common::*;
 use rusty_parser::*;
 
@@ -165,7 +163,7 @@ where
         if let Name::Qualified(bare_name, qualifier) = name {
             match self.linter_context.functions().get(bare_name) {
                 Some(function_signature_pos) => {
-                    if function_signature_pos.element.qualifier() != *qualifier {
+                    if function_signature_pos.element != *qualifier {
                         Err(LintError::TypeMismatch.at(function_signature_pos))
                     } else {
                         lint_call_args(args, function_signature_pos.element.param_types(), pos)

rusty_linter/src/pre_linter/constant_map.rs

@@ -0,0 +1,13 @@
+use crate::core::ConstLookup;
+use rusty_common::CaseInsensitiveString;
+use rusty_parser::BareName;
+use rusty_variant::Variant;
+use std::collections::HashMap;
+
+pub type ConstantMap = HashMap<BareName, Variant>;
+
+impl ConstLookup for ConstantMap {
+    fn get_resolved_constant(&self, name: &CaseInsensitiveString) -> Option<&Variant> {
+        self.get(name)
+    }
+}