Allow enum type access patterns from Cython as well as Python.

Cython/Compiler/ExprNodes.py

@@ -1859,7 +1859,12 @@ class NameNode(AtomicExprNode):
         entry = self.entry
         if entry.is_type and entry.type.is_extension_type:
             self.type_entry = entry
-        if not (entry.is_const or entry.is_variable
+        if entry.is_type and entry.type.is_enum:
+            py_entry = Symtab.Entry(self.name, None, py_object_type)
+            py_entry.is_pyglobal = True
+            py_entry.scope = self.entry.scope
+            self.entry = py_entry
+        elif not (entry.is_const or entry.is_variable
             or entry.is_builtin or entry.is_cfunction
             or entry.is_cpp_class):
                 if self.entry.as_variable:
@@ -5832,7 +5837,7 @@ class AttributeNode(ExprNode):
         node = self.analyse_as_cimported_attribute_node(env, target=False)
         if node is not None:
             return node.entry.type
-        node = self.analyse_as_unbound_cmethod_node(env)
+        node = self.analyse_as_type_attribute(env)
         if node is not None:
             return node.entry.type
         obj_type = self.obj.infer_type(env)
@@ -5859,7 +5864,7 @@ class AttributeNode(ExprNode):
         self.initialized_check = env.directives['initializedcheck']
         node = self.analyse_as_cimported_attribute_node(env, target)
         if node is None and not target:
-            node = self.analyse_as_unbound_cmethod_node(env)
+            node = self.analyse_as_type_attribute(env)
         if node is None:
             node = self.analyse_as_ordinary_attribute_node(env, target)
             assert node is not None
@@ -5883,7 +5888,7 @@ class AttributeNode(ExprNode):
                 return self.as_name_node(env, entry, target)
         return None
 
-    def analyse_as_unbound_cmethod_node(self, env):
+    def analyse_as_type_attribute(self, env):
         # Try to interpret this as a reference to an unbound
         # C method of an extension type or builtin type.  If successful,
         # creates a corresponding NameNode and returns it, otherwise
@@ -5891,7 +5896,8 @@ class AttributeNode(ExprNode):
         if self.obj.is_string_literal:
             return
         type = self.obj.analyse_as_type(env)
-        if type and (type.is_extension_type or type.is_builtin_type or type.is_cpp_class):
+        if type:
+            if type.is_extension_type or type.is_builtin_type or type.is_cpp_class:
                 entry = type.scope.lookup_here(self.attribute)
                 if entry and (entry.is_cmethod or type.is_cpp_class and entry.type.is_cfunction):
                     if type.is_builtin_type:
@@ -5922,6 +5928,11 @@ class AttributeNode(ExprNode):
                         ubcm_entry.func_cname = entry.func_cname
                         ubcm_entry.is_unbound_cmethod = 1
                     return self.as_name_node(env, ubcm_entry, target=False)
+            elif type.is_enum:
+                if self.attribute in type.values:
+                    return self.as_name_node(env, env.lookup(self.attribute), target=False)
+                else:
+                    error(self.pos, "%s not a known value of %s" % (self.attribute, type))
         return None
 
     def analyse_as_type(self, env):

Cython/Compiler/Nodes.py

@@ -1496,11 +1496,15 @@ class CEnumDefNode(StatNode):
                 self.entry.defined_in_pxd = 1
             for item in self.items:
                 item.analyse_declarations(env, self.entry)
+        if self.name is not None:
+            self.entry.type.values = set(
+                (item.name) for item in self.items)
         if self.create_wrapper and self.name is not None:
             from .UtilityCode import CythonUtilityCode
             env.use_utility_code(CythonUtilityCode.load(
               "EnumType", "CpdefEnums.pyx",
-              context={"name": self.name, "items": tuple(item.name for item in self.items)},
+              context={"name": self.name,
+                       "items": tuple(item.name for item in self.items)},
               outer_module_scope=env.global_scope()))
 
     def analyse_expressions(self, env):

Cython/Compiler/Optimize.py

@@ -2098,7 +2098,7 @@ class OptimizeBuiltinCalls(Visitor.NodeRefCleanupMixin,
                 entry=type_entry,
                 type=type_entry.type),
             attribute=attr_name,
-            is_called=True).analyse_as_unbound_cmethod_node(self.current_env())
+            is_called=True).analyse_as_type_attribute(self.current_env())
         if method is None:
             return node
         args = node.args

tests/run/cpdef_enums.pyx

@@ -58,3 +58,19 @@ cpdef enum PyxEnum:
 
 cdef enum SecretPyxEnum:
     SEVEN = 7
+
+def test_as_variable_from_cython():
+    """
+    >>> test_as_variable_from_cython()
+    """
+    assert list(PyxEnum) == [TWO, THREE, FIVE]
+    assert list(PxdEnum) == [RANK_0, RANK_1, RANK_2]
+
+cdef int verify_pure_c() nogil:
+    cdef int x = TWO
+    cdef int y = PyxEnum.THREE
+    cdef int z = SecretPyxEnum.SEVEN
+    return x + y + z
+
+# Use it to suppress warning.
+verify_pure_c()