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

package/dist/languageService/completionProvider.js

@@ -37,6 +37,7 @@ const vscode_languageserver_1 = require("vscode-languageserver");
 const AnalyzerNodeInfo = __importStar(require("../analyzer/analyzerNodeInfo"));
 const declaration_1 = require("../analyzer/declaration");
 const declarationUtils_1 = require("../analyzer/declarationUtils");
+const enums_1 = require("../analyzer/enums");
 const importResolver_1 = require("../analyzer/importResolver");
 const parameterUtils_1 = require("../analyzer/parameterUtils");
 const ParseTreeUtils = __importStar(require("../analyzer/parseTreeUtils"));
@@ -57,6 +58,7 @@ const debug_1 = require("../common/debug");
 const lspUtils_1 = require("../common/lspUtils");
 const positionUtils_1 = require("../common/positionUtils");
 const pythonVersion_1 = require("../common/pythonVersion");
+require("../common/serviceProviderExtensions");
 const StringUtils = __importStar(require("../common/stringUtils"));
 const textRange_1 = require("../common/textRange");
 const uri_1 = require("../common/uri/uri");
@@ -67,8 +69,6 @@ const autoImporter_1 = require("./autoImporter");
 const completionProviderUtils_1 = require("./completionProviderUtils");
 const documentSymbolCollector_1 = require("./documentSymbolCollector");
 const tooltipUtils_1 = require("./tooltipUtils");
-require("../common/serviceProviderExtensions");
-const enums_1 = require("../analyzer/enums");
 var Keywords;
 (function (Keywords) {
     const base = [
@@ -271,8 +271,8 @@ class CompletionProvider {
             return undefined;
         }
         const symbolTable = new Map();
-        for (let i = 1; i < classResults.classType.details.mro.length; i++) {
-            const mroClass = classResults.classType.details.mro[i];
+        for (let i = 1; i < classResults.classType.shared.mro.length; i++) {
+            const mroClass = classResults.classType.shared.mro[i];
             if ((0, types_1.isInstantiableClass)(mroClass)) {
                 (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
             }
@@ -284,7 +284,7 @@ class CompletionProvider {
             var _a;
             let decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(symbol);
             if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                if (StringUtils.isPatternInSymbol(partialName.value, name)) {
+                if (StringUtils.isPatternInSymbol(partialName.d.value, name)) {
                     const declaredType = (_a = this.evaluator.getTypeForDeclaration(decl)) === null || _a === void 0 ? void 0 : _a.type;
                     if (!declaredType) {
                         return;
@@ -320,11 +320,11 @@ class CompletionProvider {
                         text = `${methodSignature}: ...`;
                     }
                     else {
-                        const methodBody = this.printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl, decl.node.isAsync);
+                        const methodBody = this.printOverriddenMethodBody(classResults.classType, isDeclaredStaticMethod, isProperty, decl, decl.node.d.isAsync);
                         text = `${methodSignature}:\n${methodBody}`;
                     }
                     const textEdit = this.createReplaceEdits(priorWord, partialName, text);
-                    this.addSymbol(name, symbol, partialName.value, completionMap, {
+                    this.addSymbol(name, symbol, partialName.d.value, completionMap, {
                         // method signature already contains ()
                         funcParensDisabled: true,
                         edits: {
@@ -339,40 +339,42 @@ class CompletionProvider {
     }
     printOverriddenMethodBody(classType, isStaticMethod, isProperty, decl, insertAwait) {
         let sb = this.parseResults.tokenizerOutput.predominantTabSequence;
-        if (classType.details.baseClasses.length === 1 &&
-            (0, types_1.isClass)(classType.details.baseClasses[0]) &&
-            classType.details.baseClasses[0].details.fullName === 'builtins.object') {
+        if (classType.shared.baseClasses.length === 1 &&
+            (0, types_1.isClass)(classType.shared.baseClasses[0]) &&
+            classType.shared.baseClasses[0].shared.fullName === 'builtins.object') {
             sb += this.options.snippet ? '${0:pass}' : 'pass';
             return sb;
         }
-        if (decl.node.parameters.length === 0) {
+        if (decl.node.d.params.length === 0) {
             sb += this.options.snippet ? '${0:pass}' : 'pass';
             return sb;
         }
-        const parameters = getParameters(isStaticMethod ? decl.node.parameters : decl.node.parameters.slice(1));
-        if (decl.node.name.value !== '__init__') {
+        const parameters = getParameters(isStaticMethod ? decl.node.d.params : decl.node.d.params.slice(1));
+        if (decl.node.d.name.d.value !== '__init__') {
             sb += 'return ';
         }
         if (insertAwait) {
             sb += 'await ';
         }
         if (isProperty) {
-            return sb + `super().${decl.node.name.value}`;
+            return sb + `super().${decl.node.d.name.d.value}`;
         }
-        return sb + `super().${decl.node.name.value}(${parameters.map(convertToString).join(', ')})`;
+        return sb + `super().${decl.node.d.name.d.value}(${parameters.map(convertToString).join(', ')})`;
         function getParameters(parameters) {
             const results = [];
             let sawKeywordOnlySeparator = false;
             for (const parameter of parameters) {
-                if (parameter.name) {
+                if (parameter.d.name) {
                     results.push([
                         parameter,
-                        parameter.category === 0 /* ParameterCategory.Simple */ && !!parameter.name && sawKeywordOnlySeparator,
+                        parameter.d.category === 0 /* ParameterCategory.Simple */ &&
+                            !!parameter.d.name &&
+                            sawKeywordOnlySeparator,
                     ]);
                 }
                 // All simple parameters after a `*` or `*args` parameter
                 // are considered keyword only.
-                if (parameter.category === 1 /* ParameterCategory.ArgsList */) {
+                if (parameter.d.category === 1 /* ParameterCategory.ArgsList */) {
                     sawKeywordOnlySeparator = true;
                 }
             }
@@ -380,11 +382,11 @@ class CompletionProvider {
         }
         function convertToString(parameter) {
             var _a;
-            const name = (_a = parameter[0].name) === null || _a === void 0 ? void 0 : _a.value;
-            if (parameter[0].category === 1 /* ParameterCategory.ArgsList */) {
+            const name = (_a = parameter[0].d.name) === null || _a === void 0 ? void 0 : _a.d.value;
+            if (parameter[0].d.category === 1 /* ParameterCategory.ArgsList */) {
                 return `*${name}`;
             }
-            if (parameter[0].category === 2 /* ParameterCategory.KwargsDict */) {
+            if (parameter[0].d.category === 2 /* ParameterCategory.KwargsDict */) {
                 return `**${name}`;
             }
             return parameter[1] ? `${name}=${name}` : name;
@@ -392,7 +394,7 @@ class CompletionProvider {
     }
     createReplaceEdits(priorWord, node, text) {
         const replaceOrInsertEndChar = (node === null || node === void 0 ? void 0 : node.nodeType) === 38 /* ParseNodeType.Name */
-            ? this.position.character - priorWord.length + node.value.length
+            ? this.position.character - priorWord.length + node.d.value.length
             : this.position.character;
         const range = {
             start: { line: this.position.line, character: this.position.character - priorWord.length },
@@ -499,8 +501,8 @@ class CompletionProvider {
         leftType = this.evaluator.makeTopLevelTypeVarsConcrete(leftType);
         // If this is an unknown type with a "possible type" associated with
         // it, use the possible type.
-        if ((0, types_1.isUnknown)(leftType) && leftType.possibleType) {
-            leftType = this.evaluator.makeTopLevelTypeVarsConcrete(leftType.possibleType);
+        if ((0, types_1.isUnknown)(leftType) && leftType.priv.possibleType) {
+            leftType = this.evaluator.makeTopLevelTypeVarsConcrete(leftType.priv.possibleType);
         }
         (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
             subtype = this.evaluator.makeTopLevelTypeVarsConcrete(subtype);
@@ -752,7 +754,7 @@ class CompletionProvider {
         else if (node) {
             const fStringContainer = ParseTreeUtils.getParentNodeOfType(node, 30 /* ParseNodeType.FormatString */);
             if (fStringContainer) {
-                this._stringLiteralContainer = fStringContainer.token;
+                this._stringLiteralContainer = fStringContainer.d.token;
             }
         }
         // See if we can get to a "better" node by backing up a few columns.
@@ -828,7 +830,7 @@ class CompletionProvider {
                 return this._getExpressionErrorCompletions(curNode, offset, priorWord, priorText, postText);
             }
             if (curNode.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-                return this.getMemberAccessCompletions(curNode.leftExpression, priorWord);
+                return this.getMemberAccessCompletions(curNode.d.leftExpr, priorWord);
             }
             if (curNode.nodeType === 18 /* ParseNodeType.Dictionary */) {
                 const completionMap = new CompletionMap();
@@ -841,7 +843,7 @@ class CompletionProvider {
             if (dictionaryEntry) {
                 if (((_b = dictionaryEntry.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 18 /* ParseNodeType.Dictionary */) {
                     const dictionaryNode = dictionaryEntry.parent;
-                    if (dictionaryNode.trailingCommaToken && dictionaryNode.trailingCommaToken.start < offset) {
+                    if (dictionaryNode.d.trailingCommaToken && dictionaryNode.d.trailingCommaToken.start < offset) {
                         const completionMap = new CompletionMap();
                         if (this._tryAddTypedDictKeysFromDictionary(dictionaryNode, 
                         /* stringNode */ undefined, priorWord, priorText, postText, completionMap)) {
@@ -872,18 +874,18 @@ class CompletionProvider {
             if (curNode.nodeType === 50 /* ParseNodeType.Suite */) {
                 if (curNode.parent &&
                     curNode.parent.nodeType === 28 /* ParseNodeType.Except */ &&
-                    !curNode.parent.name &&
-                    curNode.parent.typeExpression &&
-                    textRange_1.TextRange.getEnd(curNode.parent.typeExpression) < offset &&
-                    offset <= curNode.parent.exceptSuite.start) {
+                    !curNode.parent.d.name &&
+                    curNode.parent.d.typeExpr &&
+                    textRange_1.TextRange.getEnd(curNode.parent.d.typeExpr) < offset &&
+                    offset <= curNode.parent.d.exceptSuite.start) {
                     // except Exception as [<empty>]
                     return undefined;
                 }
                 if (curNode.parent &&
                     curNode.parent.nodeType === 10 /* ParseNodeType.Class */ &&
-                    (!curNode.parent.name || !curNode.parent.name.value) &&
-                    curNode.parent.arguments.length === 0 &&
-                    offset <= curNode.parent.suite.start) {
+                    (!curNode.parent.d.name || !curNode.parent.d.name.d.value) &&
+                    curNode.parent.d.arguments.length === 0 &&
+                    offset <= curNode.parent.d.suite.start) {
                     // class [<empty>]
                     return undefined;
                 }
@@ -914,7 +916,7 @@ class CompletionProvider {
         if (!curNode.parent) {
             return false;
         }
-        if (curNode.parent.nodeType === 24 /* ParseNodeType.ImportAs */ && curNode.parent.alias === curNode) {
+        if (curNode.parent.nodeType === 24 /* ParseNodeType.ImportAs */ && curNode.parent.d.alias === curNode) {
             // Are we within a "import Y as [Z]"?
             return undefined;
         }
@@ -922,7 +924,7 @@ class CompletionProvider {
             // Are we within a "import Y as [<empty>]"?
             if (curNode.parent.parent &&
                 curNode.parent.parent.nodeType === 24 /* ParseNodeType.ImportAs */ &&
-                !curNode.parent.parent.alias &&
+                !curNode.parent.parent.d.alias &&
                 textRange_1.TextRange.getEnd(curNode.parent.parent) < offset) {
                 return undefined;
             }
@@ -931,55 +933,55 @@ class CompletionProvider {
             return this._getImportModuleCompletions(curNode.parent);
         }
         if (curNode.parent.nodeType === 26 /* ParseNodeType.ImportFromAs */) {
-            if (curNode.parent.alias === curNode) {
+            if (curNode.parent.d.alias === curNode) {
                 // Are we within a "from X import Y as [Z]"?
                 return undefined;
             }
             const parentNode = curNode.parent.parent;
             if (parentNode && parentNode.nodeType === 25 /* ParseNodeType.ImportFrom */) {
                 // Are we within a "from X import Y as [<empty>]"?
-                if (!curNode.parent.alias && textRange_1.TextRange.getEnd(curNode.parent) < offset) {
+                if (!curNode.parent.d.alias && textRange_1.TextRange.getEnd(curNode.parent) < offset) {
                     return undefined;
                 }
-                if (curNode.parent.name === curNode) {
+                if (curNode.parent.d.name === curNode) {
                     return this._getImportFromCompletions(parentNode, offset, priorWord);
                 }
                 return this._getImportFromCompletions(parentNode, offset, '');
             }
             return false;
         }
-        if (curNode.parent.nodeType === 35 /* ParseNodeType.MemberAccess */ && curNode === curNode.parent.memberName) {
-            return this.getMemberAccessCompletions(curNode.parent.leftExpression, priorWord);
+        if (curNode.parent.nodeType === 35 /* ParseNodeType.MemberAccess */ && curNode === curNode.parent.d.member) {
+            return this.getMemberAccessCompletions(curNode.parent.d.leftExpr, priorWord);
         }
-        if (curNode.parent.nodeType === 28 /* ParseNodeType.Except */ && curNode === curNode.parent.name) {
+        if (curNode.parent.nodeType === 28 /* ParseNodeType.Except */ && curNode === curNode.parent.d.name) {
             return undefined;
         }
-        if (curNode.parent.nodeType === 31 /* ParseNodeType.Function */ && curNode === curNode.parent.name) {
-            if ((_a = curNode.parent.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
+        if (curNode.parent.nodeType === 31 /* ParseNodeType.Function */ && curNode === curNode.parent.d.name) {
+            if ((_a = curNode.parent.d.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
                 return this._getMethodOverloadsCompletions(priorWord, curNode);
             }
             return undefined;
         }
-        if (curNode.parent.nodeType === 41 /* ParseNodeType.Parameter */ && curNode === curNode.parent.name) {
+        if (curNode.parent.nodeType === 41 /* ParseNodeType.Parameter */ && curNode === curNode.parent.d.name) {
             return undefined;
         }
-        if (curNode.parent.nodeType === 10 /* ParseNodeType.Class */ && curNode === curNode.parent.name) {
+        if (curNode.parent.nodeType === 10 /* ParseNodeType.Class */ && curNode === curNode.parent.d.name) {
             return undefined;
         }
         if (curNode.parent.nodeType === 29 /* ParseNodeType.For */ &&
-            textRange_1.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
+            textRange_1.TextRange.contains(curNode.parent.d.targetExpr, curNode.start)) {
             return undefined;
         }
         if (curNode.parent.nodeType === 12 /* ParseNodeType.ComprehensionFor */ &&
-            textRange_1.TextRange.contains(curNode.parent.targetExpression, curNode.start)) {
+            textRange_1.TextRange.contains(curNode.parent.d.targetExpr, curNode.start)) {
             return undefined;
         }
         // For assignments that implicitly declare variables, remove itself (var decl) from completion.
         if (curNode.parent.nodeType === 3 /* ParseNodeType.Assignment */ ||
             curNode.parent.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
             const leftNode = curNode.parent.nodeType === 4 /* ParseNodeType.AssignmentExpression */
-                ? curNode.parent.name
-                : curNode.parent.leftExpression;
+                ? curNode.parent.d.name
+                : curNode.parent.d.leftExpr;
             if (leftNode !== curNode || priorWord.length === 0) {
                 return false;
             }
@@ -989,7 +991,7 @@ class CompletionProvider {
             }
             const completionMap = this._getExpressionCompletions(curNode, priorWord, priorText, postText);
             if (completionMap) {
-                completionMap.delete(curNode.value);
+                completionMap.delete(curNode.d.value);
             }
             return completionMap;
         }
@@ -1048,7 +1050,7 @@ class CompletionProvider {
         // Is the error due to a missing member access name? If so,
         // we can evaluate the left side of the member access expression
         // to determine its type and offer suggestions based on it.
-        switch (node.category) {
+        switch (node.d.category) {
             case 0 /* ErrorExpressionCategory.MissingIn */: {
                 return this._createSingleKeywordCompletion('in');
             }
@@ -1063,7 +1065,7 @@ class CompletionProvider {
                 const index = ParseTreeUtils.getTokenIndexAtLeft(tokenizerOutput.tokens, offset);
                 const token = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index);
                 const prevToken = ParseTreeUtils.getTokenAtIndex(tokenizerOutput.tokens, index - 1);
-                if (node.category === 2 /* ErrorExpressionCategory.MissingExpression */) {
+                if (node.d.category === 2 /* ErrorExpressionCategory.MissingExpression */) {
                     // Skip dots on expressions.
                     if ((token === null || token === void 0 ? void 0 : token.type) === 20 /* TokenType.Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* TokenType.Ellipsis */) {
                         break;
@@ -1086,7 +1088,7 @@ class CompletionProvider {
                     const previousOffset = textRange_1.TextRange.getEnd(prevToken);
                     const previousNode = ParseTreeUtils.findNodeByOffset(this.parseResults.parserOutput.parseTree, previousOffset);
                     if ((previousNode === null || previousNode === void 0 ? void 0 : previousNode.nodeType) !== 0 /* ParseNodeType.Error */ ||
-                        previousNode.category !== 7 /* ErrorExpressionCategory.MissingMemberAccessName */) {
+                        previousNode.d.category !== 7 /* ErrorExpressionCategory.MissingMemberAccessName */) {
                         return this._getExpressionCompletions(node, priorWord, priorText, postText);
                     }
                     else {
@@ -1094,7 +1096,7 @@ class CompletionProvider {
                         node = previousNode;
                     }
                 }
-                else if (node.category === 7 /* ErrorExpressionCategory.MissingMemberAccessName */) {
+                else if (node.d.category === 7 /* ErrorExpressionCategory.MissingMemberAccessName */) {
                     // Skip double dots on member access.
                     if (((token === null || token === void 0 ? void 0 : token.type) === 20 /* TokenType.Dot */ || (token === null || token === void 0 ? void 0 : token.type) === 19 /* TokenType.Ellipsis */) &&
                         ((prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 20 /* TokenType.Dot */ || (prevToken === null || prevToken === void 0 ? void 0 : prevToken.type) === 19 /* TokenType.Ellipsis */)) {
@@ -1115,13 +1117,13 @@ class CompletionProvider {
                 return completionResults;
             }
             case 10 /* ErrorExpressionCategory.MissingFunctionParameterList */: {
-                if (node.child && node.child.nodeType === 38 /* ParseNodeType.Name */) {
-                    if ((_a = node.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
-                        return this._getMethodOverloadsCompletions(priorWord, node.child);
+                if (node.d.child && node.d.child.nodeType === 38 /* ParseNodeType.Name */) {
+                    if ((_a = node.d.decorators) === null || _a === void 0 ? void 0 : _a.some((d) => this._isOverload(d))) {
+                        return this._getMethodOverloadsCompletions(priorWord, node.d.child);
                     }
                     // Determine if the partial name is a method that's overriding
                     // a method in a base class.
-                    return this.getMethodOverrideCompletions(priorWord, node.child, node.decorators);
+                    return this.getMethodOverrideCompletions(priorWord, node.d.child, node.d.decorators);
                 }
                 break;
             }
@@ -1129,10 +1131,10 @@ class CompletionProvider {
         return undefined;
     }
     _getMissingMemberAccessNameCompletions(node, priorWord) {
-        if (!node.child || !(0, parseNodes_1.isExpressionNode)(node.child)) {
+        if (!node.d.child || !(0, parseNodes_1.isExpressionNode)(node.d.child)) {
             return undefined;
         }
-        return this.getMemberAccessCompletions(node.child, priorWord);
+        return this.getMemberAccessCompletions(node.d.child, priorWord);
     }
     _isOverload(node) {
         return ParseTreeUtils.checkDecorator(node, 'overload');
@@ -1150,8 +1152,8 @@ class CompletionProvider {
         // class T:
         //    f: |<= here
         const isTypeAnnotationOfClassVariable = ((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* ParseNodeType.TypeAnnotation */ &&
-            parseNode.parent.valueExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-            parseNode.parent.typeAnnotation === parseNode &&
+            parseNode.parent.d.valueExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+            parseNode.parent.d.annotation === parseNode &&
             ((_b = parseNode.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 47 /* ParseNodeType.StatementList */ &&
             ((_c = parseNode.parent.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 50 /* ParseNodeType.Suite */ &&
             ((_d = parseNode.parent.parent.parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* ParseNodeType.Class */;
@@ -1166,7 +1168,7 @@ class CompletionProvider {
         if (!classResults) {
             return undefined;
         }
-        const classVariableName = parseNode.parent.valueExpression.value;
+        const classVariableName = parseNode.parent.d.valueExpr.d.value;
         const classMember = (0, typeUtils_1.lookUpClassMember)(classResults.classType, classVariableName, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 1 /* MemberAccessFlags.SkipOriginalClass */);
         // First, see whether we can use semantic info to get variable type.
         if (classMember) {
@@ -1182,7 +1184,7 @@ class CompletionProvider {
         }
         // If we can't do that using semantic info, then try syntactic info.
         const symbolTable = new Map();
-        for (const mroClass of classResults.classType.details.mro) {
+        for (const mroClass of classResults.classType.shared.mro) {
             if (mroClass === classResults.classType) {
                 // Ignore current type.
                 continue;
@@ -1226,7 +1228,7 @@ class CompletionProvider {
             return undefined;
         }
         const symbolTable = new Map();
-        for (const mroClass of classResults.classType.details.mro) {
+        for (const mroClass of classResults.classType.shared.mro) {
             if ((0, types_1.isInstantiableClass)(mroClass)) {
                 (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
             }
@@ -1236,7 +1238,7 @@ class CompletionProvider {
             if (SymbolNameUtils.isPrivateName(name) ||
                 symbol.isPrivateMember() ||
                 symbol.isExternallyHidden() ||
-                !StringUtils.isPatternInSymbol(partialName.value, name)) {
+                !StringUtils.isPatternInSymbol(partialName.d.value, name)) {
                 return;
             }
             const decls = symbol
@@ -1247,7 +1249,7 @@ class CompletionProvider {
                 decls.some((d) => d.node && ParseTreeUtils.getEnclosingClass(d.node, false) === enclosingClass)) {
                 return;
             }
-            this.addSymbol(name, symbol, partialName.value, completionMap, {});
+            this.addSymbol(name, symbol, partialName.d.value, completionMap, {});
         });
         return completionMap.size > 0 ? completionMap : undefined;
     }
@@ -1265,7 +1267,7 @@ class CompletionProvider {
             if (!decl || decl.type !== 5 /* DeclarationType.Function */) {
                 return;
             }
-            if (!decl.node.decorators.some((d) => this._isOverload(d))) {
+            if (!decl.node.d.decorators.some((d) => this._isOverload(d))) {
                 // Only consider ones that have overload decorator.
                 return;
             }
@@ -1274,9 +1276,9 @@ class CompletionProvider {
                 // Don't show itself.
                 return;
             }
-            if (StringUtils.isPatternInSymbol(partialName.value, name)) {
-                const textEdit = this.createReplaceEdits(priorWord, partialName, decl.node.name.value);
-                this.addSymbol(name, symbol, partialName.value, completionMap, {
+            if (StringUtils.isPatternInSymbol(partialName.d.value, name)) {
+                const textEdit = this.createReplaceEdits(priorWord, partialName, decl.node.d.name.d.value);
+                this.addSymbol(name, symbol, partialName.d.value, completionMap, {
                     funcParensDisabled,
                     edits: { textEdit },
                 });
@@ -1291,7 +1293,7 @@ class CompletionProvider {
                     return undefined;
                 }
                 const symbolTable = new Map();
-                for (const mroClass of classResults.classType.details.mro) {
+                for (const mroClass of classResults.classType.shared.mro) {
                     if ((0, types_1.isInstantiableClass)(mroClass)) {
                         (0, typeUtils_1.getMembersForClass)(mroClass, symbolTable, /* includeInstanceVars */ false);
                     }
@@ -1314,7 +1316,7 @@ class CompletionProvider {
             // In stubs, always use "...".
             ellipsisForDefault = true;
         }
-        else if (classType.details.moduleName === decl.moduleName) {
+        else if (classType.shared.moduleName === decl.moduleName) {
             // In the same file, always print the full default.
             ellipsisForDefault = false;
         }
@@ -1322,17 +1324,17 @@ class CompletionProvider {
             ? 1 /* ParseTreeUtils.PrintExpressionFlags.ForwardDeclarations */ |
                 2 /* ParseTreeUtils.PrintExpressionFlags.DoNotLimitStringLength */
             : 2 /* ParseTreeUtils.PrintExpressionFlags.DoNotLimitStringLength */;
-        const paramList = node.parameters
+        const paramList = node.d.params
             .map((param, index) => {
             let paramString = '';
-            if (param.category === 1 /* ParameterCategory.ArgsList */) {
+            if (param.d.category === 1 /* ParameterCategory.ArgsList */) {
                 paramString += '*';
             }
-            else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
+            else if (param.d.category === 2 /* ParameterCategory.KwargsDict */) {
                 paramString += '**';
             }
-            if (param.name) {
-                paramString += param.name.value;
+            if (param.d.name) {
+                paramString += param.d.name.d.value;
             }
             // Currently, we don't automatically add import if the type used in the annotation is not imported
             // in current file.
@@ -1340,25 +1342,26 @@ class CompletionProvider {
             if (paramTypeAnnotation) {
                 paramString += ': ' + ParseTreeUtils.printExpression(paramTypeAnnotation, printFlags);
             }
-            if (param.defaultValue) {
+            if (param.d.defaultValue) {
                 paramString += paramTypeAnnotation ? ' = ' : '=';
-                const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !ParseTreeUtils.isSimpleDefault(param.defaultValue);
-                paramString += useEllipsis ? '...' : ParseTreeUtils.printExpression(param.defaultValue, printFlags);
+                const useEllipsis = ellipsisForDefault !== null && ellipsisForDefault !== void 0 ? ellipsisForDefault : !ParseTreeUtils.isSimpleDefault(param.d.defaultValue);
+                paramString += useEllipsis
+                    ? '...'
+                    : ParseTreeUtils.printExpression(param.d.defaultValue, printFlags);
             }
-            if (!paramString && !param.name && param.category === 0 /* ParameterCategory.Simple */) {
+            if (!paramString && !param.d.name && param.d.category === 0 /* ParameterCategory.Simple */) {
                 return '/';
             }
             return paramString;
         })
             .join(', ');
-        let methodSignature = node.name.value + '(' + paramList + ')';
-        if (node.returnTypeAnnotation) {
-            methodSignature += ' -> ' + ParseTreeUtils.printExpression(node.returnTypeAnnotation, printFlags);
+        let methodSignature = node.d.name.d.value + '(' + paramList + ')';
+        if (node.d.returnAnnotation) {
+            methodSignature += ' -> ' + ParseTreeUtils.printExpression(node.d.returnAnnotation, printFlags);
         }
-        else if (node.functionAnnotationComment) {
+        else if (node.d.funcAnnotationComment) {
             methodSignature +=
-                ' -> ' +
-                    ParseTreeUtils.printExpression(node.functionAnnotationComment.returnTypeAnnotation, printFlags);
+                ' -> ' + ParseTreeUtils.printExpression(node.d.funcAnnotationComment.d.returnAnnotation, printFlags);
         }
         return methodSignature;
     }
@@ -1377,7 +1380,7 @@ class CompletionProvider {
         // Are we within a "with Y as []"?
         // Don't add any completion options.
         if (((_a = parseNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 59 /* ParseNodeType.WithItem */ &&
-            parseNode.parent === ((_b = parseNode.parent.target) === null || _b === void 0 ? void 0 : _b.parent)) {
+            parseNode.parent === ((_b = parseNode.parent.d.target) === null || _b === void 0 ? void 0 : _b.parent)) {
             return undefined;
         }
         const completionMap = new CompletionMap();
@@ -1417,11 +1420,11 @@ class CompletionProvider {
         const currentNode = node.parent;
         return (currentNode &&
             currentNode.nodeType === 1 /* ParseNodeType.Argument */ &&
-            currentNode.argumentCategory === 0 /* ArgumentCategory.Simple */ &&
+            currentNode.d.argCategory === 0 /* ArgumentCategory.Simple */ &&
             currentNode.parent &&
             currentNode.parent.nodeType === 27 /* ParseNodeType.Index */ &&
-            currentNode.parent.baseExpression &&
-            currentNode.parent.baseExpression.nodeType === 38 /* ParseNodeType.Name */);
+            currentNode.parent.d.leftExpr &&
+            currentNode.parent.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */);
     }
     _addCallArgumentCompletions(parseNode, priorWord, priorText, postText, atArgument, completionMap) {
         // If we're within the argument list of a call, add parameter names.
@@ -1433,7 +1436,7 @@ class CompletionProvider {
         const signatureInfo = this.evaluator.getCallSignatureInfo(callInfo.callNode, callInfo.activeIndex, callInfo.activeOrFake);
         if (signatureInfo) {
             // Are we past the call expression and within the argument list?
-            const callNameEnd = (0, positionUtils_1.convertOffsetToPosition)(signatureInfo.callNode.leftExpression.start + signatureInfo.callNode.leftExpression.length, this.parseResults.tokenizerOutput.lines);
+            const callNameEnd = (0, positionUtils_1.convertOffsetToPosition)(signatureInfo.callNode.d.leftExpr.start + signatureInfo.callNode.d.leftExpr.length, this.parseResults.tokenizerOutput.lines);
             if ((0, textRange_1.comparePositions)(this.position, callNameEnd) > 0) {
                 if (!atArgument) {
                     this._addNamedParameters(signatureInfo, priorWord, completionMap);
@@ -1449,11 +1452,11 @@ class CompletionProvider {
                 return undefined;
             }
             const type = signature.type;
-            const paramIndex = type.details.parameters.indexOf(signature.activeParam);
+            const paramIndex = type.shared.parameters.indexOf(signature.activeParam);
             if (paramIndex < 0) {
                 return undefined;
             }
-            const paramType = type.details.parameters[paramIndex].type;
+            const paramType = type.shared.parameters[paramIndex].type;
             this._addLiteralValuesForTargetType(paramType, priorWord, priorText, postText, completionMap);
             return undefined;
         });
@@ -1465,7 +1468,7 @@ class CompletionProvider {
                 const value = (0, typePrinter_1.printLiteralValue)(v, quoteValue.quoteCharacter);
                 if (quoteValue.stringValue === undefined) {
                     this.addNameToCompletions(value, vscode_languageserver_1.CompletionItemKind.Constant, priorWord, completionMap, {
-                        sortText: this._makeSortText(SortCategory.LiteralValue, v.literalValue),
+                        sortText: this._makeSortText(SortCategory.LiteralValue, v.priv.literalValue),
                     });
                 }
                 else {
@@ -1479,12 +1482,12 @@ class CompletionProvider {
         if (!node) {
             return [];
         }
-        return node.entries.flatMap((entry) => {
-            if (entry.nodeType !== 20 /* ParseNodeType.DictionaryKeyEntry */ || (excludeIds === null || excludeIds === void 0 ? void 0 : excludeIds.has(entry.keyExpression.id))) {
+        return node.d.items.flatMap((entry) => {
+            if (entry.nodeType !== 20 /* ParseNodeType.DictionaryKeyEntry */ || (excludeIds === null || excludeIds === void 0 ? void 0 : excludeIds.has(entry.d.keyExpr.id))) {
                 return [];
             }
-            if (entry.keyExpression.nodeType === 48 /* ParseNodeType.StringList */) {
-                return [entry.keyExpression.strings.map((s) => s.value).join('')];
+            if (entry.d.keyExpr.nodeType === 48 /* ParseNodeType.StringList */) {
+                return [entry.d.keyExpr.d.strings.map((s) => s.d.value).join('')];
             }
             return [];
         });
@@ -1519,8 +1522,8 @@ class CompletionProvider {
             const typesToCombine = [];
             // Handle both overloaded and non-overloaded functions.
             (0, typeUtils_1.doForEachSignature)(getItemType, (signature) => {
-                if (signature.details.parameters.length >= 1 &&
-                    signature.details.parameters[0].category === 0 /* ParameterCategory.Simple */) {
+                if (signature.shared.parameters.length >= 1 &&
+                    signature.shared.parameters[0].category === 0 /* ParameterCategory.Simple */) {
                     typesToCombine.push(types_1.FunctionType.getEffectiveParameterType(signature, 0));
                 }
             });
@@ -1532,7 +1535,7 @@ class CompletionProvider {
     }
     _getIndexKeys(indexNode, invocationNode) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const baseType = this.evaluator.getType(indexNode.baseExpression);
+        const baseType = this.evaluator.getType(indexNode.d.leftExpr);
         if (!baseType || !(0, types_1.isClassInstance)(baseType)) {
             return [];
         }
@@ -1554,12 +1557,12 @@ class CompletionProvider {
                 return keys;
             }
         }
-        if (indexNode.baseExpression.nodeType !== 38 /* ParseNodeType.Name */) {
+        if (indexNode.d.leftExpr.nodeType !== 38 /* ParseNodeType.Name */) {
             // This completion only supports simple name case
             return [];
         }
         // Must be local variable/parameter
-        const declarations = (_a = this.evaluator.getDeclarationsForNameNode(indexNode.baseExpression)) !== null && _a !== void 0 ? _a : [];
+        const declarations = (_a = this.evaluator.getDeclarationsForNameNode(indexNode.d.leftExpr)) !== null && _a !== void 0 ? _a : [];
         const declaration = declarations.length > 0 ? declarations[0] : undefined;
         if (!declaration ||
             (declaration.type !== 1 /* DeclarationType.Variable */ && declaration.type !== 2 /* DeclarationType.Parameter */)) {
@@ -1568,7 +1571,7 @@ class CompletionProvider {
         if (!declaration.uri.equals(this.fileUri)) {
             return [];
         }
-        let startingNode = indexNode.baseExpression;
+        let startingNode = indexNode.d.leftExpr;
         if (declaration.node) {
             const scopeRoot = ParseTreeUtils.getEvaluationScopeNode(declaration.node).node;
             // Find the lowest tree to search the symbol.
@@ -1576,30 +1579,28 @@ class CompletionProvider {
                 startingNode = scopeRoot;
             }
         }
-        const results = documentSymbolCollector_1.DocumentSymbolCollector.collectFromNode(this.program, indexNode.baseExpression, this.cancellationToken, startingNode);
+        const results = documentSymbolCollector_1.DocumentSymbolCollector.collectFromNode(this.program, indexNode.d.leftExpr, this.cancellationToken, startingNode);
         const keys = new Set();
         for (const result of results) {
             const node = ((_d = result.node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* ParseNodeType.TypeAnnotation */ ? result.node.parent : result.node;
             if (((_e = node.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 3 /* ParseNodeType.Assignment */ ||
                 ((_f = node.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 4 /* ParseNodeType.AssignmentExpression */) {
-                if (node.parent.rightExpression.nodeType === 18 /* ParseNodeType.Dictionary */) {
-                    const dictionary = node.parent.rightExpression;
-                    for (const entry of dictionary.entries.filter((e) => e.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */)) {
-                        const key = this.parseResults.text
-                            .substr(entry.keyExpression.start, entry.keyExpression.length)
-                            .trim();
+                if (node.parent.d.rightExpr.nodeType === 18 /* ParseNodeType.Dictionary */) {
+                    const dictionary = node.parent.d.rightExpr;
+                    for (const entry of dictionary.d.items.filter((e) => e.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */)) {
+                        const key = this.parseResults.text.substr(entry.d.keyExpr.start, entry.d.keyExpr.length).trim();
                         if (key.length > 0)
                             keys.add(key);
                     }
                 }
-                if (node.parent.rightExpression.nodeType === 9 /* ParseNodeType.Call */) {
-                    const call = node.parent.rightExpression;
-                    const type = this.evaluator.getType(call.leftExpression);
+                if (node.parent.d.rightExpr.nodeType === 9 /* ParseNodeType.Call */) {
+                    const call = node.parent.d.rightExpr;
+                    const type = this.evaluator.getType(call.d.leftExpr);
                     if (!type || !(0, types_1.isInstantiableClass)(type) || !types_1.ClassType.isBuiltIn(type, 'dict')) {
                         continue;
                     }
-                    for (const arg of call.arguments) {
-                        const key = (_h = (_g = arg.name) === null || _g === void 0 ? void 0 : _g.value.trim()) !== null && _h !== void 0 ? _h : '';
+                    for (const arg of call.d.args) {
+                        const key = (_h = (_g = arg.d.name) === null || _g === void 0 ? void 0 : _g.d.value.trim()) !== null && _h !== void 0 ? _h : '';
                         const quote = this.parseResults.tokenizerOutput.predominantSingleQuoteCharacter;
                         if (key.length > 0) {
                             keys.add(`${quote}${key}${quote}`);
@@ -1608,12 +1609,12 @@ class CompletionProvider {
                 }
             }
             if (((_j = node.parent) === null || _j === void 0 ? void 0 : _j.nodeType) === 27 /* ParseNodeType.Index */ &&
-                node.parent.items.length === 1 &&
-                node.parent.items[0].valueExpression.nodeType !== 0 /* ParseNodeType.Error */ &&
+                node.parent.d.items.length === 1 &&
+                node.parent.d.items[0].d.valueExpr.nodeType !== 0 /* ParseNodeType.Error */ &&
                 !textRange_1.TextRange.containsRange(node.parent, invocationNode)) {
-                const indexArgument = node.parent.items[0];
+                const indexArgument = node.parent.d.items[0];
                 const key = this.parseResults.text
-                    .substr(indexArgument.valueExpression.start, indexArgument.valueExpression.length)
+                    .substr(indexArgument.d.valueExpr.start, indexArgument.d.valueExpr.length)
                     .trim();
                 if (key.length > 0)
                     keys.add(key);
@@ -1644,7 +1645,7 @@ class CompletionProvider {
         // See if the type evaluator can determine the expected type for this node.
         // ex) a: Literal["str"] = /* here */
         const nodeForExpectedType = parentAndChild.parent.nodeType === 3 /* ParseNodeType.Assignment */
-            ? parentAndChild.parent.rightExpression === parentAndChild.child
+            ? parentAndChild.parent.d.rightExpr === parentAndChild.child
                 ? parentAndChild.child
                 : undefined
             : (0, parseNodes_1.isExpressionNode)(parentAndChild.child)
@@ -1664,7 +1665,7 @@ class CompletionProvider {
             // a set initially.
             let dictOrSet;
             if (nodeForKey.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */ &&
-                nodeForKey.keyExpression === parentAndChild.child &&
+                nodeForKey.d.keyExpr === parentAndChild.child &&
                 ((_a = nodeForKey.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 18 /* ParseNodeType.Dictionary */) {
                 dictOrSet = nodeForKey.parent;
             }
@@ -1719,8 +1720,9 @@ class CompletionProvider {
         // if c == "/* here */"
         const comparison = parentAndChild.parent;
         const supportedOperators = [2 /* OperatorType.Assign */, 12 /* OperatorType.Equals */, 28 /* OperatorType.NotEquals */];
-        if (comparison.nodeType === 7 /* ParseNodeType.BinaryOperation */ && supportedOperators.includes(comparison.operator)) {
-            const type = this.evaluator.getType(comparison.leftExpression);
+        if (comparison.nodeType === 7 /* ParseNodeType.BinaryOperation */ &&
+            supportedOperators.includes(comparison.d.operator)) {
+            const type = this.evaluator.getType(comparison.d.leftExpr);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1729,8 +1731,8 @@ class CompletionProvider {
         // if c := "/* here */"
         const assignmentExpression = parentAndChild.parent;
         if (assignmentExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */ &&
-            assignmentExpression.rightExpression === parentAndChild.child) {
-            const type = this.evaluator.getType(assignmentExpression.name);
+            assignmentExpression.d.rightExpr === parentAndChild.child) {
+            const type = this.evaluator.getType(assignmentExpression.d.name);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1741,11 +1743,11 @@ class CompletionProvider {
         //     case /* here */
         const caseNode = parentAndChild.parent;
         if (caseNode.nodeType === 64 /* ParseNodeType.Case */ &&
-            caseNode.pattern.nodeType === 0 /* ParseNodeType.Error */ &&
-            caseNode.pattern.category === 11 /* ErrorExpressionCategory.MissingPattern */ &&
-            caseNode.suite === parentAndChild.child &&
+            caseNode.d.pattern.nodeType === 0 /* ParseNodeType.Error */ &&
+            caseNode.d.pattern.d.category === 11 /* ErrorExpressionCategory.MissingPattern */ &&
+            caseNode.d.suite === parentAndChild.child &&
             ((_c = caseNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 63 /* ParseNodeType.Match */) {
-            const type = this.evaluator.getType(caseNode.parent.subjectExpression);
+            const type = this.evaluator.getType(caseNode.parent.d.expr);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1760,7 +1762,7 @@ class CompletionProvider {
             ((_d = patternLiteral.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 66 /* ParseNodeType.PatternAs */ &&
             ((_e = patternLiteral.parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 64 /* ParseNodeType.Case */ &&
             ((_f = patternLiteral.parent.parent.parent) === null || _f === void 0 ? void 0 : _f.nodeType) === 63 /* ParseNodeType.Match */) {
-            const type = this.evaluator.getType(patternLiteral.parent.parent.parent.subjectExpression);
+            const type = this.evaluator.getType(patternLiteral.parent.parent.parent.d.expr);
             if (type && (0, typeUtils_1.containsLiteralType)(type)) {
                 this._addLiteralValuesForTargetType(type, priorWord, priorText, postText, completionMap);
                 return true;
@@ -1784,7 +1786,7 @@ class CompletionProvider {
             if (!node.parent.parent) {
                 return undefined;
             }
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 48 /* ParseNodeType.StringList */ || node.parent.strings.length > 1) {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 48 /* ParseNodeType.StringList */ || node.parent.d.strings.length > 1) {
                 return undefined;
             }
             return { parent: node.parent.parent, child: node.parent };
@@ -1893,7 +1895,7 @@ class CompletionProvider {
         if (!indexNode) {
             return false;
         }
-        const baseType = this.evaluator.getType(indexNode.baseExpression);
+        const baseType = this.evaluator.getType(indexNode.d.leftExpr);
         if (!baseType) {
             return false;
         }
@@ -1936,12 +1938,12 @@ class CompletionProvider {
     _getImportFromCompletions(importFromNode, offset, priorWord) {
         var _a;
         // Don't attempt to provide completions for "from X import *".
-        if (importFromNode.isWildcardImport) {
+        if (importFromNode.d.isWildcardImport) {
             return undefined;
         }
         // Access the imported module information, which is hanging
         // off the ImportFromNode.
-        const importInfo = AnalyzerNodeInfo.getImportInfo(importFromNode.module);
+        const importInfo = AnalyzerNodeInfo.getImportInfo(importFromNode.d.module);
         if (!importInfo) {
             return undefined;
         }
@@ -1965,7 +1967,7 @@ class CompletionProvider {
             symbol.getDeclarations().some((d) => !(0, declaration_1.isIntrinsicDeclaration)(d)) &&
                 // Don't suggest symbols that have already been imported elsewhere
                 // in this import statement.
-                !importFromNode.imports.find((imp) => imp.name.value === name &&
+                !importFromNode.d.imports.find((imp) => imp.d.name.d.value === name &&
                     !(textRange_1.TextRange.contains(imp, offset) || textRange_1.TextRange.getEnd(imp) === offset)));
         }, priorWord, importFromNode, 
         /* isInImport */ true, 
@@ -1976,7 +1978,7 @@ class CompletionProvider {
     }
     _addImplicitImportsToCompletion(importInfo, importFromNode, priorWord, completionMap) {
         importInfo.implicitImports.forEach((implImport) => {
-            if (!importFromNode.imports.find((imp) => imp.name.value === implImport.name)) {
+            if (!importFromNode.d.imports.find((imp) => imp.d.name.d.value === implImport.name)) {
                 this.addNameToCompletions(implImport.name, vscode_languageserver_1.CompletionItemKind.Module, priorWord, completionMap, {
                     moduleUri: implImport.uri,
                 });
@@ -2001,15 +2003,15 @@ class CompletionProvider {
         // Add keys from typed dict outside signatures.
         signatureInfo.signatures.forEach((signature) => {
             var _a;
-            if (signature.type.boundToType) {
-                const keys = Array.from(((_a = signature.type.boundToType.details.typedDictEntries) === null || _a === void 0 ? void 0 : _a.knownItems.keys()) || []);
+            if (signature.type.priv.boundToType) {
+                const keys = Array.from(((_a = signature.type.priv.boundToType.shared.typedDictEntries) === null || _a === void 0 ? void 0 : _a.knownItems.keys()) || []);
                 keys.forEach((key) => argNameSet.add(key));
             }
         });
         // Remove any named parameters that are already provided.
-        signatureInfo.callNode.arguments.forEach((arg) => {
-            if (arg.name) {
-                argNameSet.delete(arg.name.value);
+        signatureInfo.callNode.d.args.forEach((arg) => {
+            if (arg.d.name) {
+                argNameSet.delete(arg.d.name.d.value);
             }
         });
         // Add the remaining unique parameter names to the completion list.
@@ -2058,7 +2060,7 @@ class CompletionProvider {
                 if (curNode.nodeType === 10 /* ParseNodeType.Class */) {
                     const classType = this.evaluator.getTypeOfClass(curNode);
                     if (classType && (0, types_1.isInstantiableClass)(classType.classType)) {
-                        classType.classType.details.mro.forEach((baseClass, index) => {
+                        classType.classType.shared.mro.forEach((baseClass, index) => {
                             if ((0, types_1.isInstantiableClass)(baseClass)) {
                                 this._addSymbolsForSymbolTable(types_1.ClassType.getSymbolTable(baseClass), (symbol) => {
                                     if (!symbol.isClassMember()) {
@@ -2168,7 +2170,7 @@ class CompletionProvider {
         }
         switch (resolvedDeclaration.type) {
             case 0 /* DeclarationType.Intrinsic */:
-                return resolvedDeclaration.intrinsicType === 'class'
+                return resolvedDeclaration.intrinsicType === 'type[self]'
                     ? vscode_languageserver_1.CompletionItemKind.Class
                     : vscode_languageserver_1.CompletionItemKind.Variable;
             case 2 /* DeclarationType.Parameter */:
@@ -2218,19 +2220,19 @@ class CompletionProvider {
     }
     _getImportModuleCompletions(node) {
         const moduleDescriptor = {
-            leadingDots: node.leadingDots,
-            hasTrailingDot: node.hasTrailingDot || false,
-            nameParts: node.nameParts.map((part) => part.value),
+            leadingDots: node.d.leadingDots,
+            hasTrailingDot: node.d.hasTrailingDot || false,
+            nameParts: node.d.nameParts.map((part) => part.d.value),
             importedSymbols: new Set(),
         };
         const completions = this.importResolver.getCompletionSuggestions(this.fileUri, this.execEnv, moduleDescriptor);
         const completionMap = new CompletionMap();
         // If we're in the middle of a "from X import Y" statement, offer
         // the "import" keyword as a completion.
-        if (!node.hasTrailingDot &&
+        if (!node.d.hasTrailingDot &&
             node.parent &&
             node.parent.nodeType === 25 /* ParseNodeType.ImportFrom */ &&
-            node.parent.missingImportKeyword) {
+            node.parent.d.missingImport) {
             const keyword = 'import';
             const completionItem = vscode_languageserver_1.CompletionItem.create(keyword);
             completionItem.kind = vscode_languageserver_1.CompletionItemKind.Keyword;
@@ -2248,7 +2250,7 @@ class CompletionProvider {
     _isPossiblePropertyDeclaration(decl) {
         // Do cheap check using only nodes that will cover 99.9% cases
         // before doing more expensive type evaluation.
-        return decl.isMethod && decl.node.decorators.length > 0;
+        return decl.isMethod && decl.node.d.decorators.length > 0;
     }
     _isEnumMember(containingType, name) {
         if (!containingType || !types_1.ClassType.isEnumClass(containingType)) {
@@ -2258,7 +2260,7 @@ class CompletionProvider {
         return (symbolType &&
             (0, types_1.isClassInstance)(symbolType) &&
             types_1.ClassType.isSameGenericClass(symbolType, containingType) &&
-            symbolType.literalValue instanceof types_1.EnumLiteral);
+            symbolType.priv.literalValue instanceof types_1.EnumLiteral);
     }
 }
 exports.CompletionProvider = CompletionProvider;