diff -r 1cfe82916d98 Lib/enum.py
--- a/Lib/enum.py	Mon Sep 09 21:12:21 2013 +0900
+++ b/Lib/enum.py	Mon Sep 09 11:55:31 2013 -0700
@@ -22,20 +22,28 @@ class _RouteClassAttributeToGetattr:
             raise AttributeError()
         return self.fget(instance)
 
     def __set__(self, instance, value):
         raise AttributeError("can't set attribute")
 
     def __delete__(self, instance):
         raise AttributeError("can't delete attribute")
 
 
+def _is_descriptor(obj):
+    """Returns True if obj is a descriptor, False otherwise."""
+    return (
+            hasattr(obj, '__get__') or 
+            hasattr(obj, '__set__') or 
+            hasattr(obj, '__delete__'))
+
+
 def _is_dunder(name):
     """Returns True if a __dunder__ name, False otherwise."""
     return (name[:2] == name[-2:] == '__' and
             name[2:3] != '_' and
             name[-3:-2] != '_')
 
 
 def _is_sunder(name):
     """Returns True if a _sunder_ name, False otherwise."""
     return (name[0] == name[-1] == '_' and
@@ -69,29 +77,29 @@ class _EnumDict(dict):
         sequence of values).
 
         If an enum member name is used twice, an error is raised; duplicate
         values are not checked for.
 
         Single underscore (sunder) names are reserved.
 
         """
         if _is_sunder(key):
             raise ValueError('_names_ are reserved for future Enum use')
-        elif _is_dunder(key) or hasattr(value, '__get__'):
-            if key in self._member_names:
-                # overwriting an enum with a method?  then remove the name from
-                # _member_names or it will become an enum anyway when the class
-                # is created
-                self._member_names.remove(key)
-        else:
-            if key in self._member_names:
-                raise TypeError('Attempted to reuse key: %r' % key)
+        elif _is_dunder(key):
+            pass
+        elif key in self._member_names:
+            # descriptor overwriting an enum?
+            raise TypeError('Attempted to reuse key: %r' % key)
+        elif not _is_descriptor(value):
+            if key in self:
+                # enum overwriting a descriptor?
+                raise TypeError('Key already defined as: %r' % self[key])
             self._member_names.append(key)
         super().__setitem__(key, value)
 
 
 # Dummy value for Enum as EnumMeta explicitly checks for it, but of course
 # until EnumMeta finishes running the first time the Enum class doesn't exist.
 # This is also why there are checks in EnumMeta like `if Enum is not None`
 Enum = None
 
 
diff -r 1cfe82916d98 Lib/test/test_enum.py
--- a/Lib/test/test_enum.py	Mon Sep 09 21:12:21 2013 +0900
+++ b/Lib/test/test_enum.py	Mon Sep 09 11:55:31 2013 -0700
@@ -221,20 +221,46 @@ class TestEnum(unittest.TestCase):
         self.assertEqual(Season.FALL.value, 3)
         self.assertEqual(Season.AUTUMN.value, 3)
         self.assertIs(Season(3), Season.AUTUMN)
         self.assertIs(Season(1), Season.SPRING)
         self.assertEqual(Season.FALL.name, 'AUTUMN')
         self.assertEqual(
                 [k for k,v in Season.__members__.items() if v.name != k],
                 ['FALL', 'ANOTHER_SPRING'],
                 )
 
+    def test_duplicate_name(self):
+        with self.assertRaises(TypeError):
+            class Color(Enum):
+                red = 1
+                green = 2
+                blue = 3
+                red = 4
+
+        with self.assertRaises(TypeError):
+            class Color(Enum):
+                red = 1
+                green = 2
+                blue = 3
+                def red(self):
+                    return 'red'
+
+        with self.assertRaises(TypeError):
+            class Color(Enum):
+                @property
+                def red(self):
+                    return 'redder'
+                red = 1
+                green = 2
+                blue = 3
+
+
     def test_enum_with_value_name(self):
         class Huh(Enum):
             name = 1
             value = 2
         self.assertEqual(
             list(Huh),
             [Huh.name, Huh.value],
             )
         self.assertIs(type(Huh.name), Huh)
         self.assertEqual(Huh.name.name, 'name')
@@ -604,31 +630,20 @@ class TestEnum(unittest.TestCase):
 
     def test_exclude_methods(self):
         class whatever(Enum):
             this = 'that'
             these = 'those'
             def really(self):
                 return 'no, not %s' % self.value
         self.assertIsNot(type(whatever.really), whatever)
         self.assertEqual(whatever.this.really(), 'no, not that')
 
-    def test_overwrite_enums(self):
-        class Why(Enum):
-            question = 1
-            answer = 2
-            propisition = 3
-            def question(self):
-                print(42)
-        self.assertIsNot(type(Why.question), Why)
-        self.assertNotIn(Why.question, Why._member_names_)
-        self.assertNotIn(Why.question, Why)
-
     def test_wrong_inheritance_order(self):
         with self.assertRaises(TypeError):
             class Wrong(Enum, str):
                 NotHere = 'error before this point'
 
     def test_intenum_transitivity(self):
         class number(IntEnum):
             one = 1
             two = 2
             three = 3