[Heavy] Generalize syntax as functions

Author: ricejasonf

heavy/include/heavy/Builtins.h

@@ -27,6 +27,8 @@
 #define HEAVY_LOAD_MODULE_VAR         "_HEAVY_load_module"
 
 #define HEAVY_BASE_VAR(NAME)          ::heavy::base_var::NAME
+#define HEAVY_BASE_VAR_STR(NAME)      HEAVY_BASE_VAR_STR__##NAME
+#define HEAVY_BASE_VAR_STR__error     HEAVY_BASE_LIB_STR "5Serror"
 
 // Forward declare vars that are used in the C++ codebase.
 namespace heavy::base_var {

heavy/include/heavy/Context.h

@@ -57,8 +57,6 @@ void write(llvm::raw_ostream&, Value);
 
 class OpEvalImpl;
 void opEval(mlir::Operation*);
-void invokeSyntaxOp(heavy::Context& C, mlir::Operation* Op,
-                    heavy::Value Value);
 
 class ContextLocalLookup {
   friend struct ContextLocal;
@@ -122,6 +120,7 @@ class Context : public ContinuationStack<Context>,
 
 public:
   heavy::OpGen* OpGen = nullptr;
+  // FIXME OpEval is not cleaned up or owned by anything.
   heavy::OpEvalImpl* OpEval = nullptr;
 
   // Work around DidCallContinuation being set with compiler errors.
@@ -153,7 +152,7 @@ class Context : public ContinuationStack<Context>,
   //           when the callee finishes or on
   //           exception so the parent loop can
   //           finish execution such as clean up.
-  Value RunSync(Value Callee, Value Arg);
+  Value RunSync(Value Callee, ValueRefs Args);
 
   void InitModule(Symbol* MangledName);
   mlir::Operation* getModuleOp();
@@ -299,8 +298,6 @@ class Context : public ContinuationStack<Context>,
     }
   }
 
-  Syntax* CreateSyntaxWithOp(mlir::Operation* SyntaxOp);
-
   Value RebuildLiteral(Value V);
 
   Heap<Context>& getAllocator() { return *this; }

heavy/include/heavy/OpGen.h

@@ -39,11 +39,16 @@ using NameSet = llvm::SmallPtrSetImpl<String*>;
 class PatternTemplate;
 class TemplateGen;
 
+template <typename Derived>
+class TemplateBase;
+
 class OpGen : public ValueVisitor<OpGen, mlir::Value> {
   friend ValueVisitor;
   friend CopyCollector;
   friend PatternTemplate;
   friend TemplateGen;
+  template <typename Derived>
+  friend class TemplateBase;
   using BindingScopeTable = llvm::ScopedHashTable<
                                             heavy::Value,
                                             mlir::Value>;
@@ -271,6 +276,8 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {
 
   mlir::Value createCall(heavy::SourceLocation Loc, mlir::Value Fn,
                          llvm::MutableArrayRef<mlir::Value> Args);
+  mlir::Value createSyntaxError(heavy::SourceLocation Loc,
+                         llvm::MutableArrayRef<mlir::Value> Args);
   mlir::Value createOpGen(SourceLocation Loc, mlir::Value Input,
                           mlir::Value Env);
   mlir::Value createBody(SourceLocation Loc, Value Body);
@@ -306,8 +313,12 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {
   mlir::Value createSet(SourceLocation Loc, Value LHS, Value RHS);
 
   mlir::Value createEqual(Value V1, Value V2); // equal? for pattern matching
+
+  heavy::LiteralOp createLiteral(heavy::SourceLocation Loc, Value V) {
+    return create<LiteralOp>(Loc, V);
+  }
   heavy::LiteralOp createLiteral(Value V) {
-    return create<LiteralOp>(V.getSourceLocation(), V);
+    return createLiteral(V.getSourceLocation(), V);
   }
 
   void createLoadModule(SourceLocation Loc, Symbol* MangledName);

heavy/include/heavy/Ops.td

@@ -200,10 +200,6 @@ def heavy_GlobalOp : HeavyOp<"global", [Symbol, IsolatedFromAbove]> {
   }];
 
   let arguments = (ins StrAttr:$sym_name);
-  let results   = (outs HeavyValue:$result);
-  let builders = [
-    OpBuilder<(ins "::llvm::StringRef":$sym_name)>
-  ];
 }
 
 def heavy_IfOp : HeavyOp<"if", []> {
@@ -441,13 +437,18 @@ def heavy_ResolveOp : HeavyOp<"resolve", [Terminator]> {
   let results   = (outs);
 }
 
-def heavy_PatternOp : HeavyOp<"pattern", [HasParent<"SyntaxOp">]> {
+def heavy_PatternOp : HeavyOp<"pattern", []> {
   let description = [{
-    PatternOp represents the pattern in a pattern/template
-    pair as part of the syntax-rules transform specifier. The
-    region should contain matching operations on the input syntax,
-    as well as ConsOps for the template, terminating with an OpGenOp
-    on the constructed AST.
+    PatternOp represents a pattern/template pair as part of the
+    syntax-rules transform specifier. Operations in its region are
+    evaluated in order. When a match operation fails within its region,
+    evaluation will jump to the successor operation of the containing
+    PatternOp (which is likely another pattern or error.)
+
+    Successfully matched patterns will likely generate and compile a
+    new scheme form via ConsOps and terminating with an OpGenOp.
+    Alternatively they may terminate with an ErrorOp in the case
+    of `syntax-error`.
   }];
 
   let arguments = (ins);
@@ -565,22 +566,22 @@ def heavy_SyntaxClosureOp : HeavyOp<"syntax_closure"> {
   ];
 }
 
-def heavy_SyntaxOp: HeavyOp<"syntax", [IsolatedFromAbove, NoTerminator]> {
+def heavy_SyntaxOp: HeavyOp<"syntax", []> {
   let summary = "syntax";
   let description = [{
-    SyntaxOp contains a linearly overloaded sequence of PatternOps that
-    operate on the input AST.
-    Any PatternOp that guarantees it cannot match can be removed.
-    Any PatternOp that guarantees a match statically can have subsequent
-    matches removed.
-    A SyntaxOp must contain at least one PatternOp.
-    Semantics are implied for chaining and failure to find a match.
+    SyntaxOp creates a syntax function object that is callable like
+    a lambda but has the specific purpose of generating new
+    operations in the current builder context.
+
+    The argument $name refers to the function name.
   }];
 
-  let regions   = (region SizedRegion<1>:$region);
-  let arguments = (ins);
-  let results   = (outs HeavySyntax:$result);
-  let builders  = [OpBuilder<(ins)>];
+  let arguments = (ins StrAttr:$name);
+  let results = (outs HeavySyntax:$result);
+
+  let builders = [
+    OpBuilder<(ins "::llvm::StringRef":$name)>
+  ];
 }
 
 def heavy_ToVectorOp : HeavyOp<"to_vector"> {

heavy/include/heavy/Value.h

@@ -1809,23 +1809,9 @@ class Environment : public ValueBase {
     return X.second == MangledName;
   }
 
-  // Insert - Add a named mutable location. Overwriting
-  //          with a new object is okay here if it is mutable
+  // Add a named location or syntax keyword.
   void Insert(Symbol* S, String* MangledName) {
-    String* Name = S->getString();
-    String*& MangleNameEntry = EnvMap[Name];
-    // FIXME This should not be an assert.
-    assert(!MangleNameEntry && "insert may not modify immutable locations");
-    MangleNameEntry = MangledName;
-  }
-
-  // SetSyntax - Extend the syntactic environment.
-  void SetSyntax(Symbol* Name, Syntax* S, String* MangledName) {
-    String*& MangledNameEntry = EnvMap[Name->getString()];
-    assert(MangledNameEntry != MangledName &&
-        "global syntax must have unique mangling");
-    // We need to associate the syntax name at compile time.
-    MangledNameEntry = MangledName;
+    EnvMap[S->getString()] = MangledName;
   }
 
   static bool classof(Value V) {

heavy/lib/Builtins.cpp

@@ -37,11 +37,13 @@ heavy::ExternBuiltinSyntax cond_expand;
 heavy::ExternBuiltinSyntax define;
 heavy::ExternBuiltinSyntax define_syntax;
 heavy::ExternBuiltinSyntax syntax_rules;
+heavy::ExternBuiltinSyntax ir_macro_transformer;
 heavy::ExternBuiltinSyntax if_;
 heavy::ExternBuiltinSyntax lambda;
 heavy::ExternBuiltinSyntax quasiquote;
 heavy::ExternBuiltinSyntax quote;
 heavy::ExternBuiltinSyntax set;
+heavy::ExternBuiltinSyntax syntax_error;
 
 
 heavy::ExternFunction add;
@@ -158,6 +160,10 @@ mlir::Value syntax_rules(OpGen& OG, Pair* P) {
                               SpecInput->Car, SpecInput->Cdr);
 }
 
+mlir::Value ir_macro_transformer(OpGen& OG, Pair* P) {
+  llvm_unreachable("TODO");
+}
+
 mlir::Value lambda(OpGen& OG, Pair* P) {
   Pair* P2 = dyn_cast<Pair>(P->Cdr);
   Value Formals = P2->Car;
@@ -203,6 +209,17 @@ mlir::Value set(OpGen& OG, Pair* P) {
   return OG.createSet(P->getSourceLocation(), S, Expr);
 }
 
+mlir::Value syntax_error(OpGen& OG, Pair* P) {
+  heavy::SourceLocation Loc = P->getSourceLocation();
+  Pair* P2 = dyn_cast<Pair>(P->Cdr);
+  if (!P2)
+    return OG.SetError("invalid syntax-error... syntax", P);
+  llvm::SmallVector<mlir::Value, 8> Args;
+  for (auto [Loc, V] : WithSource(P2))
+    Args.push_back(OG.createLiteral(Loc, V));
+  return OG.createSyntaxError(Loc, Args);
+}
+
 namespace {
   void import_helper(Context& C, ValueRefs Args) {
     if (Pair* P = dyn_cast<Pair>(Args[0])) {
@@ -869,6 +886,8 @@ void HEAVY_BASE_INIT(heavy::Context& Context) {
   HEAVY_BASE_VAR(define)          = heavy::base::define;
   HEAVY_BASE_VAR(define_syntax)   = heavy::base::define_syntax;
   HEAVY_BASE_VAR(syntax_rules)    = heavy::base::syntax_rules;
+  HEAVY_BASE_VAR(ir_macro_transformer)
+                                  = heavy::base::ir_macro_transformer;
   HEAVY_BASE_VAR(if_)             = heavy::base::if_;
   HEAVY_BASE_VAR(lambda)          = heavy::base::lambda;
   HEAVY_BASE_VAR(quasiquote)      = heavy::base::quasiquote;
@@ -952,6 +971,8 @@ void HEAVY_BASE_LOAD_MODULE(heavy::Context& Context) {
     {"quote",         HEAVY_BASE_VAR(quote)},
     {"set!",          HEAVY_BASE_VAR(set)},
     {"syntax-rules",  HEAVY_BASE_VAR(syntax_rules)},
+    {"ir-macro-transformer",
+                      HEAVY_BASE_VAR(ir_macro_transformer)},
     {"begin",         HEAVY_BASE_VAR(begin)},
     {"cond-expand",   HEAVY_BASE_VAR(cond_expand)},
     {"define-library",HEAVY_BASE_VAR(define_library)},

heavy/lib/Context.cpp

@@ -118,16 +118,6 @@ Environment* Context::getTopLevelEnvironment() {
   llvm_unreachable("EnvStack should have an Environment.");
 }
 
-Syntax* Context::CreateSyntaxWithOp(mlir::Operation* Op) {
-  auto SyntaxOp = cast<heavy::SyntaxOp>(Op);
-  auto Fn = [SyntaxOp](heavy::Context& C, ValueRefs Args) -> void {
-    heavy::Value Input = Args[0];
-    invokeSyntaxOp(C, SyntaxOp, Input);
-    // The contained OpGenOp will call C.Apply(...).
-  };
-  return CreateSyntax(Fn);
-}
-
 Module* Context::RegisterModule(llvm::StringRef MangledName,
                                 heavy::ModuleLoadNamesFn* LoadNames) {
   auto Result = Modules.try_emplace(MangledName,
@@ -1054,7 +1044,6 @@ void Context::LoadExports(heavy::Module* M, mlir::Operation* ModuleOp) {
 }
 
 // Allow the user to add cleanup routines to unload a module/library.
-// It is currently used for destroying the instance of OpEval.
 // TODO expose this via run-time function accessible in scheme land.
 void Context::PushModuleCleanup(llvm::StringRef MangledName, Value Fn) {
   std::unique_ptr<Module>& M = Modules[MangledName];
@@ -1408,15 +1397,15 @@ void Context::WithEnv(std::unique_ptr<heavy::Environment> EnvPtr,
 //           called escape procedure is complete.
 //           This is used for *nested* calls in C++ when finishing
 //           the operation on the current C++ call stack is needed.
-Value Context::RunSync(Value Callee, Value SingleArg) {
+Value Context::RunSync(Value Callee, ValueRefs Args) {
   Value CatchHandler = CreateLambda(
     [](heavy::Context& C, ValueRefs Args) {
       C.Yield(Args);
     });
   Value PrevHandlers = ExceptionHandlers;
   ExceptionHandlers = CatchHandler;
   PushBreak();
-  Apply(Callee, ValueRefs{SingleArg});
+  Apply(Callee, Args);
   Resume();
   ExceptionHandlers = PrevHandlers;
   return getCurrentResult();

heavy/lib/Dialect.cpp

@@ -115,29 +115,13 @@ void BindingOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
   BindingOp::build(B, OpState, B.getType<HeavyValueTy>(), Input);
 }
 
-#if 0
-void BuiltinOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
-                      heavy::Builtin* Builtin) {
-  // TODO eventually we need to have a "symbol" to the externally
-  //      linked function
-  BuiltinOp::build(B, OpState, B.getType<HeavyValueTy>(),
-      HeavyValueAttr::get(B.getContext(), Builtin));
-}
-#endif
-
 void ConsOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
                    mlir::Value X, mlir::Value Y) {
   mlir::Type HeavyValueT = B.getType<HeavyValueTy>();
   // TODO return type should be Pair
   ConsOp::build(B, OpState, HeavyValueT, X, Y);
 }
 
-void GlobalOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
-                     llvm::StringRef SymName) {
-  mlir::Type HeavyValueT = B.getType<HeavyValueTy>();
-  GlobalOp::build(B, OpState, HeavyValueT, SymName);
-}
-
 void IfOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
                  mlir::Value Input) {
   IfOp::build(B, OpState, B.getType<HeavyValueTy>(), Input);
@@ -251,9 +235,10 @@ void SyntaxClosureOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
   SyntaxClosureOp::build(B, OpState, HeavyValueT, Input, Env);
 }
 
-void SyntaxOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState) {
+void SyntaxOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
+                    llvm::StringRef MangledName) {
   mlir::Type HeavySyntaxT = B.getType<HeavySyntaxTy>();
-  SyntaxOp::build(B, OpState, HeavySyntaxT);
+  SyntaxOp::build(B, OpState, HeavySyntaxT, MangledName);
 }
 
 void ToVectorOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,