Allow for multi-span errors (#296)

* Test

* Specialized error message for one type of error.

* Missing function arguments.

* Move format methods to be inside of CompileError and CompileWarning.

* Better error messages.

* TooManyArgumentsForFunction message.

* ReassignmentToNonVariable.

* Simplify iterator stuff.

Author: emilyaherbert

Cargo.lock

@@ -22,7 +22,8 @@ sha2 = "0.9"
 structopt = { version = "0.3", default-features = false, optional = true }
 thiserror = "1.0"
 uuid-b64 = "0.1"
-
+line-col = "0.2"
+source-span = "2.4"
 
 [[bin]]
 name = "selector-debug"

core_lang/Cargo.toml

@@ -2,6 +2,11 @@ use crate::span::Span;
 use crate::{parser::Rule, types::MaybeResolvedType};
 use inflector::cases::classcase::to_class_case;
 use inflector::cases::snakecase::to_snake_case;
+use line_col::LineColLookup;
+use source_span::{
+    fmt::{Formatter, Style},
+    Position,
+};
 use thiserror::Error;
 
 macro_rules! check {
@@ -137,6 +142,34 @@ impl<'sc> CompileWarning<'sc> {
             self.span.end_pos().line_col().into(),
         )
     }
+
+    pub fn format(&self, fmt: &mut Formatter) -> source_span::fmt::Formatted {
+        let input = self.span.input();
+        let chars = input.chars().map(|x| -> Result<_, ()> { Ok(x) });
+
+        let metrics = source_span::DEFAULT_METRICS;
+        let buffer = source_span::SourceBuffer::new(chars, Position::default(), metrics);
+
+        for c in buffer.iter() {
+            let _ = c.unwrap(); // report eventual errors.
+        }
+
+        let (start_pos, end_pos) = self.span();
+        let lookup = LineColLookup::new(input);
+        let (start_line, start_col) = lookup.get(start_pos);
+        let (end_line, end_col) = lookup.get(end_pos - 1);
+
+        let err_start = Position::new(start_line - 1, start_col - 1);
+        let err_end = Position::new(end_line - 1, end_col - 1);
+        let err_span = source_span::Span::new(err_start, err_end, err_end.next_column());
+        fmt.add(
+            err_span,
+            Some(self.to_friendly_warning_string()),
+            Style::Warning,
+        );
+
+        fmt.render(buffer.iter(), buffer.span(), &metrics).unwrap()
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -390,10 +423,15 @@ pub enum CompileError<'sc> {
     ReassignmentToNonVariable {
         name: &'sc str,
         kind: &'sc str,
-        span: Span<'sc>,
+        decl_span: Span<'sc>,
+        usage_span: Span<'sc>,
+    },
+    #[error("Assignment to immutable variable. Variable {name} is not declared as mutable.")]
+    AssignmentToNonMutable {
+        name: &'sc str,
+        decl_span: Span<'sc>,
+        usage_span: Span<'sc>,
     },
-    #[error("Assignment to immutable variable. Variable {0} is not declared as mutable.")]
-    AssignmentToNonMutable(String, Span<'sc>),
     #[error(
         "Generic type \"{name}\" is not in scope. Perhaps you meant to specify type parameters in \
          the function signature? For example: \n`fn \
@@ -631,7 +669,8 @@ pub enum CompileError<'sc> {
         "Function \"{method_name}\" expects {expected} arguments but you provided {received}."
     )]
     TooManyArgumentsForFunction {
-        span: Span<'sc>,
+        decl_span: Span<'sc>,
+        usage_span: Span<'sc>,
         method_name: &'sc str,
         expected: usize,
         received: usize,
@@ -640,7 +679,8 @@ pub enum CompileError<'sc> {
         "Function \"{method_name}\" expects {expected} arguments but you provided {received}."
     )]
     TooFewArgumentsForFunction {
-        span: Span<'sc>,
+        decl_span: Span<'sc>,
+        usage_span: Span<'sc>,
         method_name: &'sc str,
         expected: usize,
         received: usize,
@@ -792,8 +832,8 @@ impl<'sc> CompileError<'sc> {
             PredicateMainDoesNotReturnBool(span) => span,
             NoScriptMainFunction(span) => span,
             MultipleScriptMainFunctions(span) => span,
-            ReassignmentToNonVariable { span, .. } => span,
-            AssignmentToNonMutable(_, span) => span,
+            ReassignmentToNonVariable { usage_span, .. } => usage_span,
+            AssignmentToNonMutable { usage_span, .. } => usage_span,
             TypeParameterNotInTypeScope { span, .. } => span,
             MultipleImmediates(span) => span,
             MismatchedTypeInTrait { span, .. } => span,
@@ -848,8 +888,8 @@ impl<'sc> CompileError<'sc> {
             UnnecessaryEnumInstantiator { span, .. } => span,
             TraitNotFound { span, .. } => span,
             InvalidExpressionOnLhs { span, .. } => span,
-            TooManyArgumentsForFunction { span, .. } => span,
-            TooFewArgumentsForFunction { span, .. } => span,
+            TooManyArgumentsForFunction { usage_span, .. } => usage_span,
+            TooFewArgumentsForFunction { usage_span, .. } => usage_span,
             InvalidAbiType { span, .. } => span,
             InvalidNumberOfAbiParams { span, .. } => span,
             NotAnAbi { span, .. } => span,
@@ -870,4 +910,139 @@ impl<'sc> CompileError<'sc> {
             self.internal_span().end_pos().line_col().into(),
         )
     }
+
+    pub fn format(&self, fmt: &mut Formatter) -> source_span::fmt::Formatted {
+        match self {
+            CompileError::AssignmentToNonMutable {
+                name,
+                decl_span,
+                usage_span,
+            } => self.format_one_hint_one_err(
+                fmt,
+                decl_span,
+                format!(
+                    "Variable {} not declared as mutable. Try adding 'mut'.",
+                    name
+                ),
+                usage_span,
+                format!("Assignment to immutable variable {}.", name),
+            ),
+            CompileError::TooFewArgumentsForFunction {
+                decl_span,
+                usage_span,
+                method_name,
+                expected,
+                received,
+            } => self.format_one_hint_one_err(
+                fmt,
+                decl_span,
+                format!("Function {} declared here.", method_name),
+                usage_span,
+                format!(
+                    "Function {} expected {} arguments and recieved {}.",
+                    method_name, expected, received
+                ),
+            ),
+            CompileError::TooManyArgumentsForFunction {
+                decl_span,
+                usage_span,
+                method_name,
+                expected,
+                received,
+            } => self.format_one_hint_one_err(
+                fmt,
+                decl_span,
+                format!("Function {} declared here.", method_name),
+                usage_span,
+                format!(
+                    "Function {} expected {} arguments and recieved {}.",
+                    method_name, expected, received
+                ),
+            ),
+            CompileError::ReassignmentToNonVariable {
+                name,
+                kind,
+                decl_span,
+                usage_span,
+            } => self.format_one_hint_one_err(
+                fmt,
+                decl_span,
+                format!("Symbol {} declared here.", name),
+                usage_span,
+                format!("Attempted to reassign to a symbol that is not a variable. Symbol {} is not a mutable \
+                variable, it is a {}.", name, kind)
+            ),
+            _ => self.format_err_simple(fmt),
+        }
+    }
+
+    fn format_err_simple(&self, fmt: &mut Formatter) -> source_span::fmt::Formatted {
+        let input = self.internal_span().input();
+        let chars = input.chars().map(Result::<_, String>::Ok);
+
+        let metrics = source_span::DEFAULT_METRICS;
+        let buffer = source_span::SourceBuffer::new(chars, Position::default(), metrics);
+
+        for c in buffer.iter() {
+            let _ = c.unwrap(); // report eventual errors.
+        }
+
+        let (start_pos, end_pos) = self.span();
+        let lookup = LineColLookup::new(input);
+        let (start_line, start_col) = lookup.get(start_pos);
+        let (end_line, end_col) = lookup.get(if end_pos == 0 { 0 } else { end_pos - 1 });
+
+        let err_start = Position::new(start_line - 1, start_col - 1);
+        let err_end = Position::new(end_line - 1, end_col - 1);
+        let err_span = source_span::Span::new(err_start, err_end, err_end.next_column());
+        fmt.add(
+            err_span,
+            Some(self.to_friendly_error_string()),
+            Style::Error,
+        );
+
+        fmt.render(buffer.iter(), buffer.span(), &metrics).unwrap()
+    }
+
+    fn format_one_hint_one_err(
+        &self,
+        fmt: &mut Formatter,
+        hint_span: &Span<'sc>,
+        hint_message: String,
+        err_span: &Span<'sc>,
+        err_message: String,
+    ) -> source_span::fmt::Formatted {
+        self.format_one(fmt, hint_span.clone(), Style::Note, hint_message);
+        self.format_one(fmt, err_span.clone(), Style::Error, err_message);
+
+        let span = crate::utils::join_spans(hint_span.clone(), err_span.clone());
+        let input = span.input();
+        let chars = input.chars().map(Result::<_, String>::Ok);
+        let metrics = source_span::DEFAULT_METRICS;
+        let buffer = source_span::SourceBuffer::new(chars, Position::default(), metrics);
+        for c in buffer.iter() {
+            let _ = c.unwrap(); // report eventual errors.
+        }
+
+        fmt.render(buffer.iter(), buffer.span(), &metrics).unwrap()
+    }
+
+    fn format_one(
+        &self,
+        fmt: &mut Formatter,
+        span: Span<'sc>,
+        style: source_span::fmt::Style,
+        friendly_string: String,
+    ) {
+        let input = span.input();
+        let (start_pos, end_pos) = (span.start(), span.end());
+        let lookup = LineColLookup::new(input);
+        let (start_line, start_col) = lookup.get(start_pos);
+        let (end_line, end_col) = lookup.get(if end_pos == 0 { 0 } else { end_pos - 1 });
+
+        let err_start = Position::new(start_line - 1, start_col - 1);
+        let err_end = Position::new(end_line - 1, end_col - 1);
+        let err_span = source_span::Span::new(err_start, err_end, err_end.next_column());
+        fmt.add(err_span, Some(friendly_string.clone()), style);
+    }
 }

core_lang/src/error.rs

@@ -24,7 +24,7 @@ use pest::iterators::Pair;
 use pest::Parser;
 use semantic_analysis::{TreeType, TypedParseTree};
 pub mod types;
-pub(crate) mod utils;
+pub mod utils;
 pub use crate::parse_tree::{Declaration, Expression, UseStatement, WhileLoop};
 use std::collections::{HashMap, HashSet};
 

core_lang/src/lib.rs

@@ -54,6 +54,7 @@ impl<'sc> TypedDeclaration<'sc> {
             ErrorRecovery => "error",
         }
     }
+
     pub(crate) fn return_type(&self) -> CompileResult<'sc, MaybeResolvedType<'sc>> {
         ok(
             match self {

core_lang/src/semantic_analysis/ast_node/declaration.rs

@@ -324,7 +324,7 @@ impl<'sc> TypedExpression<'sc> {
     fn type_check_function_application(
         name: CallPath<'sc>,
         arguments: Vec<Expression<'sc>>,
-        span: Span<'sc>,
+        app_span: Span<'sc>,
         namespace: &mut Namespace<'sc>,
         self_type: &MaybeResolvedType<'sc>,
         build_config: &BuildConfig,
@@ -345,6 +345,7 @@ impl<'sc> TypedExpression<'sc> {
                     parameters,
                     return_type,
                     body,
+                    span,
                     ..
                 } = decl.clone();
                 if arguments.len() > parameters.len() {
@@ -356,7 +357,8 @@ impl<'sc> TypedExpression<'sc> {
                         |acc, arg| crate::utils::join_spans(acc, arg.span()),
                     );
                     errors.push(CompileError::TooManyArgumentsForFunction {
-                        span: arguments_span,
+                        decl_span: span.clone(),
+                        usage_span: arguments_span,
                         method_name: name.suffix.primary_name,
                         expected: parameters.len(),
                         received: arguments.len(),
@@ -370,7 +372,8 @@ impl<'sc> TypedExpression<'sc> {
                         |acc, arg| crate::utils::join_spans(acc, arg.span()),
                     );
                     errors.push(CompileError::TooFewArgumentsForFunction {
-                        span: arguments_span,
+                        decl_span: span.clone(),
+                        usage_span: arguments_span,
                         method_name: name.suffix.primary_name,
                         expected: parameters.len(),
                         received: arguments.len(),
@@ -419,7 +422,7 @@ impl<'sc> TypedExpression<'sc> {
                         function_body: body.clone(),
                         selector: None, // regular functions cannot be in a contract call; only methods
                     },
-                    span,
+                    span: app_span,
                 }
             }
             a => {

core_lang/src/semantic_analysis/ast_node/expression/typed_expression.rs

@@ -70,7 +70,8 @@ pub(crate) fn type_check_method_application<'sc>(
             MethodName::FromModule { method_name } => {
                 if args_buf.len() > method.parameters.len() {
                     errors.push(CompileError::TooManyArgumentsForFunction {
-                        span: span.clone(),
+                        decl_span: method.span.clone(),
+                        usage_span: span.clone(),
                         method_name: method_name.primary_name,
                         expected: method.parameters.len(),
                         received: args_buf.len(),
@@ -79,7 +80,8 @@ pub(crate) fn type_check_method_application<'sc>(
 
                 if args_buf.len() < method.parameters.len() {
                     errors.push(CompileError::TooFewArgumentsForFunction {
-                        span: span.clone(),
+                        decl_span: method.span.clone(),
+                        usage_span: span.clone(),
                         method_name: method_name.primary_name,
                         expected: method.parameters.len(),
                         received: args_buf.len(),
@@ -133,7 +135,8 @@ pub(crate) fn type_check_method_application<'sc>(
             MethodName::FromType { ref call_path, .. } => {
                 if args_buf.len() > method.parameters.len() {
                     errors.push(CompileError::TooManyArgumentsForFunction {
-                        span: span.clone(),
+                        decl_span: method.span.clone(),
+                        usage_span: span.clone(),
                         method_name: method_name.easy_name(),
                         expected: method.parameters.len(),
                         received: args_buf.len(),
@@ -142,7 +145,8 @@ pub(crate) fn type_check_method_application<'sc>(
 
                 if args_buf.len() < method.parameters.len() {
                     errors.push(CompileError::TooFewArgumentsForFunction {
-                        span: span.clone(),
+                        decl_span: method.span.clone(),
+                        usage_span: span.clone(),
                         method_name: method_name.easy_name(),
                         expected: method.parameters.len(),
                         received: args_buf.len(),