Title should be self-explanatory.

I don't think this conversion is correct. If there is a test for InstanceType, there is (IMO) a fifty-fifty-chance that it is there to distinguish old-style and new-style classes, so converting it to object is most likely to break the code.

People who actually want this conversion to happen could replace types.InstanceType with

  getattr(types, 'InstanceType', object)

or add

try:
  from types import InstanceType
except ImportError:
  InstanceType = object

to the top of the module; this would then work for both 2.x and 3.x (assuming that replacing InstanceType with object is actually correct in the code in question).

I'm working on a debugger, trying to identify instances of
old-style classes in Python 2, and any class in Python 3.
The getattr formulation will work, but because I already
need to maintain an "is_v3" flag, I might as well use it
here.

As a side note, how are instances of new-style classes in
v2 categorized?  This v2 code prints 'None':

import types
def get_type_name(target_type):
  for t in dir(types):
    if target_type == getattr(types, t):
      return t

class C(object):
  pass

c = C()
print get_type_name(type(c))

In a sense, *all* objects are instances of new-style classes in 2.x, including instances of old-style classes (which are instances of the InstanceType type, which is a type, and hence a new-style class).

You may want to look at the __flags__ property of the type object. If it is a heap type, there is a good chance that it was created through a class statement. Alternatively, you can look at the type's __module__, and find out whether the module is a Python module.

Closing 2to3 request.