[antlr4-python3-runtime] Fixed multiple Incomplete (#15038)

2026-05-04 20:45:49 +08:00 · 2025-11-17 13:06:24 +05:00
parent 58da238f50
commit 09da7a473b
13 changed files with 282 additions and 227 deletions
@@ -1,19 +1,18 @@
-from _typeshed import Incomplete
-
 from antlr4.error.Errors import IllegalStateException as IllegalStateException
+from antlr4.Lexer import Lexer as ActualLexer, TokenSource
 from antlr4.Token import Token as Token

-Lexer: Incomplete
+Lexer: None

 class TokenStream: ...

 class BufferedTokenStream(TokenStream):
    __slots__ = ("tokenSource", "tokens", "index", "fetchedEOF")
-    tokenSource: Incomplete
-    tokens: Incomplete
+    tokenSource: TokenSource
+    tokens: list[Token]
    index: int
    fetchedEOF: bool
-    def __init__(self, tokenSource: Lexer) -> None: ...
+    def __init__(self, tokenSource: ActualLexer | None) -> None: ...
    def mark(self) -> int: ...
    def release(self, marker: int) -> None: ...
    def reset(self) -> None: ...
@@ -26,15 +25,15 @@ class BufferedTokenStream(TokenStream):
    def LA(self, i: int) -> int: ...
    def LB(self, k: int) -> Token | None: ...
    def LT(self, k: int) -> Token | None: ...
-    def adjustSeekIndex(self, i: int): ...
+    def adjustSeekIndex(self, i: int) -> int: ...
    def lazyInit(self) -> None: ...
    def setup(self) -> None: ...
-    def setTokenSource(self, tokenSource: Lexer): ...
-    def nextTokenOnChannel(self, i: int, channel: int): ...
-    def previousTokenOnChannel(self, i: int, channel: int): ...
-    def getHiddenTokensToRight(self, tokenIndex: int, channel: int = -1): ...
-    def getHiddenTokensToLeft(self, tokenIndex: int, channel: int = -1): ...
-    def filterForChannel(self, left: int, right: int, channel: int): ...
-    def getSourceName(self): ...
-    def getText(self, start: int | None = None, stop: int | None = None): ...
+    def setTokenSource(self, tokenSource: ActualLexer | None) -> None: ...
+    def nextTokenOnChannel(self, i: int, channel: int) -> int: ...
+    def previousTokenOnChannel(self, i: int, channel: int) -> int: ...
+    def getHiddenTokensToRight(self, tokenIndex: int, channel: int = -1) -> list[Token] | None: ...
+    def getHiddenTokensToLeft(self, tokenIndex: int, channel: int = -1) -> list[Token] | None: ...
+    def filterForChannel(self, left: int, right: int, channel: int) -> list[Token] | None: ...
+    def getSourceName(self) -> str: ...
+    def getText(self, start: int | None = None, stop: int | None = None) -> str: ...
    def fill(self) -> None: ...
@@ -1,15 +1,23 @@
-from _typeshed import Incomplete
-
+from antlr4.InputStream import InputStream
+from antlr4.Lexer import TokenSource
 from antlr4.Token import CommonToken as CommonToken

 class TokenFactory: ...

 class CommonTokenFactory(TokenFactory):
    __slots__ = "copyText"
-    DEFAULT: Incomplete
-    copyText: Incomplete
+    DEFAULT: CommonTokenFactory | None
+    copyText: bool
    def __init__(self, copyText: bool = False) -> None: ...
    def create(
-        self, source: tuple[Incomplete, ...], type: int, text: str, channel: int, start: int, stop: int, line: int, column: int
-    ): ...
-    def createThin(self, type: int, text: str): ...
+        self,
+        source: tuple[TokenSource, InputStream],
+        type: int,
+        text: str,
+        channel: int,
+        start: int,
+        stop: int,
+        line: int,
+        column: int,
+    ) -> CommonToken: ...
+    def createThin(self, type: int, text: str) -> CommonToken: ...
@@ -1,12 +1,10 @@
-from _typeshed import Incomplete
-
 from antlr4.BufferedTokenStream import BufferedTokenStream as BufferedTokenStream
 from antlr4.Lexer import Lexer as Lexer
 from antlr4.Token import Token as Token

 class CommonTokenStream(BufferedTokenStream):
    __slots__ = "channel"
-    channel: Incomplete
+    channel: int
    def __init__(self, lexer: Lexer, channel: int = 0) -> None: ...
    def adjustSeekIndex(self, i: int) -> int: ...
    def LB(self, k: int) -> Token | None: ...
@@ -1,9 +1,7 @@
-from _typeshed import Incomplete
-
 from antlr4.InputStream import InputStream as InputStream

 class FileStream(InputStream):
    __slots__ = "fileName"
-    fileName: Incomplete
+    fileName: str
    def __init__(self, fileName: str, encoding: str = "ascii", errors: str = "strict") -> None: ...
-    def readDataFrom(self, fileName: str, encoding: str, errors: str = "strict"): ...
+    def readDataFrom(self, fileName: str, encoding: str, errors: str = "strict") -> str: ...
@@ -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: ...
@@ -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: ...
@@ -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: ...
@@ -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: ...
@@ -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: ...
@@ -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: ...
@@ -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: ...
@@ -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: ...
@@ -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: ...