This special-casing of object worries me a bit. But anyway, this will be necessary only for the backport (with PEP 560 all these hacks will be removed). So if @gvanrossum is fine with this, then it is also OK with me.

I don't see any viable alternatives. Any suggestions?

The other alternative is just to keep the status quo. I remember we have a similar situation with GenericMeta.__new__. You can special-case for object, but it looks like that the same can happen with any other class that doesn't expect additional arguments in its __new__.

You can special-case for object, it looks like that the same can happen with any other class that doesn't expect additional arguments in its new.

The existing code is already a special-case for object: by assuming there are no args in base_cls.__new__ it's assuming base_cls is object. I'm simply adding another case that covers multiple inheritance while preserving the existing special object case.

When using multiple inheritance with Generic and __new__ users will simply have to be responsible and only pass args that are compatible with super's __new__. This is what they would do normally anyway, so it's not asking anything additional of them. Also, note that in my tests I've covered the case where no args are expected.

What happens if you don't special-case object and always pass *args, **kwds? I find it disturbing that by inheriting directly from object you end up with a class that ignores all arguments passed to it. (Though I realize that there is a problem here when you override one of __init__ and __new__ but not the other.)

What happens if you don't special-case object and always pass *args, **kwds?

Any class inheriting from Generic whose __init__ takes an arg will fail.

Here's an example of a test case that fails if we pass *args, **kwds to base_cls.__new__:

T = TypeVar('T')
class C(Generic[T]):
    def __init__(self, attr):
        self.attr = attr

c = C(42)

======================================================================
ERROR: test_copy_generic_instances (test_typing.GenericTests)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/Users/chad/dev/typing/src/test_typing.py", line 1113, in test_copy_generic_instances
    c = C(42)
  File "/Users/chad/dev/typing/src/typing.py", line 1223, in __new__
    return _generic_new(cls.__next_in_mro__, cls, *args, **kwds)
  File "/Users/chad/dev/typing/src/typing.py", line 1184, in _generic_new
    return base_cls.__new__(cls, *args, **kwds)
TypeError: object() takes no parameters

Though I realize that there is a problem here when you override one of __init__ and __new__ but not the other.

I think this is exactly the point. typing.Generic has created this situation for all subclasses, so to avoid inconveniencing users by forcing subclasses with args to implement __new__ and pass the correct args (almost always none), it deals with the problem transparently, by special-casing object. And I'm speaking now about the status-quo, prior to this PR.

OK, I am beginning to understand the situation. It is indeed a problem (we don't want to require that both __init__ and __new__ process all arguments). But I can defeat your hack by having C subclass a non-generic class D that also override __init__ -- then the __init__ call works fine, but the __new__ call still fails because the superclass isn't object (but still doesn't implement __new__). So I think we should really check whether base_cls.__new__ is object.__new__.

So I think we should really check whether base_cls.new is object.new.

Deal!