bpo-29941: Add --with-assertions configure flag to enable C assertions.

.github/CONTRIBUTING.rst

@@ -31,6 +31,9 @@ also suggestions on how you can most effectively help the project.
 Please be aware that our workflow does deviate slightly from the typical GitHub
 project. Details on how to properly submit a pull request are covered in
 `Lifecycle of a Pull Request <https://cpython-devguide.readthedocs.io/pullrequest.html>`_.
+One key point is to keep comments on GitHub to only those related to the reviewing
+the code in the pull request. All other discussions -- e.g. about the issue being
+fixed -- should happen on bugs.python.org.
 
 If you are making a code contribution or large documentation contribution,
 please feel free to add yourself to the ``Misc/ACKS`` file alphabetically.

.codecov.yml → .github/codecov.yml

@@ -12,18 +12,12 @@ ignore:
   - "Grammar/*"
 coverage:
   precision: 2
-  range:
-  - 70.0
-  - 100.0
+  range: 70...90
   round: down
   status:
     changes: off
     project: off
-    patch:
-      default:
-        target: 100%
-        only_pulls: true
-        threshold: 0.05
+    patch: off
 parsers:
   gcov:
     branch_detection:

.gitignore

@@ -54,6 +54,8 @@ PCbuild/*.suo
 PCbuild/*.*sdf
 PCbuild/*-pgi
 PCbuild/*-pgo
+PCbuild/*.VC.db
+PCbuild/*.VC.opendb
 PCbuild/.vs/
 PCbuild/amd64/
 PCbuild/obj/

.mention-bot

@@ -7,5 +7,14 @@
     "Doc/whatsnew/*.rst"
   ],
   "userBlacklist": ["gvanrossum", "skrah", "haypo"],
-  "userBlacklistForPR": ["benjaminp", "skrah"]
+  "userBlacklistForPR": ["benjaminp", "skrah", "berkerpeksag"],
+  "alwaysNotifyForPaths": [
+    {"name": "tiran",
+     "files": [
+       "Doc/library/hashlib.rst", "Doc/library/ssl.rst", "Lib/hashlib.py",
+       "Lib/ssl.py", "Lib/test/test_hashlib.py", "Lib/test/test_ssl.py",
+       "Modules/_hashopenssl.c", "Modules/_ssl*", "Modules/hashlib.h",
+       "Python/pyhash.c", "Include/pyhash.h"]
+    }
+  ]
 }

.travis.yml

@@ -32,14 +32,17 @@ matrix:
   include:
     - os: linux
       language: python
+      # Build the docs against a stable version of Python so code bugs don't hold up doc-related PRs.
       python: 3.6
       env:
         - TESTING=docs
       before_script:
         - cd Doc
-        - make venv
+        # Sphinx is pinned so that new versions that introduce new warnings won't suddenly cause build failures.
+        # (Updating the version is fine as long as no warnings are raised by doing so.)
+        - python -m pip install sphinx~=1.6.1
       script:
-        - make check suspicious html PYTHON="./venv/bin/python" SPHINXBUILD="./venv/bin/python -m sphinx" SPHINXOPTS="-q -W"
+        - make check suspicious html SPHINXOPTS="-q -W"
     - os: linux
       language: c
       compiler: gcc

Doc/c-api/bytes.rst

@@ -72,29 +72,29 @@ called with a non-bytes parameter.
    | :attr:`%c`        | int           | A single byte,                 |
    |                   |               | represented as a C int.        |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%d`        | int           | Exactly equivalent to          |
-   |                   |               | ``printf("%d")``.              |
+   | :attr:`%d`        | int           | Equivalent to                  |
+   |                   |               | ``printf("%d")``. [1]_         |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%u`        | unsigned int  | Exactly equivalent to          |
-   |                   |               | ``printf("%u")``.              |
+   | :attr:`%u`        | unsigned int  | Equivalent to                  |
+   |                   |               | ``printf("%u")``. [1]_         |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%ld`       | long          | Exactly equivalent to          |
-   |                   |               | ``printf("%ld")``.             |
+   | :attr:`%ld`       | long          | Equivalent to                  |
+   |                   |               | ``printf("%ld")``. [1]_        |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%lu`       | unsigned long | Exactly equivalent to          |
-   |                   |               | ``printf("%lu")``.             |
+   | :attr:`%lu`       | unsigned long | Equivalent to                  |
+   |                   |               | ``printf("%lu")``. [1]_        |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%zd`       | Py_ssize_t    | Exactly equivalent to          |
-   |                   |               | ``printf("%zd")``.             |
+   | :attr:`%zd`       | Py_ssize_t    | Equivalent to                  |
+   |                   |               | ``printf("%zd")``. [1]_        |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%zu`       | size_t        | Exactly equivalent to          |
-   |                   |               | ``printf("%zu")``.             |
+   | :attr:`%zu`       | size_t        | Equivalent to                  |
+   |                   |               | ``printf("%zu")``. [1]_        |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%i`        | int           | Exactly equivalent to          |
-   |                   |               | ``printf("%i")``.              |
+   | :attr:`%i`        | int           | Equivalent to                  |
+   |                   |               | ``printf("%i")``. [1]_         |
    +-------------------+---------------+--------------------------------+
-   | :attr:`%x`        | int           | Exactly equivalent to          |
-   |                   |               | ``printf("%x")``.              |
+   | :attr:`%x`        | int           | Equivalent to                  |
+   |                   |               | ``printf("%x")``. [1]_         |
    +-------------------+---------------+--------------------------------+
    | :attr:`%s`        | const char\*  | A null-terminated C character  |
    |                   |               | array.                         |
@@ -111,6 +111,9 @@ called with a non-bytes parameter.
    An unrecognized format character causes all the rest of the format string to be
    copied as-is to the result object, and any extra arguments discarded.
 
+   .. [1] For integer specifiers (d, u, ld, lu, zd, zu, i, x): the 0-conversion
+      flag has effect even when a precision is given.
+
 
 .. c:function:: PyObject* PyBytes_FromFormatV(const char *format, va_list vargs)
 

Doc/c-api/exceptions.rst

@@ -291,16 +291,11 @@ an error value).
    is the function calling :c:func:`PyErr_WarnEx`, 2 is  the function above that,
    and so forth.
 
-   Warning categories must be subclasses of :c:data:`Warning`; the default warning
-   category is :c:data:`RuntimeWarning`.  The standard Python warning categories are
-   available as global variables whose names are ``PyExc_`` followed by the Python
-   exception name. These have the type :c:type:`PyObject\*`; they are all class
-   objects. Their names are :c:data:`PyExc_Warning`, :c:data:`PyExc_UserWarning`,
-   :c:data:`PyExc_UnicodeWarning`, :c:data:`PyExc_DeprecationWarning`,
-   :c:data:`PyExc_SyntaxWarning`, :c:data:`PyExc_RuntimeWarning`, and
-   :c:data:`PyExc_FutureWarning`.  :c:data:`PyExc_Warning` is a subclass of
-   :c:data:`PyExc_Exception`; the other warning categories are subclasses of
-   :c:data:`PyExc_Warning`.
+   Warning categories must be subclasses of :c:data:`PyExc_Warning`;
+   :c:data:`PyExc_Warning` is a subclass of :c:data:`PyExc_Exception`;
+   the default warning category is :c:data:`PyExc_RuntimeWarning`. The standard
+   Python warning categories are available as global variables whose names are
+   enumerated at :ref:`standardwarningcategories`.
 
    For information about warning control, see the documentation for the
    :mod:`warnings` module and the :option:`-W` option in the command line
@@ -963,8 +958,10 @@ Notes:
    Only defined on Windows; protect code that uses this by testing that the
    preprocessor macro ``MS_WINDOWS`` is defined.
 
-Standard Warnings
-=================
+.. _standardwarningcategories:
+
+Standard Warning Categories
+===========================
 
 All standard Python warning categories are available as global variables whose
 names are ``PyExc_`` followed by the Python exception name. These have the type
@@ -974,7 +971,7 @@ the variables:
 .. index::
    single: PyExc_Warning
    single: PyExc_BytesWarning
-   single: PyExc_DepricationWarning
+   single: PyExc_DeprecationWarning
    single: PyExc_FutureWarning
    single: PyExc_ImportWarning
    single: PyExc_PendingDeprecationWarning
@@ -997,7 +994,7 @@ the variables:
 +------------------------------------------+---------------------------------+----------+
 | :c:data:`PyExc_ImportWarning`            | :exc:`ImportWarning`            |          |
 +------------------------------------------+---------------------------------+----------+
-| :c:data:`PyExc_PendingDepricationWarning`| :exc:`PendingDeprecationWarning`|          |
+| :c:data:`PyExc_PendingDeprecationWarning`| :exc:`PendingDeprecationWarning`|          |
 +------------------------------------------+---------------------------------+----------+
 | :c:data:`PyExc_ResourceWarning`          | :exc:`ResourceWarning`          |          |
 +------------------------------------------+---------------------------------+----------+

Doc/c-api/long.rst

@@ -85,13 +85,12 @@ All integers are implemented as "long" integer objects of arbitrary size.
    Return a new :c:type:`PyLongObject` based on the string value in *str*, which
    is interpreted according to the radix in *base*.  If *pend* is non-*NULL*,
    *\*pend* will point to the first character in *str* which follows the
-   representation of the number.  If *base* is ``0``, the radix will be
-   determined based on the leading characters of *str*: if *str* starts with
-   ``'0x'`` or ``'0X'``, radix 16 will be used; if *str* starts with ``'0o'`` or
-   ``'0O'``, radix 8 will be used; if *str* starts with ``'0b'`` or ``'0B'``,
-   radix 2 will be used; otherwise radix 10 will be used.  If *base* is not
-   ``0``, it must be between ``2`` and ``36``, inclusive.  Leading spaces are
-   ignored.  If there are no digits, :exc:`ValueError` will be raised.
+   representation of the number.  If *base* is ``0``, *str* is interpreted using
+   the :ref:`integers` definition; in this case, leading zeros in a
+   non-zero decimal number raises a :exc:`ValueError`. If *base* is not ``0``,
+   it must be between ``2`` and ``36``, inclusive.  Leading spaces and single
+   underscores after a base specifier and between digits are ignored.  If there
+   are no digits, :exc:`ValueError` will be raised.
 
 
 .. c:function:: PyObject* PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)

Doc/c-api/slice.rst

@@ -75,7 +75,7 @@ Slice Objects
    Extract the start, stop and step data members from a slice object as
    C integers.  Silently reduce values larger than ``PY_SSIZE_T_MAX`` to
    ``PY_SSIZE_T_MAX``, silently boost the start and stop values less than
-   ``-PY_SSIZE_T_MAX-1`` to ``-PY_SSIZE_T_MAX-1``, and silently boost the step
+   ``PY_SSIZE_T_MIN`` to ``PY_SSIZE_T_MIN``, and silently boost the step
    values less than ``-PY_SSIZE_T_MAX`` to ``-PY_SSIZE_T_MAX``.
 
    Return ``-1`` on error, ``0`` on success.
@@ -93,3 +93,14 @@ Slice Objects
    code.
 
    .. versionadded:: 3.6.1
+
+
+Ellipsis Object
+---------------
+
+
+.. c:var:: PyObject *Py_Ellipsis
+
+   The Python ``Ellipsis`` object.  This object has no methods.  It needs to be
+   treated just like any other object with respect to reference counts.  Like
+   :c:data:`Py_None` it is a singleton object.

Doc/c-api/unicode.rst

@@ -451,44 +451,44 @@ APIs:
    | :attr:`%c`        | int                 | A single character,            |
    |                   |                     | represented as a C int.        |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%d`        | int                 | Exactly equivalent to          |
-   |                   |                     | ``printf("%d")``.              |
+   | :attr:`%d`        | int                 | Equivalent to                  |
+   |                   |                     | ``printf("%d")``. [1]_         |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%u`        | unsigned int        | Exactly equivalent to          |
-   |                   |                     | ``printf("%u")``.              |
+   | :attr:`%u`        | unsigned int        | Equivalent to                  |
+   |                   |                     | ``printf("%u")``. [1]_         |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%ld`       | long                | Exactly equivalent to          |
-   |                   |                     | ``printf("%ld")``.             |
+   | :attr:`%ld`       | long                | Equivalent to                  |
+   |                   |                     | ``printf("%ld")``. [1]_        |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%li`       | long                | Exactly equivalent to          |
-   |                   |                     | ``printf("%li")``.             |
+   | :attr:`%li`       | long                | Equivalent to                  |
+   |                   |                     | ``printf("%li")``. [1]_        |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%lu`       | unsigned long       | Exactly equivalent to          |
-   |                   |                     | ``printf("%lu")``.             |
+   | :attr:`%lu`       | unsigned long       | Equivalent to                  |
+   |                   |                     | ``printf("%lu")``. [1]_        |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%lld`      | long long           | Exactly equivalent to          |
-   |                   |                     | ``printf("%lld")``.            |
+   | :attr:`%lld`      | long long           | Equivalent to                  |
+   |                   |                     | ``printf("%lld")``. [1]_       |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%lli`      | long long           | Exactly equivalent to          |
-   |                   |                     | ``printf("%lli")``.            |
+   | :attr:`%lli`      | long long           | Equivalent to                  |
+   |                   |                     | ``printf("%lli")``. [1]_       |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%llu`      | unsigned long long  | Exactly equivalent to          |
-   |                   |                     | ``printf("%llu")``.            |
+   | :attr:`%llu`      | unsigned long long  | Equivalent to                  |
+   |                   |                     | ``printf("%llu")``. [1]_       |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%zd`       | Py_ssize_t          | Exactly equivalent to          |
-   |                   |                     | ``printf("%zd")``.             |
+   | :attr:`%zd`       | Py_ssize_t          | Equivalent to                  |
+   |                   |                     | ``printf("%zd")``. [1]_        |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%zi`       | Py_ssize_t          | Exactly equivalent to          |
-   |                   |                     | ``printf("%zi")``.             |
+   | :attr:`%zi`       | Py_ssize_t          | Equivalent to                  |
+   |                   |                     | ``printf("%zi")``. [1]_        |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%zu`       | size_t              | Exactly equivalent to          |
-   |                   |                     | ``printf("%zu")``.             |
+   | :attr:`%zu`       | size_t              | Equivalent to                  |
+   |                   |                     | ``printf("%zu")``. [1]_        |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%i`        | int                 | Exactly equivalent to          |
-   |                   |                     | ``printf("%i")``.              |
+   | :attr:`%i`        | int                 | Equivalent to                  |
+   |                   |                     | ``printf("%i")``. [1]_         |
    +-------------------+---------------------+--------------------------------+
-   | :attr:`%x`        | int                 | Exactly equivalent to          |
-   |                   |                     | ``printf("%x")``.              |
+   | :attr:`%x`        | int                 | Equivalent to                  |
+   |                   |                     | ``printf("%x")``. [1]_         |
    +-------------------+---------------------+--------------------------------+
    | :attr:`%s`        | const char\*        | A null-terminated C character  |
    |                   |                     | array.                         |
@@ -530,6 +530,9 @@ APIs:
       characters for ``"%A"``, ``"%U"``, ``"%S"``, ``"%R"`` and ``"%V"``
       (if the ``PyObject*`` argument is not NULL).
 
+   .. [1] For integer specifiers (d, u, ld, li, lu, lld, lli, llu, zd, zi,
+      zu, i, x): the 0-conversion flag has effect even when a precision is given.
+
    .. versionchanged:: 3.2
       Support for ``"%lld"`` and ``"%llu"`` added.