Mixed refined to an object produces a read-only object, which breaks a lot of existing code.

[lxe]

Flow version: 0.98

https://flow.org/try/#0GYVwdgxgLglg9mABMOcAUAjAhgJwFyIC2MAHgKYAmAlIgN4BQiiMwiaUAngA5lyvY5EAQgC8IxAHI4GAFZloExAB8lwgTQZMmOMlBA4kYEABtjAbkaIAvvUss2AgHRQAFjDABzRGPESAznCEum6eEhqWTE6u7l6+OFiuZDgSFkw2VkA

function foo(bar: mixed) {
  if (typeof bar !== 'object' || !bar) {
    return null;
  }

  if (bar.thing === 'something') {
    bar.thing = 'rather';
  }
}

Expected behavior

No Errors

Actual behavior

7:     bar.thing = 'rather';
           ^ Cannot assign `'rather'` to `bar.thing` because property `thing` is not writable.

Also #7684

[goodmind]

0983bd0

[goodmind]

@dsainati1

[goodmind]

It is unsafe even if you refine type, because original type may have been string literal

const m: {a: 'foo'} = {a: 'foo'}
function unsafeWrite(obj: mixed) {
   if (typeof obj === 'object' && obj !== null) {
      if (typeof obj.a === 'string') {
        obj.a = 'bar' // unsafe
      }
   }
}
unsafeWrite(m)
m.a // bar

[dsainati1]

Yes, this is an intentional change. Consider the example in the linked commit:

function bad (x : mixed) {
  if (typeof x === "object" && x !== null) {
    x.a = 3;
  }
}

let obj : {a : string} = {a : "oops"};
bad(obj); // yikes

It is rarely necessary to use mixed, your example could easily be rewritten as:

function foo(bar: ?{thing : string}) {
  if (typeof bar !== 'object' || !bar) {
    return null;
  }

  if (bar.thing === 'something') {
    bar.thing = 'rather';
  }
}

Alternatively you could use generics or bounded generics if your function needs to be able to accept a variety of inputs.

[lxe]

It is rarely necessary to use mixed, your example could easily be rewritten as:

We're adding flow to a large code base, and mixed is a useful and practical tool to enforce refinements when it's woefully difficult to hunt down the type of function arguments.

Sure, I can simply replace mixed with an explicit type based on already written refinements, but that's something that the type system should be doing for me automatically, which is exactly what mixed used to do.

Why not have a warning instead when attempting to write properties of objects of mixed types?