102c2eec12
## Summary
Add support for implicitly-defined instance attributes, i.e. support
type inference for cases like this:
```py
class C:
def __init__(self) -> None:
self.x: int = 1
self.y = None
reveal_type(C().x) # int
reveal_type(C().y) # Unknown | None
```
## Benchmarks
Codspeed reports no change in a cold-cache benchmark, and a -1%
regression in the incremental benchmark. On `black`'s `src` folder, I
don't see a statistically significant difference between the branches:
| Command | Mean [ms] | Min [ms] | Max [ms] | Relative |
|:---|---:|---:|---:|---:|
| `./red_knot_main check --project /home/shark/black/src` | 133.7 ± 9.5 | 126.7 | 164.7 | 1.01 ± 0.08 |
| `./red_knot_feature check --project /home/shark/black/src` | 132.2 ± 5.1 | 118.1 | 140.9 | 1.00 |
## Test Plan
Updated and new Markdown tests
61 lines
1.8 KiB
Rust
61 lines
1.8 KiB
Rust
use crate::ast_node_ref::AstNodeRef;
|
|
use crate::db::Db;
|
|
use crate::semantic_index::symbol::{FileScopeId, ScopeId};
|
|
use ruff_db::files::File;
|
|
use ruff_python_ast as ast;
|
|
use salsa;
|
|
|
|
/// Whether or not this expression should be inferred as a normal expression or
|
|
/// a type expression. For example, in `self.x: <annotation> = <value>`, the
|
|
/// `<annotation>` is inferred as a type expression, while `<value>` is inferred
|
|
/// as a normal expression.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub(crate) enum ExpressionKind {
|
|
Normal,
|
|
TypeExpression,
|
|
}
|
|
|
|
/// An independently type-inferable expression.
|
|
///
|
|
/// Includes constraint expressions (e.g. if tests) and the RHS of an unpacking assignment.
|
|
///
|
|
/// ## Module-local type
|
|
/// This type should not be used as part of any cross-module API because
|
|
/// it holds a reference to the AST node. Range-offset changes
|
|
/// then propagate through all usages, and deserialization requires
|
|
/// reparsing the entire module.
|
|
///
|
|
/// E.g. don't use this type in:
|
|
///
|
|
/// * a return type of a cross-module query
|
|
/// * a field of a type that is a return type of a cross-module query
|
|
/// * an argument of a cross-module query
|
|
#[salsa::tracked]
|
|
pub(crate) struct Expression<'db> {
|
|
/// The file in which the expression occurs.
|
|
#[id]
|
|
pub(crate) file: File,
|
|
|
|
/// The scope in which the expression occurs.
|
|
#[id]
|
|
pub(crate) file_scope: FileScopeId,
|
|
|
|
/// The expression node.
|
|
#[no_eq]
|
|
#[return_ref]
|
|
pub(crate) node_ref: AstNodeRef<ast::Expr>,
|
|
|
|
/// Should this expression be inferred as a normal expression or a type expression?
|
|
#[id]
|
|
pub(crate) kind: ExpressionKind,
|
|
|
|
#[no_eq]
|
|
count: countme::Count<Expression<'static>>,
|
|
}
|
|
|
|
impl<'db> Expression<'db> {
|
|
pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
|
|
self.file_scope(db).to_scope_id(db, self.file(db))
|
|
}
|
|
}
|