@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (170) hide show
  1. package/dist/analyzer/analyzerNodeInfo.js +74 -46
  2. package/dist/analyzer/analyzerNodeInfo.js.map +1 -1
  3. package/dist/analyzer/binder.js +507 -513
  4. package/dist/analyzer/binder.js.map +1 -1
  5. package/dist/analyzer/checker.js +652 -633
  6. package/dist/analyzer/checker.js.map +1 -1
  7. package/dist/analyzer/codeFlowEngine.d.ts +5 -3
  8. package/dist/analyzer/codeFlowEngine.js +143 -122
  9. package/dist/analyzer/codeFlowEngine.js.map +1 -1
  10. package/dist/analyzer/codeFlowTypes.js +30 -28
  11. package/dist/analyzer/codeFlowTypes.js.map +1 -1
  12. package/dist/analyzer/constraintSolver.d.ts +1 -1
  13. package/dist/analyzer/constraintSolver.js +71 -67
  14. package/dist/analyzer/constraintSolver.js.map +1 -1
  15. package/dist/analyzer/constructorTransform.js +22 -22
  16. package/dist/analyzer/constructorTransform.js.map +1 -1
  17. package/dist/analyzer/constructors.js +85 -77
  18. package/dist/analyzer/constructors.js.map +1 -1
  19. package/dist/analyzer/dataClasses.js +113 -176
  20. package/dist/analyzer/dataClasses.js.map +1 -1
  21. package/dist/analyzer/declaration.d.ts +1 -1
  22. package/dist/analyzer/declarationUtils.js +14 -15
  23. package/dist/analyzer/declarationUtils.js.map +1 -1
  24. package/dist/analyzer/decorators.js +85 -85
  25. package/dist/analyzer/decorators.js.map +1 -1
  26. package/dist/analyzer/enums.js +71 -57
  27. package/dist/analyzer/enums.js.map +1 -1
  28. package/dist/analyzer/functionTransform.js +8 -18
  29. package/dist/analyzer/functionTransform.js.map +1 -1
  30. package/dist/analyzer/importResolver.d.ts +2 -1
  31. package/dist/analyzer/importResolver.js +40 -29
  32. package/dist/analyzer/importResolver.js.map +1 -1
  33. package/dist/analyzer/importStatementUtils.js +27 -27
  34. package/dist/analyzer/importStatementUtils.js.map +1 -1
  35. package/dist/analyzer/namedTuples.js +33 -59
  36. package/dist/analyzer/namedTuples.js.map +1 -1
  37. package/dist/analyzer/operations.d.ts +4 -4
  38. package/dist/analyzer/operations.js +70 -70
  39. package/dist/analyzer/operations.js.map +1 -1
  40. package/dist/analyzer/packageTypeVerifier.js +66 -62
  41. package/dist/analyzer/packageTypeVerifier.js.map +1 -1
  42. package/dist/analyzer/parameterUtils.d.ts +4 -4
  43. package/dist/analyzer/parameterUtils.js +28 -46
  44. package/dist/analyzer/parameterUtils.js.map +1 -1
  45. package/dist/analyzer/parseTreeUtils.js +268 -269
  46. package/dist/analyzer/parseTreeUtils.js.map +1 -1
  47. package/dist/analyzer/parseTreeWalker.js +76 -76
  48. package/dist/analyzer/parseTreeWalker.js.map +1 -1
  49. package/dist/analyzer/patternMatching.js +195 -147
  50. package/dist/analyzer/patternMatching.js.map +1 -1
  51. package/dist/analyzer/program.js +1 -1
  52. package/dist/analyzer/program.js.map +1 -1
  53. package/dist/analyzer/properties.js +78 -147
  54. package/dist/analyzer/properties.js.map +1 -1
  55. package/dist/analyzer/protocols.js +22 -22
  56. package/dist/analyzer/protocols.js.map +1 -1
  57. package/dist/analyzer/sourceFile.d.ts +3 -2
  58. package/dist/analyzer/sourceFile.js +8 -8
  59. package/dist/analyzer/sourceFile.js.map +1 -1
  60. package/dist/analyzer/sourceMapper.js +20 -19
  61. package/dist/analyzer/sourceMapper.js.map +1 -1
  62. package/dist/analyzer/staticExpressions.js +83 -84
  63. package/dist/analyzer/staticExpressions.js.map +1 -1
  64. package/dist/analyzer/testWalker.js +2 -2
  65. package/dist/analyzer/testWalker.js.map +1 -1
  66. package/dist/analyzer/tracePrinter.js +20 -20
  67. package/dist/analyzer/tracePrinter.js.map +1 -1
  68. package/dist/analyzer/typeDocStringUtils.js +25 -25
  69. package/dist/analyzer/typeDocStringUtils.js.map +1 -1
  70. package/dist/analyzer/typeEvaluator.js +2330 -2367
  71. package/dist/analyzer/typeEvaluator.js.map +1 -1
  72. package/dist/analyzer/typeEvaluatorTypes.d.ts +33 -31
  73. package/dist/analyzer/typeEvaluatorTypes.js +48 -41
  74. package/dist/analyzer/typeEvaluatorTypes.js.map +1 -1
  75. package/dist/analyzer/typeGuards.js +221 -217
  76. package/dist/analyzer/typeGuards.js.map +1 -1
  77. package/dist/analyzer/typePrinter.js +118 -115
  78. package/dist/analyzer/typePrinter.js.map +1 -1
  79. package/dist/analyzer/typeStubWriter.js +104 -103
  80. package/dist/analyzer/typeStubWriter.js.map +1 -1
  81. package/dist/analyzer/typeUtils.d.ts +26 -9
  82. package/dist/analyzer/typeUtils.js +460 -404
  83. package/dist/analyzer/typeUtils.js.map +1 -1
  84. package/dist/analyzer/typeVarContext.js +8 -8
  85. package/dist/analyzer/typeVarContext.js.map +1 -1
  86. package/dist/analyzer/typeWalker.js +13 -10
  87. package/dist/analyzer/typeWalker.js.map +1 -1
  88. package/dist/analyzer/typedDicts.js +96 -198
  89. package/dist/analyzer/typedDicts.js.map +1 -1
  90. package/dist/analyzer/types.d.ts +147 -103
  91. package/dist/analyzer/types.js +668 -493
  92. package/dist/analyzer/types.js.map +1 -1
  93. package/dist/commands/dumpFileDebugInfoCommand.js +33 -33
  94. package/dist/commands/dumpFileDebugInfoCommand.js.map +1 -1
  95. package/dist/common/diagnostic.d.ts +14 -0
  96. package/dist/common/diagnostic.js +41 -1
  97. package/dist/common/diagnostic.js.map +1 -1
  98. package/dist/common/diagnosticSink.d.ts +4 -0
  99. package/dist/common/diagnosticSink.js +21 -1
  100. package/dist/common/diagnosticSink.js.map +1 -1
  101. package/dist/common/fileSystem.d.ts +1 -0
  102. package/dist/common/fileSystem.js.map +1 -1
  103. package/dist/common/fullAccessHost.js +6 -4
  104. package/dist/common/fullAccessHost.js.map +1 -1
  105. package/dist/common/realFileSystem.d.ts +1 -0
  106. package/dist/common/realFileSystem.js +4 -0
  107. package/dist/common/realFileSystem.js.map +1 -1
  108. package/dist/common/textEditTracker.js +14 -14
  109. package/dist/common/textEditTracker.js.map +1 -1
  110. package/dist/languageService/autoImporter.js +10 -10
  111. package/dist/languageService/autoImporter.js.map +1 -1
  112. package/dist/languageService/callHierarchyProvider.js +23 -23
  113. package/dist/languageService/callHierarchyProvider.js.map +1 -1
  114. package/dist/languageService/completionProvider.d.ts +1 -1
  115. package/dist/languageService/completionProvider.js +156 -154
  116. package/dist/languageService/completionProvider.js.map +1 -1
  117. package/dist/languageService/definitionProvider.d.ts +1 -1
  118. package/dist/languageService/definitionProvider.js +3 -1
  119. package/dist/languageService/definitionProvider.js.map +1 -1
  120. package/dist/languageService/documentSymbolCollector.js +19 -19
  121. package/dist/languageService/documentSymbolCollector.js.map +1 -1
  122. package/dist/languageService/hoverProvider.js +25 -24
  123. package/dist/languageService/hoverProvider.js.map +1 -1
  124. package/dist/languageService/importSorter.js +8 -8
  125. package/dist/languageService/importSorter.js.map +1 -1
  126. package/dist/languageService/referencesProvider.js +8 -8
  127. package/dist/languageService/referencesProvider.js.map +1 -1
  128. package/dist/languageService/signatureHelpProvider.d.ts +1 -1
  129. package/dist/languageService/signatureHelpProvider.js +6 -6
  130. package/dist/languageService/signatureHelpProvider.js.map +1 -1
  131. package/dist/languageService/symbolIndexer.js +3 -3
  132. package/dist/languageService/symbolIndexer.js.map +1 -1
  133. package/dist/languageService/tooltipUtils.js +13 -13
  134. package/dist/languageService/tooltipUtils.js.map +1 -1
  135. package/dist/localization/localize.d.ts +3 -0
  136. package/dist/localization/localize.js +1 -0
  137. package/dist/localization/localize.js.map +1 -1
  138. package/dist/localization/package.nls.en-us.json +2 -1
  139. package/dist/parser/parseNodes.d.ts +468 -401
  140. package/dist/parser/parseNodes.js +626 -355
  141. package/dist/parser/parseNodes.js.map +1 -1
  142. package/dist/parser/parser.d.ts +1 -0
  143. package/dist/parser/parser.js +322 -297
  144. package/dist/parser/parser.js.map +1 -1
  145. package/dist/pyright.js +265 -5
  146. package/dist/pyright.js.map +1 -1
  147. package/dist/tests/classDeclaration.test.js +14 -14
  148. package/dist/tests/classDeclaration.test.js.map +1 -1
  149. package/dist/tests/fourslash/hover.init.fourslash.js +1 -1
  150. package/dist/tests/fourslash/hover.init.fourslash.js.map +1 -1
  151. package/dist/tests/harness/vfs/filesystem.d.ts +3 -2
  152. package/dist/tests/harness/vfs/filesystem.js +6 -2
  153. package/dist/tests/harness/vfs/filesystem.js.map +1 -1
  154. package/dist/tests/importResolver.test.js +4 -3
  155. package/dist/tests/importResolver.test.js.map +1 -1
  156. package/dist/tests/parseTreeUtils.test.js +5 -5
  157. package/dist/tests/parseTreeUtils.test.js.map +1 -1
  158. package/dist/tests/parser.test.js +8 -8
  159. package/dist/tests/parser.test.js.map +1 -1
  160. package/dist/tests/sourceMapperUtils.test.js +7 -7
  161. package/dist/tests/sourceMapperUtils.test.js.map +1 -1
  162. package/dist/tests/typeEvaluator2.test.js +2 -2
  163. package/dist/tests/typeEvaluator3.test.js +10 -5
  164. package/dist/tests/typeEvaluator3.test.js.map +1 -1
  165. package/dist/tests/typeEvaluator4.test.js +1 -1
  166. package/dist/tests/typeEvaluator7.test.js +2 -2
  167. package/dist/tests/typeEvaluator7.test.js.map +1 -1
  168. package/dist/tests/typePrinter.test.js +14 -39
  169. package/dist/tests/typePrinter.test.js.map +1 -1
  170. package/package.json +1 -1
@@ -59,27 +59,27 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
59
59
  return getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount);
60
60
  }
61
61
  if (testExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
62
- const isOrIsNotOperator = testExpression.operator === 39 /* OperatorType.Is */ || testExpression.operator === 40 /* OperatorType.IsNot */;
63
- const equalsOrNotEqualsOperator = testExpression.operator === 12 /* OperatorType.Equals */ || testExpression.operator === 28 /* OperatorType.NotEquals */;
62
+ const isOrIsNotOperator = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 40 /* OperatorType.IsNot */;
63
+ const equalsOrNotEqualsOperator = testExpression.d.operator === 12 /* OperatorType.Equals */ || testExpression.d.operator === 28 /* OperatorType.NotEquals */;
64
64
  const comparisonOperator = equalsOrNotEqualsOperator ||
65
- testExpression.operator === 20 /* OperatorType.LessThan */ ||
66
- testExpression.operator === 21 /* OperatorType.LessThanOrEqual */ ||
67
- testExpression.operator === 15 /* OperatorType.GreaterThan */ ||
68
- testExpression.operator === 16 /* OperatorType.GreaterThanOrEqual */;
65
+ testExpression.d.operator === 20 /* OperatorType.LessThan */ ||
66
+ testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
67
+ testExpression.d.operator === 15 /* OperatorType.GreaterThan */ ||
68
+ testExpression.d.operator === 16 /* OperatorType.GreaterThanOrEqual */;
69
69
  if (isOrIsNotOperator || equalsOrNotEqualsOperator) {
70
70
  // Invert the "isPositiveTest" value if this is an "is not" operation.
71
- const adjIsPositiveTest = testExpression.operator === 39 /* OperatorType.Is */ || testExpression.operator === 12 /* OperatorType.Equals */
71
+ const adjIsPositiveTest = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 12 /* OperatorType.Equals */
72
72
  ? isPositiveTest
73
73
  : !isPositiveTest;
74
74
  // Look for "X is None", "X is not None", "X == None", and "X != None".
75
75
  // These are commonly-used patterns used in control flow.
76
- if (testExpression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
77
- testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
76
+ if (testExpression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
77
+ testExpression.d.rightExpr.d.constType === 26 /* KeywordType.None */) {
78
78
  // Allow the LHS to be either a simple expression or an assignment
79
79
  // expression that assigns to a simple name.
80
- let leftExpression = testExpression.leftExpression;
80
+ let leftExpression = testExpression.d.leftExpr;
81
81
  if (leftExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
82
- leftExpression = leftExpression.name;
82
+ leftExpression = leftExpression.d.name;
83
83
  }
84
84
  if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
85
85
  return (type) => {
@@ -87,15 +87,15 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
87
87
  };
88
88
  }
89
89
  if (leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
90
- ParseTreeUtils.isMatchingExpression(reference, leftExpression.baseExpression) &&
91
- leftExpression.items.length === 1 &&
92
- !leftExpression.trailingComma &&
93
- leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
94
- !leftExpression.items[0].name &&
95
- leftExpression.items[0].valueExpression.nodeType === 40 /* ParseNodeType.Number */ &&
96
- leftExpression.items[0].valueExpression.isInteger &&
97
- !leftExpression.items[0].valueExpression.isImaginary) {
98
- const indexValue = leftExpression.items[0].valueExpression.value;
90
+ ParseTreeUtils.isMatchingExpression(reference, leftExpression.d.leftExpr) &&
91
+ leftExpression.d.items.length === 1 &&
92
+ !leftExpression.d.trailingComma &&
93
+ leftExpression.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
94
+ !leftExpression.d.items[0].d.name &&
95
+ leftExpression.d.items[0].d.valueExpr.nodeType === 40 /* ParseNodeType.Number */ &&
96
+ leftExpression.d.items[0].d.valueExpr.d.isInteger &&
97
+ !leftExpression.d.items[0].d.valueExpr.d.isImaginary) {
98
+ const indexValue = leftExpression.d.items[0].d.valueExpr.d.value;
99
99
  if (typeof indexValue === 'number') {
100
100
  return (type) => {
101
101
  return {
@@ -107,12 +107,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
107
107
  }
108
108
  }
109
109
  // Look for "X is ...", "X is not ...", "X == ...", and "X != ...".
110
- if (testExpression.rightExpression.nodeType === 21 /* ParseNodeType.Ellipsis */) {
110
+ if (testExpression.d.rightExpr.nodeType === 21 /* ParseNodeType.Ellipsis */) {
111
111
  // Allow the LHS to be either a simple expression or an assignment
112
112
  // expression that assigns to a simple name.
113
- let leftExpression = testExpression.leftExpression;
113
+ let leftExpression = testExpression.d.leftExpr;
114
114
  if (leftExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
115
- leftExpression = leftExpression.name;
115
+ leftExpression = leftExpression.d.name;
116
116
  }
117
117
  if (ParseTreeUtils.isMatchingExpression(reference, leftExpression)) {
118
118
  return (type) => {
@@ -124,14 +124,14 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
124
124
  }
125
125
  }
126
126
  // Look for "type(X) is Y", "type(X) is not Y", "type(X) == Y" or "type(X) != Y".
127
- if (testExpression.leftExpression.nodeType === 9 /* ParseNodeType.Call */) {
128
- if (testExpression.leftExpression.arguments.length === 1 &&
129
- testExpression.leftExpression.arguments[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
130
- const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
127
+ if (testExpression.d.leftExpr.nodeType === 9 /* ParseNodeType.Call */) {
128
+ if (testExpression.d.leftExpr.d.args.length === 1 &&
129
+ testExpression.d.leftExpr.d.args[0].d.argCategory === 0 /* ArgumentCategory.Simple */) {
130
+ const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
131
131
  if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
132
- const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
132
+ const callType = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */).type;
133
133
  if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type')) {
134
- const classTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
134
+ const classTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
135
135
  const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
136
136
  if ((0, types_1.isInstantiableClass)(classType)) {
137
137
  return (type) => {
@@ -146,13 +146,13 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
146
146
  }
147
147
  }
148
148
  if (isOrIsNotOperator) {
149
- if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
150
- const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
149
+ if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
150
+ const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
151
151
  const rightType = rightTypeResult.type;
152
152
  // Look for "X is Y" or "X is not Y" where Y is a an enum or bool literal.
153
153
  if ((0, types_1.isClassInstance)(rightType) &&
154
154
  (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
155
- rightType.literalValue !== undefined) {
155
+ rightType.priv.literalValue !== undefined) {
156
156
  return (type) => {
157
157
  return {
158
158
  type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest,
@@ -172,17 +172,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
172
172
  }
173
173
  }
174
174
  // Look for X[<literal>] is <literal> or X[<literal>] is not <literal>.
175
- if (testExpression.leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
176
- testExpression.leftExpression.items.length === 1 &&
177
- !testExpression.leftExpression.trailingComma &&
178
- testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
179
- ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
180
- const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
175
+ if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
176
+ testExpression.d.leftExpr.d.items.length === 1 &&
177
+ !testExpression.d.leftExpr.d.trailingComma &&
178
+ testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
179
+ ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
180
+ const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
181
181
  const indexType = indexTypeResult.type;
182
182
  if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
183
183
  if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
184
- const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
185
- if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
184
+ const rightType = evaluator.getTypeOfExpression(testExpression.d.rightExpr).type;
185
+ if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
186
186
  return (type) => {
187
187
  return {
188
188
  type: narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
@@ -192,15 +192,15 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
192
192
  }
193
193
  }
194
194
  else if (types_1.ClassType.isBuiltIn(indexType, 'int')) {
195
- const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
195
+ const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
196
196
  const rightType = rightTypeResult.type;
197
- if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
197
+ if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
198
198
  let canNarrow = false;
199
199
  // Narrowing can be applied only for bool or enum literals.
200
200
  if (types_1.ClassType.isBuiltIn(rightType, 'bool')) {
201
201
  canNarrow = true;
202
202
  }
203
- else if (rightType.literalValue instanceof types_1.EnumLiteral) {
203
+ else if (rightType.priv.literalValue instanceof types_1.EnumLiteral) {
204
204
  canNarrow = true;
205
205
  }
206
206
  if (canNarrow) {
@@ -218,16 +218,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
218
218
  }
219
219
  if (equalsOrNotEqualsOperator) {
220
220
  // Look for X == <literal> or X != <literal>
221
- const adjIsPositiveTest = testExpression.operator === 12 /* OperatorType.Equals */ ? isPositiveTest : !isPositiveTest;
222
- if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
221
+ const adjIsPositiveTest = testExpression.d.operator === 12 /* OperatorType.Equals */ ? isPositiveTest : !isPositiveTest;
222
+ if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
223
223
  // Use speculative mode here to avoid polluting the type cache. This is
224
224
  // important in cases where evaluation of the right expression creates
225
225
  // a false dependency on another variable.
226
- const rightTypeResult = evaluator.useSpeculativeMode(testExpression.rightExpression, () => {
227
- return evaluator.getTypeOfExpression(testExpression.rightExpression);
226
+ const rightTypeResult = evaluator.useSpeculativeMode(testExpression.d.rightExpr, () => {
227
+ return evaluator.getTypeOfExpression(testExpression.d.rightExpr);
228
228
  });
229
229
  const rightType = rightTypeResult.type;
230
- if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
230
+ if ((0, types_1.isClassInstance)(rightType) && rightType.priv.literalValue !== undefined) {
231
231
  return (type) => {
232
232
  return {
233
233
  type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest,
@@ -238,16 +238,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
238
238
  }
239
239
  }
240
240
  // Look for X[<literal>] == <literal> or X[<literal>] != <literal>
241
- if (testExpression.leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
242
- testExpression.leftExpression.items.length === 1 &&
243
- !testExpression.leftExpression.trailingComma &&
244
- testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
245
- ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
246
- const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
241
+ if (testExpression.d.leftExpr.nodeType === 27 /* ParseNodeType.Index */ &&
242
+ testExpression.d.leftExpr.d.items.length === 1 &&
243
+ !testExpression.d.leftExpr.d.trailingComma &&
244
+ testExpression.d.leftExpr.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
245
+ ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
246
+ const indexTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.items[0].d.valueExpr);
247
247
  const indexType = indexTypeResult.type;
248
248
  if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
249
249
  if (types_1.ClassType.isBuiltIn(indexType, ['str', 'int'])) {
250
- const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
250
+ const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
251
251
  const rightType = rightTypeResult.type;
252
252
  if ((0, typeUtils_1.isLiteralTypeOrUnion)(rightType)) {
253
253
  return (type) => {
@@ -270,16 +270,16 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
270
270
  }
271
271
  // Look for X.Y == <literal> or X.Y != <literal>
272
272
  if (equalsOrNotEqualsOperator &&
273
- testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
274
- ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
275
- const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
273
+ testExpression.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
274
+ ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
275
+ const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
276
276
  const rightType = rightTypeResult.type;
277
- const memberName = testExpression.leftExpression.memberName;
277
+ const memberName = testExpression.d.leftExpr.d.member;
278
278
  if ((0, types_1.isClassInstance)(rightType)) {
279
- if (rightType.literalValue !== undefined || (0, typeUtils_1.isNoneInstance)(rightType)) {
279
+ if (rightType.priv.literalValue !== undefined || (0, typeUtils_1.isNoneInstance)(rightType)) {
280
280
  return (type) => {
281
281
  return {
282
- type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
282
+ type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.d.value, rightType, adjIsPositiveTest),
283
283
  isIncomplete: !!rightTypeResult.isIncomplete,
284
284
  };
285
285
  };
@@ -288,17 +288,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
288
288
  }
289
289
  // Look for X.Y is <literal> or X.Y is not <literal> where <literal> is
290
290
  // an enum or bool literal
291
- if (testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
292
- ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression)) {
293
- const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
291
+ if (testExpression.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
292
+ ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr)) {
293
+ const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
294
294
  const rightType = rightTypeResult.type;
295
- const memberName = testExpression.leftExpression.memberName;
295
+ const memberName = testExpression.d.leftExpr.d.member;
296
296
  if ((0, types_1.isClassInstance)(rightType) &&
297
297
  (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
298
- rightType.literalValue !== undefined) {
298
+ rightType.priv.literalValue !== undefined) {
299
299
  return (type) => {
300
300
  return {
301
- type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
301
+ type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.d.value, rightType, adjIsPositiveTest),
302
302
  isIncomplete: !!rightTypeResult.isIncomplete,
303
303
  };
304
304
  };
@@ -306,14 +306,14 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
306
306
  }
307
307
  // Look for X.Y is None or X.Y is not None
308
308
  // These are commonly-used patterns used in control flow.
309
- if (testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
310
- ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression) &&
311
- testExpression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
312
- testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
313
- const memberName = testExpression.leftExpression.memberName;
309
+ if (testExpression.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
310
+ ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr.d.leftExpr) &&
311
+ testExpression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
312
+ testExpression.d.rightExpr.d.constType === 26 /* KeywordType.None */) {
313
+ const memberName = testExpression.d.leftExpr.d.member;
314
314
  return (type) => {
315
315
  return {
316
- type: narrowTypeForDiscriminatedFieldNoneComparison(evaluator, type, memberName.value, adjIsPositiveTest),
316
+ type: narrowTypeForDiscriminatedFieldNoneComparison(evaluator, type, memberName.d.value, adjIsPositiveTest),
317
317
  isIncomplete: false,
318
318
  };
319
319
  };
@@ -321,32 +321,32 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
321
321
  }
322
322
  // Look for len(x) == <literal>, len(x) != <literal>, len(x) < <literal>, etc.
323
323
  if (comparisonOperator &&
324
- testExpression.leftExpression.nodeType === 9 /* ParseNodeType.Call */ &&
325
- testExpression.leftExpression.arguments.length === 1) {
326
- const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
324
+ testExpression.d.leftExpr.nodeType === 9 /* ParseNodeType.Call */ &&
325
+ testExpression.d.leftExpr.d.args.length === 1) {
326
+ const arg0Expr = testExpression.d.leftExpr.d.args[0].d.valueExpr;
327
327
  if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
328
- const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
328
+ const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
329
329
  const callType = callTypeResult.type;
330
- if ((0, types_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
331
- const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
330
+ if ((0, types_1.isFunction)(callType) && callType.shared.fullName === 'builtins.len') {
331
+ const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
332
332
  const rightType = rightTypeResult.type;
333
333
  if ((0, types_1.isClassInstance)(rightType) &&
334
- typeof rightType.literalValue === 'number' &&
335
- rightType.literalValue >= 0) {
336
- let tupleLength = rightType.literalValue;
334
+ typeof rightType.priv.literalValue === 'number' &&
335
+ rightType.priv.literalValue >= 0) {
336
+ let tupleLength = rightType.priv.literalValue;
337
337
  // We'll treat <, <= and == as positive tests with >=, > and != as
338
338
  // their negative counterparts.
339
- const isLessOrEqual = testExpression.operator === 12 /* OperatorType.Equals */ ||
340
- testExpression.operator === 20 /* OperatorType.LessThan */ ||
341
- testExpression.operator === 21 /* OperatorType.LessThanOrEqual */;
339
+ const isLessOrEqual = testExpression.d.operator === 12 /* OperatorType.Equals */ ||
340
+ testExpression.d.operator === 20 /* OperatorType.LessThan */ ||
341
+ testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */;
342
342
  const adjIsPositiveTest = isLessOrEqual ? isPositiveTest : !isPositiveTest;
343
343
  // For <= (or its negative counterpart >), adjust the tuple length by 1.
344
- if (testExpression.operator === 21 /* OperatorType.LessThanOrEqual */ ||
345
- testExpression.operator === 15 /* OperatorType.GreaterThan */) {
344
+ if (testExpression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
345
+ testExpression.d.operator === 15 /* OperatorType.GreaterThan */) {
346
346
  tupleLength++;
347
347
  }
348
- const isEqualityCheck = testExpression.operator === 12 /* OperatorType.Equals */ ||
349
- testExpression.operator === 28 /* OperatorType.NotEquals */;
348
+ const isEqualityCheck = testExpression.d.operator === 12 /* OperatorType.Equals */ ||
349
+ testExpression.d.operator === 28 /* OperatorType.NotEquals */;
350
350
  return (type) => {
351
351
  return {
352
352
  type: narrowTypeForTupleLength(evaluator, type, tupleLength, adjIsPositiveTest, !isEqualityCheck),
@@ -357,12 +357,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
357
357
  }
358
358
  }
359
359
  }
360
- if (testExpression.operator === 41 /* OperatorType.In */ || testExpression.operator === 42 /* OperatorType.NotIn */) {
360
+ if (testExpression.d.operator === 41 /* OperatorType.In */ || testExpression.d.operator === 42 /* OperatorType.NotIn */) {
361
361
  // Look for "x in y" or "x not in y" where y is one of several built-in types.
362
- if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
363
- const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
362
+ if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.leftExpr)) {
363
+ const rightTypeResult = evaluator.getTypeOfExpression(testExpression.d.rightExpr);
364
364
  const rightType = rightTypeResult.type;
365
- const adjIsPositiveTest = testExpression.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
365
+ const adjIsPositiveTest = testExpression.d.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
366
366
  return (type) => {
367
367
  return {
368
368
  type: narrowTypeForContainerType(evaluator, type, rightType, adjIsPositiveTest),
@@ -370,13 +370,13 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
370
370
  };
371
371
  };
372
372
  }
373
- if (ParseTreeUtils.isMatchingExpression(reference, testExpression.rightExpression)) {
373
+ if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.rightExpr)) {
374
374
  // Look for <string literal> in y where y is a union that contains
375
375
  // one or more TypedDicts.
376
- const leftTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression);
376
+ const leftTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr);
377
377
  const leftType = leftTypeResult.type;
378
378
  if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
379
- const adjIsPositiveTest = testExpression.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
379
+ const adjIsPositiveTest = testExpression.d.operator === 41 /* OperatorType.In */ ? isPositiveTest : !isPositiveTest;
380
380
  return (type) => {
381
381
  return {
382
382
  type: narrowTypeForTypedDictKey(evaluator, type, types_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
@@ -389,26 +389,20 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
389
389
  }
390
390
  if (testExpression.nodeType === 9 /* ParseNodeType.Call */) {
391
391
  // Look for "isinstance(X, Y)" or "issubclass(X, Y)".
392
- if (testExpression.arguments.length === 2) {
392
+ if (testExpression.d.args.length === 2) {
393
393
  // Make sure the first parameter is a supported expression type
394
394
  // and the second parameter is a valid class type or a tuple
395
395
  // of valid class types.
396
- const arg0Expr = testExpression.arguments[0].valueExpression;
397
- const arg1Expr = testExpression.arguments[1].valueExpression;
396
+ const arg0Expr = testExpression.d.args[0].d.valueExpr;
397
+ const arg1Expr = testExpression.d.args[1].d.valueExpr;
398
398
  if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
399
- const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
399
+ const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
400
400
  const callType = callTypeResult.type;
401
- if ((0, types_1.isFunction)(callType) &&
402
- (callType.details.builtInName === 'isinstance' || callType.details.builtInName === 'issubclass')) {
403
- const isInstanceCheck = callType.details.builtInName === 'isinstance';
404
- const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
405
- 8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
406
- 32 /* EvaluatorFlags.DisallowParamSpec */ |
407
- 64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
408
- 16 /* EvaluatorFlags.DisallowFinal */ |
409
- 2 /* EvaluatorFlags.DoNotSpecialize */);
401
+ if ((0, types_1.isFunction)(callType) && types_1.FunctionType.isBuiltIn(callType, ['isinstance', 'issubclass'])) {
402
+ const isInstanceCheck = types_1.FunctionType.isBuiltIn(callType, 'isinstance');
403
+ const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 536871546 /* EvalFlags.IsInstanceArgDefaults */);
410
404
  const arg1Type = arg1TypeResult.type;
411
- const classTypeList = getIsInstanceClassTypes(arg1Type);
405
+ const classTypeList = getIsInstanceClassTypes(evaluator, arg1Type);
412
406
  const isIncomplete = !!callTypeResult.isIncomplete || !!arg1TypeResult.isIncomplete;
413
407
  if (classTypeList) {
414
408
  return (type) => {
@@ -433,12 +427,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
433
427
  }
434
428
  }
435
429
  // Look for "callable(X)"
436
- if (testExpression.arguments.length === 1) {
437
- const arg0Expr = testExpression.arguments[0].valueExpression;
430
+ if (testExpression.d.args.length === 1) {
431
+ const arg0Expr = testExpression.d.args[0].d.valueExpr;
438
432
  if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
439
- const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
433
+ const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
440
434
  const callType = callTypeResult.type;
441
- if ((0, types_1.isFunction)(callType) && callType.details.builtInName === 'callable') {
435
+ if ((0, types_1.isFunction)(callType) && types_1.FunctionType.isBuiltIn(callType, 'callable')) {
442
436
  return (type) => {
443
437
  let narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression,
444
438
  /* allowIntersections */ false);
@@ -453,9 +447,9 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
453
447
  }
454
448
  }
455
449
  // Look for "bool(X)"
456
- if (testExpression.arguments.length === 1 && !testExpression.arguments[0].name) {
457
- if (ParseTreeUtils.isMatchingExpression(reference, testExpression.arguments[0].valueExpression)) {
458
- const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
450
+ if (testExpression.d.args.length === 1 && !testExpression.d.args[0].d.name) {
451
+ if (ParseTreeUtils.isMatchingExpression(reference, testExpression.d.args[0].d.valueExpr)) {
452
+ const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
459
453
  const callType = callTypeResult.type;
460
454
  if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
461
455
  return (type) => {
@@ -468,17 +462,17 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
468
462
  }
469
463
  }
470
464
  // Look for a TypeGuard function.
471
- if (testExpression.arguments.length >= 1) {
472
- const arg0Expr = testExpression.arguments[0].valueExpression;
465
+ if (testExpression.d.args.length >= 1) {
466
+ const arg0Expr = testExpression.d.args[0].d.valueExpr;
473
467
  if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
474
468
  // Does this look like it's a custom type guard function?
475
469
  let isPossiblyTypeGuard = false;
476
470
  const isFunctionReturnTypeGuard = (type) => {
477
- return (type.details.declaredReturnType &&
478
- (0, types_1.isClassInstance)(type.details.declaredReturnType) &&
479
- types_1.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'TypeIs']));
471
+ return (type.shared.declaredReturnType &&
472
+ (0, types_1.isClassInstance)(type.shared.declaredReturnType) &&
473
+ types_1.ClassType.isBuiltIn(type.shared.declaredReturnType, ['TypeGuard', 'TypeIs']));
480
474
  };
481
- const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
475
+ const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
482
476
  const callType = callTypeResult.type;
483
477
  if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
484
478
  isPossiblyTypeGuard = true;
@@ -496,9 +490,9 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
496
490
  const functionReturnType = functionReturnTypeResult.type;
497
491
  if ((0, types_1.isClassInstance)(functionReturnType) &&
498
492
  types_1.ClassType.isBuiltIn(functionReturnType, 'bool') &&
499
- functionReturnType.typeGuardType) {
500
- const isStrictTypeGuard = !!functionReturnType.isStrictTypeGuard;
501
- const typeGuardType = functionReturnType.typeGuardType;
493
+ functionReturnType.priv.typeGuardType) {
494
+ const isStrictTypeGuard = !!functionReturnType.priv.isStrictTypeGuard;
495
+ const typeGuardType = functionReturnType.priv.typeGuardType;
502
496
  const isIncomplete = !!callTypeResult.isIncomplete || !!functionReturnTypeResult.isIncomplete;
503
497
  return (type) => {
504
498
  return {
@@ -529,8 +523,9 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
529
523
  // by the binder when it creates condition flow nodes, but we can find this
530
524
  // in the case of local variables type narrowing.
531
525
  if (reference.nodeType === 38 /* ParseNodeType.Name */) {
532
- if (testExpression.nodeType === 55 /* ParseNodeType.UnaryOperation */ && testExpression.operator === 38 /* OperatorType.Not */) {
533
- return getTypeNarrowingCallback(evaluator, reference, testExpression.expression, !isPositiveTest, recursionCount);
526
+ if (testExpression.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
527
+ testExpression.d.operator === 38 /* OperatorType.Not */) {
528
+ return getTypeNarrowingCallback(evaluator, reference, testExpression.d.expr, !isPositiveTest, recursionCount);
534
529
  }
535
530
  }
536
531
  return undefined;
@@ -592,7 +587,7 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
592
587
  if ((scope === null || scope === void 0 ? void 0 : scope.type) !== 2 /* ScopeType.Function */ && (scope === null || scope === void 0 ? void 0 : scope.type) !== 4 /* ScopeType.Module */) {
593
588
  return undefined;
594
589
  }
595
- const symbol = scope.lookUpSymbol(name.value);
590
+ const symbol = scope.lookUpSymbol(name.d.value);
596
591
  if (!symbol) {
597
592
  return undefined;
598
593
  }
@@ -608,7 +603,7 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
608
603
  // "nonlocal" reference), don't consider it a local variable.
609
604
  let prevDeclScope;
610
605
  if (decls.some((decl) => {
611
- const nodeToConsider = decl.type === 2 /* DeclarationType.Parameter */ ? decl.node.name : decl.node;
606
+ const nodeToConsider = decl.type === 2 /* DeclarationType.Parameter */ ? decl.node.d.name : decl.node;
612
607
  const declScopeNode = ParseTreeUtils.getExecutionScopeNode(nodeToConsider);
613
608
  if (prevDeclScope && declScopeNode !== prevDeclScope) {
614
609
  return true;
@@ -623,7 +618,7 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
623
618
  }
624
619
  function getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
625
620
  var _a;
626
- return ((_a = getTypeNarrowingCallback(evaluator, reference, testExpression.rightExpression, isPositiveTest, recursionCount)) !== null && _a !== void 0 ? _a : getTypeNarrowingCallback(evaluator, reference, testExpression.name, isPositiveTest, recursionCount));
621
+ return ((_a = getTypeNarrowingCallback(evaluator, reference, testExpression.d.rightExpr, isPositiveTest, recursionCount)) !== null && _a !== void 0 ? _a : getTypeNarrowingCallback(evaluator, reference, testExpression.d.name, isPositiveTest, recursionCount));
627
622
  }
628
623
  function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, errorNode) {
629
624
  // For non-strict type guards, always narrow to the typeGuardType
@@ -660,14 +655,14 @@ function narrowTypeForTruthiness(evaluator, type, isPositiveTest) {
660
655
  function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
661
656
  return evaluator.mapSubtypesExpandTypeVars(type, /* options */ undefined, (subtype) => {
662
657
  const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
663
- if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.tupleTypeArguments) {
658
+ if (!tupleType || (0, typeUtils_1.isUnboundedTupleClass)(tupleType) || !tupleType.priv.tupleTypeArguments) {
664
659
  return subtype;
665
660
  }
666
- const tupleLength = tupleType.tupleTypeArguments.length;
661
+ const tupleLength = tupleType.priv.tupleTypeArguments.length;
667
662
  if (indexValue < 0 || indexValue >= tupleLength) {
668
663
  return subtype;
669
664
  }
670
- const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.tupleTypeArguments[indexValue].type);
665
+ const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.priv.tupleTypeArguments[indexValue].type);
671
666
  if (isPositiveTest) {
672
667
  if (!evaluator.assignType(typeOfEntry, evaluator.getNoneType())) {
673
668
  return undefined;
@@ -689,6 +684,7 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
689
684
  let resultIncludesNoneSubtype = false;
690
685
  const result = evaluator.mapSubtypesExpandTypeVars(expandedType,
691
686
  /* options */ undefined, (subtype, unexpandedSubtype) => {
687
+ var _a;
692
688
  if ((0, types_1.isAnyOrUnknown)(subtype)) {
693
689
  // We need to assume that "Any" is always both None and not None,
694
690
  // so it matches regardless of whether the test is positive or negative.
@@ -697,20 +693,20 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
697
693
  // If this is a TypeVar that isn't constrained, use the unexpanded
698
694
  // TypeVar. For all other cases (including constrained TypeVars),
699
695
  // use the expanded subtype.
700
- const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
696
+ const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
701
697
  ? unexpandedSubtype
702
698
  : subtype;
703
699
  // See if it's a match for object.
704
700
  if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
705
701
  resultIncludesNoneSubtype = true;
706
702
  return isPositiveTest
707
- ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.condition)
703
+ ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition)
708
704
  : adjustedSubtype;
709
705
  }
710
706
  // See if it's a match for None.
711
707
  if ((0, typeUtils_1.isNoneInstance)(subtype) === isPositiveTest) {
712
708
  resultIncludesNoneSubtype = true;
713
- if ((0, types_1.isTypeVar)(adjustedSubtype) && adjustedSubtype.details.isSynthesizedSelf) {
709
+ if ((0, types_1.isTypeVar)(adjustedSubtype) && adjustedSubtype.shared.isSynthesizedSelf) {
714
710
  return adjustedSubtype;
715
711
  }
716
712
  return subtype;
@@ -733,6 +729,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
733
729
  return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
734
730
  });
735
731
  return evaluator.mapSubtypesExpandTypeVars(expandedType, /* options */ undefined, (subtype, unexpandedSubtype) => {
732
+ var _a;
736
733
  if ((0, types_1.isAnyOrUnknown)(subtype)) {
737
734
  // We need to assume that "Any" is always both None and not None,
738
735
  // so it matches regardless of whether the test is positive or negative.
@@ -741,12 +738,14 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
741
738
  // If this is a TypeVar that isn't constrained, use the unexpanded
742
739
  // TypeVar. For all other cases (including constrained TypeVars),
743
740
  // use the expanded subtype.
744
- const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
741
+ const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
745
742
  ? unexpandedSubtype
746
743
  : subtype;
747
744
  // See if it's a match for object.
748
745
  if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
749
- return isPositiveTest ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), subtype.condition) : adjustedSubtype;
746
+ return isPositiveTest
747
+ ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition)
748
+ : adjustedSubtype;
750
749
  }
751
750
  const isEllipsis = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['EllipsisType', 'ellipsis']);
752
751
  // See if it's a match for "...".
@@ -760,7 +759,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
760
759
  // that accepts a single class, and a more complex form that accepts a tuple
761
760
  // of classes (including arbitrarily-nested tuples). This method determines
762
761
  // which form and returns a list of classes or undefined.
763
- function getIsInstanceClassTypes(argType) {
762
+ function getIsInstanceClassTypes(evaluator, argType) {
764
763
  let foundNonClassType = false;
765
764
  const classTypeList = [];
766
765
  // Create a helper function that returns a list of class types or
@@ -768,7 +767,7 @@ function getIsInstanceClassTypes(argType) {
768
767
  const addClassTypesToList = (types) => {
769
768
  types.forEach((subtype) => {
770
769
  if ((0, types_1.isClass)(subtype)) {
771
- subtype = (0, typeUtils_1.specializeWithUnknownTypeArgs)(subtype);
770
+ subtype = (0, typeUtils_1.specializeWithUnknownTypeArgs)(subtype, evaluator.getTupleClassType());
772
771
  if ((0, types_1.isInstantiableClass)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'Callable')) {
773
772
  subtype = (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.getUnknownTypeForCallable)());
774
773
  }
@@ -781,9 +780,9 @@ function getIsInstanceClassTypes(argType) {
781
780
  classTypeList.push(subtype);
782
781
  }
783
782
  else if ((0, types_1.isFunction)(subtype) &&
784
- subtype.details.parameters.length === 2 &&
785
- subtype.details.parameters[0].category === 1 /* ParameterCategory.ArgsList */ &&
786
- subtype.details.parameters[1].category === 2 /* ParameterCategory.KwargsDict */) {
783
+ subtype.shared.parameters.length === 2 &&
784
+ subtype.shared.parameters[0].category === 1 /* ParameterCategory.ArgsList */ &&
785
+ subtype.shared.parameters[1].category === 2 /* ParameterCategory.KwargsDict */) {
787
786
  classTypeList.push(subtype);
788
787
  }
789
788
  else {
@@ -796,8 +795,8 @@ function getIsInstanceClassTypes(argType) {
796
795
  return;
797
796
  }
798
797
  if ((0, types_1.isClass)(type) && types_1.TypeBase.isInstance(type) && (0, typeUtils_1.isTupleClass)(type)) {
799
- if (type.tupleTypeArguments) {
800
- type.tupleTypeArguments.forEach((tupleEntry) => {
798
+ if (type.priv.tupleTypeArguments) {
799
+ type.priv.tupleTypeArguments.forEach((tupleEntry) => {
801
800
  addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
802
801
  });
803
802
  }
@@ -814,13 +813,13 @@ function getIsInstanceClassTypes(argType) {
814
813
  return foundNonClassType ? undefined : classTypeList;
815
814
  }
816
815
  function isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck) {
817
- if ((0, types_1.isTypeVar)(filterType) || concreteFilterType.literalValue !== undefined) {
816
+ if ((0, types_1.isTypeVar)(filterType) || concreteFilterType.priv.literalValue !== undefined) {
818
817
  return (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), varType);
819
818
  }
820
819
  // If the filter type represents all possible subclasses
821
820
  // of a type, we can't make any statements about its superclass
822
821
  // relationship with concreteVarType.
823
- if (concreteFilterType.includeSubclasses) {
822
+ if (concreteFilterType.priv.includeSubclasses) {
824
823
  return false;
825
824
  }
826
825
  if (types_1.ClassType.isDerivedFrom(concreteVarType, concreteFilterType)) {
@@ -878,6 +877,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
878
877
  // and returns the list of types the varType could be after
879
878
  // applying the filter.
880
879
  const filterClassType = (varType, concreteVarType, conditions, negativeFallbackType) => {
880
+ var _a, _b, _c;
881
881
  const filteredTypes = [];
882
882
  let foundSuperclass = false;
883
883
  let isClassRelationshipIndeterminate = false;
@@ -894,10 +894,10 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
894
894
  // If the class was implicitly specialized (e.g. because its type
895
895
  // parameters have default values), replace the default type arguments
896
896
  // with Unknown.
897
- if (concreteFilterType.typeArguments && !concreteFilterType.isTypeArgumentExplicit) {
897
+ if (concreteFilterType.priv.typeArguments && !concreteFilterType.priv.isTypeArgumentExplicit) {
898
898
  concreteFilterType = (0, typeUtils_1.specializeWithUnknownTypeArgs)(types_1.ClassType.cloneForSpecialization(concreteFilterType,
899
899
  /* typeArguments */ undefined,
900
- /* isTypeArgumentExplicit */ false));
900
+ /* isTypeArgumentExplicit */ false), evaluator.getTupleClassType());
901
901
  }
902
902
  filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filterType, concreteFilterType, isInstanceCheck);
903
903
  filterIsSubclass = isIsinstanceFilterSubclass(evaluator, concreteVarType, concreteFilterType, isInstanceCheck);
@@ -925,7 +925,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
925
925
  // If the variable type is a subclass of the isinstance filter,
926
926
  // we haven't learned anything new about the variable type.
927
927
  // If the varType is a Self or type[Self], retain the unnarrowedType.
928
- if ((0, types_1.isTypeVar)(varType) && varType.details.isSynthesizedSelf) {
928
+ if ((0, types_1.isTypeVar)(varType) && varType.shared.isSynthesizedSelf) {
929
929
  filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, conditions));
930
930
  }
931
931
  else {
@@ -947,17 +947,21 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
947
947
  // be passed to isinstance or issubclass.
948
948
  if ((0, types_1.isClass)(filterType)) {
949
949
  if (types_1.ClassType.isSpecialBuiltIn(filterType) ||
950
- filterType.details.typeParameters.length > 0) {
951
- if (!filterType.typeArguments ||
952
- !filterType.isTypeArgumentExplicit ||
950
+ filterType.shared.typeParameters.length > 0) {
951
+ if (!filterType.priv.typeArguments ||
952
+ !filterType.priv.isTypeArgumentExplicit ||
953
953
  !types_1.ClassType.isSameGenericClass(concreteVarType, filterType)) {
954
954
  const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
955
955
  const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType,
956
956
  /* typeArguments */ undefined,
957
957
  /* isTypeArgumentExplicit */ false);
958
- if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext,
958
+ if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, unspecializedFilterType, concreteVarType, typeVarContext,
959
959
  /* liveTypeVarScopes */ undefined, errorNode.start)) {
960
- specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, { unknownIfNotFound: true, useUnknownOverDefault: true });
960
+ specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, {
961
+ unknownIfNotFound: true,
962
+ useUnknownOverDefault: true,
963
+ tupleClassType: evaluator.getTupleClassType(),
964
+ });
961
965
  }
962
966
  }
963
967
  }
@@ -973,34 +977,34 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
973
977
  // be a mix-in class used with the other. In this case, we'll
974
978
  // synthesize a new class type that represents an intersection of
975
979
  // the two types.
976
- const className = `<subclass of ${concreteVarType.details.name} and ${concreteFilterType.details.name}>`;
980
+ const className = `<subclass of ${concreteVarType.shared.name} and ${concreteFilterType.shared.name}>`;
977
981
  const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
978
982
  // The effective metaclass of the intersection is the narrower of the two metaclasses.
979
- let effectiveMetaclass = concreteVarType.details.effectiveMetaclass;
980
- if (concreteFilterType.details.effectiveMetaclass) {
983
+ let effectiveMetaclass = concreteVarType.shared.effectiveMetaclass;
984
+ if (concreteFilterType.shared.effectiveMetaclass) {
981
985
  if (!effectiveMetaclass ||
982
- evaluator.assignType(effectiveMetaclass, concreteFilterType.details.effectiveMetaclass)) {
983
- effectiveMetaclass = concreteFilterType.details.effectiveMetaclass;
986
+ evaluator.assignType(effectiveMetaclass, concreteFilterType.shared.effectiveMetaclass)) {
987
+ effectiveMetaclass = concreteFilterType.shared.effectiveMetaclass;
984
988
  }
985
989
  }
986
990
  let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode),
987
- /* declaredMetaclass */ undefined, effectiveMetaclass, concreteVarType.details.docString);
988
- newClassType.details.baseClasses = [
991
+ /* declaredMetaclass */ undefined, effectiveMetaclass, concreteVarType.shared.docString);
992
+ newClassType.shared.baseClasses = [
989
993
  types_1.ClassType.cloneAsInstantiable(concreteVarType),
990
994
  concreteFilterType,
991
995
  ];
992
996
  (0, typeUtils_1.computeMroLinearization)(newClassType);
993
- newClassType = (0, typeUtils_1.addConditionToType)(newClassType, concreteFilterType.condition);
997
+ newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = concreteFilterType.props) === null || _a === void 0 ? void 0 : _a.condition);
994
998
  if ((0, types_1.isTypeVar)(varType) &&
995
- !varType.details.isParamSpec &&
996
- varType.details.constraints.length === 0) {
999
+ !varType.shared.isParamSpec &&
1000
+ varType.shared.constraints.length === 0) {
997
1001
  newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [
998
1002
  { typeVar: varType, constraintIndex: 0 },
999
1003
  ]);
1000
1004
  }
1001
1005
  let newClassInstanceType = types_1.ClassType.cloneAsInstance(newClassType);
1002
- if (concreteVarType.condition) {
1003
- newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, concreteVarType.condition);
1006
+ if ((_b = concreteVarType.props) === null || _b === void 0 ? void 0 : _b.condition) {
1007
+ newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, (_c = concreteVarType.props) === null || _c === void 0 ? void 0 : _c.condition);
1004
1008
  }
1005
1009
  // If this is a issubclass check, we do a double conversion from instantiable
1006
1010
  // to instance back to instantiable to make sure that the includeSubclasses flag
@@ -1111,14 +1115,14 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
1111
1115
  for (const filterType of filterTypes) {
1112
1116
  const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
1113
1117
  if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
1114
- const filterMetaclass = concreteFilterType.details.effectiveMetaclass;
1118
+ const filterMetaclass = concreteFilterType.shared.effectiveMetaclass;
1115
1119
  if (filterMetaclass && (0, types_1.isInstantiableClass)(filterMetaclass)) {
1116
1120
  let isMetaclassOverlap = evaluator.assignType(metaclassType, types_1.ClassType.cloneAsInstance(filterMetaclass));
1117
1121
  // Handle the special case where the metaclass for the filter is type.
1118
1122
  // This will normally be treated as type[Any], which is compatible with
1119
1123
  // any metaclass, but we specifically want to treat type as the class
1120
1124
  // type[object] in this case.
1121
- if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.isTypeArgumentExplicit) {
1125
+ if (types_1.ClassType.isBuiltIn(filterMetaclass, 'type') && !filterMetaclass.priv.isTypeArgumentExplicit) {
1122
1126
  if (!types_1.ClassType.isBuiltIn(metaclassType, 'type')) {
1123
1127
  isMetaclassOverlap = false;
1124
1128
  }
@@ -1128,7 +1132,8 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
1128
1132
  filteredTypes.push(filterType);
1129
1133
  foundPositiveMatch = true;
1130
1134
  }
1131
- else if (!(0, types_1.isTypeSame)(metaclassType, filterMetaclass) || filterMetaclass.includeSubclasses) {
1135
+ else if (!(0, types_1.isTypeSame)(metaclassType, filterMetaclass) ||
1136
+ filterMetaclass.priv.includeSubclasses) {
1132
1137
  filteredTypes.push(metaclassType);
1133
1138
  isMatchIndeterminate = true;
1134
1139
  }
@@ -1302,23 +1307,23 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
1302
1307
  // If it's not a tuple, we can't narrow it.
1303
1308
  if (!(0, types_1.isClassInstance)(concreteSubtype) ||
1304
1309
  !(0, typeUtils_1.isTupleClass)(concreteSubtype) ||
1305
- !concreteSubtype.tupleTypeArguments) {
1310
+ !concreteSubtype.priv.tupleTypeArguments) {
1306
1311
  return subtype;
1307
1312
  }
1308
1313
  // If the tuple contains a variadic TypeVar, we can't narrow it.
1309
- if (concreteSubtype.tupleTypeArguments.some((typeArg) => (0, types_1.isUnpackedVariadicTypeVar)(typeArg.type))) {
1314
+ if (concreteSubtype.priv.tupleTypeArguments.some((typeArg) => (0, types_1.isUnpackedVariadicTypeVar)(typeArg.type))) {
1310
1315
  return subtype;
1311
1316
  }
1312
1317
  // If the tuple contains no unbounded elements, then we know its length exactly.
1313
- if (!concreteSubtype.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
1318
+ if (!concreteSubtype.priv.tupleTypeArguments.some((typeArg) => typeArg.isUnbounded)) {
1314
1319
  const tupleLengthMatches = isLessThanCheck
1315
- ? concreteSubtype.tupleTypeArguments.length < lengthValue
1316
- : concreteSubtype.tupleTypeArguments.length === lengthValue;
1320
+ ? concreteSubtype.priv.tupleTypeArguments.length < lengthValue
1321
+ : concreteSubtype.priv.tupleTypeArguments.length === lengthValue;
1317
1322
  return tupleLengthMatches === isPositiveTest ? subtype : undefined;
1318
1323
  }
1319
1324
  // The tuple contains a "...". We'll expand this into as many elements as
1320
1325
  // necessary to match the lengthValue.
1321
- const elementsToAdd = lengthValue - concreteSubtype.tupleTypeArguments.length + 1;
1326
+ const elementsToAdd = lengthValue - concreteSubtype.priv.tupleTypeArguments.length + 1;
1322
1327
  if (!isLessThanCheck) {
1323
1328
  // If the specified length is smaller than the minimum length of this tuple,
1324
1329
  // we can rule it out for a positive test and rule it in for a negative test.
@@ -1331,7 +1336,7 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
1331
1336
  return expandUnboundedTupleElement(concreteSubtype, elementsToAdd, /* keepUnbounded */ false);
1332
1337
  }
1333
1338
  // If this is a tuple related to an "*args: P.args" parameter, don't expand it.
1334
- if ((0, types_1.isParamSpec)(subtype) && subtype.paramSpecAccess) {
1339
+ if ((0, types_1.isParamSpec)(subtype) && subtype.priv.paramSpecAccess) {
1335
1340
  return subtype;
1336
1341
  }
1337
1342
  // Place an upper limit on the number of union subtypes we
@@ -1358,7 +1363,7 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
1358
1363
  // to) the unbounded element.
1359
1364
  function expandUnboundedTupleElement(tupleType, elementsToAdd, keepUnbounded) {
1360
1365
  const tupleTypeArgs = [];
1361
- tupleType.tupleTypeArguments.forEach((typeArg) => {
1366
+ tupleType.priv.tupleTypeArguments.forEach((typeArg) => {
1362
1367
  if (!typeArg.isUnbounded) {
1363
1368
  tupleTypeArgs.push(typeArg);
1364
1369
  }
@@ -1386,13 +1391,13 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
1386
1391
  // with a known length.
1387
1392
  if (!(0, types_1.isClassInstance)(containerType) ||
1388
1393
  !types_1.ClassType.isBuiltIn(containerType, 'tuple') ||
1389
- !containerType.tupleTypeArguments) {
1394
+ !containerType.priv.tupleTypeArguments) {
1390
1395
  return referenceType;
1391
1396
  }
1392
1397
  // Determine which tuple types can be eliminated. Only "None" and
1393
1398
  // literal types can be handled here.
1394
1399
  const typesToEliminate = [];
1395
- containerType.tupleTypeArguments.forEach((tupleEntry) => {
1400
+ containerType.priv.tupleTypeArguments.forEach((tupleEntry) => {
1396
1401
  if (!tupleEntry.isUnbounded) {
1397
1402
  if ((0, typeUtils_1.isNoneInstance)(tupleEntry.type)) {
1398
1403
  typesToEliminate.push(tupleEntry.type);
@@ -1407,7 +1412,7 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
1407
1412
  }
1408
1413
  return (0, typeUtils_1.mapSubtypes)(referenceType, (referenceSubtype) => {
1409
1414
  referenceSubtype = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
1410
- if ((0, types_1.isClassInstance)(referenceSubtype) && referenceSubtype.literalValue === undefined) {
1415
+ if ((0, types_1.isClassInstance)(referenceSubtype) && referenceSubtype.priv.literalValue === undefined) {
1411
1416
  // If we're able to enumerate all possible literal values
1412
1417
  // (for bool or enum), we can eliminate all others in a negative test.
1413
1418
  const allLiteralTypes = enumerateLiteralsForType(evaluator, referenceSubtype);
@@ -1427,12 +1432,12 @@ function getElementTypeForContainerNarrowing(containerType) {
1427
1432
  if (!(0, types_1.isClassInstance)(containerType) || !types_1.ClassType.isBuiltIn(containerType, supportedContainers)) {
1428
1433
  return undefined;
1429
1434
  }
1430
- if (!containerType.typeArguments || containerType.typeArguments.length < 1) {
1435
+ if (!containerType.priv.typeArguments || containerType.priv.typeArguments.length < 1) {
1431
1436
  return undefined;
1432
1437
  }
1433
- let elementType = containerType.typeArguments[0];
1434
- if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.tupleTypeArguments) {
1435
- elementType = (0, types_1.combineTypes)(containerType.tupleTypeArguments.map((t) => t.type));
1438
+ let elementType = containerType.priv.typeArguments[0];
1439
+ if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.priv.tupleTypeArguments) {
1440
+ elementType = (0, types_1.combineTypes)(containerType.priv.tupleTypeArguments.map((t) => t.type));
1436
1441
  }
1437
1442
  return elementType;
1438
1443
  }
@@ -1507,7 +1512,7 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
1507
1512
  }
1508
1513
  if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
1509
1514
  const entries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
1510
- const tdEntry = (_a = entries.knownItems.get(literalKey.literalValue)) !== null && _a !== void 0 ? _a : entries.extraItems;
1515
+ const tdEntry = (_a = entries.knownItems.get(literalKey.priv.literalValue)) !== null && _a !== void 0 ? _a : entries.extraItems;
1511
1516
  if (isPositiveTest) {
1512
1517
  if (!tdEntry) {
1513
1518
  return undefined;
@@ -1517,9 +1522,9 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
1517
1522
  if (tdEntry.isRequired || tdEntry.isProvided) {
1518
1523
  return subtype;
1519
1524
  }
1520
- const newNarrowedEntriesMap = new Map((_b = subtype.typedDictNarrowedEntries) !== null && _b !== void 0 ? _b : []);
1525
+ const newNarrowedEntriesMap = new Map((_b = subtype.priv.typedDictNarrowedEntries) !== null && _b !== void 0 ? _b : []);
1521
1526
  // Add the new entry.
1522
- newNarrowedEntriesMap.set(literalKey.literalValue, {
1527
+ newNarrowedEntriesMap.set(literalKey.priv.literalValue, {
1523
1528
  valueType: tdEntry.valueType,
1524
1529
  isReadOnly: tdEntry.isReadOnly,
1525
1530
  isRequired: false,
@@ -1544,7 +1549,7 @@ function narrowTypeForDiscriminatedDictEntryComparison(evaluator, referenceType,
1544
1549
  const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
1545
1550
  if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
1546
1551
  const symbolMap = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype);
1547
- const tdEntry = symbolMap.knownItems.get(indexLiteralType.literalValue);
1552
+ const tdEntry = symbolMap.knownItems.get(indexLiteralType.priv.literalValue);
1548
1553
  if (tdEntry && (0, typeUtils_1.isLiteralTypeOrUnion)(tdEntry.valueType)) {
1549
1554
  if (isPositiveTest) {
1550
1555
  let foundMatch = false;
@@ -1579,11 +1584,13 @@ function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, ind
1579
1584
  if ((0, types_1.isClassInstance)(subtype) &&
1580
1585
  types_1.ClassType.isTupleClass(subtype) &&
1581
1586
  !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
1582
- typeof indexLiteralType.literalValue === 'number' &&
1587
+ typeof indexLiteralType.priv.literalValue === 'number' &&
1583
1588
  (0, types_1.isClassInstance)(literalType)) {
1584
- const indexValue = indexLiteralType.literalValue;
1585
- if (subtype.tupleTypeArguments && indexValue >= 0 && indexValue < subtype.tupleTypeArguments.length) {
1586
- const tupleEntryType = (_a = subtype.tupleTypeArguments[indexValue]) === null || _a === void 0 ? void 0 : _a.type;
1589
+ const indexValue = indexLiteralType.priv.literalValue;
1590
+ if (subtype.priv.tupleTypeArguments &&
1591
+ indexValue >= 0 &&
1592
+ indexValue < subtype.priv.tupleTypeArguments.length) {
1593
+ const tupleEntryType = (_a = subtype.priv.tupleTypeArguments[indexValue]) === null || _a === void 0 ? void 0 : _a.type;
1587
1594
  if (tupleEntryType && (0, typeUtils_1.isLiteralTypeOrUnion)(tupleEntryType)) {
1588
1595
  if (isPositiveTest) {
1589
1596
  return evaluator.assignType(tupleEntryType, literalType) ? subtype : undefined;
@@ -1618,8 +1625,8 @@ function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceTy
1618
1625
  // Handle the case where the field is a property
1619
1626
  // that has a declared literal return type for its getter.
1620
1627
  if ((0, types_1.isClassInstance)(subtype) && (0, types_1.isClassInstance)(memberType) && (0, typeUtils_1.isProperty)(memberType)) {
1621
- const getterType = (_a = memberType.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType;
1622
- if (getterType && getterType.details.declaredReturnType) {
1628
+ const getterType = (_a = memberType.priv.fgetInfo) === null || _a === void 0 ? void 0 : _a.methodType;
1629
+ if (getterType && getterType.shared.declaredReturnType) {
1623
1630
  const getterReturnType = types_1.FunctionType.getEffectiveReturnType(getterType);
1624
1631
  if (getterReturnType) {
1625
1632
  memberType = getterReturnType;
@@ -1681,6 +1688,7 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
1681
1688
  function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
1682
1689
  return evaluator.mapSubtypesExpandTypeVars(type,
1683
1690
  /* options */ undefined, (subtype, unexpandedSubtype) => {
1691
+ var _a;
1684
1692
  if ((0, types_1.isClassInstance)(subtype)) {
1685
1693
  const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
1686
1694
  if (isPositiveTest) {
@@ -1688,13 +1696,13 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
1688
1696
  if (types_1.ClassType.isSameGenericClass(subtype, classType)) {
1689
1697
  return subtype;
1690
1698
  }
1691
- return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), subtype.condition);
1699
+ return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition);
1692
1700
  }
1693
- if (!classType.includeSubclasses) {
1701
+ if (!classType.priv.includeSubclasses) {
1694
1702
  return undefined;
1695
1703
  }
1696
1704
  }
1697
- else if (!classType.includeSubclasses) {
1705
+ else if (!classType.priv.includeSubclasses) {
1698
1706
  // If the class if marked final and it matches, then
1699
1707
  // we can eliminate it in the negative case.
1700
1708
  if (matches && types_1.ClassType.isFinal(subtype)) {
@@ -1728,8 +1736,8 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
1728
1736
  types_1.TypeBase.isInstance(subtype) &&
1729
1737
  types_1.ClassType.isBuiltIn(concreteSubtype, 'type')) {
1730
1738
  concreteSubtype =
1731
- concreteSubtype.typeArguments && concreteSubtype.typeArguments.length > 0
1732
- ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.typeArguments[0])
1739
+ concreteSubtype.priv.typeArguments && concreteSubtype.priv.typeArguments.length > 0
1740
+ ? (0, typeUtils_1.convertToInstantiable)(concreteSubtype.priv.typeArguments[0])
1733
1741
  : types_1.UnknownType.create();
1734
1742
  }
1735
1743
  if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
@@ -1741,11 +1749,11 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
1741
1749
  }
1742
1750
  const isSuperType = isIsinstanceFilterSuperclass(evaluator, subtype, concreteSubtype, classType, classType,
1743
1751
  /* isInstanceCheck */ false);
1744
- if (!classType.includeSubclasses) {
1752
+ if (!classType.priv.includeSubclasses) {
1745
1753
  // Handle the case where the LHS and RHS operands are specific
1746
1754
  // classes, as opposed to types that represent classes and their
1747
1755
  // subclasses.
1748
- if (!concreteSubtype.includeSubclasses) {
1756
+ if (!concreteSubtype.priv.includeSubclasses) {
1749
1757
  return types_1.ClassType.isSameGenericClass(concreteSubtype, classType) ? classType : undefined;
1750
1758
  }
1751
1759
  const isSubType = isIsinstanceFilterSubclass(evaluator, concreteSubtype, classType,
@@ -1786,7 +1794,7 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
1786
1794
  return subtype;
1787
1795
  }
1788
1796
  else if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
1789
- if (subtype.literalValue !== undefined) {
1797
+ if (subtype.priv.literalValue !== undefined) {
1790
1798
  const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
1791
1799
  if ((literalValueMatches && !isPositiveTest) || (!literalValueMatches && isPositiveTest)) {
1792
1800
  return undefined;
@@ -1825,7 +1833,7 @@ function enumerateLiteralsForType(evaluator, type) {
1825
1833
  if (types_1.ClassType.isEnumClass(type)) {
1826
1834
  // Enum expansion doesn't apply to enum classes that derive
1827
1835
  // from enum.Flag.
1828
- if (type.details.baseClasses.some((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'Flag'))) {
1836
+ if (type.shared.baseClasses.some((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'Flag'))) {
1829
1837
  return undefined;
1830
1838
  }
1831
1839
  // Enumerate all of the values in this enumeration.
@@ -1838,7 +1846,7 @@ function enumerateLiteralsForType(evaluator, type) {
1838
1846
  symbolType = (_a = (0, enums_1.transformTypeForEnumMember)(evaluator, type, name)) !== null && _a !== void 0 ? _a : symbolType;
1839
1847
  if ((0, types_1.isClassInstance)(symbolType) &&
1840
1848
  types_1.ClassType.isSameGenericClass(type, symbolType) &&
1841
- symbolType.literalValue !== undefined) {
1849
+ symbolType.priv.literalValue !== undefined) {
1842
1850
  enumList.push(symbolType);
1843
1851
  }
1844
1852
  }
@@ -1854,6 +1862,7 @@ exports.enumerateLiteralsForType = enumerateLiteralsForType;
1854
1862
  // it's not callable.
1855
1863
  function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allowIntersections) {
1856
1864
  return evaluator.mapSubtypesExpandTypeVars(type, /* options */ undefined, (subtype) => {
1865
+ var _a;
1857
1866
  switch (subtype.category) {
1858
1867
  case 4 /* TypeCategory.Function */:
1859
1868
  case 5 /* TypeCategory.OverloadedFunction */: {
@@ -1879,24 +1888,19 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
1879
1888
  // The type appears to not be callable. It's possible that the
1880
1889
  // two type is a subclass that is callable. We'll synthesize a
1881
1890
  // new intersection type.
1882
- const className = `<callable subtype of ${subtype.details.name}>`;
1891
+ const className = `<callable subtype of ${subtype.shared.name}>`;
1883
1892
  const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
1884
1893
  let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode),
1885
- /* declaredMetaclass */ undefined, subtype.details.effectiveMetaclass, subtype.details.docString);
1886
- newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
1894
+ /* declaredMetaclass */ undefined, subtype.shared.effectiveMetaclass, subtype.shared.docString);
1895
+ newClassType.shared.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
1887
1896
  (0, typeUtils_1.computeMroLinearization)(newClassType);
1888
- newClassType = (0, typeUtils_1.addConditionToType)(newClassType, subtype.condition);
1897
+ newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition);
1889
1898
  // Add a __call__ method to the new class.
1890
1899
  const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
1891
- const selfParam = {
1892
- category: 0 /* ParameterCategory.Simple */,
1893
- name: 'self',
1894
- type: types_1.ClassType.cloneAsInstance(newClassType),
1895
- hasDeclaredType: true,
1896
- };
1900
+ const selfParam = types_1.FunctionParam.create(0 /* ParameterCategory.Simple */, types_1.ClassType.cloneAsInstance(newClassType), types_1.FunctionParamFlags.TypeDeclared, 'self');
1897
1901
  types_1.FunctionType.addParameter(callMethod, selfParam);
1898
1902
  types_1.FunctionType.addDefaultParameters(callMethod);
1899
- callMethod.details.declaredReturnType = types_1.UnknownType.create();
1903
+ callMethod.shared.declaredReturnType = types_1.UnknownType.create();
1900
1904
  types_1.ClassType.getSymbolTable(newClassType).set('__call__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, callMethod));
1901
1905
  return types_1.ClassType.cloneAsInstance(newClassType);
1902
1906
  }