exclude non-builtin C methods from builtins optimisation again

Cython/Compiler/Optimize.py

@@ -2596,16 +2596,6 @@ class OptimizeBuiltinCalls(Visitor.NodeRefCleanupMixin,
             ],
         exception_value="-1")
 
-    def _dispatch_to_method_handler(self, attr_name, self_arg,
-                                    is_unbound_method, type_name,
-                                    node, function, arg_list, kwargs):
-        if hasattr(function, 'type') and function.type.is_cfunction:
-            # Don't "optimize" already bound C calls.
-            return node
-        return super(OptimizeBuiltinCalls, self)._dispatch_to_method_handler(
-            attr_name, self_arg, is_unbound_method, type_name,
-            node, function, arg_list, kwargs)
-
     def _handle_simple_method_object_append(self, node, function, args, is_unbound_method):
         """Optimistic optimisation as X.append() is almost always
         referring to a list.

Cython/Compiler/Visitor.py

@@ -598,7 +598,11 @@ class MethodDispatcherTransform(EnvTransform):
             attr_name = function.attribute
             if function.type.is_pyobject:
                 self_arg = function.obj
-            elif node.self:
+            elif node.self and function.entry:
+                entry = function.entry.as_variable
+                if not entry or not entry.is_builtin:
+                    return node
+                # C implementation of a Python builtin method - see if we find further matches
                 self_arg = node.self
                 arg_list = arg_list[1:]  # drop CloneNode of self argument
             else:

tests/run/append.pyx

@@ -52,6 +52,19 @@ def test_append(L):
     return L
 
 
+def test_append_typed(list L not None):
+    """
+    >>> test_append_typed([])
+    None
+    None
+    [1, 2, (3, 4)]
+    """
+    print L.append(1)
+    L.append(2)
+    print L.append((3,4))
+    return L
+
+
 def append_unused_retval(L):
     """
     >>> append_unused_retval([])