TypeScript/tests/baselines/reference/taggedTemplatesWithTypeArguments1.types

=== tests/cases/conformance/es6/templates/taggedTemplatesWithTypeArguments1.ts ===
declare function f<T>(strs: TemplateStringsArray, ...callbacks: Array<(x: T) => any>): void;
>f : <T>(strs: TemplateStringsArray, ...callbacks: ((x: T) => any)[]) => void
>strs : TemplateStringsArray
>callbacks : ((x: T) => any)[]
>x : T

interface Stuff {
    x: number;
>x : number

    y: string;
>y : string

    z: boolean;
>z : boolean
}

export const a = f<Stuff> `
>a : void
>f<Stuff> `    hello    ${stuff => stuff.x}    brave    ${stuff => stuff.y}    world    ${stuff => stuff.z}` : void
>f : <T>(strs: TemplateStringsArray, ...callbacks: ((x: T) => any)[]) => void
>`    hello    ${stuff => stuff.x}    brave    ${stuff => stuff.y}    world    ${stuff => stuff.z}` : string

    hello
    ${stuff => stuff.x}
>stuff => stuff.x : (stuff: Stuff) => number
>stuff : Stuff
>stuff.x : number
>stuff : Stuff
>x : number

    brave
    ${stuff => stuff.y}
>stuff => stuff.y : (stuff: Stuff) => string
>stuff : Stuff
>stuff.y : string
>stuff : Stuff
>y : string

    world
    ${stuff => stuff.z}
>stuff => stuff.z : (stuff: Stuff) => boolean
>stuff : Stuff
>stuff.z : boolean
>stuff : Stuff
>z : boolean

`;

declare function g<Input, T, U, V>(
>g : <Input, T, U, V>(strs: TemplateStringsArray, t: (i: Input) => T, u: (i: Input) => U, v: (i: Input) => V) => T | U | V

    strs: TemplateStringsArray,
>strs : TemplateStringsArray

    t: (i: Input) => T, u: (i: Input) => U, v: (i: Input) => V): T | U | V;
>t : (i: Input) => T
>i : Input
>u : (i: Input) => U
>i : Input
>v : (i: Input) => V
>i : Input

export const b = g<Stuff, number, string, boolean> `
>b : string | number | boolean
>g<Stuff, number, string, boolean> `    hello    ${stuff => stuff.x}    brave    ${stuff => stuff.y}    world    ${stuff => stuff.z}` : string | number | boolean
>g : <Input, T, U, V>(strs: TemplateStringsArray, t: (i: Input) => T, u: (i: Input) => U, v: (i: Input) => V) => T | U | V
>`    hello    ${stuff => stuff.x}    brave    ${stuff => stuff.y}    world    ${stuff => stuff.z}` : string

    hello
    ${stuff => stuff.x}
>stuff => stuff.x : (stuff: Stuff) => number
>stuff : Stuff
>stuff.x : number
>stuff : Stuff
>x : number

    brave
    ${stuff => stuff.y}
>stuff => stuff.y : (stuff: Stuff) => string
>stuff : Stuff
>stuff.y : string
>stuff : Stuff
>y : string

    world
    ${stuff => stuff.z}
>stuff => stuff.z : (stuff: Stuff) => boolean
>stuff : Stuff
>stuff.z : boolean
>stuff : Stuff
>z : boolean

`;

declare let obj: {
>obj : { prop: <T>(strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }; }

    prop: <T>(strs: TemplateStringsArray, x: (input: T) => T) => {
>prop : <T>(strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }
>strs : TemplateStringsArray
>x : (input: T) => T
>input : T

        returnedObjProp: T
>returnedObjProp : T
    }
}

export let c = obj["prop"]<Stuff> `${(input) => ({ ...input })}`
>c : { returnedObjProp: Stuff; }
>obj["prop"]<Stuff> `${(input) => ({ ...input })}` : { returnedObjProp: Stuff; }
>obj["prop"] : <T>(strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }
>obj : { prop: <T>(strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }; }
>"prop" : "prop"
>`${(input) => ({ ...input })}` : string
>(input) => ({ ...input }) : (input: Stuff) => { x: number; y: string; z: boolean; }
>input : Stuff
>({ ...input }) : { x: number; y: string; z: boolean; }
>{ ...input } : { x: number; y: string; z: boolean; }
>input : Stuff

c.returnedObjProp.x;
>c.returnedObjProp.x : number
>c.returnedObjProp : Stuff
>c : { returnedObjProp: Stuff; }
>returnedObjProp : Stuff
>x : number

c.returnedObjProp.y;
>c.returnedObjProp.y : string
>c.returnedObjProp : Stuff
>c : { returnedObjProp: Stuff; }
>returnedObjProp : Stuff
>y : string

c.returnedObjProp.z;
>c.returnedObjProp.z : boolean
>c.returnedObjProp : Stuff
>c : { returnedObjProp: Stuff; }
>returnedObjProp : Stuff
>z : boolean

c = obj.prop<Stuff> `${(input) => ({ ...input })}`
>c = obj.prop<Stuff> `${(input) => ({ ...input })}` : { returnedObjProp: Stuff; }
>c : { returnedObjProp: Stuff; }
>obj.prop<Stuff> `${(input) => ({ ...input })}` : { returnedObjProp: Stuff; }
>obj.prop : <T>(strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }
>obj : { prop: <T>(strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }; }
>prop : <T>(strs: TemplateStringsArray, x: (input: T) => T) => { returnedObjProp: T; }
>`${(input) => ({ ...input })}` : string
>(input) => ({ ...input }) : (input: Stuff) => { x: number; y: string; z: boolean; }
>input : Stuff
>({ ...input }) : { x: number; y: string; z: boolean; }
>{ ...input } : { x: number; y: string; z: boolean; }
>input : Stuff

c.returnedObjProp.x;
>c.returnedObjProp.x : number
>c.returnedObjProp : Stuff
>c : { returnedObjProp: Stuff; }
>returnedObjProp : Stuff
>x : number

c.returnedObjProp.y;
>c.returnedObjProp.y : string
>c.returnedObjProp : Stuff
>c : { returnedObjProp: Stuff; }
>returnedObjProp : Stuff
>y : string

c.returnedObjProp.z;
>c.returnedObjProp.z : boolean
>c.returnedObjProp : Stuff
>c : { returnedObjProp: Stuff; }
>returnedObjProp : Stuff
>z : boolean