From 3533d7f5b4617ae91bc5cc3c4d0bbef4677be431 Mon Sep 17 00:00:00 2001 From: Dhruv Manilawala Date: Fri, 13 Dec 2024 19:59:53 +0530 Subject: [PATCH] [red-knot] Display definition range in trace logs (#14955) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit I've mainly opened this PR to get some opinions. I've found having some additional information in the tracing logs to be useful to determine what we are currently inferring. For the `Definition` ingredient, the range seems to be much useful. I thought of using the identifier name but we would have to deconstruct the `Expr` to find out the identifier which seems a lot for just trace logs. Additionally, multiple identifiers _could_ have the same name where range would be useful. The ranges are isolated to the names that have been defined by the definition except for the `except` block where the entire range is being used because the name is optional. ***Before:*** ``` 3 ├─ 0.074671s 54ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(3), kind: WillExecute { database_key: infer_definition_types(Id(1402)) } } 3 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(1402), file=/Users/dhruv/playground/ruff/type_inference/isolated3/play.py} 3 ┌─┘ 3 ├─ 0.074768s 54ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(3), kind: WillExecute { database_key: inner_fn_name_(Id(2800)) } } 3 ├─ 0.074807s 54ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(3), kind: WillExecute { database_key: infer_deferred_types(Id(1735)) } } 3 └─┐red_knot_python_semantic::types::infer::infer_deferred_types{definition=Id(1735), file=vendored://stdlib/typing.pyi} 3 ├─ 0.074842s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(3), kind: WillExecute { database_key: infer_definition_types(Id(14f3)) } } 3 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(14f3), file=vendored://stdlib/typing.pyi} 3 ├─ 0.074871s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(3), kind: WillExecute { database_key: infer_expression_types(Id(1820)) } } 3 └─┐red_knot_python_semantic::types::infer::infer_expression_types{expression=Id(1820), file=vendored://stdlib/typing.pyi} 3 ├─ 0.074924s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(3), kind: WillExecute { database_key: infer_definition_types(Id(1429)) } } 3 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(1429), file=vendored://stdlib/typing.pyi} 3 ├─ 0.074958s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(3), kind: WillExecute { database_key: infer_definition_types(Id(1428)) } } 3 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(1428), file=vendored://stdlib/typing.pyi} 3 ┌─┘ ``` ***After:*** ``` 12 ├─ 0.074609s 55ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(12), kind: WillExecute { database_key: infer_definition_types(Id(1402)) } } 12 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(1402), range=36..37, file=/Users/dhruv/playground/ruff/type_inference/isolated3/play.py} 12 ┌─┘ 12 ├─ 0.074705s 55ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(12), kind: WillExecute { database_key: inner_fn_name_(Id(2800)) } } 12 ├─ 0.074742s 55ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(12), kind: WillExecute { database_key: infer_deferred_types(Id(1735)) } } 12 └─┐red_knot_python_semantic::types::infer::infer_deferred_types{definition=Id(1735), range=30225..30236, file=vendored://stdlib/typing.pyi} 12 ├─ 0.074775s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(12), kind: WillExecute { database_key: infer_definition_types(Id(14f3)) } } 12 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(14f3), range=9472..9474, file=vendored://stdlib/typing.pyi} 12 ├─ 0.074803s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(12), kind: WillExecute { database_key: infer_expression_types(Id(1820)) } } 12 └─┐red_knot_python_semantic::types::infer::infer_expression_types{expression=Id(1820), range=9477..9490, file=vendored://stdlib/typing.pyi} 12 ├─ 0.074855s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(12), kind: WillExecute { database_key: infer_definition_types(Id(1429)) } } 12 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(1429), range=3139..3146, file=vendored://stdlib/typing.pyi} 12 ├─ 0.074892s 0ms TRACE red_knot_workspace::db Salsa event: Event { thread_id: ThreadId(12), kind: WillExecute { database_key: infer_definition_types(Id(1428)) } } 12 └─┐red_knot_python_semantic::types::infer::infer_definition_types{definition=Id(1428), range=3102..3107, file=vendored://stdlib/typing.pyi} 12 ┌─┘ ``` --- .../src/semantic_index/definition.rs | 28 +++++++++++++++++++ .../src/types/infer.rs | 13 +++++++-- 2 files changed, 38 insertions(+), 3 deletions(-) diff --git a/crates/red_knot_python_semantic/src/semantic_index/definition.rs b/crates/red_knot_python_semantic/src/semantic_index/definition.rs index d73064636d..a7b80a225d 100644 --- a/crates/red_knot_python_semantic/src/semantic_index/definition.rs +++ b/crates/red_knot_python_semantic/src/semantic_index/definition.rs @@ -1,6 +1,7 @@ use ruff_db::files::File; use ruff_db::parsed::ParsedModule; use ruff_python_ast as ast; +use ruff_text_size::{Ranged, TextRange}; use crate::ast_node_ref::AstNodeRef; use crate::module_resolver::file_to_module; @@ -465,6 +466,33 @@ pub enum DefinitionKind<'db> { TypeVarTuple(AstNodeRef), } +impl Ranged for DefinitionKind<'_> { + fn range(&self) -> TextRange { + match self { + DefinitionKind::Import(alias) => alias.range(), + DefinitionKind::ImportFrom(import) => import.alias().range(), + DefinitionKind::Function(function) => function.name.range(), + DefinitionKind::Class(class) => class.name.range(), + DefinitionKind::TypeAlias(type_alias) => type_alias.name.range(), + DefinitionKind::NamedExpression(named) => named.target.range(), + DefinitionKind::Assignment(assignment) => assignment.name().range(), + DefinitionKind::AnnotatedAssignment(assign) => assign.target.range(), + DefinitionKind::AugmentedAssignment(aug_assign) => aug_assign.target.range(), + DefinitionKind::For(for_stmt) => for_stmt.target().range(), + DefinitionKind::Comprehension(comp) => comp.target().range(), + DefinitionKind::VariadicPositionalParameter(parameter) => parameter.name.range(), + DefinitionKind::VariadicKeywordParameter(parameter) => parameter.name.range(), + DefinitionKind::Parameter(parameter) => parameter.parameter.name.range(), + DefinitionKind::WithItem(with_item) => with_item.target().range(), + DefinitionKind::MatchPattern(match_pattern) => match_pattern.identifier.range(), + DefinitionKind::ExceptHandler(handler) => handler.node().range(), + DefinitionKind::TypeVar(type_var) => type_var.name.range(), + DefinitionKind::ParamSpec(param_spec) => param_spec.name.range(), + DefinitionKind::TypeVarTuple(type_var_tuple) => type_var_tuple.name.range(), + } + } +} + impl DefinitionKind<'_> { pub(crate) fn category(&self) -> DefinitionCategory { match self { diff --git a/crates/red_knot_python_semantic/src/types/infer.rs b/crates/red_knot_python_semantic/src/types/infer.rs index cccef4ece4..c764cad802 100644 --- a/crates/red_knot_python_semantic/src/types/infer.rs +++ b/crates/red_knot_python_semantic/src/types/infer.rs @@ -32,6 +32,7 @@ use itertools::Itertools; use ruff_db::files::File; use ruff_db::parsed::parsed_module; use ruff_python_ast::{self as ast, AnyNodeRef, ExprContext, UnaryOp}; +use ruff_text_size::Ranged; use rustc_hash::{FxHashMap, FxHashSet}; use salsa; use salsa::plumbing::AsId; @@ -125,6 +126,7 @@ pub(crate) fn infer_definition_types<'db>( let _span = tracing::trace_span!( "infer_definition_types", definition = ?definition.as_id(), + range = ?definition.kind(db).range(), file = %file.path(db) ) .entered(); @@ -147,6 +149,7 @@ pub(crate) fn infer_deferred_types<'db>( let _span = tracing::trace_span!( "infer_deferred_types", definition = ?definition.as_id(), + range = ?definition.kind(db).range(), file = %file.path(db) ) .entered(); @@ -167,9 +170,13 @@ pub(crate) fn infer_expression_types<'db>( expression: Expression<'db>, ) -> TypeInference<'db> { let file = expression.file(db); - let _span = - tracing::trace_span!("infer_expression_types", expression=?expression.as_id(), file=%file.path(db)) - .entered(); + let _span = tracing::trace_span!( + "infer_expression_types", + expression = ?expression.as_id(), + range = ?expression.node_ref(db).range(), + file = %file.path(db) + ) + .entered(); let index = semantic_index(db, file);