Fix objc wrapper request box default inclusion

stone/backends/swift_client.py

@@ -142,7 +142,7 @@
         self._generate_client(api)
         self._generate_request_boxes(api)
         if not self.args.objc:
             self._generate_reconnection_helpers(api)
 
     def _generate_client(self, api):
         template_globals = {}
@@ -168,7 +168,7 @@
         namespace_fields = []
         for namespace in api.namespaces.values():
             if self._namespace_contains_valid_routes_for_auth_type(namespace):
                 namespace_fields.append((fmt_var(namespace.name),
                                         fmt_class(self._class_name(namespace.name))))
 
         return namespace_fields
@@ -206,7 +206,7 @@
         template_globals['objc_init_args_to_swift'] = self._objc_init_args_to_swift
         template_globals['objc_result_from_swift'] = self._objc_result_from_swift
         template_globals['objc_no_defualts_func_args'] = self._objc_no_defualts_func_args
         template_globals['objc_app_auth_route_wrapper_already_defined'] = \
             self._objc_app_auth_route_wrapper_already_defined
 
         ns_class = self._class_name(fmt_class(namespace.name))
@@ -240,17 +240,17 @@
         template_globals['request_type_signature'] = self._request_type_signature
         template_globals['fmt_func'] = fmt_func
         template_globals['fmt_route_objc_class'] = self._fmt_route_objc_class
         swift_class_name = '{}RequestBox'.format(self.args.class_name)
 
         if self.args.objc:
             template = self._jinja_template("ObjCRequestBox.jinja")
             template.globals = template_globals
 
             # don't include the default case in the generated switch statement if it's unreachable
-            include_default_in_switch = \
-                len(background_objc_routes) < len(background_compatible_routes)
+            include_default_in_switch = True
+            # TODO(jlocke): implement this to eliminate the unreachable code warning
 
             output = template.render(
                 background_compatible_routes=background_compatible_routes,
                 background_objc_routes=background_objc_routes,
                 class_name=swift_class_name,
@@ -276,22 +276,22 @@
         if len(background_compatible_pairs) == 0:
             return
 
         is_app_auth_client = self.args.auth_type == 'app'
         class_name_prefix = 'AppAuth' if is_app_auth_client else ''
         class_name = '{}ReconnectionHelpers'.format(class_name_prefix)
         return_type = '{}RequestBox'.format(self.args.class_name)
 
         template = self._jinja_template("SwiftReconnectionHelpers.jinja")
         template.globals['fmt_func'] = fmt_func
         template.globals['fmt_class'] = fmt_class
         template.globals['class_name'] = class_name
         template.globals['return_type'] = return_type
 
         output_from_parsed_template = template.render(
             background_compatible_namespace_route_pairs=background_compatible_pairs
         )
 
         self._write_output_in_target_folder(
             output_from_parsed_template, '{}.swift'.format(class_name)
         )
 
@@ -340,23 +340,23 @@
         # if building the user or team client, include routes of all auth types except
         # app auth exclusive routes
 
         is_app_auth_only_route = route_auth_type == 'app'
         route_auth_types_include_app = 'app' in route_auth_type
 
         if client_auth_type == 'app':
             return is_app_auth_only_route or route_auth_types_include_app
         else:
             return not is_app_auth_only_route
 
     # The objc compatibility wrapper generates a class to wrap each route providing properly
     # typed completion handlers without generics. User and App clients are generated in separate
     # passes, and if the wrapper is already defined for the user client, we must skip generating
     # a second definition of it for the app client.
     def _objc_app_auth_route_wrapper_already_defined(self, route):
         client_auth_type = self.args.auth_type
         is_app_auth_client = client_auth_type == 'app'
 
         return is_app_auth_client and route.attrs.get('auth') != 'app'
 
     def _namespace_contains_valid_routes_for_auth_type(self, namespace):
         valid_count = 0
@@ -565,7 +565,7 @@
         objc_class_to_route = {}
         for namespace in namespaces:
             for route in namespace.routes:
                 bg_route_style = self._background_session_route_style(route)
                 if bg_route_style is not None and self._valid_route_for_auth_type(route):
                     args_data = self._route_client_args(route)[0]
                     objc_class = self._fmt_route_objc_class(namespace, route, args_data)
@@ -603,7 +603,7 @@
             if is_user_defined_type(list_data_type):
                 objc_type = fmt_objc_type(list_data_type, False)
                 factory_func = '.factory' if is_union_type(list_data_type) else ''
                 factory_func = '.wrapPreservingSubtypes' if datatype_has_subtypes(data_type) \
                     else factory_func
                 value = '{}.map {}{{ {}{}(swift: $0) }}'.format(value,
                                                                 prefix,
@@ -624,7 +624,7 @@
         else:
             objc_data_type = fmt_objc_type(data_type)
             factory_func = '.factory' if is_union_type(data_type) else ''
             factory_func = '.wrapPreservingSubtypes' if datatype_has_subtypes(data_type) \
                 else factory_func
             return '{}{}(swift: {})'.format(objc_data_type,
                                             factory_func,