"exponentially large number of cases" errors in latest Flow with common spread pattern

Question

I frequently use the following pattern to create objects with null/undefined properties omitted:

const whatever = {
  something: true,
  ...(a ? { a } : null),
  ...(b ? { b } : null),
};

As of flow release v0.112, this leads to the error message:

Computing object literal [1] may lead to an exponentially large number of cases to reason about because conditional [2] and conditional [3] are both unions. Please use at most one union type per spread to simplify reasoning about the spread result. You may be able to get rid of a union by specifying a more general type that captures all of the branches of the union.

It sounds to me like this isn't really a type error, just that Flow is trying to avoid some heavier computation. This has led to dozens of flow errors in my project that I need to address somehow. Is there some elegant way to provide better type information for these? I'd prefer not to modify the logic of the code, I believe that it works the way that I need it to (unless someone has a more elegant solution here as well). Asking here before I resort to // $FlowFixMe for all of these.

Complete example on Try Flow

Answer 1

It's not as elegant to write, and I think Flow should handle the case that you've shown, but if you still want Flow to type check it you could try rewriting it like this:

/* @flow */

type A = {
  cat: number,
};

type B = {
  dog: string,
}

type Built = {
  something: boolean,
  a?: A,
  b?: B,
};

function buildObj(a?: ?A, b?: ?B): Built {
  const ret: Built = {
    something: true
  };

  if(a) ret.a = a
  if(b) ret.b = b

  return ret;
}

Try Flow