Remove UnresolvedFunctionImplementation.decorators as it's not needed…

… now. Improve a few error messages.

src/interpreter/run.rs

@@ -30,7 +30,7 @@ pub fn get_main_function(module: &Module) -> RResult<Option<&Rc<FunctionHead>>>
     let entry_function = match &module.main_functions[..] {
         [] => return Ok(None),
         [f] => f,
-        functions => return Err(RuntimeError::error(format!("Too many @main functions declared: {:?}", functions).as_str()).to_array()),
+        functions => return Err(RuntimeError::error(format!("Too many !main functions declared: {:?}", functions).as_str()).to_array()),
     };
     if !entry_function.interface.parameters.is_empty() {
         return Err(RuntimeError::error("main! function has parameters.").to_array());

src/parser/ast.rs

@@ -108,6 +108,18 @@ impl From<Vec<Box<Positioned<Term>>>> for Expression {
     }
 }
 
+impl Array {
+    pub fn empty() -> Array {
+        Array { arguments: vec![] }
+    }
+}
+
+impl Struct {
+    pub fn empty() -> Struct {
+        Struct { arguments: vec![] }
+    }
+}
+
 #[derive(Eq, PartialEq, Clone)]
 pub enum Term {
     Error(RuntimeError),

src/resolver/ambiguous/function_call.rs

@@ -139,7 +139,11 @@ impl ResolverAmbiguity for AmbiguousFunctionCall {
                     types: &resolver.types,
                 };
                 Err(
-                    RuntimeError::error(format!("function {} could not be resolved. {} candidates failed type / requirements test.", signature, cs.len()).as_str()).to_array()
+                    RuntimeError::error(format!("function {} could not be resolved. ", signature).as_str())
+                        .with_note(
+                            RuntimeError::info(format!("{} candidates failed type / requirements test.", cs.len()).as_str())
+                        )
+                        .to_array()
                 )
             }
         }

src/resolver/conformance.rs

@@ -18,7 +18,6 @@ use crate::refactor::monomorphize::map_interface_types;
 pub struct UnresolvedFunctionImplementation<'a> {
     pub function: Rc<FunctionHead>,
     pub representation: FunctionRepresentation,
-    pub decorators: Vec<String>,
     pub body: &'a Option<ast::Expression>,
 }
 
@@ -40,17 +39,16 @@ impl <'a, 'b> ConformanceResolver<'a, 'b> {
                     function,
                     representation,
                     body: &syntax.body,
-                    decorators: vec![],
                 });
             }
             ast::Statement::Expression(e) => {
                 return Err(
-                    RuntimeError::error(format!("Expression {} not valid in a conformance context.", statement).as_str()).to_array()
+                    RuntimeError::error("Expression not valid in a conformance context.").to_array()
                 );
             }
             _ => {
                 return Err(
-                    RuntimeError::error(format!("Statement {} not valid in a conformance context.", statement).as_str()).to_array()
+                    RuntimeError::error("Statement {} not valid in a conformance context.").to_array()
                 );
             }
         }

src/resolver/global.rs

@@ -96,7 +96,7 @@ impl <'a> GlobalResolver<'a> {
                     self.global_variables.add_pattern(pattern)?;
                 }
                 self.schedule_function_body(&fun, syntax.body.as_ref(), pstatement.value.position.clone());
-                self.add_function_interface(fun, representation, &vec![])?;
+                self.add_function_interface(fun, representation)?;
             }
             ast::Statement::Trait(syntax) => {
                 pstatement.no_decorations()?;
@@ -192,7 +192,7 @@ impl <'a> GlobalResolver<'a> {
                     self.schedule_function_body(&fun.function, fun.body.as_ref(), pstatement.value.position.clone());
                     // TODO Instead of adding conformance functions statically, we should add the abstract function to the scope.
                     //  This will allow the compiler to determine "function exists but no declaration exists" in the future.
-                    self.add_function_interface(fun.function, fun.representation.clone(), &fun.decorators)?;
+                    self.add_function_interface(fun.function, fun.representation.clone())?;
                 }
             }
             ast::Statement::Expression(e) => {
@@ -237,12 +237,12 @@ impl <'a> GlobalResolver<'a> {
                 }
 
                 return Err(
-                    RuntimeError::error(format!("Expression {} is not supported in a global context.", e).as_str()).to_array()
+                    RuntimeError::error("Expression is not supported in a global context.").to_array()
                 )
             }
-            statement => {
+            _ => {
                 return Err(
-                    RuntimeError::error(format!("Statement {} is not supported in a global context.", statement).as_str()).to_array()
+                    RuntimeError::error("Statement is not supported in a global context.").to_array()
                 )
             }
         }
@@ -263,13 +263,7 @@ impl <'a> GlobalResolver<'a> {
         Ok(())
     }
 
-    pub fn add_function_interface(&mut self, pointer: Rc<FunctionHead>, representation: FunctionRepresentation, decorators: &Vec<String>) -> RResult<()> {
-        for decorator in decorators.iter() {
-            return Err(
-                RuntimeError::error(format!("Decorator could not be resolved: {}", decorator).as_str()).to_array()
-            )
-        }
-
+    pub fn add_function_interface(&mut self, pointer: Rc<FunctionHead>, representation: FunctionRepresentation) -> RResult<()> {
         referencible::add_function(self.runtime, &mut self.module, Some(&mut self.global_variables), pointer, representation)?;
 
         Ok(())

src/resolver/grammar/parse.rs

@@ -124,18 +124,16 @@ pub fn resolve_expression_to_tokens(resolver: &mut ImperativeResolver, syntax: &
 
                         match next_token.map(|t| &t.value) {
                             Some(ast::Term::Struct(s)) => {
-                                let range = &next_token.unwrap().position;
-
                                 // The next token is a struct; we can immediately call it!
-                                let struct_ = resolver.resolve_struct(scope, s).err_in_range(range)?;
+                                let struct_ = resolver.resolve_struct(scope, s).err_in_range(&next_token.unwrap().position)?;
 
                                 let expression_id = resolver.resolve_function_call(
                                     overload.functions.iter(),
                                     overload.representation.clone(),
                                     [ParameterKey::Positional].into_iter().chain(struct_.keys.clone()).collect_vec(),
                                     [target.clone()].into_iter().chain(struct_.values.clone()).collect_vec(),
                                     scope,
-                                    ast_token.position.clone(),
+                                    range.clone(),
                                 ).err_in_range(range)?;
 
                                 Token::Value(expression_id)
@@ -151,7 +149,7 @@ pub fn resolve_expression_to_tokens(resolver: &mut ImperativeResolver, syntax: &
                                 vec![ParameterKey::Positional],
                                 vec![target.clone()],
                                 scope,
-                                ast_token.position.clone()
+                                range.clone()
                             ).err_in_range(range)?
                         )
                     }

src/resolver/traits.rs

@@ -77,12 +77,12 @@ impl <'a> TraitResolver<'a> {
             }
             ast::Statement::Expression(e) => {
                 return Err(
-                    RuntimeError::error(format!("Expression {} not valid in a trait context.", statement).as_str()).to_array()
+                    RuntimeError::error("Expression not valid in a trait context.").to_array()
                 );
             }
             _ => {
                 return Err(
-                    RuntimeError::error(format!("Statement {} not valid in a trait context.", statement).as_str()).to_array()
+                    RuntimeError::error("Statement not valid in a trait context.").to_array()
                 );
             }
         }
@@ -180,7 +180,6 @@ pub fn try_make_struct(trait_: &Rc<Trait>, resolver: &mut GlobalResolver) -> RRe
     resolver.add_function_interface(
         Rc::clone(&struct_.constructor),
         FunctionRepresentation::new("call_as_function", FunctionTargetType::Member, FunctionCallExplicity::Explicit),
-        &vec![],
     )?;
 
     for (ref_, head) in struct_.field_getters.iter() {
@@ -193,8 +192,7 @@ pub fn try_make_struct(trait_: &Rc<Trait>, resolver: &mut GlobalResolver) -> RRe
         resolver.add_function_interface(
             Rc::clone(head),
             FunctionRepresentation::new(name, FunctionTargetType::Member, FunctionCallExplicity::Implicit),
-            &vec![])?
-        ;
+        )?;
     }
 
     for (ref_, head) in struct_.field_setters.iter() {
@@ -207,7 +205,6 @@ pub fn try_make_struct(trait_: &Rc<Trait>, resolver: &mut GlobalResolver) -> RRe
         resolver.add_function_interface(
             Rc::clone(head),
             FunctionRepresentation::new(name, FunctionTargetType::Member, FunctionCallExplicity::Implicit),
-            &vec![]
         )?;
     }