Excess parameters create unsafe usage possibilities

[weswigham]

TypeScript Version: 2.4.0 / nightly (2.5.0-dev.201xxxxx)

Just found a bug like this while editing our compiler - it would be super nice if we caught it.

Code

type AnonymousType = { kind: "anon", id: number, symbol: Symbol };
type UnionType = { kind: "union", id: number, types: Type[] };
type Type = UnionType | AnonymousType;
declare function forEach<T, U>(items: U[], cb: (item: U, index: number) => T): T;
declare function clone(symbol: Symbol): Symbol;
var someType: Type;
if (someType.kind === "anon") {
    addThingCallback(someType, clone(someType.symbol));
}
else {
    forEachType(someOtherType, addThingCallback);
}

function addThingCallback(t: Type, symbol?: Symbol) {
    if (symbol) {
        t.symbol = symbol;
    }
    t.id;
}

function forEachType<T>(type: UnionType, cb: (t: Type) => T) {
  return type && forEach(type.types, cb);
}

Expected behavior:
Either an error on the definition of forEachType warning about possible issues about overwritten parameters, or an error on the usage of addThingCallback with forEachType warning that it has excess arguments which may not be fulfilled by the specified type at runtime.
Actual behavior:
No error.

I feel like this is in the vein of improved checking that we've been doing with strict callback variance and excess property checks.

cc @rbuckton since you seemed interested - here's an issue to track it, and @sandersn, since you did work on the object literal checks.

[RyanCavanaugh]

Duplicate #13043

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.