@zzzen/pyright-internal 1.2.0-dev.20260809 → 1.2.0-dev.20260823

package/dist/parser/parser.js

@@ -57,6 +57,7 @@ const textRange_1 = require("../common/textRange");
 const timing_1 = require("../common/timing");
 const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("./parseNodes");
+const stringAnnotationInfo_1 = require("./stringAnnotationInfo");
 const StringTokenUtils = __importStar(require("./stringTokenUtils"));
 const tokenizer_1 = require("./tokenizer");
 const tokenizerTypes_1 = require("./tokenizerTypes");
@@ -104,13 +105,18 @@ class Parser {
         this._typingSymbolAliases = new Map();
         this._maxChildDepthMap = new Map();
         this._hasTypeAnnotations = false;
+        this._createdOwnerKey = false;
+        this._stringAnnotations = (0, stringAnnotationInfo_1.createStringAnnotationInfo)();
     }
-    parseSourceFile(fileContents, parseOptions, diagSink) {
+    parseSourceFile(fileContents, parseOptions, diagSink, contentHash) {
         this._hasTypeAnnotations = false;
+        this._stringAnnotations = (0, stringAnnotationInfo_1.createStringAnnotationInfo)();
         timing_1.timingStats.tokenizeFileTime.timeOperation(() => {
             this._startNewParse(fileContents, 0, fileContents.length, parseOptions, diagSink);
         });
         const moduleNode = parseNodes_1.ModuleNode.create({ start: 0, length: fileContents.length });
+        this._ownerKey = moduleNode.a;
+        this._createdOwnerKey = true;
         timing_1.timingStats.parseFileTime.timeOperation(() => {
             while (!this._atEof()) {
                 if (!this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
@@ -138,12 +144,14 @@ class Parser {
                 }
             }
         });
+        this._attachParserStringAnnotations();
         (0, debug_1.assert)(this._tokenizerOutput !== undefined);
         return {
             text: fileContents,
-            contentHash: (0, stringUtils_1.hashString)(fileContents),
+            contentHash: contentHash ?? (0, stringUtils_1.getStringFingerprint)(fileContents),
             parserOutput: {
                 parseTree: moduleNode,
+                stringAnnotations: this._stringAnnotations.info,
                 importedModules: this._importedModules,
                 futureImports: this._futureImports,
                 containsWildcardImport: this._containsWildcardImport,
@@ -154,7 +162,10 @@ class Parser {
             tokenizerOutput: this._tokenizerOutput,
         };
     }
-    parseTextExpression(fileContents, textOffset, textLength, parseOptions, parseTextMode = 0 /* ParseTextMode.Expression */, initialParenDepth = 0, typingSymbolAliases) {
+    parseTextExpression(fileContents, textOffset, textLength, parseOptions, parseTextMode = 0 /* ParseTextMode.Expression */, initialParenDepth = 0, typingSymbolAliases, ownerKey) {
+        this._stringAnnotations = (0, stringAnnotationInfo_1.createStringAnnotationInfo)();
+        this._createdOwnerKey = ownerKey === undefined;
+        this._ownerKey = ownerKey ?? {};
         const diagSink = new diagnosticSink_1.DiagnosticSink();
         this._startNewParse(fileContents, textOffset, textLength, parseOptions, diagSink, initialParenDepth);
         if (typingSymbolAliases) {
@@ -189,12 +200,29 @@ class Parser {
         if (!this._atEof()) {
             this._addSyntaxError(localize_1.LocMessage.unexpectedExprToken(), this._peekToken());
         }
+        this._attachParserStringAnnotations();
         return {
             parseTree,
+            stringAnnotations: this._stringAnnotations.info,
             lines: this._tokenizerOutput.lines,
             diagnostics: diagSink.fetchAndClear(),
         };
     }
+    // Attaches parser-derived string annotations onto the owner key, but only when
+    // this parser instance created that key (top-level file parse, or a standalone
+    // expression parse with no inherited owner key) and only when the tree actually
+    // contains at least one quoted annotation. Nested re-parses inherit their
+    // parent's owner key and merge their annotations back into the parent, so they
+    // must not attach; the key-creating parser attaches the fully merged set.
+    _attachParserStringAnnotations() {
+        if (this._createdOwnerKey && this._ownerKey !== undefined && this._stringAnnotations.info.size > 0) {
+            (0, parseNodes_1.setParserStringAnnotationInfo)(this._ownerKey, this._stringAnnotations.info);
+        }
+    }
+    _getOwnerKey() {
+        (0, debug_1.assert)(this._ownerKey !== undefined);
+        return this._ownerKey;
+    }
     _startNewParse(fileContents, textOffset, textLength, parseOptions, diagSink, initialParenDepth = 0) {
         this._fileContents = fileContents;
         this._parseOptions = parseOptions;
@@ -316,7 +344,7 @@ class Parser {
         }
         const nameToken = this._getTokenIfIdentifier();
         (0, debug_1.assert)(nameToken !== undefined);
-        const name = parseNodes_1.NameNode.create(nameToken);
+        const name = parseNodes_1.NameNode.create(this._getOwnerKey(), nameToken);
         let typeParameters;
         if (this._peekToken().type === 15 /* TokenType.OpenBracket */) {
             typeParameters = this._parseTypeParameterList();
@@ -333,7 +361,7 @@ class Parser {
         this._isParsingTypeAnnotation = true;
         const expression = this._parseTestExpression(/* allowAssignmentExpression */ false);
         this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
-        return parseNodes_1.TypeAliasNode.create(typeToken, name, expression, typeParameters);
+        return parseNodes_1.TypeAliasNode.create(this._getOwnerKey(), typeToken, name, expression, typeParameters);
     }
     // type_param_seq: '[' (type_param ',')+ ']'
     _parseTypeParameterList() {
@@ -365,7 +393,7 @@ class Parser {
         else {
             this._getNextToken();
         }
-        return parseNodes_1.TypeParameterListNode.create(openBracketToken, closingToken, typeVariableNodes);
+        return parseNodes_1.TypeParameterListNode.create(this._getOwnerKey(), openBracketToken, closingToken, typeVariableNodes);
     }
     // type_param: ['*' | '**'] NAME [':' bound_expr] ['=' default_expr]
     _parseTypeParameter() {
@@ -381,7 +409,7 @@ class Parser {
             this._addSyntaxError(localize_1.LocMessage.expectedTypeParameterName(), this._peekToken());
             return undefined;
         }
-        const name = parseNodes_1.NameNode.create(nameToken);
+        const name = parseNodes_1.NameNode.create(this._getOwnerKey(), nameToken);
         let boundExpression;
         if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             boundExpression = this._parseExpression(/* allowUnpack */ false);
@@ -398,7 +426,7 @@ class Parser {
                 this._addSyntaxError(localize_1.LocMessage.typeVarDefaultIllegal(), defaultExpression);
             }
         }
-        return parseNodes_1.TypeParameterNode.create(name, typeParamCategory, boundExpression, defaultExpression);
+        return parseNodes_1.TypeParameterNode.create(this._getOwnerKey(), name, typeParamCategory, boundExpression, defaultExpression);
     }
     // match_stmt: "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT
     // subject_expr:
@@ -429,7 +457,7 @@ class Parser {
         const subjectExpression = this._parseTestOrStarListAsExpression(
         /* allowAssignmentExpression */ true, 
         /* allowMultipleUnpack */ true, 12 /* ErrorExpressionCategory.MissingPatternSubject */, () => localize_1.LocMessage.expectedReturnExpr());
-        const matchNode = parseNodes_1.MatchNode.create(matchToken, subjectExpression);
+        const matchNode = parseNodes_1.MatchNode.create(this._getOwnerKey(), matchToken, subjectExpression);
         const nextToken = this._peekToken();
         if (!this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             this._addSyntaxError(localize_1.LocMessage.expectedColon(), nextToken);
@@ -530,19 +558,19 @@ class Parser {
         }
         else if (patternList.list.length === 0) {
             this._addSyntaxError(localize_1.LocMessage.expectedPatternExpr(), this._peekToken());
-            casePattern = parseNodes_1.ErrorNode.create(caseToken, 11 /* ErrorExpressionCategory.MissingPattern */);
+            casePattern = parseNodes_1.ErrorNode.create(this._getOwnerKey(), caseToken, 11 /* ErrorExpressionCategory.MissingPattern */);
         }
         else if (patternList.list.length === 1 && !patternList.trailingComma) {
             const pattern = patternList.list[0].d.orPatterns[0];
             if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.d.isStar) {
-                casePattern = parseNodes_1.PatternSequenceNode.create(patternList.list[0], patternList.list);
+                casePattern = parseNodes_1.PatternSequenceNode.create(this._getOwnerKey(), patternList.list[0], patternList.list);
             }
             else {
                 casePattern = patternList.list[0];
             }
         }
         else {
-            casePattern = parseNodes_1.PatternSequenceNode.create(patternList.list[0], patternList.list);
+            casePattern = parseNodes_1.PatternSequenceNode.create(this._getOwnerKey(), patternList.list[0], patternList.list);
         }
         if (casePattern.nodeType !== 0 /* ParseNodeType.Error */) {
             const globalNameMap = new Map();
@@ -554,7 +582,7 @@ class Parser {
             guardExpression = this._parseTestExpression(/* allowAssignmentExpression */ true);
         }
         const suite = this._parseSuite(this._isInFunction);
-        return parseNodes_1.CaseNode.create(caseToken, casePattern, this._isPatternIrrefutable(casePattern), guardExpression, suite);
+        return parseNodes_1.CaseNode.create(this._getOwnerKey(), caseToken, casePattern, this._isPatternIrrefutable(casePattern), guardExpression, suite);
     }
     // PEP 634 defines the concept of an "irrefutable" pattern - a pattern that
     // will always be matched.
@@ -722,7 +750,7 @@ class Parser {
         if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
             const nameToken = this._getTokenIfIdentifier();
             if (nameToken) {
-                target = parseNodes_1.NameNode.create(nameToken);
+                target = parseNodes_1.NameNode.create(this._getOwnerKey(), nameToken);
             }
             else {
                 this._addSyntaxError(localize_1.LocMessage.expectedNameAfterAs(), this._peekToken());
@@ -758,7 +786,7 @@ class Parser {
                 this._addSyntaxError(localize_1.LocMessage.orPatternMissingName() + diag.getString(), orPattern);
             }
         });
-        return parseNodes_1.PatternAsNode.create(orPatterns, target);
+        return parseNodes_1.PatternAsNode.create(this._getOwnerKey(), orPatterns, target);
     }
     // pattern_atom:
     //     | literal_pattern
@@ -789,7 +817,7 @@ class Parser {
             const classNameExpr = patternCaptureOrValue.nodeType === 69 /* ParseNodeType.PatternCapture */
                 ? patternCaptureOrValue.d.target
                 : patternCaptureOrValue.d.expr;
-            const classPattern = parseNodes_1.PatternClassNode.create(classNameExpr, args);
+            const classPattern = parseNodes_1.PatternClassNode.create(this._getOwnerKey(), classNameExpr, args);
             if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
                 this._addSyntaxError(localize_1.LocMessage.expectedCloseParen(), openParenToken);
                 // Consume the remainder of tokens on the line for error
@@ -808,10 +836,10 @@ class Parser {
             const identifierToken = this._getTokenIfIdentifier();
             if (!identifierToken) {
                 this._addSyntaxError(localize_1.LocMessage.expectedIdentifier(), this._peekToken());
-                return parseNodes_1.ErrorNode.create(starToken, 2 /* ErrorExpressionCategory.MissingExpression */);
+                return parseNodes_1.ErrorNode.create(this._getOwnerKey(), starToken, 2 /* ErrorExpressionCategory.MissingExpression */);
             }
             else {
-                return parseNodes_1.PatternCaptureNode.create(parseNodes_1.NameNode.create(identifierToken), starToken);
+                return parseNodes_1.PatternCaptureNode.create(this._getOwnerKey(), parseNodes_1.NameNode.create(this._getOwnerKey(), identifierToken), starToken);
             }
         }
         if (nextToken.type === 13 /* TokenType.OpenParenthesis */ || nextToken.type === 15 /* TokenType.OpenBracket */) {
@@ -826,7 +854,7 @@ class Parser {
                 startToken.type === 13 /* TokenType.OpenParenthesis */) {
                 const pattern = patternList.list[0].d.orPatterns[0];
                 if (pattern.nodeType === 69 /* ParseNodeType.PatternCapture */ && pattern.d.isStar) {
-                    casePattern = parseNodes_1.PatternSequenceNode.create(startToken, patternList.list);
+                    casePattern = parseNodes_1.PatternSequenceNode.create(this._getOwnerKey(), startToken, patternList.list);
                 }
                 else {
                     casePattern = patternList.list[0];
@@ -834,7 +862,7 @@ class Parser {
                 (0, parseNodes_1.extendRange)(casePattern, nextToken);
             }
             else {
-                casePattern = parseNodes_1.PatternSequenceNode.create(startToken, patternList.list);
+                casePattern = parseNodes_1.PatternSequenceNode.create(this._getOwnerKey(), startToken, patternList.list);
             }
             const endToken = this._peekToken();
             if (this._consumeTokenIfType(nextToken.type === 13 /* TokenType.OpenParenthesis */ ? 14 /* TokenType.CloseParenthesis */ : 16 /* TokenType.CloseBracket */)) {
@@ -905,12 +933,12 @@ class Parser {
             secondToken.operatorType === 2 /* OperatorType.Assign */) {
             const classNameToken = this._getTokenIfIdentifier();
             if (classNameToken !== undefined) {
-                keywordName = parseNodes_1.NameNode.create(classNameToken);
+                keywordName = parseNodes_1.NameNode.create(this._getOwnerKey(), classNameToken);
                 this._getNextToken();
             }
         }
         const pattern = this._parsePatternAs();
-        return parseNodes_1.PatternClassArgumentNode.create(pattern, keywordName);
+        return parseNodes_1.PatternClassArgumentNode.create(this._getOwnerKey(), pattern, keywordName);
     }
     // literal_pattern:
     //     | signed_number
@@ -935,14 +963,14 @@ class Parser {
                     this._addSyntaxError(localize_1.LocMessage.formatStringInPattern(), stringAtom);
                 }
             });
-            return parseNodes_1.PatternLiteralNode.create(stringList);
+            return parseNodes_1.PatternLiteralNode.create(this._getOwnerKey(), stringList);
         }
         if (nextToken.type === 8 /* TokenType.Keyword */) {
             const keywordToken = nextToken;
             if (keywordToken.keywordType === 15 /* KeywordType.False */ ||
                 keywordToken.keywordType === 34 /* KeywordType.True */ ||
                 keywordToken.keywordType === 27 /* KeywordType.None */) {
-                return parseNodes_1.PatternLiteralNode.create(this._parseAtom());
+                return parseNodes_1.PatternLiteralNode.create(this._getOwnerKey(), this._parseAtom());
             }
         }
         return undefined;
@@ -978,7 +1006,7 @@ class Parser {
                 this._addSyntaxError(localize_1.LocMessage.expectedComplexNumberLiteral(), expression);
             }
         }
-        return parseNodes_1.PatternLiteralNode.create(expression);
+        return parseNodes_1.PatternLiteralNode.create(this._getOwnerKey(), expression);
     }
     _parsePatternMapping(firstToken) {
         const itemList = this._parseExpressionListGeneric(() => this._parsePatternMappingItem());
@@ -988,9 +1016,10 @@ class Parser {
             if (starStarEntries.length > 1) {
                 this._addSyntaxError(localize_1.LocMessage.duplicateStarStarPattern(), starStarEntries[1]);
             }
-            return parseNodes_1.PatternMappingNode.create(firstToken, itemList.list);
+            return parseNodes_1.PatternMappingNode.create(this._getOwnerKey(), firstToken, itemList.list);
         }
-        return itemList.parseError || parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
+        return (itemList.parseError ||
+            parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */));
     }
     // key_value_pattern:
     //     | (literal_pattern | attr) ':' as_pattern
@@ -1002,13 +1031,13 @@ class Parser {
             const identifierToken = this._getTokenIfIdentifier();
             if (!identifierToken) {
                 this._addSyntaxError(localize_1.LocMessage.expectedIdentifier(), this._peekToken());
-                return parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
+                return parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
             }
-            const nameNode = parseNodes_1.NameNode.create(identifierToken);
+            const nameNode = parseNodes_1.NameNode.create(this._getOwnerKey(), identifierToken);
             if (identifierToken.value === '_') {
                 this._addSyntaxError(localize_1.LocMessage.starStarWildcardNotAllowed(), nameNode);
             }
-            return parseNodes_1.PatternMappingExpandEntryNode.create(doubleStar, nameNode);
+            return parseNodes_1.PatternMappingExpandEntryNode.create(this._getOwnerKey(), doubleStar, nameNode);
         }
         const patternLiteral = this._parsePatternLiteral();
         if (patternLiteral) {
@@ -1022,23 +1051,23 @@ class Parser {
                 }
                 else {
                     this._addSyntaxError(localize_1.LocMessage.expectedPatternValue(), patternCaptureOrValue);
-                    keyExpression = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
+                    keyExpression = parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
                 }
             }
         }
         if (!keyExpression) {
             this._addSyntaxError(localize_1.LocMessage.expectedPatternExpr(), this._peekToken());
-            keyExpression = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
+            keyExpression = parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
         }
         let valuePattern;
         if (!this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             this._addSyntaxError(localize_1.LocMessage.expectedColon(), this._peekToken());
-            valuePattern = parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
+            valuePattern = parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
         }
         else {
             valuePattern = this._parsePatternAs();
         }
-        return parseNodes_1.PatternMappingKeyEntryNode.create(keyExpression, valuePattern);
+        return parseNodes_1.PatternMappingKeyEntryNode.create(this._getOwnerKey(), keyExpression, valuePattern);
     }
     _parsePatternCaptureOrValue() {
         const nextToken = this._peekToken();
@@ -1047,8 +1076,10 @@ class Parser {
             while (true) {
                 const identifierToken = this._getTokenIfIdentifier();
                 if (identifierToken) {
-                    const nameNode = parseNodes_1.NameNode.create(identifierToken);
-                    nameOrMember = nameOrMember ? parseNodes_1.MemberAccessNode.create(nameOrMember, nameNode) : nameNode;
+                    const nameNode = parseNodes_1.NameNode.create(this._getOwnerKey(), identifierToken);
+                    nameOrMember = nameOrMember
+                        ? parseNodes_1.MemberAccessNode.create(this._getOwnerKey(), nameOrMember, nameNode)
+                        : nameNode;
                 }
                 else {
                     this._addSyntaxError(localize_1.LocMessage.expectedIdentifier(), this._peekToken());
@@ -1060,12 +1091,12 @@ class Parser {
             }
             if (!nameOrMember) {
                 this._addSyntaxError(localize_1.LocMessage.expectedIdentifier(), this._peekToken());
-                return parseNodes_1.ErrorNode.create(this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
+                return parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 11 /* ErrorExpressionCategory.MissingPattern */);
             }
             if (nameOrMember.nodeType === 35 /* ParseNodeType.MemberAccess */) {
-                return parseNodes_1.PatternValueNode.create(nameOrMember);
+                return parseNodes_1.PatternValueNode.create(this._getOwnerKey(), nameOrMember);
             }
-            return parseNodes_1.PatternCaptureNode.create(nameOrMember);
+            return parseNodes_1.PatternCaptureNode.create(this._getOwnerKey(), nameOrMember);
         }
         return undefined;
     }
@@ -1076,7 +1107,7 @@ class Parser {
         const ifOrElifToken = this._getKeywordToken(keywordType);
         const test = this._parseTestExpression(/* allowAssignmentExpression */ true);
         const suite = this._parseSuite(this._isInFunction);
-        const ifNode = parseNodes_1.IfNode.create(ifOrElifToken, test, suite);
+        const ifNode = parseNodes_1.IfNode.create(this._getOwnerKey(), ifOrElifToken, test, suite);
         if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
             ifNode.d.elseSuite = this._parseSuite(this._isInFunction);
             ifNode.d.elseSuite.parent = ifNode;
@@ -1127,7 +1158,7 @@ class Parser {
     // suite: ':' (simple_stmt | NEWLINE INDENT stmt+ DEDENT)
     _parseSuite(isFunction = false, skipBody = false, postColonCallback) {
         const nextToken = this._peekToken();
-        const suite = parseNodes_1.SuiteNode.create(nextToken);
+        const suite = parseNodes_1.SuiteNode.create(this._getOwnerKey(), nextToken);
         if (!this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             this._addSyntaxError(localize_1.LocMessage.expectedColon(), nextToken);
             // Try to perform parse recovery by consuming tokens.
@@ -1193,6 +1224,31 @@ class Parser {
                 this._addSyntaxError(localize_1.LocMessage.inconsistentTabs(), bodyIndentToken);
             }
             while (true) {
+                // In notebook mode, an IPython magic or shell-escape line is consumed into a
+                // comment, which can leave a bare NewLine token at the start of a suite body.
+                // Skip such blank lines like the module-level loop does so they aren't misparsed
+                // as an empty statement (which would report a spurious "expected expression").
+                if (this._parseOptions.useNotebookMode && this._peekTokenType() === 2 /* TokenType.NewLine */) {
+                    this._getNextToken();
+                    // If the magic/blank line(s) were the entire suite body, this is a valid empty
+                    // suite. Report any indentation inconsistency on the terminating dedent (shared
+                    // with the normal dedent branch below via _reportDedentInconsistencies), then consume
+                    // the dedent so it doesn't bubble up to the enclosing scope (which would otherwise
+                    // report a spurious "unindent not expected"). Unlike the normal dedent branch,
+                    // which leaves an empty suite's dedent unconsumed for multi-level recovery, a
+                    // magic-only suite is a valid empty suite and consumes its own dedent here.
+                    if (this._peekTokenType() === 4 /* TokenType.Dedent */ && suite.d.statements.length === 0) {
+                        const dedentToken = this._peekToken();
+                        this._reportDedentInconsistencies(dedentToken);
+                        this._getNextToken();
+                        (0, parseNodes_1.extendRange)(suite, dedentToken);
+                        break;
+                    }
+                    if (this._peekTokenType() === 1 /* TokenType.EndOfStream */) {
+                        break;
+                    }
+                    continue;
+                }
                 // Handle a common error here and see if we can recover.
                 const nextToken = this._peekToken();
                 if (nextToken.type === 3 /* TokenType.Indent */) {
@@ -1208,12 +1264,7 @@ class Parser {
                 else if (nextToken.type === 4 /* TokenType.Dedent */) {
                     // When we see a dedent, stop before parsing the dedented statement.
                     const dedentToken = nextToken;
-                    if (!dedentToken.matchesIndent) {
-                        this._addSyntaxError(localize_1.LocMessage.inconsistentIndent(), dedentToken);
-                    }
-                    if (dedentToken.isDedentAmbiguous) {
-                        this._addSyntaxError(localize_1.LocMessage.inconsistentTabs(), dedentToken);
-                    }
+                    this._reportDedentInconsistencies(dedentToken);
                     // When the suite is incomplete (no statements), leave the dedent token for
                     // recovery. This allows a single dedent token to cause us to break out of
                     // multiple levels of nested suites. Also extend the suite's range in this
@@ -1265,6 +1316,17 @@ class Parser {
         this._isInFunction = wasFunction;
         return suite;
     }
+    // Reports indentation inconsistencies (inconsistent indent / ambiguous tabs) for a terminating
+    // dedent token. Shared by _parseSuite's notebook-mode empty-suite branch and its normal dedent
+    // branch so the two sites can't drift apart.
+    _reportDedentInconsistencies(dedentToken) {
+        if (!dedentToken.matchesIndent) {
+            this._addSyntaxError(localize_1.LocMessage.inconsistentIndent(), dedentToken);
+        }
+        if (dedentToken.isDedentAmbiguous) {
+            this._addSyntaxError(localize_1.LocMessage.inconsistentTabs(), dedentToken);
+        }
+    }
     // for_stmt: [async] 'for' exprlist 'in' testlist suite ['else' suite]
     _parseForStatement(asyncToken) {
         const forToken = this._getKeywordToken(17 /* KeywordType.For */);
@@ -1274,7 +1336,7 @@ class Parser {
         let elseSuite;
         if (!this._consumeTokenIfKeyword(22 /* KeywordType.In */)) {
             seqExpr = this._handleExpressionParseError(0 /* ErrorExpressionCategory.MissingIn */, localize_1.LocMessage.expectedIn());
-            forSuite = parseNodes_1.SuiteNode.create(this._peekToken());
+            forSuite = parseNodes_1.SuiteNode.create(this._getOwnerKey(), textRange_1.TextRange.create(this._peekToken().start, /* length */ 0));
         }
         else {
             seqExpr = this._parseTestOrStarListAsExpression(
@@ -1299,7 +1361,7 @@ class Parser {
                 elseSuite = this._parseSuite(this._isInFunction);
             }
         }
-        const forNode = parseNodes_1.ForNode.create(forToken, targetExpr, seqExpr, forSuite);
+        const forNode = parseNodes_1.ForNode.create(this._getOwnerKey(), forToken, targetExpr, seqExpr, forSuite);
         forNode.d.elseSuite = elseSuite;
         if (elseSuite) {
             (0, parseNodes_1.extendRange)(forNode, elseSuite);
@@ -1327,7 +1389,7 @@ class Parser {
         else if (target.nodeType === 19 /* ParseNodeType.DictionaryExpandEntry */) {
             this._addSyntaxError(localize_1.LocMessage.dictExpandIllegalInComprehension(), target);
         }
-        const compNode = parseNodes_1.ComprehensionNode.create(target, isGenerator);
+        const compNode = parseNodes_1.ComprehensionNode.create(this._getOwnerKey(), target, isGenerator);
         const forIfList = [compFor];
         while (true) {
             const compIter = this._tryParseCompForStatement() || this._tryParseCompIfStatement();
@@ -1373,7 +1435,7 @@ class Parser {
                 seqExpr = this._parseOrTest();
             });
         }
-        const compForNode = parseNodes_1.ComprehensionForNode.create(asyncToken || forToken, targetExpr, seqExpr);
+        const compForNode = parseNodes_1.ComprehensionForNode.create(this._getOwnerKey(), asyncToken || forToken, targetExpr, seqExpr);
         if (asyncToken) {
             compForNode.d.isAsync = true;
             compForNode.d.asyncToken = asyncToken;
@@ -1389,13 +1451,13 @@ class Parser {
         const ifToken = this._getKeywordToken(20 /* KeywordType.If */);
         const ifExpr = this._tryParseLambdaExpression() ||
             this._parseAssignmentExpression(/* disallowAssignmentExpression */ true);
-        const compIfNode = parseNodes_1.ComprehensionIfNode.create(ifToken, ifExpr);
+        const compIfNode = parseNodes_1.ComprehensionIfNode.create(this._getOwnerKey(), ifToken, ifExpr);
         return compIfNode;
     }
     // while_stmt: 'while' test suite ['else' suite]
     _parseWhileStatement() {
         const whileToken = this._getKeywordToken(37 /* KeywordType.While */);
-        const whileNode = parseNodes_1.WhileNode.create(whileToken, this._parseTestExpression(/* allowAssignmentExpression */ true), this._parseLoopSuite());
+        const whileNode = parseNodes_1.WhileNode.create(this._getOwnerKey(), whileToken, this._parseTestExpression(/* allowAssignmentExpression */ true), this._parseLoopSuite());
         if (this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
             whileNode.d.elseSuite = this._parseSuite(this._isInFunction);
             whileNode.d.elseSuite.parent = whileNode;
@@ -1412,7 +1474,7 @@ class Parser {
     _parseTryStatement() {
         const tryToken = this._getKeywordToken(35 /* KeywordType.Try */);
         const trySuite = this._parseSuite(this._isInFunction);
-        const tryNode = parseNodes_1.TryNode.create(tryToken, trySuite);
+        const tryNode = parseNodes_1.TryNode.create(this._getOwnerKey(), tryToken, trySuite);
         let sawCatchAllExcept = false;
         let reportedExceptGroupMismatch = false;
         while (true) {
@@ -1484,13 +1546,13 @@ class Parser {
                 }
             }
             const exceptSuite = this._parseExceptSuite(isExceptGroup, () => this._parseSuite(this._isInFunction));
-            const exceptNode = parseNodes_1.ExceptNode.create(exceptToken, exceptSuite, isExceptGroup);
+            const exceptNode = parseNodes_1.ExceptNode.create(this._getOwnerKey(), exceptToken, exceptSuite, isExceptGroup);
             if (typeExpr) {
                 exceptNode.d.typeExpr = typeExpr;
                 exceptNode.d.typeExpr.parent = exceptNode;
             }
             if (symbolName) {
-                exceptNode.d.name = parseNodes_1.NameNode.create(symbolName);
+                exceptNode.d.name = parseNodes_1.NameNode.create(this._getOwnerKey(), symbolName);
                 exceptNode.d.name.parent = exceptNode;
             }
             tryNode.d.exceptClauses.push(exceptNode);
@@ -1527,7 +1589,7 @@ class Parser {
         const nameToken = this._getTokenIfIdentifier();
         if (!nameToken) {
             this._addSyntaxError(localize_1.LocMessage.expectedFunctionName(), defToken);
-            return parseNodes_1.ErrorNode.create(defToken, 10 /* ErrorExpressionCategory.MissingFunctionParameterList */, undefined, decorators);
+            return parseNodes_1.ErrorNode.create(this._getOwnerKey(), defToken, 10 /* ErrorExpressionCategory.MissingFunctionParameterList */, undefined, decorators);
         }
         let typeParameters;
         const possibleOpenBracket = this._peekToken();
@@ -1541,7 +1603,7 @@ class Parser {
         const openParenToken = this._peekToken();
         if (!this._consumeTokenIfType(13 /* TokenType.OpenParenthesis */)) {
             this._addSyntaxError(localize_1.LocMessage.expectedOpenParen(), this._peekToken());
-            return parseNodes_1.ErrorNode.create(nameToken, 10 /* ErrorExpressionCategory.MissingFunctionParameterList */, parseNodes_1.NameNode.create(nameToken), decorators);
+            return parseNodes_1.ErrorNode.create(this._getOwnerKey(), nameToken, 10 /* ErrorExpressionCategory.MissingFunctionParameterList */, parseNodes_1.NameNode.create(this._getOwnerKey(), nameToken), decorators);
         }
         const paramList = this._parseVarArgsList(14 /* TokenType.CloseParenthesis */, /* allowAnnotations */ true);
         if (!this._consumeTokenIfType(14 /* TokenType.CloseParenthesis */)) {
@@ -1567,7 +1629,7 @@ class Parser {
         this._isInExceptionGroup = wasInExceptionGroup;
         this._isInFinallyBlock = wasInFinallyBlock;
         this._isInFinallyLoop = wasInFinallyLoop;
-        const functionNode = parseNodes_1.FunctionNode.create(defToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
+        const functionNode = parseNodes_1.FunctionNode.create(this._getOwnerKey(), defToken, parseNodes_1.NameNode.create(this._getOwnerKey(), nameToken), suite, typeParameters);
         if (asyncToken) {
             functionNode.d.isAsync = true;
             (0, parseNodes_1.extendRange)(functionNode, asyncToken);
@@ -1744,11 +1806,11 @@ class Parser {
         const paramName = this._getTokenIfIdentifier();
         if (!paramName) {
             if (starCount === 1) {
-                const paramNode = parseNodes_1.ParameterNode.create(firstToken, 1 /* ParamCategory.ArgsList */);
+                const paramNode = parseNodes_1.ParameterNode.create(this._getOwnerKey(), firstToken, 1 /* ParamCategory.ArgsList */);
                 return paramNode;
             }
             else if (slashCount === 1) {
-                const paramNode = parseNodes_1.ParameterNode.create(firstToken, 0 /* ParamCategory.Simple */);
+                const paramNode = parseNodes_1.ParameterNode.create(this._getOwnerKey(), firstToken, 0 /* ParamCategory.Simple */);
                 return paramNode;
             }
             // Check for the Python 2.x parameter sublist syntax and handle it gracefully.
@@ -1770,9 +1832,9 @@ class Parser {
         else if (starCount === 2) {
             paramType = 2 /* ParamCategory.KwargsDict */;
         }
-        const paramNode = parseNodes_1.ParameterNode.create(firstToken, paramType);
+        const paramNode = parseNodes_1.ParameterNode.create(this._getOwnerKey(), firstToken, paramType);
         if (paramName) {
-            paramNode.d.name = parseNodes_1.NameNode.create(paramName);
+            paramNode.d.name = parseNodes_1.NameNode.create(this._getOwnerKey(), paramName);
             paramNode.d.name.parent = paramNode;
             (0, parseNodes_1.extendRange)(paramNode, paramName);
         }
@@ -1855,7 +1917,7 @@ class Parser {
                 typeComment = comment;
             }
         });
-        const withNode = parseNodes_1.WithNode.create(withToken, withSuite);
+        const withNode = parseNodes_1.WithNode.create(this._getOwnerKey(), withToken, withSuite);
         if (asyncToken) {
             withNode.d.isAsync = true;
             withNode.d.asyncToken = asyncToken;
@@ -1873,7 +1935,7 @@ class Parser {
     // with_item: test ['as' expr]
     _parseWithItem() {
         const expr = this._parseTestExpression(/* allowAssignmentExpression */ true);
-        const itemNode = parseNodes_1.WithItemNode.create(expr);
+        const itemNode = parseNodes_1.WithItemNode.create(this._getOwnerKey(), expr);
         if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
             itemNode.d.target = this._parseExpression(/* allowUnpack */ false);
             itemNode.d.target.parent = itemNode;
@@ -1914,7 +1976,7 @@ class Parser {
         this._addSyntaxError(localize_1.LocMessage.expectedAfterDecorator(), this._peekToken());
         // Return a dummy class declaration so the completion provider has
         // some parse nodes to work with.
-        return parseNodes_1.ClassNode.createDummyForDecorators(decoratorList);
+        return parseNodes_1.ClassNode.createDummyForDecorators(this._getOwnerKey(), decoratorList);
     }
     // decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
     _parseDecorator() {
@@ -1936,7 +1998,7 @@ class Parser {
                 this._addSyntaxError(localize_1.LocMessage.expectedDecoratorExpr(), expression);
             }
         }
-        const decoratorNode = parseNodes_1.DecoratorNode.create(atOperator, expression);
+        const decoratorNode = parseNodes_1.DecoratorNode.create(this._getOwnerKey(), atOperator, expression);
         if (!this._consumeTokenIfType(2 /* TokenType.NewLine */)) {
             this._addSyntaxError(localize_1.LocMessage.expectedDecoratorNewline(), this._peekToken());
             this._consumeTokensUntilType([2 /* TokenType.NewLine */]);
@@ -1978,7 +2040,7 @@ class Parser {
             }
         }
         const suite = this._parseSuite(/* isFunction */ false, this._parseOptions.skipFunctionAndClassBody);
-        const classNode = parseNodes_1.ClassNode.create(classToken, parseNodes_1.NameNode.create(nameToken), suite, typeParameters);
+        const classNode = parseNodes_1.ClassNode.create(this._getOwnerKey(), classToken, parseNodes_1.NameNode.create(this._getOwnerKey(), nameToken), suite, typeParameters);
         classNode.d.arguments = argList;
         argList.forEach((arg) => {
             arg.parent = classNode;
@@ -1995,7 +2057,7 @@ class Parser {
         return classNode;
     }
     _parsePassStatement() {
-        return parseNodes_1.PassNode.create(this._getKeywordToken(31 /* KeywordType.Pass */));
+        return parseNodes_1.PassNode.create(this._getOwnerKey(), this._getKeywordToken(31 /* KeywordType.Pass */));
     }
     _parseBreakStatement() {
         const breakToken = this._getKeywordToken(5 /* KeywordType.Break */);
@@ -2008,7 +2070,7 @@ class Parser {
         if (this._isInFinallyLoop && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
             this._addSyntaxError(localize_1.LocMessage.finallyBreak(), breakToken);
         }
-        return parseNodes_1.BreakNode.create(breakToken);
+        return parseNodes_1.BreakNode.create(this._getOwnerKey(), breakToken);
     }
     _parseContinueStatement() {
         const continueToken = this._getKeywordToken(8 /* KeywordType.Continue */);
@@ -2021,12 +2083,12 @@ class Parser {
         if (this._isInFinallyLoop && pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_14)) {
             this._addSyntaxError(localize_1.LocMessage.finallyContinue(), continueToken);
         }
-        return parseNodes_1.ContinueNode.create(continueToken);
+        return parseNodes_1.ContinueNode.create(this._getOwnerKey(), continueToken);
     }
     // return_stmt: 'return' [testlist]
     _parseReturnStatement() {
         const returnToken = this._getKeywordToken(33 /* KeywordType.Return */);
-        const returnNode = parseNodes_1.ReturnNode.create(returnToken);
+        const returnNode = parseNodes_1.ReturnNode.create(this._getOwnerKey(), returnToken);
         if (!this._isInFunction) {
             this._addSyntaxError(localize_1.LocMessage.returnOutsideFunction(), returnToken);
         }
@@ -2054,7 +2116,7 @@ class Parser {
     _parseFromStatement() {
         const fromToken = this._getKeywordToken(18 /* KeywordType.From */);
         const modName = this._parseDottedModuleName(/* allowJustDots */ true);
-        const importFromNode = parseNodes_1.ImportFromNode.create(fromToken, modName);
+        const importFromNode = parseNodes_1.ImportFromNode.create(this._getOwnerKey(), fromToken, modName);
         // Handle imports from __future__ specially because they can
         // change the way we interpret the rest of the file.
         const isFutureImport = modName.d.leadingDots === 0 &&
@@ -2087,14 +2149,14 @@ class Parser {
                         break;
                     }
                     trailingCommaToken = undefined;
-                    const importFromAsNode = parseNodes_1.ImportFromAsNode.create(parseNodes_1.NameNode.create(importName));
+                    const importFromAsNode = parseNodes_1.ImportFromAsNode.create(this._getOwnerKey(), parseNodes_1.NameNode.create(this._getOwnerKey(), importName));
                     if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
                         const aliasName = this._getTokenIfIdentifier();
                         if (!aliasName) {
                             this._addSyntaxError(localize_1.LocMessage.expectedImportAlias(), this._peekToken());
                         }
                         else {
-                            importFromAsNode.d.alias = parseNodes_1.NameNode.create(aliasName);
+                            importFromAsNode.d.alias = parseNodes_1.NameNode.create(this._getOwnerKey(), aliasName);
                             importFromAsNode.d.alias.parent = importFromAsNode;
                             (0, parseNodes_1.extendRange)(importFromAsNode, aliasName);
                         }
@@ -2165,14 +2227,14 @@ class Parser {
     // dotted_as_name: dotted_name ['as' NAME]
     _parseImportStatement() {
         const importToken = this._getKeywordToken(21 /* KeywordType.Import */);
-        const importNode = parseNodes_1.ImportNode.create(importToken);
+        const importNode = parseNodes_1.ImportNode.create(this._getOwnerKey(), importToken);
         while (true) {
             const modName = this._parseDottedModuleName();
-            const importAsNode = parseNodes_1.ImportAsNode.create(modName);
+            const importAsNode = parseNodes_1.ImportAsNode.create(this._getOwnerKey(), modName);
             if (this._consumeTokenIfKeyword(1 /* KeywordType.As */)) {
                 const aliasToken = this._getTokenIfIdentifier();
                 if (aliasToken) {
-                    importAsNode.d.alias = parseNodes_1.NameNode.create(aliasToken);
+                    importAsNode.d.alias = parseNodes_1.NameNode.create(this._getOwnerKey(), aliasToken);
                     importAsNode.d.alias.parent = importAsNode;
                     (0, parseNodes_1.extendRange)(importAsNode, importAsNode.d.alias);
                 }
@@ -2226,7 +2288,7 @@ class Parser {
     // ('.' | '...')* dotted_name | ('.' | '...')+
     // dotted_name: NAME ('.' NAME)*
     _parseDottedModuleName(allowJustDots = false) {
-        const moduleNameNode = parseNodes_1.ModuleNameNode.create(this._peekToken());
+        const moduleNameNode = parseNodes_1.ModuleNameNode.create(this._getOwnerKey(), this._peekToken());
         while (true) {
             const token = this._getTokenIfType(19 /* TokenType.Ellipsis */) ?? this._getTokenIfType(20 /* TokenType.Dot */);
             if (token) {
@@ -2251,7 +2313,7 @@ class Parser {
                 }
                 break;
             }
-            const namePart = parseNodes_1.NameNode.create(identifier);
+            const namePart = parseNodes_1.NameNode.create(this._getOwnerKey(), identifier);
             moduleNameNode.d.nameParts.push(namePart);
             namePart.parent = moduleNameNode;
             (0, parseNodes_1.extendRange)(moduleNameNode, namePart);
@@ -2266,7 +2328,7 @@ class Parser {
     }
     _parseGlobalStatement() {
         const globalToken = this._getKeywordToken(19 /* KeywordType.Global */);
-        const globalNode = parseNodes_1.GlobalNode.create(globalToken);
+        const globalNode = parseNodes_1.GlobalNode.create(this._getOwnerKey(), globalToken);
         globalNode.d.targets = this._parseNameList();
         if (globalNode.d.targets.length > 0) {
             globalNode.d.targets.forEach((name) => {
@@ -2278,7 +2340,7 @@ class Parser {
     }
     _parseNonlocalStatement() {
         const nonlocalToken = this._getKeywordToken(28 /* KeywordType.Nonlocal */);
-        const nonlocalNode = parseNodes_1.NonlocalNode.create(nonlocalToken);
+        const nonlocalNode = parseNodes_1.NonlocalNode.create(this._getOwnerKey(), nonlocalToken);
         nonlocalNode.d.targets = this._parseNameList();
         if (nonlocalNode.d.targets.length > 0) {
             nonlocalNode.d.targets.forEach((name) => {
@@ -2296,7 +2358,7 @@ class Parser {
                 this._addSyntaxError(localize_1.LocMessage.expectedIdentifier(), this._peekToken());
                 break;
             }
-            nameList.push(parseNodes_1.NameNode.create(name));
+            nameList.push(parseNodes_1.NameNode.create(this._getOwnerKey(), name));
             if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
                 break;
             }
@@ -2307,7 +2369,7 @@ class Parser {
     // (old) raise_stmt: 'raise' [test [',' test [',' test]]]
     _parseRaiseStatement() {
         const raiseToken = this._getKeywordToken(32 /* KeywordType.Raise */);
-        const raiseNode = parseNodes_1.RaiseNode.create(raiseToken);
+        const raiseNode = parseNodes_1.RaiseNode.create(this._getOwnerKey(), raiseToken);
         if (!this._isNextTokenNeverExpression()) {
             raiseNode.d.expr = this._parseTestExpression(/* allowAssignmentExpression */ true);
             raiseNode.d.expr.parent = raiseNode;
@@ -2324,7 +2386,7 @@ class Parser {
     _parseAssertStatement() {
         const assertToken = this._getKeywordToken(2 /* KeywordType.Assert */);
         const expr = this._parseTestExpression(/* allowAssignmentExpression */ false);
-        const assertNode = parseNodes_1.AssertNode.create(assertToken, expr);
+        const assertNode = parseNodes_1.AssertNode.create(this._getOwnerKey(), assertToken, expr);
         if (this._consumeTokenIfType(12 /* TokenType.Comma */)) {
             const exceptionExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
             assertNode.d.exceptionExpr = exceptionExpr;
@@ -2340,7 +2402,7 @@ class Parser {
         if (!exprListResult.parseError && exprListResult.list.length === 0) {
             this._addSyntaxError(localize_1.LocMessage.expectedDelExpr(), this._peekToken());
         }
-        const delNode = parseNodes_1.DelNode.create(delToken);
+        const delNode = parseNodes_1.DelNode.create(this._getOwnerKey(), delToken);
         delNode.d.targets = exprListResult.list;
         if (delNode.d.targets.length > 0) {
             delNode.d.targets.forEach((expr) => {
@@ -2359,7 +2421,7 @@ class Parser {
             if (pythonVersion_1.PythonVersion.isLessThan(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_3)) {
                 this._addSyntaxError(localize_1.LocMessage.yieldFromIllegal(), nextToken);
             }
-            return parseNodes_1.YieldFromNode.create(yieldToken, this._parseTestExpression(/* allowAssignmentExpression */ false));
+            return parseNodes_1.YieldFromNode.create(this._getOwnerKey(), yieldToken, this._parseTestExpression(/* allowAssignmentExpression */ false));
         }
         let exprList;
         if (!this._isNextTokenNeverExpression()) {
@@ -2368,7 +2430,7 @@ class Parser {
             /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedYieldExpr());
             this._reportConditionalErrorForStarTupleElement(exprList);
         }
-        return parseNodes_1.YieldNode.create(yieldToken, exprList);
+        return parseNodes_1.YieldNode.create(this._getOwnerKey(), yieldToken, exprList);
     }
     _tryParseYieldExpression() {
         if (this._peekKeywordType() !== 39 /* KeywordType.Yield */) {
@@ -2378,7 +2440,7 @@ class Parser {
     }
     // simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
     _parseSimpleStatement() {
-        const statement = parseNodes_1.StatementListNode.create(this._peekToken());
+        const statement = parseNodes_1.StatementListNode.create(this._getOwnerKey(), this._peekToken());
         while (true) {
             // Swallow invalid tokens to make sure we make forward progress.
             if (this._peekTokenType() === 0 /* TokenType.Invalid */) {
@@ -2501,7 +2563,7 @@ class Parser {
         // To accommodate empty tuples ("()"), we will reach back to get
         // the opening parenthesis as the opening token.
         const tupleStartRange = exprListResult.list.length > 0 ? exprListResult.list[0] : this._peekToken(-1);
-        const tupleNode = parseNodes_1.TupleNode.create(tupleStartRange, enclosedInParens);
+        const tupleNode = parseNodes_1.TupleNode.create(this._getOwnerKey(), tupleStartRange, enclosedInParens);
         tupleNode.d.items = exprListResult.list;
         if (exprListResult.list.length > 0) {
             exprListResult.list.forEach((expr) => {
@@ -2514,7 +2576,7 @@ class Parser {
     _parseExpressionListAsPossibleTuple(errorCategory, getErrorString, errorToken) {
         if (this._isNextTokenNeverExpression()) {
             this._addSyntaxError(getErrorString(), errorToken);
-            return parseNodes_1.ErrorNode.create(errorToken, errorCategory);
+            return parseNodes_1.ErrorNode.create(this._getOwnerKey(), errorToken, errorCategory);
         }
         const exprListResult = this._parseExpressionList(/* allowStar */ true);
         if (exprListResult.parseError) {
@@ -2571,7 +2633,7 @@ class Parser {
     _parseExpression(allowUnpack) {
         const startToken = this._peekToken();
         if (allowUnpack && this._consumeTokenIfOperator(26 /* OperatorType.Multiply */)) {
-            return parseNodes_1.UnpackNode.create(startToken, this._parseExpression(/* allowUnpack */ false));
+            return parseNodes_1.UnpackNode.create(this._getOwnerKey(), startToken, this._parseExpression(/* allowUnpack */ false));
         }
         return this._parseBitwiseOrExpression();
     }
@@ -2599,10 +2661,10 @@ class Parser {
             return testExpr;
         }
         if (!this._consumeTokenIfKeyword(13 /* KeywordType.Else */)) {
-            return parseNodes_1.TernaryNode.create(ifExpr, testExpr, this._handleExpressionParseError(1 /* ErrorExpressionCategory.MissingElse */, localize_1.LocMessage.expectedElse()));
+            return parseNodes_1.TernaryNode.create(this._getOwnerKey(), ifExpr, testExpr, this._handleExpressionParseError(1 /* ErrorExpressionCategory.MissingElse */, localize_1.LocMessage.expectedElse()));
         }
         const elseExpr = this._parseTestExpression(/* allowAssignmentExpression */ true);
-        return parseNodes_1.TernaryNode.create(ifExpr, testExpr, elseExpr);
+        return parseNodes_1.TernaryNode.create(this._getOwnerKey(), ifExpr, testExpr, elseExpr);
     }
     // assign_expr: NAME := test
     _parseAssignmentExpression(disallowAssignmentExpression = false) {
@@ -2624,7 +2686,7 @@ class Parser {
             this._addSyntaxError(localize_1.LocMessage.walrusIllegal(), walrusToken);
         }
         const rightExpr = this._parseTestExpression(/* allowAssignmentExpression */ false);
-        return parseNodes_1.AssignmentExpressionNode.create(leftExpr, walrusToken, rightExpr);
+        return parseNodes_1.AssignmentExpressionNode.create(this._getOwnerKey(), leftExpr, walrusToken, rightExpr);
     }
     // or_test: and_test ('or' and_test)*
     _parseOrTest() {
@@ -2885,7 +2947,7 @@ class Parser {
                 const wasParsingTypeAnnotation = this._isParsingTypeAnnotation;
                 this._isParsingTypeAnnotation = false;
                 const argListResult = this._parseArgList();
-                const callNode = parseNodes_1.CallNode.create(atomExpression, argListResult.args, argListResult.trailingComma);
+                const callNode = parseNodes_1.CallNode.create(this._getOwnerKey(), atomExpression, argListResult.args, argListResult.trailingComma);
                 if (argListResult.args.length > 1 || argListResult.trailingComma) {
                     argListResult.args.forEach((arg) => {
                         if (arg.d.valueExpr.nodeType === 11 /* ParseNodeType.Comprehension */) {
@@ -2913,7 +2975,7 @@ class Parser {
                 this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
                 const maxDepth = this._maxChildDepthMap.get(atomExpression.id) ?? 0;
                 if (maxDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(callNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
+                    atomExpression = parseNodes_1.ErrorNode.create(this._getOwnerKey(), callNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
                 }
                 else {
@@ -2941,7 +3003,7 @@ class Parser {
                 this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
                 this._isParsingIndexTrailer = wasParsingIndexTrailer;
                 const closingToken = this._peekToken();
-                const indexNode = parseNodes_1.IndexNode.create(atomExpression, subscriptList.list, subscriptList.trailingComma, closingToken);
+                const indexNode = parseNodes_1.IndexNode.create(this._getOwnerKey(), atomExpression, subscriptList.list, subscriptList.trailingComma, closingToken);
                 (0, parseNodes_1.extendRange)(indexNode, indexNode);
                 if (!this._consumeTokenIfType(16 /* TokenType.CloseBracket */)) {
                     // Handle the error case, but don't use the error node in this
@@ -2950,7 +3012,7 @@ class Parser {
                 }
                 const maxDepth = this._maxChildDepthMap.get(atomExpression.id) ?? 0;
                 if (maxDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(indexNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
+                    atomExpression = parseNodes_1.ErrorNode.create(this._getOwnerKey(), indexNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
                 }
                 else {
@@ -2964,10 +3026,10 @@ class Parser {
                 if (!memberName) {
                     return this._handleExpressionParseError(7 /* ErrorExpressionCategory.MissingMemberAccessName */, localize_1.LocMessage.expectedMemberName(), startOfTrailerToken, atomExpression, [8 /* TokenType.Keyword */]);
                 }
-                const memberAccessNode = parseNodes_1.MemberAccessNode.create(atomExpression, parseNodes_1.NameNode.create(memberName));
+                const memberAccessNode = parseNodes_1.MemberAccessNode.create(this._getOwnerKey(), atomExpression, parseNodes_1.NameNode.create(this._getOwnerKey(), memberName));
                 const maxDepth = this._maxChildDepthMap.get(atomExpression.id) ?? 0;
                 if (maxDepth >= maxChildNodeDepth) {
-                    atomExpression = parseNodes_1.ErrorNode.create(memberAccessNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
+                    atomExpression = parseNodes_1.ErrorNode.create(this._getOwnerKey(), memberAccessNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
                 }
                 else {
@@ -2980,7 +3042,7 @@ class Parser {
             }
         }
         if (awaitToken) {
-            return parseNodes_1.AwaitNode.create(awaitToken, atomExpression);
+            return parseNodes_1.AwaitNode.create(this._getOwnerKey(), awaitToken, atomExpression);
         }
         return atomExpression;
     }
@@ -3027,9 +3089,9 @@ class Parser {
                     }
                 }
             }
-            const argNode = parseNodes_1.ArgumentNode.create(firstToken, valueExpr, argType);
+            const argNode = parseNodes_1.ArgumentNode.create(this._getOwnerKey(), firstToken, valueExpr, argType);
             if (nameIdentifier) {
-                argNode.d.name = parseNodes_1.NameNode.create(nameIdentifier);
+                argNode.d.name = parseNodes_1.NameNode.create(this._getOwnerKey(), nameIdentifier);
                 argNode.d.name.parent = argNode;
             }
             if (argNode.d.name) {
@@ -3064,7 +3126,7 @@ class Parser {
             const errorNode = this._handleExpressionParseError(3 /* ErrorExpressionCategory.MissingIndexOrSlice */, localize_1.LocMessage.expectedSliceIndex(), 
             /* targetToken */ undefined, 
             /* childNode */ undefined, [16 /* TokenType.CloseBracket */]);
-            argList.push(parseNodes_1.ArgumentNode.create(this._peekToken(), errorNode, 0 /* ArgCategory.Simple */));
+            argList.push(parseNodes_1.ArgumentNode.create(this._getOwnerKey(), this._peekToken(), errorNode, 0 /* ArgCategory.Simple */));
         }
         return {
             list: argList,
@@ -3100,9 +3162,9 @@ class Parser {
             if (sliceExpressions[0]) {
                 return sliceExpressions[0];
             }
-            return parseNodes_1.ErrorNode.create(this._peekToken(), 3 /* ErrorExpressionCategory.MissingIndexOrSlice */);
+            return parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 3 /* ErrorExpressionCategory.MissingIndexOrSlice */);
         }
-        const sliceNode = parseNodes_1.SliceNode.create(firstToken);
+        const sliceNode = parseNodes_1.SliceNode.create(this._getOwnerKey(), firstToken);
         sliceNode.d.startValue = sliceExpressions[0];
         if (sliceNode.d.startValue) {
             sliceNode.d.startValue.parent = sliceNode;
@@ -3191,9 +3253,9 @@ class Parser {
                 }
             }
         }
-        const argNode = parseNodes_1.ArgumentNode.create(firstToken, valueExpr, argType);
+        const argNode = parseNodes_1.ArgumentNode.create(this._getOwnerKey(), firstToken, valueExpr, argType);
         if (nameIdentifier) {
-            argNode.d.name = parseNodes_1.NameNode.create(nameIdentifier);
+            argNode.d.name = parseNodes_1.NameNode.create(this._getOwnerKey(), nameIdentifier);
             argNode.d.name.parent = argNode;
         }
         return argNode;
@@ -3205,13 +3267,13 @@ class Parser {
     _parseAtom() {
         const nextToken = this._peekToken();
         if (nextToken.type === 19 /* TokenType.Ellipsis */) {
-            return parseNodes_1.EllipsisNode.create(this._getNextToken());
+            return parseNodes_1.EllipsisNode.create(this._getOwnerKey(), this._getNextToken());
         }
         if (nextToken.type === 6 /* TokenType.Number */) {
-            return parseNodes_1.NumberNode.create(this._getNextToken());
+            return parseNodes_1.NumberNode.create(this._getOwnerKey(), this._getNextToken());
         }
         if (nextToken.type === 7 /* TokenType.Identifier */) {
-            return parseNodes_1.NameNode.create(this._getNextToken());
+            return parseNodes_1.NameNode.create(this._getOwnerKey(), this._getNextToken());
         }
         if (nextToken.type === 5 /* TokenType.String */ || nextToken.type === 24 /* TokenType.FStringStart */) {
             return this._parseStringList();
@@ -3256,12 +3318,12 @@ class Parser {
                 keywordToken.keywordType === 34 /* KeywordType.True */ ||
                 keywordToken.keywordType === 9 /* KeywordType.Debug */ ||
                 keywordToken.keywordType === 27 /* KeywordType.None */) {
-                return parseNodes_1.ConstantNode.create(this._getNextToken());
+                return parseNodes_1.ConstantNode.create(this._getOwnerKey(), this._getNextToken());
             }
             // Make an identifier out of the keyword.
             const keywordAsIdentifier = this._getTokenIfIdentifier();
             if (keywordAsIdentifier) {
-                return parseNodes_1.NameNode.create(keywordAsIdentifier);
+                return parseNodes_1.NameNode.create(this._getOwnerKey(), keywordAsIdentifier);
             }
         }
         return this._handleExpressionParseError(2 /* ErrorExpressionCategory.MissingExpression */, localize_1.LocMessage.expectedExpr());
@@ -3282,7 +3344,7 @@ class Parser {
         const initialRange = stopTokens.some((k) => nextToken.type === k)
             ? targetToken ?? childNode ?? textRange_1.TextRange.create(nextToken.start, /* length */ 0)
             : nextToken;
-        const expr = parseNodes_1.ErrorNode.create(initialRange, category, childNode);
+        const expr = parseNodes_1.ErrorNode.create(this._getOwnerKey(), initialRange, category, childNode);
         this._consumeTokensUntilType(stopTokens);
         return expr;
     }
@@ -3300,7 +3362,7 @@ class Parser {
         else {
             testExpr = this._tryParseLambdaExpression(/* allowConditional */ false) || this._parseOrTest();
         }
-        const lambdaNode = parseNodes_1.LambdaNode.create(lambdaToken, testExpr);
+        const lambdaNode = parseNodes_1.LambdaNode.create(this._getOwnerKey(), lambdaToken, testExpr);
         lambdaNode.d.params = argList;
         argList.forEach((arg) => {
             arg.parent = lambdaNode;
@@ -3344,6 +3406,7 @@ class Parser {
     _parseListAtom() {
         const startBracket = this._getNextToken();
         (0, debug_1.assert)(startBracket.type === 15 /* TokenType.OpenBracket */);
+        const ownerKey = this._getOwnerKey();
         const exprListResult = this._parseTestListWithComprehension(/* isGenerator */ false);
         const closeBracket = this._peekToken();
         if (!this._consumeTokenIfType(16 /* TokenType.CloseBracket */)) {
@@ -3351,7 +3414,7 @@ class Parser {
         }
         return _createList();
         function _createList() {
-            const listAtom = parseNodes_1.ListNode.create(startBracket);
+            const listAtom = parseNodes_1.ListNode.create(ownerKey, startBracket);
             if (closeBracket) {
                 (0, parseNodes_1.extendRange)(listAtom, closeBracket);
             }
@@ -3438,7 +3501,7 @@ class Parser {
                     this._addSyntaxError(localize_1.LocMessage.keyValueInSet(), valueExpression);
                 }
                 else {
-                    const keyEntryNode = parseNodes_1.DictionaryKeyEntryNode.create(keyExpression, valueExpression);
+                    const keyEntryNode = parseNodes_1.DictionaryKeyEntryNode.create(this._getOwnerKey(), keyExpression, valueExpression);
                     let dictEntry = keyEntryNode;
                     const comprehension = this._tryParseComprehension(keyEntryNode, /* isGenerator */ false);
                     if (comprehension) {
@@ -3457,7 +3520,7 @@ class Parser {
                     this._addSyntaxError(localize_1.LocMessage.unpackInSet(), doubleStarExpression);
                 }
                 else {
-                    const listEntryNode = parseNodes_1.DictionaryExpandEntryNode.create(doubleStarExpression);
+                    const listEntryNode = parseNodes_1.DictionaryExpandEntryNode.create(this._getOwnerKey(), doubleStarExpression);
                     (0, parseNodes_1.extendRange)(listEntryNode, doubleStar);
                     let expandEntryNode = listEntryNode;
                     const comprehension = this._tryParseComprehension(listEntryNode, /* isGenerator */ false);
@@ -3476,8 +3539,8 @@ class Parser {
                 (0, debug_1.assert)(keyExpression !== undefined);
                 if (keyExpression) {
                     if (isDictionary) {
-                        const missingValueErrorNode = parseNodes_1.ErrorNode.create(this._peekToken(), 13 /* ErrorExpressionCategory.MissingDictValue */);
-                        const keyEntryNode = parseNodes_1.DictionaryKeyEntryNode.create(keyExpression, missingValueErrorNode);
+                        const missingValueErrorNode = parseNodes_1.ErrorNode.create(this._getOwnerKey(), this._peekToken(), 13 /* ErrorExpressionCategory.MissingDictValue */);
+                        const keyEntryNode = parseNodes_1.DictionaryKeyEntryNode.create(this._getOwnerKey(), keyExpression, missingValueErrorNode);
                         dictionaryEntries.push(keyEntryNode);
                         this._addSyntaxError(localize_1.LocMessage.dictKeyValuePairs(), keyExpression);
                     }
@@ -3511,7 +3574,7 @@ class Parser {
             closeCurlyBrace = undefined;
         }
         if (isSet) {
-            const setAtom = parseNodes_1.SetNode.create(startBrace);
+            const setAtom = parseNodes_1.SetNode.create(this._getOwnerKey(), startBrace);
             if (closeCurlyBrace) {
                 (0, parseNodes_1.extendRange)(setAtom, closeCurlyBrace);
             }
@@ -3524,7 +3587,7 @@ class Parser {
             setAtom.d.items = setEntries;
             return setAtom;
         }
-        const dictionaryAtom = parseNodes_1.DictionaryNode.create(startBrace);
+        const dictionaryAtom = parseNodes_1.DictionaryNode.create(this._getOwnerKey(), startBrace);
         if (trailingCommaToken) {
             dictionaryAtom.d.trailingCommaToken = trailingCommaToken;
             (0, parseNodes_1.extendRange)(dictionaryAtom, trailingCommaToken);
@@ -3584,7 +3647,7 @@ class Parser {
         // Is this a type annotation assignment?
         if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
             annotationExpr = this._parseTypeAnnotation();
-            leftExpr = parseNodes_1.TypeAnnotationNode.create(leftExpr, annotationExpr);
+            leftExpr = parseNodes_1.TypeAnnotationNode.create(this._getOwnerKey(), leftExpr, annotationExpr);
             if (!this._parseOptions.isStubFile &&
                 pythonVersion_1.PythonVersion.isLessThan(this._getLanguageVersion(), pythonVersion_1.pythonVersion3_6)) {
                 this._addSyntaxError(localize_1.LocMessage.varAnnotationIllegal(), annotationExpr);
@@ -3606,7 +3669,7 @@ class Parser {
                 /* allowAssignmentExpression */ false, 
                 /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedAssignRightHandExpr());
             this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
-            return parseNodes_1.AssignmentNode.create(leftExpr, rightExpr);
+            return parseNodes_1.AssignmentNode.create(this._getOwnerKey(), leftExpr, rightExpr);
         }
         // Is this a simple assignment?
         if (this._consumeTokenIfOperator(2 /* OperatorType.Assign */)) {
@@ -3622,7 +3685,7 @@ class Parser {
             // Make a shallow copy of the dest expression but give it a new ID.
             const destExpr = Object.assign({}, leftExpr);
             destExpr.id = (0, parseNodes_1.getNextNodeId)();
-            return parseNodes_1.AugmentedAssignmentNode.create(leftExpr, rightExpr, operatorToken.operatorType, destExpr);
+            return parseNodes_1.AugmentedAssignmentNode.create(this._getOwnerKey(), leftExpr, rightExpr, operatorToken.operatorType, destExpr);
         }
         return leftExpr;
     }
@@ -3647,7 +3710,7 @@ class Parser {
         }
         // Create a tree of assignment expressions starting with the first one.
         // The final RHS value is assigned to the targets left to right in Python.
-        let assignmentNode = parseNodes_1.AssignmentNode.create(assignmentTargets[0], rightExpr);
+        let assignmentNode = parseNodes_1.AssignmentNode.create(this._getOwnerKey(), assignmentTargets[0], rightExpr);
         // Look for a type annotation comment at the end of the line.
         const typeAnnotationComment = this._parseVariableTypeAnnotationComment();
         if (typeAnnotationComment) {
@@ -3666,7 +3729,7 @@ class Parser {
         }
         assignmentTargets.forEach((target, index) => {
             if (index > 0) {
-                assignmentNode = parseNodes_1.AssignmentNode.create(target, assignmentNode);
+                assignmentNode = parseNodes_1.AssignmentNode.create(this._getOwnerKey(), target, assignmentNode);
             }
         });
         return assignmentNode;
@@ -3709,7 +3772,7 @@ class Parser {
             paramAnnotations = [];
             isParamListEllipsis = true;
         }
-        return parseNodes_1.FunctionAnnotationNode.create(openParenToken, isParamListEllipsis, paramAnnotations, returnType);
+        return parseNodes_1.FunctionAnnotationNode.create(this._getOwnerKey(), openParenToken, isParamListEllipsis, paramAnnotations, returnType);
     }
     _parseTypeAnnotation(allowUnpack = false) {
         // Temporary set a flag that indicates we're parsing a type annotation.
@@ -3727,7 +3790,7 @@ class Parser {
         }
         let result = this._parseTestExpression(/* allowAssignmentExpression */ false);
         if (isUnpack) {
-            result = parseNodes_1.UnpackNode.create(startToken, result);
+            result = parseNodes_1.UnpackNode.create(this._getOwnerKey(), startToken, result);
         }
         this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
         this._hasTypeAnnotations = true;
@@ -3769,7 +3832,7 @@ class Parser {
     _makeStringNode(stringToken) {
         const unescapedResult = StringTokenUtils.getUnescapedString(stringToken);
         this._reportStringTokenErrors(stringToken, unescapedResult);
-        return parseNodes_1.StringNode.create(stringToken, unescapedResult.value);
+        return parseNodes_1.StringNode.create(this._getOwnerKey(), stringToken, unescapedResult.value);
     }
     _getTypeAnnotationCommentText() {
         if (this._tokenIndex === 0) {
@@ -3804,30 +3867,32 @@ class Parser {
             return undefined;
         }
         const stringNode = this._makeStringNode(stringToken);
-        const stringListNode = parseNodes_1.StringListNode.create([stringNode]);
+        const stringListNode = parseNodes_1.StringListNode.create(this._getOwnerKey(), [stringNode]);
         const parser = new Parser();
         const parseResults = parser.parseTextExpression(this._fileContents, stringToken.start, stringToken.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, 
-        /* initialParenDepth */ undefined, this._typingSymbolAliases);
+        /* initialParenDepth */ undefined, this._typingSymbolAliases, this._getOwnerKey());
         parseResults.diagnostics.forEach((diag) => {
             this._addSyntaxError(diag.message, stringListNode);
         });
         if (!parseResults.parseTree) {
             return undefined;
         }
+        this._stringAnnotations.writer.addAll(parseResults.stringAnnotations);
         return parseResults.parseTree;
     }
     _parseFunctionTypeAnnotationComment(stringToken, functionNode) {
         const stringNode = this._makeStringNode(stringToken);
-        const stringListNode = parseNodes_1.StringListNode.create([stringNode]);
+        const stringListNode = parseNodes_1.StringListNode.create(this._getOwnerKey(), [stringNode]);
         const parser = new Parser();
         const parseResults = parser.parseTextExpression(this._fileContents, stringToken.start, stringToken.length, this._parseOptions, 2 /* ParseTextMode.FunctionAnnotation */, 
-        /* initialParenDepth */ undefined, this._typingSymbolAliases);
+        /* initialParenDepth */ undefined, this._typingSymbolAliases, this._getOwnerKey());
         parseResults.diagnostics.forEach((diag) => {
             this._addSyntaxError(diag.message, stringListNode);
         });
         if (!parseResults.parseTree) {
             return;
         }
+        this._stringAnnotations.writer.addAll(parseResults.stringAnnotations);
         const functionAnnotation = parseResults.parseTree;
         functionNode.d.funcAnnotationComment = functionAnnotation;
         functionAnnotation.parent = functionNode;
@@ -3952,10 +4017,10 @@ class Parser {
             break;
         }
         this._reportStringTokenErrors(startToken);
-        return parseNodes_1.FormatStringNode.create(startToken, endToken, middleTokens, fieldExpressions, formatExpressions);
+        return parseNodes_1.FormatStringNode.create(this._getOwnerKey(), startToken, endToken, middleTokens, fieldExpressions, formatExpressions);
     }
     _createBinaryOperationNode(leftExpression, rightExpression, operatorToken, operator) {
-        const binaryNode = parseNodes_1.BinaryOperationNode.create(leftExpression, rightExpression, operatorToken, operator);
+        const binaryNode = parseNodes_1.BinaryOperationNode.create(this._getOwnerKey(), leftExpression, rightExpression, operatorToken, operator);
         // Determine if we're exceeding the max parse depth. If so, replace
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
@@ -3963,20 +4028,20 @@ class Parser {
         const rightMaxDepth = this._maxChildDepthMap.get(rightExpression.id) ?? 0;
         if (leftMaxDepth >= maxChildNodeDepth || rightMaxDepth >= maxChildNodeDepth) {
             this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), binaryNode);
-            return parseNodes_1.ErrorNode.create(binaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
+            return parseNodes_1.ErrorNode.create(this._getOwnerKey(), binaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
         }
         this._maxChildDepthMap.set(binaryNode.id, Math.max(leftMaxDepth, rightMaxDepth) + 1);
         return binaryNode;
     }
     _createUnaryOperationNode(operatorToken, expression, operator) {
-        const unaryNode = parseNodes_1.UnaryOperationNode.create(operatorToken, expression, operator);
+        const unaryNode = parseNodes_1.UnaryOperationNode.create(this._getOwnerKey(), operatorToken, expression, operator);
         // Determine if we're exceeding the max parse depth. If so, replace
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
         const maxDepth = this._maxChildDepthMap.get(expression.id) ?? 0;
         if (maxDepth >= maxChildNodeDepth) {
             this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), unaryNode);
-            return parseNodes_1.ErrorNode.create(unaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
+            return parseNodes_1.ErrorNode.create(this._getOwnerKey(), unaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
         }
         this._maxChildDepthMap.set(unaryNode.id, maxDepth + 1);
         return unaryNode;
@@ -3995,7 +4060,7 @@ class Parser {
                 break;
             }
         }
-        const stringNode = parseNodes_1.StringListNode.create(stringList);
+        const stringNode = parseNodes_1.StringListNode.create(this._getOwnerKey(), stringList);
         // If we're parsing a type annotation, parse the contents of the string.
         if (this._isParsingTypeAnnotation) {
             // Don't allow multiple strings because we have no way of reporting
@@ -4031,15 +4096,16 @@ class Parser {
                         128 /* StringTokenFlags.Template */)) ===
                     0) {
                     const parser = new Parser();
-                    const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.d.strings[0].d.token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
+                    const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.d.strings[0].d.token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases, this._getOwnerKey());
                     if (parseResults.diagnostics.length === 0 ||
                         this._parseOptions.reportErrorsForParsedStringContents) {
                         parseResults.diagnostics.forEach((diag) => {
                             this._addSyntaxError(diag.message, stringNode);
                         });
                         if (parseResults.parseTree) {
-                            stringNode.d.annotation = parseResults.parseTree;
-                            stringNode.d.annotation.parent = stringNode;
+                            this._stringAnnotations.writer.set(stringNode, parseResults.parseTree);
+                            this._stringAnnotations.writer.addAll(parseResults.stringAnnotations);
+                            parseResults.parseTree.parent = stringNode;
                         }
                     }
                 }