type wrongly interpreted as never ; beta->rc regression

[AlexGalays]

TypeScript Version: 2.0.2 rc

This is a regression from 2.0.0 beta

Code

First, I define some types in file1.ts:

export interface Route<P> {
  uri: string
}

export interface RouteWithParams<P> {
  route: Route<P>
  isIn<T>(parent: Route<T>): this is RouteWithParams<T>
}

Then, I re-export these types from another module, for convenience (one is an abstract util module used only once, the other should be exclusively imported everywhere):

file2.ts

import { Route, RouteWithParams } from './file1'

export { Route, RouteWithParams }

Then, whenever I import these types in other modules, they are seen as having the never type (error TS2339: Property 'isIn' does not exist on type 'never').

I hope I have isolated the issue. It could also be due to wrong flow analysis.
If not, you can also very easily see the issue on a repo I have:

git clone git@github.com:AlexGalays/kaiju.git
cd kaiju/example
npm install
npm run build  // it compiles fine
Now go to package.json and change the typescript version from `beta` to `rc`
npm install
npm run build // compilation error

[aluanhaddad]

Works fine for me with typescript@2.1.0-dev.20160906

By the way your repository requires authentication and I cannot clone it.
Silly me, I Copy/Pasted by mistake. Forgot the https://.

[AlexGalays]

@aluanhaddad Just installed that nightly version and my repo has the same compilation errors as with v2.0.2

[aluanhaddad]

What does your tsconfig look like?

[sandersn]

@aluanhaddad here it is. I don't think there's much surprising there.

I cloned the repo and reproduced the bug there. But I don't get the error with the miniaturised one you gave, @AlexGalays.

{
    "compilerOptions": {
        "target": "es5",
        "noImplicitAny": true,
        "strictNullChecks": true
    },
    "compileOnSave": false,
    "atom": {
        "rewriteTsconfig": false
    },
    "filesGlob": [
        "src/**/*.*",
        "typings/**/*.d.ts"
    ]
}

My code in the using file is

import { Route, RouteWithParams } from "./second";
let r: Route<number> = { uri: 'foo' };
let rp: RouteWithParams<number> = { 
  route: r, 
  isIn<T>(parent: Route<T>) {
    return false;
  }
}
console.log(r.uri)
rp.isIn(r);

I need to make sure my tsconfig matches yours exactly still, though.

[AlexGalays]

Can I somehow provide more info if you were able to reproduce it with the repo?

[sandersn]

I am looking for a small, standalone repro. Since the repo exhibits the bug, the next step is to understand the code enough to cut it down to a small repro. I'll do that after I look at another bug if you don't have time to do it.

[AlexGalays]

Oh I see. I don't think I will have the time to find the minimum repro case in the coming days though :(

[sandersn]

That's ok. I'll get to it after looking at the bug on enums-as-unions.

[sandersn]

The never arises from control flow analysis, not an import/export binding. If I comment out line 91 then the compilation errors go away.

I'm pretty sure this is a change that @ahejlsberg made to type predicates like this is RouteWithParams<T> such that you get never in branches that can never actually happen. But I need to look closer at the code to make sure.

[sandersn]

Here is a much smaller repro. I'll try to make it even smaller, though.

// @filename: util.ts
export interface Route<P> {
  uri: string
  path: string
}
export function Route<P>(uri: string): Route<P> {
  const path = uri.split('?')[0]
  return { uri, path }
}

export interface RouteWithParams<P> {
  route: Route<P>
  params: P
  isIn<T>(parent: Route<T>): this is RouteWithParams<T>
}

// @filename: router.ts
import { Route, RouteWithParams } from './util'
export { Route, RouteWithParams }
export type BlueParams = { id: string }
export const red = Route<BlueParams>('blue/:id/red')

// @filename: main.ts
import * as routes from "./router";

function getChildren(route: routes.RouteWithParams<routes.BlueParams>) {
  if (route.isIn(routes.red)) return []
  if (route.isIn(routes.red)) return []
  return []
}

[sandersn]

I think the repro boils down to this. The biggest change is dropping the type parameters from RouteWithParams (now called I) I'm not sure if that should affect narrowing.

interface I {
  predicate(): this is I
}
function getChildren(i: I): any[] {
  if (i.predicate()) return []
  i.predicate() // error: `i: never` here
  return []
}