Update LKG.

Author: DanielRosenwasser

lib/protocol.d.ts

@@ -844,10 +844,6 @@ declare namespace ts.server.protocol {
          * If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
          */
         fileToRename?: string;
-        /**
-         * Error message if item can not be renamed.
-         */
-        fileToRename?: string;
         /**
          * Display name of the item to be renamed.
          */
@@ -867,6 +863,13 @@ declare namespace ts.server.protocol {
         /** Span of text to rename. */
         triggerSpan: TextSpan;
     }
+    interface RenameInfoFailure {
+        canRename: false;
+        /**
+         * Error message if item can not be renamed.
+         */
+        localizedErrorMessage: string;
+    }
     /**
      *  A group of text spans, all in 'file'.
      */

lib/tsc.js

@@ -60,7 +60,7 @@ var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cook
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "3.1";
-    ts.version = ts.versionMajorMinor + ".2";
+    ts.version = ts.versionMajorMinor + ".3";
 })(ts || (ts = {}));
 (function (ts) {
     ts.emptyArray = [];

lib/tsserver.js

@@ -85,7 +85,7 @@ var ts;
     // If changing the text in this section, be sure to test `configureNightly` too.
     ts.versionMajorMinor = "3.4";
     /** The version of the TypeScript compiler release */
-    ts.version = ts.versionMajorMinor + ".2";
+    ts.version = ts.versionMajorMinor + ".3";
 })(ts || (ts = {}));
 (function (ts) {
     /* @internal */
@@ -98842,7 +98842,7 @@ var ts;
                     if (resolvedModuleSymbol !== moduleSymbol &&
                         // Don't add another completion for `export =` of a symbol that's already global.
                         // So in `declare namespace foo {} declare module "foo" { export = foo; }`, there will just be the global completion for `foo`.
-                        resolvedModuleSymbol.declarations.some(function (d) { return !!d.getSourceFile().externalModuleIndicator; })) {
+                        ts.some(resolvedModuleSymbol.declarations, function (d) { return !!d.getSourceFile().externalModuleIndicator; })) {
                         symbols.push(resolvedModuleSymbol);
                         symbolToOriginInfoMap[ts.getSymbolId(resolvedModuleSymbol)] = { kind: 3 /* Export */, moduleSymbol: moduleSymbol, isDefaultExport: false };
                     }
@@ -105433,7 +105433,6 @@ var ts;
                 fileToRename: name,
                 kind: kind,
                 displayName: name,
-                localizedErrorMessage: undefined,
                 fullDisplayName: name,
                 kindModifiers: "" /* none */,
                 triggerSpan: triggerSpan,
@@ -109926,6 +109925,14 @@ var ts;
                 var pos = before.modifiers.end;
                 this.insertNodeAt(sourceFile, pos, ts.createToken(modifier), { prefix: " " });
             };
+            ChangeTracker.prototype.insertLastModifierBefore = function (sourceFile, modifier, before) {
+                if (!before.modifiers) {
+                    this.insertModifierBefore(sourceFile, modifier, before);
+                    return;
+                }
+                var pos = before.modifiers.end;
+                this.replaceRange(sourceFile, { pos: pos, end: pos }, ts.createToken(modifier), { prefix: " " });
+            };
             ChangeTracker.prototype.insertCommentBeforeLine = function (sourceFile, lineNumber, position, commentText) {
                 var lineStartPosition = ts.getStartPositionOfLine(lineNumber, sourceFile);
                 var startPosition = ts.getFirstNonSpaceCharacterPosition(sourceFile.text, lineStartPosition);
@@ -112108,7 +112115,7 @@ var ts;
                 return;
             }
             // add the async keyword
-            changes.insertLastModifierBefore(sourceFile, 121 /* AsyncKeyword */, functionToConvert);
+            changes.insertLastModifierBefore(sourceFile, 120 /* AsyncKeyword */, functionToConvert);
             function startTransformation(node, nodeToReplace) {
                 var newNodes = transformExpression(node, transformer, node);
                 changes.replaceNodeWithNodes(sourceFile, nodeToReplace, newNodes);
@@ -112276,7 +112283,7 @@ var ts;
             }
         }
         function getNewNameIfConflict(name, originalNames) {
-            var numVarsSameName = (originalNames.get(name.text) || []).length;
+            var numVarsSameName = (originalNames.get(name.text) || ts.emptyArray).length;
             var numberOfAssignmentsOriginal = 0;
             var identifier = numVarsSameName === 0 ? name : ts.createIdentifier(name.text + "_" + numVarsSameName);
             return { identifier: identifier, types: [], numberOfAssignmentsOriginal: numberOfAssignmentsOriginal };
@@ -112302,7 +112309,7 @@ var ts;
                 return transformPromiseCall(node, transformer, prevArgName);
             }
             codeActionSucceeded = false;
-            return [];
+            return ts.emptyArray;
         }
         function transformCatch(node, transformer, prevArgName) {
             var func = node.arguments[0];
@@ -112385,11 +112392,11 @@ var ts;
         function createTransformedStatement(prevArgName, rightHandSide, transformer) {
             if (!prevArgName || prevArgName.identifier.text.length === 0) {
                 // if there's no argName to assign to, there still might be side effects
-                return ts.createNodeArray([ts.createStatement(rightHandSide)]);
+                return [ts.createStatement(rightHandSide)];
             }
             if (prevArgName.types.length < prevArgName.numberOfAssignmentsOriginal) {
                 // if the variable has already been declared, we don't need "let" or "const"
-                return ts.createNodeArray([ts.createStatement(ts.createAssignment(ts.getSynthesizedDeepClone(prevArgName.identifier), rightHandSide))]);
+                return [ts.createStatement(ts.createAssignment(ts.getSynthesizedDeepClone(prevArgName.identifier), rightHandSide))];
             }
             return [ts.createVariableStatement(/*modifiers*/ undefined, (ts.createVariableDeclarationList([ts.createVariableDeclaration(ts.getSynthesizedDeepClone(prevArgName.identifier), /*type*/ undefined, rightHandSide)], getFlagOfIdentifier(prevArgName.identifier, transformer.constIdentifiers))))];
         }
@@ -112405,7 +112412,7 @@ var ts;
                         // undefined was argument passed to promise handler
                         break;
                     }
-                    var synthCall = ts.createCall(ts.getSynthesizedDeepClone(func), /*typeArguments*/ undefined, argName ? [argName.identifier] : []);
+                    var synthCall = ts.createCall(ts.getSynthesizedDeepClone(func), /*typeArguments*/ undefined, argName ? [argName.identifier] : ts.emptyArray);
                     if (shouldReturn) {
                         return [ts.createReturn(synthCall)];
                     }
@@ -112441,14 +112448,14 @@ var ts;
                                 refactoredStmts.push(statement);
                             }
                         }
-                        return shouldReturn ? ts.getSynthesizedDeepClones(ts.createNodeArray(refactoredStmts)) :
-                            removeReturns(ts.createNodeArray(refactoredStmts), prevArgName.identifier, transformer, seenReturnStatement);
+                        return shouldReturn ? refactoredStmts.map(function (s) { return ts.getSynthesizedDeepClone(s); }) :
+                            removeReturns(refactoredStmts, prevArgName === undefined ? undefined : prevArgName.identifier, transformer, seenReturnStatement);
                     }
                     else {
                         var innerRetStmts = ts.getReturnStatementsWithPromiseHandlers(ts.createReturn(funcBody));
                         var innerCbBody = getInnerTransformationBody(transformer, innerRetStmts, prevArgName);
                         if (innerCbBody.length > 0) {
-                            return ts.createNodeArray(innerCbBody);
+                            return innerCbBody;
                         }
                         if (!shouldReturn) {
                             var type_1 = transformer.checker.getTypeAtLocation(func);
@@ -112462,7 +112469,7 @@ var ts;
                             return transformedStatement;
                         }
                         else {
-                            return [ts.createReturn(possiblyAwaitedRightHandSide)];
+                            return [ts.createReturn(ts.getSynthesizedDeepClone(funcBody))];
                         }
                     }
                 }
@@ -112484,18 +112491,23 @@ var ts;
                 if (ts.isReturnStatement(stmt)) {
                     if (stmt.expression) {
                         var possiblyAwaitedExpression = isPromiseReturningExpression(stmt.expression, transformer.checker) ? ts.createAwait(stmt.expression) : stmt.expression;
-                        ret.push(ts.createVariableStatement(/*modifiers*/ undefined, (ts.createVariableDeclarationList([ts.createVariableDeclaration(prevArgName, /*type*/ undefined, possiblyAwaitedExpression)], getFlagOfIdentifier(prevArgName, transformer.constIdentifiers)))));
+                        if (prevArgName === undefined) {
+                            ret.push(ts.createExpressionStatement(possiblyAwaitedExpression));
+                        }
+                        else {
+                            ret.push(ts.createVariableStatement(/*modifiers*/ undefined, (ts.createVariableDeclarationList([ts.createVariableDeclaration(prevArgName, /*type*/ undefined, possiblyAwaitedExpression)], getFlagOfIdentifier(prevArgName, transformer.constIdentifiers)))));
+                        }
                     }
                 }
                 else {
                     ret.push(ts.getSynthesizedDeepClone(stmt));
                 }
             }
             // if block has no return statement, need to define prevArgName as undefined to prevent undeclared variables
-            if (!seenReturnStatement) {
+            if (!seenReturnStatement && prevArgName !== undefined) {
                 ret.push(ts.createVariableStatement(/*modifiers*/ undefined, (ts.createVariableDeclarationList([ts.createVariableDeclaration(prevArgName, /*type*/ undefined, ts.createIdentifier("undefined"))], getFlagOfIdentifier(prevArgName, transformer.constIdentifiers)))));
             }
-            return ts.createNodeArray(ret);
+            return ret;
         }
         function getInnerTransformationBody(transformer, innerRetStmts, prevArgName) {
             var innerCbBody = [];
@@ -113236,19 +113248,19 @@ var ts;
                 }
                 var defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
                 if (defaultInfo && defaultInfo.name === symbolName && ts.skipAlias(defaultInfo.symbol, checker) === exportedSymbol) {
-                    result.push({ moduleSymbol: moduleSymbol, importKind: defaultInfo.kind, exportedSymbolIsTypeOnly: isTypeOnlySymbol(defaultInfo.symbol) });
+                    result.push({ moduleSymbol: moduleSymbol, importKind: defaultInfo.kind, exportedSymbolIsTypeOnly: isTypeOnlySymbol(defaultInfo.symbol, checker) });
                 }
                 for (var _i = 0, _a = checker.getExportsOfModule(moduleSymbol); _i < _a.length; _i++) {
                     var exported = _a[_i];
                     if (exported.name === symbolName && ts.skipAlias(exported, checker) === exportedSymbol) {
-                        result.push({ moduleSymbol: moduleSymbol, importKind: 0 /* Named */, exportedSymbolIsTypeOnly: isTypeOnlySymbol(exported) });
+                        result.push({ moduleSymbol: moduleSymbol, importKind: 0 /* Named */, exportedSymbolIsTypeOnly: isTypeOnlySymbol(exported, checker) });
                     }
                 }
             });
             return result;
         }
-        function isTypeOnlySymbol(s) {
-            return !(s.flags & 67220415 /* Value */);
+        function isTypeOnlySymbol(s, checker) {
+            return !(ts.skipAlias(s, checker).flags & 67220415 /* Value */);
         }
         function getFixForImport(exportInfos, symbolName, position, program, sourceFile, host, preferences) {
             var checker = program.getTypeChecker();
@@ -113438,7 +113450,7 @@ var ts;
                 return undefined;
             var symbol = exported.symbol, kind = exported.kind;
             var info = getDefaultExportInfoWorker(symbol, moduleSymbol, checker, compilerOptions);
-            return info && { symbol: symbol, symbolForMeaning: info.symbolForMeaning, name: info.name, kind: kind };
+            return info && __assign({ symbol: symbol, kind: kind }, info);
         }
         function getDefaultLikeExportWorker(moduleSymbol, checker) {
             var defaultExport = checker.tryGetMemberInModuleExports("default" /* Default */, moduleSymbol);
@@ -129467,9 +129479,14 @@ var ts;
                 var renameInfo = this.mapRenameInfo(defaultProject.getLanguageService().getRenameInfo(file, position), ts.Debug.assertDefined(this.projectService.getScriptInfo(file)));
                 return { info: renameInfo, locs: this.toSpanGroups(locations) };
             };
-            Session.prototype.mapRenameInfo = function (_a, scriptInfo) {
-                var canRename = _a.canRename, fileToRename = _a.fileToRename, localizedErrorMessage = _a.localizedErrorMessage, displayName = _a.displayName, fullDisplayName = _a.fullDisplayName, kind = _a.kind, kindModifiers = _a.kindModifiers, triggerSpan = _a.triggerSpan;
-                return { canRename: canRename, fileToRename: fileToRename, localizedErrorMessage: localizedErrorMessage, displayName: displayName, fullDisplayName: fullDisplayName, kind: kind, kindModifiers: kindModifiers, triggerSpan: this.toLocationTextSpan(triggerSpan, scriptInfo) };
+            Session.prototype.mapRenameInfo = function (info, scriptInfo) {
+                if (info.canRename) {
+                    var canRename = info.canRename, fileToRename = info.fileToRename, displayName = info.displayName, fullDisplayName = info.fullDisplayName, kind = info.kind, kindModifiers = info.kindModifiers, triggerSpan = info.triggerSpan;
+                    return ts.identity({ canRename: canRename, fileToRename: fileToRename, displayName: displayName, fullDisplayName: fullDisplayName, kind: kind, kindModifiers: kindModifiers, triggerSpan: this.toLocationTextSpan(triggerSpan, scriptInfo) });
+                }
+                else {
+                    return info;
+                }
             };
             Session.prototype.toSpanGroups = function (locations) {
                 var map = ts.createMap();

lib/tsserverlibrary.d.ts

@@ -5210,14 +5210,14 @@ declare namespace ts {
         documentation?: SymbolDisplayPart[];
         tags?: JSDocTagInfo[];
     }
-    interface RenameInfo {
-        canRename: boolean;
+    type RenameInfo = RenameInfoSuccess | RenameInfoFailure;
+    interface RenameInfoSuccess {
+        canRename: true;
         /**
          * File or directory to rename.
          * If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
          */
         fileToRename?: string;
-        localizedErrorMessage?: string;
         displayName: string;
         fullDisplayName: string;
         kind: ScriptElementKind;
@@ -5228,9 +5228,6 @@ declare namespace ts {
         canRename: false;
         localizedErrorMessage: string;
     }
-    interface RenameInfoOptions {
-        readonly allowRenameOfImportPath?: boolean;
-    }
     interface SignatureHelpParameter {
         name: string;
         documentation: SymbolDisplayPart[];
@@ -6569,10 +6566,6 @@ declare namespace ts.server.protocol {
          * If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
          */
         fileToRename?: string;
-        /**
-         * Error message if item can not be renamed.
-         */
-        fileToRename?: string;
         /**
          * Display name of the item to be renamed.
          */
@@ -6592,6 +6585,13 @@ declare namespace ts.server.protocol {
         /** Span of text to rename. */
         triggerSpan: TextSpan;
     }
+    interface RenameInfoFailure {
+        canRename: false;
+        /**
+         * Error message if item can not be renamed.
+         */
+        localizedErrorMessage: string;
+    }
     /**
      *  A group of text spans, all in 'file'.
      */