TypeScript/tests/baselines/reference/missingTypeArguments3.types

=== tests/cases/compiler/missingTypeArguments3.ts ===
declare module linq {
>linq : any

    interface Enumerable<T> {
>Enumerable : Enumerable<T>
>T : T

        OrderByDescending(keySelector?: string): OrderedEnumerable<T>;
>OrderByDescending : (keySelector?: string) => OrderedEnumerable<T>
>keySelector : string
>OrderedEnumerable : OrderedEnumerable<T>
>T : T

        GroupBy<TKey>(keySelector: (element: T) => TKey): Enumerable<Grouping<TKey, T>>;
>GroupBy : { <TKey>(keySelector: (element: T) => TKey): Enumerable<Grouping<TKey, T>>; <TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable<Grouping<TKey, TElement>>; }
>TKey : TKey
>keySelector : (element: T) => TKey
>element : T
>T : T
>TKey : TKey
>Enumerable : Enumerable<T>
>Grouping : Grouping<TKey, TElement>
>TKey : TKey
>T : T

        GroupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable<Grouping<TKey, TElement>>;
>GroupBy : { <TKey>(keySelector: (element: T) => TKey): Enumerable<Grouping<TKey, T>>; <TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable<Grouping<TKey, TElement>>; }
>TKey : TKey
>TElement : TElement
>keySelector : (element: T) => TKey
>element : T
>T : T
>TKey : TKey
>elementSelector : (element: T) => TElement
>element : T
>T : T
>TElement : TElement
>Enumerable : Enumerable<T>
>Grouping : Grouping<TKey, TElement>
>TKey : TKey
>TElement : TElement

        ToDictionary<TKey>(keySelector: (element: T) => TKey): Dictionary<TKey, T>;
>ToDictionary : <TKey>(keySelector: (element: T) => TKey) => Dictionary<TKey, T>
>TKey : TKey
>keySelector : (element: T) => TKey
>element : T
>T : T
>TKey : TKey
>Dictionary : Dictionary<TKey, TValue>
>TKey : TKey
>T : T
    }

    interface OrderedEnumerable<T> extends Enumerable<T> {
>OrderedEnumerable : OrderedEnumerable<T>
>T : T
>Enumerable : Enumerable<T>
>T : T

        ThenBy<TCompare>(keySelector: (element: T) => TCompare): OrderedEnumerable<T>; // used to incorrectly think this was missing a type argument
>ThenBy : <TCompare>(keySelector: (element: T) => TCompare) => OrderedEnumerable<T>
>TCompare : TCompare
>keySelector : (element: T) => TCompare
>element : T
>T : T
>TCompare : TCompare
>OrderedEnumerable : OrderedEnumerable<T>
>T : T
    }

    interface Grouping<TKey, TElement> extends Enumerable<TElement> {
>Grouping : Grouping<TKey, TElement>
>TKey : TKey
>TElement : TElement
>Enumerable : Enumerable<T>
>TElement : TElement

        Key(): TKey;
>Key : () => TKey
>TKey : TKey
    }

    interface Lookup<TKey, TElement> {
>Lookup : Lookup<TKey, TElement>
>TKey : TKey
>TElement : TElement

        Count(): number;
>Count : () => number

        Get(key): Enumerable<any>;
>Get : (key: any) => Enumerable<any>
>key : any
>Enumerable : Enumerable<T>

        Contains(key): boolean;
>Contains : (key: any) => boolean
>key : any

        ToEnumerable(): Enumerable<Grouping<TKey, any>>;
>ToEnumerable : () => Enumerable<Grouping<TKey, any>>
>Enumerable : Enumerable<T>
>Grouping : Grouping<TKey, TElement>
>TKey : TKey
    }

    interface Dictionary<TKey, TValue> {
>Dictionary : Dictionary<TKey, TValue>
>TKey : TKey
>TValue : TValue

        Add(key: TKey, value: TValue): void;
>Add : (key: TKey, value: TValue) => void
>key : TKey
>TKey : TKey
>value : TValue
>TValue : TValue

        Get(ke: TKey): TValue;
>Get : (ke: TKey) => TValue
>ke : TKey
>TKey : TKey
>TValue : TValue

        Set(key: TKey, value: TValue): boolean;
>Set : (key: TKey, value: TValue) => boolean
>key : TKey
>TKey : TKey
>value : TValue
>TValue : TValue

        Contains(key: TKey): boolean;
>Contains : (key: TKey) => boolean
>key : TKey
>TKey : TKey

        Clear(): void;
>Clear : () => void

        Remove(key: TKey): void;
>Remove : (key: TKey) => void
>key : TKey
>TKey : TKey

        Count(): number;
>Count : () => number

        ToEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
>ToEnumerable : () => Enumerable<KeyValuePair<TKey, TValue>>
>Enumerable : Enumerable<T>
>KeyValuePair : KeyValuePair<TKey, TValue>
>TKey : TKey
>TValue : TValue
    }

    interface KeyValuePair<TKey, TValue> {
>KeyValuePair : KeyValuePair<TKey, TValue>
>TKey : TKey
>TValue : TValue

        Key: TKey;
>Key : TKey
>TKey : TKey

        Value: TValue;
>Value : TValue
>TValue : TValue
    }
}