type guarded type not preserved in returned object method?

[benmosher]

TypeScript Version: 2.0.2

Code

// a function to take either an iterator or an iterable, and return an iterable (for for..of)
export function iterable<T>(iter: Iterator<T> | Iterable<T>): Iterable<T> {
  if (isIterator(iter)) {
    //const iter2 = iter //<== returning iter2 instead works fine, iter2 is inferred to be Iterator<T>
    return {
      [Symbol.iterator]() { return iter } // <== this is marked as an error, reports iter as `Iterator<T> | Iterable<T>` in spite of the guard
    }
  }
  if (isIterable(iter)) return iter  // works fine

  throw new Error("provided argument neither iterable nor iterator")
}

// guards
export function isIterable<T>(iter: Iterable<T> | Iterator<T>): iter is Iterable<T>;
export function isIterable(iter: any): iter is Iterable<any> {
  if (iter == null) return false
  if (!(iter[Symbol.iterator] instanceof Function)) return false

  return true
}

export function isIterator<T>(iter: Iterable<T> | Iterator<T>): iter is Iterator<T>;
export function isIterator(iter: any): iter is Iterator<any> {
  if (iter == null) return false
  return (typeof iter.next === 'function')
}

Possibly related: #10734 ?

Expected behavior:

I would expect iter to be allowed as a return value, since it has been guarded.

Actual behavior:

Only iter2 is allowed to be returned, if defined.

I wondered if this might have been due to iter being a var-scoped name, so I tried defining a const iter2 = iter at the top and then calling the guards on iter2, but that also didn't work.

Apologies for the terrible title, I'm not familiar enough with typing jargon yet to succinctly describe what I'm seeing. (and I'm willing to believe it's working as intended, but I'm not positive)

[benmosher]

Interesting twist--this compiles without errors:

export function iterable<T>(iter: Iterator<T> | Iterable<T>): Iterable<T> {
  if (isIterator(iter)) return { [Symbol.iterator]: () => iter }
  // this too:   if (isIterator(iter)) return { [Symbol.iterator]: function () { return iter } }
  if (isIterable(iter)) return iter

  throw new Error("provided argument neither iterable nor iterator")
}

The arrow/function expressions seems to infer the guarded type, even though the short-format method did not.

[jods4]

I think this is a duplicate of #10501, where guards flow through function and lambdas, but not through method shorthand in literals.

[RyanCavanaugh]

Thanks for finding that @jods4