diff --git a/pytype/abstract.py b/pytype/abstract.py
index 9f84677b5..9cc78865e 100644
--- a/pytype/abstract.py
+++ b/pytype/abstract.py
@@ -55,7 +55,7 @@ class AtomicAbstractValue(utils.VirtualMachineWeakrefMixin):
 
   def __init__(self, name, vm):
     """Basic initializer for all AtomicAbstractValues."""
-    super(AtomicAbstractValue, self).__init__(vm)
+    super().__init__(vm)
     assert hasattr(vm, "program"), type(self)
     self.cls = None
     self.name = name
@@ -415,7 +415,7 @@ def __new__(cls, *args, **kwargs):
     # filled by its parent. cls needs to be given its own instance.
     if not cls._instance or type(cls._instance) != cls:  # pylint: disable=unidiomatic-typecheck
       log.debug("Singleton: Making new instance for %s", cls)
-      cls._instance = super(Singleton, cls).__new__(cls)
+      cls._instance = super().__new__(cls)
     return cls._instance
 
   def get_special_attribute(self, node, name, valself):
@@ -463,14 +463,14 @@ def f():
   """
 
   def __init__(self, vm):
-    super(Empty, self).__init__("empty", vm)
+    super().__init__("empty", vm)
 
 
 class Deleted(Empty):
   """Assigned to variables that have del called on them."""
 
   def __init__(self, vm):
-    super(Deleted, self).__init__(vm)
+    super().__init__(vm)
     self.name = "deleted"
 
 
@@ -481,7 +481,7 @@ class TypeParameter(AtomicAbstractValue):
 
   def __init__(self, name, vm, constraints=(), bound=None,
                covariant=False, contravariant=False, module=None):
-    super(TypeParameter, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.constraints = constraints
     self.bound = bound
     self.covariant = covariant
@@ -553,7 +553,7 @@ class TypeParameterInstance(AtomicAbstractValue):
   """An instance of a type parameter."""
 
   def __init__(self, param, instance, vm):
-    super(TypeParameterInstance, self).__init__(param.name, vm)
+    super().__init__(param.name, vm)
     self.param = param
     self.instance = instance
     self.module = param.module
@@ -598,7 +598,7 @@ def __init__(self, name, vm):
       name: Name of this value. For debugging and error reporting.
       vm: The TypegraphVirtualMachine to use.
     """
-    super(SimpleAbstractValue, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.members = datatypes.MonitorDict()
     # Lazily loaded to handle recursive types.
     # See Instance._load_instance_type_parameters().
@@ -742,14 +742,14 @@ def get_type_key(self, seen=None):
     if key:
       type_key = frozenset(key)
     else:
-      type_key = super(SimpleAbstractValue, self).get_type_key()
+      type_key = super().get_type_key()
     self._cached_type_key = (
         (self.members.changestamp, self.instance_type_parameters.changestamp),
         type_key)
     return type_key
 
   def _unique_parameters(self):
-    parameters = super(SimpleAbstractValue, self)._unique_parameters()
+    parameters = super()._unique_parameters()
     parameters.extend(self.instance_type_parameters.values())
     return parameters
 
@@ -758,7 +758,7 @@ class Instance(SimpleAbstractValue):
   """An instance of some object."""
 
   def __init__(self, cls, vm):
-    super(Instance, self).__init__(cls.name, vm)
+    super().__init__(cls.name, vm)
     self.cls = cls
     self._instance_type_parameters_loaded = False
     cls.register_instance(self)
@@ -797,7 +797,7 @@ class List(Instance, mixin.HasSlots, mixin.PythonConstant):
   """Representation of Python 'list' objects."""
 
   def __init__(self, content, vm):
-    super(List, self).__init__(vm.convert.list_type, vm)
+    super().__init__(vm.convert.list_type, vm)
     self._instance_cache = {}
     mixin.PythonConstant.init_mixin(self, content)
     mixin.HasSlots.init_mixin(self)
@@ -819,7 +819,7 @@ def __repr__(self):
 
   def merge_instance_type_parameter(self, node, name, value):
     self.could_contain_anything = True
-    super(List, self).merge_instance_type_parameter(node, name, value)
+    super().merge_instance_type_parameter(node, name, value)
 
   def getitem_slot(self, node, index_var):
     """Implements __getitem__ for List.
@@ -918,7 +918,7 @@ def __init__(self, content, vm):
         for name, instance_param in
         tuple(enumerate(content)) + ((abstract_utils.T, combined_content),)}
     cls = TupleClass(vm.convert.tuple_type, class_params, vm)
-    super(Tuple, self).__init__(cls, vm)
+    super().__init__(cls, vm)
     self.merge_instance_type_parameter(None, abstract_utils.T, combined_content)
     mixin.PythonConstant.init_mixin(self, content)
     self.tuple_length = len(self.pyval)
@@ -932,7 +932,7 @@ def str_of_constant(self, printer):
     return "(%s)" % content
 
   def _unique_parameters(self):
-    parameters = super(Tuple, self)._unique_parameters()
+    parameters = super()._unique_parameters()
     parameters.extend(self.pyval)
     return parameters
 
@@ -963,7 +963,7 @@ class Dict(Instance, mixin.HasSlots, mixin.PythonConstant,
   """
 
   def __init__(self, vm):
-    super(Dict, self).__init__(vm.convert.dict_type, vm)
+    super().__init__(vm.convert.dict_type, vm)
     mixin.HasSlots.init_mixin(self)
     self.set_slot("__contains__", self.contains_slot)
     self.set_slot("__getitem__", self.getitem_slot)
@@ -1002,9 +1002,9 @@ def getitem_slot(self, node, name_var):
         else:
           try:
             results.append(self.pyval[name])
-          except KeyError:
+          except KeyError as e:
             unresolved = True
-            raise function.DictKeyMissing(name)
+            raise function.DictKeyMissing(name) from e
     node, ret = self.call_pytd(node, "__getitem__", name_var)
     if unresolved or self.could_contain_anything:
       # We *do* know the overall type of the values through the "V" type
@@ -1088,8 +1088,8 @@ def pop_slot(self, node, key_var, default_var=None):
     else:
       try:
         return node, self.pyval.pop(str_key)
-      except KeyError:
-        raise function.DictKeyMissing(str_key)
+      except KeyError as e:
+        raise function.DictKeyMissing(str_key) from e
 
   def update_slot(self, node, *args, **kwargs):
     posargs_handled = False
@@ -1174,7 +1174,7 @@ def __init__(self, expr, stack, vm):
     # _attribute_names needs to be defined last!
     self._attribute_names = (
         set(LateAnnotation.__dict__) |
-        set(super(LateAnnotation, self).__getattribute__("__dict__")))
+        set(super().__getattribute__("__dict__")))
 
   def __repr__(self):
     return "LateAnnotation(%r, resolved=%r)" % (
@@ -1191,7 +1191,7 @@ def __eq__(self, other):
 
   def __getattribute__(self, name):
     if name == "_attribute_names" or name in self._attribute_names:
-      return super(LateAnnotation, self).__getattribute__(name)
+      return super().__getattribute__(name)
     return self._type.__getattribute__(name)
 
   def resolve(self, node, f_globals, f_locals):
@@ -1241,7 +1241,7 @@ class AnnotationClass(SimpleAbstractValue, mixin.HasSlots):
   """Base class of annotations that can be parameterized."""
 
   def __init__(self, name, vm):
-    super(AnnotationClass, self).__init__(name, vm)
+    super().__init__(name, vm)
     mixin.HasSlots.init_mixin(self)
     self.set_slot("__getitem__", self.getitem_slot)
 
@@ -1290,7 +1290,7 @@ class AnnotationContainer(AnnotationClass):
   """Implementation of X[...] for annotations."""
 
   def __init__(self, name, vm, base_cls):
-    super(AnnotationContainer, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.base_cls = base_cls
 
   def _get_value_info(self, inner, ellipses, allowed_ellipses=frozenset()):
@@ -1402,7 +1402,7 @@ class AbstractOrConcreteValue(Instance, mixin.PythonConstant):
   """Abstract value with a concrete fallback."""
 
   def __init__(self, pyval, cls, vm):
-    super(AbstractOrConcreteValue, self).__init__(cls, vm)
+    super().__init__(cls, vm)
     mixin.PythonConstant.init_mixin(self, pyval)
 
 
@@ -1431,7 +1431,7 @@ class Union(AtomicAbstractValue, mixin.NestedAnnotation, mixin.HasSlots):
   """
 
   def __init__(self, options, vm):
-    super(Union, self).__init__("Union", vm)
+    super().__init__("Union", vm)
     assert options
     self.options = list(options)
     # TODO(rechen): Don't allow a mix of formal and non-formal types
@@ -1521,7 +1521,7 @@ class Function(SimpleAbstractValue):
   CAN_BE_ABSTRACT = True
 
   def __init__(self, name, vm):
-    super(Function, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.cls = FunctionPyTDClass(self, vm)
     self.is_attribute_of_class = False
     self.is_classmethod = False
@@ -1636,7 +1636,7 @@ class ClassMethod(AtomicAbstractValue):
   """Implements @classmethod methods in pyi."""
 
   def __init__(self, name, method, callself, vm):
-    super(ClassMethod, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.method = method
     self.method.is_attribute_of_class = True
     # Rename to callcls to make clear that callself is the cls parameter.
@@ -1658,7 +1658,7 @@ class StaticMethod(AtomicAbstractValue):
   """Implements @staticmethod methods in pyi."""
 
   def __init__(self, name, method, _, vm):
-    super(StaticMethod, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.method = method
     self.signatures = self.method.signatures
 
@@ -1677,7 +1677,7 @@ class Property(AtomicAbstractValue):
   """
 
   def __init__(self, name, method, callself, vm):
-    super(Property, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.method = method
     self._callself = callself
     self.signatures = self.method.signatures
@@ -1728,7 +1728,7 @@ def make(cls, name, vm, module, pyval=None, pyval_name=None):
     return cls(function_name, f.signatures, pyval.kind, vm)
 
   def __init__(self, name, signatures, kind, vm):
-    super(PyTDFunction, self).__init__(name, vm)
+    super().__init__(name, vm)
     assert signatures
     self.kind = kind
     self.bound_class = BoundPyTDFunction
@@ -1769,7 +1769,7 @@ def property_get(self, callself, is_class=False):
     elif self.kind == pytd.PROPERTY and not is_class:
       return Property(self.name, self, callself, self.vm)
     else:
-      return super(PyTDFunction, self).property_get(callself, is_class)
+      return super().property_get(callself, is_class)
 
   def argcount(self, _):
     return min(sig.signature.mandatory_param_count() for sig in self.signatures)
@@ -2089,7 +2089,7 @@ def __init__(self, base_cls, formal_type_parameters, vm, template=None):
     # base type is restricted to NamedType and ClassType.
     assert isinstance(base_cls, mixin.Class)
     self.base_cls = base_cls
-    super(ParameterizedClass, self).__init__(base_cls.name, vm)
+    super().__init__(base_cls.name, vm)
     self.module = base_cls.module
     # Lazily loaded to handle recursive types.
     # See the formal_type_parameters() property.
@@ -2219,7 +2219,7 @@ def instantiate(self, node, container=None):
     elif self.vm.frame and self.vm.frame.current_opcode:
       return self._new_instance().to_variable(node)
     else:
-      return super(ParameterizedClass, self).instantiate(node, container)
+      return super().instantiate(node, container)
 
   def get_class(self):
     return self.base_cls.get_class()
@@ -2286,8 +2286,7 @@ class TupleClass(ParameterizedClass, mixin.HasSlots):
   """
 
   def __init__(self, base_cls, formal_type_parameters, vm, template=None):
-    super(TupleClass, self).__init__(
-        base_cls, formal_type_parameters, vm, template)
+    super().__init__(base_cls, formal_type_parameters, vm, template)
     mixin.HasSlots.init_mixin(self)
     self.set_slot("__getitem__", self.getitem_slot)
     if isinstance(self._formal_type_parameters,
@@ -2365,7 +2364,7 @@ def get_special_attribute(self, node, name, valself):
     if (valself and not abstract_utils.equivalent_to(valself, self) and
         name in self._slots):
       return mixin.HasSlots.get_special_attribute(self, node, name, valself)
-    return super(TupleClass, self).get_special_attribute(node, name, valself)
+    return super().get_special_attribute(node, name, valself)
 
 
 class CallableClass(ParameterizedClass, mixin.HasSlots):
@@ -2381,8 +2380,7 @@ class CallableClass(ParameterizedClass, mixin.HasSlots):
   """
 
   def __init__(self, base_cls, formal_type_parameters, vm, template=None):
-    super(CallableClass, self).__init__(
-        base_cls, formal_type_parameters, vm, template)
+    super().__init__(base_cls, formal_type_parameters, vm, template)
     mixin.HasSlots.init_mixin(self)
     self.set_slot("__call__", self.call_slot)
     # We subtract two to account for "ARGS" and "RET".
@@ -2433,7 +2431,7 @@ def get_special_attribute(self, node, name, valself):
     if (valself and not abstract_utils.equivalent_to(valself, self) and
         name in self._slots):
       return mixin.HasSlots.get_special_attribute(self, node, name, valself)
-    return super(CallableClass, self).get_special_attribute(node, name, valself)
+    return super().get_special_attribute(node, name, valself)
 
 
 class LiteralClass(ParameterizedClass):
@@ -2441,8 +2439,7 @@ class LiteralClass(ParameterizedClass):
 
   def __init__(self, base_cls, instance, vm, template=None):
     formal_type_parameters = {abstract_utils.T: instance.get_class()}
-    super(LiteralClass, self).__init__(
-        base_cls, formal_type_parameters, vm, template)
+    super().__init__(base_cls, formal_type_parameters, vm, template)
     self._instance = instance
 
   def __repr__(self):
@@ -2470,7 +2467,7 @@ class PyTDClass(SimpleAbstractValue, mixin.Class):
 
   def __init__(self, name, pytd_cls, vm):
     self.pytd_cls = pytd_cls
-    super(PyTDClass, self).__init__(name, vm)
+    super().__init__(name, vm)
     mm = {}
     for val in pytd_cls.constants + pytd_cls.methods:
       mm[val.name] = val
@@ -2504,7 +2501,7 @@ def bases(self):
 
   def load_lazy_attribute(self, name):
     try:
-      super(PyTDClass, self).load_lazy_attribute(name)
+      super().load_lazy_attribute(name)
     except self.vm.convert.TypeParameterError as e:
       self.vm.errorlog.unbound_type_param(
           self.vm.frames, self, name, e.type_param_name)
@@ -2618,7 +2615,7 @@ def __init__(self, name, bases, members, cls, vm):
     assert isinstance(bases, list)
     assert isinstance(members, dict)
     self._bases = bases
-    super(InterpreterClass, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.members = datatypes.MonitorDict(members)
     mixin.Class.init_mixin(self, cls)
     self.instances = set()  # filled through register_instance
@@ -2778,7 +2775,7 @@ def instantiate(self, node, container=None):
       # When the analyze_x methods in CallTracer instantiate classes in
       # preparation for analysis, often there is no frame on the stack yet, or
       # the frame is a SimpleFrame with no opcode.
-      return super(InterpreterClass, self).instantiate(node, container)
+      return super().instantiate(node, container)
 
   def __repr__(self):
     return "InterpreterClass(%s)" % self.name
@@ -2806,7 +2803,7 @@ class NativeFunction(Function):
   """
 
   def __init__(self, name, func, vm):
-    super(NativeFunction, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.func = func
     self.bound_class = lambda callself, underlying: self
 
@@ -2820,11 +2817,11 @@ def call(self, node, _, args, alias_map=None):
                  for k, u in args.namedargs.items()}
     try:
       inspect.signature(self.func).bind(node, *posargs, **namedargs)
-    except ValueError:
+    except ValueError as e:
       # Happens for, e.g.,
       #   def f((x, y)): pass
       #   f((42,))
-      raise NotImplementedError("Wrong number of values to unpack")
+      raise NotImplementedError("Wrong number of values to unpack") from e
     except TypeError as e:
       # The possible errors here are:
       #   (1) wrong arg count
@@ -2835,7 +2832,7 @@ def call(self, node, _, args, alias_map=None):
         # Happens for, e.g.,
         #   def f(*args): pass
         #   f(x=42)
-        raise NotImplementedError("Unexpected keyword")
+        raise NotImplementedError("Unexpected keyword") from e
       # The function was passed the wrong number of arguments. The signature is
       # ([self, ]node, ...). The length of "..." tells us how many variables
       # are expected.
@@ -2873,7 +2870,7 @@ class SignedFunction(Function):
   """
 
   def __init__(self, signature, vm):
-    super(SignedFunction, self).__init__(signature.name, vm)
+    super().__init__(signature.name, vm)
     self.signature = signature
     # Track whether we've annotated `self` with `set_self_annot`, since
     # annotating `self` in `__init__` is otherwise illegal.
@@ -3106,7 +3103,7 @@ def __init__(self, name, code, f_locals, f_globals, defaults, kw_defaults,
     if self.code.co_kwonlyargcount >= 0:  # This is usually -1 or 0 (fast call)
       self.nonstararg_count += self.code.co_kwonlyargcount
     signature = self._build_signature(name, annotations)
-    super(InterpreterFunction, self).__init__(signature, vm)
+    super().__init__(signature, vm)
     self.last_frame = None  # for BuildClass
     self._store_call_records = False
     if self.vm.PY3:
@@ -3441,7 +3438,7 @@ def property_get(self, callself, is_class=False):
             self.signature.annotations[self_name],
             details="Cannot annotate self argument of __init__", name=self_name)
         self.signature.del_annotation(self_name)
-    return super(InterpreterFunction, self).property_get(callself, is_class)
+    return super().property_get(callself, is_class)
 
   def is_coroutine(self):
     return self.code.has_coroutine() or self.code.has_iterable_coroutine()
@@ -3480,7 +3477,7 @@ def __init__(self, name, param_names, varargs_name, kwonly_params,
     signature = function.Signature(name, param_names, varargs_name,
                                    kwonly_params, kwargs_name, defaults,
                                    annotations)
-    super(SimpleFunction, self).__init__(signature, vm)
+    super().__init__(signature, vm)
     self.bound_class = BoundFunction
 
   def call(self, node, _, args, alias_map=None):
@@ -3505,7 +3502,7 @@ class BoundFunction(AtomicAbstractValue):
   """An function type which has had an argument bound into it."""
 
   def __init__(self, callself, underlying):
-    super(BoundFunction, self).__init__(underlying.name, underlying.vm)
+    super().__init__(underlying.name, underlying.vm)
     self._callself = callself
     self.underlying = underlying
     self.is_attribute_of_class = False
@@ -3652,7 +3649,7 @@ class Coroutine(Instance):
   """A representation of instances of coroutine."""
 
   def __init__(self, vm, ret_var, node):
-    super(Coroutine, self).__init__(vm.convert.coroutine_type, vm)
+    super().__init__(vm.convert.coroutine_type, vm)
     self.merge_instance_type_parameter(
         node, abstract_utils.T, self.vm.new_unsolvable(node))
     self.merge_instance_type_parameter(
@@ -3677,7 +3674,7 @@ class BaseGenerator(Instance):
   """A base class of instances of generators and async generators."""
 
   def __init__(self, generator_type, frame, vm, is_return_allowed):
-    super(BaseGenerator, self).__init__(generator_type, vm)
+    super().__init__(generator_type, vm)
     self.frame = frame
     self.runs = 0
     self.is_return_allowed = is_return_allowed  # if return statement is allowed
@@ -3722,8 +3719,7 @@ class Generator(BaseGenerator):
   """A representation of instances of generators."""
 
   def __init__(self, generator_frame, vm):
-    super(Generator, self).__init__(vm.convert.generator_type,
-                                    generator_frame, vm, True)
+    super().__init__(vm.convert.generator_type, generator_frame, vm, True)
 
   def get_special_attribute(self, node, name, valself):
     if name == "__iter__":
@@ -3737,7 +3733,7 @@ def get_special_attribute(self, node, name, valself):
       # throw() to a next() (which won't be executed).
       return self.to_variable(node)
     else:
-      return super(Generator, self).get_special_attribute(node, name, valself)
+      return super().get_special_attribute(node, name, valself)
 
   def __iter__(self, node):  # pylint: disable=non-iterator-returned,unexpected-special-method-signature
     return node, self.to_variable(node)
@@ -3747,15 +3743,15 @@ class AsyncGenerator(BaseGenerator):
   """A representation of instances of async generators."""
 
   def __init__(self, async_generator_frame, vm):
-    super(AsyncGenerator, self).__init__(vm.convert.async_generator_type,
-                                         async_generator_frame, vm, False)
+    super().__init__(vm.convert.async_generator_type, async_generator_frame, vm,
+                     False)
 
 
 class Iterator(Instance, mixin.HasSlots):
   """A representation of instances of iterators."""
 
   def __init__(self, vm, return_var):
-    super(Iterator, self).__init__(vm.convert.iterator_type, vm)
+    super().__init__(vm.convert.iterator_type, vm)
     mixin.HasSlots.init_mixin(self)
     self.set_slot(self.vm.convert.next_attr, self.next_slot)
     # TODO(dbaum): Should we set instance_type_parameters[self.TYPE_PARAM] to
@@ -3772,7 +3768,7 @@ class Module(Instance):
   is_lazy = True  # uses _convert_member
 
   def __init__(self, vm, name, member_map, ast):
-    super(Module, self).__init__(vm.convert.module_type, vm)
+    super().__init__(vm.convert.module_type, vm)
     self.name = name
     self._member_map = member_map
     self.ast = ast
@@ -3857,7 +3853,7 @@ class BuildClass(AtomicAbstractValue):
   CLOSURE_NAME = "__class__"
 
   def __init__(self, vm):
-    super(BuildClass, self).__init__("__build_class__", vm)
+    super().__init__("__build_class__", vm)
 
   def call(self, node, _, args, alias_map=None):
     funcvar, name = args.posargs[0:2]
@@ -3923,7 +3919,7 @@ class Unsolvable(Singleton):
   SINGLETON = True
 
   def __init__(self, vm):
-    super(Unsolvable, self).__init__("unsolveable", vm)
+    super().__init__("unsolveable", vm)
 
   def get_special_attribute(self, node, name, _):
     # Overrides Singleton.get_special_attributes.
@@ -3956,7 +3952,7 @@ class Unknown(AtomicAbstractValue):
 
   def __init__(self, vm):
     name = "~unknown%d" % Unknown._current_id
-    super(Unknown, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.members = datatypes.MonitorDict()
     self.owner = None
     Unknown._current_id += 1
diff --git a/pytype/abstract_test.py b/pytype/abstract_test.py
index c1b15e38a..48c577a21 100644
--- a/pytype/abstract_test.py
+++ b/pytype/abstract_test.py
@@ -21,7 +21,7 @@
 class AbstractTestBase(test_base.UnitTest):
 
   def setUp(self):
-    super(AbstractTestBase, self).setUp()
+    super().setUp()
     options = config.Options.create(python_version=self.python_version)
     self._vm = vm.VirtualMachine(
         errors.ErrorLog(), options, load_pytd.Loader(None, self.python_version))
@@ -46,7 +46,7 @@ def new_dict(self, **kwargs):
 class IsInstanceTest(AbstractTestBase):
 
   def setUp(self):
-    super(IsInstanceTest, self).setUp()
+    super().setUp()
     self._is_instance = special_builtins.IsInstance.make(self._vm)
     # Easier access to some primitive instances.
     self._bool = self._vm.convert.primitive_class_instances[bool]
diff --git a/pytype/abstract_utils.py b/pytype/abstract_utils.py
index 982c8218c..e3b3d1461 100644
--- a/pytype/abstract_utils.py
+++ b/pytype/abstract_utils.py
@@ -62,7 +62,7 @@ class GenericTypeError(Exception):
   """The error for user-defined generic types."""
 
   def __init__(self, annot, error):
-    super(GenericTypeError, self).__init__(annot, error)
+    super().__init__(annot, error)
     self.annot = annot
     self.error = error
 
@@ -488,9 +488,9 @@ def compute_template(val):
         seqs.append(seq)
     try:
       template.extend(mro.MergeSequences(seqs))
-    except ValueError:
+    except ValueError as e:
       raise GenericTypeError(
-          val, "Illegal type parameter order in class %s" % val.name)
+          val, "Illegal type parameter order in class %s" % val.name) from e
 
   return template
 
diff --git a/pytype/abstract_utils_test.py b/pytype/abstract_utils_test.py
index aad2f5eca..9b8fc73e4 100644
--- a/pytype/abstract_utils_test.py
+++ b/pytype/abstract_utils_test.py
@@ -15,7 +15,7 @@
 class GetViewsTest(test_base.UnitTest):
 
   def setUp(self):
-    super(GetViewsTest, self).setUp()
+    super().setUp()
     self._vm = vm.VirtualMachine(
         errors.ErrorLog(), config.Options.create(
             python_version=self.python_version),
diff --git a/pytype/analyze.py b/pytype/analyze.py
index aeadde790..690babdeb 100644
--- a/pytype/analyze.py
+++ b/pytype/analyze.py
@@ -56,7 +56,7 @@ class CallTracer(vm.VirtualMachine):
   _CONSTRUCTORS = ("__new__", "__init__")
 
   def __init__(self, *args, **kwargs):
-    super(CallTracer, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     self._unknowns = {}
     self._builtin_map = {}
     self._calls = set()
diff --git a/pytype/attribute_test.py b/pytype/attribute_test.py
index 9f09db488..07daace8b 100644
--- a/pytype/attribute_test.py
+++ b/pytype/attribute_test.py
@@ -14,7 +14,7 @@
 class AttributeTest(test_base.UnitTest):
 
   def setUp(self):
-    super(AttributeTest, self).setUp()
+    super().setUp()
     options = config.Options.create(python_version=self.python_version)
     self._vm = vm.VirtualMachine(
         errors.ErrorLog(), options, load_pytd.Loader(None, self.python_version))
diff --git a/pytype/compare_test.py b/pytype/compare_test.py
index 32e5d8cc9..738c0380b 100644
--- a/pytype/compare_test.py
+++ b/pytype/compare_test.py
@@ -18,7 +18,7 @@
 class CompareTestBase(test_base.UnitTest):
 
   def setUp(self):
-    super(CompareTestBase, self).setUp()
+    super().setUp()
     options = config.Options.create(python_version=self.python_version)
     self._vm = vm.VirtualMachine(
         errors.ErrorLog(), options, load_pytd.Loader(None, self.python_version))
@@ -87,7 +87,7 @@ def test_compare_frozensets(self):
 class TupleTest(CompareTestBase):
 
   def setUp(self):
-    super(TupleTest, self).setUp()
+    super().setUp()
     self._var = self._program.NewVariable()
     self._var.AddBinding(abstract.Unknown(self._vm), [], self._node)
 
@@ -119,7 +119,7 @@ def test_getitem__abstract_index(self):
 class DictTest(CompareTestBase):
 
   def setUp(self):
-    super(DictTest, self).setUp()
+    super().setUp()
     self._d = abstract.Dict(self._vm)
     self._var = self._program.NewVariable()
     self._var.AddBinding(abstract.Unknown(self._vm), [], self._node)
diff --git a/pytype/config_test.py b/pytype/config_test.py
index 666299157..928411b23 100644
--- a/pytype/config_test.py
+++ b/pytype/config_test.py
@@ -92,7 +92,7 @@ def test_arg_conflicts(self):
 class PostprocessorTest(unittest.TestCase):
 
   def setUp(self):
-    super(PostprocessorTest, self).setUp()
+    super().setUp()
     self.output_options = datatypes.SimpleNamespace()
 
   def test_input(self):
diff --git a/pytype/convert.py b/pytype/convert.py
index 9281438c8..278373d0c 100644
--- a/pytype/convert.py
+++ b/pytype/convert.py
@@ -34,11 +34,11 @@ class Converter(utils.VirtualMachineWeakrefMixin):
   class TypeParameterError(Exception):
 
     def __init__(self, type_param_name):
-      super(Converter.TypeParameterError, self).__init__(type_param_name)
+      super().__init__(type_param_name)
       self.type_param_name = type_param_name
 
   def __init__(self, vm):
-    super(Converter, self).__init__(vm)
+    super().__init__(vm)
     self.vm.convert = self  # to make constant_to_value calls below work
     self.pytd_convert = output.Converter(vm)
 
diff --git a/pytype/convert_test.py b/pytype/convert_test.py
index 874f027f0..562026475 100644
--- a/pytype/convert_test.py
+++ b/pytype/convert_test.py
@@ -18,7 +18,7 @@
 class ConvertTest(test_base.UnitTest):
 
   def setUp(self):
-    super(ConvertTest, self).setUp()
+    super().setUp()
     options = config.Options.create(python_version=self.python_version)
     self._vm = vm.VirtualMachine(
         errors.ErrorLog(), options, load_pytd.Loader(None, self.python_version))
diff --git a/pytype/debug_test.py b/pytype/debug_test.py
index dfcb3de31..40cfe8668 100644
--- a/pytype/debug_test.py
+++ b/pytype/debug_test.py
@@ -29,7 +29,7 @@ def __repr__(self):
 class DebugTest(unittest.TestCase):
 
   def setUp(self):
-    super(DebugTest, self).setUp()
+    super().setUp()
     self.prog = cfg.Program()
     self.current_location = self.prog.NewCFGNode()
 
diff --git a/pytype/directors.py b/pytype/directors.py
index c24903fe4..699e49e8d 100644
--- a/pytype/directors.py
+++ b/pytype/directors.py
@@ -382,8 +382,8 @@ def _process_pytype(self, lineno, data, open_ended):
       try:
         command, values = option.split("=", 1)
         values = values.split(",")
-      except ValueError:
-        raise _DirectiveError("Invalid directive syntax.")
+      except ValueError as e:
+        raise _DirectiveError("Invalid directive syntax.") from e
       # Additional commands may be added in the future.  For now, only
       # "disable" and "enable" are supported.
       if command == "disable":
diff --git a/pytype/function.py b/pytype/function.py
index b86f336ef..51183e66d 100644
--- a/pytype/function.py
+++ b/pytype/function.py
@@ -302,8 +302,11 @@ def __new__(cls, posargs, namedargs=None, starargs=None, starstarargs=None):
     """
     assert isinstance(posargs, tuple), posargs
     cls.replace = cls._replace
-    return super(Args, cls).__new__(
-        cls, posargs=posargs, namedargs=namedargs or {}, starargs=starargs,
+    return super().__new__(
+        cls,
+        posargs=posargs,
+        namedargs=namedargs or {},
+        starargs=starargs,
         starstarargs=starstarargs)
 
   def starargs_as_tuple(self, node, vm):
@@ -374,7 +377,7 @@ class ReturnValueMixin(object):
   """Mixin for exceptions that hold a return node and variable."""
 
   def __init__(self):
-    super(ReturnValueMixin, self).__init__()
+    super().__init__()
     self.return_node = None
     self.return_variable = None
 
@@ -399,7 +402,7 @@ class NotCallable(FailedFunctionCall):
   """For objects that don't have __call__."""
 
   def __init__(self, obj):
-    super(NotCallable, self).__init__()
+    super().__init__()
     self.obj = obj
 
 
@@ -407,7 +410,7 @@ class UndefinedParameterError(FailedFunctionCall):
   """Function called with an undefined variable."""
 
   def __init__(self, name):
-    super(UndefinedParameterError, self).__init__()
+    super().__init__()
     self.name = name
 
 
@@ -415,7 +418,7 @@ class DictKeyMissing(Exception, ReturnValueMixin):
   """When retrieving a key that does not exist in a dict."""
 
   def __init__(self, name):
-    super(DictKeyMissing, self).__init__()
+    super().__init__()
     self.name = name
 
   def __gt__(self, other):
@@ -432,7 +435,7 @@ class InvalidParameters(FailedFunctionCall):
   """Exception for functions called with an incorrect parameter combination."""
 
   def __init__(self, sig, passed_args, vm, bad_param=None):
-    super(InvalidParameters, self).__init__()
+    super().__init__()
     self.name = sig.name
     passed_args = [(name, vm.merge_values(arg.data))
                    for name, arg, _ in sig.iter_args(passed_args)]
@@ -456,7 +459,7 @@ class WrongKeywordArgs(InvalidParameters):
   """E.g. an arg "x" is passed to a function that doesn't have an "x" param."""
 
   def __init__(self, sig, passed_args, vm, extra_keywords):
-    super(WrongKeywordArgs, self).__init__(sig, passed_args, vm)
+    super().__init__(sig, passed_args, vm)
     self.extra_keywords = tuple(extra_keywords)
 
 
@@ -464,7 +467,7 @@ class DuplicateKeyword(InvalidParameters):
   """E.g. an arg "x" is passed to a function as both a posarg and a kwarg."""
 
   def __init__(self, sig, passed_args, vm, duplicate):
-    super(DuplicateKeyword, self).__init__(sig, passed_args, vm)
+    super().__init__(sig, passed_args, vm)
     self.duplicate = duplicate
 
 
@@ -472,7 +475,7 @@ class MissingParameter(InvalidParameters):
   """E.g. a function requires parameter 'x' but 'x' isn't passed."""
 
   def __init__(self, sig, passed_args, vm, missing_parameter):
-    super(MissingParameter, self).__init__(sig, passed_args, vm)
+    super().__init__(sig, passed_args, vm)
     self.missing_parameter = missing_parameter
 # pylint: enable=g-bad-exception-name
 
@@ -496,7 +499,7 @@ class PyTDSignature(utils.VirtualMachineWeakrefMixin):
   """
 
   def __init__(self, name, pytd_sig, vm):
-    super(PyTDSignature, self).__init__(vm)
+    super().__init__(vm)
     self.name = name
     self.pytd_sig = pytd_sig
     self.param_types = [
diff --git a/pytype/io.py b/pytype/io.py
index ff2b4dff4..c72442410 100644
--- a/pytype/io.py
+++ b/pytype/io.py
@@ -42,8 +42,9 @@ def read_source_file(input_filename):
     else:
       with open(input_filename, "rb") as fi:
         return fi.read().decode("utf8")
-  except IOError:
-    raise utils.UsageError("Could not load input file %s" % input_filename)
+  except IOError as e:
+    raise utils.UsageError("Could not load input file %s" %
+                           input_filename) from e
 
 
 def _set_verbosity_from(posarg):
@@ -167,7 +168,7 @@ def check_or_generate_pyi(options, loader=None):
     result += "# skip-file found, file not analyzed"
   except Exception as e:  # pylint: disable=broad-except
     if options.nofail:
-      log.warn("***Caught exception: %s", str(e), exc_info=True)
+      log.warning("***Caught exception: %s", str(e), exc_info=True)
       if not options.check:
         result += (  # pytype: disable=name-error
             "# Caught error in pytype: " + str(e).replace("\n", "\n#")
@@ -246,7 +247,7 @@ def write_pickle(ast, options, loader=None):
       ast = serialize_ast.PrepareForExport(
           options.module_name,
           pytd_builtins.GetDefaultAst(options.python_version), loader)
-      log.warn("***Caught exception: %s", str(e), exc_info=True)
+      log.warning("***Caught exception: %s", str(e), exc_info=True)
     else:
       raise
   if options.verify_pickle:
@@ -319,17 +320,17 @@ def wrap_pytype_exceptions(exception_type, filename=""):
   try:
     yield
   except utils.UsageError as e:
-    raise exception_type("Pytype usage error: %s" % utils.message(e))
+    raise exception_type("Pytype usage error: %s" % utils.message(e)) from e
   except pyc.CompileError as e:
     raise exception_type("Error reading file %s at line %s: %s" %
-                         (filename, e.lineno, e.error))
+                         (filename, e.lineno, e.error)) from e
   except tokenize.TokenError as e:
     msg, (lineno, unused_column) = e.args  # pylint: disable=unbalanced-tuple-unpacking
     raise exception_type("Error reading file %s at line %s: %s" %
-                         (filename, lineno, msg))
-  except directors.SkipFileError:
+                         (filename, lineno, msg)) from e
+  except directors.SkipFileError as e:
     raise exception_type("Pytype could not analyze file %s: "
-                         "'# skip-file' directive found" % filename)
+                         "'# skip-file' directive found" % filename) from e
   except Exception as e:  # pylint: disable=broad-except
     msg = "Pytype error: %s: %s" % (e.__class__.__name__, e.args[0])
     # We need the version check here because six.reraise doesn't work properly
diff --git a/pytype/load_pytd.py b/pytype/load_pytd.py
index 8db080bf8..59cc46a69 100644
--- a/pytype/load_pytd.py
+++ b/pytype/load_pytd.py
@@ -103,7 +103,7 @@ class BadDependencyError(Exception):
 
   def __init__(self, module_error, src=None):
     referenced = ", referenced from %r" % src if src else ""
-    super(BadDependencyError, self).__init__(module_error + referenced)
+    super().__init__(module_error + referenced)
 
   def __str__(self):
     return utils.message(self)
@@ -347,7 +347,7 @@ def _resolve_external_types(self, pyval, ast_name=None):
           self._get_module_map(), self_name=name,
           module_alias_map=self._aliases))
     except KeyError as e:
-      raise BadDependencyError(utils.message(e), name)
+      raise BadDependencyError(utils.message(e), name) from e
     return pyval
 
   def _finish_pyi(self, pyval, ast=None):
@@ -359,7 +359,7 @@ def _verify_pyi(self, pyval, ast_name=None):
     try:
       pyval.Visit(visitors.VerifyLookup(ignore_late_types=True))
     except ValueError as e:
-      raise BadDependencyError(utils.message(e), ast_name or pyval.name)
+      raise BadDependencyError(utils.message(e), ast_name or pyval.name) from e
     pyval.Visit(visitors.VerifyContainers())
 
   def resolve_type(self, pyval, ast):
@@ -633,7 +633,7 @@ class PickledPyiLoader(Loader):
   """A Loader which always loads pickle instead of PYI, for speed."""
 
   def __init__(self, *args, **kwargs):
-    super(PickledPyiLoader, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
 
   @classmethod
   def load_from_pickle(cls, filename, base_module, **kwargs):
@@ -675,7 +675,7 @@ def _unpickle_module(self, module):
   def load_file(self, module_name, filename, ast=None):
     """Load (or retrieve from cache) a module and resolve its dependencies."""
     if not is_pickle(filename):
-      return super(PickledPyiLoader, self).load_file(module_name, filename, ast)
+      return super().load_file(module_name, filename, ast)
     existing = self._get_existing_ast(module_name)
     if existing:
       return existing
@@ -691,7 +691,7 @@ def load_file(self, module_name, filename, ast=None):
       ast = serialize_ast.ProcessAst(loaded_ast, self._get_module_map())
     except serialize_ast.UnrestorableDependencyError as e:
       del self._modules[module_name]
-      raise BadDependencyError(utils.message(e), module_name)
+      raise BadDependencyError(utils.message(e), module_name) from e
     # Mark all the module's late dependencies as explicitly imported.
     for d, _ in loaded_ast.late_dependencies:
       if d != loaded_ast.ast.name:
diff --git a/pytype/matcher.py b/pytype/matcher.py
index 8b0d2e5c6..0685fc666 100644
--- a/pytype/matcher.py
+++ b/pytype/matcher.py
@@ -37,7 +37,7 @@ class AbstractMatcher(utils.VirtualMachineWeakrefMixin):
   """Matcher for abstract values."""
 
   def __init__(self, vm):
-    super(AbstractMatcher, self).__init__(vm)
+    super().__init__(vm)
     self._protocol_cache = set()
 
   def _set_error_subst(self, subst):
diff --git a/pytype/matcher_test.py b/pytype/matcher_test.py
index 0cf77bd1f..28d450ede 100644
--- a/pytype/matcher_test.py
+++ b/pytype/matcher_test.py
@@ -18,7 +18,7 @@ class MatcherTest(test_base.UnitTest):
   """Test matcher.AbstractMatcher."""
 
   def setUp(self):
-    super(MatcherTest, self).setUp()
+    super().setUp()
     options = config.Options.create(python_version=self.python_version)
     self.vm = vm.VirtualMachine(
         errors.ErrorLog(), options, load_pytd.Loader(None, self.python_version))
diff --git a/pytype/metaclass.py b/pytype/metaclass.py
index 7e7cf9aaa..c99f2ae8d 100644
--- a/pytype/metaclass.py
+++ b/pytype/metaclass.py
@@ -18,7 +18,7 @@ class AddMetaclassInstance(abstract.AtomicAbstractValue):
   """AddMetaclass instance (constructed by AddMetaclass.call())."""
 
   def __init__(self, meta, vm, module_name):
-    super(AddMetaclassInstance, self).__init__("AddMetaclassInstance", vm)
+    super().__init__("AddMetaclassInstance", vm)
     self.meta = meta
     self.module_name = module_name
 
@@ -45,7 +45,7 @@ class AddMetaclass(abstract.PyTDFunction):
 
   @classmethod
   def make(cls, name, vm, module_name):
-    self = super(AddMetaclass, cls).make(name, vm, module_name)
+    self = super().make(name, vm, module_name)
     self.module_name = module_name
     return self
 
@@ -62,7 +62,7 @@ class WithMetaclassInstance(abstract.AtomicAbstractValue):
   """Anonymous class created by with_metaclass."""
 
   def __init__(self, vm, cls, bases):
-    super(WithMetaclassInstance, self).__init__("WithMetaclassInstance", vm)
+    super().__init__("WithMetaclassInstance", vm)
     self.cls = cls
     self.bases = bases
 
diff --git a/pytype/output.py b/pytype/output.py
index ba498a2fd..039ec506d 100644
--- a/pytype/output.py
+++ b/pytype/output.py
@@ -44,7 +44,7 @@ class Converter(utils.VirtualMachineWeakrefMixin):
   """Functions for converting abstract classes into PyTD."""
 
   def __init__(self, vm):
-    super(Converter, self).__init__(vm)
+    super().__init__(vm)
     self._detailed = False
 
   @contextlib.contextmanager
diff --git a/pytype/overlay.py b/pytype/overlay.py
index 4244f9330..b2fcaf4bd 100644
--- a/pytype/overlay.py
+++ b/pytype/overlay.py
@@ -38,7 +38,7 @@ def __init__(self, vm, name, member_map, ast):
         Used to access type information for members of the module that are not
         explicitly provided by the overlay.
     """
-    super(Overlay, self).__init__(vm, name, member_map, ast)
+    super().__init__(vm, name, member_map, ast)
     self.real_module = vm.convert.constant_to_value(
         ast, subst=datatypes.AliasingDict(), node=vm.root_cfg_node)
 
@@ -57,7 +57,7 @@ def get_module(self, name):
       return self.real_module
 
   def items(self):
-    items = super(Overlay, self).items()
+    items = super().items()
     items += [(name, item) for name, item in self.real_module.items()
               if name not in self._member_map]
     return items
diff --git a/pytype/overlays/abc_overlay.py b/pytype/overlays/abc_overlay.py
index 4e88f9213..6c5b76497 100644
--- a/pytype/overlays/abc_overlay.py
+++ b/pytype/overlays/abc_overlay.py
@@ -14,7 +14,7 @@ def __init__(self, vm):
         "abstractproperty": AbstractProperty
     }
     ast = vm.loader.import_name("abc")
-    super(ABCOverlay, self).__init__(vm, "abc", member_map, ast)
+    super().__init__(vm, "abc", member_map, ast)
 
 
 class AbstractMethod(abstract.PyTDFunction):
@@ -22,7 +22,7 @@ class AbstractMethod(abstract.PyTDFunction):
 
   @classmethod
   def make(cls, name, vm):
-    return super(AbstractMethod, cls).make(name, vm, "abc")
+    return super().make(name, vm, "abc")
 
   def call(self, node, unused_func, args):
     """Marks that the given function is abstract."""
@@ -45,7 +45,7 @@ class AbstractProperty(special_builtins.PropertyTemplate):
   """Implements the @abc.abstractproperty decorator."""
 
   def __init__(self, name, vm):
-    super(AbstractProperty, self).__init__(vm, name, "abc")
+    super().__init__(vm, name, "abc")
 
   def call(self, node, funcv, args):
     property_args = self._get_args(args)
diff --git a/pytype/overlays/asyncio_types_overlay.py b/pytype/overlays/asyncio_types_overlay.py
index c7107155b..8b1b92d06 100644
--- a/pytype/overlays/asyncio_types_overlay.py
+++ b/pytype/overlays/asyncio_types_overlay.py
@@ -12,7 +12,7 @@ def __init__(self, vm):
         "coroutine": CoroutineDecorator.make_for_types
     }
     ast = vm.loader.import_name("types")
-    super(TypesOverlay, self).__init__(vm, "types", member_map, ast)
+    super().__init__(vm, "types", member_map, ast)
 
 
 class AsyncioOverlay(overlay.Overlay):
@@ -23,7 +23,7 @@ def __init__(self, vm):
         "coroutine": CoroutineDecorator.make_for_asyncio
     }
     ast = vm.loader.import_name("asyncio")
-    super(AsyncioOverlay, self).__init__(vm, "asyncio", member_map, ast)
+    super().__init__(vm, "asyncio", member_map, ast)
 
 
 class CoroutineDecorator(abstract.PyTDFunction):
@@ -31,11 +31,11 @@ class CoroutineDecorator(abstract.PyTDFunction):
 
   @classmethod
   def make_for_types(cls, name, vm):
-    return super(CoroutineDecorator, cls).make(name, vm, "types")
+    return super().make(name, vm, "types")
 
   @classmethod
   def make_for_asyncio(cls, name, vm):
-    return super(CoroutineDecorator, cls).make(name, vm, "asyncio")
+    return super().make(name, vm, "asyncio")
 
   def call(self, node, unused_func, args):
     """Marks the function as a generator-based coroutine."""
diff --git a/pytype/overlays/attr_overlay.py b/pytype/overlays/attr_overlay.py
index b535ecbad..88b6213cf 100644
--- a/pytype/overlays/attr_overlay.py
+++ b/pytype/overlays/attr_overlay.py
@@ -30,7 +30,7 @@ def __init__(self, vm):
         "Factory": Factory.make,
     }
     ast = vm.loader.import_name("attr")
-    super(AttrOverlay, self).__init__(vm, "attr", member_map, ast)
+    super().__init__(vm, "attr", member_map, ast)
 
 
 class Attrs(classgen.Decorator):
@@ -38,7 +38,7 @@ class Attrs(classgen.Decorator):
 
   @classmethod
   def make(cls, name, vm):
-    return super(Attrs, cls).make(name, vm, "attr")
+    return super().make(name, vm, "attr")
 
   def init_name(self, attr):
     # attrs removes leading underscores from attrib names when generating kwargs
@@ -114,7 +114,7 @@ class AttribInstance(abstract.SimpleAbstractValue, mixin.HasSlots):
   """Return value of an attr.ib() call."""
 
   def __init__(self, vm, typ, has_type, init, kw_only, default):
-    super(AttribInstance, self).__init__("attrib", vm)
+    super().__init__("attrib", vm)
     mixin.HasSlots.init_mixin(self)
     self.typ = typ
     self.has_type = has_type
@@ -164,7 +164,7 @@ class Attrib(classgen.FieldConstructor):
 
   @classmethod
   def make(cls, name, vm):
-    return super(Attrib, cls).make(name, vm, "attr")
+    return super().make(name, vm, "attr")
 
   def call(self, node, unused_func, args):
     """Returns a type corresponding to an attr."""
@@ -228,4 +228,4 @@ class Factory(abstract.PyTDFunction):
 
   @classmethod
   def make(cls, name, vm):
-    return super(Factory, cls).make(name, vm, "attr")
+    return super().make(name, vm, "attr")
diff --git a/pytype/overlays/classgen.py b/pytype/overlays/classgen.py
index c8cbe3f90..bcab37108 100644
--- a/pytype/overlays/classgen.py
+++ b/pytype/overlays/classgen.py
@@ -12,7 +12,6 @@
 from pytype import mixin
 from pytype import overlay_utils
 from pytype import special_builtins
-import six
 
 
 log = logging.getLogger(__name__)
@@ -66,8 +65,7 @@ def __repr__(self):
                 "default": self.default})
 
 
-@six.add_metaclass(abc.ABCMeta)
-class Decorator(abstract.PyTDFunction):
+class Decorator(abstract.PyTDFunction, metaclass=abc.ABCMeta):
   """Base class for decorators that generate classes from data declarations."""
 
   # Defaults for the args that we support (dataclasses only support 'init',
@@ -79,7 +77,7 @@ class Decorator(abstract.PyTDFunction):
   }
 
   def __init__(self, *args, **kwargs):
-    super(Decorator, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     # Decorator.call() is invoked first with args, then with the class to
     # decorate, so we need to first store the args and then associate them to
     # the right class.
diff --git a/pytype/overlays/collections_overlay.py b/pytype/overlays/collections_overlay.py
index 356fecaf3..135c133d4 100644
--- a/pytype/overlays/collections_overlay.py
+++ b/pytype/overlays/collections_overlay.py
@@ -88,7 +88,7 @@ def __init__(self, vm):
     # collections_overlay contains all the members that have special definitions
     member_map = collections_overlay.copy()
     ast = vm.loader.import_name("collections")
-    super(CollectionsOverlay, self).__init__(vm, "collections", member_map, ast)
+    super().__init__(vm, "collections", member_map, ast)
 
 
 class NamedTupleBuilder(abstract.PyTDFunction):
@@ -101,8 +101,7 @@ def make(cls, name, vm, pyval=None):
     # Subclasses of NamedTupleBuilder need a different pyval.
     if not pyval:
       pyval = collections_ast.Lookup("collections.namedtuple")
-    self = super(NamedTupleBuilder, cls).make(
-        name, vm, "collections", pyval=pyval)
+    self = super().make(name, vm, "collections", pyval=pyval)
     self.collections_ast = collections_ast
     return self
 
diff --git a/pytype/overlays/dataclass_overlay.py b/pytype/overlays/dataclass_overlay.py
index 415f8f1df..ce3473fe3 100644
--- a/pytype/overlays/dataclass_overlay.py
+++ b/pytype/overlays/dataclass_overlay.py
@@ -27,7 +27,7 @@ def __init__(self, vm):
         "field": Field.make,
     }
     ast = vm.loader.import_name("dataclasses")
-    super(DataclassOverlay, self).__init__(vm, "dataclasses", member_map, ast)
+    super().__init__(vm, "dataclasses", member_map, ast)
 
 
 class Dataclass(classgen.Decorator):
@@ -35,7 +35,7 @@ class Dataclass(classgen.Decorator):
 
   @classmethod
   def make(cls, name, vm, mod="dataclasses"):
-    return super(Dataclass, cls).make(name, vm, mod)
+    return super().make(name, vm, mod)
 
   def _handle_initvar(self, node, cls, name, typ, orig):
     """Unpack or delete an initvar in the class annotations."""
@@ -114,7 +114,7 @@ class FieldInstance(abstract.SimpleAbstractValue):
   """Return value of a field() call."""
 
   def __init__(self, vm, init, default):
-    super(FieldInstance, self).__init__("field", vm)
+    super().__init__("field", vm)
     self.init = init
     self.default = default
     self.cls = vm.convert.unsolvable
@@ -125,7 +125,7 @@ class Field(classgen.FieldConstructor):
 
   @classmethod
   def make(cls, name, vm):
-    return super(Field, cls).make(name, vm, "dataclasses")
+    return super().make(name, vm, "dataclasses")
 
   def call(self, node, unused_func, args):
     """Returns a type corresponding to a field."""
diff --git a/pytype/overlays/flax_overlay.py b/pytype/overlays/flax_overlay.py
index a88c19267..ae28ac6f8 100644
--- a/pytype/overlays/flax_overlay.py
+++ b/pytype/overlays/flax_overlay.py
@@ -23,7 +23,7 @@ def __init__(self, vm):
         "dataclass": Dataclass.make,
     }
     ast = vm.loader.import_name("flax.struct")
-    super(DataclassOverlay, self).__init__(vm, "flax.struct", member_map, ast)
+    super().__init__(vm, "flax.struct", member_map, ast)
 
 
 class Dataclass(dataclass_overlay.Dataclass):
@@ -31,4 +31,4 @@ class Dataclass(dataclass_overlay.Dataclass):
 
   @classmethod
   def make(cls, name, vm):
-    return super(Dataclass, cls).make(name, vm, "flax.struct")
+    return super().make(name, vm, "flax.struct")
diff --git a/pytype/overlays/future_overlay.py b/pytype/overlays/future_overlay.py
index 0e568b8b5..31d9490cd 100644
--- a/pytype/overlays/future_overlay.py
+++ b/pytype/overlays/future_overlay.py
@@ -12,8 +12,7 @@ def __init__(self, vm):
         "with_metaclass": build_with_metaclass,
     }
     ast = vm.loader.import_name("future.utils")
-    super(FutureUtilsOverlay, self).__init__(vm, "future.utils", member_map,
-                                             ast)
+    super().__init__(vm, "future.utils", member_map, ast)
 
 
 def build_with_metaclass(name, vm):
diff --git a/pytype/overlays/six_overlay.py b/pytype/overlays/six_overlay.py
index 44bedc600..01c8cf261 100644
--- a/pytype/overlays/six_overlay.py
+++ b/pytype/overlays/six_overlay.py
@@ -17,7 +17,7 @@ def __init__(self, vm):
         "PY3": build_version_bool(3),
     }
     ast = vm.loader.import_name("six")
-    super(SixOverlay, self).__init__(vm, "six", member_map, ast)
+    super().__init__(vm, "six", member_map, ast)
 
 
 def build_add_metaclass(name, vm):
diff --git a/pytype/overlays/subprocess_overlay.py b/pytype/overlays/subprocess_overlay.py
index 61aca6b5b..e87f333f4 100644
--- a/pytype/overlays/subprocess_overlay.py
+++ b/pytype/overlays/subprocess_overlay.py
@@ -13,7 +13,7 @@ def __init__(self, vm):
         "Popen": Popen,
     }
     ast = vm.loader.import_name("subprocess")
-    super(SubprocessOverlay, self).__init__(vm, "subprocess", member_map, ast)
+    super().__init__(vm, "subprocess", member_map, ast)
 
 
 class Popen(abstract.PyTDClass):
@@ -23,7 +23,7 @@ class Popen(abstract.PyTDClass):
 
   def __init__(self, name, vm):
     pyval = vm.loader.import_name("subprocess").Lookup("subprocess.Popen")
-    super(Popen, self).__init__(name, pyval, vm)
+    super().__init__(name, pyval, vm)
     # lazily loaded because the signatures refer back to Popen itself
     self._new = self._UNLOADED
 
@@ -43,7 +43,7 @@ def new(self):
   def get_own_new(self, node, value):
     if self.new:
       return node, self.new.to_variable(node)
-    return super(Popen, self).get_own_new(node, value)
+    return super().get_own_new(node, value)
 
 
 class PopenNew(abstract.PyTDFunction):
@@ -85,7 +85,7 @@ def _yield_matching_signatures(self, node, args, view, alias_map):
       if sig is None:
         sig = self._match_bytes_mode(args, view)
     if sig is None:
-      for sig_info in super(PopenNew, self)._yield_matching_signatures(
+      for sig_info in super()._yield_matching_signatures(
           node, args, view, alias_map):
         yield sig_info
       return
diff --git a/pytype/overlays/sys_overlay.py b/pytype/overlays/sys_overlay.py
index 3070b8960..f1cb279b3 100644
--- a/pytype/overlays/sys_overlay.py
+++ b/pytype/overlays/sys_overlay.py
@@ -12,7 +12,7 @@ def __init__(self, vm):
         "version_info": build_version_info
     }
     ast = vm.loader.import_name("sys")
-    super(SysOverlay, self).__init__(vm, "sys", member_map, ast)
+    super().__init__(vm, "sys", member_map, ast)
 
 
 class VersionInfo(abstract.Tuple):
diff --git a/pytype/overlays/typing_overlay.py b/pytype/overlays/typing_overlay.py
index fa9ba7924..214f5dad0 100644
--- a/pytype/overlays/typing_overlay.py
+++ b/pytype/overlays/typing_overlay.py
@@ -36,14 +36,14 @@ def __init__(self, vm):
       _, name = cls.name.rsplit(".", 1)
       if name not in member_map and pytd.IsContainer(cls) and cls.template:
         member_map[name] = TypingContainer
-    super(TypingOverlay, self).__init__(vm, "typing", member_map, ast)
+    super().__init__(vm, "typing", member_map, ast)
 
 
 class Union(abstract.AnnotationClass):
   """Implementation of typing.Union[...]."""
 
   def __init__(self, name, vm, options=()):
-    super(Union, self).__init__(name, vm)
+    super().__init__(name, vm)
     self.options = options
 
   def _build_value(self, node, inner, ellipses):
@@ -59,7 +59,7 @@ def __init__(self, name, vm):
     else:
       pytd_name = "typing." + name
     base = vm.convert.name_to_value(pytd_name)
-    super(TypingContainer, self).__init__(name, vm, base)
+    super().__init__(name, vm, base)
 
 
 class Tuple(TypingContainer):
@@ -69,7 +69,7 @@ def _get_value_info(self, inner, ellipses):
     if ellipses:
       # An ellipsis may appear at the end of the parameter list as long as it is
       # not the only parameter.
-      return super(Tuple, self)._get_value_info(
+      return super()._get_value_info(
           inner, ellipses, allowed_ellipses={len(inner) - 1} - {0})
     else:
       template = list(moves.range(len(inner))) + [abstract_utils.T]
@@ -109,15 +109,14 @@ def _get_value_info(self, inner, ellipses):
       return template, inner, abstract.CallableClass
     else:
       # An ellipsis may take the place of the ARGS list.
-      return super(Callable, self)._get_value_info(
-          inner, ellipses, allowed_ellipses={0})
+      return super()._get_value_info(inner, ellipses, allowed_ellipses={0})
 
 
 class TypeVarError(Exception):
   """Raised if an error is encountered while initializing a TypeVar."""
 
   def __init__(self, message, bad_call=None):
-    super(TypeVarError, self).__init__(message)
+    super().__init__(message)
     self.bad_call = bad_call
 
 
@@ -127,9 +126,10 @@ class TypeVar(abstract.PyTDFunction):
   def _get_constant(self, var, name, arg_type, arg_type_desc=None):
     try:
       ret = abstract_utils.get_atomic_python_constant(var, arg_type)
-    except abstract_utils.ConversionError:
-      raise TypeVarError("%s must be %s" % (
-          name, arg_type_desc or "a constant " + arg_type.__name__))
+    except abstract_utils.ConversionError as e:
+      raise TypeVarError(
+          "%s must be %s" %
+          (name, arg_type_desc or "a constant " + arg_type.__name__)) from e
     return ret
 
   def _get_annotation(self, node, var, name):
@@ -157,11 +157,11 @@ def _get_typeparam(self, node, args):
     try:
       self.match_args(node, args)
     except function.InvalidParameters as e:
-      raise TypeVarError("wrong arguments", e.bad_call)
-    except function.FailedFunctionCall:
+      raise TypeVarError("wrong arguments", e.bad_call) from e
+    except function.FailedFunctionCall as e:
       # It is currently impossible to get here, since the only
       # FailedFunctionCall that is not an InvalidParameters is NotCallable.
-      raise TypeVarError("initialization failed")
+      raise TypeVarError("initialization failed") from e
     name = self._get_constant(args.posargs[0], "name", six.string_types,
                               arg_type_desc="a constant str")
     constraints = tuple(
@@ -207,14 +207,14 @@ def call(self, node, func, args):
             self.vm.frames, "cannot pass a TypeVar to a function")
         return node, self.vm.new_unsolvable(node)
       return self.vm.init_class(node, annot)
-    return super(Cast, self).call(node, func, args)
+    return super().call(node, func, args)
 
 
 class NoReturn(abstract.Singleton):
   """Implements typing.NoReturn as a singleton."""
 
   def __init__(self, vm):
-    super(NoReturn, self).__init__("NoReturn", vm)
+    super().__init__("NoReturn", vm)
 
 
 def build_any(name, vm):
@@ -233,7 +233,7 @@ def make(cls, name, vm):
     # error messages will correctly display "typing.NamedTuple".
     pyval = typing_ast.Lookup("typing._NamedTuple")
     pyval = pyval.Replace(name="typing.NamedTuple")
-    self = super(NamedTupleFuncBuilder, cls).make(name, vm, pyval)
+    self = super().make(name, vm, pyval)
     # NamedTuple's fields arg has type Sequence[Sequence[Union[str, type]]],
     # which doesn't provide precise enough type-checking, so we have to do
     # some of our own in _getargs. _NamedTupleFields is an alias to
@@ -482,7 +482,7 @@ def __init__(self, name, vm):
     typing_ast = vm.loader.import_name("typing")
     pyval = typing_ast.Lookup("typing._NamedTupleClass")
     pyval = pyval.Replace(name="typing.NamedTuple")
-    super(NamedTupleClassBuilder, self).__init__(name, pyval, vm)
+    super().__init__(name, pyval, vm)
     # Prior to python 3.6, NamedTuple is a function. Although NamedTuple is a
     # class in python 3.6+, we can still use it like a function. Hold the
     # an instance of 'NamedTupleFuncBuilder' so that we can reuse the
@@ -571,7 +571,7 @@ class NewType(abstract.PyTDFunction):
   """Implementation of typing.NewType as a function."""
 
   def __init__(self, name, signatures, kind, vm):
-    super(NewType, self).__init__(name, signatures, kind, vm)
+    super().__init__(name, signatures, kind, vm)
     assert len(self.signatures) == 1, "NewType has more than one signature."
     signature = self.signatures[0].signature
     self._name_arg_name = signature.param_names[0]
diff --git a/pytype/pyc/loadmarshal.py b/pytype/pyc/loadmarshal.py
index e297b25c2..083672e1e 100644
--- a/pytype/pyc/loadmarshal.py
+++ b/pytype/pyc/loadmarshal.py
@@ -162,10 +162,10 @@ def load(self):
       else:
         result = _LoadMarshal.dispatch[c](self)
       return result
-    except KeyError:
-      raise ValueError('bad marshal code: %r (%02x)' % (chr(c), c))
-    except IndexError:
-      raise EOFError
+    except KeyError as e:
+      raise ValueError('bad marshal code: %r (%02x)' % (chr(c), c)) from e
+    except IndexError as e:
+      raise EOFError() from e
 
   def _read(self, n):
     """Read n bytes as a string."""
diff --git a/pytype/pyc/opcodes.py b/pytype/pyc/opcodes.py
index 780009398..85839e247 100644
--- a/pytype/pyc/opcodes.py
+++ b/pytype/pyc/opcodes.py
@@ -138,7 +138,7 @@ class OpcodeWithArg(Opcode):
   __slots__ = ("arg", "pretty_arg")
 
   def __init__(self, index, line, arg, pretty_arg):
-    super(OpcodeWithArg, self).__init__(index, line)
+    super().__init__(index, line)
     self.arg = arg
     self.pretty_arg = pretty_arg
 
diff --git a/pytype/pyc/pyc.py b/pytype/pyc/pyc.py
index fdc474ea7..f596f104b 100644
--- a/pytype/pyc/pyc.py
+++ b/pytype/pyc/pyc.py
@@ -23,7 +23,7 @@ class CompileError(Exception):
   """A compilation error."""
 
   def __init__(self, msg):
-    super(CompileError, self).__init__(msg)
+    super().__init__(msg)
     match = COMPILE_ERROR_RE.match(msg)
     if match:
       self.error = match.group(1)
diff --git a/pytype/pytd/parse/preconditions_test.py b/pytype/pytd/parse/preconditions_test.py
index d72da89d3..146b07e6e 100644
--- a/pytype/pytd/parse/preconditions_test.py
+++ b/pytype/pytd/parse/preconditions_test.py
@@ -70,7 +70,7 @@ def test_is_instance_precondition(self):
 class CallCheckerTest(unittest.TestCase):
 
   def setUp(self):
-    super(CallCheckerTest, self).setUp()
+    super().setUp()
     self.checker = preconditions.CallChecker([
         ("x", preconditions._ClassNamePrecondition("int")),
         ("s", preconditions._ClassNamePrecondition("str"))])
diff --git a/pytype/pytd/pytd_test.py b/pytype/pytd/pytd_test.py
index d1b02c4bd..039161b38 100644
--- a/pytype/pytd/pytd_test.py
+++ b/pytype/pytd/pytd_test.py
@@ -12,7 +12,7 @@ class TestPytd(unittest.TestCase):
   """Test the simple functionality in pytd.py."""
 
   def setUp(self):
-    super(TestPytd, self).setUp()
+    super().setUp()
     self.int = pytd.ClassType("int")
     self.none_type = pytd.ClassType("NoneType")
     self.float = pytd.ClassType("float")
diff --git a/pytype/pytd/serialize_ast.py b/pytype/pytd/serialize_ast.py
index 21b3bd3a6..bcf42034b 100644
--- a/pytype/pytd/serialize_ast.py
+++ b/pytype/pytd/serialize_ast.py
@@ -22,7 +22,7 @@ class FindClassAndFunctionTypesVisitor(visitors.Visitor):
   """Visitor to find class and function types."""
 
   def __init__(self):
-    super(FindClassAndFunctionTypesVisitor, self).__init__()
+    super().__init__()
     self.class_type_nodes = []
     self.function_type_nodes = []
 
diff --git a/pytype/pytd/serialize_ast_test.py b/pytype/pytd/serialize_ast_test.py
index a58d73302..556e76242 100644
--- a/pytype/pytd/serialize_ast_test.py
+++ b/pytype/pytd/serialize_ast_test.py
@@ -117,7 +117,7 @@ def test_unrestorable_child(self):
     class RenameVisitor(visitors.Visitor):
 
       def __init__(self, *args, **kwargs):
-        super(RenameVisitor, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self._init = False
 
       def EnterFunction(self, func):
diff --git a/pytype/pytd/type_match_test.py b/pytype/pytd/type_match_test.py
index 1bbd9785e..75a523353 100644
--- a/pytype/pytd/type_match_test.py
+++ b/pytype/pytd/type_match_test.py
@@ -38,7 +38,7 @@ class TestTypeMatch(parser_test_base.ParserTest):
   """Test algorithms and datastructures of booleq.py."""
 
   def setUp(self):
-    super(TestTypeMatch, self).setUp()
+    super().setUp()
     builtins = parser.parse_string(textwrap.dedent(_BUILTINS),
                                    name="__builtin__",
                                    python_version=self.python_version)
@@ -331,10 +331,10 @@ class `~unknown0`():
     tup = ast.Lookup("x").type
     m = type_match.TypeMatch(type_match.get_all_subclasses([ast]))
     match = m.match_Unknown_against_Generic(unk, tup, {})
-    self.assertListEqual(sorted(match.extract_equalities()),
-                         [("~unknown0", "__builtin__.tuple"),
-                          ("~unknown0.__builtin__.tuple._T", "int"),
-                          ("~unknown0.__builtin__.tuple._T", "str")])
+    self.assertCountEqual(sorted(match.extract_equalities()),
+                          [("~unknown0", "__builtin__.tuple"),
+                           ("~unknown0.__builtin__.tuple._T", "int"),
+                           ("~unknown0.__builtin__.tuple._T", "str")])
 
   def test_function_against_tuple_subclass(self):
     ast = self.ParseWithBuiltins("""
diff --git a/pytype/pytd/typeshed_test.py b/pytype/pytd/typeshed_test.py
index 6aff946b6..a1a59f334 100644
--- a/pytype/pytd/typeshed_test.py
+++ b/pytype/pytd/typeshed_test.py
@@ -12,7 +12,7 @@ class TestTypeshedLoading(parser_test_base.ParserTest):
   """Test the code for loading files from typeshed."""
 
   def setUp(self):
-    super(TestTypeshedLoading, self).setUp()
+    super().setUp()
     self.ts = typeshed.Typeshed()
 
   def test_get_typeshed_file(self):
@@ -95,7 +95,7 @@ class TestTypeshedParsing(test_base.TargetPython27FeatureTest):
   """
 
   def setUp(self):
-    super(TestTypeshedParsing, self).setUp()
+    super().setUp()
     self.ConfigureOptions(module_name="base")
 
   def test_quopri(self):
diff --git a/pytype/pytype_source_utils_test.py b/pytype/pytype_source_utils_test.py
index fd8ee4f3d..390985513 100644
--- a/pytype/pytype_source_utils_test.py
+++ b/pytype/pytype_source_utils_test.py
@@ -13,7 +13,7 @@ class PytypeSourceUtilsTest(unittest.TestCase):
   """Test pytype source utilities."""
 
   def setUp(self):
-    super(PytypeSourceUtilsTest, self).setUp()
+    super().setUp()
     self.root = os.path.dirname(__file__)
 
   def test_pytype_source_dir(self):
diff --git a/pytype/single_test.py b/pytype/single_test.py
index ff6085e5b..312253547 100644
--- a/pytype/single_test.py
+++ b/pytype/single_test.py
@@ -29,17 +29,17 @@ class PytypeTest(test_base.UnitTest):
 
   @classmethod
   def setUpClass(cls):
-    super(PytypeTest, cls).setUpClass()
+    super().setUpClass()
     cls.pytype_dir = os.path.dirname(os.path.dirname(parser.__file__))
 
   def setUp(self):
-    super(PytypeTest, self).setUp()
+    super().setUp()
     self._reset_pytype_args()
     self.tmp_dir = tempfile.mkdtemp()
     self.errors_csv = os.path.join(self.tmp_dir, "errors.csv")
 
   def tearDown(self):
-    super(PytypeTest, self).tearDown()
+    super().tearDown()
     shutil.rmtree(self.tmp_dir)
 
   def _reset_pytype_args(self):
diff --git a/pytype/special_builtins.py b/pytype/special_builtins.py
index 78b54ee30..7efb829f6 100644
--- a/pytype/special_builtins.py
+++ b/pytype/special_builtins.py
@@ -40,7 +40,7 @@ def call(self, node, func, args):
       # bound to a class or function, so we'll go with Any.
       self.match_args(node, args)  # May raise FailedFunctionCall.
       return node, self.vm.new_unsolvable(node)
-    node, raw_ret = super(TypeNew, self).call(node, func, args)
+    node, raw_ret = super().call(node, func, args)
     # Removes TypeVars from the return value.
     # See test_typevar.TypeVarTest.test_type_of_typevar(_error).
     ret = self.vm.program.NewVariable()
@@ -58,7 +58,7 @@ class BuiltinFunction(abstract.PyTDFunction):
   @classmethod
   def make(cls, vm):
     assert cls.name
-    return super(BuiltinFunction, cls).make(cls.name, vm, "__builtin__")
+    return super().make(cls.name, vm, "__builtin__")
 
   def get_underlying_method(self, node, receiver, method_name):
     """Get the bound method that a built-in function delegates to."""
@@ -167,7 +167,7 @@ def _filter_none(self, data, node):
   def call(self, node, func, args):
     self.match_args(node, args)
     if len(args.posargs) != 2:
-      return super(Filter, self).call(node, func, args)
+      return super().call(node, func, args)
     pred, seq = args.posargs
     # Special case filter(None, seq). We remove None from seq and then call the
     # regular filter() so we don't need to reimplement eveything.
@@ -180,7 +180,7 @@ def call(self, node, func, args):
         else:
           result.PasteBinding(b)
       args = function.Args((pred, result))
-    return super(Filter, self).call(node, func, args)
+    return super().call(node, func, args)
 
 
 class ObjectPredicate(BuiltinFunction):
@@ -191,7 +191,7 @@ class ObjectPredicate(BuiltinFunction):
   """
 
   def __init__(self, name, signatures, kind, vm):
-    super(ObjectPredicate, self).__init__(name, signatures, kind, vm)
+    super().__init__(name, signatures, kind, vm)
     # Map of True/False/None (where None signals an ambiguous bool) to
     # vm values.
     self._vm_values = {
@@ -436,7 +436,7 @@ def __init__(self, vm, name, module="__builtin__"):
     else:
       ast = vm.loader.import_name(module)
       pytd_cls = ast.Lookup("%s.%s" % (module, name))
-    super(BuiltinClass, self).__init__(name, pytd_cls, vm)
+    super().__init__(name, pytd_cls, vm)
     self.module = module
 
 
@@ -444,7 +444,7 @@ class SuperInstance(abstract.AtomicAbstractValue):
   """The result of a super() call, i.e., a lookup proxy."""
 
   def __init__(self, cls, obj, vm):
-    super(SuperInstance, self).__init__("super", vm)
+    super().__init__("super", vm)
     self.cls = self.vm.convert.super_type
     self.super_cls = cls
     self.super_obj = obj
@@ -475,8 +475,7 @@ def get_special_attribute(self, node, name, valself):
       # superclass, fall back to returning self.
       return self.get.to_variable(node)
     else:
-      return super(SuperInstance, self).get_special_attribute(
-          node, name, valself)
+      return super().get_special_attribute(node, name, valself)
 
   def get_class(self):
     return self.cls
@@ -493,7 +492,7 @@ class Super(BuiltinClass):
   _SIGNATURE = function.Signature.from_param_names("super", ("cls", "self"))
 
   def __init__(self, vm):
-    super(Super, self).__init__(vm, "super")
+    super().__init__(vm, "super")
 
   def call(self, node, _, args):
     result = self.vm.program.NewVariable()
@@ -544,7 +543,7 @@ class Object(BuiltinClass):
   """Implementation of __builtin__.object."""
 
   def __init__(self, vm):
-    super(Object, self).__init__(vm, "object")
+    super().__init__(vm, "object")
 
   def is_object_new(self, func):
     """Whether the given function is object.__new__.
@@ -596,14 +595,14 @@ def get_special_attribute(self, node, name, valself):
             self._has_own(node, val.cls, "__new__")):
         self.load_lazy_attribute("__init__extra_args")
         return self.members["__init__extra_args"]
-    return super(Object, self).get_special_attribute(node, name, valself)
+    return super().get_special_attribute(node, name, valself)
 
 
 class RevealType(abstract.AtomicAbstractValue):
   """For debugging. reveal_type(x) prints the type of "x"."""
 
   def __init__(self, vm):
-    super(RevealType, self).__init__("reveal_type", vm)
+    super().__init__("reveal_type", vm)
 
   def call(self, node, _, args):
     for a in args.posargs:
@@ -617,7 +616,7 @@ class PropertyTemplate(BuiltinClass):
   _KEYS = ["fget", "fset", "fdel", "doc"]
 
   def __init__(self, vm, name, module="__builtin__"):  # pylint: disable=useless-super-delegation
-    super(PropertyTemplate, self).__init__(vm, name, module)
+    super().__init__(vm, name, module)
 
   def signature(self):
     # Minimal signature, only used for constructing exceptions.
@@ -641,7 +640,7 @@ class PropertyInstance(abstract.SimpleAbstractValue, mixin.HasSlots):
   CAN_BE_ABSTRACT = True
 
   def __init__(self, vm, name, cls, fget=None, fset=None, fdel=None, doc=None):
-    super(PropertyInstance, self).__init__("property", vm)
+    super().__init__("property", vm)
     mixin.HasSlots.init_mixin(self)
     self.name = name  # Reports the correct decorator in error messages.
     self.fget = fget
@@ -699,7 +698,7 @@ class Property(PropertyTemplate):
   """Property method decorator."""
 
   def __init__(self, vm):
-    super(Property, self).__init__(vm, "property")
+    super().__init__(vm, "property")
 
   def call(self, node, funcv, args):
     property_args = self._get_args(args)
@@ -711,7 +710,7 @@ class StaticMethodInstance(abstract.SimpleAbstractValue, mixin.HasSlots):
   """StaticMethod instance (constructed by StaticMethod.call())."""
 
   def __init__(self, vm, cls, func):
-    super(StaticMethodInstance, self).__init__("staticmethod", vm)
+    super().__init__("staticmethod", vm)
     mixin.HasSlots.init_mixin(self)
     self.func = func
     self.cls = cls
@@ -731,7 +730,7 @@ class StaticMethod(BuiltinClass):
   _SIGNATURE = function.Signature.from_param_names("staticmethod", ("func",))
 
   def __init__(self, vm):
-    super(StaticMethod, self).__init__(vm, "staticmethod")
+    super().__init__(vm, "staticmethod")
 
   def call(self, node, funcv, args):
     if len(args.posargs) != 1:
@@ -748,7 +747,7 @@ class ClassMethodInstance(abstract.SimpleAbstractValue, mixin.HasSlots):
   """ClassMethod instance (constructed by ClassMethod.call())."""
 
   def __init__(self, vm, cls, func):
-    super(ClassMethodInstance, self).__init__("classmethod", vm)
+    super().__init__("classmethod", vm)
     mixin.HasSlots.init_mixin(self)
     self.cls = cls
     self.func = func
@@ -768,7 +767,7 @@ class ClassMethod(BuiltinClass):
   _SIGNATURE = function.Signature.from_param_names("classmethod", ("func",))
 
   def __init__(self, vm):
-    super(ClassMethod, self).__init__(vm, "classmethod")
+    super().__init__(vm, "classmethod")
 
   def call(self, node, funcv, args):
     if len(args.posargs) != 1:
diff --git a/pytype/state.py b/pytype/state.py
index 42ed05ec0..d1b8ebb13 100644
--- a/pytype/state.py
+++ b/pytype/state.py
@@ -23,7 +23,7 @@ class FrameState(utils.VirtualMachineWeakrefMixin):
   __slots__ = ["block_stack", "data_stack", "node", "exception", "why"]
 
   def __init__(self, data_stack, block_stack, node, vm, exception, why):
-    super(FrameState, self).__init__(vm)
+    super().__init__(vm)
     self.data_stack = data_stack
     self.block_stack = block_stack
     self.node = node
@@ -250,7 +250,7 @@ def __init__(self, node, vm, f_code, f_globals, f_locals, f_back, callargs,
     Raises:
       NameError: If we can't resolve any references into the outer frame.
     """
-    super(Frame, self).__init__(vm)
+    super().__init__(vm)
     assert isinstance(f_globals, abstract.LazyConcreteDict)
     assert isinstance(f_locals, abstract.LazyConcreteDict)
     self.node = node
diff --git a/pytype/state_test.py b/pytype/state_test.py
index f963ee097..43eba4dd7 100644
--- a/pytype/state_test.py
+++ b/pytype/state_test.py
@@ -42,14 +42,14 @@ def fake_compatible_with(value, logical_value):
 class ConditionTestBase(unittest.TestCase):
 
   def setUp(self):
-    super(ConditionTestBase, self).setUp()
+    super().setUp()
     self._program = cfg.Program()
     self._node = self._program.NewCFGNode("test")
     self._old_compatible_with = compare.compatible_with
     compare.compatible_with = fake_compatible_with
 
   def tearDown(self):
-    super(ConditionTestBase, self).tearDown()
+    super().tearDown()
     compare.compatible_with = self._old_compatible_with
 
   def new_binding(self, value=AMBIGUOUS):
@@ -103,7 +103,7 @@ def test(self):
 class RestrictConditionTest(ConditionTestBase):
 
   def setUp(self):
-    super(RestrictConditionTest, self).setUp()
+    super().setUp()
     p = self.new_binding()
     self._parent = state.Condition(self._node, [[p]])
 
diff --git a/pytype/tests/test_base.py b/pytype/tests/test_base.py
index e016881f5..a9b01419e 100644
--- a/pytype/tests/test_base.py
+++ b/pytype/tests/test_base.py
@@ -98,7 +98,7 @@ class BaseTest(unittest.TestCase):
 
   @classmethod
   def setUpClass(cls):
-    super(BaseTest, cls).setUpClass()
+    super().setUpClass()
     # We use class-wide loader to avoid creating a new loader for every test
     # method if not required.
     cls._loader = None
@@ -155,7 +155,7 @@ def t(name):  # pylint: disable=invalid-name
                                                 (cls.nothing, cls.nothing))
 
   def setUp(self):
-    super(BaseTest, self).setUp()
+    super().setUp()
     self.options = config.Options.create(python_version=self.python_version,
                                          check_attribute_types=True,
                                          check_container_types=True,
diff --git a/pytype/tests/test_functions.py b/pytype/tests/test_functions.py
index b21f37646..22a0ed9a8 100644
--- a/pytype/tests/test_functions.py
+++ b/pytype/tests/test_functions.py
@@ -199,7 +199,7 @@ class PreciseReturnTest(test_base.TargetIndependentTest):
   """Tests for --precise-return."""
 
   def setUp(self):
-    super(PreciseReturnTest, self).setUp()
+    super().setUp()
     self.options.tweak(precise_return=True)
 
   def test_pytd_return(self):
diff --git a/pytype/tests/test_utils.py b/pytype/tests/test_utils.py
index 6a545c271..48a18e779 100644
--- a/pytype/tests/test_utils.py
+++ b/pytype/tests/test_utils.py
@@ -199,7 +199,7 @@ class TestErrorLog(errors.ErrorLog):
   ERROR_RE = re.compile(r"^(?P<code>(\w+-)+\w+)(\[(?P<mark>.+)\])?$")
 
   def __init__(self, src):
-    super(TestErrorLog, self).__init__()
+    super().__init__()
     self.marks = None  # set by assert_errors_match_expected()
     self.expected = self._parse_comments(src)
 
diff --git a/pytype/tools/analyze_project/environment.py b/pytype/tools/analyze_project/environment.py
index 43ba792c0..c8f123175 100644
--- a/pytype/tools/analyze_project/environment.py
+++ b/pytype/tools/analyze_project/environment.py
@@ -10,7 +10,7 @@ class PytdFileSystem(fs.ExtensionRemappingFileSystem):
   """File system that remaps .py file extensions to pytd."""
 
   def __init__(self, underlying):
-    super(PytdFileSystem, self).__init__(underlying, 'pytd')
+    super().__init__(underlying, 'pytd')
 
 
 def create_importlab_environment(conf, typeshed):
diff --git a/pytype/tools/analyze_project/pytype_runner_test.py b/pytype/tools/analyze_project/pytype_runner_test.py
index f3599b608..7b5bb65d8 100644
--- a/pytype/tools/analyze_project/pytype_runner_test.py
+++ b/pytype/tools/analyze_project/pytype_runner_test.py
@@ -69,7 +69,7 @@ class TestDepsFromImportGraph(unittest.TestCase):
   """Test deps_from_import_graph."""
 
   def setUp(self):
-    super(TestDepsFromImportGraph, self).setUp()
+    super().setUp()
     init = ImportlabModule('/foo/bar/__init__.py', 'bar/__init__.py', 'bar')
     a = ImportlabModule('/foo/bar/a.py', 'bar/a.py', 'bar.a')
     b = ImportlabModule('/foo/bar/b.py', 'bar/b.py', 'bar.b')
@@ -132,7 +132,7 @@ class TestBase(unittest.TestCase):
 
   @classmethod
   def setUpClass(cls):
-    super(TestBase, cls).setUpClass()
+    super().setUpClass()
     cls.parser = parse_args.make_parser()
 
 
@@ -140,7 +140,7 @@ class TestCustomOptions(TestBase):
   """Test PytypeRunner.set_custom_options."""
 
   def setUp(self):
-    super(TestCustomOptions, self).setUp()
+    super().setUp()
     self.conf = self.parser.config_from_defaults()
 
   # --disable tests a flag with a string value.
@@ -210,7 +210,7 @@ class TestGetRunCmd(TestBase):
   """Test PytypeRunner.get_pytype_command_for_ninja()."""
 
   def setUp(self):
-    super(TestGetRunCmd, self).setUp()
+    super().setUp()
     self.runner = make_runner([], [], self.parser.config_from_defaults())
 
   def get_options(self, args):
@@ -458,7 +458,7 @@ class TestNinjaBody(TestBase):
   """Test PytypeRunner.setup_build."""
 
   def setUp(self):
-    super(TestNinjaBody, self).setUp()
+    super().setUp()
     self.conf = self.parser.config_from_defaults()
 
   def assertBuildStatementMatches(self, build_statement, expected):
@@ -600,7 +600,7 @@ class TestImports(TestBase):
   """Test imports-related functionality."""
 
   def setUp(self):
-    super(TestImports, self).setUp()
+    super().setUp()
     self.conf = self.parser.config_from_defaults()
 
   def test_write_default_pyi(self):
diff --git a/pytype/tools/merge_pyi/merge_pyi.py b/pytype/tools/merge_pyi/merge_pyi.py
index 4d1bee60c..960b6308b 100644
--- a/pytype/tools/merge_pyi/merge_pyi.py
+++ b/pytype/tools/merge_pyi/merge_pyi.py
@@ -541,7 +541,7 @@ class FixMergePyi(BaseFix):
   PATTERN = FuncSignature.PATTERN
 
   def __init__(self, options, log):
-    super(FixMergePyi, self).__init__(options, log)
+    super().__init__(options, log)
 
     # name -> FuncSignature map obtained from .pyi file
     self.pyi_funcs = None
@@ -893,7 +893,7 @@ class StandaloneRefactoringTool(refactor.RefactoringTool):
 
   def __init__(self, options):
     self._fixer = None
-    super(StandaloneRefactoringTool, self).__init__([], options=options)
+    super().__init__([], options=options)
 
   def get_fixers(self):
     if self.fixer.order == 'pre':
diff --git a/pytype/tools/traces/traces.py b/pytype/tools/traces/traces.py
index 8c4efcd99..75d325289 100644
--- a/pytype/tools/traces/traces.py
+++ b/pytype/tools/traces/traces.py
@@ -1,4 +1,4 @@
-# Lint as: python2, python3
+# Lint as: python3
 """A library for accessing pytype's inferred local types."""
 
 import itertools
@@ -146,7 +146,7 @@ class MatchAstVisitor(visitor.BaseVisitor):
   """
 
   def __init__(self, src_code, *args, **kwargs):
-    super(MatchAstVisitor, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     self.source = src_code
     # In Python versions before 3.7, there is a mismatch between where the ast
     # and bytecode representations think some nodes are located, so we manually
@@ -184,8 +184,8 @@ def match(self, node):
     method = "match_" + node.__class__.__name__
     try:
       match = getattr(self, method)
-    except AttributeError:
-      raise NotImplementedError(method)
+    except AttributeError as e:
+      raise NotImplementedError(method) from e
     return match(node)
 
   def match_Attribute(self, node):
@@ -341,7 +341,7 @@ def _match_import(self, node, is_from):
 class _LineNumberVisitor(visitor.BaseVisitor):
 
   def __init__(self, *args, **kwargs):
-    super(_LineNumberVisitor, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     self.line = 0
 
   def generic_visit(self, node):
diff --git a/pytype/tools/traces/traces_test.py b/pytype/tools/traces/traces_test.py
index fa489a61b..2baaf3f83 100644
--- a/pytype/tools/traces/traces_test.py
+++ b/pytype/tools/traces/traces_test.py
@@ -1,4 +1,4 @@
-# Lint as: python2, python3
+# Lint as: python3
 """Tests for traces.traces."""
 
 import ast
@@ -23,7 +23,7 @@ def visit_Module(self, node):
 class _TestVisitor(traces.MatchAstVisitor):
 
   def __init__(self, *args, **kwargs):
-    super(_TestVisitor, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     self.traces_by_node_type = collections.defaultdict(list)
 
   def generic_visit(self, node):
@@ -41,7 +41,7 @@ def test_traces(self):
     src = traces.trace("")
     trace, = src.traces[1]
     self.assertEqual(trace.op, "LOAD_CONST")
-    self.assertEqual(trace.symbol, None)
+    self.assertIsNone(trace.symbol)
     pyval, = trace.types
     self.assertEqual(pyval.name, "__builtin__.NoneType")
     self.assertEqual(pyval.cls.name, "__builtin__.NoneType")
diff --git a/pytype/tools/traces/visitor_test.py b/pytype/tools/traces/visitor_test.py
index 3862d1845..72850adc6 100644
--- a/pytype/tools/traces/visitor_test.py
+++ b/pytype/tools/traces/visitor_test.py
@@ -1,4 +1,4 @@
-# Lint as: python2, python3
+# Lint as: python3
 """Tests for traces.visitor."""
 
 import ast
@@ -12,7 +12,7 @@ class _VisitOrderVisitor(visitor.BaseVisitor):
   """Tests visit order."""
 
   def __init__(self, *args, **kwargs):
-    super(_VisitOrderVisitor, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     self.funcs = []
 
   def visit_FunctionDef(self, node):
@@ -35,7 +35,7 @@ class _GenericVisitVisitor(visitor.BaseVisitor):
   """Tests generic_visit()."""
 
   def __init__(self, *args, **kwargs):
-    super(_GenericVisitVisitor, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     self.nodes = []
 
   def generic_visit(self, node):
@@ -46,7 +46,7 @@ class _EnterVisitor(visitor.BaseVisitor):
   """Tests enter() by recording names."""
 
   def __init__(self, *args, **kwargs):
-    super(_EnterVisitor, self).__init__(*args, **kwargs)
+    super().__init__(*args, **kwargs)
     self.names = []
 
   def enter_Name(self, node):
diff --git a/pytype/tools/xref/indexer.py b/pytype/tools/xref/indexer.py
index c81f760fd..2e1091b3f 100644
--- a/pytype/tools/xref/indexer.py
+++ b/pytype/tools/xref/indexer.py
@@ -446,7 +446,7 @@ class CollectNamesVisitor(ast_visitor.BaseVisitor):
   """Collect all occurences of Name in a subtree."""
 
   def __init__(self, ast):
-    super(CollectNamesVisitor, self).__init__(ast)
+    super().__init__(ast)
     self.names = []
 
   def visit_Name(self, node):
@@ -467,7 +467,7 @@ class ScopedVisitor(ast_visitor.BaseVisitor):
   # anything by way of maintainability or readability?
 
   def __init__(self, ast, module_name, **kwargs):
-    super(ScopedVisitor, self).__init__(ast=ast, **kwargs)  # pytype: disable=wrong-keyword-args
+    super().__init__(ast=ast, **kwargs)  # pytype: disable=wrong-keyword-args
     self.stack = []
     self.class_ids = []
     self.envs = {}
@@ -533,12 +533,12 @@ def enter_FunctionDef(self, node):
     self.add_scope(node)
 
   def enter_Module(self, node):
-    super(ScopedVisitor, self).enter_Module(node)  # pytype: disable=attribute-error
+    super().enter_Module(node)  # pytype: disable=attribute-error
     self.add_scope(node)
 
   def leave(self, node):
     """If the node has introduced a new scope, we need to pop it off."""
-    super(ScopedVisitor, self).leave(node)
+    super().leave(node)
     if node == self.stack[-1]:
       self.stack.pop()
 
@@ -547,9 +547,7 @@ class IndexVisitor(ScopedVisitor, traces.MatchAstVisitor):
   """Visitor that generates indexes."""
 
   def __init__(self, ast, src, module_name):
-    super(IndexVisitor, self).__init__(ast=ast,
-                                       src_code=src,
-                                       module_name=module_name)
+    super().__init__(ast=ast, src_code=src, module_name=module_name)
     self.defs = {}
     self.locs = collections.defaultdict(list)
     self.refs = []
@@ -589,7 +587,7 @@ def _get_node_name(self, node):
     if isinstance(node, str):
       # We replace nodes with their names after visiting them.
       return node
-    return super(IndexVisitor, self)._get_node_name(node)
+    return super()._get_node_name(node)
 
   def make_def(self, node, **kwargs):
     """Make a definition from a node."""
@@ -717,7 +715,7 @@ def enter_ClassDef(self, node):
     defn = self.add_local_def(node, data=data,
                               doc=DocString.from_node(self._ast, node))
     self.classmap[d[0]] = defn
-    super(IndexVisitor, self).enter_ClassDef(node)
+    super().enter_ClassDef(node)
 
   def enter_FunctionDef(self, node):
     last_line = max(node.lineno, node.body[0].lineno - 1)
@@ -1237,7 +1235,7 @@ def __repr__(self):
     types_repr = tuple(
         t and [node_utils.typename(x) for x in t]
         for t in self.types)
-    return "%s %s" % (super(VmTrace, self).__repr__(), types_repr)
+    return "%s %s" % (super().__repr__(), types_repr)
 
 
 def process_file(options, source_text=None, generate_callgraphs=False,
diff --git a/pytype/tools/xref/indexer_test.py b/pytype/tools/xref/indexer_test.py
index 4396c4c77..936ce7a72 100644
--- a/pytype/tools/xref/indexer_test.py
+++ b/pytype/tools/xref/indexer_test.py
@@ -258,12 +258,12 @@ class IndexerTestPy3(test_base.TargetPython3BasicTest, IndexerTestMixin):
   def index_code(self, code, *args, **kwargs):
     if utils.USE_ANNOTATIONS_BACKPORT and self.python_version == (2, 7):
       code = test_base.WithAnnotationsImport(code)
-    return super(IndexerTestPy3, self).index_code(code, *args, **kwargs)
+    return super().index_code(code, *args, **kwargs)
 
   def assertDefLocs(self, index, fqname, locs):
     if utils.USE_ANNOTATIONS_BACKPORT and self.python_version == (2, 7):
       locs = [(line + 1, col) for line, col in locs]
-    return super(IndexerTestPy3, self).assertDefLocs(index, fqname, locs)
+    return super().assertDefLocs(index, fqname, locs)
 
   def test_type_annotations(self):
     ix = self.index_code("""
diff --git a/pytype/vm.py b/pytype/vm.py
index a0ea625ea..651491a25 100644
--- a/pytype/vm.py
+++ b/pytype/vm.py
@@ -646,8 +646,8 @@ def _check_defaults(self, node, method):
         method.match_args(node, args)
       except function.FailedFunctionCall as e:
         if not isinstance(e, function.InvalidParameters):
-          raise AssertionError(
-              "Unexpected argument matching error: %s" % e.__class__.__name__)
+          raise AssertionError("Unexpected argument matching error: %s" %
+                               e.__class__.__name__) from e
         arg_name = e.bad_call.bad_param.name
         expected_type = e.bad_call.bad_param.expected
         for name, value in e.bad_call.passed_args:
@@ -668,7 +668,8 @@ def _check_defaults(self, node, method):
           break
         else:
           raise AssertionError(
-              "Mismatched parameter %s not found in passed_args" % arg_name)
+              "Mismatched parameter %s not found in passed_args" %
+              arg_name) from e
       else:
         needs_checking = False
 
@@ -1864,12 +1865,12 @@ def byte_LOAD_NAME(self, state, op):
     except KeyError:
       try:
         state, val = self.load_global(state, name)
-      except KeyError:
+      except KeyError as e:
         try:
           if self._is_private(name):
             # Private names must be explicitly imported.
             self.trace_opcode(op, name, None)
-            raise KeyError()
+            raise KeyError(name) from e
           state, val = self.load_builtin(state, name)
         except KeyError:
           if self._is_private(name) or not self.has_unknown_wildcard_imports:
diff --git a/pytype/vm_test.py b/pytype/vm_test.py
index 5dbcf13b5..f255e3723 100644
--- a/pytype/vm_test.py
+++ b/pytype/vm_test.py
@@ -20,7 +20,7 @@ class TraceVM(vm.VirtualMachine):
   """Special VM that remembers which instructions it executed."""
 
   def __init__(self, options, loader):
-    super(TraceVM, self).__init__(errors.ErrorLog(), options, loader=loader)
+    super().__init__(errors.ErrorLog(), options, loader=loader)
     # There are multiple possible orderings of the basic blocks of the code, so
     # we collect the instructions in an order-independent way:
     self.instructions_executed = set()
@@ -32,7 +32,7 @@ def __init__(self, options, loader):
 
   def run_instruction(self, op, state):
     self.instructions_executed.add(op.index)
-    return super(TraceVM, self).run_instruction(op, state)
+    return super().run_instruction(op, state)
 
 
 class BytecodeTest(test_base.BaseTest, test_utils.MakeCodeMixin):
@@ -42,7 +42,7 @@ class BytecodeTest(test_base.BaseTest, test_utils.MakeCodeMixin):
   PY_MAJOR_VERSIONS = [2]
 
   def setUp(self):
-    super(BytecodeTest, self).setUp()
+    super().setUp()
     self.errorlog = errors.ErrorLog()
     self.trace_vm = TraceVM(self.options, self.loader)
 
@@ -186,7 +186,7 @@ class TraceTest(test_base.BaseTest, test_utils.MakeCodeMixin):
   """Tests for opcode tracing in the VM."""
 
   def setUp(self):
-    super(TraceTest, self).setUp()
+    super().setUp()
     self.errorlog = errors.ErrorLog()
     self.trace_vm = TraceVM(self.options, self.loader)
 
@@ -228,7 +228,7 @@ class AnnotationsTest(test_base.BaseTest, test_utils.MakeCodeMixin):
   """Tests for recording annotations."""
 
   def setUp(self):
-    super(AnnotationsTest, self).setUp()
+    super().setUp()
     self.errorlog = errors.ErrorLog()
     self.vm = analyze.CallTracer(self.errorlog, self.options, self.loader)
 
@@ -242,7 +242,7 @@ def test_record_local_ops(self):
 class DirectorLineNumbersTest(test_base.BaseTest, test_utils.MakeCodeMixin):
 
   def setUp(self):
-    super(DirectorLineNumbersTest, self).setUp()
+    super().setUp()
     self.errorlog = errors.ErrorLog()
     self.vm = analyze.CallTracer(self.errorlog, self.options, self.loader)