Merge branch 'main' into charlie/metaclass

* main:
  [ty] Split up `types/class.rs` (#23714)
  [ty] Rework module resolution to be breadth-first instead of depth-first (#22449)
  [ty] Move tests and type-alias-related code out of `types.rs` (#23711)
  [ty] Move TypeVar-related code to a `types::typevar` submodule (#23710)
  Fail CI on new linter ecosystem panics (#23597)
  [ty] Fix handling of non-Python text documents
  [ty] Move `CallableType`, and related methods/types, to a new `types::callable` submodule (#23707)
  [ty] Avoid stack overflow with recursive typevar (#23652)
  [ty] Add a diagnostic for an unused awaitable (#23650)
  [ty] Fix union `*args` binding for optional positional parameters (#23124)
  [`refurb`] Fix `FURB101` and `FURB103` false positives when I/O variable is used later (#23542)
  [ty] Fix type checking for multi-member enums within in a function block (#23683)
  [ty] Improve folding for decorators (#23543)
  [`airflow`] Extract common utilities for use in new rules (#23630)

Author: carljm

.github/workflows/ci.yaml

@@ -663,6 +663,12 @@ jobs:
           path: ecosystem-result
           if-no-files-found: "error"
 
+      - name: Fail on ecosystem errors
+        run: |
+          if grep -q "project error" ecosystem-result; then
+            exit 1
+          fi
+
   fuzz-ty:
     name: "Fuzz for new ty panics"
     runs-on: ${{ github.repository == 'astral-sh/ruff' && 'depot-ubuntu-22.04-16' || 'ubuntu-latest' }}

crates/ruff_linter/resources/test/fixtures/airflow/AIR301_context.py

@@ -205,3 +205,37 @@ def test_inlet_events_dataset_subscript_ok(**context):
 
     print(context["inlet_events"][Dataset("this://is-url")])
     print(context["inlet_events"][Asset("this://is-url")])
+
+
+# Same context checks with airflow.sdk import
+from airflow.sdk import task as sdk_task
+
+
+@sdk_task
+def sdk_access_deprecated_context_key(**context):
+    execution_date = context["execution_date"]
+    next_ds = context["next_ds"]
+
+
+@sdk_task
+def sdk_access_valid_context_key(**context):
+    logical_date = context["logical_date"]
+
+
+# Test variant decorator forms like @task.branch and @task.short_circuit
+@task.branch
+def branch_task_with_deprecated_context(**context):
+    execution_date = context["execution_date"]
+    return "some_task"
+
+
+@task.short_circuit
+def short_circuit_task_with_deprecated_context(**context):
+    next_ds = context["next_ds"]
+    return True
+
+
+@task.branch()
+def branch_task_with_call_and_deprecated_context(**context):
+    tomorrow_ds = context["tomorrow_ds"]
+    return "some_task"

crates/ruff_linter/resources/test/fixtures/refurb/FURB101_2.py

@@ -0,0 +1,21 @@
+# FURB101
+with open("file.txt", encoding="utf-8") as f:
+    _ = f.read()
+f = object()
+print(f)
+
+# See: https://github.com/astral-sh/ruff/issues/21483
+with open("file.txt", encoding="utf-8") as f:
+    _ = f.read()
+print(f.mode)
+
+# Rebinding in a later `with ... as config_file` should not suppress this one.
+with open("config.yaml", encoding="utf-8") as config_file:
+    config_raw = config_file.read()
+
+if "tts:" in config_raw:
+    try:
+        with open("config.yaml", "w", encoding="utf-8") as config_file:
+            config_file.write(config_raw.replace("tts:", "google_translate:"))
+    except OSError:
+        pass

crates/ruff_linter/resources/test/fixtures/refurb/FURB103_2.py

@@ -0,0 +1,26 @@
+# FURB103
+# should trigger
+with open("file.txt", "w", encoding="utf-8") as f:
+    f.write("\n")
+f = object()
+print(f)
+
+# See: https://github.com/astral-sh/ruff/issues/21483
+with open("file.txt", "w") as f:
+    f.write("\n")
+print(f.encoding)
+
+
+def _():
+    # should trigger
+    with open("file.txt", "w") as f:
+        f.write("\n")
+    return (f.name for _ in [0])
+
+
+def _set():
+    # should trigger
+    with open("file.txt", "w") as f:
+        f.write("\n")
+    g = {f.name for _ in [0]}
+    return g

crates/ruff_linter/src/checkers/ast/analyze/deferred_with_statements.rs

@@ -0,0 +1,23 @@
+use ruff_python_ast::Stmt;
+
+use crate::{checkers::ast::Checker, codes::Rule, rules::refurb};
+
+/// Run lint rules over all deferred with-statements in the [`SemanticModel`].
+pub(crate) fn deferred_with_statements(checker: &mut Checker) {
+    while !checker.analyze.with_statements.is_empty() {
+        let with_statements = std::mem::take(&mut checker.analyze.with_statements);
+        for snapshot in with_statements {
+            checker.semantic.restore(snapshot);
+
+            let Stmt::With(stmt_with) = checker.semantic.current_statement() else {
+                unreachable!("Expected Stmt::With");
+            };
+            if checker.is_rule_enabled(Rule::ReadWholeFile) {
+                refurb::rules::read_whole_file(checker, stmt_with);
+            }
+            if checker.is_rule_enabled(Rule::WriteWholeFile) {
+                refurb::rules::write_whole_file(checker, stmt_with);
+            }
+        }
+    }
+}

crates/ruff_linter/src/checkers/ast/analyze/mod.rs

@@ -4,6 +4,7 @@ pub(super) use deferred_comprehensions::deferred_comprehensions;
 pub(super) use deferred_for_loops::deferred_for_loops;
 pub(super) use deferred_lambdas::deferred_lambdas;
 pub(super) use deferred_scopes::deferred_scopes;
+pub(super) use deferred_with_statements::deferred_with_statements;
 pub(super) use definitions::definitions;
 pub(super) use except_handler::except_handler;
 pub(super) use expression::expression;
@@ -21,6 +22,7 @@ mod deferred_comprehensions;
 mod deferred_for_loops;
 mod deferred_lambdas;
 mod deferred_scopes;
+mod deferred_with_statements;
 mod definitions;
 mod except_handler;
 mod expression;

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -1181,11 +1181,11 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.is_rule_enabled(Rule::RedefinedLoopName) {
                 pylint::rules::redefined_loop_name(checker, stmt);
             }
-            if checker.is_rule_enabled(Rule::ReadWholeFile) {
-                refurb::rules::read_whole_file(checker, with_stmt);
-            }
-            if checker.is_rule_enabled(Rule::WriteWholeFile) {
-                refurb::rules::write_whole_file(checker, with_stmt);
+            if checker.any_rule_enabled(&[Rule::ReadWholeFile, Rule::WriteWholeFile]) {
+                checker
+                    .analyze
+                    .with_statements
+                    .push(checker.semantic.snapshot());
             }
             if checker.is_rule_enabled(Rule::UselessWithLock) {
                 pylint::rules::useless_with_lock(checker, with_stmt);

crates/ruff_linter/src/checkers/ast/deferred.rs

@@ -34,5 +34,6 @@ pub(crate) struct Analyze {
     pub(crate) scopes: Vec<ScopeId>,
     pub(crate) lambdas: Vec<Snapshot>,
     pub(crate) for_loops: Vec<Snapshot>,
+    pub(crate) with_statements: Vec<Snapshot>,
     pub(crate) comprehensions: Vec<Snapshot>,
 }

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -3321,6 +3321,7 @@ pub(crate) fn check_ast(
     analyze::definitions(&mut checker);
     analyze::bindings(&checker);
     analyze::unresolved_references(&checker);
+    analyze::deferred_with_statements(&mut checker);
 
     // Reset the scope to module-level, and check all consumed scopes.
     checker.semantic.scope_id = ScopeId::global();

crates/ruff_linter/src/rules/airflow/helpers.rs

@@ -3,6 +3,7 @@ use crate::fix::edits::remove_unused_imports;
 use crate::importer::ImportRequest;
 use crate::rules::numpy::helpers::{AttributeSearcher, ImportSearcher};
 use ruff_diagnostics::{Edit, Fix};
+use ruff_python_ast::helpers::map_callable;
 use ruff_python_ast::name::{QualifiedName, QualifiedNameBuilder};
 use ruff_python_ast::statement_visitor::StatementVisitor;
 use ruff_python_ast::visitor::Visitor;
@@ -290,3 +291,38 @@ where
 
     any_qualified_base_class(class_def, semantic, &is_base_class)
 }
+
+/// Returns `true` if the current statement hierarchy has a function that's decorated with
+/// `@airflow.decorators.task` or `@airflow.sdk.task`.
+pub(crate) fn in_airflow_task_function(semantic: &SemanticModel) -> bool {
+    semantic
+        .current_statements()
+        .find_map(|stmt| stmt.as_function_def_stmt())
+        .is_some_and(|function_def| is_airflow_task(function_def, semantic))
+}
+
+/// Returns `true` if the given function is decorated with `@airflow.decorators.task`
+/// (or `@airflow.sdk.task`), including variant forms like `@task.branch` and
+/// `@task.short_circuit`.
+pub(crate) fn is_airflow_task(function_def: &StmtFunctionDef, semantic: &SemanticModel) -> bool {
+    function_def.decorator_list.iter().any(|decorator| {
+        let expr = map_callable(&decorator.expression);
+
+        // Match `@task` and `@task()` directly.
+        if semantic
+            .resolve_qualified_name(expr)
+            .is_some_and(|qn| matches!(qn.segments(), ["airflow", "decorators" | "sdk", "task"]))
+        {
+            return true;
+        }
+
+        // Match `@task.<variant>` (e.g., `@task.branch`, `@task.short_circuit`).
+        if let Expr::Attribute(ExprAttribute { value, .. }) = expr {
+            return semantic.resolve_qualified_name(value).is_some_and(|qn| {
+                matches!(qn.segments(), ["airflow", "decorators" | "sdk", "task"])
+            });
+        }
+
+        false
+    })
+}