Merge branch 'master' into publicTransformers

Author: rbuckton

Jakefile.js

@@ -37,7 +37,6 @@ if (process.env.path !== undefined) {
 }
 
 function filesFromConfig(configPath) {
-    console.log(configPath);
     var configText = fs.readFileSync(configPath).toString();
     var config = ts.parseConfigFileTextToJson(configPath, configText, /*stripComments*/ true);
     if (config.error) {

src/compiler/checker.ts

@@ -3322,7 +3322,7 @@ namespace ts {
                 type;
         }
 
-        function getTypeForVariableLikeDeclarationFromJSDocComment(declaration: VariableLikeDeclaration) {
+        function getTypeForDeclarationFromJSDocComment(declaration: Node ) {
             const jsdocType = getJSDocType(declaration);
             if (jsdocType) {
                 return getTypeFromTypeNode(jsdocType);
@@ -3350,7 +3350,7 @@ namespace ts {
                 // If this is a variable in a JavaScript file, then use the JSDoc type (if it has
                 // one as its type), otherwise fallback to the below standard TS codepaths to
                 // try to figure it out.
-                const type = getTypeForVariableLikeDeclarationFromJSDocComment(declaration);
+                const type = getTypeForDeclarationFromJSDocComment(declaration);
                 if (type && type !== unknownType) {
                     return type;
                 }
@@ -3445,6 +3445,27 @@ namespace ts {
             return undefined;
         }
 
+        // Return the inferred type for a variable, parameter, or property declaration
+        function getTypeForJSSpecialPropertyDeclaration(declaration: Declaration): Type {
+            const expression = declaration.kind === SyntaxKind.BinaryExpression ? <BinaryExpression>declaration :
+                declaration.kind === SyntaxKind.PropertyAccessExpression ? <BinaryExpression>getAncestor(declaration, SyntaxKind.BinaryExpression) :
+                undefined;
+
+            if (!expression) {
+                return unknownType;
+            }
+
+            if (expression.flags & NodeFlags.JavaScriptFile) {
+                // If there is a JSDoc type, use it
+                const type = getTypeForDeclarationFromJSDocComment(expression.parent);
+                if (type && type !== unknownType) {
+                    return getWidenedType(type);
+                }
+            }
+
+            return getWidenedLiteralType(checkExpressionCached(expression.right));
+        }
+
         // Return the type implied by a binding pattern element. This is the type of the initializer of the element if
         // one is present. Otherwise, if the element is itself a binding pattern, it is the type implied by the binding
         // pattern. Otherwise, it is the type any.
@@ -3599,18 +3620,7 @@ namespace ts {
                 // * className.prototype.method = expr
                 if (declaration.kind === SyntaxKind.BinaryExpression ||
                     declaration.kind === SyntaxKind.PropertyAccessExpression && declaration.parent.kind === SyntaxKind.BinaryExpression) {
-                    // Use JS Doc type if present on parent expression statement
-                    if (declaration.flags & NodeFlags.JavaScriptFile) {
-                        const jsdocType = getJSDocType(declaration.parent);
-                        if (jsdocType) {
-                            return links.type = getTypeFromTypeNode(jsdocType);
-                        }
-                    }
-                    const declaredTypes = map(symbol.declarations,
-                        decl => decl.kind === SyntaxKind.BinaryExpression ?
-                            checkExpressionCached((<BinaryExpression>decl).right) :
-                            checkExpressionCached((<BinaryExpression>decl.parent).right));
-                    type = getUnionType(declaredTypes, /*subtypeReduction*/ true);
+                    type = getWidenedType(getUnionType(map(symbol.declarations, getTypeForJSSpecialPropertyDeclaration), /*subtypeReduction*/ true));
                 }
                 else {
                     type = getWidenedTypeForVariableLikeDeclaration(<VariableLikeDeclaration>declaration, /*reportErrors*/ true);
@@ -3653,7 +3663,7 @@ namespace ts {
                 const setter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.SetAccessor);
 
                 if (getter && getter.flags & NodeFlags.JavaScriptFile) {
-                    const jsDocType = getTypeForVariableLikeDeclarationFromJSDocComment(getter);
+                    const jsDocType = getTypeForDeclarationFromJSDocComment(getter);
                     if (jsDocType) {
                         return links.type = jsDocType;
                     }
@@ -9535,11 +9545,19 @@ namespace ts {
         }
 
         function getAssignedTypeOfBinaryExpression(node: BinaryExpression): Type {
-            return node.parent.kind === SyntaxKind.ArrayLiteralExpression || node.parent.kind === SyntaxKind.PropertyAssignment ?
+            const isDestructuringDefaultAssignment =
+                node.parent.kind === SyntaxKind.ArrayLiteralExpression && isDestructuringAssignmentTarget(node.parent) ||
+                node.parent.kind === SyntaxKind.PropertyAssignment && isDestructuringAssignmentTarget(node.parent.parent);
+            return isDestructuringDefaultAssignment ?
                 getTypeWithDefault(getAssignedType(node), node.right) :
                 getTypeOfExpression(node.right);
         }
 
+        function isDestructuringAssignmentTarget(parent: Node) {
+            return parent.parent.kind === SyntaxKind.BinaryExpression && (parent.parent as BinaryExpression).left === parent ||
+                parent.parent.kind === SyntaxKind.ForOfStatement && (parent.parent as ForOfStatement).initializer === parent;
+        }
+
         function getAssignedTypeOfArrayLiteralElement(node: ArrayLiteralExpression, element: Expression): Type {
             return getTypeOfDestructuredArrayElement(getAssignedType(node), indexOf(node.elements, element));
         }

src/compiler/comments.ts

@@ -9,6 +9,7 @@ namespace ts {
         emitNodeWithComments(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
         emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void): void;
         emitTrailingCommentsOfPosition(pos: number): void;
+        emitLeadingCommentsOfPosition(pos: number): void;
     }
 
     export function createCommentWriter(printerOptions: PrinterOptions, emitPos: ((pos: number) => void) | undefined): CommentWriter {
@@ -32,6 +33,7 @@ namespace ts {
             emitNodeWithComments,
             emitBodyWithDetachedComments,
             emitTrailingCommentsOfPosition,
+            emitLeadingCommentsOfPosition,
         };
 
         function emitNodeWithComments(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
@@ -275,6 +277,14 @@ namespace ts {
             }
         }
 
+        function emitLeadingCommentsOfPosition(pos: number) {
+            if (disabled || pos === -1) {
+                return;
+            }
+
+            emitLeadingComments(pos, /*isEmittedNode*/ true);
+        }
+
         function emitTrailingComments(pos: number) {
             forEachTrailingCommentToEmit(pos, emitTrailingComment);
         }

src/compiler/emitter.ts

@@ -1,4 +1,4 @@
-/// <reference path="checker.ts" />
+/// <reference path="checker.ts" />
 /// <reference path="transformer.ts" />
 /// <reference path="declarationEmitter.ts" />
 /// <reference path="sourcemap.ts" />
@@ -208,6 +208,7 @@ namespace ts {
             emitNodeWithComments,
             emitBodyWithDetachedComments,
             emitTrailingCommentsOfPosition,
+            emitLeadingCommentsOfPosition,
         } = comments;
 
         let currentSourceFile: SourceFile;
@@ -1336,6 +1337,10 @@ namespace ts {
             else {
                 writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
                 emitBlockStatements(node);
+                // We have to call emitLeadingComments explicitly here because otherwise leading comments of the close brace token will not be emitted
+                increaseIndent();
+                emitLeadingCommentsOfPosition(node.statements.end);
+                decreaseIndent();
                 writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
             }
         }
@@ -2218,6 +2223,15 @@ namespace ts {
 
                     // Write the delimiter if this is not the first node.
                     if (previousSibling) {
+                        // i.e
+                        //      function commentedParameters(
+                        //          /* Parameter a */
+                        //          a
+                        //          /* End of parameter a */ -> this comment isn't considered to be trailing comment of parameter "a" due to newline
+                        //          ,
+                        if (delimiter && previousSibling.end !== parentNode.end) {
+                            emitLeadingCommentsOfPosition(previousSibling.end);
+                        }
                         write(delimiter);
 
                         // Write either a line terminator or whitespace to separate the elements.
@@ -2264,6 +2278,17 @@ namespace ts {
                     write(",");
                 }
 
+
+                // Emit any trailing comment of the last element in the list
+                // i.e
+                //       var array = [...
+                //          2
+                //          /* end of element 2 */
+                //       ];
+                if (previousSibling && delimiter && previousSibling.end !== parentNode.end) {
+                    emitLeadingCommentsOfPosition(previousSibling.end);
+                }
+
                 // Decrease the indent, if requested.
                 if (format & ListFormat.Indented) {
                     decreaseIndent();

src/compiler/sys.ts

@@ -486,7 +486,7 @@ namespace ts {
                     // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
                     let options: any;
                     if (!directoryExists(directoryName) || (isUNCPath(directoryName) && process.platform === "win32")) {
-                        // do nothing if either 
+                        // do nothing if either
                         // - target folder does not exist
                         // - this is UNC path on Windows (https://github.com/Microsoft/TypeScript/issues/13874)
                         return noOpFileWatcher;