[Heavy] Replace ResolveOp with DiscardOp

Author: ricejasonf

heavy/include/nbdl_gen/Nbdl.td

@@ -133,18 +133,6 @@ def Nbdl_GetOp : Nbdl_Op<"get", []> {
   let results   = (outs Nbdl_Type:$result);
 }
 
-def Nbdl_ResolveOp : Nbdl_Op<"resolve", [Terminator]> {
-  let description = [{
-    Finalize resolving stores by invoking the callback
-    provided in the definition of a visit function.
-    This is similar to nbdl.visit except it does not return
-    a value and terminates the block.
-  }];
-
-  let arguments = (ins Nbdl_Type:$fn, Variadic<Nbdl_Type>:$args);
-  let results   = (outs);
-}
-
 def Nbdl_MatchOp : Nbdl_Op<"match", [Terminator, NoTerminator]> {
   let summary = "match";
   let description = [{
@@ -344,6 +332,21 @@ def Nbdl_UnitOp : Nbdl_Op<"unit", []> {
   let results = (outs Nbdl_Unit:$result);
 }
 
+def Nbdl_DiscardOp : Nbdl_Op<"discard", [Terminator]> {
+  let description = [{
+    Discard the result of a nbdl.visit call.
+
+    Note:
+    This is really only used to terminate the block
+    and is the most command case for nbdl.visit.
+    I don't know that we will ever want to "return"
+    a value.
+  }];
+
+  let arguments = (ins Nbdl_Type:$arg);
+  let results   = (outs);
+}
+
 def Nbdl_VisitOp : Nbdl_Op<"visit", []> {
   let description = [{
     Call a function with resolved stores as arguments

heavy/lib/Nbdl/NbdlWriter.cpp

@@ -353,7 +353,7 @@ class FuncWriter : public NbdlWriter<FuncWriter> {
     else if (isa<OverloadOp>(Op))     return Visit(cast<OverloadOp>(Op));
     else if (isa<MemberNameOp>(Op))   return Visit(cast<MemberNameOp>(Op));
     else if (isa<GetOp>(Op))          return Visit(cast<GetOp>(Op));
-    else if (isa<ResolveOp>(Op))      return Visit(cast<ResolveOp>(Op));
+    else if (isa<DiscardOp>(Op))      return Visit(cast<DiscardOp>(Op));
     else if (isa<VisitOp>(Op))        return Visit(cast<VisitOp>(Op));
     else if (isa<NoOp>(Op))           return Visit(cast<NoOp>(Op));
     else if (isa<MatchIfOp>(Op))      return Visit(cast<MatchIfOp>(Op));
@@ -450,14 +450,8 @@ class FuncWriter : public NbdlWriter<FuncWriter> {
     OS << ");\n";
   }
 
-  void Visit(ResolveOp Op) {
-    WriteExpr(Op.getFn());
-    OS << '(';
-    llvm::interleave(Op.getArgs(), OS,
-        [&](mlir::Value V) {
-          WriteExpr(V);
-        }, ",\n");
-    OS << ");\n";
+  void Visit(DiscardOp Op) {
+    // Do nothing.
   }
 
   void Visit(ApplyActionOp Op) {

heavy/test/Nbdl/match_params.scm

@@ -10,8 +10,24 @@
 (define !nbdl.store (type "!nbdl.store"))
 (define !nbdl.tag (type "!nbdl.tag"))
 (define !nbdl.symbol (type "!nbdl.symbol"))
+(define !nbdl.unit (type "!nbdl.unit"))
 (define i32 (type "i32"))
 
+(define (resolve . args)
+  (define Result
+    (result
+      (create-op "nbdl.visit"
+                 (loc: 0)
+                 (operands: args)
+                 (attributes:)
+                 (result-types: !nbdl.unit)
+                 )))
+  (create-op "nbdl.discard"
+             (loc: 0)
+             (operands: Result)
+             (attributes:)
+             (result-types:)))
+
 (%build-match-params
   'my_match_params
   1 ; num-params
@@ -62,7 +78,7 @@
         (at-block-begin (entry-block the-match-op))
         (%build-overload 'loc "::my::first_t const&"
           (lambda (my-first)
-            (old-create-op "nbdl.resolve" (operands fn my-first))))
+            (resolve fn my-first)))
         (%build-overload 'loc "uint32_t"
           (lambda (input)
             (define pred1 (result
@@ -77,12 +93,13 @@
                          (result-types !nbdl.store))))
             (%build-match-if
               'loc input pred1
-              (lambda() (old-create-op "nbdl.resolve" (operands fn input)))
+              (lambda()
+                (resolve fn input))
               (lambda()
                 (%build-match-if
                   'loc input pred2
-                  (lambda () (old-create-op "nbdl.resolve"
-                                            (operands fn input)))
+                  (lambda()
+                    (resolve fn input))
                   (lambda ()
                     (define some-fn (result
                         (old-create-op
@@ -91,12 +108,14 @@
                             `("expr", (string-attr "::my::some_fn")))
                           (result-types !nbdl.store))))
                     (define some-fn-result
+                      ; Intermediate visit call with result as operand
+                      ; to "resolving" visit/discard.
                       (result
                         (old-create-op "nbdl.visit"
-                                   (operands some-fn input)
-                                   (result-types !nbdl.store))))
-                      (old-create-op "nbdl.resolve"
-                                     (operands fn some-fn-result))))))))
+                                       (operands some-fn input)
+                                       (result-types !nbdl.store))))
+                    (resolve fn some-fn-result)
+                    ))))))
         (%build-overload 'loc "")
         ))))