Defer external invocation targets in translation (#111)

Fix a bug that was discovered in the translation phase of the compiler
where we were failing to handle remote invocation targets. By their
nature, external targets will remain unresolved through translation and
linking and can only be looked up at runtime.

Author: istathar

src/language/types.rs

@@ -131,7 +131,7 @@ impl<'i> Identifier<'i> {
     }
 }
 
-#[derive(Eq, Debug)]
+#[derive(Clone, Copy, Eq, Debug)]
 pub struct External<'i> {
     pub value: &'i str,
     pub span: Span,

src/problem/messages.rs

@@ -1137,10 +1137,7 @@ functions calls:
             function: Identifier { value: name, .. },
         } => (
             format!("Unknown function {}()", name),
-            format!(
-                "The function {}() is neither builtin nor provided by the selected domain.",
-                name
-            ),
+            "The function is neither builtin nor provided by the selected domain.".to_string(),
         ),
     }
 }

src/program/types.rs

@@ -145,11 +145,13 @@ pub struct Invocable<'i> {
 /// subroutine into `Program.subroutines`; the resolve pass walks the
 /// translated tree replacing matching `Unresolved` references with
 /// `Resolved`. Names that don't match any declared subroutine become a
-/// translation error.
+/// translation error. `Deferred` references (ie URLs) are left as-is; they
+/// are resolved at a later phase or at runtime.
 #[derive(Debug, Eq, PartialEq)]
 pub enum SubroutineRef<'i> {
     Unresolved(language::Identifier<'i>),
     Resolved(SubroutineId),
+    Deferred(language::External<'i>),
 }
 
 /// Lowered form of `language::Function`. Functions live in a separate

src/runner/runner.rs

@@ -472,6 +472,11 @@ impl<'i, D: Driver> Runner<'i, D> {
                     .announce(&format!("<{}>", id.value));
                 Ok(Outcome::Done(Value::Unitus))
             }
+            SubroutineRef::Deferred(ext) => {
+                self.driver
+                    .announce(&format!("<{}>", ext.value));
+                Ok(Outcome::Done(Value::Unitus))
+            }
         }
     }
 

src/translation/translator.rs

@@ -745,7 +745,7 @@ impl<'i> Translator<'i> {
     fn translate_invocation(&mut self, invocation: &'i language::Invocation<'i>) -> Invocable<'i> {
         let target = match &invocation.target {
             language::Target::Local(id) => SubroutineRef::Unresolved(*id),
-            language::Target::Remote(_) => todo!("remote invocation target"),
+            language::Target::Remote(external) => SubroutineRef::Deferred(*external),
         };
         let arguments = match &invocation.parameters {
             Some(params) => params