basedpyright 1.36.2 → 1.37.0-961d59bacff1958014fe4e9ed2ef3116fe2266e2

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/InputStream.pyi

@@ -1,22 +1,24 @@
-from _typeshed import Incomplete
+from typing import Literal
 
 from antlr4.Token import Token as Token
 
 class InputStream:
     __slots__ = ("name", "strdata", "_index", "data", "_size")
     name: str
-    strdata: Incomplete
-    data: Incomplete
+    strdata: str
+    data: list[int]
+    _index: int
+    _size: int
     def __init__(self, data: str) -> None: ...
     @property
-    def index(self): ...
+    def index(self) -> int: ...
     @property
-    def size(self): ...
+    def size(self) -> int: ...
     def reset(self) -> None: ...
     def consume(self) -> None: ...
-    def LA(self, offset: int): ...
-    def LT(self, offset: int): ...
-    def mark(self): ...
-    def release(self, marker: int): ...
-    def seek(self, _index: int): ...
-    def getText(self, start: int, stop: int): ...
+    def LA(self, offset: int) -> int: ...
+    def LT(self, offset: int) -> int: ...
+    def mark(self) -> Literal[-1]: ...
+    def release(self, marker: int) -> None: ...
+    def seek(self, _index: int) -> None: ...
+    def getText(self, start: int, stop: int) -> str: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/Lexer.pyi

@@ -1,4 +1,3 @@
-from _typeshed import Incomplete
 from typing import TextIO
 
 from antlr4.atn.LexerATNSimulator import LexerATNSimulator as LexerATNSimulator
@@ -10,7 +9,7 @@ from antlr4.error.Errors import (
 )
 from antlr4.InputStream import InputStream as InputStream
 from antlr4.Recognizer import Recognizer as Recognizer
-from antlr4.Token import Token as Token
+from antlr4.Token import CommonToken, Token as Token
 
 class TokenSource: ...
 
@@ -34,47 +33,62 @@ class Lexer(Recognizer, TokenSource):
     DEFAULT_MODE: int
     MORE: int
     SKIP: int
-    DEFAULT_TOKEN_CHANNEL: Incomplete
-    HIDDEN: Incomplete
+    DEFAULT_TOKEN_CHANNEL: int
+    HIDDEN: int
     MIN_CHAR_VALUE: int
     MAX_CHAR_VALUE: int
+    _input: InputStream
+    _output: TextIO
+    _factory: CommonTokenFactory
+    _tokenFactorySourcePair: tuple[TokenSource, InputStream]
+    _interp: LexerATNSimulator
+    _token: Token | None
+    _tokenStartCharIndex: int
+    _tokenStartLine: int
+    _tokenStartColumn: int
+    _hitEOF: bool
+    _channel: int
+    _type: int
+    _modeStack: list[int]
+    _mode: int
+    _text: str | None
     def __init__(self, input: InputStream, output: TextIO = ...) -> None: ...
     def reset(self) -> None: ...
-    def nextToken(self): ...
+    def nextToken(self) -> Token | None: ...
     def skip(self) -> None: ...
     def more(self) -> None: ...
-    def mode(self, m: int): ...
-    def pushMode(self, m: int): ...
-    def popMode(self): ...
+    def mode(self, m: int) -> None: ...
+    def pushMode(self, m: int) -> None: ...
+    def popMode(self) -> int: ...
     @property
-    def inputStream(self): ...
+    def inputStream(self) -> InputStream: ...
     @inputStream.setter
-    def inputStream(self, input: InputStream): ...
+    def inputStream(self, input: InputStream) -> None: ...
     @property
-    def sourceName(self): ...
-    def emitToken(self, token: Token): ...
-    def emit(self): ...
-    def emitEOF(self): ...
+    def sourceName(self) -> str: ...
+    def emitToken(self, token: Token) -> None: ...
+    def emit(self) -> CommonToken: ...
+    def emitEOF(self) -> CommonToken: ...
     @property
-    def type(self): ...
+    def type(self) -> int: ...
     @type.setter
-    def type(self, type: int): ...
+    def type(self, type: int) -> None: ...
     @property
-    def line(self): ...
+    def line(self) -> int: ...
     @line.setter
-    def line(self, line: int): ...
+    def line(self, line: int) -> None: ...
     @property
-    def column(self): ...
+    def column(self) -> int: ...
     @column.setter
-    def column(self, column: int): ...
-    def getCharIndex(self): ...
+    def column(self, column: int) -> None: ...
+    def getCharIndex(self) -> int: ...
     @property
-    def text(self): ...
+    def text(self) -> str: ...
     @text.setter
-    def text(self, txt: str): ...
-    def getAllTokens(self): ...
-    def notifyListeners(self, e: LexerNoViableAltException): ...
-    def getErrorDisplay(self, s: str): ...
-    def getErrorDisplayForChar(self, c: str): ...
-    def getCharErrorDisplay(self, c: str): ...
-    def recover(self, re: RecognitionException): ...
+    def text(self, txt: str) -> None: ...
+    def getAllTokens(self) -> list[Token]: ...
+    def notifyListeners(self, e: LexerNoViableAltException) -> None: ...
+    def getErrorDisplay(self, s: str) -> str: ...
+    def getErrorDisplayForChar(self, c: str) -> str: ...
+    def getCharErrorDisplay(self, c: str) -> str: ...
+    def recover(self, re: RecognitionException) -> None: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/Parser.pyi

@@ -1,8 +1,9 @@
 from _typeshed import Incomplete
-from typing import TextIO
+from typing import Literal, TextIO
 
 from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions as ATNDeserializationOptions
 from antlr4.atn.ATNDeserializer import ATNDeserializer as ATNDeserializer
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator
 from antlr4.BufferedTokenStream import TokenStream as TokenStream
 from antlr4.CommonTokenFactory import TokenFactory as TokenFactory
 from antlr4.error.Errors import (
@@ -16,6 +17,7 @@ from antlr4.ParserRuleContext import ParserRuleContext as ParserRuleContext
 from antlr4.Recognizer import Recognizer as Recognizer
 from antlr4.RuleContext import RuleContext as RuleContext
 from antlr4.Token import Token as Token
+from antlr4.tree.ParseTreePattern import ParseTreePattern
 from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher as ParseTreePatternMatcher
 from antlr4.tree.Tree import ErrorNode as ErrorNode, ParseTreeListener as ParseTreeListener, TerminalNode as TerminalNode
 
@@ -39,48 +41,59 @@ class Parser(Recognizer):
         "_parseListeners",
         "_syntaxErrors",
     )
-    bypassAltsAtnCache: Incomplete
+    _input: TokenStream
+    _output: TextIO
+    _errHandler: DefaultErrorStrategy
+    _precedenceStack: list[int]
+    _ctx: ParserRuleContext | None
+    _tracer: TraceListener | None
+    _parseListeners: list[ParseTreeListener]
+    _syntaxErrors: int
+    _interp: ParserATNSimulator
+    bypassAltsAtnCache: dict[Incomplete, Incomplete]
     buildParseTrees: bool
     def __init__(self, input: TokenStream, output: TextIO = ...) -> None: ...
     def reset(self) -> None: ...
-    def match(self, ttype: int): ...
-    def matchWildcard(self): ...
-    def getParseListeners(self): ...
-    def addParseListener(self, listener: ParseTreeListener): ...
-    def removeParseListener(self, listener: ParseTreeListener): ...
+    def match(self, ttype: int) -> Token: ...
+    def matchWildcard(self) -> Token: ...
+    def getParseListeners(self) -> list[ParseTreeListener]: ...
+    def addParseListener(self, listener: ParseTreeListener) -> None: ...
+    def removeParseListener(self, listener: ParseTreeListener) -> None: ...
     def removeParseListeners(self) -> None: ...
     def triggerEnterRuleEvent(self) -> None: ...
     def triggerExitRuleEvent(self) -> None: ...
-    def getNumberOfSyntaxErrors(self): ...
-    def getTokenFactory(self): ...
-    def setTokenFactory(self, factory: TokenFactory): ...
+    def getNumberOfSyntaxErrors(self) -> int: ...
+    def getTokenFactory(self) -> TokenFactory: ...
+    def setTokenFactory(self, factory: TokenFactory) -> None: ...
     def getATNWithBypassAlts(self): ...
-    def compileParseTreePattern(self, pattern: str, patternRuleIndex: int, lexer: Lexer | None = None): ...
-    def getInputStream(self): ...
-    def setInputStream(self, input: InputStream): ...
-    def getTokenStream(self): ...
-    def setTokenStream(self, input: TokenStream): ...
-    def getCurrentToken(self): ...
-    def notifyErrorListeners(self, msg: str, offendingToken: Token | None = None, e: RecognitionException | None = None): ...
-    def consume(self): ...
+    def compileParseTreePattern(self, pattern: str, patternRuleIndex: int, lexer: Lexer | None = None) -> ParseTreePattern: ...
+    def getInputStream(self) -> InputStream: ...
+    def setInputStream(self, input: InputStream) -> None: ...
+    def getTokenStream(self) -> TokenStream: ...
+    def setTokenStream(self, input: TokenStream) -> None: ...
+    def getCurrentToken(self) -> Token | None: ...
+    def notifyErrorListeners(
+        self, msg: str, offendingToken: Token | None = None, e: RecognitionException | None = None
+    ) -> None: ...
+    def consume(self) -> None: ...
     def addContextToParseTree(self) -> None: ...
-    state: Incomplete
-    def enterRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int): ...
+    state: int
+    def enterRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int) -> None: ...
     def exitRule(self) -> None: ...
-    def enterOuterAlt(self, localctx: ParserRuleContext, altNum: int): ...
-    def getPrecedence(self): ...
-    def enterRecursionRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int, precedence: int): ...
-    def pushNewRecursionContext(self, localctx: ParserRuleContext, state: int, ruleIndex: int): ...
-    def unrollRecursionContexts(self, parentCtx: ParserRuleContext): ...
-    def getInvokingContext(self, ruleIndex: int): ...
-    def precpred(self, localctx: RuleContext, precedence: int): ...
-    def inContext(self, context: str): ...
-    def isExpectedToken(self, symbol: int): ...
+    def enterOuterAlt(self, localctx: ParserRuleContext, altNum: int) -> None: ...
+    def getPrecedence(self) -> int: ...
+    def enterRecursionRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int, precedence: int) -> None: ...
+    def pushNewRecursionContext(self, localctx: ParserRuleContext, state: int, ruleIndex: int) -> None: ...
+    def unrollRecursionContexts(self, parentCtx: ParserRuleContext) -> None: ...
+    def getInvokingContext(self, ruleIndex: int) -> RuleContext | None: ...
+    def precpred(self, localctx: RuleContext, precedence: int) -> bool: ...
+    def inContext(self, context: str) -> Literal[False]: ...
+    def isExpectedToken(self, symbol: int) -> bool: ...
     def getExpectedTokens(self): ...
     def getExpectedTokensWithinCurrentRule(self): ...
-    def getRuleIndex(self, ruleName: str): ...
-    def getRuleInvocationStack(self, p: RuleContext | None = None): ...
-    def getDFAStrings(self): ...
+    def getRuleIndex(self, ruleName: str) -> int: ...
+    def getRuleInvocationStack(self, p: RuleContext | None = None) -> list[str]: ...
+    def getDFAStrings(self) -> list[str]: ...
     def dumpDFA(self) -> None: ...
-    def getSourceName(self): ...
-    def setTrace(self, trace: bool): ...
+    def getSourceName(self) -> str: ...
+    def setTrace(self, trace: bool) -> None: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/ParserInterpreter.pyi

@@ -28,19 +28,19 @@ class ParserInterpreter(Parser):
         "_parentContextStack",
         "pushRecursionContextStates",
     )
-    grammarFileName: Incomplete
-    atn: Incomplete
-    tokenNames: Incomplete
-    ruleNames: Incomplete
-    decisionToDFA: Incomplete
-    sharedContextCache: Incomplete
-    pushRecursionContextStates: Incomplete
+    grammarFileName: str
+    atn: ATN
+    tokenNames: list[Incomplete]
+    ruleNames: list[str]
+    decisionToDFA: list[DFA]
+    sharedContextCache: PredictionContextCache
+    pushRecursionContextStates: set[int]
     def __init__(
         self, grammarFileName: str, tokenNames: list[str], ruleNames: list[str], atn: ATN, input: TokenStream
     ) -> None: ...
-    state: Incomplete
-    def parse(self, startRuleIndex: int): ...
-    def enterRecursionRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int, precedence: int): ...
-    def getATNState(self): ...
-    def visitState(self, p: ATNState): ...
-    def visitRuleStopState(self, p: ATNState): ...
+    state: int
+    def parse(self, startRuleIndex: int) -> ParserRuleContext | None: ...
+    def enterRecursionRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int, precedence: int) -> None: ...
+    def getATNState(self) -> ATNState: ...
+    def visitState(self, p: ATNState) -> None: ...
+    def visitRuleStopState(self, p: ATNState) -> None: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/ParserRuleContext.pyi

@@ -1,6 +1,7 @@
-from _typeshed import Incomplete
-from collections.abc import Generator
+from collections.abc import Callable, Generator
+from typing import TypeVar
 
+from antlr4.error.Errors import RecognitionException
 from antlr4.RuleContext import RuleContext as RuleContext
 from antlr4.Token import Token as Token
 from antlr4.tree.Tree import (
@@ -14,29 +15,35 @@ from antlr4.tree.Tree import (
 
 class ParserRuleContext(RuleContext):
     __slots__ = ("children", "start", "stop", "exception")
-    children: Incomplete
-    start: Incomplete
-    stop: Incomplete
-    exception: Incomplete
+    children: list[ParseTree | TerminalNode] | None
+    start: Token | None
+    stop: Token | None
+    exception: RecognitionException | None
     def __init__(self, parent: ParserRuleContext | None = None, invokingStateNumber: int | None = None) -> None: ...
-    parentCtx: Incomplete
-    invokingState: Incomplete
-    def copyFrom(self, ctx: ParserRuleContext): ...
-    def enterRule(self, listener: ParseTreeListener): ...
-    def exitRule(self, listener: ParseTreeListener): ...
-    def addChild(self, child: ParseTree): ...
+    parentCtx: RuleContext | None
+    invokingState: int
+    def copyFrom(self, ctx: ParserRuleContext) -> None: ...
+    def enterRule(self, listener: ParseTreeListener) -> None: ...
+    def exitRule(self, listener: ParseTreeListener) -> None: ...
+    def addChild(self, child: _ParseTreeT) -> _ParseTreeT: ...
     def removeLastChild(self) -> None: ...
-    def addTokenNode(self, token: Token): ...
-    def addErrorNode(self, badToken: Token): ...
-    def getChild(self, i: int, ttype: type | None = None): ...
-    def getChildren(self, predicate=None) -> Generator[Incomplete, None, None]: ...
-    def getToken(self, ttype: int, i: int): ...
-    def getTokens(self, ttype: int): ...
-    def getTypedRuleContext(self, ctxType: type, i: int): ...
-    def getTypedRuleContexts(self, ctxType: type): ...
-    def getChildCount(self): ...
-    def getSourceInterval(self): ...
+    def addTokenNode(self, token: Token) -> TerminalNodeImpl: ...
+    def addErrorNode(self, badToken: Token) -> ErrorNodeImpl: ...
+    def getChild(self, i: int, ttype: type[_GenericType] | None = None) -> _GenericType | None: ...
+    def getChildren(
+        self, predicate: Callable[[ParseTree | TerminalNode], bool] | None = None
+    ) -> Generator[ParseTree | TerminalNode, None, None]: ...
+    def getToken(self, ttype: int, i: int) -> TerminalNode | None: ...
+    def getTokens(self, ttype: int) -> list[TerminalNode]: ...
+    def getTypedRuleContext(self, ctxType: type[_ParserRuleContextT], i: int) -> _ParserRuleContextT | None: ...
+    def getTypedRuleContexts(self, ctxType: type[_ParserRuleContextT]) -> list[_ParserRuleContextT]: ...
+    def getChildCount(self) -> int: ...
+    def getSourceInterval(self) -> tuple[int | None, int | None]: ...
+
+_GenericType = TypeVar("_GenericType", bound=type)
+_ParseTreeT = TypeVar("_ParseTreeT", bound=ParseTree)
+_ParserRuleContextT = TypeVar("_ParserRuleContextT", bound=ParserRuleContext)
 
 class InterpreterRuleContext(ParserRuleContext):
-    ruleIndex: Incomplete
+    ruleIndex: int
     def __init__(self, parent: ParserRuleContext, invokingStateNumber: int, ruleIndex: int) -> None: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/Recognizer.pyi

@@ -1,28 +1,37 @@
 from _typeshed import Incomplete
 
-from antlr4.error.ErrorListener import ConsoleErrorListener as ConsoleErrorListener, ProxyErrorListener as ProxyErrorListener
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.error.ErrorListener import (
+    ConsoleErrorListener as ConsoleErrorListener,
+    ErrorListener,
+    ProxyErrorListener as ProxyErrorListener,
+)
+from antlr4.error.Errors import RecognitionException
 from antlr4.RuleContext import RuleContext as RuleContext
 from antlr4.Token import Token as Token
 
 class Recognizer:
     __slots__ = ("_listeners", "_interp", "_stateNumber")
-    tokenTypeMapCache: Incomplete
-    ruleIndexMapCache: Incomplete
+    tokenTypeMapCache: dict[Incomplete, int]
+    ruleIndexMapCache: dict[str, int]
+    _listeners: list[ErrorListener]
+    _interp: ATNSimulator | None
+    _stateNumber: int
     def __init__(self) -> None: ...
-    def extractVersion(self, version): ...
-    def checkVersion(self, toolVersion) -> None: ...
-    def addErrorListener(self, listener) -> None: ...
-    def removeErrorListener(self, listener) -> None: ...
+    def extractVersion(self, version: str) -> tuple[str, str]: ...
+    def checkVersion(self, toolVersion: str) -> None: ...
+    def addErrorListener(self, listener: ErrorListener) -> None: ...
+    def removeErrorListener(self, listener: ErrorListener) -> None: ...
     def removeErrorListeners(self) -> None: ...
-    def getTokenTypeMap(self): ...
-    def getRuleIndexMap(self): ...
-    def getTokenType(self, tokenName: str): ...
-    def getErrorHeader(self, e): ...
-    def getTokenErrorDisplay(self, t: Token): ...
-    def getErrorListenerDispatch(self): ...
-    def sempred(self, localctx: RuleContext, ruleIndex: int, actionIndex: int): ...
-    def precpred(self, localctx: RuleContext, precedence: int): ...
+    def getTokenTypeMap(self) -> dict[Incomplete, int]: ...
+    def getRuleIndexMap(self) -> dict[str, int]: ...
+    def getTokenType(self, tokenName: str) -> int: ...
+    def getErrorHeader(self, e: RecognitionException) -> str: ...
+    def getTokenErrorDisplay(self, t: Token | None) -> str: ...
+    def getErrorListenerDispatch(self) -> ProxyErrorListener: ...
+    def sempred(self, localctx: RuleContext, ruleIndex: int, actionIndex: int) -> bool: ...
+    def precpred(self, localctx: RuleContext, precedence: int) -> bool: ...
     @property
-    def state(self): ...
+    def state(self) -> int: ...
     @state.setter
-    def state(self, atnState: int): ...
+    def state(self, atnState: int) -> None: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/RuleContext.pyi

@@ -1,29 +1,31 @@
-from _typeshed import Incomplete
 from collections.abc import Generator
+from typing import Any, Literal
+from typing_extensions import Self
 
+from antlr4.Recognizer import Recognizer
 from antlr4.tree.Tree import INVALID_INTERVAL as INVALID_INTERVAL, ParseTreeVisitor as ParseTreeVisitor, RuleNode as RuleNode
 from antlr4.tree.Trees import Trees as Trees
 
-Parser: Incomplete
+Parser: None
 
 class RuleContext(RuleNode):
     __slots__ = ("parentCtx", "invokingState")
-    EMPTY: Incomplete
-    parentCtx: Incomplete
-    invokingState: Incomplete
+    EMPTY: RuleContext | None
+    parentCtx: RuleContext | None
+    invokingState: int
     def __init__(self, parent: RuleContext | None = None, invokingState: int = -1) -> None: ...
-    def depth(self): ...
-    def isEmpty(self): ...
-    def getSourceInterval(self): ...
-    def getRuleContext(self): ...
-    def getPayload(self): ...
-    def getText(self): ...
-    def getRuleIndex(self): ...
-    def getAltNumber(self): ...
-    def setAltNumber(self, altNumber: int): ...
-    def getChild(self, i: int): ...
-    def getChildCount(self): ...
-    def getChildren(self) -> Generator[Incomplete, None, None]: ...
-    def accept(self, visitor: ParseTreeVisitor): ...
-    def toStringTree(self, ruleNames: list[Incomplete] | None = None, recog: Parser | None = None): ...
-    def toString(self, ruleNames: list[Incomplete], stop: RuleContext) -> str: ...
+    def depth(self) -> int: ...
+    def isEmpty(self) -> bool: ...
+    def getSourceInterval(self) -> tuple[int | None, int | None]: ...
+    def getRuleContext(self) -> Self: ...
+    def getPayload(self) -> Self: ...
+    def getText(self) -> str: ...
+    def getRuleIndex(self) -> Literal[-1]: ...
+    def getAltNumber(self) -> Literal[0]: ...
+    def setAltNumber(self, altNumber: int) -> None: ...
+    def getChild(self, i: int) -> Any: ...
+    def getChildCount(self) -> int: ...
+    def getChildren(self) -> Generator[Any, None, None]: ...
+    def accept(self, visitor: ParseTreeVisitor) -> None: ...
+    def toStringTree(self, ruleNames: list[str] | None = None, recog: Recognizer | None = None) -> str: ...
+    def toString(self, ruleNames: list[str], stop: RuleContext) -> str: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/Token.pyi

@@ -1,4 +1,5 @@
-from _typeshed import Incomplete
+from antlr4.InputStream import InputStream
+from antlr4.Lexer import TokenSource
 
 class Token:
     __slots__ = ("source", "type", "channel", "start", "stop", "tokenIndex", "line", "column", "_text")
@@ -8,42 +9,42 @@ class Token:
     EOF: int
     DEFAULT_CHANNEL: int
     HIDDEN_CHANNEL: int
-    source: Incomplete
-    type: Incomplete
-    channel: Incomplete
-    start: Incomplete
-    stop: Incomplete
-    tokenIndex: Incomplete
-    line: Incomplete
-    column: Incomplete
+    source: tuple[TokenSource | None, InputStream | None]
+    type: int
+    channel: int
+    start: int
+    stop: int
+    tokenIndex: int | None
+    line: int
+    column: int
     def __init__(self) -> None: ...
     @property
-    def text(self): ...
+    def text(self) -> str: ...
     @text.setter
-    def text(self, text: str): ...
-    def getTokenSource(self): ...
-    def getInputStream(self): ...
+    def text(self, text: str) -> None: ...
+    def getTokenSource(self) -> TokenSource | None: ...
+    def getInputStream(self) -> InputStream | None: ...
 
 class CommonToken(Token):
-    EMPTY_SOURCE: Incomplete
-    source: Incomplete
-    type: Incomplete
-    channel: Incomplete
-    start: Incomplete
-    stop: Incomplete
+    EMPTY_SOURCE: tuple[None, None]
+    source: tuple[TokenSource | None, InputStream | None]
+    type: int
+    channel: int
+    start: int
+    stop: int
     tokenIndex: int
-    line: Incomplete
-    column: Incomplete
+    line: int
+    column: int
     def __init__(
         self,
-        source: tuple[Incomplete, Incomplete] = (None, None),
+        source: tuple[TokenSource | None, InputStream | None] = (None, None),
         type: int | None = None,
         channel: int = 0,
         start: int = -1,
         stop: int = -1,
     ) -> None: ...
-    def clone(self): ...
+    def clone(self) -> CommonToken: ...
     @property
-    def text(self): ...
+    def text(self) -> str: ...
     @text.setter
-    def text(self, text: str): ...
+    def text(self, text: str) -> None: ...

package/dist/typeshed-fallback/stubs/antlr4-python3-runtime/antlr4/tree/Tree.pyi

@@ -1,5 +1,7 @@
 from _typeshed import Incomplete
+from typing import Any, Literal, TypeVar
 
+from antlr4.ParserRuleContext import ParserRuleContext, RuleContext
 from antlr4.Token import Token as Token
 
 INVALID_INTERVAL: Incomplete
@@ -11,42 +13,44 @@ class RuleNode(ParseTree): ...
 class TerminalNode(ParseTree): ...
 class ErrorNode(TerminalNode): ...
 
+_GenericType = TypeVar("_GenericType", bound=type)
+
 class ParseTreeVisitor:
-    def visit(self, tree): ...
-    def visitChildren(self, node): ...
-    def visitTerminal(self, node): ...
-    def visitErrorNode(self, node): ...
+    def visit(self, tree: Tree) -> None: ...
+    def visitChildren(self, node) -> None: ...
+    def visitTerminal(self, node: TerminalNode) -> None: ...
+    def visitErrorNode(self, node: ErrorNode) -> None: ...
     def defaultResult(self) -> None: ...
-    def aggregateResult(self, aggregate, nextResult): ...
-    def shouldVisitNextChild(self, node, currentResult): ...
+    def aggregateResult(self, aggregate, nextResult: _GenericType) -> _GenericType: ...
+    def shouldVisitNextChild(self, node, currentResult) -> Literal[True]: ...
 
 class ParseTreeListener:
-    def visitTerminal(self, node: TerminalNode): ...
-    def visitErrorNode(self, node: ErrorNode): ...
-    def enterEveryRule(self, ctx): ...
-    def exitEveryRule(self, ctx): ...
+    def visitTerminal(self, node: TerminalNode) -> None: ...
+    def visitErrorNode(self, node: ErrorNode) -> None: ...
+    def enterEveryRule(self, ctx: ParserRuleContext) -> None: ...
+    def exitEveryRule(self, ctx: ParserRuleContext) -> None: ...
 
 class TerminalNodeImpl(TerminalNode):
     __slots__ = ("parentCtx", "symbol")
-    parentCtx: Incomplete
-    symbol: Incomplete
+    parentCtx: RuleContext | None
+    symbol: Token
     def __init__(self, symbol: Token) -> None: ...
-    def __setattr__(self, key, value) -> None: ...
-    def getChild(self, i: int): ...
-    def getSymbol(self): ...
-    def getParent(self): ...
-    def getPayload(self): ...
-    def getSourceInterval(self): ...
-    def getChildCount(self): ...
-    def accept(self, visitor: ParseTreeVisitor): ...
-    def getText(self): ...
+    def __setattr__(self, key: str, value: Any) -> None: ...
+    def getChild(self, i: int) -> None: ...
+    def getSymbol(self) -> Token: ...
+    def getParent(self) -> RuleContext | None: ...
+    def getPayload(self) -> Token: ...
+    def getSourceInterval(self) -> tuple[Literal[-1], Literal[-2]] | tuple[int | None, int | None]: ...
+    def getChildCount(self) -> Literal[0]: ...
+    def accept(self, visitor: ParseTreeVisitor) -> None: ...
+    def getText(self) -> str: ...
 
 class ErrorNodeImpl(TerminalNodeImpl, ErrorNode):
     def __init__(self, token: Token) -> None: ...
-    def accept(self, visitor: ParseTreeVisitor): ...
+    def accept(self, visitor: ParseTreeVisitor) -> None: ...
 
 class ParseTreeWalker:
-    DEFAULT: Incomplete
-    def walk(self, listener: ParseTreeListener, t: ParseTree): ...
-    def enterRule(self, listener: ParseTreeListener, r: RuleNode): ...
-    def exitRule(self, listener: ParseTreeListener, r: RuleNode): ...
+    DEFAULT: ParseTreeWalker
+    def walk(self, listener: ParseTreeListener, t: ParseTree) -> None: ...
+    def enterRule(self, listener: ParseTreeListener, r: RuleNode) -> None: ...
+    def exitRule(self, listener: ParseTreeListener, r: RuleNode) -> None: ...