WIP: Add imports and modules

This is a big change because it touches a lot of stuff, but here is the
overview:

* Import syntax:
    ```
    import foo
    import bar from foo
    import bar from "foo.npp"
    import bar, baz from foo
    import * from foo
    import "foo.npp"
    ```
    * These are all valid imports. They should be pretty
      straightforward, maybe with exception of the last item. If you are
      importing a path directly, but not importing any members from it,
      it does not insert anything into the current namespace, and just
      executes the file. This is probably going to be unused but I want
      to include it for completeness. We can always remove it later
      before a hypothetical 1.0 release.
    * The "from" keyword is only ever used as a keyword here, and I am
      allowing it to be used as an identifier elsewhere. Don't export
      it, because that's weird and wrong and won't work.
* Modules:
    * Doing an `import foo` will look for "foo.npp" at compile-time,
      relative to the importer's directory, parse it, and compile it.
      The importer will then attempt to execute the module with the new
      `EnterModule` op. This instruction will execute the module kind of
      like a function, assigning the module's global namespace to an
      object that you can pass around.
    * `import bar from foo` and `import bar from "foo.npp"` et al syntax
      is not currently implemented in the compiler.
    * There is a new "Module" object that represents a potentially
      un-initialized module. This can't be referred to directly in code.
* VM:
    * The VM operates around Module objects now. If you want to "call" a
      new module, you should call `enter_module`. This is how the main
      chunk is invoked.
* TODOs:
    * `exit_module` function in the VM
    * Finish up module implementation in compiler
    * Built-in modules
    * Sub-modules - e.g. `import foo.bar` - how does naming work for
      this?
    * Module directories. In Python you have `foo/__init__.py` and in
      Rust you have `foo/mod.rs`.
    * Probably a "Namespace" object that explicitly denotes "this is an
      imported module that you're dealing with"
    * Tests, tests, tests

Signed-off-by: Alek Ratzloff <alekratz@gmail.com>

tools/genast.py

@@ -63,7 +63,7 @@ class GenerateStruct(Generator):
         sb.line(f"impl {self.base} for {self.name}{self.base} " + "{")
         sb.indent()
         sb.line(
-            f"fn accept(&self, visitor: &mut dyn {self.base}Visitor) -> Result<(), Box<dyn std::error::Error>> "
+            f"fn accept(&self, visitor: &mut dyn {self.base}Visitor) -> Result<(), Error> "
             + "{"
         )
         sb.indent()
@@ -81,7 +81,69 @@ class GenerateStruct(Generator):
         return str(sb)
 
     def generate_visitor(self) -> str:
-        return f"fn visit_{self.name.lower()}_{self.base.lower()}(&mut self, {self.base.lower()}: &{self.name}{self.base}) -> Result<(), Box<dyn std::error::Error>>;"
+        return f"fn visit_{self.name.lower()}_{self.base.lower()}(&mut self, {self.base.lower()}: &{self.name}{self.base}) -> Result<(), Error>;"
+
+
+class GenerateEnum(Generator):
+    def __init__(
+        self, base: str, name: str, variants: list[tuple[str, str | list[str]]]
+    ):
+        self.base = base
+        self.name = name
+        self.variants = [
+            (variant, ([members] if isinstance(members, str) else members))
+            for (variant, members) in variants
+        ]
+
+    def generate_members(self) -> str:
+        sb = SB()
+        sb.line("#[derive(Debug)]")
+        sb.line(f"pub enum {self.name}{self.base} " + "{")
+        sb.indent()
+        for variant, members in self.variants:
+            sb.write(f"{variant}")
+            if members:
+                struct_like = any(":" in member for member in members)
+
+                if struct_like:
+                    sb.line(" {")
+                    sb.indent()
+                    for member in members:
+                        sb.line(f"{member},")
+                    sb.dedent()
+                    sb.line("},")
+                else:
+                    sb.write("(")
+                    sb.write(", ".join(members))
+                    sb.line("),")
+            else:
+                sb.line(",")
+        sb.dedent()
+        sb.line("}")
+        sb.line()
+
+        sb.line(f"impl {self.base} for {self.name}{self.base} " + "{")
+        sb.indent()
+        sb.line(
+            f"fn accept(&self, visitor: &mut dyn {self.base}Visitor) -> Result<(), Error> "
+            + "{"
+        )
+        sb.indent()
+        sb.line(f"visitor.visit_{self.name.lower()}_{self.base.lower()}(self)")
+
+        sb.dedent()
+        sb.line("}")
+        sb.line()
+        sb.line("fn as_any(self: Box<Self>) -> Box<dyn Any> { self }")
+        sb.line("fn as_any_ref(&self) -> &dyn Any { self }")
+
+        sb.dedent()
+        sb.write("}")
+
+        return str(sb)
+
+    def generate_visitor(self) -> str:
+        return f"fn visit_{self.name.lower()}_{self.base.lower()}(&mut self, {self.base.lower()}: &{self.name}{self.base}) -> Result<(), Error>;"
 
 
 class GenerateGroup(Generator):
@@ -95,10 +157,15 @@ class GenerateGroup(Generator):
         sb = SB()
 
         sb.line(self.generate_visitor())
+        sb.line()
         sb.line(self.generate_members())
 
         return str(sb)
 
+    def add_enum(self, name: str, variants: list[tuple[str, str | list[str]]]) -> Self:
+        self.group += [GenerateEnum(self.name, name, variants)]
+        return self
+
     def add_struct(self, name: str, rules: list[str]) -> Self:
         self.group += [GenerateStruct(self.name, name, rules)]
         return self
@@ -110,7 +177,7 @@ class GenerateGroup(Generator):
         sb.line(f"pub trait {self.name}: Debug + Any " + "{")
         sb.indent()
         sb.line(
-            f"fn accept(&self, visitor: &mut dyn {self.name}Visitor) -> Result<(), Box<dyn std::error::Error>>;"
+            f"fn accept(&self, visitor: &mut dyn {self.name}Visitor) -> Result<(), Error>;"
         )
         sb.line("fn as_any(self: Box<Self>) -> Box<dyn Any>;")
         sb.line("fn as_any_ref(&self) -> &dyn Any;")
@@ -120,13 +187,14 @@ class GenerateGroup(Generator):
 
         # Type
         sb.line(f"pub type {self.name}P = Box<dyn {self.name} + 'static>;")
+        sb.line()
 
         # All members and rules
         for g in self.group:
             sb.line(g.generate_members())
             sb.line()
 
-        return str(sb)
+        return str(sb).strip()
 
     def generate_visitor(self) -> str:
         sb = SB()
@@ -139,7 +207,7 @@ class GenerateGroup(Generator):
         sb.dedent()
         sb.line("}")
 
-        return str(sb)
+        return str(sb).strip()
 
 
 GENERATE = [
@@ -164,7 +232,7 @@ GENERATE = [
     .add_struct("List", ["lbracket: Token", "exprs: Vec<ExprP>", "rbracket: Token"]),
     # Stmt
     GenerateGroup("Stmt")
-    .add_struct("Import", ["import_kw: Token", "module: Token"])
+    .add_struct("Import", ["import_kw: Token", "what: Vec<Token>", "module: Token"])
     .add_struct("Expr", ["expr: ExprP"])
     .add_struct("Assign", ["lhs: Token", "rhs: ExprP"])
     .add_struct("Set", ["expr: ExprP", "name: Token", "rhs: ExprP"])
@@ -206,6 +274,8 @@ def main():
     sb.line()
     sb.line("use crate::token::Token;")
     sb.line()
+    sb.line("type Error = Box<dyn std::error::Error>;")
+    sb.line()
 
     for g in GENERATE:
         sb.line(g.generate())