@zzzen/pyright-internal 1.2.0-dev.20250413 → 1.2.0-dev.20250802

package/dist/analyzer/parseTreeUtils.js

@@ -83,7 +83,6 @@ exports.getTokenIndexAtLeft = getTokenIndexAtLeft;
 exports.getTokenAtLeft = getTokenAtLeft;
 exports.getTokenIndexAfter = getTokenIndexAfter;
 exports.getTokenAfter = getTokenAfter;
-exports.isWhitespace = isWhitespace;
 exports.getTokenAtIndex = getTokenAtIndex;
 exports.getTokenAt = getTokenAt;
 exports.getTokenOverlapping = getTokenOverlapping;
@@ -133,6 +132,8 @@ const positionUtils_1 = require("../common/positionUtils");
 const textRange_1 = require("../common/textRange");
 const textRangeCollection_1 = require("../common/textRangeCollection");
 const parseNodes_1 = require("../parser/parseNodes");
+const parseNodeUtils_1 = require("../parser/parseNodeUtils");
+const tokenizer_1 = require("../parser/tokenizer");
 const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
 const parseTreeWalker_1 = require("./parseTreeWalker");
 var PrintExpressionFlags;
@@ -218,13 +219,7 @@ function isCompliantWithNodeRangeRules(node) {
     // 1. Children are all contained within the parent.
     // 2. Children have non-overlapping ranges.
     // 3. Children are listed in increasing order.
-    if (node.nodeType === 3 /* ParseNodeType.Assignment */ || node.nodeType === 48 /* ParseNodeType.StringList */) {
-        return false;
-    }
-    if (node.nodeType === 1 /* ParseNodeType.Argument */ && node.d.isNameSameAsValue) {
-        return false;
-    }
-    return true;
+    return node.nodeType !== 3 /* ParseNodeType.Assignment */ && node.nodeType !== 48 /* ParseNodeType.StringList */;
 }
 function getClassFullName(classNode, moduleName, className) {
     const nameParts = [className];
@@ -257,9 +252,7 @@ function printArg(node, flags) {
     if (node.d.name) {
         argStr += node.d.name.d.value + '=';
     }
-    if (!node.d.isNameSameAsValue) {
-        argStr += printExpression(node.d.valueExpr, flags);
-    }
+    argStr += printExpression(node.d.valueExpr, flags);
     return argStr;
 }
 function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
@@ -337,6 +330,9 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
             if (node.d.token.flags & 64 /* StringTokenFlags.Format */) {
                 exprString += 'f';
             }
+            if (node.d.token.flags & 128 /* StringTokenFlags.Template */) {
+                exprString += 't';
+            }
             let escapedString = node.d.token.escapedValue;
             if ((flags & 2 /* PrintExpressionFlags.DoNotLimitStringLength */) === 0) {
                 const maxStringLength = 32;
@@ -566,54 +562,13 @@ function printExpression(node, flags = 0 /* PrintExpressionFlags.None */) {
     return '<Expression>';
 }
 function printOperator(operator) {
-    const operatorMap = {
-        [0 /* OperatorType.Add */]: '+',
-        [1 /* OperatorType.AddEqual */]: '+=',
-        [2 /* OperatorType.Assign */]: '=',
-        [3 /* OperatorType.BitwiseAnd */]: '&',
-        [4 /* OperatorType.BitwiseAndEqual */]: '&=',
-        [5 /* OperatorType.BitwiseInvert */]: '~',
-        [6 /* OperatorType.BitwiseOr */]: '|',
-        [7 /* OperatorType.BitwiseOrEqual */]: '|=',
-        [8 /* OperatorType.BitwiseXor */]: '^',
-        [9 /* OperatorType.BitwiseXorEqual */]: '^=',
-        [10 /* OperatorType.Divide */]: '/',
-        [11 /* OperatorType.DivideEqual */]: '/=',
-        [12 /* OperatorType.Equals */]: '==',
-        [13 /* OperatorType.FloorDivide */]: '//',
-        [14 /* OperatorType.FloorDivideEqual */]: '//=',
-        [15 /* OperatorType.GreaterThan */]: '>',
-        [16 /* OperatorType.GreaterThanOrEqual */]: '>=',
-        [17 /* OperatorType.LeftShift */]: '<<',
-        [18 /* OperatorType.LeftShiftEqual */]: '<<=',
-        [19 /* OperatorType.LessOrGreaterThan */]: '<>',
-        [20 /* OperatorType.LessThan */]: '<',
-        [21 /* OperatorType.LessThanOrEqual */]: '<=',
-        [22 /* OperatorType.MatrixMultiply */]: '@',
-        [23 /* OperatorType.MatrixMultiplyEqual */]: '@=',
-        [24 /* OperatorType.Mod */]: '%',
-        [25 /* OperatorType.ModEqual */]: '%=',
-        [26 /* OperatorType.Multiply */]: '*',
-        [27 /* OperatorType.MultiplyEqual */]: '*=',
-        [28 /* OperatorType.NotEquals */]: '!=',
-        [29 /* OperatorType.Power */]: '**',
-        [30 /* OperatorType.PowerEqual */]: '**=',
-        [31 /* OperatorType.RightShift */]: '>>',
-        [32 /* OperatorType.RightShiftEqual */]: '>>=',
-        [33 /* OperatorType.Subtract */]: '-',
-        [34 /* OperatorType.SubtractEqual */]: '-=',
-        [36 /* OperatorType.And */]: 'and',
-        [37 /* OperatorType.Or */]: 'or',
-        [38 /* OperatorType.Not */]: 'not ',
-        [39 /* OperatorType.Is */]: 'is',
-        [40 /* OperatorType.IsNot */]: 'is not',
-        [41 /* OperatorType.In */]: 'in',
-        [42 /* OperatorType.NotIn */]: 'not in',
-    };
-    if (operatorMap[operator]) {
-        return operatorMap[operator];
+    const operatorName = parseNodeUtils_1.OperatorTypeNameMap[operator];
+    if (operatorName) {
+        return operatorName;
+    }
+    else {
+        return 'unknown';
     }
-    return 'unknown';
 }
 // If the name node is the LHS of a call expression or is a member
 // name in the LHS of a call expression, returns the call node.
@@ -1614,7 +1569,7 @@ function getTokenIndexAtLeft(tokens, position, includeWhitespace = false, includ
         if (!includeZeroLengthToken && token.length === 0) {
             continue;
         }
-        if (!includeWhitespace && isWhitespace(token)) {
+        if (!includeWhitespace && tokenizer_1.Tokenizer.isWhitespace(token)) {
             continue;
         }
         if (textRange_1.TextRange.getEnd(token) <= position) {
@@ -1650,9 +1605,6 @@ function getTokenAfter(tokens, position, predicate) {
     }
     return tokens.getItemAt(index);
 }
-function isWhitespace(token) {
-    return token.type === 2 /* TokenType.NewLine */ || token.type === 3 /* TokenType.Indent */ || token.type === 4 /* TokenType.Dedent */;
-}
 function getTokenAtIndex(tokens, index) {
     if (index < 0) {
         return undefined;
@@ -1695,165 +1647,7 @@ function getCommentsAtTokenIndex(tokens, index) {
     return token.comments;
 }
 function printParseNodeType(type) {
-    switch (type) {
-        case 0 /* ParseNodeType.Error */:
-            return 'Error';
-        case 1 /* ParseNodeType.Argument */:
-            return 'Argument';
-        case 2 /* ParseNodeType.Assert */:
-            return 'Assert';
-        case 3 /* ParseNodeType.Assignment */:
-            return 'Assignment';
-        case 4 /* ParseNodeType.AssignmentExpression */:
-            return 'AssignmentExpression';
-        case 5 /* ParseNodeType.AugmentedAssignment */:
-            return 'AugmentedAssignment';
-        case 6 /* ParseNodeType.Await */:
-            return 'Await';
-        case 7 /* ParseNodeType.BinaryOperation */:
-            return 'BinaryOperation';
-        case 8 /* ParseNodeType.Break */:
-            return 'Break';
-        case 9 /* ParseNodeType.Call */:
-            return 'Call';
-        case 10 /* ParseNodeType.Class */:
-            return 'Class';
-        case 14 /* ParseNodeType.Constant */:
-            return 'Constant';
-        case 15 /* ParseNodeType.Continue */:
-            return 'Continue';
-        case 16 /* ParseNodeType.Decorator */:
-            return 'Decorator';
-        case 17 /* ParseNodeType.Del */:
-            return 'Del';
-        case 18 /* ParseNodeType.Dictionary */:
-            return 'Dictionary';
-        case 19 /* ParseNodeType.DictionaryExpandEntry */:
-            return 'DictionaryExpandEntry';
-        case 20 /* ParseNodeType.DictionaryKeyEntry */:
-            return 'DictionaryKeyEntry';
-        case 21 /* ParseNodeType.Ellipsis */:
-            return 'Ellipsis';
-        case 22 /* ParseNodeType.If */:
-            return 'If';
-        case 23 /* ParseNodeType.Import */:
-            return 'Import';
-        case 24 /* ParseNodeType.ImportAs */:
-            return 'ImportAs';
-        case 25 /* ParseNodeType.ImportFrom */:
-            return 'ImportFrom';
-        case 26 /* ParseNodeType.ImportFromAs */:
-            return 'ImportFromAs';
-        case 27 /* ParseNodeType.Index */:
-            return 'Index';
-        case 28 /* ParseNodeType.Except */:
-            return 'Except';
-        case 29 /* ParseNodeType.For */:
-            return 'For';
-        case 30 /* ParseNodeType.FormatString */:
-            return 'FormatString';
-        case 31 /* ParseNodeType.Function */:
-            return 'Function';
-        case 32 /* ParseNodeType.Global */:
-            return 'Global';
-        case 33 /* ParseNodeType.Lambda */:
-            return 'Lambda';
-        case 34 /* ParseNodeType.List */:
-            return 'List';
-        case 11 /* ParseNodeType.Comprehension */:
-            return 'Comprehension';
-        case 12 /* ParseNodeType.ComprehensionFor */:
-            return 'ComprehensionFor';
-        case 13 /* ParseNodeType.ComprehensionIf */:
-            return 'ComprehensionIf';
-        case 35 /* ParseNodeType.MemberAccess */:
-            return 'MemberAccess';
-        case 36 /* ParseNodeType.Module */:
-            return 'Module';
-        case 37 /* ParseNodeType.ModuleName */:
-            return 'ModuleName';
-        case 38 /* ParseNodeType.Name */:
-            return 'Name';
-        case 39 /* ParseNodeType.Nonlocal */:
-            return 'Nonlocal';
-        case 40 /* ParseNodeType.Number */:
-            return 'Number';
-        case 41 /* ParseNodeType.Parameter */:
-            return 'Parameter';
-        case 42 /* ParseNodeType.Pass */:
-            return 'Pass';
-        case 43 /* ParseNodeType.Raise */:
-            return 'Raise';
-        case 44 /* ParseNodeType.Return */:
-            return 'Return';
-        case 45 /* ParseNodeType.Set */:
-            return 'Set';
-        case 46 /* ParseNodeType.Slice */:
-            return 'Slice';
-        case 47 /* ParseNodeType.StatementList */:
-            return 'StatementList';
-        case 48 /* ParseNodeType.StringList */:
-            return 'StringList';
-        case 49 /* ParseNodeType.String */:
-            return 'String';
-        case 50 /* ParseNodeType.Suite */:
-            return 'Suite';
-        case 51 /* ParseNodeType.Ternary */:
-            return 'Ternary';
-        case 52 /* ParseNodeType.Tuple */:
-            return 'Tuple';
-        case 53 /* ParseNodeType.Try */:
-            return 'Try';
-        case 54 /* ParseNodeType.TypeAnnotation */:
-            return 'TypeAnnotation';
-        case 55 /* ParseNodeType.UnaryOperation */:
-            return 'UnaryOperation';
-        case 56 /* ParseNodeType.Unpack */:
-            return 'Unpack';
-        case 57 /* ParseNodeType.While */:
-            return 'While';
-        case 58 /* ParseNodeType.With */:
-            return 'With';
-        case 59 /* ParseNodeType.WithItem */:
-            return 'WithItem';
-        case 60 /* ParseNodeType.Yield */:
-            return 'Yield';
-        case 61 /* ParseNodeType.YieldFrom */:
-            return 'YieldFrom';
-        case 62 /* ParseNodeType.FunctionAnnotation */:
-            return 'FunctionAnnotation';
-        case 63 /* ParseNodeType.Match */:
-            return 'Match';
-        case 64 /* ParseNodeType.Case */:
-            return 'Case';
-        case 65 /* ParseNodeType.PatternSequence */:
-            return 'PatternSequence';
-        case 66 /* ParseNodeType.PatternAs */:
-            return 'PatternAs';
-        case 67 /* ParseNodeType.PatternLiteral */:
-            return 'PatternLiteral';
-        case 68 /* ParseNodeType.PatternClass */:
-            return 'PatternClass';
-        case 69 /* ParseNodeType.PatternCapture */:
-            return 'PatternCapture';
-        case 70 /* ParseNodeType.PatternMapping */:
-            return 'PatternMapping';
-        case 71 /* ParseNodeType.PatternMappingKeyEntry */:
-            return 'PatternMappingKeyEntry';
-        case 72 /* ParseNodeType.PatternMappingExpandEntry */:
-            return 'PatternMappingExpandEntry';
-        case 73 /* ParseNodeType.PatternValue */:
-            return 'PatternValue';
-        case 74 /* ParseNodeType.PatternClassArgument */:
-            return 'PatternClassArgument';
-        case 75 /* ParseNodeType.TypeParameter */:
-            return 'TypeParameter';
-        case 76 /* ParseNodeType.TypeParameterList */:
-            return 'TypeParameterList';
-        case 77 /* ParseNodeType.TypeAlias */:
-            return 'TypeAlias';
-    }
-    (0, debug_1.assertNever)(type);
+    return parseNodeUtils_1.ParseNodeTypeNameMap[type] ?? 'Unknown';
 }
 function isWriteAccess(node) {
     let prevNode = node;
@@ -2162,7 +1956,7 @@ function getFullStatementRange(statementNode, parseFileResults, options) {
 }
 function isBlankLine(tokenizerOutput, text, line) {
     const span = tokenizerOutput.lines.getItemAt(line);
-    return (0, core_1.containsOnlyWhitespace)(text, span);
+    return (0, core_1.containsOnlyWhitespace)(text, span.start, textRange_1.TextRange.getEnd(span));
 }
 function isUnannotatedFunction(node) {
     return (node.d.returnAnnotation === undefined &&
@@ -2401,7 +2195,7 @@ function isSimpleDefault(node) {
         case 35 /* ParseNodeType.MemberAccess */:
             return true;
         case 49 /* ParseNodeType.String */:
-            return (node.d.token.flags & 64 /* StringTokenFlags.Format */) === 0;
+            return (node.d.token.flags & (64 /* StringTokenFlags.Format */ | 128 /* StringTokenFlags.Template */)) === 0;
         case 48 /* ParseNodeType.StringList */:
             return node.d.strings.every(isSimpleDefault);
         case 55 /* ParseNodeType.UnaryOperation */:
@@ -2416,7 +2210,7 @@ function getPreviousNonWhitespaceToken(tokens, offset) {
     let tokenIndex = tokens.getItemAtPosition(offset);
     while (tokenIndex >= 0) {
         const token = tokens.getItemAt(tokenIndex);
-        if (!isWhitespace(token)) {
+        if (!tokenizer_1.Tokenizer.isWhitespace(token)) {
             return token;
         }
         tokenIndex -= 1;
@@ -2424,7 +2218,7 @@ function getPreviousNonWhitespaceToken(tokens, offset) {
     return undefined;
 }
 function getNextNonWhitespaceToken(tokens, offset) {
-    return getNextMatchingToken(tokens, offset, (token) => !isWhitespace(token));
+    return getNextMatchingToken(tokens, offset, (token) => !tokenizer_1.Tokenizer.isWhitespace(token));
 }
 function getNextMatchingToken(tokens, offset, match, exit = () => false) {
     let tokenIndex = tokens.getItemAtPosition(offset) + 1;