"... but we should gradually enable them as time allows" :)

Nitpick: new test names should be `test_wordsWordsWords`. Not gonna block on that though ;-)

We can add this to `.coveragerc` to avoid this type of bogus coverage gap: ``` [report] exclude_lines = pragma: no cover if TYPE_CHECKING \s*\.\.\.$ ```

Seems like this should also be a generic, and this should be `Deferred[T]`? If users are using it for something heterogenous, `T` can always be `Any`.

Do we support a version of Python where this `AttributeError` can still happen? Can we just nuke the whole `try`?

Ugh I can't wait to drop 3.6 so we don't have all this gratuitous quoting

What? Why does mypy think these types are distinct at all? It should be able to see them as a pure type alias?

If we want to support this behavior, we should be testing it. Rather than a `ignore[unreachable]`, specify something like `onTimeoutCancelLegacy: Optional[Callable[[object, float], object] = onTimeoutCancel` up at the top of the function, then explain that we don't want it publicly typed to allow None but we may want to allow non-mypy users to keep passing it

See above; this was moved up in the file

This code path is extremely hot, so I'd be a little wary of adding the two extra `getattr` calls here. (I wish speed center could quickly just, you know, tell us the performance impact instead of guessing like this, but c'est la vie)

If you can get rid of this modification you can avoid worrying about the codecov error here ;-)

I think that the right answer here is to have `defer.fail` explicitly become a `Deferred[Any]`, so that it will match shapes like this one.

This to avoid a function that sets an attribute on itself

Old thing has false positive for "merge failure" check

In addition to self-as-typevar having some issues with mypy's internals, there's also the issue here that this signature is conceptually wrong too; `_DeferredT.addCallback(x->y)` does *not* return `_DeferredT` in the future generic version, it returns `Deferred[Y]`. I think if we want to go with simpler stubs for the first iteration, it would be better to simply type this as `Deferred`. (I think the idea here is to capture `DeferredList`'s subclass behavior, but `DeferredList` being a subclass ought to be irrelevant; the public attributes `fireOnOneCallback` etc. are exposed by accident from the constructor, ought to be private, and it has no differing public behaviors beyond those.

Why make this (incorrectly) unreachable rather than making the arguments properly `Optional`?

OK perhaps this looks like a weird change. The tests [`OtherPrimitivesTests.testLock`](https://github.com/twisted/twisted/blob/10017-mypy-defer/src/twisted/test/test_defer.py#L2131) and [`OtherPrimitivesTests.testSemaphore`](https://github.com/twisted/twisted/blob/10017-mypy-defer/src/twisted/test/test_defer.py#L2191) pass in `self=` to this method, which presumably means that `kwargs` here needs to accept any argument, hence the original method signature, which lacked `self` entirely, and the funky argument handling removed below to get it back. That, of course, makes it hard for a tool like `mypy` to know what's going on with the method signature. So here we put both `self` and the required first argument (which we can now type as a `Callable`) back in, but then we have to deal with the need to be able to pass `self` in as a keyword to the callable… So we change the name of `self`, and we want that name not to be some other thing you might want to pass into the callable. So I took a UUID and encoded it to letters. If someone ends up trying to pass `dbjAAcAiBbiFeBiEAcjgDhfFchjEBahF` as a keyword here then I HATE THAT JERK SHUT UP GO AWAY. So there.

```suggestion def __iter__(self) -> _DeferredT: ``` `Deferred` already has a `__next__`

an enum might be better here ``` class _Sentinel(enum.Enum): NO_RESULT = auto() CONTINUE = auto() ``` then you can use `Union[DeferredCallback, Literal[_Sentinel.CONTINUE]]`

This suggests that `Generator[Deferred, object, None]]` is the wrong return type for `f`. I could use other eyes on this.

I feel like I must be doing something wrong here but I don't see it

This to avoid a function that sets an attribute on itself

old code sure likes to pretend that `False is 0` and `True is 1`

This one is only used internally.

These are standard for `*args` and `**kwargs`… so less compelling for clients, and maybe overkill here, but I think they help with reading the intended uses.

These two are used in public type signatures and I thought they would be useful to clients, so I didn't prefix them with `_`… but I'm not super happy with these signatures, since they aren't providing a good descriptions due to the limitations of `Callable`. I think they remain useful in that when we eventually fix these, the user of these variables will then benefit from the checking. I used the "next best" examples above when doing the initial typing work do distinguish callbacks from errbacks, for example, but we can't ship with those definitions because they don't allows for callbacks with extra arguments.

Moved up for easier to manage definition order

Should all imports be prefixed with '_' or is '_MethodType' special? It would be safer to move to `_foo.py` files with `foo.py` importing the public symbols if we are trying to keep the namespace cleaner than "look at `__all__`", no?