[red-knot] definition-level inference

crates/red_knot/src/lint.rs

@@ -130,11 +130,7 @@ fn lint_bad_override(context: &SemanticLintContext, class: &ast::StmtClassDef) {
         return;
     };
 
-    let Some(typing_override) = semantic.public_symbol(&typing, "override") else {
-        return;
-    };
-
-    let override_ty = semantic.public_symbol_ty(typing_override);
+    let override_ty = semantic.module_global_symbol_ty(&typing, "override");
 
     let Type::Class(class_ty) = class.ty(semantic) else {
         return;
@@ -154,7 +150,10 @@ fn lint_bad_override(context: &SemanticLintContext, class: &ast::StmtClassDef) {
 
         if ty.has_decorator(db, override_ty) {
             let method_name = ty.name(db);
-            if class_ty.inherited_class_member(db, &method_name).is_none() {
+            if class_ty
+                .inherited_class_member(db, &method_name)
+                .is_unbound()
+            {
                 // TODO should have a qualname() method to support nested classes
                 context.push_diagnostic(
                     format!(

crates/red_knot_python_semantic/src/ast_node_ref.rs

@@ -27,12 +27,13 @@ pub struct AstNodeRef<T> {
 
 #[allow(unsafe_code)]
 impl<T> AstNodeRef<T> {
-    /// Creates a new `AstNodeRef` that reference `node`. The `parsed` is the [`ParsedModule`] to which
-    /// the `AstNodeRef` belongs.
+    /// Creates a new `AstNodeRef` that reference `node`. The `parsed` is the [`ParsedModule`] to
+    /// which the `AstNodeRef` belongs.
     ///
     /// ## Safety
-    /// Dereferencing the `node` can result in undefined behavior if `parsed` isn't the [`ParsedModule`] to
-    /// which `node` belongs. It's the caller's responsibility to ensure that the invariant `node belongs to parsed` is upheld.
+    /// Dereferencing the `node` can result in undefined behavior if `parsed` isn't the
+    /// [`ParsedModule`] to which `node` belongs. It's the caller's responsibility to ensure that
+    /// the invariant `node belongs to parsed` is upheld.
 
     pub(super) unsafe fn new(parsed: ParsedModule, node: &T) -> Self {
         Self {
@@ -43,8 +44,8 @@ impl<T> AstNodeRef<T> {
 
     /// Returns a reference to the wrapped node.
     pub fn node(&self) -> &T {
-        // SAFETY: Holding on to `parsed` ensures that the AST to which `node` belongs is still alive
-        // and not moved.
+        // SAFETY: Holding on to `parsed` ensures that the AST to which `node` belongs is still
+        // alive and not moved.
         unsafe { self.node.as_ref() }
     }
 }

crates/red_knot_python_semantic/src/db.rs

@@ -4,27 +4,30 @@ use red_knot_module_resolver::Db as ResolverDb;
 use ruff_db::{Db as SourceDb, Upcast};
 
 use crate::semantic_index::definition::Definition;
-use crate::semantic_index::symbol::{public_symbols_map, PublicSymbolId, ScopeId};
-use crate::semantic_index::{root_scope, semantic_index, symbol_table};
+use crate::semantic_index::symbol::ScopeId;
+use crate::semantic_index::usedef::Expression;
+use crate::semantic_index::{module_global_scope, semantic_index, symbol_table, use_def_map};
 use crate::types::{
-    infer_types, public_symbol_ty, ClassType, FunctionType, IntersectionType, UnionType,
+    infer_definition_types, infer_expression_types, infer_scope_types, ClassType, FunctionType,
+    IntersectionType, UnionType,
 };
 
 #[salsa::jar(db=Db)]
 pub struct Jar(
     ScopeId<'_>,
-    PublicSymbolId<'_>,
     Definition<'_>,
+    Expression<'_>,
     FunctionType<'_>,
     ClassType<'_>,
     UnionType<'_>,
     IntersectionType<'_>,
     symbol_table,
-    root_scope,
+    use_def_map,
+    module_global_scope,
     semantic_index,
-    infer_types,
-    public_symbol_ty,
-    public_symbols_map,
+    infer_definition_types,
+    infer_expression_types,
+    infer_scope_types,
 );
 
 /// Database giving access to semantic information about a Python program.