_exceptions.py: Align LoadError() parameter orderingtpollard/loaderror

All of the errors which subclass from BstError have their first
positional argument as message, LoadError should follow this
ordering for consistency.

5 files changed, 32 insertions, 36 deletions

diff --git a/src/buildstream/_options/optionarch.py b/src/buildstream/_options/optionarch.py
index 612ca2aa0..cbe360f9e 100644
--- a/src/buildstream/_options/optionarch.py
+++ b/src/buildstream/_options/optionarch.py
@@ -58,9 +58,8 @@ class OptionArch(OptionEnum):
                 prefix = ""
                 if provenance:
                     prefix = "{}: ".format(provenance)
-                raise LoadError(LoadErrorReason.INVALID_DATA,
-                                "{}Invalid value for {} option '{}': {}"
-                                .format(prefix, self.OPTION_TYPE, self.name, e))
+                raise LoadError("{}Invalid value for {} option '{}': {}"
+                                .format(prefix, self.OPTION_TYPE, self.name, e), LoadErrorReason.INVALID_DATA)
 
         if default_value is None:
             # Host architecture is not supported by the project.
diff --git a/src/buildstream/_options/optionbool.py b/src/buildstream/_options/optionbool.py
index 28ab71278..af67df601 100644
--- a/src/buildstream/_options/optionbool.py
+++ b/src/buildstream/_options/optionbool.py
@@ -47,8 +47,8 @@ class OptionBool(Option):
         elif value in ('False', 'false'):
             self.value = False
         else:
-            raise LoadError(LoadErrorReason.INVALID_DATA,
-                            "Invalid value for boolean option {}: {}".format(self.name, value))
+            raise LoadError("Invalid value for boolean option {}: {}".format(self.name, value),
+                            LoadErrorReason.INVALID_DATA)
 
     def get_value(self):
         if self.value:
diff --git a/src/buildstream/_options/optionenum.py b/src/buildstream/_options/optionenum.py
index 3d5053639..be9799acc 100644
--- a/src/buildstream/_options/optionenum.py
+++ b/src/buildstream/_options/optionenum.py
@@ -47,9 +47,9 @@ class OptionEnum(Option):
 
         self.values = node.get_str_list('values', default=[])
         if not self.values:
-            raise LoadError(LoadErrorReason.INVALID_DATA,
-                            "{}: No values specified for {} option '{}'"
-                            .format(node.get_provenance(), self.OPTION_TYPE, self.name))
+            raise LoadError("{}: No values specified for {} option '{}'"
+                            .format(node.get_provenance(), self.OPTION_TYPE, self.name),
+                            LoadErrorReason.INVALID_DATA,)
 
         # Allow subclass to define the default value
         self.value = self.load_default_value(node)
@@ -75,10 +75,10 @@ class OptionEnum(Option):
                 prefix = "{}: ".format(provenance)
             else:
                 prefix = ""
-            raise LoadError(LoadErrorReason.INVALID_DATA,
-                            "{}Invalid value for {} option '{}': {}\n"
+            raise LoadError("{}Invalid value for {} option '{}': {}\n"
                             .format(prefix, self.OPTION_TYPE, self.name, value) +
-                            "Valid values: {}".format(", ".join(self.values)))
+                            "Valid values: {}".format(", ".join(self.values)),
+                            LoadErrorReason.INVALID_DATA)
 
     def load_default_value(self, node):
         value_node = node.get_scalar('default')
diff --git a/src/buildstream/_options/optionflags.py b/src/buildstream/_options/optionflags.py
index 64149d28e..0ce995709 100644
--- a/src/buildstream/_options/optionflags.py
+++ b/src/buildstream/_options/optionflags.py
@@ -48,9 +48,9 @@ class OptionFlags(Option):
         # Allow subclass to define the valid values
         self.values = self.load_valid_values(node)
         if not self.values:
-            raise LoadError(LoadErrorReason.INVALID_DATA,
-                            "{}: No values specified for {} option '{}'"
-                            .format(node.get_provenance(), self.OPTION_TYPE, self.name))
+            raise LoadError("{}: No values specified for {} option '{}'"
+                            .format(node.get_provenance(), self.OPTION_TYPE, self.name),
+                            LoadErrorReason.INVALID_DATA)
 
         value_node = node.get_sequence('default', default=[])
         self.value = value_node.as_str_list()
@@ -85,10 +85,10 @@ class OptionFlags(Option):
                     prefix = "{}: ".format(provenance)
                 else:
                     prefix = ""
-                raise LoadError(LoadErrorReason.INVALID_DATA,
-                                "{}Invalid value for flags option '{}': {}\n"
+                raise LoadError("{}Invalid value for flags option '{}': {}\n"
                                 .format(prefix, self.name, value) +
-                                "Valid values: {}".format(", ".join(self.values)))
+                                "Valid values: {}".format(", ".join(self.values)),
+                                LoadErrorReason.INVALID_DATA)
 
     def load_valid_values(self, node):
         # Allow the more descriptive error to raise when no values
diff --git a/src/buildstream/_options/optionpool.py b/src/buildstream/_options/optionpool.py
index d7541530b..efafdcdce 100644
--- a/src/buildstream/_options/optionpool.py
+++ b/src/buildstream/_options/optionpool.py
@@ -75,8 +75,8 @@ class OptionPool():
                 opt_type = _OPTION_TYPES[opt_type_name]
             except KeyError:
                 p = option_definition.get_scalar('type').get_provenance()
-                raise LoadError(LoadErrorReason.INVALID_DATA,
-                                "{}: Invalid option type '{}'".format(p, opt_type_name))
+                raise LoadError("{}: Invalid option type '{}'".format(p, opt_type_name),
+                                LoadErrorReason.INVALID_DATA)
 
             option = opt_type(option_name, option_definition, self)
             self._options[option_name] = option
@@ -95,9 +95,8 @@ class OptionPool():
                 option = self._options[option_name]
             except KeyError as e:
                 p = option_value.get_provenance()
-                raise LoadError(LoadErrorReason.INVALID_DATA,
-                                "{}: Unknown option '{}' specified"
-                                .format(p, option_name)) from e
+                raise LoadError("{}: Unknown option '{}' specified"
+                                .format(p, option_name), LoadErrorReason.INVALID_DATA) from e
             option.load_value(node, transform=transform)
 
     # load_cli_values()
@@ -115,9 +114,8 @@ class OptionPool():
                 option = self._options[option_name]
             except KeyError as e:
                 if not ignore_unknown:
-                    raise LoadError(LoadErrorReason.INVALID_DATA,
-                                    "Unknown option '{}' specified on the command line"
-                                    .format(option_name)) from e
+                    raise LoadError("Unknown option '{}' specified on the command line"
+                                    .format(option_name), LoadErrorReason.INVALID_DATA) from e
             else:
                 option.set_value(option_value)
 
@@ -226,11 +224,11 @@ class OptionPool():
             elif val == "False":
                 return False
             else:  # pragma: nocover
-                raise LoadError(LoadErrorReason.EXPRESSION_FAILED,
-                                "Failed to evaluate expression: {}".format(expression))
+                raise LoadError("Failed to evaluate expression: {}".format(expression),
+                                LoadErrorReason.EXPRESSION_FAILED)
         except jinja2.exceptions.TemplateError as e:
-            raise LoadError(LoadErrorReason.EXPRESSION_FAILED,
-                            "Failed to evaluate expression ({}): {}".format(expression, e))
+            raise LoadError("Failed to evaluate expression ({}): {}".format(expression, e),
+                            LoadErrorReason.EXPRESSION_FAILED)
 
     # Recursion assistent for lists, in case there
     # are lists of lists.
@@ -257,8 +255,7 @@ class OptionPool():
         # it being overwritten by a later assertion which might also trigger.
         if assertion is not None:
             p = node.get_scalar('(!)').get_provenance()
-            raise LoadError(LoadErrorReason.USER_ASSERTION,
-                            "{}: {}".format(p, assertion.strip()))
+            raise LoadError("{}: {}".format(p, assertion.strip()), LoadErrorReason.USER_ASSERTION)
 
         if conditions is not None:
             del node['(?)']
@@ -267,8 +264,8 @@ class OptionPool():
                 tuples = list(condition.items())
                 if len(tuples) > 1:
                     provenance = condition.get_provenance()
-                    raise LoadError(LoadErrorReason.INVALID_DATA,
-                                    "{}: Conditional statement has more than one key".format(provenance))
+                    raise LoadError("{}: Conditional statement has more than one key".format(provenance),
+                                    LoadErrorReason.INVALID_DATA)
 
                 expression, value = tuples[0]
                 try:
@@ -276,12 +273,12 @@ class OptionPool():
                 except LoadError as e:
                     # Prepend the provenance of the error
                     provenance = condition.get_provenance()
-                    raise LoadError(e.reason, "{}: {}".format(provenance, e)) from e
+                    raise LoadError("{}: {}".format(provenance, e), e.reason) from e
 
                 if type(value) is not MappingNode:  # pylint: disable=unidiomatic-typecheck
                     provenance = condition.get_provenance()
-                    raise LoadError(LoadErrorReason.ILLEGAL_COMPOSITE,
-                                    "{}: Only values of type 'dict' can be composed.".format(provenance))
+                    raise LoadError("{}: Only values of type 'dict' can be composed.".format(provenance),
+                                    LoadErrorReason.ILLEGAL_COMPOSITE)
 
                 # Apply the yaml fragment if its condition evaluates to true
                 if apply_fragment: