[record] defend against problematic collisions

python_modules/dagster/dagster/_record/__init__.py

@@ -1,3 +1,4 @@
+import inspect
 from abc import ABC
 from functools import partial
 from typing import (
@@ -46,7 +47,24 @@ def _namedtuple_model_transform(
         * creates a run time checked __new__  (optional).
     """
     field_set = getattr(cls, "__annotations__", {})
-    defaults = {name: getattr(cls, name) for name in field_set.keys() if hasattr(cls, name)}
+
+    defaults = {}
+    for name in field_set.keys():
+        if hasattr(cls, name):
+            attr_val = getattr(cls, name)
+            check.invariant(
+                not isinstance(attr_val, property),
+                f"Conflicting @property for field {name} on record {cls.__name__}."
+                "If you are trying to declare an abstract property "
+                "you will have to use a class attribute instead.",
+            )
+            check.invariant(
+                not inspect.isfunction(attr_val),
+                f"Conflicting function for field {name} on record {cls.__name__}. "
+                "If you are trying to set a function as a default value "
+                "you will have to override __new__.",
+            )
+            defaults[name] = attr_val
 
     base = NamedTuple(f"_{cls.__name__}", field_set.items())
     nt_new = base.__new__
@@ -83,9 +101,8 @@ def _namedtuple_model_transform(
         check.failed(f"Expected __new__ on {cls}, add it or switch from the _with_new decorator.")
 
     # clear default values
-    for name in field_set.keys():
-        if hasattr(cls, name):
-            delattr(cls, name)
+    for name in defaults.keys():
+        delattr(cls, name)
 
     new_type = type(
         cls.__name__,

python_modules/dagster/dagster_tests/model_tests/test_dagster_model.py

@@ -1,4 +1,5 @@
 import pickle
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
 
 import pytest
@@ -436,3 +437,42 @@ def test_pickle():
 
     a2 = Agent(name="mr. clean")
     assert a2 == pickle.loads(pickle.dumps(a2))
+
+
+def test_default_collision() -> None:
+    class BadBase(ABC):
+        @property
+        @abstractmethod
+        def abstract_prop(self): ...
+
+        def some_method(self): ...
+
+    with pytest.raises(check.CheckError, match="Conflicting @property"):
+
+        @record
+        class _(BadBase):
+            abstract_prop: Any
+
+    with pytest.raises(check.CheckError, match="Conflicting function"):
+
+        @record
+        class _(BadBase):
+            some_method: Any
+
+    class Base(ABC):
+        thing: Any
+
+    @record
+    class Impl(Base):
+        thing: Any
+
+    assert Impl(thing=3).thing == 3
+
+    with pytest.raises(check.CheckError, match="will have to override __new__"):
+
+        def _some_func():
+            return 4
+
+        @record
+        class _(Base):
+            thing: Any = _some_func