typescript 4.6.0-dev.20211126 → 4.6.0-dev.20211130

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211126";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211130";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -90899,11 +90899,10 @@ var ts;
                 // we can safely elide the parentheses here, as a new synthetic
                 // ParenthesizedExpression will be inserted if we remove parentheses too
                 // aggressively.
-                // HOWEVER - if there are leading comments on the expression itself, to handle ASI
-                // correctly for return and throw, we must keep the parenthesis
-                if (ts.length(ts.getLeadingCommentRangesOfNode(expression, currentSourceFile))) {
-                    return factory.updateParenthesizedExpression(node, expression);
-                }
+                //
+                // If there are leading comments on the expression itself, the emitter will handle ASI
+                // for return, throw, and yield by re-introducing parenthesis during emit on an as-need
+                // basis.
                 return factory.createPartiallyEmittedExpression(expression, node);
             }
             return ts.visitEachChild(node, visitor, context);
@@ -94851,11 +94850,11 @@ var ts;
         }
         function visitOptionalExpression(node, captureThisArg, isDelete) {
             var _a = flattenChain(node), expression = _a.expression, chain = _a.chain;
-            var left = visitNonOptionalExpression(expression, ts.isCallChain(chain[0]), /*isDelete*/ false);
+            var left = visitNonOptionalExpression(ts.skipPartiallyEmittedExpressions(expression), ts.isCallChain(chain[0]), /*isDelete*/ false);
             var leftThisArg = ts.isSyntheticReference(left) ? left.thisArg : undefined;
-            var leftExpression = ts.isSyntheticReference(left) ? left.expression : left;
-            var capturedLeft = leftExpression;
-            if (!ts.isSimpleCopiableExpression(leftExpression)) {
+            var capturedLeft = ts.isSyntheticReference(left) ? left.expression : left;
+            var leftExpression = factory.restoreOuterExpressions(expression, capturedLeft, 8 /* PartiallyEmittedExpressions */);
+            if (!ts.isSimpleCopiableExpression(capturedLeft)) {
                 capturedLeft = factory.createTempVariable(hoistVariableDeclaration);
                 leftExpression = factory.createAssignment(capturedLeft, leftExpression);
             }
@@ -94881,6 +94880,10 @@ var ts;
                         break;
                     case 207 /* CallExpression */:
                         if (i === 0 && leftThisArg) {
+                            if (!ts.isGeneratedIdentifier(leftThisArg)) {
+                                leftThisArg = factory.cloneNode(leftThisArg);
+                                ts.addEmitFlags(leftThisArg, 1536 /* NoComments */);
+                            }
                             rightExpression = factory.createFunctionCallCall(rightExpression, leftThisArg.kind === 106 /* SuperKeyword */ ? factory.createThis() : leftThisArg, ts.visitNodes(segment.arguments, visitor, ts.isExpression));
                         }
                         else {
@@ -109663,7 +109666,7 @@ var ts;
         function emitYieldExpression(node) {
             emitTokenWithComment(125 /* YieldKeyword */, node.pos, writeKeyword, node);
             emit(node.asteriskToken);
-            emitExpressionWithLeadingSpace(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma);
+            emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsiAndDisallowedComma);
         }
         function emitSpreadElement(node) {
             emitTokenWithComment(25 /* DotDotDotToken */, node.pos, writePunctuation, node);
@@ -109860,9 +109863,49 @@ var ts;
             }
             return pos;
         }
+        function commentWillEmitNewLine(node) {
+            return node.kind === 2 /* SingleLineCommentTrivia */ || !!node.hasTrailingNewLine;
+        }
+        function willEmitLeadingNewLine(node) {
+            if (!currentSourceFile)
+                return false;
+            if (ts.some(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), commentWillEmitNewLine))
+                return true;
+            if (ts.some(ts.getSyntheticLeadingComments(node), commentWillEmitNewLine))
+                return true;
+            if (ts.isPartiallyEmittedExpression(node)) {
+                if (node.pos !== node.expression.pos) {
+                    if (ts.some(ts.getTrailingCommentRanges(currentSourceFile.text, node.expression.pos), commentWillEmitNewLine))
+                        return true;
+                }
+                return willEmitLeadingNewLine(node.expression);
+            }
+            return false;
+        }
+        /**
+         * Wraps an expression in parens if we would emit a leading comment that would introduce a line separator
+         * between the node and its parent.
+         */
+        function parenthesizeExpressionForNoAsi(node) {
+            if (!commentsDisabled && ts.isPartiallyEmittedExpression(node) && willEmitLeadingNewLine(node)) {
+                var parseNode = ts.getParseTreeNode(node);
+                if (parseNode && ts.isParenthesizedExpression(parseNode)) {
+                    // If the original node was a parenthesized expression, restore it to preserve comment and source map emit
+                    var parens = ts.factory.createParenthesizedExpression(node.expression);
+                    ts.setOriginalNode(parens, node);
+                    ts.setTextRange(parens, parseNode);
+                    return parens;
+                }
+                return ts.factory.createParenthesizedExpression(node);
+            }
+            return node;
+        }
+        function parenthesizeExpressionForNoAsiAndDisallowedComma(node) {
+            return parenthesizeExpressionForNoAsi(parenthesizer.parenthesizeExpressionForDisallowedComma(node));
+        }
         function emitReturnStatement(node) {
             emitTokenWithComment(105 /* ReturnKeyword */, node.pos, writeKeyword, /*contextNode*/ node);
-            emitExpressionWithLeadingSpace(node.expression);
+            emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi);
             writeTrailingSemicolon();
         }
         function emitWithStatement(node) {
@@ -109890,7 +109933,7 @@ var ts;
         }
         function emitThrowStatement(node) {
             emitTokenWithComment(109 /* ThrowKeyword */, node.pos, writeKeyword, node);
-            emitExpressionWithLeadingSpace(node.expression);
+            emitExpressionWithLeadingSpace(parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi);
             writeTrailingSemicolon();
         }
         function emitTryStatement(node) {
@@ -110734,7 +110777,14 @@ var ts;
         }
         // Transformation nodes
         function emitPartiallyEmittedExpression(node) {
+            var emitFlags = ts.getEmitFlags(node);
+            if (!(emitFlags & 512 /* NoLeadingComments */) && node.pos !== node.expression.pos) {
+                emitTrailingCommentsOfPosition(node.expression.pos);
+            }
             emitExpression(node.expression);
+            if (!(emitFlags & 1024 /* NoTrailingComments */) && node.end !== node.expression.end) {
+                emitLeadingCommentsOfPosition(node.expression.end);
+            }
         }
         function emitCommaList(node) {
             emitExpressionList(node, node.elements, 528 /* CommaListElements */, /*parenthesizerRule*/ undefined);
@@ -111098,10 +111148,8 @@ var ts;
                     // Emit this child.
                     previousSourceFileTextKind = recordBundleFileInternalSectionStart(child);
                     if (shouldEmitInterveningComments) {
-                        if (emitTrailingCommentsOfPosition) {
-                            var commentRange = ts.getCommentRange(child);
-                            emitTrailingCommentsOfPosition(commentRange.pos);
-                        }
+                        var commentRange = ts.getCommentRange(child);
+                        emitTrailingCommentsOfPosition(commentRange.pos);
                     }
                     else {
                         shouldEmitInterveningComments = mayEmitInterveningComments;
@@ -111422,7 +111470,7 @@ var ts;
         function writeLineSeparatorsAndIndentBefore(node, parent) {
             var leadingNewlines = preserveSourceNewlines && getLeadingLineTerminatorCount(parent, [node], 0 /* None */);
             if (leadingNewlines) {
-                writeLinesAndIndent(leadingNewlines, /*writeLinesIfNotIndenting*/ false);
+                writeLinesAndIndent(leadingNewlines, /*writeSpaceIfNotIndenting*/ false);
             }
             return !!leadingNewlines;
         }

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.6.0-dev.20211126",
+    "version": "4.6.0-dev.20211130",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [