#11565: Merge with 3.1.

4 files changed, 5 insertions, 5 deletions

diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index df8d77f..3fa5cc4 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -2080,7 +2080,7 @@ dict_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         assert(d->ma_table == NULL && d->ma_fill == 0 && d->ma_used == 0);
         INIT_NONZERO_DICT_SLOTS(d);
         d->ma_lookup = lookdict_unicode;
-        /* The object has been implicitely tracked by tp_alloc */
+        /* The object has been implicitly tracked by tp_alloc */
         if (type == &PyDict_Type)
             _PyObject_GC_UNTRACK(d);
 #ifdef SHOW_CONVERSION_COUNTS
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 2e0c8aa..18713ab 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -11,7 +11,7 @@
 /* Ensure ob_item has room for at least newsize elements, and set
  * ob_size to newsize.  If newsize > ob_size on entry, the content
  * of the new slots at exit is undefined heap trash; it's the caller's
- * responsiblity to overwrite them with sane values.
+ * responsibility to overwrite them with sane values.
  * The number of allocated elements may grow, shrink, or stay the same.
  * Failure is impossible if newsize <= self.allocated on entry, although
  * that partly relies on an assumption that the system realloc() never
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 7c9506a..552f8f0 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -709,7 +709,7 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
         is_signed = *pendbyte >= 0x80;
 
     /* Compute numsignificantbytes.  This consists of finding the most
-       significant byte.  Leading 0 bytes are insignficant if the number
+       significant byte.  Leading 0 bytes are insignificant if the number
        is positive, and leading 0xff bytes if negative. */
     {
         size_t i;
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 7a1aa77..8eaf51f 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -1008,7 +1008,7 @@ subtype_dealloc(PyObject *self)
           self has a refcount of 0, and if gc ever gets its hands on it
           (which can happen if any weakref callback gets invoked), it
           looks like trash to gc too, and gc also tries to delete self
-          then.  But we're already deleting self.  Double dealloction is
+          then.  But we're already deleting self.  Double deallocation is
           a subtle disaster.
 
        Q. Why the bizarre (net-zero) manipulation of
@@ -5937,7 +5937,7 @@ recurse_down_subclasses(PyTypeObject *type, PyObject *name,
    slots compete for the same descriptor (for example both sq_item and
    mp_subscript generate a __getitem__ descriptor).
 
-   In the latter case, the first slotdef entry encoutered wins.  Since
+   In the latter case, the first slotdef entry encountered wins.  Since
    slotdef entries are sorted by the offset of the slot in the
    PyHeapTypeObject, this gives us some control over disambiguating
    between competing slots: the members of PyHeapTypeObject are listed