Make 'declare' syntax require ::, so that we can parse an expression …

…for the target. This also improves error reporting in this place.

monoteny/core/strings.monoteny

@@ -5,7 +5,7 @@ use!(
 -- The easiest way to format an object: It formats itself!
 def format(object '$ToString) -> String :: object.to_string();
 
-declare String is ToString {
+declare String is ToString :: {
     def (self 'Self).to_string() -> String :: self;
 };
 

src/interpreter/tests.rs

@@ -47,7 +47,7 @@ mod tests {
 
         let module = runtime.load_file_as_module(&PathBuf::from(path), module_name("main"))?;
 
-        let entry_function = interpreter::run::get_main_function(&module)?;
+        let entry_function = interpreter::run::get_main_function(&module)?.unwrap();
 
         // TODO Should gather all used functions and compile them
         let compiled = compile_deep(&mut runtime, entry_function)?;

src/monoteny_grammar.lalrpop

@@ -115,7 +115,7 @@ Trait: TraitDefinition = {
 }
 
 Conformance: TraitConformanceDeclaration = {
-    "declare" <declared_for: Expression> "is" <declared: Identifier> "{" <block: Box<Block>> "}" => TraitConformanceDeclaration { <> },
+    "declare" <declared_for: Expression> "is" <declared: Expression> "::" "{" <block: Box<Block>> "}" => TraitConformanceDeclaration { <> },
 }
 
 // =============================== Statement =====================================

src/parser/ast.rs

@@ -44,7 +44,7 @@ pub struct TraitDefinition {
 #[derive(Eq, PartialEq, Clone)]
 pub struct TraitConformanceDeclaration {
     pub declared_for: Expression,
-    pub declared: String,
+    pub declared: Expression,
     pub block: Box<Block>,
 }
 

src/resolver/global.rs

@@ -134,7 +134,14 @@ impl <'a> GlobalResolver<'a> {
 
                 let mut type_factory = TypeFactory::new(&self.global_variables, &mut self.runtime);
                 let self_type = type_factory.resolve_type(&syntax.declared_for, true)?;
-                let declared = type_factory.resolve_trait(&syntax.declared)?;
+                let declared_type = type_factory.resolve_type(&syntax.declared, false)?;
+                let TypeUnit::Struct(declared) = &declared_type.unit else {
+                    panic!("Somehow, the resolved type wasn't a struct.")
+                };
+                if !declared_type.arguments.is_empty() {
+                    return Err(RuntimeError::error("Conformance cannot be declared with bindings for now.").to_array());
+                }
+
                 if declared.generics.keys().collect_vec() != vec!["Self"] {
                     // Requires 1) parsing generics that the programmer binds
                     // and  2) inserting new generics for each that isn't explicitly bound

test-code/traits/conformance.monoteny

@@ -9,14 +9,14 @@ trait Animal {
 trait Cat {};
 
 -- Declare every Cat subtype is Animal.
-declare $Cat is Animal {
+declare $Cat is Animal :: {
     def (self 'Self).talk() -> String :: "Meow";
 };
 
 trait Dog {};
 
 -- Declare just the Dog struct is Animal.
-declare Dog is Animal {
+declare Dog is Animal :: {
    def (self 'Self).talk() -> String :: "Bark";
 };