[llvm][TableGen][Jupyter] Show llvm-tblgen not found error in notebook

[DavidSpickett]

Summary

Previously this message was only shown on the command line,
which is not much help if you can't see that.
(you've full screened the browser or you aren't running Jupyter
on the same machine)

Instead return the error as stderr which will get printed in
the notebook just like stderr from llvm-tblgen would.

I've refactored the message sending along the way. Note that
even when we do not send a stream, we still need to send the
status reply. The send_... methods will do that for you.

llvm/utils/TableGen/jupyter/tablegen_kernel/kernel.py

def __init__(self, **kwargs):
         self._previous_code = ""
         # The most recent set of magic since the last reset.
         self._previous_magic = {}
 
     @property
     def banner(self):
         return "llvm-tblgen kernel %s" % __version__
 
-    @property
-    def executable(self):
+    def get_executable(self):
         """If this is the first run, search for llvm-tblgen.
         Otherwise return the cached path to it."""
         if self._executable is None:
             path = os.environ.get("LLVM_TBLGEN_EXECUTABLE")
             if path is not None and os.path.isfile(path) and os.access(path, os.X_OK):
                 self._executable = path
             else:
                 path = shutil.which("llvm-tblgen")
                 if path is None:
-                    raise OSError("llvm-tblgen not found, please see README")
+                    raise OSError(
+                        "llvm-tblgen not found. Put it on your PATH or set the"
+                        " environment variable LLVM_TBLGEN_EXECUTABLE to point to it."
+                    )
                 self._executable = path
 
         return self._executable
 
     def get_magic(self, code):
         """Given a block of code remove the magic lines from it.
         Returns a tuple of newline joined code lines and a dictionary of magic.
         Where the key is the magic name (minus the %) and the values are lists
def get_code_and_args(self, new_code):
             self._previous_code = new_code
             self._previous_magic = new_magic
         else:
             self._previous_code += ("\n" if self._previous_code else "") + new_code
             self._previous_magic.update(new_magic)
 
         return self._previous_code, self._previous_magic.get("args", [])
 
+    def make_status(self):
+        return {
+            "status": "ok",
+            "execution_count": self.execution_count,
+            "payload": [],
+            "user_expressions": {},
+        }
+
+    def send_stream(self, name, content):
+        self.send_response(self.iopub_socket, "stream", {"name": name, "text": content})
+
+        return self.make_status()
+
+    def send_stderr(self, stderr):
+        return self.send_stream("stderr", stderr)
+
+    def send_stdout(self, stdout):
+        return self.send_stream("stdout", stdout)
+
     def do_execute(
         self, code, silent, store_history=True, user_expressions=None, allow_stdin=False
     ):
         """Execute user code using llvm-tblgen binary."""
         all_code, args = self.get_code_and_args(code)
 
+        # If we cannot find llvm-tblgen, propogate the error to the notebook.
+        # (in case the user is not able to see the output from the Jupyter server)
+        try:
+            executable = self.get_executable()
+        except Exception as e:
+            return self.send_stderr(str(e))
+
         with tempfile.TemporaryFile("w+") as f:
             f.write(all_code)
             f.seek(0)
             got = subprocess.run(
-                [self.executable, *args],
+                [executable, *args],
                 stdin=f,
                 stderr=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 universal_newlines=True,
             )
 
         if not silent:
             if got.stderr:
-                self.send_response(
-                    self.iopub_socket, "stream", {"name": "stderr", "text": got.stderr}
-                )
+                return self.send_stderr(got.stderr)
             else:
-                self.send_response(
-                    self.iopub_socket, "stream", {"name": "stdout", "text": got.stdout}
-                )
-
-        return {
-            "status": "ok",
-            "execution_count": self.execution_count,
-            "payload": [],
-            "user_expressions": {},
-        }
+                return self.send_stdout(got.stdout)
+        else:
+            return self.make_status()
 
 
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod(extraglobs={"k": TableGenKernel()})