language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-09-28 12:55:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

[red-knot] rename module_global to global (#12385)

Browse source 
Per comments in https://github.com/astral-sh/ruff/pull/12269, "module
global" is kind of long, and arguably redundant.

I tried just using "module" but there were too many cases where I felt
this was ambiguous. I like the way "global" works out better, though it
does require an understanding that in Python "global" generally means
"module global" not "globally global" (though in a sense module globals
are also globally global since modules are singletons).
This commit is contained in:
Carl Meyer 2024-07-18 13:05:30 -07:00 • committed by GitHub
parent 519eca9fe7
commit 181e7b3c0d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 82 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/red_knot/src/lint.rs
View file

@ -130,7 +130,7 @@ fn lint_bad_override(context: &SemanticLintContext, class: &ast::StmtClassDef) {
return; return;
}; };
let override_ty = semantic.module_global_symbol_ty(&typing, "override"); let override_ty = semantic.global_symbol_ty(&typing, "override");
let Type::Class(class_ty) = class.ty(semantic) else { let Type::Class(class_ty) = class.ty(semantic) else {
return; return;

4
crates/red_knot_python_semantic/src/db.rs
View file

@ -6,7 +6,7 @@ use ruff_db::{Db as SourceDb, Upcast};
use crate::semantic_index::definition::Definition; use crate::semantic_index::definition::Definition;
use crate::semantic_index::expression::Expression; use crate::semantic_index::expression::Expression;
use crate::semantic_index::symbol::ScopeId; use crate::semantic_index::symbol::ScopeId;
use crate::semantic_index::{module_global_scope, semantic_index, symbol_table, use_def_map}; use crate::semantic_index::{global_scope, semantic_index, symbol_table, use_def_map};
use crate::types::{ use crate::types::{
infer_definition_types, infer_expression_types, infer_scope_types, ClassType, FunctionType, infer_definition_types, infer_expression_types, infer_scope_types, ClassType, FunctionType,
IntersectionType, UnionType, IntersectionType, UnionType,
@ -23,7 +23,7 @@ pub struct Jar(
IntersectionType<'_>, IntersectionType<'_>,
symbol_table, symbol_table,
use_def_map, use_def_map,
module_global_scope, global_scope,
semantic_index, semantic_index,
infer_definition_types, infer_definition_types,
infer_expression_types, infer_expression_types,

114
crates/red_knot_python_semantic/src/semantic_index.rs
View file

@ -68,10 +68,10 @@ pub(crate) fn use_def_map<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Arc<UseD
/// Returns the module global scope of `file`. /// Returns the module global scope of `file`.
#[salsa::tracked] #[salsa::tracked]
pub(crate) fn module_global_scope(db: &dyn Db, file: File) -> ScopeId<'_> { pub(crate) fn global_scope(db: &dyn Db, file: File) -> ScopeId<'_> {
let _span = tracing::trace_span!("module_global_scope", ?file).entered(); let _span = tracing::trace_span!("global_scope", ?file).entered();
FileScopeId::module_global().to_scope_id(db, file) FileScopeId::global().to_scope_id(db, file)
} }
/// The symbol tables and use-def maps for all scopes in a file. /// The symbol tables and use-def maps for all scopes in a file.
@ -309,7 +309,7 @@ mod tests {
use crate::semantic_index::ast_ids::HasScopedUseId; use crate::semantic_index::ast_ids::HasScopedUseId;
use crate::semantic_index::definition::DefinitionKind; use crate::semantic_index::definition::DefinitionKind;
use crate::semantic_index::symbol::{FileScopeId, Scope, ScopeKind, SymbolTable}; use crate::semantic_index::symbol::{FileScopeId, Scope, ScopeKind, SymbolTable};
use crate::semantic_index::{module_global_scope, semantic_index, symbol_table, use_def_map}; use crate::semantic_index::{global_scope, semantic_index, symbol_table, use_def_map};
use crate::Db; use crate::Db;
struct TestCase { struct TestCase {
@ -336,38 +336,38 @@ mod tests {
#[test] #[test]
fn empty() { fn empty() {
let TestCase { db, file } = test_case(""); let TestCase { db, file } = test_case("");
let module_global_table = symbol_table(&db, module_global_scope(&db, file)); let global_table = symbol_table(&db, global_scope(&db, file));
let module_global_names = names(&module_global_table); let global_names = names(&global_table);
assert_eq!(module_global_names, Vec::<&str>::new()); assert_eq!(global_names, Vec::<&str>::new());
} }
#[test] #[test]
fn simple() { fn simple() {
let TestCase { db, file } = test_case("x"); let TestCase { db, file } = test_case("x");
let module_global_table = symbol_table(&db, module_global_scope(&db, file)); let global_table = symbol_table(&db, global_scope(&db, file));
assert_eq!(names(&module_global_table), vec!["x"]); assert_eq!(names(&global_table), vec!["x"]);
} }
#[test] #[test]
fn annotation_only() { fn annotation_only() {
let TestCase { db, file } = test_case("x: int"); let TestCase { db, file } = test_case("x: int");
let module_global_table = symbol_table(&db, module_global_scope(&db, file)); let global_table = symbol_table(&db, global_scope(&db, file));
assert_eq!(names(&module_global_table), vec!["int", "x"]); assert_eq!(names(&global_table), vec!["int", "x"]);
// TODO record definition // TODO record definition
} }
#[test] #[test]
fn import() { fn import() {
let TestCase { db, file } = test_case("import foo"); let TestCase { db, file } = test_case("import foo");
let scope = module_global_scope(&db, file); let scope = global_scope(&db, file);
let module_global_table = symbol_table(&db, scope); let global_table = symbol_table(&db, scope);
assert_eq!(names(&module_global_table), vec!["foo"]); assert_eq!(names(&global_table), vec!["foo"]);
let foo = module_global_table.symbol_id_by_name("foo").unwrap(); let foo = global_table.symbol_id_by_name("foo").unwrap();
let use_def = use_def_map(&db, scope); let use_def = use_def_map(&db, scope);
let [definition] = use_def.public_definitions(foo) else { let [definition] = use_def.public_definitions(foo) else {
@ -379,28 +379,28 @@ mod tests {
#[test] #[test]
fn import_sub() { fn import_sub() {
let TestCase { db, file } = test_case("import foo.bar"); let TestCase { db, file } = test_case("import foo.bar");
let module_global_table = symbol_table(&db, module_global_scope(&db, file)); let global_table = symbol_table(&db, global_scope(&db, file));
assert_eq!(names(&module_global_table), vec!["foo"]); assert_eq!(names(&global_table), vec!["foo"]);
} }
#[test] #[test]
fn import_as() { fn import_as() {
let TestCase { db, file } = test_case("import foo.bar as baz"); let TestCase { db, file } = test_case("import foo.bar as baz");
let module_global_table = symbol_table(&db, module_global_scope(&db, file)); let global_table = symbol_table(&db, global_scope(&db, file));
assert_eq!(names(&module_global_table), vec!["baz"]); assert_eq!(names(&global_table), vec!["baz"]);
} }
#[test] #[test]
fn import_from() { fn import_from() {
let TestCase { db, file } = test_case("from bar import foo"); let TestCase { db, file } = test_case("from bar import foo");
let scope = module_global_scope(&db, file); let scope = global_scope(&db, file);
let module_global_table = symbol_table(&db, scope); let global_table = symbol_table(&db, scope);
assert_eq!(names(&module_global_table), vec!["foo"]); assert_eq!(names(&global_table), vec!["foo"]);
assert!( assert!(
module_global_table global_table
.symbol_by_name("foo") .symbol_by_name("foo")
.is_some_and(|symbol| { symbol.is_defined() && !symbol.is_used() }), .is_some_and(|symbol| { symbol.is_defined() && !symbol.is_used() }),
"symbols that are defined get the defined flag" "symbols that are defined get the defined flag"
@ -408,7 +408,7 @@ mod tests {
let use_def = use_def_map(&db, scope); let use_def = use_def_map(&db, scope);
let [definition] = use_def.public_definitions( let [definition] = use_def.public_definitions(
module_global_table global_table
.symbol_id_by_name("foo") .symbol_id_by_name("foo")
.expect("symbol to exist"), .expect("symbol to exist"),
) else { ) else {
@ -423,22 +423,20 @@ mod tests {
#[test] #[test]
fn assign() { fn assign() {
let TestCase { db, file } = test_case("x = foo"); let TestCase { db, file } = test_case("x = foo");
let scope = module_global_scope(&db, file); let scope = global_scope(&db, file);
let module_global_table = symbol_table(&db, scope); let global_table = symbol_table(&db, scope);
assert_eq!(names(&module_global_table), vec!["foo", "x"]); assert_eq!(names(&global_table), vec!["foo", "x"]);
assert!( assert!(
module_global_table global_table
.symbol_by_name("foo") .symbol_by_name("foo")
.is_some_and(|symbol| { !symbol.is_defined() && symbol.is_used() }), .is_some_and(|symbol| { !symbol.is_defined() && symbol.is_used() }),
"a symbol used but not defined in a scope should have only the used flag" "a symbol used but not defined in a scope should have only the used flag"
); );
let use_def = use_def_map(&db, scope); let use_def = use_def_map(&db, scope);
let [definition] = use_def.public_definitions( let [definition] =
module_global_table use_def.public_definitions(global_table.symbol_id_by_name("x").expect("symbol exists"))
.symbol_id_by_name("x") else {
.expect("symbol exists"),
) else {
panic!("expected one definition"); panic!("expected one definition");
}; };
assert!(matches!( assert!(matches!(
@ -456,14 +454,14 @@ class C:
y = 2 y = 2
", ",
); );
let module_global_table = symbol_table(&db, module_global_scope(&db, file)); let global_table = symbol_table(&db, global_scope(&db, file));
assert_eq!(names(&module_global_table), vec!["C", "y"]); assert_eq!(names(&global_table), vec!["C", "y"]);
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let [(class_scope_id, class_scope)] = index let [(class_scope_id, class_scope)] = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.collect::<Vec<_>>()[..] .collect::<Vec<_>>()[..]
else { else {
panic!("expected one child scope") panic!("expected one child scope")
@ -496,12 +494,12 @@ y = 2
", ",
); );
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let module_global_table = index.symbol_table(FileScopeId::module_global()); let global_table = index.symbol_table(FileScopeId::global());
assert_eq!(names(&module_global_table), vec!["func", "y"]); assert_eq!(names(&global_table), vec!["func", "y"]);
let [(function_scope_id, function_scope)] = index let [(function_scope_id, function_scope)] = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.collect::<Vec<_>>()[..] .collect::<Vec<_>>()[..]
else { else {
panic!("expected one child scope") panic!("expected one child scope")
@ -537,11 +535,11 @@ def func():
", ",
); );
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let module_global_table = index.symbol_table(FileScopeId::module_global()); let global_table = index.symbol_table(FileScopeId::global());
assert_eq!(names(&module_global_table), vec!["func"]); assert_eq!(names(&global_table), vec!["func"]);
let [(func_scope1_id, func_scope_1), (func_scope2_id, func_scope_2)] = index let [(func_scope1_id, func_scope_1), (func_scope2_id, func_scope_2)] = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.collect::<Vec<_>>()[..] .collect::<Vec<_>>()[..]
else { else {
panic!("expected two child scopes"); panic!("expected two child scopes");
@ -558,9 +556,9 @@ def func():
assert_eq!(names(&func1_table), vec!["x"]); assert_eq!(names(&func1_table), vec!["x"]);
assert_eq!(names(&func2_table), vec!["y"]); assert_eq!(names(&func2_table), vec!["y"]);
let use_def = index.use_def_map(FileScopeId::module_global()); let use_def = index.use_def_map(FileScopeId::global());
let [definition] = use_def.public_definitions( let [definition] = use_def.public_definitions(
module_global_table global_table
.symbol_id_by_name("func") .symbol_id_by_name("func")
.expect("symbol exists"), .expect("symbol exists"),
) else { ) else {
@ -579,12 +577,12 @@ def func[T]():
); );
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let module_global_table = index.symbol_table(FileScopeId::module_global()); let global_table = index.symbol_table(FileScopeId::global());
assert_eq!(names(&module_global_table), vec!["func"]); assert_eq!(names(&global_table), vec!["func"]);
let [(ann_scope_id, ann_scope)] = index let [(ann_scope_id, ann_scope)] = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.collect::<Vec<_>>()[..] .collect::<Vec<_>>()[..]
else { else {
panic!("expected one child scope"); panic!("expected one child scope");
@ -616,12 +614,12 @@ class C[T]:
); );
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let module_global_table = index.symbol_table(FileScopeId::module_global()); let global_table = index.symbol_table(FileScopeId::global());
assert_eq!(names(&module_global_table), vec!["C"]); assert_eq!(names(&global_table), vec!["C"]);
let [(ann_scope_id, ann_scope)] = index let [(ann_scope_id, ann_scope)] = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.collect::<Vec<_>>()[..] .collect::<Vec<_>>()[..]
else { else {
panic!("expected one child scope"); panic!("expected one child scope");
@ -653,7 +651,7 @@ class C[T]:
fn reachability_trivial() { fn reachability_trivial() {
let TestCase { db, file } = test_case("x = 1; x"); let TestCase { db, file } = test_case("x = 1; x");
let parsed = parsed_module(&db, file); let parsed = parsed_module(&db, file);
let scope = module_global_scope(&db, file); let scope = global_scope(&db, file);
let ast = parsed.syntax(); let ast = parsed.syntax();
let ast::Stmt::Expr(ast::StmtExpr { let ast::Stmt::Expr(ast::StmtExpr {
value: x_use_expr, .. value: x_use_expr, ..
@ -694,7 +692,7 @@ class C[T]:
let x = &x_stmt.targets[0]; let x = &x_stmt.targets[0];
assert_eq!(index.expression_scope(x).kind(), ScopeKind::Module); assert_eq!(index.expression_scope(x).kind(), ScopeKind::Module);
assert_eq!(index.expression_scope_id(x), FileScopeId::module_global()); assert_eq!(index.expression_scope_id(x), FileScopeId::global());
let def = ast.body[1].as_function_def_stmt().unwrap(); let def = ast.body[1].as_function_def_stmt().unwrap();
let y_stmt = def.body[0].as_assign_stmt().unwrap(); let y_stmt = def.body[0].as_assign_stmt().unwrap();
@ -731,20 +729,16 @@ def x():
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let descendents = index.descendent_scopes(FileScopeId::module_global()); let descendents = index.descendent_scopes(FileScopeId::global());
assert_eq!( assert_eq!(
scope_names(descendents, &db, file), scope_names(descendents, &db, file),
vec!["Test", "foo", "bar", "baz", "x"] vec!["Test", "foo", "bar", "baz", "x"]
); );
let children = index.child_scopes(FileScopeId::module_global()); let children = index.child_scopes(FileScopeId::global());
assert_eq!(scope_names(children, &db, file), vec!["Test", "x"]); assert_eq!(scope_names(children, &db, file), vec!["Test", "x"]);
let test_class = index let test_class = index.child_scopes(FileScopeId::global()).next().unwrap().0;
.child_scopes(FileScopeId::module_global())
.next()
.unwrap()
.0;
let test_child_scopes = index.child_scopes(test_class); let test_child_scopes = index.child_scopes(test_class);
assert_eq!( assert_eq!(
scope_names(test_child_scopes, &db, file), scope_names(test_child_scopes, &db, file),
@ -752,7 +746,7 @@ def x():
); );
let bar_scope = index let bar_scope = index
.descendent_scopes(FileScopeId::module_global()) .descendent_scopes(FileScopeId::global())
.nth(2) .nth(2)
.unwrap() .unwrap()
.0; .0;

2
crates/red_knot_python_semantic/src/semantic_index/symbol.rs
View file

@ -133,7 +133,7 @@ pub struct FileScopeId;
impl FileScopeId { impl FileScopeId {
/// Returns the scope id of the module-global scope. /// Returns the scope id of the module-global scope.
pub fn module_global() -> Self { pub fn global() -> Self {
FileScopeId::from_u32(0) FileScopeId::from_u32(0)
} }

6
crates/red_knot_python_semantic/src/semantic_model.rs
View file

@ -5,7 +5,7 @@ use ruff_python_ast::{Expr, ExpressionRef, StmtClassDef};
use crate::semantic_index::ast_ids::HasScopedAstId; use crate::semantic_index::ast_ids::HasScopedAstId;
use crate::semantic_index::semantic_index; use crate::semantic_index::semantic_index;
use crate::types::{definition_ty, infer_scope_types, module_global_symbol_ty_by_name, Type}; use crate::types::{definition_ty, global_symbol_ty_by_name, infer_scope_types, Type};
use crate::Db; use crate::Db;
pub struct SemanticModel<'db> { pub struct SemanticModel<'db> {
@ -28,8 +28,8 @@ impl<'db> SemanticModel<'db> {
resolve_module(self.db.upcast(), module_name) resolve_module(self.db.upcast(), module_name)
} }
pub fn module_global_symbol_ty(&self, module: &Module, symbol_name: &str) -> Type<'db> { pub fn global_symbol_ty(&self, module: &Module, symbol_name: &str) -> Type<'db> {
module_global_symbol_ty_by_name(self.db, module.file(), symbol_name) global_symbol_ty_by_name(self.db, module.file(), symbol_name)
} }
} }

12
crates/red_knot_python_semantic/src/types.rs
View file

@ -3,7 +3,7 @@ use ruff_python_ast::name::Name;
use crate::semantic_index::definition::Definition; use crate::semantic_index::definition::Definition;
use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId}; use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId};
use crate::semantic_index::{module_global_scope, symbol_table, use_def_map}; use crate::semantic_index::{global_scope, symbol_table, use_def_map};
use crate::{Db, FxOrderSet}; use crate::{Db, FxOrderSet};
mod display; mod display;
@ -43,12 +43,8 @@ pub(crate) fn symbol_ty_by_name<'db>(
} }
/// Shorthand for `symbol_ty` that looks up a module-global symbol in a file. /// Shorthand for `symbol_ty` that looks up a module-global symbol in a file.
pub(crate) fn module_global_symbol_ty_by_name<'db>( pub(crate) fn global_symbol_ty_by_name<'db>(db: &'db dyn Db, file: File, name: &str) -> Type<'db> {
db: &'db dyn Db, symbol_ty_by_name(db, global_scope(db, file), name)
file: File,
name: &str,
) -> Type<'db> {
symbol_ty_by_name(db, module_global_scope(db, file), name)
} }
/// Infer the type of a [`Definition`]. /// Infer the type of a [`Definition`].
@ -145,7 +141,7 @@ impl<'db> Type<'db> {
Type::Unbound => Type::Unbound, Type::Unbound => Type::Unbound,
Type::None => todo!("attribute lookup on None type"), Type::None => todo!("attribute lookup on None type"),
Type::Function(_) => todo!("attribute lookup on Function type"), Type::Function(_) => todo!("attribute lookup on Function type"),
Type::Module(file) => module_global_symbol_ty_by_name(db, *file, name), Type::Module(file) => global_symbol_ty_by_name(db, *file, name),
Type::Class(class) => class.class_member(db, name), Type::Class(class) => class.class_member(db, name),
Type::Instance(_) => { Type::Instance(_) => {
// TODO MRO? get_own_instance_member, get_instance_member // TODO MRO? get_own_instance_member, get_instance_member

35
crates/red_knot_python_semantic/src/types/infer.rs
View file

@ -37,8 +37,7 @@ use crate::semantic_index::symbol::NodeWithScopeKind;
use crate::semantic_index::symbol::{NodeWithScopeRef, ScopeId}; use crate::semantic_index::symbol::{NodeWithScopeRef, ScopeId};
use crate::semantic_index::SemanticIndex; use crate::semantic_index::SemanticIndex;
use crate::types::{ use crate::types::{
definitions_ty, module_global_symbol_ty_by_name, ClassType, FunctionType, Name, Type, definitions_ty, global_symbol_ty_by_name, ClassType, FunctionType, Name, Type, UnionTypeBuilder,
UnionTypeBuilder,
}; };
use crate::Db; use crate::Db;
@ -685,7 +684,7 @@ impl<'db> TypeInferenceBuilder<'db> {
let symbol = symbols.symbol_by_name(id).unwrap(); let symbol = symbols.symbol_by_name(id).unwrap();
if !symbol.is_defined() || !self.scope.is_function_like(self.db) { if !symbol.is_defined() || !self.scope.is_function_like(self.db) {
// implicit global // implicit global
Some(module_global_symbol_ty_by_name(self.db, self.file, id)) Some(global_symbol_ty_by_name(self.db, self.file, id))
} else { } else {
Some(Type::Unbound) Some(Type::Unbound)
} }
@ -796,7 +795,7 @@ mod tests {
use crate::semantic_index::semantic_index; use crate::semantic_index::semantic_index;
use crate::semantic_index::symbol::FileScopeId; use crate::semantic_index::symbol::FileScopeId;
use crate::types::{ use crate::types::{
infer_definition_types, module_global_scope, module_global_symbol_ty_by_name, symbol_table, global_scope, global_symbol_ty_by_name, infer_definition_types, symbol_table,
symbol_ty_by_name, use_def_map, Type, symbol_ty_by_name, use_def_map, Type,
}; };
use crate::{HasTy, SemanticModel}; use crate::{HasTy, SemanticModel};
@ -821,7 +820,7 @@ mod tests {
fn assert_public_ty(db: &TestDb, file_name: &str, symbol_name: &str, expected: &str) { fn assert_public_ty(db: &TestDb, file_name: &str, symbol_name: &str, expected: &str) {
let file = system_path_to_file(db, file_name).expect("Expected file to exist."); let file = system_path_to_file(db, file_name).expect("Expected file to exist.");
let ty = module_global_symbol_ty_by_name(db, file, symbol_name); let ty = global_symbol_ty_by_name(db, file, symbol_name);
assert_eq!(ty.display(db).to_string(), expected); assert_eq!(ty.display(db).to_string(), expected);
} }
@ -855,7 +854,7 @@ mod tests {
)?; )?;
let mod_file = system_path_to_file(&db, "src/mod.py").expect("Expected file to exist."); let mod_file = system_path_to_file(&db, "src/mod.py").expect("Expected file to exist.");
let ty = module_global_symbol_ty_by_name(&db, mod_file, "Sub"); let ty = global_symbol_ty_by_name(&db, mod_file, "Sub");
let Type::Class(class) = ty else { let Type::Class(class) = ty else {
panic!("Sub is not a Class") panic!("Sub is not a Class")
@ -885,7 +884,7 @@ mod tests {
)?; )?;
let mod_file = system_path_to_file(&db, "src/mod.py").unwrap(); let mod_file = system_path_to_file(&db, "src/mod.py").unwrap();
let ty = module_global_symbol_ty_by_name(&db, mod_file, "C"); let ty = global_symbol_ty_by_name(&db, mod_file, "C");
let Type::Class(class_id) = ty else { let Type::Class(class_id) = ty else {
panic!("C is not a Class"); panic!("C is not a Class");
@ -1234,7 +1233,7 @@ mod tests {
)?; )?;
let a = system_path_to_file(&db, "src/a.py").expect("Expected file to exist."); let a = system_path_to_file(&db, "src/a.py").expect("Expected file to exist.");
let c_ty = module_global_symbol_ty_by_name(&db, a, "C"); let c_ty = global_symbol_ty_by_name(&db, a, "C");
let Type::Class(c_class) = c_ty else { let Type::Class(c_class) = c_ty else {
panic!("C is not a Class") panic!("C is not a Class")
}; };
@ -1272,7 +1271,7 @@ mod tests {
let file = system_path_to_file(&db, "src/a.py").expect("Expected file to exist."); let file = system_path_to_file(&db, "src/a.py").expect("Expected file to exist.");
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let function_scope = index let function_scope = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.next() .next()
.unwrap() .unwrap()
.0 .0
@ -1303,7 +1302,7 @@ mod tests {
let file = system_path_to_file(&db, "src/a.py").expect("Expected file to exist."); let file = system_path_to_file(&db, "src/a.py").expect("Expected file to exist.");
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let function_scope = index let function_scope = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.next() .next()
.unwrap() .unwrap()
.0 .0
@ -1336,7 +1335,7 @@ mod tests {
let file = system_path_to_file(&db, "src/a.py").expect("Expected file to exist."); let file = system_path_to_file(&db, "src/a.py").expect("Expected file to exist.");
let index = semantic_index(&db, file); let index = semantic_index(&db, file);
let class_scope = index let class_scope = index
.child_scopes(FileScopeId::module_global()) .child_scopes(FileScopeId::global())
.next() .next()
.unwrap() .unwrap()
.0 .0
@ -1370,7 +1369,7 @@ mod tests {
} }
fn first_public_def<'db>(db: &'db TestDb, file: File, name: &str) -> Definition<'db> { fn first_public_def<'db>(db: &'db TestDb, file: File, name: &str) -> Definition<'db> {
let scope = module_global_scope(db, file); let scope = global_scope(db, file);
*use_def_map(db, scope) *use_def_map(db, scope)
.public_definitions(symbol_table(db, scope).symbol_id_by_name(name).unwrap()) .public_definitions(symbol_table(db, scope).symbol_id_by_name(name).unwrap())
.first() .first()
@ -1387,7 +1386,7 @@ mod tests {
])?; ])?;
let a = system_path_to_file(&db, "/src/a.py").unwrap(); let a = system_path_to_file(&db, "/src/a.py").unwrap();
let x_ty = module_global_symbol_ty_by_name(&db, a, "x"); let x_ty = global_symbol_ty_by_name(&db, a, "x");
assert_eq!(x_ty.display(&db).to_string(), "Literal[10]"); assert_eq!(x_ty.display(&db).to_string(), "Literal[10]");
@ -1396,7 +1395,7 @@ mod tests {
let a = system_path_to_file(&db, "/src/a.py").unwrap(); let a = system_path_to_file(&db, "/src/a.py").unwrap();
let x_ty_2 = module_global_symbol_ty_by_name(&db, a, "x"); let x_ty_2 = global_symbol_ty_by_name(&db, a, "x");
assert_eq!(x_ty_2.display(&db).to_string(), "Literal[20]"); assert_eq!(x_ty_2.display(&db).to_string(), "Literal[20]");
@ -1413,7 +1412,7 @@ mod tests {
])?; ])?;
let a = system_path_to_file(&db, "/src/a.py").unwrap(); let a = system_path_to_file(&db, "/src/a.py").unwrap();
let x_ty = module_global_symbol_ty_by_name(&db, a, "x"); let x_ty = global_symbol_ty_by_name(&db, a, "x");
assert_eq!(x_ty.display(&db).to_string(), "Literal[10]"); assert_eq!(x_ty.display(&db).to_string(), "Literal[10]");
@ -1423,7 +1422,7 @@ mod tests {
db.clear_salsa_events(); db.clear_salsa_events();
let x_ty_2 = module_global_symbol_ty_by_name(&db, a, "x"); let x_ty_2 = global_symbol_ty_by_name(&db, a, "x");
assert_eq!(x_ty_2.display(&db).to_string(), "Literal[10]"); assert_eq!(x_ty_2.display(&db).to_string(), "Literal[10]");
@ -1449,7 +1448,7 @@ mod tests {
])?; ])?;
let a = system_path_to_file(&db, "/src/a.py").unwrap(); let a = system_path_to_file(&db, "/src/a.py").unwrap();
let x_ty = module_global_symbol_ty_by_name(&db, a, "x"); let x_ty = global_symbol_ty_by_name(&db, a, "x");
assert_eq!(x_ty.display(&db).to_string(), "Literal[10]"); assert_eq!(x_ty.display(&db).to_string(), "Literal[10]");
@ -1459,7 +1458,7 @@ mod tests {
db.clear_salsa_events(); db.clear_salsa_events();
let x_ty_2 = module_global_symbol_ty_by_name(&db, a, "x"); let x_ty_2 = global_symbol_ty_by_name(&db, a, "x");
assert_eq!(x_ty_2.display(&db).to_string(), "Literal[10]"); assert_eq!(x_ty_2.display(&db).to_string(), "Literal[10]");