function returnFoo<T extends {a: 1, b: 2}>(foo: T): T {
    return foo;
}

// ✅ auto-completion works
returnFoo({  })
//          ^|
// ❌ auto-completion broken
returnFoo({  } as const)
//          ^|

// @strictNullChecks: true
// @filename: test.js
// @allowJs: true
// @checkJs: true
// @noEmit: true

const x = "hello" ?? 0;
//    ^?

// @allowJs
// @filename: index.js

/**
 * @type {(...args: [string, string] | [number, string, string]) => void}
 */
function foo(...args) {
//               ^?
}

// @noImplicitAny: false

type Entity = {
  someDate: Date | null;
} & ({ id: string; } | { id: number; })

type RowRendererMeta<TInput extends {}> = {
  [key in keyof TInput]: { key: key; caption: string; formatter?: (value: TInput[key]) => string; };
}
type RowRenderer<TInput extends {}> = RowRendererMeta<TInput>[keyof RowRendererMeta<TInput>];

const test: RowRenderer<Entity> = {
  key: 'someDate',
  caption: 'My Date',
  formatter: (value) => value ? value.toString() : '-' // value: any
//            ^?
}

const thisIsNotTheIssue: Partial<RowRendererMeta<Entity>> = {
  someDate: {
    key: 'someDate',
    caption: 'My Date',
    formatter: (value) => value ? value.toString() : '-' // value: Date | null
//              ^?
  }
}

type State
    = {tag: "one"}
    | {tag: "two"}
    | {tag: "three"}

function notallowed(arg: number) {
    let state: State = {tag: "one"};
    try {
        state = {tag: "two"};
        try { // <- this inner try causes a problem
            state = {tag: "three"}; // <- this should make "three" be a possibility but when inside a try, typescript "forgets" it.
        }
        finally {}
    }
    catch (err) {
        state.tag; // <- this should be "one" | "two" | "three" but typescript says it is "one" | "two"
        if (state.tag !== "one" && state.tag !== "two") {
            console.log(state.tag); // <- typescript reports a type error here
        }
    }
}

// @filename: service.ts
export class Service {}

// @filename: component.ts
 import type { Service } from "./service";

 declare var decorator: any;

 @decorator
 class MyComponent {
     constructor(public Service: Service) {
     }

     @decorator
     method(x: this) {
     }
 }

// @emitDecoratorMetadata
// @experimentalDecorators
// @showEmit
// @showEmittedFile: component.js

function decorator(a: any) {}

export default

@decorator
class A {
}

enum E {
    A,
    B,
    C,
}

function f(x: E | undefined) {
//       ^?
    return x ?? E.C;
}