fix new rule - empty body #3738

[asukaminato0721]

Summary

Fixes #3738

Added empty-body error kind and docs

Track ellipsis-only function bodies through binding/solving and emit when None is not assignable to the annotated return

Exempt .pyi, protocols, abstract methods, overloads, and if TYPE_CHECKING

Test Plan

add test

[github-actions]

Diff from mypy_primer, showing the effect of this PR on open source code:

pip (https://github.com/pypa/pip)
+ ERROR src/pip/_vendor/requests/sessions.py:132:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

egglog-python (https://github.com/egraphs-good/egglog-python)
+ ERROR python/egglog/builtins.py:449:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/egglog/builtins.py:605:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/egglog/builtins.py:623:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/egglog/builtins.py:660:5-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/egglog/builtins.py:1038:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/egglog/builtins.py:1111:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

steam.py (https://github.com/Gobot1234/steam.py)
+ ERROR steam/abc.py:823:15-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR steam/ext/csgo/client.py:242:19-29: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR steam/types/vdf.py:31:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR steam/types/vdf.py:33:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

jax (https://github.com/google/jax)
+ ERROR jax/_src/array.py:598:7-48: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

spark (https://github.com/apache/spark)
+ ERROR python/pyspark/sql/column.py:1591:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:194:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:224:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:741:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:785:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:837:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:859:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:890:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1033:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1043:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1078:9-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1121:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1187:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1230:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1256:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1325:9-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1360:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1398:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1436:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1468:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1559:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1591:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1768:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1876:9-27: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1935:9-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:1996:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2113:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2207:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2255:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2295:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2318:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2451:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2509:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2550:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2590:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2633:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2814:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2916:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:2985:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3071:9-29: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3135:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3364:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3428:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3683:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3729:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3783:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:3813:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4344:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4431:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4477:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4516:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4628:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4727:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4762:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4843:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4910:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:4968:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5035:9-23: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5093:9-38: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5144:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5228:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5352:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5474:9-23: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5573:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5611:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5646:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5690:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5739:9-34: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5756:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5794:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5840:9-26: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5903:9-27: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:5973:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6003:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6136:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6172:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6231:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6276:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6307:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6343:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6374:9-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6510:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6615:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:6740:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7140:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7156:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7188:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7229:9-23: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7239:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7244:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7249:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7254:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/dataframe.py:7259:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:71:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:123:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:175:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:251:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:347:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:360:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:373:9-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR python/pyspark/sql/window.py:400:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

prefect (https://github.com/PrefectHQ/prefect)
+ ERROR src/prefect/flows.py:2379:13-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/concurrency/lease_storage/__init__.py:31:15-27: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/concurrency/lease_storage/__init__.py:59:15-36: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/concurrency/lease_storage/__init__.py:63:15-37: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/concurrency/lease_storage/__init__.py:65:15-37: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/worker_communication/cleanup_queue/__init__.py:111:15-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/worker_communication/cleanup_queue/__init__.py:151:15-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/worker_communication/cleanup_queue/__init__.py:168:15-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/worker_communication/cleanup_queue/__init__.py:185:15-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/worker_communication/cleanup_queue/__init__.py:201:15-28: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/worker_communication/cleanup_queue/__init__.py:244:15-31: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/prefect/server/worker_communication/cleanup_queue/__init__.py:253:15-35: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

colour (https://github.com/colour-science/colour)
+ ERROR colour/hints/__init__.py:673:5-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR colour/hints/__init__.py:676:5-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

Expression (https://github.com/cognitedata/Expression)
+ ERROR expression/core/typing.py:53:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

manticore (https://github.com/trailofbits/manticore)
+ ERROR manticore/native/cpu/abstractcpu.py:271:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

hydra-zen (https://github.com/mit-ll-responsible-ai/hydra-zen)
+ ERROR tests/annotations/behaviors.py:22:5-6: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:451:5-23: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:467:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:469:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:501:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:503:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:796:13-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1072:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1085:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1097:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1146:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1149:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1161:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1164:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1174:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1253:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1287:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1322:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/declarations.py:1357:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/mypy_checks.py:16:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/mypy_checks.py:32:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/mypy_checks.py:55:9-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/mypy_checks.py:58:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/mypy_checks.py:71:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/mypy_checks.py:74:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/annotations/mypy_checks.py:87:9-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/hydra_zen/typing/_builds_overloads.py:229:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/hydra_zen/typing/_builds_overloads.py:468:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/hydra_zen/typing/_builds_overloads.py:654:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

antidote (https://github.com/Finistere/antidote)
+ ERROR tests/core/test_catalog.py:225:13-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_catalog.py:238:13-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_catalog.py:258:13-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_thread_safety.py:272:13-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:137:17-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:143:17-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:150:21-27: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:157:21-27: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:171:17-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:178:21-27: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:202:21-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/core/test_type_hints_locals.py:209:25-31: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/injectable/test_injectable.py:113:13-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/injectable/test_provider.py:53:13-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_custom.py:362:13-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_custom.py:386:13-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:119:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:123:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:127:9-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:300:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:306:13-29: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:312:13-30: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:318:13-32: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:324:13-34: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:329:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:333:9-25: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:337:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:342:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:350:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:357:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:364:9-31: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:371:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:378:9-28: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:385:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:392:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:538:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:542:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:560:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_function.py:585:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:142:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:435:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:441:13-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:447:13-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:451:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:455:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:463:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:665:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:669:9-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:689:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/interface/test_lazy.py:741:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/lazy/test_lazy.py:286:13-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/lazy/test_lazy.py:293:13-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/lazy/test_lazy.py:301:17-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/lazy/test_lazy.py:308:17-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/lazy/test_lazy.py:316:17-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR tests/lib/lazy/test_lazy.py:324:17-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1014:13-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1017:13-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1026:13-23: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1029:13-23: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1035:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1068:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1263:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1266:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1278:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1281:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1369:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1372:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1384:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR src/antidote/lib/interface_ext/__init__.py:1387:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

ibis (https://github.com/ibis-project/ibis)
+ ERROR ibis/backends/bigquery/tests/system/udf/test_udf_execute.py:157:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/bigquery/tests/system/udf/test_udf_execute.py:179:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/bigquery/tests/unit/udf/test_builtin.py:9:5-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/clickhouse/tests/test_client.py:305:5-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/clickhouse/tests/test_client.py:309:5-39: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/clickhouse/tests/test_client.py:313:5-22: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/clickhouse/tests/test_client.py:332:5-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/clickhouse/tests/test_client.py:336:5-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/clickhouse/tests/test_functions.py:475:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/clickhouse/tests/test_functions.py:490:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:13:5-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:17:5-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:21:5-20: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:25:5-28: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:29:5-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:33:5-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:57:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:64:5-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:68:5-9: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:72:5-9: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/duckdb/tests/test_udf.py:175:9-32: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/flink/tests/test_udf.py:8:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/polars/tests/test_udf.py:58:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/polars/tests/test_udf.py:110:9-24: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/pyspark/tests/test_udf.py:24:5-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/snowflake/tests/test_udf.py:16:5-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/snowflake/tests/test_udf.py:20:5-27: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/snowflake/tests/test_udf.py:25:5-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/snowflake/tests/test_udf.py:29:5-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/backends/snowflake/tests/test_udf.py:71:5-30: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/common/tests/test_patterns.py:332:13-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/common/tests/test_patterns.py:334:13-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/tests/expr/test_udf.py:100:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/tests/expr/test_udf.py:142:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/tests/expr/test_udf.py:152:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR ibis/tests/expr/test_udf.py:171:9-37: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

mypy (https://github.com/python/mypy)
+ ERROR mypyc/test-data/fixtures/ir.py:105:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:106:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:107:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:108:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:114:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:115:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:116:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:119:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:124:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:125:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:126:9-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:127:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:128:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:129:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:130:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:131:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:132:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:133:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:134:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:135:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:137:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:138:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:139:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:158:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:159:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:160:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:161:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:178:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:179:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:180:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:181:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:182:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:187:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:188:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:189:9-18: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:190:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:191:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:192:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:201:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:207:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:208:9-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:209:9-19: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:210:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:211:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:235:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:236:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:241:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:242:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:256:9-17: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:259:9-21: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:314:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:315:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:321:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:322:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:342:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:343:9-15: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:344:9-16: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:394:5-13: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:405:5-9: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:406:5-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:407:5-12: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:411:5-14: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:417:5-8: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:428:5-11: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:430:5-8: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:431:5-8: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:432:5-9: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:433:5-10: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:434:5-8: Function body cannot consist only of `...` when the return type is not `None` [empty-body]
+ ERROR mypyc/test-data/fixtures/ir.py:435:5-8: Function body cannot consist only of `...` when the return type is not `None` [empty-body]

[github-actions]

Primer Diff Classification

✅ 13 improvement(s) | 13 project(s) total | +334 errors

13 improvement(s) across pip, egglog-python, steam.py, jax, spark, prefect, colour, Expression, manticore, hydra-zen, antidote, ibis, mypy.

Project	Verdict	Changes	Error Kinds	Root Cause
pip	✅ Improvement	+1	empty-body	pyrefly/lib/alt/function.rs
egglog-python	✅ Improvement	+6	empty-body on DSL-decorated methods	crates/pyrefly_config/src/error_kind.rs
steam.py	✅ Improvement	+4	empty-body on concrete non-guarded methods	crates/pyrefly_config/src/error_kind.rs
jax	✅ Improvement	+1	empty-body	use_cpp_method()
spark	✅ Improvement	+101	empty-body	pyrefly/lib/alt/function.rs
prefect	✅ Improvement	+12	empty-body on informal abstract classes	crates/pyrefly_config/src/error_kind.rs
colour	✅ Improvement	+2	empty-body	crates/pyrefly_config/src/error_kind.rs
Expression	✅ Improvement	+1	empty-body	crates/pyrefly_config/src/error_kind.rs
manticore	✅ Improvement	+1	empty-body on non-abstract method	crates/pyrefly_config/src/error_kind.rs
hydra-zen	✅ Improvement	+29	empty-body	crates/pyrefly_config/src/error_kind.rs
antidote	✅ Improvement	+70	empty-body	crates/pyrefly_config/src/error_kind.rs
ibis	✅ Improvement	+36	empty-body on @udf.scalar.builtin / @udf.agg.builtin decorated functions	crates/pyrefly_config/src/error_kind.rs
mypy	✅ Improvement	+70	empty-body on stub-like .py fixture file	pyrefly/lib/alt/function.rs

Detailed analysis

✅ Improvement (13)

pip (+1)

This is a false positive. The send method in SessionRedirectMixin is a deliberate stub — the class is a mixin whose methods (like resolve_redirects) call self.send(), and the actual implementation is provided by Session.send() at line 752. While the method isn't formally @abstractmethod or part of a Protocol, this mixin pattern is extremely common in Python. Neither mypy nor pyright flag this. The new empty-body check needs an additional exemption for this pattern (e.g., methods in non-Protocol classes that are overridden by subclasses, or at minimum, the check should be less aggressive for methods in classes that appear to be mixins).
Attribution: The new empty-body error kind added in pyrefly/lib/alt/function.rs (the EmptyBody check in the function validation logic) fires on this method because SessionRedirectMixin is not a Protocol, not abstract, not in a stub file, and not under TYPE_CHECKING. The exemption logic in the PR doesn't account for mixin classes that define method stubs intended to be overridden by concrete subclasses.

egglog-python (+6)

❌ empty-body on DSL-decorated methods: All 6 errors flag methods decorated with @method(egg_fn=...) from egglog's DSL. These decorators replace the function body at runtime — the ... is intentional and idiomatic for this DSL. The file explicitly has # mypy: disable-error-code="empty-body" on line 1. Neither mypy nor pyright flag these (0/6 cross-check). Notably, the file has dozens of other ...-body methods with non-None return types that are NOT flagged (e.g., __add__ returning i64, replace returning String). The 6 flagged methods appear to be specifically those returning TypeVars (T or V) — e.g., Map.__getitem__ returning V, MultiSet.pick and pick_max returning T, Vec.__getitem__ returning T. This suggests pyrefly inconsistently applies the empty-body check only when the return type is a TypeVar. These are false positives because the pattern is intentional DSL usage, and the check is applied inconsistently.

Overall: These are false positives. The egglog project uses ... bodies extensively as a DSL pattern — the @method(egg_fn=...) decorator registers the function signature with the e-graph system, and the body is never executed. This is a well-established pattern in Python DSLs (similar to SQLAlchemy column declarations, Pydantic models, etc.). The file has # mypy: disable-error-code="empty-body" on line 1, explicitly acknowledging this pattern.

Notably, the file contains dozens of methods with ... bodies and non-None return types (e.g., __add__ on i64 returning i64, replace on String returning String, etc.), but only 6 are flagged. The flagged methods appear to be specifically those returning TypeVars (T or V) rather than concrete types — such as __getitem__ on Map returning V, pick and pick_max on MultiSet returning T, and __getitem__ on Vec returning T. This suggests pyrefly's empty-body check may have a bug where it only triggers for TypeVar return types, while the same pattern with concrete return types is silently accepted.

All flagged methods are decorated with @method(egg_fn=...) which transforms them into e-graph operations at runtime. Neither mypy nor pyright flag these (0/6 cross-check). The new check should recognize decorator-based DSL patterns or at minimum handle TypeVar return types consistently with concrete return types in ...-body methods.

Attribution: The new empty-body error kind was added in crates/pyrefly_config/src/error_kind.rs. The check logic is in pyrefly/lib/alt/function.rs in the function that processes UndecoratedFunction. The check exempts stub files, overloads, abstract methods, and protocol methods, but does NOT exempt functions decorated with custom decorators like @method(...) or @function(...) that serve as DSL declarations. The has_ellipsis_body flag is propagated from pyrefly/lib/binding/function.rs through BindingUndecoratedFunction.

steam.py (+4)

✅ empty-body on concrete non-guarded methods: abc.py:823 is a real issue — concrete method with non-None return and ellipsis body. Improvement.
❌ empty-body under TYPE_CHECKING or X guard: csgo/client.py:242 is inside if TYPE_CHECKING or DOCS_BUILDING: block. The Or-logic bug in is_type_checking_guard causes a false positive. Regression.
✅ empty-body with Never return type: vdf.py:31,33 have -> Never return types with ... bodies. Mypy agrees these are errors. While the pattern is intentional, None is indeed not assignable to Never. Defensible improvement.

Overall: 3 of 4 errors are legitimate (co-reported by mypy). The csgo/client.py:242 error is a false positive caused by a bug in the Or-branch logic of is_type_checking_guard — it uses all() where any() is needed, failing to recognize TYPE_CHECKING or DOCS_BUILDING as a TYPE_CHECKING guard. Overall this is a net improvement: 3 correct new errors vs 1 false positive.

Per-category reasoning:

• empty-body on concrete non-guarded methods: abc.py:823 is a real issue — concrete method with non-None return and ellipsis body. Improvement.
• empty-body under TYPE_CHECKING or X guard: csgo/client.py:242 is inside if TYPE_CHECKING or DOCS_BUILDING: block. The Or-logic bug in is_type_checking_guard causes a false positive. Regression.
• empty-body with Never return type: vdf.py:31,33 have -> Never return types with ... bodies. Mypy agrees these are errors. While the pattern is intentional, None is indeed not assignable to Never. Defensible improvement.

Attribution: The new empty-body error kind added in crates/pyrefly_config/src/error_kind.rs and the check logic in pyrefly/lib/alt/function.rs cause all four errors. The false positive on csgo/client.py:242 is caused by the is_type_checking_guard function in crates/pyrefly_python/src/sys_info.rs using .all() for BoolOp::Or — this requires ALL operands to be TYPE_CHECKING, but TYPE_CHECKING or DOCS_BUILDING has a non-TYPE_CHECKING operand. The correct logic for Or should be .any() (if any disjunct is TYPE_CHECKING, the block is entered during type checking). The type_checking_depth tracking in pyrefly/lib/binding/bindings.rs and pyrefly/lib/binding/stmt.rs correctly gates the exemption but depends on the flawed guard detection.

jax (+1)

This is a borderline case. The new empty-body check is generally useful and catches real issues (a function declaring -> tuple[np.ndarray, bool] but having only ... as its body would return None at runtime). Mypy also flags this same pattern.

However, in this specific JAX codebase, the @use_cpp_method() decorator replaces the Python body with a C++ implementation, making the ... body an intentional placeholder — similar to how stub files use .... The type checker cannot see through this decorator pattern.

That said, the error is technically correct from a static analysis perspective: without understanding the decorator's runtime behavior, a function with body ... and return type tuple[np.ndarray, bool] would indeed return None. Mypy agrees. The JAX project would need to either suppress this with a # type: ignore comment or restructure the code (e.g., raise NotImplementedError).

Since mypy also flags this, and the check is correct from a pure type-checking perspective (the function body as written doesn't satisfy the return type), this is a legitimate new check being applied correctly. The fact that the decorator replaces the body at runtime is not something the type checker is expected to understand without special-casing.

Attribution: The PR adds a new EmptyBody error kind in error_kind.rs and implements the check in pyrefly/lib/alt/function.rs. The check fires when: (1) the function body is only ..., (2) there's a return annotation, (3) None is not assignable to the return type, and (4) the function is not in a stub file, not an overload, not abstract, not in a protocol class, and not under TYPE_CHECKING. The @[use_cpp_method()](https://github.com/facebook/pyrefly/blob/main/pyrefly/lib/alt/function.rs) decorator is not in the exemption list, so the error fires on _single_device_array_to_np_array_did_copy.

spark (+101)

This is a regression. The PySpark project uses a well-established pattern where base classes define method stubs with ... bodies and @dispatch_col_method/@dispatch_df_method decorators. The actual implementations are in subclasses, and __new__ redirects to the concrete class. The files explicitly include # mypy: disable-error-code="empty-body" (line 18 in both files), showing the authors are aware of and have opted out of this check. Pyrefly's new empty-body rule doesn't account for: (1) decorator-based dispatch patterns where the body is intentionally empty, (2) mypy error code suppression comments. The 0/101 cross-check rate with mypy/pyright strongly confirms these are false positives. The PR's exemption list (stubs, protocols, abstract methods, overloads, TYPE_CHECKING) is too narrow for real-world Python code patterns.
Attribution: The PR adds a new EmptyBody error kind in pyrefly/lib/alt/function.rs that flags functions with ellipsis-only bodies when the return type is not None. The exemptions include stub files, protocols, abstract methods, overloads, and if TYPE_CHECKING blocks. However, the PR does NOT exempt functions decorated with dispatch decorators like @dispatch_col_method/@dispatch_df_method, nor does it respect mypy's # mypy: disable-error-code directives. The has_ellipsis_body flag is set in pyrefly/lib/binding/function.rs and checked in pyrefly/lib/alt/function.rs during solving.

prefect (+12)

✅ empty-body on informal abstract classes: ConcurrencyLeaseStorage and similar classes inherit from LeaseStorage (a regular class, not a Protocol) and define methods with ... bodies and non-None return types but don't use @AbstractMethod. These are real issues — the methods would return None at runtime if called on the base class, violating their declared return types. Co-reported by mypy.
✅ empty-body in else-TYPE_CHECKING block: The from_source method in FlowDecorator is in the else branch of if not TYPE_CHECKING:, which means it only exists when TYPE_CHECKING is True — making it a pure type stub never executed at runtime. The ... body is intentional for this pattern. While the PR may exempt if TYPE_CHECKING: blocks, the inverted form if not TYPE_CHECKING: ... else: may not be recognized as equivalent. Mypy also flags it. This is a minor gap in pattern recognition but the error is technically correct per the rule's logic.

Overall: Most errors (10-11 of 12) correctly flag informal abstract/interface classes (ConcurrencyLeaseStorage, etc.) that define methods with ... bodies and non-None return types without using @abstractmethod. ConcurrencyLeaseStorage inherits from LeaseStorage[ConcurrencyLimitLeaseMetadata] — it is a regular class (not a Protocol), and its methods with ... bodies would return None at runtime if called on the base class, violating their declared return types. These are real code quality issues. The flows.py error on from_source in the else branch of if not TYPE_CHECKING: is a type stub that only exists when TYPE_CHECKING is True. This is a legitimate type annotation pattern — the method body is ... because it's purely a type stub for static analysis, never executed at runtime. The check flags it because the else branch of if not TYPE_CHECKING is equivalent to if TYPE_CHECKING, but the empty-body rule may not recognize this inverted pattern. Mypy also flags it, and 12/12 co-reported by mypy supports these as correct checks.

Attribution: The new empty-body error kind added in crates/pyrefly_config/src/error_kind.rs, the detection logic in pyrefly/lib/alt/function.rs (checking has_ellipsis_body and exempting stubs/protocols/abstract/overloads), and the type_checking_depth tracking in pyrefly/lib/binding/bindings.rs and pyrefly/lib/binding/stmt.rs together implement this new check. The else branch of if TYPE_CHECKING is not exempted because type_checking_depth is only incremented for the if TYPE_CHECKING body, not the else body.

colour (+2)

These two functions (arraylike and number_or_arraylike) at lines 673 and 676 are standalone functions (not in a protocol, not abstract, not overloads, not in a .pyi file, not inside if TYPE_CHECKING:) that declare -> NDArray as their return type but have only ... as their body. At runtime they return None, which is not an NDArray. Mypy also flags these. The functions appear to be type-testing utilities (their results are used and then deleted at line 721), but they are genuinely problematic — they claim to return NDArray but don't. The new empty-body check correctly identifies this inconsistency. The PR properly exempts protocols, abstract methods, overloads, stub files, and TYPE_CHECKING blocks, and these functions don't fall into any of those categories.
Attribution: The new empty-body error kind was added in crates/pyrefly_config/src/error_kind.rs. The detection logic is in pyrefly/lib/alt/function.rs where it checks def.has_ellipsis_body && has_return_annotation && !none_is_assignable_to_return along with exemptions for stub files, overloads, abstract methods, and protocol classes. The has_ellipsis_body flag is propagated from pyrefly/lib/binding/function.rs where body_is_ellipse is computed. The type_checking_depth tracking in pyrefly/lib/binding/bindings.rs and pyrefly/lib/binding/stmt.rs ensures functions inside if TYPE_CHECKING: blocks are exempt.

Expression (+1)

This is a correct application of the new empty-body check. The ModelField.validate method at line 53 has a body of just ... with a return type of tuple[Any, Any]. At runtime, this function returns None, which is not assignable to tuple[Any, Any]. The class is not a Protocol, not abstract, not in a .pyi file, not an overload, and not inside a TYPE_CHECKING block. While the developer's intent is clearly to use this as a mock/stub class, the check is correctly applied per its rules. Mypy agrees with this assessment (marked [mypy: yes]). The code genuinely has a type inconsistency — if validate were ever called, it would return None instead of the declared tuple[Any, Any]. This is a real bug that pyrefly is now correctly catching.
Attribution: The new empty-body error kind was added in crates/pyrefly_config/src/error_kind.rs. The check logic is in pyrefly/lib/alt/function.rs where it verifies: has_ellipsis_body && has_return_annotation && !none_is_assignable_to_return && !defined_in_stub_file && !is_overload && !is_abstract_method && !is_protocol. The has_ellipsis_body flag is propagated from pyrefly/lib/binding/function.rs where body_is_ellipse is detected. The type_checking_depth tracking in pyrefly/lib/binding/stmt.rs and pyrefly/lib/binding/bindings.rs ensures TYPE_CHECKING blocks are exempt.

manticore (+1)

✅ empty-body on non-abstract method: The __copy__ method on RegisterFile declares -> RegisterFile but has only ... as its body. It's not abstract, not a protocol method, not an overload, and not in a stub file. This is a real bug — the method will return None at runtime instead of a RegisterFile. Mypy also flags this.

Overall: Looking at the code at line 271: def __copy__(self) -> 'RegisterFile': ... — this is a method on the RegisterFile class that declares it returns a RegisterFile but has only ... as its body. The class is NOT a Protocol (it's a regular class inheriting from object), the method is NOT decorated with @abstractmethod or @overload, and this is NOT a .pyi stub file. The method's docstring says 'Custom shallow copy to create a snapshot of the register state. Should be used as read-only' — this suggests the method is intended to be overridden by subclasses, but it's not marked as abstract. At runtime, calling copy.copy() on a RegisterFile instance would invoke this method and get None back instead of a RegisterFile. This is a genuine bug — the method should either be marked @abstractmethod, raise NotImplementedError, or have an actual implementation. Mypy agrees this is an error. This is a correct new check catching a real issue in the code.

Attribution: The new empty-body error kind was added in crates/pyrefly_config/src/error_kind.rs. The detection logic is in pyrefly/lib/alt/function.rs where has_ellipsis_body is checked along with conditions that None is not assignable to the return type, and the function is not in a stub file, not an overload, not abstract, and not in a protocol class. The has_ellipsis_body flag is propagated from pyrefly/lib/binding/function.rs through pyrefly/lib/binding/binding.rs and pyrefly/lib/alt/types/decorated_function.rs.

hydra-zen (+29)

These are false positives. The ... body pattern is a standard Python idiom for declaring function stubs in .py files, especially in test suites and type-checking infrastructure. The hydra-zen test files use this pattern extensively to declare function signatures for testing builds(), partial(), and other type-level operations. Pyright flags 0/29 of these. While the new check correctly exempts some patterns, it's too aggressive for regular .py files where ... stubs are intentional and idiomatic.
Attribution: The new empty-body error kind added in crates/pyrefly_config/src/error_kind.rs and the check logic in pyrefly/lib/alt/function.rs (lines 661-686) emit errors for any non-exempt function with an ellipsis body and non-None return type. The exemptions (stub files, overloads, protocols, abstract methods, TYPE_CHECKING) are insufficient — they don't cover the common pattern of stub functions in test files and type declaration modules.

antidote (+70)

These 70 new errors correctly identify functions with ellipsis-only bodies that declare non-None return types. The functions would return None at runtime, violating their type annotations. All 70 are co-reported by mypy, confirming they are legitimate findings. The exemptions (stubs, protocols, @AbstractMethod, overloads, TYPE_CHECKING) are properly implemented and consistent with mypy's behavior. The cases in ABC subclasses without @AbstractMethod are correctly flagged — being in an ABC class doesn't make a method abstract unless decorated with @AbstractMethod. For example, DebugYProvider (line 224) inherits from Provider only (not ABC), and its can_provide method with an ellipsis body and bool return type is correctly flagged. Similarly, NoDebugProvider and DebugErrorProvider inherit from both Provider and ABC, but their can_provide methods lack the @abstractmethod decorator, making them concrete methods that would return None at runtime instead of bool.
Attribution: The new empty-body error kind added in crates/pyrefly_config/src/error_kind.rs, with the detection logic in pyrefly/lib/alt/function.rs (checking def.has_ellipsis_body and !none_is_assignable_to_return), and the body tracking through pyrefly/lib/binding/function.rs (propagating body_is_ellipse into BindingUndecoratedFunction). The exemptions for abstract methods, protocols, overloads, stubs, and TYPE_CHECKING blocks are implemented in the same function in function.rs and stmt.rs.

ibis (+36)

✅ empty-body on @udf.scalar.builtin / @udf.agg.builtin decorated functions: All 36 errors are on functions decorated with ibis UDF decorators (@udf.scalar.builtin, @udf.agg.builtin) that use ... as the body with non-None return types. Examples: def bit_count(x: bytes) -> int: ... decorated with @udf.scalar.builtin, def farm_fingerprint(value: bytes) -> int: ..., def concat_agg(x, where: bool = True) -> dt.Array[str]: .... These are intentional patterns in ibis where the decorator provides the implementation, but from a type-checking perspective, the function body is ... and the return type is not None. Mypy flags all 36 of these too (100% co-reporting). This is a correct new check that pyrefly now implements, matching mypy's established behavior. The ibis project would need to either suppress these warnings or use a different pattern (like @abstractmethod or stub files) to avoid them.

Overall: This is a new empty-body check that correctly identifies functions with ... bodies that declare non-None return types. The check is well-established in mypy (100% co-reporting confirms this). While the ibis project uses @udf.scalar.builtin and @udf.agg.builtin decorators that intentionally use ... bodies (the decorator replaces the function implementation), the type checker cannot know that these specific decorators make the ... body safe. From a pure type-checking perspective, a function body of ... with a non-None return type is a legitimate warning — the function as written would return None, violating its declared type. The PR correctly exempts the standard cases (stubs, protocols, abstract methods, overloads, TYPE_CHECKING blocks). The ibis UDF pattern is a domain-specific convention that the type checker reasonably flags. This matches mypy's behavior exactly. The new check is a genuine improvement in pyrefly's capabilities.

Attribution: The new empty-body error kind was added in crates/pyrefly_config/src/error_kind.rs. The detection logic is in pyrefly/lib/alt/function.rs where has_ellipsis_body is checked along with conditions for exemptions (stub files, overloads, abstract methods, protocols). The has_ellipsis_body flag is threaded through from pyrefly/lib/binding/function.rs where body_is_ellipse is computed and passed into BindingUndecoratedFunction. The type_checking_depth tracking in pyrefly/lib/binding/bindings.rs and pyrefly/lib/binding/stmt.rs ensures functions inside if TYPE_CHECKING blocks are exempted.

mypy (+70)

❌ empty-body on stub-like .py fixture file: All 70 errors are in mypyc/test-data/fixtures/ir.py, a file that explicitly declares itself as 'builtins stubs used implicitly in AST to IR generation test cases.' Every function in this file uses pass or ... as a placeholder body because these are type stub definitions for built-in types and functions. The new empty-body check correctly exempts .pyi files but fires on this .py file that semantically serves as a stub. These are false positives — the code is intentionally written this way and is not buggy. 0/70 flagged by mypy, only 18/70 by pyright.

Overall: The file mypyc/test-data/fixtures/ir.py is explicitly described in its first line as 'builtins stubs used implicitly in AST to IR generation test cases.' It's a .py file that functions as a type stub — every function body is either pass or ... because these are stub definitions for built-in types like int, str, float, bytes, list, dict, tuple, set, property, and built-in functions like hash, sorted, min, max, repr, etc. These are not real implementations — they are type declarations.

The new empty-body rule correctly exempts .pyi files, protocols, abstract methods, and overloads, but it fires on this .py file that acts as a stub. While pyrefly can't be expected to know that every .py file with stub-like patterns is a stub, the practical impact is 70 false positives on a legitimate test fixture file. The fact that 0/70 are flagged by mypy and only 18/70 by pyright confirms this is overly aggressive.

The 18 pyright matches likely correspond to functions where pyright also flags empty bodies (pyright has reportReturnType which catches some of these), but the majority (52/70) are pyrefly-only, suggesting pyrefly's implementation is stricter than pyright's in practice.

This is a regression — the new rule is producing false positives on a file that is semantically a stub file despite having a .py extension. The rule itself is reasonable but its application here produces noise with no value.

Attribution: The new empty-body error kind added in pyrefly/lib/alt/function.rs (the EmptyBody check in the function validation logic) is responsible. The check exempts .pyi files, protocols, abstract methods, and overloads, but it does NOT exempt .py files that function as stubs. The file mypyc/test-data/fixtures/ir.py is a .py file that serves as a type stub — it has pass and ... bodies throughout for all its function definitions. The check in pyrefly/lib/alt/function.rs at the condition !def.metadata.flags.defined_in_stub_file only checks for .pyi extension, not for files that semantically act as stubs. Additionally, the has_ellipsis_body detection doesn't account for pass bodies (many functions in this file use pass instead of ...), but the 70 errors are specifically on functions using ....

---

Was this helpful? React with 👍 or 👎

_{Classification by primer-classifier (13 LLM)}