Macros to check and return if error. (#1621)

Summary:
Pull Request resolved: #1621

.

Reviewed By: dbort

Differential Revision: D52846710

fbshipit-source-id: a8c170553e837e42e35aa68ae1c14c5f56243cb3

Author: shoumikhin

runtime/core/error.h

@@ -96,34 +96,78 @@ enum class Error : error_code_t {
 } // namespace torch
 
 /**
- * If cond__ is false, log message__ and return the Error
- * from the current function, which must be declared to return
- * torch::executor::Error
+ * If cond__ is false, log the specified message and return the specified Error
+ * from the current function, which must be of return type
+ * torch::executor::Error.
  *
- * @param[in] cond__ Condition asserted as true
- * @param[in] error__ Error enum value like `InvalidArgument`.
- * @param[in] message__ Log error message format string.
+ * @param[in] cond__ The condition to be checked, asserted as true.
+ * @param[in] error__ Error enum value to return without the `Error::` prefix,
+ * like `InvalidArgument`.
+ * @param[in] message__ Format string for the log error message.
+ * @param[in] ... Optional additional arguments for the format string.
  */
 #define ET_CHECK_OR_RETURN_ERROR(cond__, error__, message__, ...) \
-  ({                                                              \
+  {                                                               \
     if (!(cond__)) {                                              \
       ET_LOG(Error, message__, ##__VA_ARGS__);                    \
-      return torch::executor::Error::error__;                     \
+      return ::torch::executor::Error::error__;                   \
     }                                                             \
-  })
+  }
 
 /**
- * If error__ is not Error::Ok, log message__ and return the Error
- * from the current function, which must be declared to return
- * torch::executor::Error
+ * If error__ is not Error::Ok, optionally log a message and return the error
+ * from the current function, which must be of return type
+ * torch::executor::Error.
  *
  * @param[in] error__ Error enum value asserted to be Error::Ok.
- * @param[in] message__ Log error message format string.
+ * @param[in] ... Optional format string for the log error message and its
+ * arguments.
  */
-#define ET_CHECK_OK_OR_RETURN_ERROR(error__, message__, ...) \
-  ({                                                         \
-    if ((error__) != Error::Ok) {                            \
-      ET_LOG(Error, message__, ##__VA_ARGS__);               \
-      return error__;                                        \
-    }                                                        \
-  })
+#define ET_CHECK_OK_OR_RETURN_ERROR(...) \
+  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_SELECT(__VA_ARGS__, 2, 1)(__VA_ARGS__)
+
+/**
+ * Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
+ * This macro selects the correct version of
+ * ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR based on the number of arguments passed.
+ * It uses a trick with the preprocessor to count the number of arguments and
+ * then selects the appropriate macro.
+ *
+ * The macro expansion uses __VA_ARGS__ to accept any number of arguments and
+ * then appends them to ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_, followed by the
+ * count of arguments. The count is determined by the macro
+ * ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_SELECT which takes the arguments and
+ * passes them along with a sequence of numbers (2, 1). The preprocessor then
+ * matches this sequence to the correct number of arguments provided.
+ *
+ * If two arguments are passed, ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2 is
+ * selected, suitable for cases where an error code and a custom message are
+ * provided. If only one argument is passed,
+ * ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_1 is selected, which is used for cases
+ * with just an error code.
+ *
+ * Usage:
+ * ET_CHECK_OK_OR_RETURN_ERROR(error_code); // Calls v1
+ * ET_CHECK_OK_OR_RETURN_ERROR(error_code, "Error message", ...); // Calls v2
+ */
+#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_SELECT(_1, _2, N, ...) \
+  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_##N
+
+// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
+#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_1(error__) \
+  do {                                                  \
+    const auto et_error__ = (error__);                  \
+    if (et_error__ != ::torch::executor::Error::Ok) {   \
+      return et_error__;                                \
+    }                                                   \
+  } while (0)
+
+// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
+#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2(error__, message__, ...) \
+  do {                                                                  \
+    const auto et_error__ = (error__);                                  \
+    if (et_error__ != ::torch::executor::Error::Ok) {                   \
+      ET_LOG(Error, message__, ##__VA_ARGS__);                          \
+      return et_error__;                                                \
+    }                                                                   \
+  } while (0)

runtime/core/result.h

@@ -207,13 +207,13 @@ T* Result<T>::operator->() {
  *
  * Note: A function using ET_UNWRAP should itself return a Result or Error.
  *
- * @param[in] _result Expression yielding the result to unwrap.
+ * @param[in] result__ Expression yielding the result to unwrap.
  */
-#define ET_UNWRAP(_result)        \
-  ({                              \
-    auto result_recv = (_result); \
-    if (!result_recv.ok()) {      \
-      return result_recv.error(); \
-    }                             \
-    *result_recv;                 \
+#define ET_UNWRAP(result__)        \
+  ({                               \
+    auto et_result__ = (result__); \
+    if (!et_result__.ok()) {       \
+      return et_result__.error();  \
+    }                              \
+    std::move(*et_result__);       \
   })