[python] Make the collections import future-proof

[jstasiak]

Summary

On Python 3.7 the old code raises a warning:

DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working
    class ArgumentsIterator(collections.Sequence):

On Python 3.8 it wouldn't work anymore.

[serge-sans-paille]

LGTM

[jstasiak]

Thanks. If you could commit this on my behalf I'd appreciate it (I don't have commit access).

bindings/python/clang/cindex.py

 # o expose code completion APIs.
 #
 # o cleanup ctypes wrapping, would be nice to separate the ctypes details more
 #   clearly, and hide from the external interface (i.e., help(cindex)).
 #
 # o implement additional SourceLocation, SourceRange, and File methods.
 
 from ctypes import *
-import collections
 
 import clang.enumerations
 
 import os
 import sys
 if sys.version_info[0] == 3:
     # Python 3 strings are unicode, translate them to/from utf8 for C-interop.
     class c_interop_string(c_char_p):
elif sys.version_info[0] == 2:
     def _to_python_string(x, *args):
         return x
 
     c_interop_string.to_python_string = staticmethod(_to_python_string)
 
     def b(x):
         return x
 
+# Importing ABC-s directly from collections is deprecated since Python 3.7,
+# will stop working in Python 3.8.
+# See: https://docs.python.org/dev/whatsnew/3.7.html#id3
+if sys.version_info[:2] >= (3, 7):
+    from collections import abc as collections_abc
+else:
+    import collections as collections_abc
+
 # We only support PathLike objects on Python version with os.fspath present
 # to be consistent with the Python standard library. On older Python versions
 # we only support strings and we have dummy fspath to just pass them through.
 try:
     fspath = os.fspath
 except AttributeError:
     def fspath(x):
         return x
def kind(self):
         return TypeKind.from_id(self._kind_id)
 
     def argument_types(self):
         """Retrieve a container for the non-variadic arguments for this type.
 
         The returned object is iterable and indexable. Each item in the
         container is a Type instance.
         """
-        class ArgumentsIterator(collections.Sequence):
+        class ArgumentsIterator(collections_abc.Sequence):
             def __init__(self, parent):
                 self.parent = parent
                 self.length = None
 
             def __len__(self):
                 if self.length is None:
                     self.length = conf.lib.clang_getNumArgTypes(self.parent)