Merge remote-tracking branch 'origin/master' into portLibFiles731

src/harness/typeWriter.ts

@@ -75,6 +75,12 @@ class TypeWriterWalker {
         const sourceText = ts.getSourceTextOfNodeFromSourceFile(this.currentSourceFile, node);
 
         if (!isSymbolWalk) {
+            // Don't try to get the type of something that's already a type.
+            // Exception for `T` in `type T = something` because that may evaluate to some interesting type.
+            if (ts.isPartOfTypeNode(node) || ts.isIdentifier(node) && !(ts.getMeaningFromDeclaration(node.parent) & ts.SemanticMeaning.Value) && !(ts.isTypeAlias(node.parent) && node.parent.name === node)) {
+                return undefined;
+            }
+
             // Workaround to ensure we output 'C' instead of 'typeof C' for base class expressions
             // let type = this.checker.getTypeAtLocation(node);
             const type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node);

tests/baselines/reference/1.0lib-noErrors.types

@@ -103,8 +103,6 @@ declare function encodeURIComponent(uriComponent: string): string;
 >uriComponent : string
 
 interface PropertyDescriptor {
->PropertyDescriptor : PropertyDescriptor
-
     configurable?: boolean;
 >configurable : boolean
 
@@ -126,20 +124,14 @@ interface PropertyDescriptor {
 }
 
 interface PropertyDescriptorMap {
->PropertyDescriptorMap : PropertyDescriptorMap
-
     [s: string]: PropertyDescriptor;
 >s : string
->PropertyDescriptor : PropertyDescriptor
 }
 
 interface Object {
->Object : Object
-
     /** The initial value of Object.prototype.constructor is the standard built-in Object constructor. */
     constructor: Function;
 >constructor : Function
->Function : Function
 
     /** Returns a string representation of an object. */
     toString(): string;
@@ -152,7 +144,6 @@ interface Object {
     /** Returns the primitive value of the specified object. */
     valueOf(): Object;
 >valueOf : () => Object
->Object : Object
 
     /**
       * Determines whether an object has a property with the specified name. 
@@ -169,7 +160,6 @@ interface Object {
     isPrototypeOf(v: Object): boolean;
 >isPrototypeOf : (v: Object) => boolean
 >v : Object
->Object : Object
 
     /** 
       * Determines whether a specified property is enumerable.
@@ -188,7 +178,6 @@ declare var Object: {
 
     new (value?: any): Object;
 >value : any
->Object : Object
 
     (): any;
     (value: any): any;
@@ -197,7 +186,6 @@ declare var Object: {
     /** A reference to the prototype for a class of objects. */
     prototype: Object;
 >prototype : Object
->Object : Object
 
     /** 
       * Returns the prototype of an object. 
@@ -217,7 +205,6 @@ declare var Object: {
 >getOwnPropertyDescriptor : (o: any, p: string) => PropertyDescriptor
 >o : any
 >p : string
->PropertyDescriptor : PropertyDescriptor
 
     /** 
       * Returns the names of the own properties of an object. The own properties of an object are those that are defined directly 
@@ -237,7 +224,6 @@ declare var Object: {
 >create : (o: any, properties?: PropertyDescriptorMap) => any
 >o : any
 >properties : PropertyDescriptorMap
->PropertyDescriptorMap : PropertyDescriptorMap
 
     /**
       * Adds a property to an object, or modifies attributes of an existing property. 
@@ -250,7 +236,6 @@ declare var Object: {
 >o : any
 >p : string
 >attributes : PropertyDescriptor
->PropertyDescriptor : PropertyDescriptor
 
     /**
       * Adds one or more properties to an object, and/or modifies attributes of existing properties. 
@@ -261,7 +246,6 @@ declare var Object: {
 >defineProperties : (o: any, properties: PropertyDescriptorMap) => any
 >o : any
 >properties : PropertyDescriptorMap
->PropertyDescriptorMap : PropertyDescriptorMap
 
     /**
       * Prevents the modification of attributes of existing properties, and prevents the addition of new properties.
@@ -324,8 +308,6 @@ declare var Object: {
   * Creates a new function.
   */
 interface Function {
->Function : Function
-
     /**
       * Calls the function, substituting the specified object for the this value of the function, and the specified array for the arguments of the function.
       * @param thisArg The object to be used as the this object.
@@ -369,7 +351,6 @@ interface Function {
 
     caller: Function;
 >caller : Function
->Function : Function
 }
 
 declare var Function: {
@@ -381,20 +362,15 @@ declare var Function: {
       */
     new (...args: string[]): Function;
 >args : string[]
->Function : Function
 
     (...args: string[]): Function;
 >args : string[]
->Function : Function
 
     prototype: Function;
 >prototype : Function
->Function : Function
 }
 
 interface IArguments {
->IArguments : IArguments
-
     [index: number]: any;
 >index : number
 
@@ -403,12 +379,9 @@ interface IArguments {
 
     callee: Function;
 >callee : Function
->Function : Function
 }
 
 interface String {
->String : String
-
     /** Returns a string representation of a string. */
     toString(): string;
 >toString : () => string
@@ -480,7 +453,6 @@ interface String {
     match(regexp: RegExp): string[];
 >match : { (regexp: string): string[]; (regexp: RegExp): string[]; }
 >regexp : RegExp
->RegExp : RegExp
 
     /**
       * Replaces text in a string, using a regular expression or search string.
@@ -512,7 +484,6 @@ interface String {
     replace(searchValue: RegExp, replaceValue: string): string;
 >replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
 >searchValue : RegExp
->RegExp : RegExp
 >replaceValue : string
 
     /**
@@ -523,7 +494,6 @@ interface String {
     replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
 >replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
 >searchValue : RegExp
->RegExp : RegExp
 >replaceValue : (substring: string, ...args: any[]) => string
 >substring : string
 >args : any[]
@@ -543,7 +513,6 @@ interface String {
     search(regexp: RegExp): number;
 >search : { (regexp: string): number; (regexp: RegExp): number; }
 >regexp : RegExp
->RegExp : RegExp
 
     /**
       * Returns a section of a string.
@@ -574,7 +543,6 @@ interface String {
     split(separator: RegExp, limit?: number): string[];
 >split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
 >separator : RegExp
->RegExp : RegExp
 >limit : number
 
     /**
@@ -635,14 +603,12 @@ declare var String: {
 
     new (value?: any): String;
 >value : any
->String : String
 
     (value?: any): string;
 >value : any
 
     prototype: String;
 >prototype : String
->String : String
 
     fromCharCode(...codes: number[]): string;
 >fromCharCode : (...codes: number[]) => string
@@ -650,26 +616,21 @@ declare var String: {
 }
 
 interface Boolean {
->Boolean : Boolean
 }
 declare var Boolean: {
 >Boolean : { (value?: any): boolean; new (value?: any): Boolean; prototype: Boolean; }
 
     new (value?: any): Boolean;
 >value : any
->Boolean : Boolean
 
     (value?: any): boolean;
 >value : any
 
     prototype: Boolean;
 >prototype : Boolean
->Boolean : Boolean
 }
 
 interface Number {
->Number : Number
-
     /**
       * Returns a string representation of an object.
       * @param radix Specifies a radix for converting numeric values to strings. This value is only used for numbers.
@@ -709,14 +670,12 @@ declare var Number: {
 
     new (value?: any): Number;
 >value : any
->Number : Number
 
     (value?: any): number;
 >value : any
 
     prototype: Number;
 >prototype : Number
->Number : Number
 
     /** The largest number that can be represented in JavaScript. Equal to approximately 1.79E+308. */
     MAX_VALUE: number;
@@ -749,8 +708,6 @@ declare var Number: {
 }
 
 interface Math {
->Math : Math
-
     /** The mathematical constant e. This is Euler's number, the base of natural logarithms. */
     E: number;
 >E : number
@@ -931,12 +888,9 @@ interface Math {
 /** An intrinsic object that provides basic mathematics functionality and constants. */
 declare var Math: Math;
 >Math : Math
->Math : Math
 
 /** Enables basic storage and retrieval of dates and times. */
 interface Date {
->Date : Date
-
     /** Returns a string representation of a date. The format of the string depends on the locale. */
     toString(): string;
 >toString : () => string
@@ -1211,15 +1165,11 @@ declare var Date: {
 >Date : { (): string; new (): Date; new (value: number): Date; new (value: string): Date; new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date; prototype: Date; parse(s: string): number; UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number; now(): number; }
 
     new (): Date;
->Date : Date
-
     new (value: number): Date;
 >value : number
->Date : Date
 
     new (value: string): Date;
 >value : string
->Date : Date
 
     new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date;
 >year : number
@@ -1229,12 +1179,10 @@ declare var Date: {
 >minutes : number
 >seconds : number
 >ms : number
->Date : Date
 
     (): string;
     prototype: Date;
 >prototype : Date
->Date : Date
 
     /**
       * Parses a string containing a date, and returns the number of milliseconds between that date and midnight, January 1, 1970.
@@ -1269,8 +1217,6 @@ declare var Date: {
 }
 
 interface RegExpExecArray {
->RegExpExecArray : RegExpExecArray
-
     [index: number]: string;
 >index : number
 
@@ -1406,8 +1352,6 @@ interface RegExpExecArray {
 
 
 interface RegExp {
->RegExp : RegExp
-
     /** 
       * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search.
       * @param string The String object or string literal on which to perform the search.
@@ -1415,7 +1359,6 @@ interface RegExp {
     exec(string: string): RegExpExecArray;
 >exec : (string: string) => RegExpExecArray
 >string : string
->RegExpExecArray : RegExpExecArray
 
     /** 
       * Returns a Boolean value that indicates whether or not a pattern exists in a searched string.
@@ -1447,7 +1390,6 @@ interface RegExp {
     // Non-standard extensions
     compile(): RegExp;
 >compile : () => RegExp
->RegExp : RegExp
 }
 declare var RegExp: {
 >RegExp : { (pattern: string, flags?: string): RegExp; new (pattern: string, flags?: string): RegExp; $1: string; $2: string; $3: string; $4: string; $5: string; $6: string; $7: string; $8: string; $9: string; lastMatch: string; }
@@ -1455,12 +1397,10 @@ declare var RegExp: {
     new (pattern: string, flags?: string): RegExp;
 >pattern : string
 >flags : string
->RegExp : RegExp
 
     (pattern: string, flags?: string): RegExp;
 >pattern : string
 >flags : string
->RegExp : RegExp
 
     // Non-standard extensions
     $1: string;
@@ -1495,8 +1435,6 @@ declare var RegExp: {
 }
 
 interface Error {
->Error : Error
-
     name: string;
 >name : string
 
@@ -1508,140 +1446,105 @@ declare var Error: {
 
     new (message?: string): Error;
 >message : string
->Error : Error
 
     (message?: string): Error;
 >message : string
->Error : Error
 
     prototype: Error;
 >prototype : Error
->Error : Error
 }
 
 interface EvalError extends Error {
->EvalError : EvalError
->Error : Error
 }
 declare var EvalError: {
 >EvalError : { (message?: string): EvalError; new (message?: string): EvalError; prototype: EvalError; }
 
     new (message?: string): EvalError;
 >message : string
->EvalError : EvalError
 
     (message?: string): EvalError;
 >message : string
->EvalError : EvalError
 
     prototype: EvalError;
 >prototype : EvalError
->EvalError : EvalError
 }
 
 interface RangeError extends Error {
->RangeError : RangeError
->Error : Error
 }
 declare var RangeError: {
 >RangeError : { (message?: string): RangeError; new (message?: string): RangeError; prototype: RangeError; }
 
     new (message?: string): RangeError;
 >message : string
->RangeError : RangeError
 
     (message?: string): RangeError;
 >message : string
->RangeError : RangeError
 
     prototype: RangeError;
 >prototype : RangeError
->RangeError : RangeError
 }
 
 interface ReferenceError extends Error {
->ReferenceError : ReferenceError
->Error : Error
 }
 declare var ReferenceError: {
 >ReferenceError : { (message?: string): ReferenceError; new (message?: string): ReferenceError; prototype: ReferenceError; }
 
     new (message?: string): ReferenceError;
 >message : string
->ReferenceError : ReferenceError
 
     (message?: string): ReferenceError;
 >message : string
->ReferenceError : ReferenceError
 
     prototype: ReferenceError;
 >prototype : ReferenceError
->ReferenceError : ReferenceError
 }
 
 interface SyntaxError extends Error {
->SyntaxError : SyntaxError
->Error : Error
 }
 declare var SyntaxError: {
 >SyntaxError : { (message?: string): SyntaxError; new (message?: string): SyntaxError; prototype: SyntaxError; }
 
     new (message?: string): SyntaxError;
 >message : string
->SyntaxError : SyntaxError
 
     (message?: string): SyntaxError;
 >message : string
->SyntaxError : SyntaxError
 
     prototype: SyntaxError;
 >prototype : SyntaxError
->SyntaxError : SyntaxError
 }
 
 interface TypeError extends Error {
->TypeError : TypeError
->Error : Error
 }
 declare var TypeError: {
 >TypeError : { (message?: string): TypeError; new (message?: string): TypeError; prototype: TypeError; }
 
     new (message?: string): TypeError;
 >message : string
->TypeError : TypeError
 
     (message?: string): TypeError;
 >message : string
->TypeError : TypeError
 
     prototype: TypeError;
 >prototype : TypeError
->TypeError : TypeError
 }
 
 interface URIError extends Error {
->URIError : URIError
->Error : Error
 }
 declare var URIError: {
 >URIError : { (message?: string): URIError; new (message?: string): URIError; prototype: URIError; }
 
     new (message?: string): URIError;
 >message : string
->URIError : URIError
 
     (message?: string): URIError;
 >message : string
->URIError : URIError
 
     prototype: URIError;
 >prototype : URIError
->URIError : URIError
 }
 
 interface JSON {
->JSON : JSON
-
     /**
       * Converts a JavaScript Object Notation (JSON) string into an object.
       * @param text A valid JSON string.
@@ -1716,7 +1619,6 @@ interface JSON {
   */
 declare var JSON: JSON;
 >JSON : JSON
->JSON : JSON
 
 
 /////////////////////////////
@@ -1724,9 +1626,6 @@ declare var JSON: JSON;
 /////////////////////////////
 
 interface Array<T> {
->Array : T[]
->T : T
-
     /**
       * Returns a string representation of an array.
       */
@@ -1742,11 +1641,7 @@ interface Array<T> {
       */
     concat<U extends T[]>(...items: U[]): T[];
 >concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
->U : U
->T : T
 >items : U[]
->U : U
->T : T
 
     /**
       * Combines two or more arrays.
@@ -1755,8 +1650,6 @@ interface Array<T> {
     concat(...items: T[]): T[];
 >concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
 >items : T[]
->T : T
->T : T
 
     /**
       * Adds all the elements of an array separated by the specified separator string.
@@ -1771,7 +1664,6 @@ interface Array<T> {
       */
     pop(): T;
 >pop : () => T
->T : T
 
     /**
       * Appends new elements to an array, and returns the new length of the array.
@@ -1780,21 +1672,18 @@ interface Array<T> {
     push(...items: T[]): number;
 >push : (...items: T[]) => number
 >items : T[]
->T : T
 
     /**
       * Reverses the elements in an Array. 
       */
     reverse(): T[];
 >reverse : () => T[]
->T : T
 
     /**
       * Removes the first element from an array and returns it.
       */
     shift(): T;
 >shift : () => T
->T : T
 
     /** 
       * Returns a section of an array.
@@ -1805,7 +1694,6 @@ interface Array<T> {
 >slice : (start?: number, end?: number) => T[]
 >start : number
 >end : number
->T : T
 
     /**
       * Sorts an array.
@@ -1815,10 +1703,7 @@ interface Array<T> {
 >sort : (compareFn?: (a: T, b: T) => number) => T[]
 >compareFn : (a: T, b: T) => number
 >a : T
->T : T
 >b : T
->T : T
->T : T
 
     /**
       * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
@@ -1827,7 +1712,6 @@ interface Array<T> {
     splice(start: number): T[];
 >splice : { (start: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
 >start : number
->T : T
 
     /**
       * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
@@ -1840,8 +1724,6 @@ interface Array<T> {
 >start : number
 >deleteCount : number
 >items : T[]
->T : T
->T : T
 
     /**
       * Inserts new elements at the start of an array.
@@ -1850,7 +1732,6 @@ interface Array<T> {
     unshift(...items: T[]): number;
 >unshift : (...items: T[]) => number
 >items : T[]
->T : T
 
     /**
       * Returns the index of the first occurrence of a value in an array.
@@ -1860,7 +1741,6 @@ interface Array<T> {
     indexOf(searchElement: T, fromIndex?: number): number;
 >indexOf : (searchElement: T, fromIndex?: number) => number
 >searchElement : T
->T : T
 >fromIndex : number
 
     /**
@@ -1871,7 +1751,6 @@ interface Array<T> {
     lastIndexOf(searchElement: T, fromIndex?: number): number;
 >lastIndexOf : (searchElement: T, fromIndex?: number) => number
 >searchElement : T
->T : T
 >fromIndex : number
 
     /**
@@ -1883,10 +1762,8 @@ interface Array<T> {
 >every : (callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any) => boolean
 >callbackfn : (value: T, index: number, array: T[]) => boolean
 >value : T
->T : T
 >index : number
 >array : T[]
->T : T
 >thisArg : any
 
     /**
@@ -1898,10 +1775,8 @@ interface Array<T> {
 >some : (callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any) => boolean
 >callbackfn : (value: T, index: number, array: T[]) => boolean
 >value : T
->T : T
 >index : number
 >array : T[]
->T : T
 >thisArg : any
 
     /**
@@ -1913,10 +1788,8 @@ interface Array<T> {
 >forEach : (callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any) => void
 >callbackfn : (value: T, index: number, array: T[]) => void
 >value : T
->T : T
 >index : number
 >array : T[]
->T : T
 >thisArg : any
 
     /**
@@ -1926,16 +1799,11 @@ interface Array<T> {
       */
     map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
 >map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
->U : U
 >callbackfn : (value: T, index: number, array: T[]) => U
 >value : T
->T : T
 >index : number
 >array : T[]
->T : T
->U : U
 >thisArg : any
->U : U
 
     /**
       * Returns the elements of an array that meet the condition specified in a callback function. 
@@ -1946,12 +1814,9 @@ interface Array<T> {
 >filter : (callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any) => T[]
 >callbackfn : (value: T, index: number, array: T[]) => boolean
 >value : T
->T : T
 >index : number
 >array : T[]
->T : T
 >thisArg : any
->T : T
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -1962,16 +1827,10 @@ interface Array<T> {
 >reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
 >callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
 >previousValue : T
->T : T
 >currentValue : T
->T : T
 >currentIndex : number
 >array : T[]
->T : T
->T : T
 >initialValue : T
->T : T
->T : T
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -1980,19 +1839,12 @@ interface Array<T> {
       */
     reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
 >reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->U : U
 >callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
 >previousValue : U
->U : U
 >currentValue : T
->T : T
 >currentIndex : number
 >array : T[]
->T : T
->U : U
 >initialValue : U
->U : U
->U : U
 
     /** 
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -2003,16 +1855,10 @@ interface Array<T> {
 >reduceRight : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
 >callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
 >previousValue : T
->T : T
 >currentValue : T
->T : T
 >currentIndex : number
 >array : T[]
->T : T
->T : T
 >initialValue : T
->T : T
->T : T
 
     /** 
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -2021,19 +1867,12 @@ interface Array<T> {
       */
     reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
 >reduceRight : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->U : U
 >callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
 >previousValue : U
->U : U
 >currentValue : T
->T : T
 >currentIndex : number
 >array : T[]
->T : T
->U : U
 >initialValue : U
->U : U
->U : U
 
     /**
       * Gets or sets the length of the array. This is a number one higher than the highest element defined in an array.
@@ -2043,7 +1882,6 @@ interface Array<T> {
 
     [n: number]: T;
 >n : number
->T : T
 }
 declare var Array: {
 >Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
@@ -2052,29 +1890,19 @@ declare var Array: {
 >arrayLength : number
 
     new <T>(arrayLength: number): T[];
->T : T
 >arrayLength : number
->T : T
 
     new <T>(...items: T[]): T[];
->T : T
 >items : T[]
->T : T
->T : T
 
     (arrayLength?: number): any[];
 >arrayLength : number
 
     <T>(arrayLength: number): T[];
->T : T
 >arrayLength : number
->T : T
 
     <T>(...items: T[]): T[];
->T : T
 >items : T[]
->T : T
->T : T
 
     isArray(arg: any): boolean;
 >isArray : (arg: any) => boolean
@@ -2082,5 +1910,4 @@ declare var Array: {
 
     prototype: Array<any>;
 >prototype : any[]
->Array : T[]
 }

tests/baselines/reference/2dArrays.types

@@ -15,11 +15,9 @@ class Board {
 
     ships: Ship[];
 >ships : Ship[]
->Ship : Ship
 
     cells: Cell[];
 >cells : Cell[]
->Cell : Cell
 
     private allShipsSunk() {
 >allShipsSunk : () => boolean

tests/baselines/reference/ArrowFunction1.types

@@ -3,6 +3,5 @@ var v = (a: ) => {
 >v : (a: any) => void
 >(a: ) => {   } : (a: any) => void
 >a : any
-> : No type information available!
    
 };

tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.types

@@ -3,14 +3,12 @@
 
 class clodule1<T>{
 >clodule1 : clodule1<T>
->T : T
 
     id: string;
 >id : string
 
     value: T;
 >value : T
->T : T
 }
 
 module clodule1 {
@@ -19,19 +17,16 @@ module clodule1 {
     function f(x: T) { }
 >f : (x: any) => void
 >x : any
->T : No type information available!
 }
 
 class clodule2<T>{
 >clodule2 : clodule2<T>
->T : T
 
     id: string;
 >id : string
 
     value: T;
 >value : T
->T : T
 }
 
 module clodule2 {
@@ -39,32 +34,26 @@ module clodule2 {
 
     var x: T;
 >x : any
->T : No type information available!
 
     class D<U extends T>{
 >D : D<U>
->U : U
->T : No type information available!
 
         id: string;
 >id : string
 
         value: U;
 >value : U
->U : U
     }
 }
 
 class clodule3<T>{
 >clodule3 : clodule3<T>
->T : T
 
     id: string;
 >id : string
 
     value: T;
 >value : T
->T : T
 }
 
 module clodule3 {
@@ -79,14 +68,12 @@ module clodule3 {
 
 class clodule4<T>{
 >clodule4 : clodule4<T>
->T : T
 
     id: string;
 >id : string
 
     value: T;
 >value : T
->T : T
 }
 
 module clodule4 {
@@ -97,7 +84,6 @@ module clodule4 {
 
         name: T;
 >name : any
->T : No type information available!
     }
 }
 

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.types

@@ -1,20 +1,16 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts ===
 class clodule<T> {
 >clodule : clodule<T>
->T : T
 
     id: string;
 >id : string
 
     value: T;
 >value : T
->T : T
 
     static fn<U>(id: U) { }
 >fn : <U>(id: U) => void
->U : U
 >id : U
->U : U
 }
 
 module clodule {
@@ -23,12 +19,8 @@ module clodule {
     // error: duplicate identifier expected
     export function fn<T>(x: T, y: T): T {
 >fn : <T>(x: T, y: T) => T
->T : T
 >x : T
->T : T
 >y : T
->T : T
->T : T
 
         return x;
 >x : T

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.types

@@ -1,14 +1,12 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts ===
 class clodule<T> {
 >clodule : clodule<T>
->T : T
 
     id: string;
 >id : string
 
     value: T;
 >value : T
->T : T
 
     static fn(id: string) { }
 >fn : (id: string) => void
@@ -21,12 +19,8 @@ module clodule {
     // error: duplicate identifier expected
     export function fn<T>(x: T, y: T): T {
 >fn : <T>(x: T, y: T) => T
->T : T
 >x : T
->T : T
 >y : T
->T : T
->T : T
 
         return x;
 >x : T

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types

@@ -1,14 +1,12 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts ===
 class clodule<T> {
 >clodule : clodule<T>
->T : T
 
     id: string;
 >id : string
 
     value: T;
 >value : T
->T : T
 
     private static sfn(id: string) { return 42; }
 >sfn : (id: string) => number
@@ -22,11 +20,8 @@ module clodule {
     // error: duplicate identifier expected
     export function fn<T>(x: T, y: T): number {
 >fn : <T>(x: T, y: T) => number
->T : T
 >x : T
->T : T
 >y : T
->T : T
 
         return clodule.sfn('a');
 >clodule.sfn('a') : number

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types

@@ -8,7 +8,6 @@ class Point {
 
     static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246
 >Origin : () => Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -37,7 +36,6 @@ module A {
 
         static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246
 >Origin : () => Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -8,7 +8,6 @@ class Point {
 
     static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : () => Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -37,7 +36,6 @@ module A {
 
         static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : () => Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.types

@@ -8,7 +8,6 @@ class Point {
 
     static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -37,7 +36,6 @@ module A {
 
         static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types

@@ -8,7 +8,6 @@ class Point {
 
     static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -37,7 +36,6 @@ module A {
 
         static Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0

tests/baselines/reference/ClassDeclaration25.types

@@ -1,24 +1,16 @@
 === tests/cases/compiler/ClassDeclaration25.ts ===
 interface IList<T> {
->IList : IList<T>
->T : T
-
     data(): T;
 >data : () => T
->T : T
 
     next(): string;
 >next : () => string
 }
 class List<U> implements IList<U> {
 >List : List<U>
->U : U
->IList : IList<T>
->U : U
 
     data(): U;
 >data : () => U
->U : U
 
     next(): string;
 >next : () => string

tests/baselines/reference/DeclarationErrorsNoEmitOnError.types

@@ -4,9 +4,6 @@ type T = { x : number }
 >x : number
 
 export interface I {
->I : I
-
     f: T;   
 >f : T
->T : T
 }

tests/baselines/reference/ES5For-ofTypeCheck13.types

@@ -1,7 +1,6 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck13.ts ===
 const strSet: Set<string> = new Set()
 >strSet : Set<string>
->Set : Set<T>
 >new Set() : Set<string>
 >Set : SetConstructor
 

tests/baselines/reference/ES5For-ofTypeCheck14.types

@@ -1,7 +1,6 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck14.ts ===
 var union: string | Set<number>
 >union : string | Set<number>
->Set : Set<T>
 
 for (const e of union) { }
 >e : string

tests/baselines/reference/ES5SymbolProperty1.types

@@ -1,13 +1,10 @@
 === tests/cases/conformance/Symbols/ES5SymbolProperty1.ts ===
 interface SymbolConstructor {
->SymbolConstructor : SymbolConstructor
-
     foo: string;
 >foo : string
 }
 var Symbol: SymbolConstructor;
 >Symbol : SymbolConstructor
->SymbolConstructor : SymbolConstructor
 
 var obj = {
 >obj : { [Symbol.foo]: number; }

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types

@@ -21,7 +21,6 @@ module enumdule {
 
 var x: enumdule;
 >x : enumdule
->enumdule : enumdule
 
 var x = enumdule.Red;
 >x : enumdule

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types

@@ -3,8 +3,6 @@ module A {
 >A : typeof A
 
     interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -14,12 +12,10 @@ module A {
         fromOrigin(p: Point): number;
 >fromOrigin : (p: Point) => number
 >p : Point
->Point : Point
     }
 
     export class Point2d implements Point {
 >Point2d : Point2d
->Point : Point
 
         constructor(public x: number, public y: number) { }
 >x : number
@@ -28,7 +24,6 @@ module A {
         fromOrigin(p: Point) {
 >fromOrigin : (p: Point) => number
 >p : Point
->Point : Point
 
             return 1;
 >1 : 1

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -14,7 +14,6 @@ module A {
 
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -31,7 +30,6 @@ module A {
 
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Point3d
->Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
 >0 : 0
@@ -42,14 +40,10 @@ module A {
 
     export class Line<TPoint extends Point>{
 >Line : Line<TPoint>
->TPoint : TPoint
->Point : Point
 
         constructor(public start: TPoint, public end: TPoint) { }
 >start : TPoint
->TPoint : TPoint
 >end : TPoint
->TPoint : TPoint
     }
 }
 

tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.types

@@ -17,11 +17,9 @@ module A {
 
         [idx: number]: Point;
 >idx : number
->Point : Point
 
         [idx: string]: Point;
 >idx : string
->Point : Point
     }
 }
 

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -14,7 +14,6 @@ module A {
 
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -31,7 +30,6 @@ module A {
 
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Point3d
->Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
 >0 : 0
@@ -42,21 +40,14 @@ module A {
 
     export class Line<TPoint extends Point>{
 >Line : Line<TPoint>
->TPoint : TPoint
->Point : Point
 
         constructor(public start: TPoint, public end: TPoint) { }
 >start : TPoint
->TPoint : TPoint
 >end : TPoint
->TPoint : TPoint
 
         static fromorigin2d(p: Point): Line<Point>{
 >fromorigin2d : (p: Point) => Line<Point>
 >p : Point
->Point : Point
->Line : Line<TPoint>
->Point : Point
 
             return null;
 >null : null

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

@@ -17,16 +17,12 @@ module A {
 
         constructor(public start: Point, public end: Point) { }
 >start : Point
->Point : Point
 >end : Point
->Point : Point
     }
 
     export function fromOrigin(p: Point): Line {
 >fromOrigin : (p: Point) => Line
 >p : Point
->Point : Point
->Line : Line
 
         return new Line({ x: 0, y: 0 }, p);
 >new Line({ x: 0, y: 0 }, p) : Line

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types

@@ -17,16 +17,12 @@ module A {
 
         constructor(public start: Point, public end: Point) { }
 >start : Point
->Point : Point
 >end : Point
->Point : Point
     }
 
     export function fromOrigin(p: Point): Line {
 >fromOrigin : (p: Point) => Line
 >p : Point
->Point : Point
->Line : Line
 
         return new Line({ x: 0, y: 0 }, p);
 >new Line({ x: 0, y: 0 }, p) : Line

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types

@@ -17,16 +17,12 @@ module A {
 
         constructor(public start: Point, public end: Point) { }
 >start : Point
->Point : Point
 >end : Point
->Point : Point
     }
 
     export function fromOrigin(p: Point): Line {
 >fromOrigin : (p: Point) => Line
 >p : Point
->Point : Point
->Line : Line
 
         return new Line({ x: 0, y: 0 }, p);
 >new Line({ x: 0, y: 0 }, p) : Line

tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -3,8 +3,6 @@ module A {
 >A : typeof A
 
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -14,7 +12,6 @@ module A {
 
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -22,16 +19,12 @@ module A {
 >0 : 0
 
     export interface Point3d extends Point {
->Point3d : Point3d
->Point : Point
-
         z: number;
 >z : number
     }
 
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Point3d
->Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
 >0 : 0
@@ -41,23 +34,15 @@ module A {
 >0 : 0
 
     export interface Line<TPoint extends Point>{
->Line : Line<TPoint>
->TPoint : TPoint
->Point : Point
-
         new (start: TPoint, end: TPoint);
 >start : TPoint
->TPoint : TPoint
 >end : TPoint
->TPoint : TPoint
 
         start: TPoint;
 >start : TPoint
->TPoint : TPoint
 
         end: TPoint;
 >end : TPoint
->TPoint : TPoint
     }
 }
 

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.types

@@ -1,10 +1,7 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
 module A {
->A : any
 
     interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -13,15 +10,12 @@ module A {
     }
 
     export interface points {
->points : points
 
         [idx: number]: Point;
 >idx : number
->Point : Point
 
         [idx: string]: Point;
 >idx : string
->Point : Point
     }
 }
 

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.types

@@ -3,8 +3,6 @@ module A {
 >A : typeof A
 
     interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -14,7 +12,6 @@ module A {
 
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -22,16 +19,12 @@ module A {
 >0 : 0
 
     export interface Point3d extends Point {
->Point3d : Point3d
->Point : Point
-
         z: number;
 >z : number
     }
 
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Point3d
->Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
 >0 : 0
@@ -41,23 +34,15 @@ module A {
 >0 : 0
 
     export interface Line<TPoint extends Point>{
->Line : Line<TPoint>
->TPoint : TPoint
->Point : Point
-
         new (start: TPoint, end: TPoint);
 >start : TPoint
->TPoint : TPoint
 >end : TPoint
->TPoint : TPoint
 
         start: TPoint;
 >start : TPoint
->TPoint : TPoint
 
         end: TPoint;
 >end : TPoint
->TPoint : TPoint
     }
 }
 

tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.types

@@ -15,7 +15,6 @@ module A {
 
         export var Origin: Point = new Point(0, 0);
 >Origin : Point
->Point : Point
 >new Point(0, 0) : Point
 >Point : typeof Point
 >0 : 0
@@ -26,16 +25,13 @@ module A {
 
             constructor(start: Point, end: Point) {
 >start : Point
->Point : Point
 >end : Point
->Point : Point
 
             }
 
             static fromOrigin(p: Point) {
 >fromOrigin : (p: Point) => Line
 >p : Point
->Point : Point
 
                 return new Line({ x: 0, y: 0 }, p);
 >new Line({ x: 0, y: 0 }, p) : Line

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.types

@@ -12,7 +12,6 @@ module A {
 
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.types

@@ -16,16 +16,12 @@ module A {
         top: { left: Point, right: Point },
 >top : { left: Point; right: Point; }
 >left : Point
->Point : Point
 >right : Point
->Point : Point
 
         bottom: { left: Point, right: Point }
 >bottom : { left: Point; right: Point; }
 >left : Point
->Point : Point
 >right : Point
->Point : Point
 
     } = null;
 >null : null

tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.types

@@ -11,12 +11,9 @@ module A {
 
     export var beez: Array<B>;
 >beez : B[]
->Array : T[]
->B : B
 
     export var beez2 = new Array<B>();
 >beez2 : B[]
 >new Array<B>() : B[]
 >Array : ArrayConstructor
->B : B
 }

tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.types

@@ -3,8 +3,6 @@ module A {
 >A : typeof A
 
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -15,7 +13,6 @@ module A {
     // valid since Point is exported
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0

tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.types

@@ -3,8 +3,6 @@ module A {
 >A : typeof A
 
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -15,7 +13,6 @@ module A {
     // valid since Point is exported
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -23,9 +20,6 @@ module A {
 >0 : 0
 
     interface Point3d extends Point {
->Point3d : Point3d
->Point : Point
-
         z: number;
 >z : number
     }
@@ -33,7 +27,6 @@ module A {
     // invalid Point3d is not exported
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
 >Origin3d : Point3d
->Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
 >0 : 0

tests/baselines/reference/FunctionDeclaration13_es6.types

@@ -5,6 +5,5 @@ function * foo() {
    // Legal to use 'yield' in a type context.
    var v: yield;
 >v : any
->yield : No type information available!
 }
 

tests/baselines/reference/FunctionPropertyAssignments6_es6.types

@@ -3,5 +3,4 @@ var v = { *<T>() { } }
 >v : { (Missing)<T>(): IterableIterator<any>; }
 >{ *<T>() { } } : { (Missing)<T>(): IterableIterator<any>; }
 > : <T>() => IterableIterator<any>
->T : T
 

tests/baselines/reference/InterfaceDeclaration8.types

@@ -1,4 +1,4 @@
 === tests/cases/compiler/InterfaceDeclaration8.ts ===
 interface string {
->string : string
-}
+No type information for this code.}
+No type information for this code.

tests/baselines/reference/InvalidNonInstantiatedModule.types

@@ -1,9 +1,6 @@
 === tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts ===
 module M {
->M : any
-
     export interface Point { x: number; y: number }
->Point : Point
 >x : number
 >y : number
 }

tests/baselines/reference/MemberFunctionDeclaration7_es6.types

@@ -4,5 +4,4 @@ class C {
 
    *foo<T>() { }
 >foo : <T>() => IterableIterator<any>
->T : T
 }

tests/baselines/reference/ModuleAndEnumWithSameNameAndCommonRoot.types

@@ -21,7 +21,6 @@ enum enumdule {
 
 var x: enumdule;
 >x : enumdule
->enumdule : enumdule
 
 var x = enumdule.Red;
 >x : enumdule

tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.types

@@ -14,16 +14,12 @@ module A {
 
     export class AG<T, U>{
 >AG : AG<T, U>
->T : T
->U : U
 
         id: T;
 >id : T
->T : T
 
         name: U;
 >name : U
->U : U
     }
 
     class A2 {
@@ -38,16 +34,12 @@ module A {
 
     class AG2<T, U>{
 >AG2 : AG2<T, U>
->T : T
->U : U
 
         id: T;
 >id : T
->T : T
 
         name: U;
 >name : U
->U : U
     }
 }
 

tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.types

@@ -17,7 +17,6 @@ module A {
 var a: A.Color = A.Color.Red;
 >a : A.Color
 >A : any
->Color : A.Color
 >A.Color.Red : A.Color.Red
 >A.Color : typeof A.Color
 >A : typeof A

tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.types

@@ -12,11 +12,7 @@ module A {
 
     export function fng<T, U>(s: T): U {
 >fng : <T, U>(s: T) => U
->T : T
->U : U
 >s : T
->T : T
->U : U
 
         return null;
 >null : null
@@ -32,11 +28,7 @@ module A {
 
     function fng2<T, U>(s: T): U {
 >fng2 : <T, U>(s: T) => U
->T : T
->U : U
 >s : T
->T : T
->U : U
 
         return null;
 >null : null
@@ -56,11 +48,7 @@ var fn = A.fn;
 
 var fng: <T, U>(s: T) => U;
 >fng : <T, U>(s: T) => U
->T : T
->U : U
 >s : T
->T : T
->U : U
 
 var fng = A.fng; // bug 838015
 >fng : <T, U>(s: T) => U

tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.types

@@ -1,10 +1,6 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedImportAlias.ts ===
 module A {
->A : any
-
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -13,9 +9,6 @@ module A {
     }
 
     interface Point3d extends Point {
->Point3d : Point3d
->Point : Point
-
         z: number;
 >z : number
     }
@@ -30,10 +23,8 @@ module B {
         constructor(public start: A.Point, public end: A.Point) { }
 >start : A.Point
 >A : any
->Point : A.Point
 >end : A.Point
 >A : any
->Point : A.Point
     }
 }
 
@@ -51,7 +42,6 @@ module Geometry {
     export var Origin: Points.Point = { x: 0, y: 0 };
 >Origin : Points.Point
 >Points : any
->Point : Points.Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -62,7 +52,6 @@ module Geometry {
     export var Unit: Lines.Line = new Lines.Line(Origin, { x: 1, y: 0 });
 >Unit : Lines.Line
 >Lines : any
->Line : Lines.Line
 >new Lines.Line(Origin, { x: 1, y: 0 }) : Lines.Line
 >Lines.Line : typeof Lines.Line
 >Lines : typeof Lines
@@ -85,7 +74,6 @@ var p: Geometry.Points.Point;
 >p : { x: number; y: number; }
 >Geometry : any
 >Points : any
->Point : A.Point
 
 var p = Geometry.Origin;
 >p : { x: number; y: number; }

tests/baselines/reference/NonInitializedExportInInternalModule.types

@@ -25,11 +25,9 @@ module Inner {
 
     export var e: A;
 >e : A
->A : A
 
     export let f: A;
 >f : A
->A : A
     
     namespace B {
 >B : typeof B
@@ -95,13 +93,11 @@ module Inner {
 
     export var g1: D = new D;
 >g1 : D
->D : D
 >new D : D
 >D : typeof D
 
     export let h1: D = new D;
 >h1 : D
->D : D
 >new D : D
 >D : typeof D
 }

tests/baselines/reference/ParameterList13.types

@@ -1,7 +1,5 @@
 === tests/cases/compiler/ParameterList13.ts ===
 interface I {
->I : I
-
     new (public x);
 >x : any
 }

tests/baselines/reference/ParameterList5.types

@@ -2,5 +2,4 @@
 function A(): (public B) => C {
 >A : () => (B: any) => any
 >B : any
->C : No type information available!
 }

tests/baselines/reference/Protected2.types

@@ -1,4 +1,4 @@
 === tests/cases/conformance/parser/ecmascript5/Protected/Protected2.ts ===
 protected module M {
->M : any
-}
+No type information for this code.}
+No type information for this code.

tests/baselines/reference/Protected8.types

@@ -1,7 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Protected/Protected8.ts ===
 interface I {
->I : I
-
    protected
 >protected : any
 

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.types

@@ -23,7 +23,6 @@ module A {
 >fromCarthesian : (p: A.Point) => { x: number; y: number; }
 >p : A.Point
 >A : any
->Point : A.Point
 
             return { x: p.x, y: p.y };
 >{ x: p.x, y: p.y } : { x: number; y: number; }
@@ -48,7 +47,6 @@ var p: { x: number; y: number; };
 var p: A.Point;
 >p : { x: number; y: number; }
 >A : any
->Point : A.Point
 
 module X.Y.Z {
 >X : typeof X
@@ -92,6 +90,5 @@ var l: X.Y.Z.Line;
 >X : any
 >Y : any
 >Z : any
->Line : X.Y.Z.Line
 
 

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.types

@@ -1,10 +1,6 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts ===
 module A {
->A : any
-
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -13,19 +9,13 @@ module A {
 
         toCarth(): Point;
 >toCarth : () => Point
->Point : Point
     }
 }
 
 module A {
->A : any
-
     interface Point {
->Point : Point
-
         fromCarth(): Point;
 >fromCarth : () => Point
->Point : Point
     }
 }
 
@@ -36,50 +26,31 @@ var p: { x: number; y: number; toCarth(): A.Point; };
 >y : number
 >toCarth : () => A.Point
 >A : any
->Point : A.Point
 
 var p: A.Point;
 >p : { x: number; y: number; toCarth(): A.Point; }
 >A : any
->Point : A.Point
 
 module X.Y.Z {
->X : any
->Y : any
->Z : any
-
     export interface Line {
->Line : Line
-
         new (start: A.Point, end: A.Point);
 >start : A.Point
 >A : any
->Point : A.Point
 >end : A.Point
 >A : any
->Point : A.Point
     }
 }
 
 module X {
->X : any
-
     export module Y.Z {
->Y : any
->Z : any
-
         interface Line {
->Line : Line
-
             start: A.Point;
 >start : A.Point
 >A : any
->Point : A.Point
 
             end: A.Point;
 >end : A.Point
 >A : any
->Point : A.Point
         }
     }
 }
@@ -89,15 +60,12 @@ var l: { new (s: A.Point, e: A.Point); }
 >l : new (s: A.Point, e: A.Point) => any
 >s : A.Point
 >A : any
->Point : A.Point
 >e : A.Point
 >A : any
->Point : A.Point
 
 var l: X.Y.Z.Line;
 >l : new (s: A.Point, e: A.Point) => any
 >X : any
 >Y : any
 >Z : any
->Line : X.Y.Z.Line
 

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types

@@ -3,8 +3,6 @@ module A {
 >A : typeof A
 
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -17,10 +15,7 @@ module A {
 
         export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->T : T
->Point : Point
 >p : T
->T : T
 
             return { x: p.y, y: p.x };
 >{ x: p.y, y: p.x } : { x: number; y: number; }
@@ -36,7 +31,6 @@ module A {
     }
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -61,9 +55,7 @@ module A {
 
             constructor(public tl: Point, public br: Point) { }
 >tl : Point
->Point : Point
 >br : Point
->Point : Point
         }
     }
 }
@@ -79,7 +71,6 @@ var o: { x: number; y: number };
 var o: A.Point;
 >o : { x: number; y: number; }
 >A : any
->Point : A.Point
 
 var o = A.Origin;
 >o : { x: number; y: number; }
@@ -101,16 +92,13 @@ var p: { tl: A.Point; br: A.Point };
 >p : { tl: A.Point; br: A.Point; }
 >tl : A.Point
 >A : any
->Point : A.Point
 >br : A.Point
 >A : any
->Point : A.Point
 
 var p: A.Utils.Plane;
 >p : { tl: A.Point; br: A.Point; }
 >A : any
 >Utils : any
->Plane : A.Utils.Plane
 
 var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >p : { tl: A.Point; br: A.Point; }

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.types

@@ -1,10 +1,6 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts ===
 module A {
->A : any
-
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -13,19 +9,13 @@ module A {
 
         toCarth(): Point;
 >toCarth : () => Point
->Point : Point
     }
 }
 
 module A {
->A : any
-
     export interface Point {
->Point : Point
-
         fromCarth(): Point;
 >fromCarth : () => Point
->Point : Point
     }
 }
 
@@ -36,53 +26,33 @@ var p: { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; };
 >y : number
 >toCarth : () => A.Point
 >A : any
->Point : A.Point
 >fromCarth : () => A.Point
 >A : any
->Point : A.Point
 
 var p: A.Point;
 >p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
 >A : any
->Point : A.Point
 
 module X.Y.Z {
->X : any
->Y : any
->Z : any
-
     export interface Line {
->Line : Line
-
         new (start: A.Point, end: A.Point);
 >start : A.Point
 >A : any
->Point : A.Point
 >end : A.Point
 >A : any
->Point : A.Point
     }
 }
 
 module X {
->X : any
-
     export module Y.Z {
->Y : any
->Z : any
-
         export interface Line {
->Line : Line
-
             start: A.Point;
 >start : A.Point
 >A : any
->Point : A.Point
 
             end: A.Point;
 >end : A.Point
 >A : any
->Point : A.Point
         }
     }
 }
@@ -92,21 +62,16 @@ var l: { start: A.Point; end: A.Point; new (s: A.Point, e: A.Point); }
 >l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
 >start : A.Point
 >A : any
->Point : A.Point
 >end : A.Point
 >A : any
->Point : A.Point
 >s : A.Point
 >A : any
->Point : A.Point
 >e : A.Point
 >A : any
->Point : A.Point
 
 var l: X.Y.Z.Line;
 >l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
 >X : any
 >Y : any
 >Z : any
->Line : X.Y.Z.Line
 

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types

@@ -3,8 +3,6 @@ export module A {
 >A : typeof A
 
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -17,10 +15,7 @@ export module A {
 
         export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->T : T
->Point : Point
 >p : T
->T : T
 
             return { x: p.y, y: p.x };
 >{ x: p.y, y: p.x } : { x: number; y: number; }
@@ -37,7 +32,6 @@ export module A {
 
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -52,7 +46,6 @@ export module A {
     // collision with 'Origin' var in other part of merged module
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : any
->Point : No type information available!
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -67,9 +60,7 @@ export module A {
 
             constructor(public tl: Point, public br: Point) { }
 >tl : any
->Point : No type information available!
 >br : any
->Point : No type information available!
         }
     }
 }

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.types

@@ -72,5 +72,4 @@ var l: X.Y.Z.Line;
 >X : any
 >Y : any
 >Z : any
->Line : X.Y.Z.Line
 

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types

@@ -6,8 +6,6 @@ module Root {
 >A : typeof A
 
         export interface Point {
->Point : Point
-
             x: number;
 >x : number
 
@@ -20,10 +18,7 @@ module Root {
 
             export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->T : T
->Point : Point
 >p : T
->T : T
 
                 return { x: p.y, y: p.x };
 >{ x: p.y, y: p.x } : { x: number; y: number; }
@@ -52,7 +47,6 @@ module otherRoot {
 >Origin : Root.A.Point
 >Root : any
 >A : any
->Point : Root.A.Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -69,11 +63,9 @@ module otherRoot {
 >tl : Root.A.Point
 >Root : any
 >A : any
->Point : Root.A.Point
 >br : Root.A.Point
 >Root : any
 >A : any
->Point : Root.A.Point
             }
         }
     }

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types

@@ -3,8 +3,6 @@ module A {
 >A : typeof A
 
     export interface Point {
->Point : Point
-
         x: number;
 >x : number
 
@@ -17,10 +15,7 @@ module A {
 
         export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->T : T
->Point : Point
 >p : T
->T : T
 
             return { x: p.y, y: p.x };
 >{ x: p.y, y: p.x } : { x: number; y: number; }
@@ -42,7 +37,6 @@ module A {
 
     export var Origin: Point = { x: 0, y: 0 };
 >Origin : Point
->Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
 >0 : 0
@@ -57,9 +51,7 @@ module A {
 
             constructor(public tl: Point, public br: Point) { }
 >tl : Point
->Point : Point
 >br : Point
->Point : Point
         }
     }
 }
@@ -75,7 +67,6 @@ var o: { x: number; y: number };
 var o: A.Point;
 >o : { x: number; y: number; }
 >A : any
->Point : A.Point
 
 var o = A.Origin;
 >o : { x: number; y: number; }
@@ -97,16 +88,13 @@ var p: { tl: A.Point; br: A.Point };
 >p : { tl: A.Point; br: A.Point; }
 >tl : A.Point
 >A : any
->Point : A.Point
 >br : A.Point
 >A : any
->Point : A.Point
 
 var p: A.Utils.Plane;
 >p : { tl: A.Point; br: A.Point; }
 >A : any
 >Utils : any
->Plane : A.Utils.Plane
 
 var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >p : { tl: A.Point; br: A.Point; }

tests/baselines/reference/TypeGuardWithArrayUnion.types

@@ -9,8 +9,6 @@ class Message {
 function saySize(message: Message | Message[]) {
 >saySize : (message: Message | Message[]) => number
 >message : Message | Message[]
->Message : Message
->Message : Message
 
     if (message instanceof Array) {
 >message instanceof Array : boolean

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -8,7 +8,6 @@ enum Color { R, G, B }
 function f1(x: Color | string) {
 >f1 : (x: string | Color) => void
 >x : string | Color
->Color : Color
 
     if (typeof x === "number") {
 >typeof x === "number" : boolean
@@ -22,7 +21,6 @@ function f1(x: Color | string) {
 
         var y: Color;
 >y : Color
->Color : Color
     }
     else {
         var z = x;
@@ -37,7 +35,6 @@ function f1(x: Color | string) {
 function f2(x: Color | string | string[]) {
 >f2 : (x: string | Color | string[]) => void
 >x : string | Color | string[]
->Color : Color
 
     if (typeof x === "object") {
 >typeof x === "object" : boolean
@@ -64,7 +61,6 @@ function f2(x: Color | string | string[]) {
 
         var z: Color;
 >z : Color
->Color : Color
     }
     else {
         var w = x;
@@ -94,7 +90,6 @@ function f2(x: Color | string | string[]) {
 
         var b: Color | string[];
 >b : Color | string[]
->Color : Color
     }
 }
 

tests/baselines/reference/abstractInterfaceIdentifierName.types

@@ -1,7 +1,5 @@
 === tests/cases/compiler/abstractInterfaceIdentifierName.ts ===
 interface abstract {
->abstract : abstract
-
     abstract(): void;
 >abstract : () => void
 }

tests/baselines/reference/abstractProperty.types

@@ -1,7 +1,5 @@
 === tests/cases/compiler/abstractProperty.ts ===
 interface A {
->A : A
-
     prop: string;
 >prop : string
 
@@ -13,7 +11,6 @@ interface A {
 }
 abstract class B implements A {
 >B : B
->A : A
 
     abstract prop: string;
 >prop : string

tests/baselines/reference/abstractPropertyInConstructor.types

@@ -5,7 +5,6 @@ abstract class AbstractClass {
     constructor(str: string, other: AbstractClass) {
 >str : string
 >other : AbstractClass
->AbstractClass : AbstractClass
 
         this.method(parseInt(str));
 >this.method(parseInt(str)) : void
@@ -97,7 +96,6 @@ class User {
 
     constructor(a: AbstractClass) {
 >a : AbstractClass
->AbstractClass : AbstractClass
 
         a.prop;
 >a.prop : string

tests/baselines/reference/abstractPropertyNegative.types

@@ -1,7 +1,5 @@
 === tests/cases/compiler/abstractPropertyNegative.ts ===
 interface A {
->A : A
-
     prop: string;
 >prop : string
 
@@ -10,7 +8,6 @@ interface A {
 }
 abstract class B implements A {
 >B : B
->A : A
 
     abstract prop: string;
 >prop : string

tests/baselines/reference/acceptableAlias1.types

@@ -3,7 +3,6 @@ module M {
 >M : typeof M
 
     export module N {
->N : any
     }
     export import X = N;
 >X : any

tests/baselines/reference/accessorsAreNotContextuallyTyped.types

@@ -22,7 +22,6 @@ class C {
 
 var c: C;
 >c : C
->C : C
 
 var r = c.x(''); // string
 >r : string

tests/baselines/reference/accessorsEmit.types

@@ -7,7 +7,6 @@ class Test {
 
     get Property(): Result {
 >Property : Result
->Result : Result
 
         var x = 1;
 >x : number

tests/baselines/reference/accessors_spec_section-4.5_inference.types

@@ -12,7 +12,6 @@ class LanguageSpec_section_4_5_inference {
     public set InferredGetterFromSetterAnnotation(a: A) { }
 >InferredGetterFromSetterAnnotation : A
 >a : A
->A : A
 
     public get InferredGetterFromSetterAnnotation() { return new B(); }
 >InferredGetterFromSetterAnnotation : A
@@ -27,7 +26,6 @@ class LanguageSpec_section_4_5_inference {
     public set InferredGetterFromSetterAnnotation_GetterFirst(a: A) { }
 >InferredGetterFromSetterAnnotation_GetterFirst : A
 >a : A
->A : A
     
 
     public get InferredFromGetter() { return new B(); }
@@ -54,13 +52,11 @@ class LanguageSpec_section_4_5_inference {
 
     public get InferredSetterFromGetterAnnotation() : A { return new B(); }
 >InferredSetterFromGetterAnnotation : A
->A : A
 >new B() : B
 >B : typeof B
 
     public get InferredSetterFromGetterAnnotation_GetterFirst() : A { return new B(); }
 >InferredSetterFromGetterAnnotation_GetterFirst : A
->A : A
 >new B() : B
 >B : typeof B
 

tests/baselines/reference/addMoreCallSignaturesToBaseSignature.types

@@ -1,21 +1,15 @@
 === tests/cases/compiler/addMoreCallSignaturesToBaseSignature.ts ===
 interface Foo {
->Foo : Foo
-
     (): string;
 }
 
 interface Bar extends Foo {
->Bar : Bar
->Foo : Foo
-
     (key: string): string;
 >key : string
 }
 
 var a: Bar;
 >a : Bar
->Bar : Bar
 
 var kitty = a();
 >kitty : string

tests/baselines/reference/addMoreCallSignaturesToBaseSignature2.types

@@ -1,22 +1,16 @@
 === tests/cases/compiler/addMoreCallSignaturesToBaseSignature2.ts ===
 interface Foo {
->Foo : Foo
-
     (bar:number): string;
 >bar : number
 }
 
 interface Bar extends Foo {
->Bar : Bar
->Foo : Foo
-
     (key: string): string;
 >key : string
 }
 
 var a: Bar;
 >a : Bar
->Bar : Bar
 
 var kitty = a(1);
 >kitty : string

tests/baselines/reference/addMoreOverloadsToBaseSignature.types

@@ -1,15 +1,10 @@
 === tests/cases/compiler/addMoreOverloadsToBaseSignature.ts ===
 interface Foo {
->Foo : Foo
-
     f(): string;
 >f : () => string
 }
 
 interface Bar extends Foo {
->Bar : Bar
->Foo : Foo
-
     f(key: string): string;
 >f : (key: string) => string
 >key : string

tests/baselines/reference/additionOperatorWithAnyAndEveryType.types

@@ -35,7 +35,6 @@ var d: string;
 
 var e: Object;
 >e : Object
->Object : Object
 
 // any as left operand, result is type Any except plusing string
 var r1 = a + a;

tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types

@@ -2,15 +2,9 @@
 // test for #17069
 function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k: K) {
 >sum : <T extends Record<K, number>, K extends string>(n: number, v: T, k: K) => void
->T : T
->Record : Record<K, T>
->K : K
->K : K
 >n : number
 >v : T
->T : T
 >k : K
->K : K
 
     n = n + v[k];
 >n = n + v[k] : number
@@ -30,15 +24,9 @@ function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k:
 }
 function realSum<T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) {
 >realSum : <T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) => void
->T : T
->Record : Record<K, T>
->K : K
->K : K
 >n : number
 >vs : T[]
->T : T
 >k : K
->K : K
 
     for (const v of vs) {
 >v : T

tests/baselines/reference/additionOperatorWithInvalidOperands.types

@@ -29,11 +29,9 @@ var b: number;
 
 var c: Object;
 >c : Object
->Object : Object
 
 var d: Number;
 >d : Number
->Number : Number
 
 // boolean + every type except any and string
 var r1 = a + a;

tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types

@@ -10,14 +10,12 @@ var a: boolean;
 
 var b: Object;
 >b : Object
->Object : Object
 
 var c: void;
 >c : void
 
 var d: Number;
 >d : Number
->Number : Number
 
 // null + boolean/Object
 var r1 = null + a;

tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types

@@ -15,7 +15,6 @@ var b: number;
 
 var c: E;
 >c : E
->E : E
 
 var d: string;
 >d : string

tests/baselines/reference/additionOperatorWithNumberAndEnum.types

@@ -14,12 +14,9 @@ var a: number;
 
 var b: E;
 >b : E
->E : E
 
 var c: E | F;
 >c : E | F
->E : E
->F : F
 
 var r1 = a + a;
 >r1 : number

tests/baselines/reference/additionOperatorWithStringAndEveryType.types

@@ -19,14 +19,12 @@ var d: string;
 
 var e: Object;
 >e : Object
->Object : Object
 
 var f: void;
 >f : void
 
 var g: E;
 >g : E
->E : E
 
 var x: string;
 >x : string

tests/baselines/reference/additionOperatorWithTypeParameter.types

@@ -7,12 +7,8 @@ enum E { a, b }
 
 function foo<T, U>(t: T, u: U) {
 >foo : <T, U>(t: T, u: U) => void
->T : T
->U : U
 >t : T
->T : T
 >u : U
->U : U
 
     var a: any;
 >a : any
@@ -28,11 +24,9 @@ function foo<T, U>(t: T, u: U) {
 
     var e: Object;
 >e : Object
->Object : Object
 
     var g: E;
 >g : E
->E : E
 
     var f: void;
 >f : void

tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types

@@ -10,14 +10,12 @@ var a: boolean;
 
 var b: Object;
 >b : Object
->Object : Object
 
 var c: void;
 >c : void
 
 var d: Number;
 >d : Number
->Number : Number
 
 // undefined + boolean/Object
 var r1 = undefined + a;

tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types

@@ -15,7 +15,6 @@ var b: number;
 
 var c: E;
 >c : E
->E : E
 
 var d: string;
 >d : string

tests/baselines/reference/aliasBug.types

@@ -35,17 +35,14 @@ function use() {
   var p1: provide.Provide; // error here, but should be okay
 >p1 : provide.Provide
 >provide : any
->Provide : provide.Provide
 
   var p2: foo.Provide;
 >p2 : provide.Provide
 >foo : any
->Provide : provide.Provide
 
   var p3:booz.bar;
 >p3 : any
 >booz : any
->bar : No type information available!
 
   var p22 = new provide.Provide();
 >p22 : provide.Provide

tests/baselines/reference/aliasErrors.types

@@ -75,17 +75,14 @@ function use() {
   var p1: provide.Provide; 
 >p1 : provide.Provide
 >provide : any
->Provide : provide.Provide
 
   var p2: foo.Provide;
 >p2 : provide.Provide
 >foo : any
->Provide : provide.Provide
 
   var p3:booz.bar;
 >p3 : any
 >booz : any
->bar : No type information available!
 
   var p22 = new provide.Provide();
 >p22 : provide.Provide

tests/baselines/reference/aliasInaccessibleModule.types

@@ -3,7 +3,6 @@ module M {
 >M : typeof M
 
     module N {
->N : any
     }
     export import X = N;
 >X : any

tests/baselines/reference/aliasOnMergedModuleInterface.types

@@ -5,7 +5,6 @@ import foo = require("foo")
 
 var z: foo;
 >z : foo
->foo : foo
 
 z.bar("hello"); // This should be ok
 >z.bar("hello") : foo.A
@@ -17,7 +16,6 @@ z.bar("hello"); // This should be ok
 var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error
 >x : foo.A
 >foo : any
->A : foo.A
 >foo.bar("hello") : any
 >foo.bar : any
 >foo : any
@@ -29,20 +27,14 @@ declare module "foo"
 >"foo" : typeof import("foo")
 {
     module B {
->B : any
-
         export interface A {
->A : A
         }
     }
     interface B {
->B : B
-
         bar(name: string): B.A;
 >bar : (name: string) => B.A
 >name : string
 >B : any
->A : B.A
     }
     export = B;
 >B : B

tests/baselines/reference/aliasUsageInAccessorsOfClass.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsage1_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -19,7 +17,6 @@ class C2 {
 
     x: IHasVisualizationModel;
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 
     get A() {
 >A : IHasVisualizationModel

tests/baselines/reference/aliasUsageInArray.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInArray_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -17,7 +15,6 @@ interface IHasVisualizationModel {
 
 var xs: IHasVisualizationModel[] = [moduleA];
 >xs : IHasVisualizationModel[]
->IHasVisualizationModel : IHasVisualizationModel
 >[moduleA] : (typeof moduleA)[]
 >moduleA : typeof moduleA
 

tests/baselines/reference/aliasUsageInFunctionExpression.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInFunctionExpression_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -18,7 +16,6 @@ var f = (x: IHasVisualizationModel) => x;
 >f : (x: IHasVisualizationModel) => IHasVisualizationModel
 >(x: IHasVisualizationModel) => x : (x: IHasVisualizationModel) => IHasVisualizationModel
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >x : IHasVisualizationModel
 
 f = (x) => moduleA;

tests/baselines/reference/aliasUsageInGenericFunction.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInGenericFunction_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -16,11 +14,8 @@ interface IHasVisualizationModel {
 }
 function foo<T extends { a: IHasVisualizationModel }>(x: T) {
 >foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
->T : T
 >a : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >x : T
->T : T
 
     return x;
 >x : T
@@ -40,7 +35,6 @@ var r2 = foo({ a: <IHasVisualizationModel>null });
 >{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
 >a : IHasVisualizationModel
 ><IHasVisualizationModel>null : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >null : null
 
 === tests/cases/compiler/aliasUsageInGenericFunction_backbone.ts ===

tests/baselines/reference/aliasUsageInIndexerOfClass.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInIndexerOfClass_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -19,7 +17,6 @@ class N {
 
     [idx: string]: IHasVisualizationModel
 >idx : string
->IHasVisualizationModel : IHasVisualizationModel
 
     x = moduleA;
 >x : typeof moduleA
@@ -34,7 +31,6 @@ class N2 {
 
     x: IHasVisualizationModel;
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 }
 === tests/cases/compiler/aliasUsageInIndexerOfClass_backbone.ts ===
 export class Model {

tests/baselines/reference/aliasUsageInObjectLiteral.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInObjectLiteral_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -25,7 +23,6 @@ var a: { x: typeof moduleA } = { x: moduleA };
 var b: { x: IHasVisualizationModel } = { x: moduleA };
 >b : { x: IHasVisualizationModel; }
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >{ x: moduleA } : { x: typeof moduleA; }
 >x : typeof moduleA
 >moduleA : typeof moduleA
@@ -34,7 +31,6 @@ var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
 >c : { y: { z: IHasVisualizationModel; }; }
 >y : { z: IHasVisualizationModel; }
 >z : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >{ y: { z: moduleA } } : { y: { z: typeof moduleA; }; }
 >y : { z: typeof moduleA; }
 >{ z: moduleA } : { z: typeof moduleA; }

tests/baselines/reference/aliasUsageInOrExpression.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInOrExpression_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -16,7 +14,6 @@ interface IHasVisualizationModel {
 }
 var i: IHasVisualizationModel;
 >i : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 
 var d1 = i || moduleA;
 >d1 : IHasVisualizationModel
@@ -26,14 +23,12 @@ var d1 = i || moduleA;
 
 var d2: IHasVisualizationModel = i || moduleA;
 >d2 : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >i || moduleA : IHasVisualizationModel
 >i : IHasVisualizationModel
 >moduleA : typeof moduleA
 
 var d2: IHasVisualizationModel = moduleA || i;
 >d2 : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >moduleA || i : IHasVisualizationModel
 >moduleA : typeof moduleA
 >i : IHasVisualizationModel
@@ -41,11 +36,9 @@ var d2: IHasVisualizationModel = moduleA || i;
 var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
 >e : { x: IHasVisualizationModel; }
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 ><{ x: IHasVisualizationModel }>null || { x: moduleA } : { x: IHasVisualizationModel; }
 ><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >null : null
 >{ x: moduleA } : { x: typeof moduleA; }
 >x : typeof moduleA
@@ -54,11 +47,9 @@ var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || {
 var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
 >f : { x: IHasVisualizationModel; }
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 ><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: typeof moduleA; }
 ><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
 >x : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 >null : null
 >{ x: moduleA } : { x: typeof moduleA; }
 >x : typeof moduleA

tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInTypeArgumentOfExtendsClause_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -16,17 +14,13 @@ interface IHasVisualizationModel {
 }
 class C<T extends IHasVisualizationModel> {
 >C : C<T>
->T : T
->IHasVisualizationModel : IHasVisualizationModel
 
     x: T;
 >x : T
->T : T
 }
 class D extends C<IHasVisualizationModel> {
 >D : D
 >C : C<IHasVisualizationModel>
->IHasVisualizationModel : IHasVisualizationModel
 
     x = moduleA;
 >x : typeof moduleA

tests/baselines/reference/aliasUsageInVarAssignment.types

@@ -6,8 +6,6 @@ import moduleA = require("./aliasUsageInVarAssignment_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : IHasVisualizationModel
-
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : typeof Backbone.Model
 >Backbone.Model : typeof Backbone.Model
@@ -16,7 +14,6 @@ interface IHasVisualizationModel {
 }
 var i: IHasVisualizationModel;
 >i : IHasVisualizationModel
->IHasVisualizationModel : IHasVisualizationModel
 
 var m: typeof moduleA = i;
 >m : typeof moduleA

tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.types

@@ -10,8 +10,6 @@ var d = b.q3;
 
 === tests/cases/compiler/aliasWithInterfaceExportAssignmentUsedInVarInitializer_0.ts ===
 interface c {
->c : c
-
     q3: number;
 >q3 : number
 }

tests/baselines/reference/allowImportClausesToMergeWithTypes.types

@@ -8,8 +8,6 @@ export default zzz;
 
 === tests/cases/compiler/a.ts ===
 export default interface zzz {
->zzz : zzz
-
     x: string;
 >x : string
 }
@@ -19,7 +17,6 @@ import zzz from "./b";
 
 const x: zzz = { x: "" };
 >x : zzz
->zzz : zzz
 >{ x: "" } : { x: string; }
 >x : string
 >"" : ""
@@ -37,7 +34,6 @@ import zzz from "./a";
 
 const x: zzz = { x: "" };
 >x : zzz
->zzz : zzz
 >{ x: "" } : { x: string; }
 >x : string
 >"" : ""
@@ -53,6 +49,5 @@ originalZZZ;
 
 const y: originalZZZ = x;
 >y : any
->originalZZZ : No type information available!
 >x : zzz
 

tests/baselines/reference/allowJscheckJsTypeParameterNoCrash.types

@@ -1,23 +1,15 @@
 === tests/cases/compiler/func.ts ===
 interface ComponentOptions<V> {
->ComponentOptions : ComponentOptions<V>
->V : V
-
     watch: Record<string, WatchHandler<any>>;
 >watch : Record<string, WatchHandler<any>>
->Record : Record<K, T>
->WatchHandler : WatchHandler<T>
 }
 type WatchHandler<T> = (val: T) => void;
 >WatchHandler : WatchHandler<T>
->T : T
 >val : T
->T : T
 
 declare function extend(options: ComponentOptions<{}>): void;
 >extend : (options: ComponentOptions<{}>) => void
 >options : ComponentOptions<{}>
->ComponentOptions : ComponentOptions<V>
 
 export var vextend = extend;
 >vextend : (options: ComponentOptions<{}>) => void

tests/baselines/reference/allowSyntheticDefaultImportsCanPaintCrossModuleDeclaration.types

@@ -1,7 +1,5 @@
 === tests/cases/compiler/color.ts ===
 interface Color {
->Color : Color
-
     c: string;
 >c : string
 }
@@ -14,7 +12,6 @@ import Color from "./color";
 
 export declare function styled(): Color;
 >styled : () => Color
->Color : Color
 
 === tests/cases/compiler/file2.ts ===
 import { styled }  from "./file1";

tests/baselines/reference/ambientClassDeclarationWithExtends.types

@@ -22,7 +22,6 @@ declare class D extends C { }
 
 var d: C = new D();
 >d : C
->C : C
 >new D() : D
 >D : typeof D
 
@@ -44,7 +43,6 @@ declare class F extends E { }
 
 var f: E = new F();
 >f : E
->E : E
 >new F() : F
 >F : typeof F
 

tests/baselines/reference/ambientClassMergesOverloadsWithInterface.types

@@ -10,8 +10,6 @@ declare class C {
 >n : number
 }
 interface C {
->C : C
-
     foo(n: number): any;
 >foo : { (n: number): any; (n: number): any; }
 >n : number

tests/baselines/reference/ambientConstLiterals.types

@@ -1,10 +1,7 @@
 === tests/cases/compiler/ambientConstLiterals.ts ===
 function f<T>(x: T): T {
 >f : <T>(x: T) => T
->T : T
 >x : T
->T : T
->T : T
 
     return x;
 >x : T