Rename Red Knot (#17820)

2025-09-29 13:25:17 +00:00 · 2025-05-03 19:49:15 +02:00 · 2025-05-03 19:49:15 +02:00 · b51c4f82ea
commit b51c4f82ea
parent e6a798b962
1564 changed files with 1598 additions and 1578 deletions
--- a/crates/ty_python_semantic/resources/mdtest/suppressions/no_type_check.md
+++ b/crates/ty_python_semantic/resources/mdtest/suppressions/no_type_check.md
@ -0,0 +1,122 @@
+# `@no_type_check`
+
+> If a type checker supports the `no_type_check` decorator for functions, it should suppress all
+> type errors for the def statement and its body including any nested functions or classes. It
+> should also ignore all parameter and return type annotations and treat the function as if it were
+> unannotated. [source](https://typing.python.org/en/latest/spec/directives.html#no-type-check)
+
+## Error in the function body
+
+```py
+from typing import no_type_check
+
+@no_type_check
+def test() -> int:
+    return a + 5
+```
+
+## Error in nested function
+
+```py
+from typing import no_type_check
+
+@no_type_check
+def test() -> int:
+    def nested():
+        return a + 5
+```
+
+## Error in nested class
+
+```py
+from typing import no_type_check
+
+@no_type_check
+def test() -> int:
+    class Nested:
+        def inner(self):
+            return a + 5
+```
+
+## Error in preceding decorator
+
+Don't suppress diagnostics for decorators appearing before the `no_type_check` decorator.
+
+```py
+from typing import no_type_check
+
+@unknown_decorator  # error: [unresolved-reference]
+@no_type_check
+def test() -> int:
+    # TODO: this should not be an error
+    # error: [unresolved-reference]
+    return a + 5
+```
+
+## Error in following decorator
+
+Unlike Pyright and mypy, suppress diagnostics appearing after the `no_type_check` decorator. We do
+this because it more closely matches Python's runtime semantics of decorators. For more details, see
+the discussion on the
+[PR adding `@no_type_check` support](https://github.com/astral-sh/ruff/pull/15122#discussion_r1896869411).
+
+```py
+from typing import no_type_check
+
+@no_type_check
+@unknown_decorator
+def test() -> int:
+    # TODO: this should not be an error
+    # error: [unresolved-reference]
+    return a + 5
+```
+
+## Error in default value
+
+```py
+from typing import no_type_check
+
+@no_type_check
+def test(a: int = "test"):
+    return x + 5
+```
+
+## Error in return value position
+
+```py
+from typing import no_type_check
+
+@no_type_check
+def test() -> Undefined:
+    return x + 5
+```
+
+## `no_type_check` on classes isn't supported
+
+ty does not support decorating classes with `no_type_check`. The behaviour of `no_type_check` when
+applied to classes is
+[not specified currently](https://typing.python.org/en/latest/spec/directives.html#no-type-check),
+and is not supported by Pyright or mypy.
+
+A future improvement might be to emit a diagnostic if a `no_type_check` annotation is applied to a
+class.
+
+```py
+from typing import no_type_check
+
+@no_type_check
+class Test:
+    def test(self):
+        return a + 5  # error: [unresolved-reference]
+```
+
+## `type: ignore` comments in `@no_type_check` blocks
+
+```py
+from typing import no_type_check
+
+@no_type_check
+def test():
+    # error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'unresolved-reference'"
+    return x + 5  # ty: ignore[unresolved-reference]
+```
--- a/crates/ty_python_semantic/resources/mdtest/suppressions/ty_ignore.md
+++ b/crates/ty_python_semantic/resources/mdtest/suppressions/ty_ignore.md
@ -0,0 +1,191 @@
+# Suppressing errors with `ty: ignore`
+
+Type check errors can be suppressed by a `ty: ignore` comment on the same line as the violation.
+
+## Simple `ty: ignore`
+
+```py
+a = 4 + test  # ty: ignore
+```
+
+## Suppressing a specific code
+
+```py
+a = 4 + test  # ty: ignore[unresolved-reference]
+```
+
+## Unused suppression
+
+```py
+test = 10
+# error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'possibly-unresolved-reference'"
+a = test + 3  # ty: ignore[possibly-unresolved-reference]
+```
+
+## Unused suppression if the error codes don't match
+
+```py
+# error: [unresolved-reference]
+# error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'possibly-unresolved-reference'"
+a = test + 3  # ty: ignore[possibly-unresolved-reference]
+```
+
+## Suppressed unused comment
+
+```py
+# error: [unused-ignore-comment]
+a = 10 / 2  # ty: ignore[division-by-zero]
+a = 10 / 2  # ty: ignore[division-by-zero, unused-ignore-comment]
+a = 10 / 2  # ty: ignore[unused-ignore-comment, division-by-zero]
+a = 10 / 2  # ty: ignore[unused-ignore-comment] # type: ignore
+a = 10 / 2  # type: ignore # ty: ignore[unused-ignore-comment]
+```
+
+## Unused ignore comment
+
+```py
+# error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'unused-ignore-comment'"
+a = 10 / 0  # ty: ignore[division-by-zero, unused-ignore-comment]
+```
+
+## Multiple unused comments
+
+Today, ty emits a diagnostic for every unused code. We might want to group the codes by comment at
+some point in the future.
+
+```py
+# error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'division-by-zero'"
+# error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'unresolved-reference'"
+a = 10 / 2  # ty: ignore[division-by-zero, unresolved-reference]
+
+# error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'invalid-assignment'"
+# error: [unused-ignore-comment] "Unused `ty: ignore` directive: 'unresolved-reference'"
+a = 10 / 0  # ty: ignore[invalid-assignment, division-by-zero, unresolved-reference]
+```
+
+## Multiple suppressions
+
+```py
+# fmt: off
+def test(a: f"f-string type annotation", b: b"byte-string-type-annotation"): ...  # ty: ignore[fstring-type-annotation, byte-string-type-annotation]
+```
+
+## Can't suppress syntax errors
+
+<!-- blacken-docs:off -->
+
+```py
+# error: [invalid-syntax]
+# error: [unused-ignore-comment]
+def test($):  # ty: ignore
+    pass
+```
+
+<!-- blacken-docs:on -->
+
+## Can't suppress `revealed-type` diagnostics
+
+```py
+a = 10
+# revealed: Literal[10]
+# error: [unknown-rule] "Unknown rule `revealed-type`"
+reveal_type(a)  # ty: ignore[revealed-type]
+```
+
+## Extra whitespace in type ignore comments is allowed
+
+```py
+a = 10 / 0  # ty   :   ignore
+a = 10 / 0  # ty: ignore  [    division-by-zero   ]
+```
+
+## Whitespace is optional
+
+```py
+# fmt: off
+a = 10 / 0  #ty:ignore[division-by-zero]
+```
+
+## Trailing codes comma
+
+Trailing commas in the codes section are allowed:
+
+```py
+a = 10 / 0  # ty: ignore[division-by-zero,]
+```
+
+## Invalid characters in codes
+
+```py
+# error: [division-by-zero]
+# error: [invalid-ignore-comment] "Invalid `ty: ignore` comment: expected a alphanumeric character or `-` or `_` as code"
+a = 10 / 0  # ty: ignore[*-*]
+```
+
+## Trailing whitespace
+
+<!-- blacken-docs:off -->
+
+```py
+a = 10 / 0  # ty: ignore[division-by-zero]      
+            #                               ^^^^^^ trailing whitespace
+```
+
+<!-- blacken-docs:on -->
+
+## Missing comma
+
+A missing comma results in an invalid suppression comment. We may want to recover from this in the
+future.
+
+```py
+# error: [unresolved-reference]
+# error: [invalid-ignore-comment] "Invalid `ty: ignore` comment: expected a comma separating the rule codes"
+a = x / 0  # ty: ignore[division-by-zero unresolved-reference]
+```
+
+## Missing closing bracket
+
+```py
+# error: [unresolved-reference] "Name `x` used when not defined"
+# error: [invalid-ignore-comment] "Invalid `ty: ignore` comment: expected a comma separating the rule codes"
+a = x / 2  # ty: ignore[unresolved-reference
+```
+
+## Empty codes
+
+An empty codes array suppresses no-diagnostics and is always useless
+
+```py
+# error: [division-by-zero]
+# error: [unused-ignore-comment] "Unused `ty: ignore` without a code"
+a = 4 / 0  # ty: ignore[]
+```
+
+## File-level suppression comments
+
+File level suppression comments are currently intentionally unsupported because we've yet to decide
+if they should use a different syntax that also supports enabling rules or changing the rule's
+severity: `ty: possibly-undefined-reference=error`
+
+```py
+# error: [unused-ignore-comment]
+# ty: ignore[division-by-zero]
+
+a = 4 / 0  # error: [division-by-zero]
+```
+
+## Unknown rule
+
+```py
+# error: [unknown-rule] "Unknown rule `is-equal-14`"
+a = 10 + 4  # ty: ignore[is-equal-14]
+```
+
+## Code with `lint:` prefix
+
+```py
+# error:[unknown-rule] "Unknown rule `lint:division-by-zero`. Did you mean `division-by-zero`?"
+# error: [division-by-zero]
+a = 10 / 0  # ty: ignore[lint:division-by-zero]
+```
--- a/crates/ty_python_semantic/resources/mdtest/suppressions/type_ignore.md
+++ b/crates/ty_python_semantic/resources/mdtest/suppressions/type_ignore.md
@ -0,0 +1,161 @@
+# Suppressing errors with `type: ignore`
+
+Type check errors can be suppressed by a `type: ignore` comment on the same line as the violation.
+
+## Simple `type: ignore`
+
+```py
+a = 4 + test  # type: ignore
+```
+
+## Multiline ranges
+
+A diagnostic with a multiline range can be suppressed by a comment on the same line as the
+diagnostic's start or end. This is the same behavior as Mypy's.
+
+```py
+# fmt: off
+y = (
+    4 / 0  # type: ignore
+)
+
+y = (
+    4 /  # type: ignore
+    0
+)
+
+y = (
+    4 /
+    0  # type: ignore
+)
+```
+
+Pyright diverges from this behavior and instead applies a suppression if its range intersects with
+the diagnostic range. This can be problematic for nested expressions because a suppression in a
+child expression now suppresses errors in the outer expression.
+
+For example, the `type: ignore` comment in this example suppresses the error of adding `2` to
+`"test"` and adding `"other"` to the result of the cast.
+
+```py
+from typing import cast
+
+y = (
+    # error: [unsupported-operator]
+    cast(
+        int,
+        2 + "test",  # type: ignore
+    )
+    + "other"
+)
+```
+
+Mypy flags the second usage.
+
+## Before opening parenthesis
+
+A suppression that applies to all errors before the opening parenthesis.
+
+```py
+a: Test = (  # type: ignore
+  Test()  # error: [unresolved-reference]
+)  # fmt: skip
+```
+
+## Multiline string
+
+```py
+a: int = 4
+a = """
+  This is a multiline string and the suppression is at its end
+"""  # type: ignore
+```
+
+## Line continuations
+
+Suppressions after a line continuation apply to all previous lines.
+
+```py
+# fmt: off
+a = test \
+  + 2  # type: ignore
+
+a = test \
+  + a \
+  + 2  # type: ignore
+```
+
+## Codes
+
+Mypy supports `type: ignore[code]`. ty doesn't understand mypy's rule names. Therefore, ignore the
+codes and suppress all errors.
+
+```py
+a = test  # type: ignore[name-defined]
+```
+
+## Nested comments
+
+```py
+# fmt: off
+a = test \
+  + 2  # fmt: skip # type: ignore
+
+a = test \
+  + 2  # type: ignore # fmt: skip
+```
+
+## Misspelled `type: ignore`
+
+```py
+# error: [unresolved-reference]
+# error: [invalid-ignore-comment]
+a = test + 2  # type: ignoree
+```
+
+## Invalid - ignore on opening parentheses
+
+`type: ignore` comments after an opening parentheses suppress any type errors inside the parentheses
+in Pyright. Neither Ruff, nor mypy support this and neither does ty.
+
+```py
+# fmt: off
+# error: [unused-ignore-comment]
+a = (  # type: ignore
+    test + 4  # error: [unresolved-reference]
+)
+```
+
+## File level suppression
+
+```py
+# type: ignore
+
+a = 10 / 0
+b = a / 0
+```
+
+## File level suppression with leading shebang
+
+```py
+#!/usr/bin/env/python
+# type: ignore
+
+a = 10 / 0
+b = a / 0
+```
+
+## Invalid own-line suppression
+
+```py
+"""
+File level suppressions must come before any non-trivia token,
+including module docstrings.
+"""
+
+# error: [unused-ignore-comment] "Unused blanket `type: ignore` directive"
+# type: ignore
+
+a = 10 / 0  # error: [division-by-zero]
+b = a / 0  # error: [division-by-zero]
+```