abstract and read only

Author: KotlinIsland

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 ### Added
+- `Abstract` and `abstract` modifiers
+- `ReadOnly` attributes
+
+## [2.9.0]
+### Added
 - `collections.User*` should have `__repr__`
 ### Fixed
 - cache modules that only have baseline errors

docs/source/based_features.rst

@@ -158,6 +158,55 @@ represent a set of choices that the ``TypeVar`` can be replaced with:
     type C = B[object]  # mypy doesn't report the error here
 
 
+Abstract Classes
+----------------
+
+abstract classes are more strict:
+
+.. code-block:: python
+
+    class A:  # error: abstract class not denoted as abstract
+        @abstractmethod
+        def f(self): ...
+
+and more flexable:
+
+.. code-block:: python
+
+    from basedtyping import abstract
+
+    @abstract
+    class A:
+        @abstract
+        def f(self): ...
+
+
+and there are abstract attributes:
+
+.. code-block:: python
+
+    from basedtyping import abstract, Abstract
+
+    @abstract
+    class A:
+        a: Abstract[int]
+
+
+Read-only attributes
+--------------------
+
+simply:
+
+.. code-block:: python
+
+    from typing import ReadOnly
+
+    class A:
+        a: ReadOnly[int]
+
+    A().a = 1  # error: A.a is read-only
+
+
 Reinvented type guards
 ----------------------
 

mypy/checker.py

@@ -3604,6 +3604,14 @@ def check_assignment(
                 self.infer_variable_type(inferred, lvalue, rvalue_type, rvalue)
             self.check_assignment_to_slots(lvalue)
 
+        if (
+            isinstance(lvalue, NameExpr)
+            and isinstance(lvalue.node, Var)
+            and lvalue.node.is_read_only
+            and not self.get_final_context()
+        ):
+            self.msg.read_only(lvalue.node.name, rvalue)
+
     # (type, operator) tuples for augmented assignments supported with partial types
     partial_type_augmented_ops: Final = {("builtins.list", "+"), ("builtins.set", "|")}
 

mypy/checkmember.py

@@ -807,6 +807,8 @@ def analyze_var(
         if mx.is_lvalue and var.is_property and not var.is_settable_property:
             # TODO allow setting attributes in subclass (although it is probably an error)
             mx.msg.read_only_property(name, itype.type, mx.context)
+        if mx.is_lvalue and var.is_read_only:
+            mx.msg.read_only(name, mx.context, itype.type)
         if mx.is_lvalue and var.is_classvar:
             mx.msg.cant_assign_to_classvar(name, mx.context)
         t = freshen_all_functions_type_vars(typ)

mypy/message_registry.py

@@ -266,6 +266,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 CLASS_VAR_WITH_TYPEVARS: Final = "ClassVar cannot contain type variables"
 CLASS_VAR_WITH_GENERIC_SELF: Final = "ClassVar cannot contain Self type in generic classes"
 CLASS_VAR_OUTSIDE_OF_CLASS: Final = "ClassVar can only be used for assignments in class body"
+ABSTRACT_OUTSIDE_OF_CLASS: Final = "`Abstract` can only be used for assignments in a class body"
 
 # Protocol
 RUNTIME_PROTOCOL_EXPECTED: Final = ErrorMessage(

mypy/messages.py

@@ -1569,12 +1569,13 @@ def incompatible_conditional_function_def(
     def cannot_instantiate_abstract_class(
         self, class_name: str, abstract_attributes: dict[str, bool], context: Context
     ) -> None:
-        attrs = format_string_list([f'"{a}"' for a in abstract_attributes])
+        if abstract_attributes:
+            attrs = format_string_list([f'"{a}"' for a in abstract_attributes])
+            rest = f" with abstract attribute{plural_s(abstract_attributes)} {attrs}"
+        else:
+            rest = ""
         self.fail(
-            f'Cannot instantiate abstract class "{class_name}" with abstract '
-            f"attribute{plural_s(abstract_attributes)} {attrs}",
-            context,
-            code=codes.ABSTRACT,
+            f'Cannot instantiate abstract class "{class_name}"{rest}', context, code=codes.ABSTRACT
         )
         attrs_with_none = [
             f'"{a}"'
@@ -1655,7 +1656,18 @@ def final_without_value(self, ctx: Context) -> None:
         self.fail("Final name must be initialized with a value", ctx)
 
     def read_only_property(self, name: str, type: TypeInfo, context: Context) -> None:
-        self.fail(f'Property "{name}" defined in "{type.name}" is read-only', context)
+        self.fail(
+            f'Property "{name}" defined in "{type.name}" is read-only',
+            context,
+            code=ErrorCode("read-only", "", ""),
+        )
+
+    def read_only(self, name: str, context: Context, type: TypeInfo | None = None) -> None:
+        if type is None:
+            prefix = f'Name "{name}"'
+        else:
+            prefix = f'Attribute "{name}" defined in "{type.name}"'
+        self.fail(f"{prefix} is read only", context, code=ErrorCode("read-only", "", ""))
 
     def incompatible_typevar_value(
         self,

mypy/metastore.py

@@ -22,7 +22,7 @@
     import sqlite3
 
 
-class MetadataStore:
+class MetadataStore:  # type: ignore[abstract]
     """Generic interface for metadata storage."""
 
     @abstractmethod

mypy/nodes.py

@@ -247,7 +247,7 @@ class FakeExpression(Expression):
 
 
 @trait
-class SymbolNode(Node):
+class SymbolNode(Node):  # type: ignore[abstract]
     """Nodes that can be stored in a symbol table."""
 
     __slots__ = ()
@@ -505,7 +505,7 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
 FUNCBASE_FLAGS: Final = ["is_property", "is_class", "is_static", "is_final", "is_type_check_only"]
 
 
-class FuncBase(Node):
+class FuncBase(Node):  # type: ignore[abstract]
     """Abstract base class for function-like nodes.
 
     N.B: Although this has SymbolNode subclasses (FuncDef,
@@ -710,7 +710,7 @@ def __init__(
 ]
 
 
-class FuncItem(FuncBase):
+class FuncItem(FuncBase):  # type: ignore[abstract]
     """Base class for nodes usable as overloaded function items."""
 
     __slots__ = (
@@ -1021,6 +1021,7 @@ class Var(SymbolNode):
         "is_settable_property",
         "is_classvar",
         "is_abstract_var",
+        "is_read_only",
         "is_final",
         "is_index_var",
         "final_unset_in_class",
@@ -1058,6 +1059,7 @@ def __init__(self, name: str, type: mypy.types.Type | None = None) -> None:
         self.is_classvar = False
         self.is_abstract_var = False
         self.is_index_var = False
+        self.is_read_only = False
         # Set to true when this variable refers to a module we were unable to
         # parse for some reason (eg a silenced module)
         self.is_suppressed_import = False
@@ -2558,7 +2560,7 @@ def accept(self, visitor: ExpressionVisitor[T]) -> T:
 VARIANCE_NOT_READY: Final = 3  # Variance hasn't been inferred (using Python 3.12 syntax)
 
 
-class TypeVarLikeExpr(SymbolNode, Expression):
+class TypeVarLikeExpr(SymbolNode, Expression):  # type: ignore[abstract]
     """Base class for TypeVarExpr, ParamSpecExpr and TypeVarTupleExpr.
 
     Note that they are constructed by the semantic analyzer.

mypy/plugin.py

@@ -151,7 +151,7 @@ class C: pass
 
 
 @trait
-class TypeAnalyzerPluginInterface:
+class TypeAnalyzerPluginInterface:  # type: ignore[abstract]
     """Interface for accessing semantic analyzer functionality in plugins.
 
     Methods docstrings contain only basic info. Look for corresponding implementation
@@ -195,7 +195,7 @@ class AnalyzeTypeContext(NamedTuple):
 
 
 @mypyc_attr(allow_interpreted_subclasses=True)
-class CommonPluginApi:
+class CommonPluginApi:  # type: ignore[abstract]
     """
     A common plugin API (shared between semantic analysis and type checking phases)
     that all plugin hooks get independently of the context.
@@ -217,7 +217,7 @@ def lookup_fully_qualified(self, fullname: str) -> SymbolTableNode | None:
 
 
 @trait
-class CheckerPluginInterface:
+class CheckerPluginInterface:  # type: ignore[abstract]
     """Interface for accessing type checker functionality in plugins.
 
     Methods docstrings contain only basic info. Look for corresponding implementation
@@ -254,7 +254,7 @@ def get_expression_type(self, node: Expression, type_context: Type | None = None
 
 
 @trait
-class SemanticAnalyzerPluginInterface:
+class SemanticAnalyzerPluginInterface:  # type: ignore[abstract]
     """Interface for accessing semantic analyzer functionality in plugins.
 
     Methods docstrings contain only basic info. Look for corresponding implementation

mypy/report.py

@@ -705,7 +705,7 @@ def on_finish(self) -> None:
 register_reporter("cobertura-xml", CoberturaXmlReporter, needs_lxml=True)
 
 
-class AbstractXmlReporter(AbstractReporter):
+class AbstractXmlReporter(AbstractReporter):  # type: ignore[abstract]
     """Internal abstract class for reporters that work via XML."""
 
     def __init__(self, reports: Reports, output_dir: str) -> None: