Implement main expressions

app/src/cli/check.rs

@@ -0,0 +1,20 @@
+use std::path::PathBuf;
+
+use query::{Database, File};
+
+use crate::result::IOError;
+
+#[derive(clap::Args)]
+pub struct Args {
+    #[clap(value_parser, value_name = "FILE")]
+    filepath: PathBuf,
+}
+
+pub fn exec(cmd: Args) -> miette::Result<()> {
+    let mut db = Database::default();
+    let file = File::read(&cmd.filepath).map_err(IOError::from).map_err(miette::Report::from)?;
+    let view = db.add(file).query();
+    let _ = view.tst().map_err(|err| view.pretty_error(err))?;
+    println!("{} typechecked successfully!", cmd.filepath.display());
+    Ok(())
+}

app/src/cli/mod.rs

@@ -1,5 +1,6 @@
 use clap::{Parser, Subcommand};
 
+mod check;
 mod format;
 mod ignore_colors;
 mod lift;
@@ -14,6 +15,7 @@ pub fn exec() -> miette::Result<()> {
     typechecker::tracer::set_enabled(cli.trace);
     match cli.command {
         Run(args) => run::exec(args),
+        Check(args) => check::exec(args),
         Fmt(args) => format::exec(args),
         Texify(args) => texify::exec(args),
         Xfunc(args) => xfunc::exec(args),
@@ -34,8 +36,10 @@ struct Cli {
 
 #[derive(Subcommand)]
 enum Command {
-    /// Run a source code file
+    /// Run the main expression of a file
     Run(run::Args),
+    /// Typecheck a file
+    Check(check::Args),
     /// Format a code file
     Fmt(format::Args),
     /// Render a code file as a latex document

app/src/cli/run.rs

@@ -1,5 +1,8 @@
 use std::path::PathBuf;
 
+use miette::Diagnostic;
+use thiserror::Error;
+
 use printer::{ColorChoice, PrintExt, StandardStream};
 use query::{Database, File};
 use syntax::nf;
@@ -16,10 +19,11 @@ pub fn exec(cmd: Args) -> miette::Result<()> {
     let mut db = Database::default();
     let file = File::read(&cmd.filepath).map_err(IOError::from).map_err(miette::Report::from)?;
     let view = db.add(file).query();
+
     let nf = view.run().map_err(|err| view.pretty_error(err))?;
-    println!("{} typechecked successfully!", cmd.filepath.display());
-    if let Some(nf) = nf {
-        print_nf(&nf)
+    match nf {
+        Some(nf) => print_nf(&nf),
+        None => return Err(miette::Report::from(MainNotFound {})),
     }
     Ok(())
 }
@@ -29,3 +33,8 @@ fn print_nf(nf: &nf::Nf) {
     nf.print_colored(&Default::default(), &mut stream).expect("Failed to print to stdout");
     println!();
 }
+
+#[derive(Error, Diagnostic, Debug)]
+#[error("Main expression was not found")]
+#[diagnostic(help("Main expressions must be called \"main\" and not take any arguments."))]
+pub struct MainNotFound {}

examples/vect.pol

@@ -34,7 +34,6 @@ def Top.example1: Vec(2) {
     Unit => Cons(1, 0, Cons(0, 0, Nil))
 }
 
-def Top.example2: Vec(4) {
-    Unit => Unit.example1.append(2, 2, Unit.example1)
+let main : Vec(4) {
+    Unit.example1.append(2, 2, Unit.example1)
 }
-

lang/query/src/view/rt.rs

@@ -2,6 +2,7 @@ use std::rc::Rc;
 
 use super::DatabaseView;
 
+use normalizer::normalize::Normalize;
 use parser::cst;
 use syntax::{nf, tst, ust};
 
@@ -33,7 +34,20 @@ impl<'a> DatabaseView<'a> {
     }
 
     pub fn run(&self) -> Result<Option<Rc<nf::Nf>>, Error> {
-        Ok(None)
+        let tst = self.tst()?;
+        let ust = tst.forget();
+
+        let main = ust.find_main();
+
+        match main {
+            Some(exp) => {
+                let nf = exp
+                    .normalize_in_empty_env(&ust)
+                    .map_err(|err| Error::Type(typechecker::TypeError::Eval(err)))?;
+                Ok(Some(nf))
+            }
+            None => Ok(None),
+        }
     }
 
     pub fn pretty_error(&self, err: Error) -> miette::Report {

lang/syntax/src/trees/generic/def.rs

@@ -45,6 +45,13 @@ pub struct Prg<P: Phase> {
     pub decls: Decls<P>,
 }
 
+impl<P: Phase> Prg<P> {
+    pub fn find_main(&self) -> Option<Rc<Exp<P>>> {
+        let main_candidate = self.decls.map.get("main")?.get_main()?;
+        Some(main_candidate.body)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Decls<P: Phase> {
     /// Map from identifiers to declarations
@@ -76,6 +83,14 @@ impl<P: Phase> Decl<P> {
             Decl::Let(_) => DeclKind::Let,
         }
     }
+
+    /// Returns whether the declaration is the "main" expression of the module.
+    pub fn get_main(&self) -> Option<Let<P>> {
+        match self {
+            Decl::Let(tl_let) => tl_let.is_main().then(|| tl_let.clone()),
+            _ => None,
+        }
+    }
 }
 impl<P: Phase> HasSpan for Decl<P> {
     fn span(&self) -> Option<Span> {
@@ -194,6 +209,13 @@ pub struct Let<P: Phase> {
     pub body: Rc<Exp<P>>,
 }
 
+impl<P: Phase> Let<P> {
+    /// Returns whether the declaration is the "main" expression of the module.
+    pub fn is_main(&self) -> bool {
+        self.name == "main" && self.params.is_empty()
+    }
+}
+
 #[derive(Debug, Clone, Derivative)]
 #[derivative(Eq, PartialEq, Hash)]
 pub struct Match<P: Phase> {