Code coverage improvements

Author: kyleect

coverage.sh

@@ -1,3 +1,4 @@
 #!/usr/bin/env bash
 
-cargo llvm-cov --html --open --ignore-filename-regex 'main|cliutil'
+cargo llvm-cov nextest --lcov --output-path target/llvm-cov/lcov.info --ignore-filename-regex 'main|cliutil'
+cargo llvm-cov report --html --open --output-dir target/llvm-cov

src/ast.rs

@@ -25,17 +25,14 @@ impl Expr {
         )))
     }
 
-    pub fn identifier_name(&self) -> Option<&str> {
-        match self {
-            Expr::Identifier(expr_identifier) => Some(expr_identifier.lookup_name()),
-            _ => None,
-        }
-    }
-
     pub fn string(string: &str) -> Self {
         Self::String(ExprString::new(string).into())
     }
 
+    pub fn number(value: f64) -> Self {
+        Self::Number(ExprNumber::new(value).into())
+    }
+
     pub fn call(callee: ExprS, args: Vec<ExprS>) -> Self {
         Self::Call(Box::new(ExprCall {
             callee: callee.into(),
@@ -47,10 +44,6 @@ impl Expr {
         Self::Bool(Box::new(ExprBool::new(value)))
     }
 
-    pub fn is_bool(&self) -> bool {
-        self.get_type() == Type::Bool
-    }
-
     pub fn get_type(&self) -> Type {
         match self {
             Expr::Bool(_) => Type::Bool,

src/cliutil.rs

@@ -72,7 +72,6 @@ pub fn unzip_key_values(keys_values: Vec<(String, String)>) -> (Vec<String>, Vec
 /// let args = Args::parse_from(["test", "--vars", "key=value", "another_key=another_value"]);
 /// assert_eq!(args.vars, vec![("key".to_string(), "value".to_string()), ("another_key".to_string(), "another_value".to_string())]);
 /// ```
-///
 pub fn parse_key_val<T, U>(value: &str) -> Result<(T, U), Box<dyn Error + Send + Sync + 'static>>
 where
     T: std::str::FromStr,
@@ -134,3 +133,52 @@ pub fn read_in_source(path: Option<String>) -> String {
         }
     }
 }
+
+#[cfg(test)]
+mod cliutil_tests {
+    use clap::Parser;
+
+    use crate::cliutil::{parse_key_val, read_in_source};
+
+    #[test]
+    fn read_in_source_from_file() {
+        let result = read_in_source(Some("./spec/valid/call_id.expr".to_string()));
+
+        assert_eq!("(id (noop))", result);
+    }
+
+    #[test]
+    fn parse_key_val_valid_keyvalue_pair() {
+        #[derive(Parser, Debug, PartialEq)]
+        struct Args {
+            #[arg(long, value_delimiter = ' ', num_args = 1.., value_parser = parse_key_val::<String, String>)]
+            vars: Vec<(String, String)>,
+        }
+
+        assert_eq!(
+            Args {
+                vars: vec![(String::from("key"), String::from("value"))]
+            },
+            Args::try_parse_from(["test", "--vars", "key=value"])
+                .ok()
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn parse_key_val_invalid_keyvalue_pair() {
+        #[derive(Parser, Debug, PartialEq)]
+        struct Args {
+            #[arg(long, value_delimiter = ' ', num_args = 1.., value_parser = parse_key_val::<String, String>)]
+            vars: Vec<(String, String)>,
+        }
+
+        assert_eq!(
+            "error: invalid value 'key_without_value' for '--vars <VARS>...': should be formatted as key=value pair: `key_without_value`\n\nFor more information, try '--help'.\n",
+            Args::try_parse_from(["test", "--vars", "key_without_value"])
+                .err()
+                .unwrap()
+                .to_string()
+        );
+    }
+}

src/compiler.rs

@@ -171,10 +171,6 @@ impl CompileTimeEnv {
         }
     }
 
-    pub fn add_keys_to_client_context(&mut self, keys: Vec<String>) {
-        self.client_context.extend(keys);
-    }
-
     pub fn get_client_context_index(&self, name: &str) -> Option<(&String, u8)> {
         let index = self
             .client_context
@@ -223,10 +219,6 @@ impl ExprByteCode {
         &self.codes
     }
 
-    pub fn get_code(&self, index: usize) -> Option<&u8> {
-        self.codes.get(index)
-    }
-
     pub fn constants(&self) -> &[Value] {
         &self.constants
     }

src/errors.rs

@@ -60,12 +60,6 @@ impl diagnostics::AsDiagnostic for LexicalError {
     }
 }
 
-impl From<ParseFloatError> for LexicalError {
-    fn from(value: ParseFloatError) -> Self {
-        LexicalError::InvalidNumber(value)
-    }
-}
-
 #[derive(Debug, Clone, Error, PartialEq)]
 pub enum SyntaxError {
     #[error("extraneous input: {token:?}")]
@@ -486,7 +480,10 @@ pub mod diagnostics {
 
     #[cfg(test)]
     mod error_to_diagnostics_tests {
-        use crate::errors::{CompileError, ExprError, LexicalError};
+        use crate::{
+            errors::{CompileError, ExprError, LexicalError, RuntimeError, SyntaxError},
+            types::Type,
+        };
 
         use super::*;
         use std::ops::Range;
@@ -552,5 +549,250 @@ pub mod diagnostics {
             assert_eq!(diagnostic.labels.len(), 1);
             assert_eq!(diagnostic.labels[0], Label::primary((), range));
         }
+
+        #[test]
+        fn it_converts_compileerror_no_callee_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::CompileError(CompileError::NoCallee);
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("compiler".to_string()));
+            assert_eq!(
+                diagnostic.message,
+                "call expression without a callee".to_string()
+            );
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_compileerror_type_mismatch_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::CompileError(CompileError::TypeMismatch {
+                expected: Type::String,
+                actual: Type::Bool,
+            });
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("compiler".to_string()));
+            assert_eq!(
+                diagnostic.message,
+                "expected type String but received Bool".to_string()
+            );
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_compileerror_invalid_lookup_type_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::CompileError(CompileError::InvalidLookupType(99));
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("compiler".to_string()));
+            assert_eq!(diagnostic.message, "invalid lookup type: 99".to_string());
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_runtimeerror_undefined_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::RuntimeError(RuntimeError::TypeMismatch {
+                expected: Type::Bool,
+                actual: Type::String,
+            });
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("runtime".to_string()));
+            assert_eq!(
+                diagnostic.message,
+                "expected type Bool but received String".to_string()
+            );
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_runtimeerror_empty_stack_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::RuntimeError(RuntimeError::EmptyStack);
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("runtime".to_string()));
+            assert_eq!(
+                diagnostic.message,
+                "attempting to pop from an empty stack".to_string()
+            );
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_syntaxerror_unrecognized_eof_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::SyntaxError(SyntaxError::UnrecognizedEOF {
+                expected: vec!["string".to_string()],
+            });
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("syntax".to_string()));
+            assert_eq!(
+                diagnostic.message,
+                "unexpected end of file; expected: [\"string\"]".to_string()
+            );
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_syntaxerror_invalid_token_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::SyntaxError(SyntaxError::InvalidToken);
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("syntax".to_string()));
+            assert_eq!(diagnostic.message, "invalid input".to_string());
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_syntaxerror_unexpected_input_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::SyntaxError(SyntaxError::UnexpectedInput {
+                token: "number".to_string(),
+            });
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("syntax".to_string()));
+            assert_eq!(
+                diagnostic.message,
+                "unexpected input: \"number\"".to_string()
+            );
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_syntaxerror_unrecognized_token_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::SyntaxError(SyntaxError::UnrecognizedToken {
+                token: "number".to_string(),
+                expected: vec![",".to_string(), "number".to_string(), "]".to_string()],
+            });
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("syntax".to_string()));
+            assert_eq!(
+                diagnostic.message,
+                "unexpected \"number\"; expected: [\",\", \"number\", \"]\"]".to_string()
+            );
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_syntaxerror_unterminated_string_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::SyntaxError(SyntaxError::UnterminatedString);
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("syntax".to_string()));
+            assert_eq!(diagnostic.message, "unterminated string".to_string());
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+
+        #[test]
+        fn it_converts_syntaxerror_extra_token_to_diagnostic() {
+            let source = dummy_source();
+            let range = dummy_range();
+            let error = ExprError::SyntaxError(SyntaxError::ExtraToken {
+                token: ",".to_string(),
+            });
+            let diagnostics = get_diagnostics(&[(error, range.clone())], source);
+
+            assert_eq!(diagnostics.len(), 1);
+            let diagnostic = &diagnostics[0];
+            assert_eq!(diagnostic.code, Some("syntax".to_string()));
+            assert_eq!(diagnostic.message, "extraneous input: \",\"".to_string());
+            assert_eq!(diagnostic.severity, Severity::Error);
+            assert_eq!(diagnostic.labels.len(), 1);
+            assert_eq!(diagnostic.labels[0], Label::primary((), range));
+        }
+    }
+    #[cfg(test)]
+    mod to_severity_tests {
+        use codespan_reporting::diagnostic::Severity;
+
+        use crate::errors::diagnostics::ExprDiagnosisSeverity;
+
+        #[test]
+        fn from_hint() {
+            assert_eq!(Severity::Help, ExprDiagnosisSeverity::HINT.to_severity());
+        }
+
+        #[test]
+        fn from_information() {
+            assert_eq!(
+                Severity::Note,
+                ExprDiagnosisSeverity::INFORMATION.to_severity()
+            );
+        }
+
+        #[test]
+        fn from_warning() {
+            assert_eq!(
+                Severity::Warning,
+                ExprDiagnosisSeverity::WARNING.to_severity()
+            );
+        }
+
+        #[test]
+        #[should_panic(expected = "Invalid diagnosis severity: 99")]
+        fn from_invalid() {
+            ExprDiagnosisSeverity(99).to_severity();
+        }
     }
 }