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

package/dist/parser/parseNodes.d.ts

@@ -1,4 +1,5 @@
 import { TextRange } from '../common/textRange';
+import { StringAnnotationInfo } from './stringAnnotationInfo';
 import { FStringEndToken, FStringMiddleToken, FStringStartToken, IdentifierToken, KeywordToken, KeywordType, NumberToken, OperatorType, StringToken, Token } from './tokenizerTypes';
 export declare const enum ParseNodeType {
     Error = 0,// 0
@@ -98,13 +99,18 @@ export declare const enum ErrorExpressionCategory {
     MissingKeywordArgValue = 14,
     MaxDepthExceeded = 15
 }
+export type ParseTreeKey = object;
+export declare function setParserStringAnnotationInfo(key: ParseTreeKey, stringAnnotations: StringAnnotationInfo): void;
+export declare function getParseTreeRoot(node: ParseNode): ModuleNode | undefined;
+export declare function getParserStringAnnotation(node: StringListNode): ExpressionNode | undefined;
+export declare function getParserStringAnnotationInfo(node: ParseNode): StringAnnotationInfo;
 export interface ParseNodeBase<T extends ParseNodeType> {
     readonly nodeType: T;
     readonly start: number;
     readonly length: number;
     id: number;
     parent: ParseNode | undefined;
-    a: object | undefined;
+    readonly a: ParseTreeKey;
     d: object;
 }
 export declare function getNextNodeId(): number;
@@ -125,7 +131,7 @@ export interface SuiteNode extends ParseNodeBase<ParseNodeType.Suite> {
     };
 }
 export declare namespace SuiteNode {
-    function create(range: TextRange): SuiteNode;
+    function create(key: ParseTreeKey, range: TextRange): SuiteNode;
 }
 export interface IfNode extends ParseNodeBase<ParseNodeType.If> {
     d: {
@@ -136,7 +142,7 @@ export interface IfNode extends ParseNodeBase<ParseNodeType.If> {
     };
 }
 export declare namespace IfNode {
-    function create(ifOrElifToken: Token, testExpr: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
+    function create(key: ParseTreeKey, ifOrElifToken: Token, testExpr: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
 }
 export interface WhileNode extends ParseNodeBase<ParseNodeType.While> {
     d: {
@@ -147,7 +153,7 @@ export interface WhileNode extends ParseNodeBase<ParseNodeType.While> {
     };
 }
 export declare namespace WhileNode {
-    function create(whileToken: Token, testExpr: ExpressionNode, whileSuite: SuiteNode): WhileNode;
+    function create(key: ParseTreeKey, whileToken: Token, testExpr: ExpressionNode, whileSuite: SuiteNode): WhileNode;
 }
 export interface ForNode extends ParseNodeBase<ParseNodeType.For> {
     d: {
@@ -162,7 +168,7 @@ export interface ForNode extends ParseNodeBase<ParseNodeType.For> {
     };
 }
 export declare namespace ForNode {
-    function create(forToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode, forSuite: SuiteNode): ForNode;
+    function create(key: ParseTreeKey, forToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode, forSuite: SuiteNode): ForNode;
 }
 export type ComprehensionForIfNode = ComprehensionForNode | ComprehensionIfNode;
 export interface ComprehensionForNode extends ParseNodeBase<ParseNodeType.ComprehensionFor> {
@@ -174,7 +180,7 @@ export interface ComprehensionForNode extends ParseNodeBase<ParseNodeType.Compre
     };
 }
 export declare namespace ComprehensionForNode {
-    function create(startToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode): ComprehensionForNode;
+    function create(key: ParseTreeKey, startToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode): ComprehensionForNode;
 }
 export interface ComprehensionIfNode extends ParseNodeBase<ParseNodeType.ComprehensionIf> {
     d: {
@@ -182,7 +188,7 @@ export interface ComprehensionIfNode extends ParseNodeBase<ParseNodeType.Compreh
     };
 }
 export declare namespace ComprehensionIfNode {
-    function create(ifToken: Token, testExpr: ExpressionNode): ComprehensionIfNode;
+    function create(key: ParseTreeKey, ifToken: Token, testExpr: ExpressionNode): ComprehensionIfNode;
 }
 export interface TryNode extends ParseNodeBase<ParseNodeType.Try> {
     d: {
@@ -194,7 +200,7 @@ export interface TryNode extends ParseNodeBase<ParseNodeType.Try> {
     };
 }
 export declare namespace TryNode {
-    function create(tryToken: Token, trySuite: SuiteNode): TryNode;
+    function create(key: ParseTreeKey, tryToken: Token, trySuite: SuiteNode): TryNode;
 }
 export interface ExceptNode extends ParseNodeBase<ParseNodeType.Except> {
     d: {
@@ -206,7 +212,7 @@ export interface ExceptNode extends ParseNodeBase<ParseNodeType.Except> {
     };
 }
 export declare namespace ExceptNode {
-    function create(exceptToken: Token, exceptSuite: SuiteNode, isExceptGroup: boolean): ExceptNode;
+    function create(key: ParseTreeKey, exceptToken: Token, exceptSuite: SuiteNode, isExceptGroup: boolean): ExceptNode;
 }
 export interface FunctionNode extends ParseNodeBase<ParseNodeType.Function> {
     d: {
@@ -222,7 +228,7 @@ export interface FunctionNode extends ParseNodeBase<ParseNodeType.Function> {
     };
 }
 export declare namespace FunctionNode {
-    function create(defToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): FunctionNode;
+    function create(key: ParseTreeKey, defToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): FunctionNode;
 }
 export declare const enum ParamCategory {
     Simple = 0,
@@ -239,7 +245,7 @@ export interface ParameterNode extends ParseNodeBase<ParseNodeType.Parameter> {
     };
 }
 export declare namespace ParameterNode {
-    function create(startToken: Token, paramCategory: ParamCategory): ParameterNode;
+    function create(key: ParseTreeKey, startToken: Token, paramCategory: ParamCategory): ParameterNode;
 }
 export interface ClassNode extends ParseNodeBase<ParseNodeType.Class> {
     d: {
@@ -252,8 +258,8 @@ export interface ClassNode extends ParseNodeBase<ParseNodeType.Class> {
     };
 }
 export declare namespace ClassNode {
-    function create(classToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): ClassNode;
-    function createDummyForDecorators(decorators: DecoratorNode[]): ClassNode;
+    function create(key: ParseTreeKey, classToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): ClassNode;
+    function createDummyForDecorators(key: ParseTreeKey, decorators: DecoratorNode[]): ClassNode;
 }
 export interface WithNode extends ParseNodeBase<ParseNodeType.With> {
     d: {
@@ -266,7 +272,7 @@ export interface WithNode extends ParseNodeBase<ParseNodeType.With> {
     };
 }
 export declare namespace WithNode {
-    function create(withToken: Token, suite: SuiteNode): WithNode;
+    function create(key: ParseTreeKey, withToken: Token, suite: SuiteNode): WithNode;
 }
 export interface WithItemNode extends ParseNodeBase<ParseNodeType.WithItem> {
     d: {
@@ -275,7 +281,7 @@ export interface WithItemNode extends ParseNodeBase<ParseNodeType.WithItem> {
     };
 }
 export declare namespace WithItemNode {
-    function create(expr: ExpressionNode): WithItemNode;
+    function create(key: ParseTreeKey, expr: ExpressionNode): WithItemNode;
 }
 export interface DecoratorNode extends ParseNodeBase<ParseNodeType.Decorator> {
     d: {
@@ -283,7 +289,7 @@ export interface DecoratorNode extends ParseNodeBase<ParseNodeType.Decorator> {
     };
 }
 export declare namespace DecoratorNode {
-    function create(atToken: Token, expr: ExpressionNode): DecoratorNode;
+    function create(key: ParseTreeKey, atToken: Token, expr: ExpressionNode): DecoratorNode;
 }
 export interface StatementListNode extends ParseNodeBase<ParseNodeType.StatementList> {
     d: {
@@ -292,7 +298,7 @@ export interface StatementListNode extends ParseNodeBase<ParseNodeType.Statement
     };
 }
 export declare namespace StatementListNode {
-    function create(atToken: Token): StatementListNode;
+    function create(key: ParseTreeKey, atToken: Token): StatementListNode;
 }
 export type StatementNode = IfNode | WhileNode | ForNode | TryNode | FunctionNode | ClassNode | WithNode | StatementListNode | MatchNode | TypeAliasNode | ErrorNode;
 export type SmallStatementNode = ExpressionNode | DelNode | PassNode | ImportNode | GlobalNode | NonlocalNode | AssertNode;
@@ -306,7 +312,7 @@ export interface ErrorNode extends ParseNodeBase<ParseNodeType.Error> {
     };
 }
 export declare namespace ErrorNode {
-    function create(initialRange: TextRange, category: ErrorExpressionCategory, child?: ExpressionNode, decorators?: DecoratorNode[]): ErrorNode;
+    function create(key: ParseTreeKey, initialRange: TextRange, category: ErrorExpressionCategory, child?: ExpressionNode, decorators?: DecoratorNode[]): ErrorNode;
 }
 export interface UnaryOperationNode extends ParseNodeBase<ParseNodeType.UnaryOperation> {
     d: {
@@ -317,7 +323,7 @@ export interface UnaryOperationNode extends ParseNodeBase<ParseNodeType.UnaryOpe
     };
 }
 export declare namespace UnaryOperationNode {
-    function create(operatorToken: Token, expr: ExpressionNode, operator: OperatorType): UnaryOperationNode;
+    function create(key: ParseTreeKey, operatorToken: Token, expr: ExpressionNode, operator: OperatorType): UnaryOperationNode;
 }
 export interface BinaryOperationNode extends ParseNodeBase<ParseNodeType.BinaryOperation> {
     d: {
@@ -329,7 +335,7 @@ export interface BinaryOperationNode extends ParseNodeBase<ParseNodeType.BinaryO
     };
 }
 export declare namespace BinaryOperationNode {
-    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
+    function create(key: ParseTreeKey, leftExpr: ExpressionNode, rightExpr: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
 }
 export interface AssignmentExpressionNode extends ParseNodeBase<ParseNodeType.AssignmentExpression> {
     d: {
@@ -340,7 +346,7 @@ export interface AssignmentExpressionNode extends ParseNodeBase<ParseNodeType.As
     };
 }
 export declare namespace AssignmentExpressionNode {
-    function create(name: NameNode, walrusToken: Token, rightExpr: ExpressionNode): AssignmentExpressionNode;
+    function create(key: ParseTreeKey, name: NameNode, walrusToken: Token, rightExpr: ExpressionNode): AssignmentExpressionNode;
 }
 export interface AssignmentNode extends ParseNodeBase<ParseNodeType.Assignment> {
     d: {
@@ -351,7 +357,7 @@ export interface AssignmentNode extends ParseNodeBase<ParseNodeType.Assignment>
     };
 }
 export declare namespace AssignmentNode {
-    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode): AssignmentNode;
+    function create(key: ParseTreeKey, leftExpr: ExpressionNode, rightExpr: ExpressionNode): AssignmentNode;
 }
 export declare enum TypeParamKind {
     TypeVar = 0,
@@ -367,7 +373,7 @@ export interface TypeParameterNode extends ParseNodeBase<ParseNodeType.TypeParam
     };
 }
 export declare namespace TypeParameterNode {
-    function create(name: NameNode, typeParamKind: TypeParamKind, boundExpr?: ExpressionNode, defaultExpr?: ExpressionNode): TypeParameterNode;
+    function create(key: ParseTreeKey, name: NameNode, typeParamKind: TypeParamKind, boundExpr?: ExpressionNode, defaultExpr?: ExpressionNode): TypeParameterNode;
 }
 export interface TypeParameterListNode extends ParseNodeBase<ParseNodeType.TypeParameterList> {
     d: {
@@ -375,7 +381,7 @@ export interface TypeParameterListNode extends ParseNodeBase<ParseNodeType.TypeP
     };
 }
 export declare namespace TypeParameterListNode {
-    function create(startToken: Token, endToken: Token, params: TypeParameterNode[]): TypeParameterListNode;
+    function create(key: ParseTreeKey, startToken: Token, endToken: Token, params: TypeParameterNode[]): TypeParameterListNode;
 }
 export interface TypeAliasNode extends ParseNodeBase<ParseNodeType.TypeAlias> {
     d: {
@@ -386,7 +392,7 @@ export interface TypeAliasNode extends ParseNodeBase<ParseNodeType.TypeAlias> {
     };
 }
 export declare namespace TypeAliasNode {
-    function create(typeToken: KeywordToken, name: NameNode, expr: ExpressionNode, typeParams?: TypeParameterListNode): TypeAliasNode;
+    function create(key: ParseTreeKey, typeToken: KeywordToken, name: NameNode, expr: ExpressionNode, typeParams?: TypeParameterListNode): TypeAliasNode;
 }
 export interface TypeAnnotationNode extends ParseNodeBase<ParseNodeType.TypeAnnotation> {
     d: {
@@ -395,7 +401,7 @@ export interface TypeAnnotationNode extends ParseNodeBase<ParseNodeType.TypeAnno
     };
 }
 export declare namespace TypeAnnotationNode {
-    function create(valueExpr: ExpressionNode, annotation: ExpressionNode): TypeAnnotationNode;
+    function create(key: ParseTreeKey, valueExpr: ExpressionNode, annotation: ExpressionNode): TypeAnnotationNode;
 }
 export interface FunctionAnnotationNode extends ParseNodeBase<ParseNodeType.FunctionAnnotation> {
     d: {
@@ -405,7 +411,7 @@ export interface FunctionAnnotationNode extends ParseNodeBase<ParseNodeType.Func
     };
 }
 export declare namespace FunctionAnnotationNode {
-    function create(openParenToken: Token, isEllipsis: boolean, paramAnnotations: ExpressionNode[], returnAnnotation: ExpressionNode): FunctionAnnotationNode;
+    function create(key: ParseTreeKey, openParenToken: Token, isEllipsis: boolean, paramAnnotations: ExpressionNode[], returnAnnotation: ExpressionNode): FunctionAnnotationNode;
 }
 export interface AugmentedAssignmentNode extends ParseNodeBase<ParseNodeType.AugmentedAssignment> {
     d: {
@@ -416,7 +422,7 @@ export interface AugmentedAssignmentNode extends ParseNodeBase<ParseNodeType.Aug
     };
 }
 export declare namespace AugmentedAssignmentNode {
-    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operator: OperatorType, destExpr: ExpressionNode): AugmentedAssignmentNode;
+    function create(key: ParseTreeKey, leftExpr: ExpressionNode, rightExpr: ExpressionNode, operator: OperatorType, destExpr: ExpressionNode): AugmentedAssignmentNode;
 }
 export interface AwaitNode extends ParseNodeBase<ParseNodeType.Await> {
     d: {
@@ -426,7 +432,7 @@ export interface AwaitNode extends ParseNodeBase<ParseNodeType.Await> {
     };
 }
 export declare namespace AwaitNode {
-    function create(awaitToken: Token, expr: ExpressionNode): AwaitNode;
+    function create(key: ParseTreeKey, awaitToken: Token, expr: ExpressionNode): AwaitNode;
 }
 export interface TernaryNode extends ParseNodeBase<ParseNodeType.Ternary> {
     d: {
@@ -436,7 +442,7 @@ export interface TernaryNode extends ParseNodeBase<ParseNodeType.Ternary> {
     };
 }
 export declare namespace TernaryNode {
-    function create(ifExpr: ExpressionNode, testExpr: ExpressionNode, elseExpr: ExpressionNode): TernaryNode;
+    function create(key: ParseTreeKey, ifExpr: ExpressionNode, testExpr: ExpressionNode, elseExpr: ExpressionNode): TernaryNode;
 }
 export interface UnpackNode extends ParseNodeBase<ParseNodeType.Unpack> {
     d: {
@@ -445,7 +451,7 @@ export interface UnpackNode extends ParseNodeBase<ParseNodeType.Unpack> {
     };
 }
 export declare namespace UnpackNode {
-    function create(starToken: Token, expr: ExpressionNode): UnpackNode;
+    function create(key: ParseTreeKey, starToken: Token, expr: ExpressionNode): UnpackNode;
 }
 export interface TupleNode extends ParseNodeBase<ParseNodeType.Tuple> {
     d: {
@@ -454,7 +460,7 @@ export interface TupleNode extends ParseNodeBase<ParseNodeType.Tuple> {
     };
 }
 export declare namespace TupleNode {
-    function create(range: TextRange, hasParens: boolean): TupleNode;
+    function create(key: ParseTreeKey, range: TextRange, hasParens: boolean): TupleNode;
 }
 export interface CallNode extends ParseNodeBase<ParseNodeType.Call> {
     d: {
@@ -464,7 +470,7 @@ export interface CallNode extends ParseNodeBase<ParseNodeType.Call> {
     };
 }
 export declare namespace CallNode {
-    function create(leftExpr: ExpressionNode, args: ArgumentNode[], trailingComma: boolean): CallNode;
+    function create(key: ParseTreeKey, leftExpr: ExpressionNode, args: ArgumentNode[], trailingComma: boolean): CallNode;
 }
 export interface ComprehensionNode extends ParseNodeBase<ParseNodeType.Comprehension> {
     d: {
@@ -475,7 +481,7 @@ export interface ComprehensionNode extends ParseNodeBase<ParseNodeType.Comprehen
     };
 }
 export declare namespace ComprehensionNode {
-    function create(expr: ParseNode, isGenerator: boolean): ComprehensionNode;
+    function create(key: ParseTreeKey, expr: ParseNode, isGenerator: boolean): ComprehensionNode;
 }
 export interface IndexNode extends ParseNodeBase<ParseNodeType.Index> {
     d: {
@@ -485,7 +491,7 @@ export interface IndexNode extends ParseNodeBase<ParseNodeType.Index> {
     };
 }
 export declare namespace IndexNode {
-    function create(leftExpr: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
+    function create(key: ParseTreeKey, leftExpr: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
 }
 export interface SliceNode extends ParseNodeBase<ParseNodeType.Slice> {
     d: {
@@ -495,7 +501,7 @@ export interface SliceNode extends ParseNodeBase<ParseNodeType.Slice> {
     };
 }
 export declare namespace SliceNode {
-    function create(range: TextRange): SliceNode;
+    function create(key: ParseTreeKey, range: TextRange): SliceNode;
 }
 export interface YieldNode extends ParseNodeBase<ParseNodeType.Yield> {
     d: {
@@ -503,7 +509,7 @@ export interface YieldNode extends ParseNodeBase<ParseNodeType.Yield> {
     };
 }
 export declare namespace YieldNode {
-    function create(yieldToken: Token, expr?: ExpressionNode): YieldNode;
+    function create(key: ParseTreeKey, yieldToken: Token, expr?: ExpressionNode): YieldNode;
 }
 export interface YieldFromNode extends ParseNodeBase<ParseNodeType.YieldFrom> {
     d: {
@@ -511,7 +517,7 @@ export interface YieldFromNode extends ParseNodeBase<ParseNodeType.YieldFrom> {
     };
 }
 export declare namespace YieldFromNode {
-    function create(yieldToken: Token, expr: ExpressionNode): YieldFromNode;
+    function create(key: ParseTreeKey, yieldToken: Token, expr: ExpressionNode): YieldFromNode;
 }
 export interface MemberAccessNode extends ParseNodeBase<ParseNodeType.MemberAccess> {
     d: {
@@ -520,7 +526,7 @@ export interface MemberAccessNode extends ParseNodeBase<ParseNodeType.MemberAcce
     };
 }
 export declare namespace MemberAccessNode {
-    function create(leftExpr: ExpressionNode, member: NameNode): MemberAccessNode;
+    function create(key: ParseTreeKey, leftExpr: ExpressionNode, member: NameNode): MemberAccessNode;
 }
 export interface LambdaNode extends ParseNodeBase<ParseNodeType.Lambda> {
     d: {
@@ -529,7 +535,7 @@ export interface LambdaNode extends ParseNodeBase<ParseNodeType.Lambda> {
     };
 }
 export declare namespace LambdaNode {
-    function create(lambdaToken: Token, expr: ExpressionNode): LambdaNode;
+    function create(key: ParseTreeKey, lambdaToken: Token, expr: ExpressionNode): LambdaNode;
 }
 export interface NameNode extends ParseNodeBase<ParseNodeType.Name> {
     d: {
@@ -538,7 +544,7 @@ export interface NameNode extends ParseNodeBase<ParseNodeType.Name> {
     };
 }
 export declare namespace NameNode {
-    function create(nameToken: IdentifierToken): NameNode;
+    function create(key: ParseTreeKey, nameToken: IdentifierToken): NameNode;
 }
 export interface ConstantNode extends ParseNodeBase<ParseNodeType.Constant> {
     d: {
@@ -546,12 +552,12 @@ export interface ConstantNode extends ParseNodeBase<ParseNodeType.Constant> {
     };
 }
 export declare namespace ConstantNode {
-    function create(token: KeywordToken): ConstantNode;
+    function create(key: ParseTreeKey, token: KeywordToken): ConstantNode;
 }
 export interface EllipsisNode extends ParseNodeBase<ParseNodeType.Ellipsis> {
 }
 export declare namespace EllipsisNode {
-    function create(range: TextRange): EllipsisNode;
+    function create(key: ParseTreeKey, range: TextRange): EllipsisNode;
 }
 export interface NumberNode extends ParseNodeBase<ParseNodeType.Number> {
     d: {
@@ -561,7 +567,7 @@ export interface NumberNode extends ParseNodeBase<ParseNodeType.Number> {
     };
 }
 export declare namespace NumberNode {
-    function create(token: NumberToken): NumberNode;
+    function create(key: ParseTreeKey, token: NumberToken): NumberNode;
 }
 export interface StringNode extends ParseNodeBase<ParseNodeType.String> {
     d: {
@@ -570,7 +576,7 @@ export interface StringNode extends ParseNodeBase<ParseNodeType.String> {
     };
 }
 export declare namespace StringNode {
-    function create(token: StringToken, value: string): StringNode;
+    function create(key: ParseTreeKey, token: StringToken, value: string): StringNode;
 }
 export interface FormatStringNode extends ParseNodeBase<ParseNodeType.FormatString> {
     d: {
@@ -582,17 +588,16 @@ export interface FormatStringNode extends ParseNodeBase<ParseNodeType.FormatStri
     };
 }
 export declare namespace FormatStringNode {
-    function create(startToken: FStringStartToken, endToken: FStringEndToken | undefined, middleTokens: FStringMiddleToken[], fieldExprs: ExpressionNode[], formatExprs: ExpressionNode[]): FormatStringNode;
+    function create(key: ParseTreeKey, startToken: FStringStartToken, endToken: FStringEndToken | undefined, middleTokens: FStringMiddleToken[], fieldExprs: ExpressionNode[], formatExprs: ExpressionNode[]): FormatStringNode;
 }
 export interface StringListNode extends ParseNodeBase<ParseNodeType.StringList> {
     d: {
         strings: (StringNode | FormatStringNode)[];
-        annotation: ExpressionNode | undefined;
         hasParens: boolean;
     };
 }
 export declare namespace StringListNode {
-    function create(strings: (StringNode | FormatStringNode)[]): StringListNode;
+    function create(key: ParseTreeKey, strings: (StringNode | FormatStringNode)[]): StringListNode;
 }
 export interface DictionaryNode extends ParseNodeBase<ParseNodeType.Dictionary> {
     d: {
@@ -601,7 +606,7 @@ export interface DictionaryNode extends ParseNodeBase<ParseNodeType.Dictionary>
     };
 }
 export declare namespace DictionaryNode {
-    function create(range: TextRange): DictionaryNode;
+    function create(key: ParseTreeKey, range: TextRange): DictionaryNode;
 }
 export interface DictionaryKeyEntryNode extends ParseNodeBase<ParseNodeType.DictionaryKeyEntry> {
     d: {
@@ -610,7 +615,7 @@ export interface DictionaryKeyEntryNode extends ParseNodeBase<ParseNodeType.Dict
     };
 }
 export declare namespace DictionaryKeyEntryNode {
-    function create(keyExpr: ExpressionNode, valueExpr: ExpressionNode): DictionaryKeyEntryNode;
+    function create(key: ParseTreeKey, keyExpr: ExpressionNode, valueExpr: ExpressionNode): DictionaryKeyEntryNode;
 }
 export interface DictionaryExpandEntryNode extends ParseNodeBase<ParseNodeType.DictionaryExpandEntry> {
     d: {
@@ -618,7 +623,7 @@ export interface DictionaryExpandEntryNode extends ParseNodeBase<ParseNodeType.D
     };
 }
 export declare namespace DictionaryExpandEntryNode {
-    function create(expr: ExpressionNode): DictionaryExpandEntryNode;
+    function create(key: ParseTreeKey, expr: ExpressionNode): DictionaryExpandEntryNode;
 }
 export type DictionaryEntryNode = DictionaryKeyEntryNode | DictionaryExpandEntryNode | ComprehensionNode;
 export interface SetNode extends ParseNodeBase<ParseNodeType.Set> {
@@ -627,7 +632,7 @@ export interface SetNode extends ParseNodeBase<ParseNodeType.Set> {
     };
 }
 export declare namespace SetNode {
-    function create(range: TextRange): SetNode;
+    function create(key: ParseTreeKey, range: TextRange): SetNode;
 }
 export interface ListNode extends ParseNodeBase<ParseNodeType.List> {
     d: {
@@ -635,7 +640,7 @@ export interface ListNode extends ParseNodeBase<ParseNodeType.List> {
     };
 }
 export declare namespace ListNode {
-    function create(range: TextRange): ListNode;
+    function create(key: ParseTreeKey, range: TextRange): ListNode;
 }
 export declare const enum ArgCategory {
     Simple = 0,
@@ -650,7 +655,7 @@ export interface ArgumentNode extends ParseNodeBase<ParseNodeType.Argument> {
     };
 }
 export declare namespace ArgumentNode {
-    function create(startToken: Token | undefined, valueExpr: ExpressionNode, argCategory: ArgCategory): ArgumentNode;
+    function create(key: ParseTreeKey, startToken: Token | undefined, valueExpr: ExpressionNode, argCategory: ArgCategory): ArgumentNode;
 }
 export interface DelNode extends ParseNodeBase<ParseNodeType.Del> {
     d: {
@@ -658,12 +663,12 @@ export interface DelNode extends ParseNodeBase<ParseNodeType.Del> {
     };
 }
 export declare namespace DelNode {
-    function create(delToken: Token): DelNode;
+    function create(key: ParseTreeKey, delToken: Token): DelNode;
 }
 export interface PassNode extends ParseNodeBase<ParseNodeType.Pass> {
 }
 export declare namespace PassNode {
-    function create(passToken: TextRange): PassNode;
+    function create(key: ParseTreeKey, passToken: TextRange): PassNode;
 }
 export interface ImportNode extends ParseNodeBase<ParseNodeType.Import> {
     d: {
@@ -673,7 +678,7 @@ export interface ImportNode extends ParseNodeBase<ParseNodeType.Import> {
     };
 }
 export declare namespace ImportNode {
-    function create(importToken: TextRange): ImportNode;
+    function create(key: ParseTreeKey, importToken: TextRange): ImportNode;
 }
 export interface ModuleNameNode extends ParseNodeBase<ParseNodeType.ModuleName> {
     d: {
@@ -683,7 +688,7 @@ export interface ModuleNameNode extends ParseNodeBase<ParseNodeType.ModuleName>
     };
 }
 export declare namespace ModuleNameNode {
-    function create(range: TextRange): ModuleNameNode;
+    function create(key: ParseTreeKey, range: TextRange): ModuleNameNode;
 }
 export interface ImportAsNode extends ParseNodeBase<ParseNodeType.ImportAs> {
     d: {
@@ -692,7 +697,7 @@ export interface ImportAsNode extends ParseNodeBase<ParseNodeType.ImportAs> {
     };
 }
 export declare namespace ImportAsNode {
-    function create(module: ModuleNameNode): ImportAsNode;
+    function create(key: ParseTreeKey, module: ModuleNameNode): ImportAsNode;
 }
 export interface ImportFromNode extends ParseNodeBase<ParseNodeType.ImportFrom> {
     d: {
@@ -707,7 +712,7 @@ export interface ImportFromNode extends ParseNodeBase<ParseNodeType.ImportFrom>
     };
 }
 export declare namespace ImportFromNode {
-    function create(fromToken: Token, module: ModuleNameNode): ImportFromNode;
+    function create(key: ParseTreeKey, fromToken: Token, module: ModuleNameNode): ImportFromNode;
 }
 export interface ImportFromAsNode extends ParseNodeBase<ParseNodeType.ImportFromAs> {
     d: {
@@ -716,7 +721,7 @@ export interface ImportFromAsNode extends ParseNodeBase<ParseNodeType.ImportFrom
     };
 }
 export declare namespace ImportFromAsNode {
-    function create(name: NameNode): ImportFromAsNode;
+    function create(key: ParseTreeKey, name: NameNode): ImportFromAsNode;
 }
 export interface GlobalNode extends ParseNodeBase<ParseNodeType.Global> {
     d: {
@@ -724,7 +729,7 @@ export interface GlobalNode extends ParseNodeBase<ParseNodeType.Global> {
     };
 }
 export declare namespace GlobalNode {
-    function create(range: TextRange): GlobalNode;
+    function create(key: ParseTreeKey, range: TextRange): GlobalNode;
 }
 export interface NonlocalNode extends ParseNodeBase<ParseNodeType.Nonlocal> {
     d: {
@@ -732,7 +737,7 @@ export interface NonlocalNode extends ParseNodeBase<ParseNodeType.Nonlocal> {
     };
 }
 export declare namespace NonlocalNode {
-    function create(range: TextRange): NonlocalNode;
+    function create(key: ParseTreeKey, range: TextRange): NonlocalNode;
 }
 export interface AssertNode extends ParseNodeBase<ParseNodeType.Assert> {
     d: {
@@ -741,17 +746,17 @@ export interface AssertNode extends ParseNodeBase<ParseNodeType.Assert> {
     };
 }
 export declare namespace AssertNode {
-    function create(assertToken: Token, testExpr: ExpressionNode): AssertNode;
+    function create(key: ParseTreeKey, assertToken: Token, testExpr: ExpressionNode): AssertNode;
 }
 export interface BreakNode extends ParseNodeBase<ParseNodeType.Break> {
 }
 export declare namespace BreakNode {
-    function create(range: TextRange): BreakNode;
+    function create(key: ParseTreeKey, range: TextRange): BreakNode;
 }
 export interface ContinueNode extends ParseNodeBase<ParseNodeType.Continue> {
 }
 export declare namespace ContinueNode {
-    function create(range: TextRange): ContinueNode;
+    function create(key: ParseTreeKey, range: TextRange): ContinueNode;
 }
 export interface ReturnNode extends ParseNodeBase<ParseNodeType.Return> {
     d: {
@@ -759,7 +764,7 @@ export interface ReturnNode extends ParseNodeBase<ParseNodeType.Return> {
     };
 }
 export declare namespace ReturnNode {
-    function create(range: TextRange): ReturnNode;
+    function create(key: ParseTreeKey, range: TextRange): ReturnNode;
 }
 export interface RaiseNode extends ParseNodeBase<ParseNodeType.Raise> {
     d: {
@@ -768,7 +773,7 @@ export interface RaiseNode extends ParseNodeBase<ParseNodeType.Raise> {
     };
 }
 export declare namespace RaiseNode {
-    function create(range: TextRange): RaiseNode;
+    function create(key: ParseTreeKey, range: TextRange): RaiseNode;
 }
 export interface MatchNode extends ParseNodeBase<ParseNodeType.Match> {
     d: {
@@ -778,7 +783,7 @@ export interface MatchNode extends ParseNodeBase<ParseNodeType.Match> {
     };
 }
 export declare namespace MatchNode {
-    function create(matchToken: Token, expr: ExpressionNode): MatchNode;
+    function create(key: ParseTreeKey, matchToken: Token, expr: ExpressionNode): MatchNode;
 }
 export interface CaseNode extends ParseNodeBase<ParseNodeType.Case> {
     d: {
@@ -789,7 +794,7 @@ export interface CaseNode extends ParseNodeBase<ParseNodeType.Case> {
     };
 }
 export declare namespace CaseNode {
-    function create(caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpr: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
+    function create(key: ParseTreeKey, caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpr: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
 }
 export interface PatternSequenceNode extends ParseNodeBase<ParseNodeType.PatternSequence> {
     d: {
@@ -798,7 +803,7 @@ export interface PatternSequenceNode extends ParseNodeBase<ParseNodeType.Pattern
     };
 }
 export declare namespace PatternSequenceNode {
-    function create(firstToken: TextRange, entries: PatternAsNode[]): PatternSequenceNode;
+    function create(key: ParseTreeKey, firstToken: TextRange, entries: PatternAsNode[]): PatternSequenceNode;
 }
 export interface PatternAsNode extends ParseNodeBase<ParseNodeType.PatternAs> {
     d: {
@@ -807,7 +812,7 @@ export interface PatternAsNode extends ParseNodeBase<ParseNodeType.PatternAs> {
     };
 }
 export declare namespace PatternAsNode {
-    function create(orPatterns: PatternAtomNode[], target?: NameNode): PatternAsNode;
+    function create(key: ParseTreeKey, orPatterns: PatternAtomNode[], target?: NameNode): PatternAsNode;
 }
 export interface PatternLiteralNode extends ParseNodeBase<ParseNodeType.PatternLiteral> {
     d: {
@@ -815,7 +820,7 @@ export interface PatternLiteralNode extends ParseNodeBase<ParseNodeType.PatternL
     };
 }
 export declare namespace PatternLiteralNode {
-    function create(expr: ExpressionNode): PatternLiteralNode;
+    function create(key: ParseTreeKey, expr: ExpressionNode): PatternLiteralNode;
 }
 export interface PatternClassNode extends ParseNodeBase<ParseNodeType.PatternClass> {
     d: {
@@ -824,7 +829,7 @@ export interface PatternClassNode extends ParseNodeBase<ParseNodeType.PatternCla
     };
 }
 export declare namespace PatternClassNode {
-    function create(className: NameNode | MemberAccessNode, args: PatternClassArgumentNode[]): PatternClassNode;
+    function create(key: ParseTreeKey, className: NameNode | MemberAccessNode, args: PatternClassArgumentNode[]): PatternClassNode;
 }
 export interface PatternClassArgumentNode extends ParseNodeBase<ParseNodeType.PatternClassArgument> {
     d: {
@@ -833,7 +838,7 @@ export interface PatternClassArgumentNode extends ParseNodeBase<ParseNodeType.Pa
     };
 }
 export declare namespace PatternClassArgumentNode {
-    function create(pattern: PatternAsNode, name?: NameNode): PatternClassArgumentNode;
+    function create(key: ParseTreeKey, pattern: PatternAsNode, name?: NameNode): PatternClassArgumentNode;
 }
 export interface PatternCaptureNode extends ParseNodeBase<ParseNodeType.PatternCapture> {
     d: {
@@ -843,7 +848,7 @@ export interface PatternCaptureNode extends ParseNodeBase<ParseNodeType.PatternC
     };
 }
 export declare namespace PatternCaptureNode {
-    function create(target: NameNode, starToken?: TextRange): PatternCaptureNode;
+    function create(key: ParseTreeKey, target: NameNode, starToken?: TextRange): PatternCaptureNode;
 }
 export interface PatternMappingNode extends ParseNodeBase<ParseNodeType.PatternMapping> {
     d: {
@@ -851,7 +856,7 @@ export interface PatternMappingNode extends ParseNodeBase<ParseNodeType.PatternM
     };
 }
 export declare namespace PatternMappingNode {
-    function create(startToken: TextRange, entries: PatternMappingEntryNode[]): PatternMappingNode;
+    function create(key: ParseTreeKey, startToken: TextRange, entries: PatternMappingEntryNode[]): PatternMappingNode;
 }
 export type PatternMappingEntryNode = PatternMappingKeyEntryNode | PatternMappingExpandEntryNode;
 export interface PatternMappingKeyEntryNode extends ParseNodeBase<ParseNodeType.PatternMappingKeyEntry> {
@@ -861,7 +866,7 @@ export interface PatternMappingKeyEntryNode extends ParseNodeBase<ParseNodeType.
     };
 }
 export declare namespace PatternMappingKeyEntryNode {
-    function create(keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode, valuePattern: PatternAsNode | ErrorNode): PatternMappingKeyEntryNode;
+    function create(key: ParseTreeKey, keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode, valuePattern: PatternAsNode | ErrorNode): PatternMappingKeyEntryNode;
 }
 export interface PatternMappingExpandEntryNode extends ParseNodeBase<ParseNodeType.PatternMappingExpandEntry> {
     d: {
@@ -869,7 +874,7 @@ export interface PatternMappingExpandEntryNode extends ParseNodeBase<ParseNodeTy
     };
 }
 export declare namespace PatternMappingExpandEntryNode {
-    function create(starStarToken: TextRange, target: NameNode): PatternMappingExpandEntryNode;
+    function create(key: ParseTreeKey, starStarToken: TextRange, target: NameNode): PatternMappingExpandEntryNode;
 }
 export interface PatternValueNode extends ParseNodeBase<ParseNodeType.PatternValue> {
     d: {
@@ -877,7 +882,7 @@ export interface PatternValueNode extends ParseNodeBase<ParseNodeType.PatternVal
     };
 }
 export declare namespace PatternValueNode {
-    function create(expr: MemberAccessNode): PatternValueNode;
+    function create(key: ParseTreeKey, expr: MemberAccessNode): PatternValueNode;
 }
 export type PatternAtomNode = PatternSequenceNode | PatternLiteralNode | PatternClassNode | PatternAsNode | PatternCaptureNode | PatternMappingNode | PatternValueNode | ErrorNode;
 export type ParseNode = ErrorNode | ArgumentNode | AssertNode | AssignmentExpressionNode | AssignmentNode | AugmentedAssignmentNode | AwaitNode | BinaryOperationNode | BreakNode | CallNode | CaseNode | ClassNode | ComprehensionNode | ComprehensionForNode | ComprehensionIfNode | ConstantNode | ContinueNode | DecoratorNode | DelNode | DictionaryNode | DictionaryExpandEntryNode | DictionaryKeyEntryNode | EllipsisNode | IfNode | ImportNode | ImportAsNode | ImportFromNode | ImportFromAsNode | IndexNode | ExceptNode | ForNode | FormatStringNode | FunctionNode | FunctionAnnotationNode | GlobalNode | LambdaNode | ListNode | MatchNode | MemberAccessNode | ModuleNameNode | ModuleNode | NameNode | NonlocalNode | NumberNode | ParameterNode | PassNode | PatternAsNode | PatternClassNode | PatternClassArgumentNode | PatternCaptureNode | PatternLiteralNode | PatternMappingExpandEntryNode | PatternMappingKeyEntryNode | PatternMappingNode | PatternSequenceNode | PatternValueNode | RaiseNode | ReturnNode | SetNode | SliceNode | StatementListNode | StringListNode | StringNode | SuiteNode | TernaryNode | TupleNode | TryNode | TypeAliasNode | TypeAnnotationNode | TypeParameterNode | TypeParameterListNode | UnaryOperationNode | UnpackNode | WhileNode | WithNode | WithItemNode | YieldNode | YieldFromNode;