@zzzen/pyright-internal 1.2.0-dev.20240519 → 1.2.0-dev.20240602

package/dist/parser/parser.js

@@ -884,7 +884,7 @@ class Parser {
             (0, debug_1.assert)(stringList.nodeType === 48 /* ParseNodeType.StringList */);
             // Check for f-strings, which are not allowed.
             stringList.strings.forEach((stringAtom) => {
-                if (stringAtom.nodeType === 27 /* ParseNodeType.FormatString */) {
+                if (stringAtom.nodeType === 30 /* ParseNodeType.FormatString */) {
                     this._addSyntaxError(localize_1.LocMessage.formatStringInPattern(), stringAtom);
                 }
             });
@@ -1253,7 +1253,7 @@ class Parser {
         return forNode;
     }
     // comp_iter: comp_for | comp_if
-    _tryParseListComprehension(target, isGenerator) {
+    _tryParseComprehension(target, isGenerator) {
         const compFor = this._tryParseCompForStatement();
         if (!compFor) {
             return undefined;
@@ -1261,27 +1261,27 @@ class Parser {
         if (target.nodeType === 56 /* ParseNodeType.Unpack */) {
             this._addSyntaxError(localize_1.LocMessage.unpackIllegalInComprehension(), target);
         }
-        else if (target.nodeType === 16 /* ParseNodeType.DictionaryExpandEntry */) {
+        else if (target.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
             this._addSyntaxError(localize_1.LocMessage.dictExpandIllegalInComprehension(), target);
         }
-        const listCompNode = parseNodes_1.ListComprehensionNode.create(target, isGenerator);
+        const compNode = parseNodes_1.ComprehensionNode.create(target, isGenerator);
         const forIfList = [compFor];
         while (true) {
             const compIter = this._tryParseCompForStatement() || this._tryParseCompIfStatement();
             if (!compIter) {
                 break;
             }
-            compIter.parent = listCompNode;
+            compIter.parent = compNode;
             forIfList.push(compIter);
         }
-        listCompNode.forIfNodes = forIfList;
+        compNode.forIfNodes = forIfList;
         if (forIfList.length > 0) {
             forIfList.forEach((comp) => {
-                comp.parent = listCompNode;
+                comp.parent = compNode;
             });
-            (0, parseNodes_1.extendRange)(listCompNode, forIfList[forIfList.length - 1]);
+            (0, parseNodes_1.extendRange)(compNode, forIfList[forIfList.length - 1]);
         }
-        return listCompNode;
+        return compNode;
     }
     // comp_for: ['async'] 'for' exprlist 'in' or_test [comp_iter]
     _tryParseCompForStatement() {
@@ -1310,7 +1310,7 @@ class Parser {
                 seqExpr = this._parseOrTest();
             });
         }
-        const compForNode = parseNodes_1.ListComprehensionForNode.create(asyncToken || forToken, targetExpr, seqExpr);
+        const compForNode = parseNodes_1.ComprehensionForNode.create(asyncToken || forToken, targetExpr, seqExpr);
         if (asyncToken) {
             compForNode.isAsync = true;
             compForNode.asyncToken = asyncToken;
@@ -1326,7 +1326,7 @@ class Parser {
         const ifToken = this._getKeywordToken(20 /* KeywordType.If */);
         const ifExpr = this._tryParseLambdaExpression() ||
             this._parseAssignmentExpression(/* disallowAssignmentExpression */ true);
-        const compIfNode = parseNodes_1.ListComprehensionIfNode.create(ifToken, ifExpr);
+        const compIfNode = parseNodes_1.ComprehensionIfNode.create(ifToken, ifExpr);
         return compIfNode;
     }
     // while_stmt: 'while' test suite ['else' suite]
@@ -2757,7 +2757,7 @@ class Parser {
                 const callNode = parseNodes_1.CallNode.create(atomExpression, argListResult.args, argListResult.trailingComma);
                 if (argListResult.args.length > 1 || argListResult.trailingComma) {
                     argListResult.args.forEach((arg) => {
-                        if (arg.valueExpression.nodeType === 32 /* ParseNodeType.ListComprehension */) {
+                        if (arg.valueExpression.nodeType === 11 /* ParseNodeType.Comprehension */) {
                             if (!arg.valueExpression.isParenthesized) {
                                 this._addSyntaxError(localize_1.LocMessage.generatorNotParenthesized(), arg.valueExpression);
                             }
@@ -3030,9 +3030,9 @@ class Parser {
                 }
             }
             else {
-                const listComp = this._tryParseListComprehension(valueExpr, /* isGenerator */ true);
-                if (listComp) {
-                    valueExpr = listComp;
+                const comprehension = this._tryParseComprehension(valueExpr, /* isGenerator */ true);
+                if (comprehension) {
+                    valueExpr = comprehension;
                 }
             }
         }
@@ -3085,7 +3085,7 @@ class Parser {
             if (possibleTupleNode.nodeType === 48 /* ParseNodeType.StringList */) {
                 possibleTupleNode.isParenthesized = true;
             }
-            if (possibleTupleNode.nodeType === 32 /* ParseNodeType.ListComprehension */) {
+            if (possibleTupleNode.nodeType === 11 /* ParseNodeType.Comprehension */) {
                 possibleTupleNode.isParenthesized = true;
             }
             return possibleTupleNode;
@@ -3218,9 +3218,9 @@ class Parser {
         let sawComprehension = false;
         return this._parseExpressionListGeneric(() => {
             let expr = this._parseTestOrStarExpression(/* allowAssignmentExpression */ true);
-            const listComp = this._tryParseListComprehension(expr, isGenerator);
-            if (listComp) {
-                expr = listComp;
+            const comprehension = this._tryParseComprehension(expr, isGenerator);
+            if (comprehension) {
+                expr = comprehension;
                 sawComprehension = true;
             }
             return expr;
@@ -3240,7 +3240,7 @@ class Parser {
         const setEntries = [];
         let isDictionary = false;
         let isSet = false;
-        let sawListComprehension = false;
+        let sawComprehension = false;
         let isFirstEntry = true;
         let trailingCommaToken;
         while (true) {
@@ -3271,10 +3271,10 @@ class Parser {
                 else {
                     const keyEntryNode = parseNodes_1.DictionaryKeyEntryNode.create(keyExpression, valueExpression);
                     let dictEntry = keyEntryNode;
-                    const listComp = this._tryParseListComprehension(keyEntryNode, /* isGenerator */ false);
-                    if (listComp) {
-                        dictEntry = listComp;
-                        sawListComprehension = true;
+                    const comprehension = this._tryParseComprehension(keyEntryNode, /* isGenerator */ false);
+                    if (comprehension) {
+                        dictEntry = comprehension;
+                        sawComprehension = true;
                         if (!isFirstEntry) {
                             this._addSyntaxError(localize_1.LocMessage.comprehensionInDict(), dictEntry);
                         }
@@ -3291,10 +3291,10 @@ class Parser {
                     const listEntryNode = parseNodes_1.DictionaryExpandEntryNode.create(doubleStarExpression);
                     (0, parseNodes_1.extendRange)(listEntryNode, doubleStar);
                     let expandEntryNode = listEntryNode;
-                    const listComp = this._tryParseListComprehension(listEntryNode, /* isGenerator */ false);
-                    if (listComp) {
-                        expandEntryNode = listComp;
-                        sawListComprehension = true;
+                    const comprehension = this._tryParseComprehension(listEntryNode, /* isGenerator */ false);
+                    if (comprehension) {
+                        expandEntryNode = comprehension;
+                        sawComprehension = true;
                         if (!isFirstEntry) {
                             this._addSyntaxError(localize_1.LocMessage.comprehensionInDict(), doubleStarExpression);
                         }
@@ -3313,10 +3313,10 @@ class Parser {
                         this._addSyntaxError(localize_1.LocMessage.dictKeyValuePairs(), keyExpression);
                     }
                     else {
-                        const listComp = this._tryParseListComprehension(keyExpression, /* isGenerator */ false);
-                        if (listComp) {
-                            keyExpression = listComp;
-                            sawListComprehension = true;
+                        const comprehension = this._tryParseComprehension(keyExpression, /* isGenerator */ false);
+                        if (comprehension) {
+                            keyExpression = comprehension;
+                            sawComprehension = true;
                             if (!isFirstEntry) {
                                 this._addSyntaxError(localize_1.LocMessage.comprehensionInSet(), keyExpression);
                             }
@@ -3327,7 +3327,7 @@ class Parser {
                 }
             }
             // List comprehension statements always end the list.
-            if (sawListComprehension) {
+            if (sawComprehension) {
                 break;
             }
             if (this._peekTokenType() !== 12 /* TokenType.Comma */) {
@@ -3531,7 +3531,7 @@ class Parser {
         }
         const returnType = this._parseTypeAnnotation();
         let isParamListEllipsis = false;
-        if (paramAnnotations.length === 1 && paramAnnotations[0].nodeType === 18 /* ParseNodeType.Ellipsis */) {
+        if (paramAnnotations.length === 1 && paramAnnotations[0].nodeType === 21 /* ParseNodeType.Ellipsis */) {
             paramAnnotations = [];
             isParamListEllipsis = true;
         }
@@ -3812,7 +3812,7 @@ class Parser {
                     this._addSyntaxError(localize_1.LocMessage.annotationSpansStrings(), stringNode);
                 }
             }
-            else if (stringNode.strings[0].nodeType === 27 /* ParseNodeType.FormatString */) {
+            else if (stringNode.strings[0].nodeType === 30 /* ParseNodeType.FormatString */) {
                 if (this._isParsingQuotedText) {
                     this._addSyntaxError(localize_1.LocMessage.annotationFormatString(), stringNode);
                 }