python · ilevkivskyi · Jan 26, 2020 · Jan 25, 2020 · Jan 26, 2020 · Jan 26, 2020
diff --git a/docs/source/final_attrs.rst b/docs/source/final_attrs.rst
@@ -219,3 +219,17 @@ Here are some situations where using a final class may be useful:
   base classes and subclasses.
 * You want to retain the freedom to arbitrarily change the class implementation
   in the future, and these changes might break subclasses.
+
+An abstract class that defines at least one abstract method or
+property and has ``@final`` decorator will generate an error from
+mypy, since those attributes could never be implemented.
+
+.. code-block:: python
+
+    from abc import ABCMeta, abstractmethod
+    from typing_extensions import final
+
+    @final
+    class A(metaclass=ABCMeta):  # error: Final class A has abstract attributes "f"
+        @abstractmethod
+        def f(self, x: int) -> None: pass
diff --git a/mypy/semanal_classprop.py b/mypy/semanal_classprop.py
@@ -109,6 +109,10 @@ def report(message: str, severity: str) -> None:
             report("Class {} has abstract attributes {}".format(typ.fullname, attrs), 'error')
             report("If it is meant to be abstract, add 'abc.ABCMeta' as an explicit metaclass",
                    'note')
+    if typ.is_final and abstract:
+        attrs = ", ".join('"{}"'.format(attr) for attr in sorted(abstract))
+        errors.report(typ.line, typ.column,
+                      "Final class {} has abstract attributes {}".format(typ.fullname, attrs))
 
 
 def check_protocol_status(info: TypeInfo, errors: Errors) -> None:

diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
@@ -6677,3 +6677,50 @@ class B:
                                         # N: Perhaps you need "Callable[...]" or a callback protocol?
 
 [builtins fixtures/classmethod.pyi]
+
+[case testFinalClassWithAbstractAttributes]
+from abc import abstractmethod, ABCMeta
+from typing import final
+
+@final
+class A(metaclass=ABCMeta):  # E: Final class __main__.A has abstract attributes "bar", "foo"
+    @abstractmethod
+    def foo(self):
+        pass
+
+    @property
+    @abstractmethod
+    def bar(self):
+        pass
+
+[builtins fixtures/property.pyi]
+
+[case testFinalClassWithoutABCMeta]
+from abc import abstractmethod
+from typing import final
+
+@final
+class A():  # E: Final class __main__.A has abstract attributes "bar", "foo"
+    @abstractmethod
+    def foo(self):
+        pass
+
+    @property
+    @abstractmethod
+    def bar(self):
+        pass
+
+[builtins fixtures/property.pyi]
+
+[case testFinalClassInheritedAbstractAttributes]
+from abc import abstractmethod, ABCMeta
+from typing import final
+
+class A(metaclass=ABCMeta):
+    @abstractmethod
+    def foo(self):
+        pass
+
+@final
+class B(A):  # E: Final class __main__.B has abstract attributes "foo"
+    pass