Merge branch 'master' of https://github.com/Microsoft/TypeScript

Author: steveluc

scripts/processDiagnosticMessages.ts

@@ -54,6 +54,7 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap:
     var result =
         '// <auto-generated />\r\n' +
         '/// <reference path="types.ts" />\r\n' +
+        '/* @internal */\r\n' +
         'module ts {\r\n' +
         '    export var Diagnostics = {\r\n';
     var names = Utilities.getObjectKeys(messageTable);

src/compiler/diagnosticMessages.json

@@ -2043,19 +2043,19 @@
     },
     "'import ... =' can only be used in a .ts file.": {
         "category": "Error",
-        "code":  8002
+        "code": 8002
     },
     "'export=' can only be used in a .ts file.": {
         "category": "Error",
-        "code":  8003
+        "code": 8003
     },
     "'type parameter declarations' can only be used in a .ts file.": {
         "category": "Error",
-        "code":  8004
+        "code": 8004
     },
     "'implements clauses' can only be used in a .ts file.": {
         "category": "Error",
-        "code":  8005
+        "code": 8005
     },
     "'interface declarations' can only be used in a .ts file.": {
         "category": "Error",

src/harness/typeWriter.ts

@@ -1,6 +1,5 @@
 interface TypeWriterResult {
     line: number;
-    column: number;
     syntaxKind: number;
     sourceText: string;
     type: string;
@@ -29,90 +28,43 @@ class TypeWriterWalker {
     }
 
     private visitNode(node: ts.Node): void {
-        switch (node.kind) {
-            // Should always log expressions that are not tokens
-            // Also, always log the "this" keyword
-            // TODO: Ideally we should log all expressions, but to compare to the
-            // old typeWriter baselines, suppress tokens
-            case ts.SyntaxKind.ThisKeyword:
-            case ts.SyntaxKind.SuperKeyword:
-            case ts.SyntaxKind.ArrayLiteralExpression:
-            case ts.SyntaxKind.ObjectLiteralExpression:
-            case ts.SyntaxKind.ElementAccessExpression:
-            case ts.SyntaxKind.CallExpression:
-            case ts.SyntaxKind.NewExpression:
-            case ts.SyntaxKind.TypeAssertionExpression:
-            case ts.SyntaxKind.ParenthesizedExpression:
-            case ts.SyntaxKind.FunctionExpression:
-            case ts.SyntaxKind.ArrowFunction:
-            case ts.SyntaxKind.TypeOfExpression:
-            case ts.SyntaxKind.VoidExpression:
-            case ts.SyntaxKind.DeleteExpression:
-            case ts.SyntaxKind.PrefixUnaryExpression:
-            case ts.SyntaxKind.PostfixUnaryExpression:
-            case ts.SyntaxKind.BinaryExpression:
-            case ts.SyntaxKind.ConditionalExpression:
-            case ts.SyntaxKind.SpreadElementExpression:
-                this.log(node, this.getTypeOfNode(node));
-                break;
-
-            case ts.SyntaxKind.PropertyAccessExpression:
-                for (var current = node; current.kind === ts.SyntaxKind.PropertyAccessExpression; current = current.parent) {
-                }
-                if (current.kind !== ts.SyntaxKind.HeritageClauseElement) {
-                    this.log(node, this.getTypeOfNode(node));
-                }
-                break;
-
-            // Should not change expression status (maybe expressions)
-            // TODO: Again, ideally should log number and string literals too,
-            // but to be consistent with the old typeWriter, just log identifiers
-            case ts.SyntaxKind.Identifier:
-                var identifier = <ts.Identifier>node;
-                if (!this.isLabel(identifier)) {
-                    var type = this.getTypeOfNode(identifier);
-                    this.log(node, type);
-                }
-                break;
+        if (ts.isExpression(node) || node.kind === ts.SyntaxKind.Identifier) {
+            this.logTypeAndSymbol(node);
         }
 
         ts.forEachChild(node, child => this.visitNode(child));
     }
 
-    private isLabel(identifier: ts.Identifier): boolean {
-        var parent = identifier.parent;
-        switch (parent.kind) {
-            case ts.SyntaxKind.ContinueStatement:
-            case ts.SyntaxKind.BreakStatement:
-                return (<ts.BreakOrContinueStatement>parent).label === identifier;
-            case ts.SyntaxKind.LabeledStatement:
-                return (<ts.LabeledStatement>parent).label === identifier;
-        }
-        return false;
-    }
-
-    private log(node: ts.Node, type: ts.Type): void {
+    private logTypeAndSymbol(node: ts.Node): void {
         var actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
         var lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
         var sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
-        
-        // If we got an unknown type, we temporarily want to fall back to just pretending the name
-        // (source text) of the node is the type. This is to align with the old typeWriter to make
-        // baseline comparisons easier. In the long term, we will want to just call typeToString
+
+        var type = this.checker.getTypeAtLocation(node);
+        ts.Debug.assert(type !== undefined, "type doesn't exist");
+        var symbol = this.checker.getSymbolAtLocation(node);
+
+        var typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
+        if (symbol) {
+            var symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
+            if (symbol.declarations) {
+                for (let declaration of symbol.declarations) {
+                    symbolString += ", ";
+                    let declSourceFile = declaration.getSourceFile();
+                    let declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
+                    symbolString += `Decl(${ ts.getBaseFileName(declSourceFile.fileName) }, ${ declLineAndCharacter.line }, ${ declLineAndCharacter.character })`
+                }
+            }
+            symbolString += ")";
+
+            typeString += ", " + symbolString;
+        }
+
         this.results.push({
             line: lineAndCharacter.line,
-            // todo(cyrusn): Not sure why column is one-based for type-writer.  But I'm preserving 
-            // that behavior to prevent having a lot of baselines to fix up.
-            column: lineAndCharacter.character + 1,
             syntaxKind: node.kind,
             sourceText: sourceText,
-            type: this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.WriteOwnNameForAnyLike)
+            type: typeString
         });
     }
-
-    private getTypeOfNode(node: ts.Node): ts.Type {
-        var type = this.checker.getTypeAtLocation(node);
-        ts.Debug.assert(type !== undefined, "type doesn't exist");
-        return type;
-    }
 }

tests/baselines/reference/2dArrays.types

@@ -1,40 +1,40 @@
 === tests/cases/compiler/2dArrays.ts ===
 class Cell {
->Cell : Cell
+>Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
 }
 
 class Ship {
->Ship : Ship
+>Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
 
     isSunk: boolean;
->isSunk : boolean
+>isSunk : boolean, Symbol(isSunk, Decl(2dArrays.ts, 3, 12))
 }
 
 class Board {
->Board : Board
+>Board : Board, Symbol(Board, Decl(2dArrays.ts, 5, 1))
 
     ships: Ship[];
->ships : Ship[]
->Ship : Ship
+>ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
 
     cells: Cell[];
->cells : Cell[]
->Cell : Cell
+>cells : Cell[], Symbol(cells, Decl(2dArrays.ts, 8, 18))
+>Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
 
     private allShipsSunk() {
->allShipsSunk : () => boolean
+>allShipsSunk : () => boolean, Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
 
         return this.ships.every(function (val) { return val.isSunk; });
 >this.ships.every(function (val) { return val.isSunk; }) : boolean
->this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
->this.ships : Ship[]
->this : Board
->ships : Ship[]
->every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
+>this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>this.ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>this : Board, Symbol(Board, Decl(2dArrays.ts, 5, 1))
+>ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
 >function (val) { return val.isSunk; } : (val: Ship) => boolean
->val : Ship
->val.isSunk : boolean
->val : Ship
->isSunk : boolean
+>val : Ship, Symbol(val, Decl(2dArrays.ts, 12, 42))
+>val.isSunk : boolean, Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
+>val : Ship, Symbol(val, Decl(2dArrays.ts, 12, 42))
+>isSunk : boolean, Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
     }    
 }