diff --git a/__init__.py b/__init__.py
index 4462ad1..6bbb9c2 100644
--- a/__init__.py
+++ b/__init__.py
@@ -6,5 +6,5 @@ from . import party
 def register():
     Pool.register(
         party.Address,
-        party.CountryZip,
+        party.PostalCode,
         module='party_zip', type_='model')
diff --git a/party.py b/party.py
index 7cdae96..3dc193e 100644
--- a/party.py
+++ b/party.py
@@ -4,12 +4,10 @@ from trytond.model import fields
 from trytond.pool import PoolMeta, Pool
 from trytond.pyson import Eval, If, Bool
 
-__all__ = ['Address', 'CountryZip']
-
 
 class Address(metaclass=PoolMeta):
     __name__ = 'party.address'
-    country_zip = fields.Many2One('country.zip', 'Location',
+    location = fields.Many2One('country.postal_code', 'Location',
         ondelete='RESTRICT', domain=[
             If(Bool(Eval('country')), ('country', '=', Eval('country', -1)),
                 ()),
@@ -20,66 +18,72 @@ class Address(metaclass=PoolMeta):
     @classmethod
     def __setup__(cls):
         super(Address, cls).__setup__()
-        cls.zip.readonly = True
+        cls.postal_code.readonly = True
         cls.city.readonly = True
-        cls.country.states['readonly'] |= Bool(Eval('country_zip'))
-        cls.subdivision.states['readonly'] |= Bool(Eval('country_zip'))
+        cls.country.states['readonly'] |= Bool(Eval('location'))
+        cls.subdivision.states['readonly'] |= Bool(Eval('location'))
+
+    @classmethod
+    def __register__(cls, module):
+        # Migration from 5.8: rename country_zip to location
+        table_h = cls.__table_handler__(module)
+        table_h.column_rename('country_zip', 'location')
+        super().__register__(module)
 
     @staticmethod
-    def update_zip_values(CountryZip, values):
+    def update_location_values(values):
+        pool = Pool()
+        PostalCode = pool.get('country.postal_code')
+
         values = values.copy()
-        if 'country_zip' in values:
-            if values['country_zip']:
-                country_zip, = CountryZip.search([
-                        ('id', '=', values['country_zip']),
-                        ], limit=1)
-                values['zip'] = country_zip.zip
-                values['city'] = country_zip.city
-                values['country'] = country_zip.country.id
-                values['subdivision'] = (country_zip.subdivision.id if
-                    country_zip.subdivision else None)
+        if 'location' in values:
+            if values['location']:
+                postal_code = PostalCode(values['location'])
+                values['postal_code'] = postal_code.postal_code
+                values['city'] = postal_code.city
+                values['country'] = postal_code.country.id
+                values['subdivision'] = (postal_code.subdivision.id if
+                    postal_code.subdivision else None)
             else:
-                values['zip'] = None
+                values['postal_code'] = None
                 values['city'] = None
         return values
 
     @classmethod
     def create(cls, vlist):
-        CountryZip = Pool().get('country.zip')
         new_vlist = []
         for values in vlist:
-            new_vlist.append(cls.update_zip_values(CountryZip, values))
+            new_vlist.append(cls.update_location_values(values))
         return super(Address, cls).create(new_vlist)
 
     @classmethod
     def write(cls, *args):
-        CountryZip = Pool().get('country.zip')
         actions = iter(args)
         new_args = []
         for addresses, values in zip(actions, actions):
             new_args.append(addresses)
-            new_args.append(cls.update_zip_values(CountryZip, values))
+            new_args.append(cls.update_location_values(values))
         super(Address, cls).write(*new_args)
 
-    @fields.depends('country_zip')
-    def on_change_country_zip(self):
-        if self.country_zip:
-            self.zip = self.country_zip.zip
-            self.city = self.country_zip.city
-            self.country = self.country_zip.country
-            self.subdivision = self.country_zip.subdivision
+    @fields.depends('location')
+    def on_change_location(self):
+        if self.location:
+            self.postal_code = self.location.postal_code
+            self.city = self.location.city
+            self.country = self.location.country
+            self.subdivision = self.location.subdivision
         else:
-            self.zip = None
+            self.postal_code = None
             self.city = None
 
 
-class CountryZip(metaclass=PoolMeta):
-    __name__ = 'country.zip'
+class PostalCode(metaclass=PoolMeta):
+    __name__ = 'country.postal_code'
 
     def get_rec_name(self, name):
         res = []
-        if self.zip:
-            res.append(self.zip)
+        if self.postal_code:
+            res.append(self.postal_code)
         if self.city:
             res.append(self.city)
         res = [' '.join(res)]
@@ -92,7 +96,7 @@ class CountryZip(metaclass=PoolMeta):
     @classmethod
     def search_rec_name(cls, name, clause):
         return ['OR',
-            [('zip',) + tuple(clause[1:])],
+            [('postal_code',) + tuple(clause[1:])],
             [('city',) + tuple(clause[1:])],
             ]
 
@@ -100,17 +104,17 @@ class CountryZip(metaclass=PoolMeta):
     def write(cls, *args):
         Address = Pool().get('party.address')
 
-        super(CountryZip, cls).write(*args)
+        super().write(*args)
 
         actions = iter(args)
-        fields = set(['zip', 'city', 'country', 'subdivision'])
+        fields = set(['postal_code', 'city', 'country', 'subdivision'])
         to_update = []
-        for zips, values in zip(actions, actions):
+        for locations, values in zip(actions, actions):
             intersec = set(values.keys()) & fields
             if not intersec:
                 continue
             addresses = Address.search([
-                    ('country_zip', 'in', [x.id for x in zips]),
+                    ('location', 'in', [x.id for x in locations]),
                     ])
             to_update.append(addresses)
             address_values = {}
diff --git a/party.xml b/party.xml
index 39f1793..045c6fa 100644
--- a/party.xml
+++ b/party.xml
@@ -45,21 +45,21 @@
             <field name="action" ref="act_subdivision_form2"/>
         </record>
 
-        <record model="ir.action.act_window" id="act_zip_form">
-            <field name="name">Zips</field>
-            <field name="res_model">country.zip</field>
+        <record model="ir.action.act_window" id="act_postal_code_form">
+            <field name="name">Postal Codes</field>
+            <field name="res_model">country.postal_code</field>
         </record>
-        <record model="ir.action.act_window.view" id="act_zip_form_view1">
+        <record model="ir.action.act_window.view" id="act_postal_code_form_view1">
             <field name="sequence" eval="10"/>
-            <field name="view" ref="country.zip_view_list"/>
-            <field name="act_window" ref="act_zip_form"/>
+            <field name="view" ref="country.postal_code_view_list"/>
+            <field name="act_window" ref="act_postal_code_form"/>
         </record>
-        <record model="ir.action.act_window.view" id="act_zip_form_view2">
+        <record model="ir.action.act_window.view" id="act_postal_code_form_view2">
             <field name="sequence" eval="20"/>
-            <field name="view" ref="country.zip_view_form"/>
-            <field name="act_window" ref="act_zip_form"/>
+            <field name="view" ref="country.postal_code_view_form"/>
+            <field name="act_window" ref="act_postal_code_form"/>
         </record>
-        <menuitem parent="country.menu_country_form" action="act_zip_form"
-            id="menu_zip_form"/>
+        <menuitem parent="country.menu_country_form" action="act_postal_code_form"
+            id="menu_postal_code_form"/>
     </data>
 </tryton>
diff --git a/tests/test_party_zip.py b/tests/test_party_zip.py
index 6ce3de5..edfbf9e 100644
--- a/tests/test_party_zip.py
+++ b/tests/test_party_zip.py
@@ -18,7 +18,7 @@ class PartyZipTestCase(ModuleTestCase):
         Address = pool.get('party.address')
         Country = pool.get('country.country')
         Subdivision = pool.get('country.subdivision')
-        Zip = pool.get('country.zip')
+        PostalCode = pool.get('country.postal_code')
 
         country1, country2 = Country.create([{
                     'name': 'Country 1',
@@ -36,13 +36,13 @@ class PartyZipTestCase(ModuleTestCase):
                     'type': 'area',
                     'country': country2.id,
                     }])
-        zip1, zip2 = Zip.create([{
-                    'zip': 'zip1',
+        postal_code1, postal_code2 = PostalCode.create([{
+                    'postal_code': 'postal_code1',
                     'city': 'city1',
                     'country': country1.id,
                     'subdivision': subdivision1.id,
                     }, {
-                    'zip': 'zip2',
+                    'postal_code': 'postal_code2',
                     'city': 'city2',
                     'country': country2.id,
                     'subdivision': subdivision2.id,
@@ -55,32 +55,32 @@ class PartyZipTestCase(ModuleTestCase):
                     'street': 'St sample, 15',
                     'city': 'City',
                     }])
-        self.assertEqual(address.zip, None)
+        self.assertEqual(address.postal_code, None)
         self.assertEqual(address.city, 'City')
         Address.write([address], {
-                    'country_zip': zip1.id,
+                    'location': postal_code1.id,
                     })
-        self.assertEqual(address.zip, 'zip1')
+        self.assertEqual(address.postal_code, 'postal_code1')
         self.assertEqual(address.city, 'city1')
         self.assertEqual(address.country.id, country1.id)
         self.assertEqual(address.subdivision.id, subdivision1.id)
 
         Address.write([address], {
-                    'country_zip': zip2.id,
+                    'location': postal_code2.id,
                     })
-        self.assertEqual(address.zip, 'zip2')
+        self.assertEqual(address.postal_code, 'postal_code2')
         self.assertEqual(address.city, 'city2')
         self.assertEqual(address.country.id, country2.id)
         self.assertEqual(address.subdivision.id, subdivision2.id)
 
-        Zip.write([zip2], {
-                    'zip': 'ZIP 3',
+        PostalCode.write([postal_code2], {
+                    'postal_code': 'Postal Code 3',
                     'city': 'CITY 3',
                     'country': country1.id,
                     'subdivision': subdivision1.id,
                     })
         address, = Address.browse([address.id])
-        self.assertEqual(address.zip, 'ZIP 3')
+        self.assertEqual(address.postal_code, 'Postal Code 3')
         self.assertEqual(address.city, 'CITY 3')
         self.assertEqual(address.country.id, country1.id)
         self.assertEqual(address.subdivision.id, subdivision1.id)
diff --git a/view/address_form.xml b/view/address_form.xml
index 55fa34d..6a2a3b8 100644
--- a/view/address_form.xml
+++ b/view/address_form.xml
@@ -2,9 +2,9 @@
 <!-- This file is part of Tryton.  The COPYRIGHT file at the top level of
 this repository contains the full copyright notices and license terms. -->
 <data>
-    <xpath expr="/form/label[@name='zip']" position="before">
-        <label name="country_zip"/>
-        <field name="country_zip" colspan="3"/>
+    <xpath expr="/form/label[@name='postal_code']" position="before">
+        <label name="location"/>
+        <field name="location" colspan="3"/>
         <newline/>
     </xpath>
 </data>