This bookmark adds structured exceptions to astroid.

Major changes:
* AstroidError has an __init__ that accepts arbitrary keyword-only
  arguments for adding information to exceptions, and a __str__ that
  lazily uses exception attributes to generate a message.  The first
  positional argument to an exception is assigned to .message.  The new
  API should be fully backwards compatible in general.
* Some exceptions are combined or renamed; the old names are still
  available.
* The OperationErrors used by pylint are now BadOperationMessages and
  located in util.py.
* The AstroidBuildingException in _data_build stores the SyntaxError
  in its .error attribute rather than args[0].
* Many places where exceptions are raised have new, hopefully more
  useful error messages.

The only major issue remaining is how to propagate information into decorators.

6 files changed, 41 insertions, 42 deletions

diff --git a/astroid/tests/unittest_brain.py b/astroid/tests/unittest_brain.py
index 3520b49..ca47d52 100644
--- a/astroid/tests/unittest_brain.py
+++ b/astroid/tests/unittest_brain.py
@@ -134,7 +134,7 @@ class NamedTupleTest(unittest.TestCase):
         instance = next(result.infer())
         self.assertEqual(len(instance.getattr('scheme')), 1)
         self.assertEqual(len(instance.getattr('port')), 1)
-        with self.assertRaises(astroid.NotFoundError):
+        with self.assertRaises(astroid.AttributeInferenceError):
             instance.getattr('foo')
         self.assertEqual(len(instance.getattr('geturl')), 1)
         self.assertEqual(instance.name, 'ParseResult')
diff --git a/astroid/tests/unittest_builder.py b/astroid/tests/unittest_builder.py
index 84bf50c..485963b 100644
--- a/astroid/tests/unittest_builder.py
+++ b/astroid/tests/unittest_builder.py
@@ -451,7 +451,7 @@ class BuilderTest(unittest.TestCase):
         self.assertIsInstance(astroid.getattr('CSTE')[0], nodes.AssignName)
         self.assertEqual(astroid.getattr('CSTE')[0].fromlineno, 2)
         self.assertEqual(astroid.getattr('CSTE')[1].fromlineno, 6)
-        with self.assertRaises(exceptions.NotFoundError):
+        with self.assertRaises(exceptions.AttributeInferenceError):
             astroid.getattr('CSTE2')
         with self.assertRaises(exceptions.InferenceError):
             next(astroid['global_no_effect'].ilookup('CSTE2'))
diff --git a/astroid/tests/unittest_lookup.py b/astroid/tests/unittest_lookup.py
index 805efd9..7f9c43a 100644
--- a/astroid/tests/unittest_lookup.py
+++ b/astroid/tests/unittest_lookup.py
@@ -174,7 +174,7 @@ class LookupTest(resources.SysPathSetup, unittest.TestCase):
         if sys.version_info < (3, 0):
             self.assertEqual(var.inferred(), [util.YES])
         else:
-            self.assertRaises(exceptions.UnresolvableName, var.inferred)
+            self.assertRaises(exceptions.NameInferenceError, var.inferred)
 
     def test_dict_comps(self):
         astroid = builder.parse("""
@@ -210,7 +210,7 @@ class LookupTest(resources.SysPathSetup, unittest.TestCase):
             var
         """)
         var = astroid.body[1].value
-        self.assertRaises(exceptions.UnresolvableName, var.inferred)
+        self.assertRaises(exceptions.NameInferenceError, var.inferred)
 
     def test_generator_attributes(self):
         tree = builder.parse("""
@@ -250,7 +250,7 @@ class LookupTest(resources.SysPathSetup, unittest.TestCase):
         self.assertTrue(p2.getattr('__name__'))
         self.assertTrue(astroid['NoName'].getattr('__name__'))
         p3 = next(astroid['p3'].infer())
-        self.assertRaises(exceptions.NotFoundError, p3.getattr, '__name__')
+        self.assertRaises(exceptions.AttributeInferenceError, p3.getattr, '__name__')
 
     def test_function_module_special(self):
         astroid = builder.parse('''
diff --git a/astroid/tests/unittest_nodes.py b/astroid/tests/unittest_nodes.py
index ade8a92..55c7268 100644
--- a/astroid/tests/unittest_nodes.py
+++ b/astroid/tests/unittest_nodes.py
@@ -331,13 +331,13 @@ class ImportNodeTest(resources.SysPathSetup, unittest.TestCase):
         self.assertEqual(from_.real_name('NameNode'), 'Name')
         imp_ = self.module['os']
         self.assertEqual(imp_.real_name('os'), 'os')
-        self.assertRaises(exceptions.NotFoundError, imp_.real_name, 'os.path')
+        self.assertRaises(exceptions.AttributeInferenceError, imp_.real_name, 'os.path')
         imp_ = self.module['NameNode']
         self.assertEqual(imp_.real_name('NameNode'), 'Name')
-        self.assertRaises(exceptions.NotFoundError, imp_.real_name, 'Name')
+        self.assertRaises(exceptions.AttributeInferenceError, imp_.real_name, 'Name')
         imp_ = self.module2['YO']
         self.assertEqual(imp_.real_name('YO'), 'YO')
-        self.assertRaises(exceptions.NotFoundError, imp_.real_name, 'data')
+        self.assertRaises(exceptions.AttributeInferenceError, imp_.real_name, 'data')
 
     def test_as_string(self):
         ast = self.module['modutils']
@@ -502,7 +502,7 @@ class UnboundMethodNodeTest(unittest.TestCase):
         meth = A.test
         ''')
         node = next(ast['meth'].infer())
-        with self.assertRaises(exceptions.NotFoundError):
+        with self.assertRaises(exceptions.AttributeInferenceError):
             node.getattr('__missssing__')
         name = node.getattr('__name__')[0]
         self.assertIsInstance(name, nodes.Const)
diff --git a/astroid/tests/unittest_objects.py b/astroid/tests/unittest_objects.py
index e0a04d5..dc91d94 100644
--- a/astroid/tests/unittest_objects.py
+++ b/astroid/tests/unittest_objects.py
@@ -233,15 +233,15 @@ class SuperTests(unittest.TestCase):
         self.assertIsInstance(first, objects.Super)

         with self.assertRaises(exceptions.SuperError) as cm:

             first.super_mro()

-        self.assertEqual(str(cm.exception), "The first super argument must be type.")

-        for node in ast_nodes[1:]:

+        self.assertIsInstance(cm.exception.super_.mro_pointer, nodes.Const)

+        self.assertEqual(cm.exception.super_.mro_pointer.value, 1)

+        for node, invalid_type in zip(ast_nodes[1:],

+                                      (nodes.Const, bases.Instance)):

             inferred = next(node.infer())

             self.assertIsInstance(inferred, objects.Super, node)

-            with self.assertRaises(exceptions.SuperArgumentTypeError) as cm:

+            with self.assertRaises(exceptions.SuperError) as cm:

                 inferred.super_mro()

-            self.assertEqual(str(cm.exception),

-                             "super(type, obj): obj must be an instance "

-                             "or subtype of type", node)

+            self.assertIsInstance(cm.exception.super_.type, invalid_type)

 

     def test_proxied(self):

         node = test_utils.extract_node('''

@@ -338,9 +338,9 @@ class SuperTests(unittest.TestCase):
         with self.assertRaises(exceptions.InferenceError):

             next(ast_nodes[2].infer())

         fourth = next(ast_nodes[3].infer())

-        with self.assertRaises(exceptions.NotFoundError):

+        with self.assertRaises(exceptions.AttributeInferenceError):

             fourth.getattr('test3')

-        with self.assertRaises(exceptions.NotFoundError):

+        with self.assertRaises(exceptions.AttributeInferenceError):

             next(fourth.igetattr('test3'))

 

         first_unbound = next(ast_nodes[4].infer())

@@ -362,7 +362,7 @@ class SuperTests(unittest.TestCase):
                super(Super, self) #@

         ''')

         inferred = next(node.infer())

-        with self.assertRaises(exceptions.NotFoundError):

+        with self.assertRaises(exceptions.AttributeInferenceError):

             next(inferred.getattr('test'))

 

     def test_super_complex_mro(self):

@@ -491,7 +491,7 @@ class SuperTests(unittest.TestCase):
         inferred = next(node.infer())

         with self.assertRaises(exceptions.SuperError):

             inferred.super_mro()

-        with self.assertRaises(exceptions.SuperArgumentTypeError):

+        with self.assertRaises(exceptions.SuperError):

             inferred.super_mro()

 

 

diff --git a/astroid/tests/unittest_scoped_nodes.py b/astroid/tests/unittest_scoped_nodes.py
index 329aa69..47807aa 100644
--- a/astroid/tests/unittest_scoped_nodes.py
+++ b/astroid/tests/unittest_scoped_nodes.py
@@ -24,12 +24,13 @@ from functools import partial
 import unittest
 import warnings
 
+import astroid
 from astroid import builder
 from astroid import nodes
 from astroid import scoped_nodes
 from astroid import util
 from astroid.exceptions import (
-    InferenceError, NotFoundError,
+    InferenceError, AttributeInferenceError,
     NoDefault, ResolveError, MroError,
     InconsistentMroError, DuplicateBasesError,
 )
@@ -75,7 +76,7 @@ class ModuleNodeTest(ModuleLoader, unittest.TestCase):
                          os.path.abspath(resources.find('data/module.py')))
         self.assertEqual(len(self.module.getattr('__dict__')), 1)
         self.assertIsInstance(self.module.getattr('__dict__')[0], nodes.Dict)
-        self.assertRaises(NotFoundError, self.module.getattr, '__path__')
+        self.assertRaises(AttributeInferenceError, self.module.getattr, '__path__')
         self.assertEqual(len(self.pack.getattr('__path__')), 1)
         self.assertIsInstance(self.pack.getattr('__path__')[0], nodes.List)
 
@@ -101,7 +102,6 @@ class ModuleNodeTest(ModuleLoader, unittest.TestCase):
         self.assertEqual(cnx.name, 'Connection')
         self.assertEqual(cnx.root().name, 'data.SSL1.Connection1')
         self.assertEqual(len(self.nonregr.getattr('enumerate')), 2)
-        # raise ResolveError
         self.assertRaises(InferenceError, self.nonregr.igetattr, 'YOAA')
 
     def test_wildcard_import_names(self):
@@ -574,7 +574,7 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
         self.assertEqual(cls.getattr('__module__')[0].value, 'data.module')
         self.assertEqual(len(cls.getattr('__dict__')), 1)
         if not cls.newstyle:
-            self.assertRaises(NotFoundError, cls.getattr, '__mro__')
+            self.assertRaises(AttributeInferenceError, cls.getattr, '__mro__')
         for cls in (nodes.List._proxied, nodes.Const(1)._proxied):
             self.assertEqual(len(cls.getattr('__bases__')), 1)
             self.assertEqual(len(cls.getattr('__name__')), 1)
@@ -620,9 +620,9 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
 
     def test_instance_special_attributes(self):
         for inst in (Instance(self.module['YO']), nodes.List(), nodes.Const(1)):
-            self.assertRaises(NotFoundError, inst.getattr, '__mro__')
-            self.assertRaises(NotFoundError, inst.getattr, '__bases__')
-            self.assertRaises(NotFoundError, inst.getattr, '__name__')
+            self.assertRaises(AttributeInferenceError, inst.getattr, '__mro__')
+            self.assertRaises(AttributeInferenceError, inst.getattr, '__bases__')
+            self.assertRaises(AttributeInferenceError, inst.getattr, '__name__')
             self.assertEqual(len(inst.getattr('__dict__')), 1)
             self.assertEqual(len(inst.getattr('__doc__')), 1)
 
@@ -718,7 +718,7 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
         method_locals = klass2.local_attr('method')
         self.assertEqual(len(method_locals), 1)
         self.assertEqual(method_locals[0].name, 'method')
-        self.assertRaises(NotFoundError, klass2.local_attr, 'nonexistant')
+        self.assertRaises(AttributeInferenceError, klass2.local_attr, 'nonexistant')
         methods = {m.name for m in klass2.methods()}
         self.assertTrue(methods.issuperset(expected_methods))
 
@@ -1297,18 +1297,16 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
         self.assertEqualMro(astroid['E1'], ['E1', 'C1', 'B1', 'A1', 'object'])
         with self.assertRaises(InconsistentMroError) as cm:
             astroid['F1'].mro()
-        self.assertEqual(str(cm.exception),
-                         "Cannot create a consistent method resolution order "
-                         "for bases (B1, C1, A1, object), "
-                         "(C1, B1, A1, object)")
-
+        A1 = astroid.getattr('A1')[0]
+        B1 = astroid.getattr('B1')[0]
+        C1 = astroid.getattr('C1')[0]
+        object_ = builder.MANAGER.astroid_cache[BUILTINS].getattr('object')[0]
+        self.assertEqual(cm.exception.mros, [[B1, C1, A1, object_],
+                                             [C1, B1, A1, object_]])
         with self.assertRaises(InconsistentMroError) as cm:
             astroid['G1'].mro()
-        self.assertEqual(str(cm.exception),
-                         "Cannot create a consistent method resolution order "
-                         "for bases (C1, B1, A1, object), "
-                         "(B1, C1, A1, object)")
-
+        self.assertEqual(cm.exception.mros, [[C1, B1, A1, object_],
+                                             [B1, C1, A1, object_]])
         self.assertEqualMro(
             astroid['PedalWheelBoat'],
             ["PedalWheelBoat", "EngineLess",
@@ -1329,9 +1327,10 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
 
         with self.assertRaises(DuplicateBasesError) as cm:
             astroid['Duplicates'].mro()
-        self.assertEqual(str(cm.exception), "Duplicates found in the mro.")
-        self.assertTrue(issubclass(cm.exception.__class__, MroError))
-        self.assertTrue(issubclass(cm.exception.__class__, ResolveError))
+        Duplicates = astroid.getattr('Duplicates')[0]
+        self.assertEqual(cm.exception.cls, Duplicates)
+        self.assertIsInstance(cm.exception, MroError)
+        self.assertIsInstance(cm.exception, ResolveError)
 
     def test_generator_from_infer_call_result_parent(self):
         func = test_utils.extract_node("""
@@ -1357,7 +1356,7 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
         self.assertEqual(first["a"].value, 1)
         self.assertIsInstance(first["b"], nodes.Const)
         self.assertEqual(first["b"].value, 2)
-        with self.assertRaises(NotFoundError):
+        with self.assertRaises(AttributeInferenceError):
             first.getattr("missing")
 
     def test_implicit_metaclass(self):
@@ -1376,7 +1375,7 @@ class ClassNodeTest(ModuleLoader, unittest.TestCase):
         instance = cls.instanciate_class()
         func = cls.getattr('mro')
         self.assertEqual(len(func), 1)
-        self.assertRaises(NotFoundError, instance.getattr, 'mro')
+        self.assertRaises(AttributeInferenceError, instance.getattr, 'mro')
 
     def test_metaclass_lookup_using_same_class(self):
         # Check that we don't have recursive attribute access for metaclass