Initial glance looks good to me. Having tested this, do you find the reported point is sensible? I've written a patch for providing contact data, but I noticed that unusual values were sometimes reported, most specifically the collision impulse.

To me they are quite sensible. I've been thinking about exposing all contact points, but the first one per colliding object seems to work for me.

From the implementation point of view seems fine and seems useful as well. But isn't it gonna to break quite a few of existing scripts?

@Sergey Sharybin (sergey): yes, this change is going to break scripts if we accept the patch as it is now. This is something I want to avoid if we can. I see three ways to continue:

1. Implement as-is, and accept that there will be breakage (not my favourite).
2. Use co_argcount to detect whether the new arguments will be accepted like @Campbell Barton (campbellbarton) suggested. I too feel that this is better than option 1. However, it may still break when a variable number of parameters is used; for example: def callback(*args): ..., as co_argcount only counts the fixed arguments. I'm also not familiar with how fast such a check would be, and it probably has to be performed for every call to every callback. The setter for KX_GameObject.collisionCallbacks won't be called when appending a callback function, so we won't be able to perform the check there.
3. Add a second callback list for the new parameters, for example collisionCallbacksExtended. That way the semantics of the current collisionCallbacks don't change, and old/current scripts don't need updating. Per-call checks also won't have to be performed.

Personally I prefer option 3, but if 2 is deemed better I'll implement that.

Note that this patch doesn't contain updates to the documentation yet. I wanted to be sure how we proceed before documenting.

@Sybren A. Stüvel (sybren), sergey and me noted *args would fail, should have mentioned in review.

While correct, its unlikely that a function accepting a single arg would be using *args,
So while it could break scripts, in practice its not very likely.

You could also use a single argument in the case of *args so as not to break anything.

Its not a perfect solution anyway, because python can have callable objects which aren't functions, its just that they arent used so often. especially not in situations like this.

I don't think having a separate list is needed really, getting co_argcount is a direct lookup in memory, theres no expensive dictionary access for example.

On a slightly related note, would someone mind checking whether my suspicions of a bug are correct? I am concerned that sensor objects register with collision sensors when they have collision callbacks.
Personally speaking, I think we should break the existing API given that I suspect its usage is quite rare, and those who do will be aware of the necessary changes.

Regarding inspecting function args, I think its important just to check for the common case, if its a single arg. else it can pass 3 in.