Inference seems to be broken with the spread syntax?

[dolsem]

TypeScript Version: 4.0.2

Search Terms:

Expected behavior: No error for both function calls

Actual behavior: The first call succeeds, the second fails

Related Issues:

Code

interface I {
    bla: string;
    blabla: string;
}

const fn = (obj: Record<string, string>) => obj;

const obj: I = { bla: '', blabla: '' };

const { bla, ...rest } = obj;
fn({ ...rest });
fn(rest);

Output

"use strict";
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
const fn = (obj) => obj;
const obj = { bla: '', blabla: '' };
const { bla } = obj, rest = __rest(obj, ["bla"]);
fn(Object.assign({}, rest));
fn(rest);

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "alwaysStrict": true,
    "esModuleInterop": true,
    "declaration": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "moduleResolution": 2,
    "target": "ES2017",
    "jsx": "React",
    "module": "ESNext"
  }
}

Playground Link: Provided

[RyanCavanaugh]

This is the expected behavior - "fresh" object literals are allowed to have an index signature inferred from context, but regular object literals are not. This is a correct difference in behavior because, for example, you can't cause a corruption to occur when the write is to a fresh object:

interface I {
    bla: string;
    blabla: string;
    n: number;
}

const fn = (obj: Record<string, string>) => {
  obj["n"] = "hello";
}

const obj: I = { bla: '', blabla: '', n: 3 };

const { bla, n, ...rest } = obj;
fn({ ...rest });

const ref: { bla: string } = obj;
fn(ref);

[dolsem]

Could this be allowed for the case when the expected type is Readonly<Record<string, string>>?

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.