Dynamic `typeof` test with union types outside do not carry into closure scope

[dxu]

Hi, I'm running into an issue that I think may be a bug. It seems like dynamic typeof tests on union types aren't respected within closures.

For example:

function b(url: string | Object) {
  if (typeof url === 'string') {
  	return new Promise(function(resolve, reject) {
 	  var request = new XMLHttpRequest();
      request.open('GET', url)
    });
  }
}

// For some reason it works when request is shadowed
function b(url: string | Object) {    
  if (typeof url === 'string') {            
    // request is shadowed
     return new Promise(function(resolve, request) {                                
       var request = new XMLHttpRequest();                                         
       request.open('GET', url);                                                      
     });                                                                           
   }                                                                                
 } 

// Another closure via function declaration
function b(url: string | Object) {
  if (typeof url === 'string') {
    const a = function(resolve, reject) {
 	  const request = new XMLHttpRequest();
      request.open('GET', url)
    };
  }
}

gives the errors

5:       request.open('GET', url)
                             ^ object type. This type is incompatible with the expected param type of
[LIB] static/v0.39.0/flowlib/bom.js:488:     open(method: string, url: string, async?: boolean, user?: string, password?: string): void;
                                                                       ^ string
26:       request.open('GET', url)
                              ^ object type. This type is incompatible with the expected param type of
[LIB] static/v0.39.0/flowlib/bom.js:488:     open(method: string, url: string, async?: boolean, user?: string, password?: string): void;
                     

I would expect that due to the typeof test on url outside the scope, and because i'm not reassigning url, this would return no errors.

Thanks for all of your continued great work! Please let me know if I'm making a mistake here.

[piuccio]

I think I'm having the same error, here's a link to try flow

My code, simplified is

const Immutable = {
   Map: {
      get(path: string): mixed {},
      getIn(path: Array<string>): mixed {},
   },
};

function banana(path: string | Array<string>) {
  const getter = typeof path === 'string'
  	? (map) => map.get(path)
  	: (map) => map.getIn(path);
  return (state) => getter(Immutable.Map);
}

The typeof guarantees that path inside the closure is a string but flow is not aware of that

[carlrosell]

I have a similar problem. I created this small example to show it:

// Error
function getBig<T: string | number>(a: T, b: T): T {
  if (typeof a === typeof b) {
    return a > b ? a : b;
  }
  return a;
}

// Error
function getBig<T: string | number>(a: T, b: T): T {
  if (
    (typeof a === 'string' && typeof b === 'string') ||
    (typeof a === 'number' && typeof b === 'number')
  ) {
    return a > b ? a : b;
  }
  return a;
}

// No error
function getBig<T: string | number>(a: T, b: T): T {
  if (typeof a === 'string' && typeof b === 'string') {
    return a > b ? a : b;
  }
  if (typeof a === 'number' && typeof b === 'number') {
    return a > b ? a : b;
  }
  return a;
}

It then tells me that it Cannot compare string to number.

Here is a link so you can try it out yourselves.