move type checking from lib.rs into compile.rs

Now the only use of ConstructNode, and incomplete types more broadly,
occurs within compile.rs. This will make it much easier for us to
update rust-simplicity to require scoped type inference contexts.

Author: apoelstra

src/compile.rs

@@ -14,7 +14,7 @@ use crate::ast::{
 };
 use crate::debug::CallTracker;
 use crate::error::{Error, RichError, Span, WithSpan};
-use crate::named::{CoreExt, PairBuilder};
+use crate::named::{self, CoreExt, PairBuilder};
 use crate::num::{NonZeroPow2Usize, Pow2Usize};
 use crate::pattern::{BasePattern, Pattern};
 use crate::str::WitnessName;
@@ -257,13 +257,18 @@ impl Program {
         &self,
         arguments: Arguments,
         include_debug_symbols: bool,
-    ) -> Result<ProgNode, RichError> {
+    ) -> Result<Arc<named::CommitNode>, RichError> {
         let mut scope = Scope::new(
             Arc::clone(self.call_tracker()),
             arguments,
             include_debug_symbols,
         );
-        self.main().compile(&mut scope).map(PairBuilder::build)
+
+        let main = self.main();
+        let construct = main.compile(&mut scope).map(PairBuilder::build)?;
+        // SimplicityHL types should be correct by construction. If not, assign the
+        // whole main function as the span for them, which is as sensible as anything.
+        named::finalize_types(&construct).with_span(&main)
     }
 }
 

src/lib.rs

@@ -81,11 +81,10 @@ impl TemplateProgram {
             .is_consistent(self.simfony.parameters())
             .map_err(|error| error.to_string())?;
 
-        let construct = self
+        let commit = self
             .simfony
             .compile(arguments, include_debug_symbols)
             .with_file(Arc::clone(&self.file))?;
-        let commit = named::finalize_types(&construct).map_err(|e| e.to_string())?;
 
         Ok(CompiledProgram {
             debug_symbols: self.simfony.debug_symbols(self.file.as_ref()),