feature: better user feedback on common exception types

Author: zalox

src/python_interpreter.cc

@@ -67,20 +67,28 @@ Python::Interpreter::Interpreter(){
     auto module_name=it->path().stem().string();
     if(module_name!="__pycache__"){
       auto module=import(module_name);
-      if(!module)
-        std::cerr << std::string(Error()) << std::endl;
+      if(!module){
+        auto err=std::string(Error());
+        auto msg="Error loading plugin "+module_name+":\n";
+        Terminal::get().print(msg,true);
+        Terminal::get().print(err+"\n");
+      }
     }
   }
 }
 
-pybind11::module Python::Interpreter::get_loaded_module(const std::string &module_name){
+pybind11::module Python::get_loaded_module(const std::string &module_name){
   return pybind11::module(PyImport_AddModule(module_name.c_str()), true);
 }
 
-pybind11::module Python::Interpreter::import(const std::string &module_name){
+pybind11::module Python::import(const std::string &module_name){
   return pybind11::module(PyImport_ImportModule(module_name.c_str()), false);
 }
 
+pybind11::module Python::reload(pybind11::module &module){
+  return pybind11::module(PyImport_ReloadModule(module.ptr()),false);
+}
+
 void Python::Interpreter::add_path(const boost::filesystem::path &path){
   if(path.empty())
     return;
@@ -103,26 +111,54 @@ Python::Interpreter::~Interpreter(){
     std::cerr << std::string(err) << std::endl;
 }
 
+pybind11::object Python::error_occured(){
+  return pybind11::object(PyErr_Occurred(),true);
+}
+
+bool Python::thrown_exception_matches(Error::Type type){
+  pybind11::object compare;
+  switch(type){
+    case Error::Type::Syntax : compare=pybind11::object(PyExc_SyntaxError,false);
+    case Error::Type::Attribute : compare=pybind11::object(PyExc_AttributeError,false);
+    case Error::Type::Import : compare=pybind11::object(PyExc_ImportError,false);
+  }
+  return PyErr_GivenExceptionMatches(Python::error_occured().ptr(), compare.ptr());
+}
+
 Python::Error::Error(){
-  pybind11::object error(PyErr_Occurred(), false);
-  if(error){
-    PyObject *exception,*value,*traceback;
-    PyErr_Fetch(&exception,&value,&traceback);
-    PyErr_NormalizeException(&exception,&value,&traceback);
+  if(error_occured()){
     try{
-      exp=std::string(pybind11::object(exception,false).str());
-      val=std::string(pybind11::object(value,false).str());
-      trace=std::string(pybind11::object(traceback,false).str());
-    } catch (const std::runtime_error &e){
-      exp=e.what();
+      PyErr_Fetch(&exp.ptr(),&val.ptr(),&trace.ptr());
+      PyErr_NormalizeException(&exp.ptr(),&val.ptr(),&trace.ptr());
+    }catch(const std::exception &e) {
+      Terminal::get().print(e.what());
     }
   }
 }
 
 Python::Error::operator std::string(){
-  return exp + "\n" + val + "\n" + trace;
+  return std::string(exp.str())+"\n"+std::string(val.str())+"\n";
+}
+
+Python::SyntaxError::SyntaxError():Error(){
+  if(val){
+    _Py_IDENTIFIER(msg);
+    _Py_IDENTIFIER(lineno);
+    _Py_IDENTIFIER(offset);
+    _Py_IDENTIFIER(text);
+    exp=std::string(pybind11::str(_PyObject_GetAttrId(val.ptr(),&PyId_msg),false));
+    text=std::string(pybind11::str(_PyObject_GetAttrId(val.ptr(),&PyId_text),false));
+    pybind11::object py_line_number(_PyObject_GetAttrId(val.ptr(),&PyId_lineno),false);
+    pybind11::object py_line_offset(_PyObject_GetAttrId(val.ptr(),&PyId_offset),false);
+    line_number=pybind11::cast<int>(py_line_number);
+    line_offset=pybind11::cast<int>(py_line_offset);
+  }
+}
+
+Python::SyntaxError::operator std::string(){
+  return exp+" ("+std::to_string(line_number)+":"+std::to_string(line_offset)+"):\n"+text;
 }
 
 Python::Error::operator bool(){
-  return !exp.empty();
+  return exp;
 }

src/python_interpreter.h

@@ -6,28 +6,47 @@
 
 #include <iostream>
 using namespace std;
-namespace Python {
+
+class Python {
+  public:
   class Interpreter {
   private:
     Interpreter();
     ~Interpreter();
     wchar_t *argv;
+    void add_path(const boost::filesystem::path &path);
   public:
     static Interpreter& get(){
       static Interpreter singleton;
       return singleton;
     }
-    pybind11::module get_loaded_module(const std::string &module_name);
-    pybind11::module import(const std::string &module_name);
-    void add_path(const boost::filesystem::path &path);
   };
 
+  pybind11::module static get_loaded_module(const std::string &module_name);
+  pybind11::module static import(const std::string &module_name);
+  pybind11::module static reload(pybind11::module &module);
+
   class Error {
   public:
     Error();
     operator std::string();
     operator bool();
-    std::string exp, val, trace;
+    pybind11::object exp, val, trace;
+    enum Type {Syntax,Attribute,Import};
+  };
+
+  class SyntaxError : Error{
+  public:
+    SyntaxError();
+    operator std::string();
+    std::string exp, text;
+    int line_number, line_offset;
   };
-}  // namespace Python
-#endif  // JUCI_PYTHON_INTERPRETER_H_
+
+  bool static thrown_exception_matches(Error::Type exception_type);
+
+private:
+  pybind11::object static error_occured();
+};
+
+#endif  // JUCI_PYTHON_INTERPRETER_H_

src/window.cc

@@ -331,17 +331,15 @@ void Window::set_menu_actions() {
           }
           if(view->file_path>Config::get().python.plugin_directory){
             auto stem=view->file_path.stem().string();
-            auto module=Python::Interpreter::get().get_loaded_module(stem);
-            if(module){
-              auto module_new=pybind11::module(PyImport_ReloadModule(module.ptr()),false);
-              if(module_new)
-                Terminal::get().print("Python module "+stem + " has been reloaded \n");
-              else Python::Error();
-            }else{
-              Python::Error();
-              module=Python::Interpreter::get().import(stem);
-              if(module)
-                Terminal::get().print("Python module "+stem + " has been reloaded \n");
+            auto module=Python::get_loaded_module(stem);
+            module=module ? Python::reload(module) : Python::import(stem);
+            if(module)
+              Terminal::get().print("Plugin `"+stem+"` was reloaded\n");
+            else {
+              if(Python::thrown_exception_matches(Python::Error::Type::Syntax))
+                Terminal::get().print(Python::SyntaxError());
+              else
+                Terminal::get().print(Python::Error());
             }
           }
         }