================

Cython Changelog

================

0.28.1 (2018-03-18)

===================

Bugs fixed

----------

* ``PyFrozenSet_New()`` was accidentally used in PyPy where it is missing

  from the C-API.

* Assignment between some C++ templated types were incorrectly rejected

  when the templates mix ``const`` with ``ctypedef``.

  (Github issue #2148)

* Undeclared C++ no-args constructors in subclasses could make the compilation

  fail if the base class constructor was declared without ``nogil``.

  (Github issue #2157)

* Bytes %-formatting inferred ``basestring`` (bytes or unicode) as result type

  in some cases where ``bytes`` would have been safe to infer.

  (Github issue #2153)

* ``None`` was accidentally disallowed as typed return value of ``dict.pop()``.

  (Github issue #2152)

0.28 (2018-03-13)

=================

Features added

--------------

* Cdef classes can now multiply inherit from ordinary Python classes.

  (The primary base must still be a c class, possibly ``object``, and

  the other bases must *not* be cdef classes.)

* Type inference is now supported for Pythran compiled NumPy expressions.

  Patch by Nils Braun.  (Github issue #1954)

* The ``const`` modifier can be applied to memoryview declarations to allow

  read-only buffers as input.  (Github issues #1605, #1869)

* C code in the docstring of a ``cdef extern`` block is copied verbatimly

  into the generated file.

  Patch by Jeroen Demeyer.  (Github issue #1915)

* When compiling with gcc, the module init function is now tuned for small

  code size instead of whatever compile flags were provided externally.

  Cython now also disables some code intensive optimisations in that function

  to further reduce the code size.  (Github issue #2102)

* Decorating an async coroutine with ``@cython.iterable_coroutine`` changes its

  type at compile time to make it iterable.  While this is not strictly in line

  with PEP-492, it improves the interoperability with old-style coroutines that

  use ``yield from`` instead of ``await``.

* The IPython magic has preliminary support for JupyterLab.

  (Github issue #1775)

* The new TSS C-API in CPython 3.7 is supported and has been backported.

  Patch by Naotoshi Seo.  (Github issue #1932)

* Cython knows the new ``Py_tss_t`` type defined in PEP-539 and automatically

  initialises variables declared with that type to ``Py_tss_NEEDS_INIT``,

  a value which cannot be used outside of static assignments.

* The set methods ``.remove()`` and ``.discard()`` are optimised.

  Patch by Antoine Pitrou.  (Github issue #2042)

* ``dict.pop()`` is optimised.

  Original patch by Antoine Pitrou.  (Github issue #2047)

* Iteration over sets and frozensets is optimised.

  (Github issue #2048)

* Safe integer loops (< range(2^30)) are automatically optimised into C loops.

* ``alist.extend([a,b,c])`` is optimised into sequential ``list.append()`` calls

  for short literal sequences.

* Calls to builtin methods that are not specifically optimised into C-API calls

  now use a cache that avoids repeated lookups of the underlying C function.

  (Github issue #2054)

* Single argument function calls can avoid the argument tuple creation in some cases.

* Some redundant extension type checks are avoided.

* Formatting C enum values in f-strings is faster, as well as some other special cases.

* String formatting with the '%' operator is optimised into f-strings in simple cases.

* Subscripting (item access) is faster in some cases.

* Some ``bytearray`` operations have been optimised similar to ``bytes``.

* Some PEP-484/526 container type declarations are now considered for

  loop optimisations.

* Indexing into memoryview slices with ``view[i][j]`` is now optimised into

  ``view[i, j]``.

* Python compatible ``cython.*`` types can now be mixed with type declarations

  in Cython syntax.

* Name lookups in the module and in classes are faster.

* Python attribute lookups on extension types without instance dict are faster.

* Some missing signals were added to ``libc/signal.pxd``.

  Patch by Jeroen Demeyer.  (Github issue #1914)

* The warning about repeated extern declarations is now visible by default.

  (Github issue #1874)

* The exception handling of the function types used by CPython's type slot

  functions was corrected to match the de-facto standard behaviour, so that

  code that uses them directly benefits from automatic and correct exception

  propagation.  Patch by Jeroen Demeyer.  (Github issue #1980)

* Defining the macro ``CYTHON_NO_PYINIT_EXPORT`` will prevent the module init

  function from being exported as symbol, e.g. when linking modules statically

  in an embedding setup.  Patch by AraHaan.  (Github issue #1944)

Bugs fixed

----------

* If a module name is explicitly provided for an ``Extension()`` that is compiled

  via ``cythonize()``, it was previously ignored and replaced by the source file

  name.  It can now be used to override the target module name, e.g. for compiling

  prefixed accelerator modules from Python files.  (Github issue #2038)

* The arguments of the ``num_threads`` parameter of parallel sections

  were not sufficiently validated and could lead to invalid C code.

  (Github issue #1957)

* Catching exceptions with a non-trivial exception pattern could call into

  CPython with a live exception set.  This triggered incorrect behaviour

  and crashes, especially in CPython 3.7.

* The signature of the special ``__richcmp__()`` method was corrected to recognise

  the type of the first argument as ``self``.  It was previously treated as plain

  object, but CPython actually guarantees that it always has the correct type.

  Note: this can change the semantics of user code that previously relied on

  ``self`` being untyped.

* Some Python 3 exceptions were not recognised as builtins when running Cython

  under Python 2.

* Some async helper functions were not defined in the generated C code when

  compiling simple async code.  (Github issue #2075)

* Line tracing did not include generators and coroutines.

  (Github issue #1949)

* C++ declarations for ``unordered_map`` were corrected.

  Patch by Michael Schatzow.  (Github issue #1484)

* Iterator declarations in C++ ``deque`` and ``vector`` were corrected.

  Patch by Alex Huszagh.  (Github issue #1870)

* The const modifiers in the C++ ``string`` declarations were corrected, together

  with the coercion behaviour of string literals into C++ strings.

  (Github issue #2132)

* Some declaration types in ``libc.limits`` were corrected.

  Patch by Jeroen Demeyer.  (Github issue #2016)

* ``@cython.final`` was not accepted on Python classes with an ``@cython.cclass``

  decorator.  (Github issue #2040)

* Cython no longer creates useless and incorrect ``PyInstanceMethod`` wrappers for

  methods in Python 3.  Patch by Jeroen Demeyer.  (Github issue #2105)

* The builtin ``bytearray`` type could not be used as base type of cdef classes.

  (Github issue #2106)

Other changes

-------------

0.27.3 (2017-11-03)

===================

Bugs fixed

----------

* String forward references to extension types like ``@cython.locals(x="ExtType")``

  failed to find the named type.  (Github issue #1962)

* NumPy slicing generated incorrect results when compiled with Pythran.

  Original patch by Serge Guelton (Github issue #1946).

* Fix "undefined reference" linker error for generators on Windows in Py3.3-3.5.

  (Github issue #1968)

* Adapt to recent C-API change of ``PyThreadState`` in CPython 3.7.

* Fix signature of ``PyWeakref_GetObject()`` API declaration.

  Patch by Jeroen Demeyer (Github issue #1975).

0.27.2 (2017-10-22)

===================

Bugs fixed

----------

* Comprehensions could incorrectly be optimised away when they appeared in boolean

  test contexts.  (Github issue #1920)

* The special methods ``__eq__``, ``__lt__`` etc. in extension types did not type

  their first argument as the type of the class but ``object``.  (Github issue #1935)

* Crash on first lookup of "cline_in_traceback" option during exception handling.

  (Github issue #1907)

* Some nested module level comprehensions failed to compile.

  (Github issue #1906)

* Compiler crash on some complex type declarations in pure mode.

  (Github issue #1908)

* ``std::unordered_map.erase()`` was declared with an incorrect ``void`` return

  type in ``libcpp.unordered_map``.  (Github issue #1484)

* Invalid use of C++ ``fallthrough`` attribute before C++11 and similar issue in clang.

  (Github issue #1930)

* Compiler crash on misnamed properties. (Github issue #1905)

0.27.1 (2017-10-01)

===================

Features added

--------------

* The Jupyter magic has a new debug option ``--verbose`` that shows details about

  the distutils invocation.  Patch by Boris Filippov (Github issue #1881).

Bugs fixed

----------

* Py3 list comprehensions in class bodies resulted in invalid C code.

  (Github issue #1889)

* Modules built for later CPython 3.5.x versions failed to import in 3.5.0/3.5.1.

  (Github issue #1880)

* Deallocating fused types functions and methods kept their GC tracking enabled,

  which could potentially lead to recursive deallocation attempts.

* Crash when compiling in C++ mode with old setuptools versions.

  (Github issue #1879)

* C++ object arguments for the constructor of Cython implemented C++ are now

  passed by reference and not by value to allow for non-copyable arguments, such

  as ``unique_ptr``.

* API-exported C++ classes with Python object members failed to compile.

  (Github issue #1866)

* Some issues with the new relaxed exception value handling were resolved.

* Python classes as annotation types could prevent compilation.

  (Github issue #1887)

* Cython annotation types in Python files could lead to import failures

  with a "cython undefined" error.  Recognised types are now turned into strings.

* Coverage analysis could fail to report on extension modules on some platforms.

* Annotations could be parsed (and rejected) as types even with

  ``annotation_typing=False``.

Other changes

-------------

* PEP 489 support has been disabled by default to counter incompatibilities with

  import setups that try to reload or reinitialise modules.

0.27 (2017-09-23)

=================

Features added

--------------

* Extension module initialisation follows

  `PEP 489 <https://www.python.org/dev/peps/pep-0489/>`_ in CPython 3.5+, which

  resolves several differences with regard to normal Python modules.  This makes

  the global names ``__file__`` and ``__path__`` correctly available to module

  level code and improves the support for module-level relative imports.

  (Github issues #1715, #1753, #1035)

* Asynchronous generators (`PEP 525 <https://www.python.org/dev/peps/pep-0525/>`_)

  and asynchronous comprehensions (`PEP 530 <https://www.python.org/dev/peps/pep-0530/>`_)

  have been implemented.  Note that async generators require finalisation support

  in order to allow for asynchronous operations during cleanup, which is only

  available in CPython 3.6+.  All other functionality has been backported as usual.

* Variable annotations are now parsed according to

  `PEP 526 <https://www.python.org/dev/peps/pep-0526/>`_.  Cython types (e.g.

  ``cython.int``) are evaluated as C type declarations and everything else as Python

  types.  This can be disabled with the directive ``annotation_typing=False``.

  Note that most complex PEP-484 style annotations are currently ignored.  This will

  change in future releases. (Github issue #1850)

* Extension types (also in pure Python mode) can implement the normal special methods

  ``__eq__``, ``__lt__`` etc. for comparisons instead of the low-level ``__richcmp__``

  method.  (Github issue #690)

* New decorator ``@cython.exceptval(x=None, check=False)`` that makes the signature

  declarations ``except x``, ``except? x`` and ``except *`` available to pure Python

  code.  Original patch by Antonio Cuni.  (Github issue #1653)

* Signature annotations are now included in the signature docstring generated by

  the ``embedsignature`` directive.  Patch by Lisandro Dalcin (Github issue #1781).

* The gdb support for Python code (``libpython.py``) was updated to the latest

  version in CPython 3.7 (git rev 5fe59f8).

* The compiler tries to find a usable exception return value for cdef functions

  with ``except *`` if the returned type allows it.  Note that this feature is subject

  to safety limitations, so it is still better to provide an explicit declaration.

* C functions can be assigned to function pointers with a compatible exception

  declaration, not only with exact matches.  A side-effect is that certain compatible

  signature overrides are now allowed and some more mismatches of exception signatures

  are now detected and rejected as errors that were not detected before.

* The IPython/Jupyter magic integration has a new option ``%%cython --pgo`` for profile

  guided optimisation. It compiles the cell with PGO settings for the C compiler,

  executes it to generate a runtime profile, and then compiles it again using that

  profile for C compiler optimisation.  Currently only tested with gcc.

* ``len(memoryview)`` can be used in nogil sections to get the size of the

  first dimension of a memory view (``shape[0]``). (Github issue #1733)

* C++ classes can now contain (properly refcounted) Python objects.

* NumPy dtype subarrays are now accessible through the C-API.

  Patch by Gerald Dalley (Github issue #245).

* Resolves several issues with PyPy and uses faster async slots in PyPy3.

  Patch by Ronan Lamy (Github issues #1871, #1878).

Bugs fixed

----------

* Extension types that were cimported from other Cython modules could disagree

  about the order of fused cdef methods in their call table.  This could lead

  to wrong methods being called and potentially also crashes.  The fix required

  changes to the ordering of fused methods in the call table, which may break

  existing compiled modules that call fused cdef methods across module boundaries,

  if these methods were implemented in a different order than they were declared

  in the corresponding .pxd file. (Github issue #1873)

* The exception state handling in generators and coroutines could lead to

  exceptions in the caller being lost if an exception was raised and handled

  inside of the coroutine when yielding. (Github issue #1731)

* Loops over ``range(enum)`` were not converted into C for-loops.  Note that it

  is still recommended to use an explicit cast to a C integer type in this case.

* Error positions of names (e.g. variables) were incorrectly reported after the

  name and not at the beginning of the name.

* Compile time ``DEF`` assignments were evaluated even when they occur inside of

  falsy ``IF`` blocks. (Github issue #1796)

* Disabling the line tracing from a trace function could fail.

  Original patch by Dmitry Trofimov. (Github issue #1769)

* Several issues with the Pythran integration were resolved.

* abs(signed int) now returns a signed rather than unsigned int.

  (Github issue #1837)

* Reading ``frame.f_locals`` of a Cython function (e.g. from a debugger or profiler

  could modify the module globals. (Github issue #1836)

* Buffer type mismatches in the NumPy buffer support could leak a reference to the

  buffer owner.

* Using the "is_f_contig" and "is_c_contig" memoryview methods together could leave

  one of them undeclared. (Github issue #1872)

* Compilation failed if the for-in-range loop target was not a variable but a more

  complex expression, e.g. an item assignment. (Github issue #1831)

* Compile time evaluations of (partially) constant f-strings could show incorrect

  results.

* Escape sequences in raw f-strings (``fr'...'``) were resolved instead of passing

  them through as expected.

* Some ref-counting issues in buffer error handling have been resolved.

Other changes

-------------

* Type declarations in signature annotations are now parsed according to

  `PEP 484 <https://www.python.org/dev/peps/pep-0484/>`_

  typing.  Only Cython types (e.g. ``cython.int``) and Python builtin types are

  currently considered as type declarations.  Everything else is ignored, but this

  will change in a future Cython release.

  (Github issue #1672)

* The directive ``annotation_typing`` is now ``True`` by default, which enables

  parsing type declarations from annotations.

* This release no longer supports Python 3.2.

0.26.1 (2017-08-29)

===================

Features added

--------------

Bugs fixed

----------

* ``cython.view.array`` was missing ``.__len__()``.

* Extension types with a ``.pxd`` override for their ``__releasebuffer__`` slot

  (e.g. as provided by Cython for the Python ``array.array`` type) could leak

  a reference to the buffer owner on release, thus not freeing the memory.

  (Github issue #1638)

* Auto-decoding failed in 0.26 for strings inside of C++ containers.

  (Github issue #1790)

* Compile error when inheriting from C++ container types.

  (Github issue #1788)

* Invalid C code in generators (declaration after code).

  (Github issue #1801)

* Arithmetic operations on ``const`` integer variables could generate invalid code.

  (Github issue #1798)

* Local variables with names of special Python methods failed to compile inside of

  closures. (Github issue #1797)

* Problem with indirect Emacs buffers in cython-mode.

  Patch by Martin Albrecht (Github issue #1743).

* Extension types named ``result`` or ``PickleError`` generated invalid unpickling code.

  Patch by Jason Madden (Github issue #1786).

* Bazel integration failed to compile ``.py`` files.

  Patch by Guro Bokum (Github issue #1784).

* Some include directories and dependencies were referenced with their absolute paths

  in the generated files despite lying within the project directory.

* Failure to compile in Py3.7 due to a modified signature of ``_PyCFunctionFast()``

0.26 (2017-07-19)

=================

Features added

--------------

* Pythran can be used as a backend for evaluating NumPy array expressions.

  Patch by Adrien Guinet (Github issue #1607).

* cdef classes now support pickling by default when possible.

  This can be disabled with the ``auto_pickle`` directive.

* Speed up comparisons of strings if their hash value is available.

  Patch by Claudio Freire (Github issue #1571).

* Support pyximport from zip files.

  Patch by Sergei Lebedev (Github issue #1485).

* IPython magic now respects the ``__all__`` variable and ignores

  names with leading-underscore (like ``import *`` does).

  Patch by Syrtis Major (Github issue #1625).

* ``abs()`` is optimised for C complex numbers.

  Patch by da-woods (Github issue #1648).

* The display of C lines in Cython tracebacks can now be enabled at runtime

  via ``import cython_runtime; cython_runtime.cline_in_traceback=True``.

  The default has been changed to False.

* The overhead of calling fused types generic functions was reduced.

* "cdef extern" include files are now also searched relative to the current file.

  Patch by Jeroen Demeyer (Github issue #1654).

* Optional optimization for re-aquiring the GIL, controlled by the

  `fast_gil` directive.

Bugs fixed

----------

* Item lookup/assignment with a unicode character as index that is typed

  (explicitly or implicitly) as ``Py_UCS4`` or ``Py_UNICODE`` used the

  integer value instead of the Unicode string value. Code that relied on

  the previous behaviour now triggers a warning that can be disabled by

  applying an explicit cast. (Github issue #1602)

* f-string processing was adapted to changes in PEP 498 and CPython 3.6.

* Invalid C code when decoding from UTF-16(LE/BE) byte strings.

  (Github issue #1696)

* Unicode escapes in 'ur' raw-unicode strings were not resolved in Py2 code.

  Original patch by Aaron Gallagher (Github issue #1594).

* File paths of code objects are now relative.

  Original patch by Jelmer Vernooij (Github issue #1565).

* Decorators of cdef class methods could be executed twice.

  Patch by Jeroen Demeyer (Github issue #1724).

* Dict iteration using the Py2 ``iter*`` methods failed in PyPy3.

  Patch by Armin Rigo (Github issue #1631).

* Several warnings in the generated code are now suppressed.

Other changes

-------------

* The ``unraisable_tracebacks`` option now defaults to ``True``.

* Coercion of C++ containers to Python is no longer automatic on attribute

  access (Github issue #1521).

* Access to Python attributes of cimported modules without the corresponding

  import is now a compile-time (rather than runtime) error.

* Do not use special dll linkage for "cdef public" functions.

  Patch by Jeroen Demeyer (Github issue #1687).

* cdef/cpdef methods must match their declarations.  See Github Issue #1732.

  This is now a warning and will be an error in future releases.

0.25.2 (2016-12-08)

===================

Bugs fixed

----------

* Fixes several issues with C++ template deduction.

* Fixes a issue with bound method type inference (Github issue #551).

* Fixes a bug with cascaded tuple assignment (Github issue #1523).

* Fixed or silenced many Clang warnings.

* Fixes bug with powers of pure real complex numbers (Github issue #1538).

0.25.1 (2016-10-26)

===================

Bugs fixed

----------

* Fixes a bug with ``isinstance(o, Exception)`` (Github issue #1496).

* Fixes bug with ``cython.view.array`` missing utility code in some cases

  (Github issue #1502).

Other changes

-------------

* The distutils extension ``Cython.Distutils.build_ext`` has been reverted,

  temporarily, to be ``old_build_ext`` to give projects time to migrate.

  The new build_ext is available as ``new_build_ext``.

0.25 (2016-10-25)

=================

Features added

--------------

* def/cpdef methods of cdef classes benefit from Cython's internal function

  implementation, which enables introspection and line profiling for them.

  Implementation sponsored by Turbostream (www.turbostream-cfd.com).

* Calls to Python functions are faster, following the recent "FastCall"

  optimisations that Victor Stinner implemented for CPython 3.6.

  See https://bugs.python.org/issue27128 and related issues.

* The new METH_FASTCALL calling convention for PyCFunctions is supported

  in CPython 3.6.  See https://bugs.python.org/issue27810

* Initial support for using Cython modules in Pyston.

  Patch by Boxiang Sun.

* Dynamic Python attributes are allowed on cdef classes if an attribute

  ``cdef dict __dict__`` is declared in the class.  Patch by empyrical.

* Cython implemented C++ classes can make direct calls to base class methods.

  Patch by empyrical.

* C++ classes can now have typedef members. STL containers updated with

  value_type.

* New directive ``cython.no_gc`` to fully disable GC for a cdef class.

  Patch by Claudio Freire.

* Buffer variables are no longer excluded from ``locals()``.

  Patch by da-woods.

* Building f-strings is faster, especially when formatting C integers.

* for-loop iteration over "std::string".

* ``libc/math.pxd`` provides ``e`` and ``pi`` as alias constants to simplify

  usage as a drop-in replacement for Python's math module.

* Speed up cython.inline().

* Binary lshift operations with small constant Python integers are faster.

* Some integer operations on Python long objects are faster in Python 2.7.

* Support for the C++ ``typeid`` operator.

* Support for bazel using a the pyx_library rule in //Tools:rules.bzl.

Significant Bugs fixed

----------------------

* Division of complex numbers avoids overflow by using Smith's method.

* Some function signatures in ``libc.math`` and ``numpy.pxd`` were incorrect.

  Patch by Michael Seifert.

Other changes

-------------

* The "%%cython" IPython/jupyter magic now defaults to the language level of

  the current jupyter kernel.  The language level can be set explicitly with

  "%%cython -2" or "%%cython -3".

* The distutils extension ``Cython.Distutils.build_ext`` has now been updated

  to use cythonize which properly handles dependencies.  The old extension can

  still be found in ``Cython.Distutils.old_build_ext`` and is now deprecated.

* ``directive_defaults`` is no longer available in ``Cython.Compiler.Options``,

  use ``get_directive_defaults()`` instead.

0.24.1 (2016-07-15)

===================

Bugs fixed

----------

* IPython cell magic was lacking a good way to enable Python 3 code semantics.

  It can now be used as "%%cython -3".

* Follow a recent change in `PEP 492 <https://www.python.org/dev/peps/pep-0492/>`_

  and CPython 3.5.2 that now requires the ``__aiter__()`` method of asynchronous

  iterators to be a simple ``def`` method instead of an ``async def`` method.

* Coroutines and generators were lacking the ``__module__`` special attribute.

* C++ ``std::complex`` values failed to auto-convert from and to Python complex

  objects.

* Namespaced C++ types could not be used as memory view types due to lack of

  name mangling.  Patch by Ivan Smirnov.

* Assignments between identical C++ types that were declared with differently

  typedefed template types could fail.

* Rebuilds could fail to evaluate dependency timestamps in C++ mode.

  Patch by Ian Henriksen.

* Macros defined in the ``distutils`` compiler option do not require values

  anymore.  Patch by Ian Henriksen.

* Minor fixes for MSVC, Cygwin and PyPy.

0.24 (2016-04-04)

=================

Features added

--------------

* `PEP 498 <https://www.python.org/dev/peps/pep-0498/>`_:

  Literal String Formatting (f-strings).

  Original patch by Jelle Zijlstra.

* `PEP 515 <https://www.python.org/dev/peps/pep-0515/>`_:

  Underscores as visual separators in number literals.

* Parser was adapted to some minor syntax changes in Py3.6, e.g.

  https://bugs.python.org/issue9232

* The embedded C code comments that show the original source code

  can be discarded with the new directive ``emit_code_comments=False``.

* Cpdef enums are now first-class iterable, callable types in Python.

* Ctuples can now be declared in pure Python code.

* Posix declarations for DLL loading and stdio extensions were added.

  Patch by Lars Buitinck.

* The Py2-only builtins ``unicode()``, ``xrange()``, ``reduce()`` and

  ``long`` are now also available in compile time ``DEF`` expressions

  when compiling with Py3.

* Exception type tests have slightly lower overhead.

  This fixes ticket 868.

* @property syntax fully supported in cdef classes, old syntax deprecated.

* C++ classes can now be declared with default template parameters.

Bugs fixed

----------

* C++ exceptions raised by overloaded C++ operators were not always

  handled.  Patch by Ian Henriksen.

* C string literals were previously always stored as non-const global

  variables in the module.  They are now stored as global constants

  when possible, and otherwise as non-const C string literals in the

  generated code that uses them.  This improves compatibility with

  strict C compiler options and prevents non-const strings literals

  with the same content from being incorrectly merged.

* Compile time evaluated ``str`` expressions (``DEF``) now behave in a

  more useful way by turning into Unicode strings when compiling under

  Python 3.  This allows using them as intermediate values in expressions.

  Previously, they always evaluated to bytes objects.

* ``isinf()`` declarations in ``libc/math.pxd`` and ``numpy/math.pxd`` now

  reflect the actual tristate ``int`` return value instead of using ``bint``.

* Literal assignments to ctuples avoid Python tuple round-trips in some

  more corner cases.

* Iteration over ``dict(...).items()`` failed to get optimised when dict

  arguments included keyword arguments.

* cProfile now correctly profiles cpdef functions and methods.

0.23.5 (2016-03-26)

===================

* Compile errors and warnings in integer type conversion code.  This fixes

  ticket 877.  Patches by Christian Neukirchen, Nikolaus Rath, Ian Henriksen.

* Reference leak when "*args" argument was reassigned in closures.

* Truth-testing Unicode strings could waste time and memory in Py3.3+.

* Return values of async functions could be ignored and replaced by ``None``.

* Compiler crash in CPython 3.6.

* Fix prange() to behave identically to range().  The end condition was

  miscalculated when the range was not exactly divisible by the step.

* Optimised ``all(genexpr)``/``any(genexpr)`` calls could warn about unused

  code.  This fixes ticket 876.

0.23.4 (2015-10-10)

===================

Bugs fixed

----------

* Memory leak when calling Python functions in PyPy.

* Compilation problem with MSVC in C99-ish mode.

* Warning about unused values in a helper macro.

0.23.3 (2015-09-29)

===================

Bugs fixed

----------

* Invalid C code for some builtin methods.  This fixes ticket 856 again.

* Incorrect C code in helper functions for PyLong conversion and string

  decoding.  This fixes ticket 863, ticket 864 and ticket 865.

  Original patch by Nikolaus Rath.

* Large folded or inserted integer constants could use too small C

  integer types and thus trigger a value wrap-around.

Other changes

-------------

* The coroutine and generator types of Cython now also register directly

  with the ``Coroutine`` and ``Generator`` ABCs in the ``backports_abc``

  module if it can be imported.  This fixes ticket 870.

0.23.2 (2015-09-11)

===================

Bugs fixed

----------

* Compiler crash when analysing some optimised expressions.

* Coverage plugin was adapted to coverage.py 4.0 beta 2.

* C++ destructor calls could fail when '&' operator is overwritten.

* Incorrect C literal generation for large integers in compile-time

  evaluated DEF expressions and constant folded expressions.

* Byte string constants could end up as Unicode strings when originating

  from compile-time evaluated DEF expressions.

* Invalid C code when caching known builtin methods.

  This fixes ticket 860.

* ``ino_t`` in ``posix.types`` was not declared as ``unsigned``.

* Declarations in ``libcpp/memory.pxd`` were missing ``operator!()``.

  Patch by Leo Razoumov.

* Static cdef methods can now be declared in .pxd files.

0.23.1 (2015-08-22)

===================

Bugs fixed

----------

* Invalid C code for generators.  This fixes ticket 858.

* Invalid C code for some builtin methods.  This fixes ticket 856.

* Invalid C code for unused local buffer variables.

  This fixes ticket 154.

* Test failures on 32bit systems.  This fixes ticket 857.

* Code that uses ``from xyz import *`` and global C struct/union/array

  variables could fail to compile due to missing helper functions.

  This fixes ticket 851.

* Misnamed PEP 492 coroutine property ``cr_yieldfrom`` renamed to

  ``cr_await`` to match CPython.

* Missing deallocation code for C++ object attributes in certain

  extension class hierarchies.

* Crash when async coroutine was not awaited.

* Compiler crash on ``yield`` in signature annotations and default

  argument values.  Both are forbidden now.

* Compiler crash on certain constructs in ``finally`` clauses.

* Cython failed to build when CPython's pgen is installed.