Returns the most appropriate type of this argument when there is no specific declared type.

Infer all types for an [`Expression`] (including sub-expressions). Use rarely; only for cases where we'd otherwise risk double-inferring an expression

Converts the key back into its original URI.

Return `true` if `self` is a nominal instance of the given known class.

Returns `true` if a function definition is an `@override` (PEP 698).

Return `true` if this class constitutes a typed dict specification (inherits from `typing.TypedDict` or `typing_extensions.TypedDict`, either directly

Lookup a symbol in the current scope without materializing lazy builtins.

If `self` is a materialized `Divergent` type, returns the concrete type it should behave as: `object` for top-materialized, `Never` for bottom-materia

The total length of the string's opener, i.e., the length of the prefixes plus the length of the quotes used to open the string.

Return the original class literal for a class definition. For decorated classes, this is the class object before applying decorators. The public bind

Returns the parameter documentation recognized in a reST docstring. `normalized_source` must have already undergone PEP-257 trimming and universal ne

Parses every Python expression except unparenthesized tuple and named expressions. Matches the `expression` rule in the [Python grammar]. This uses

Normalize recursive types for cycle recovery when there's no previous value. See [`Type::recursive_type_normalized`] for more details.

Removes `rule` from the set. ## Examples ```rust # use ruff_linter::registry::{Rule, RuleSet}; let mut set = RuleSet::from_rules(&[Rule::AmbiguousFun

Returns the path to the test directory root.

Generate a [`Snapshot`] of the current semantic model.

Create a span with the range of the given expression in the file being currently type checked. If you're creating a diagnostic with snippets in files

Return a `TOMLDecodeError` where error message is suffixed with coordinates in source.

Return the zero-indexed primitive value for this [`OneIndexed`]

Attempts to convert the [`Parsed<Mod>`] into a [`Parsed<ModModule>`]. This method checks if the `syntax` field of the output is a [`Mod::Module`]. If

Given the type of an object that is iterated over in some way, return a tuple spec describing the type of objects that are yielded by that iteration.

Adds a type to this union.

Returns the scopes enclosing `node`, starting with the scope containing the node itself. Like [`Self::scope`], this handles nodes inside string annot

Applies an optional specialization to this specialization.

Returns `Some` if the reference is a `Symbol`, otherwise `None`.

If this type is a class instance, returns the class and its specialization.

Clear the parsed module, dropping the AST once all references to it are dropped.

Whether to enable colors or not.

The range of the string literal's contents. This excludes any prefixes, opening quotes or closing quotes.

Creates a new, empty virtual environment.

Create Ruff-style syntax error diagnostics for testing the various output formats.

Returns a nice debug representation that prints the source code for every comment (and not just the range).

Return the compact enum-complement view of this intersection, if it has one.

Returns the [`File`] attached to this [`Span`]. Panics if the file is a [`UnifiedFile::Ruff`] instead of a [`UnifiedFile::Ty`].

Returns all of the explicit base class types for this class. Note that when this is a namedtuple this always returns a sequence of length one corresp

Returns the `Span` associated with this annotation.

Returns the identifier for this diagnostic.

Test whether the given binding can be considered a dictionary. For this, we check what value might be associated with it through it's initialization,

Returns `true` if a function has an empty body, and is therefore a stub. A function body is considered to be empty if it contains only `pass` stateme

Returns an iterator over every symbol along with its ID.

Returns the [byte offsets](TextSize) for every line

Returns an iterator over the [`StringLiteral`] parts contained in this value. Note that this doesn't recurse into the f-string parts. For example, `