echanced deprecated view

10 files changed, 72 insertions, 46 deletions

diff --git a/generator/generator.py b/generator/generator.py
index 8d2a8d63d..6192b6816 100644
--- a/generator/generator.py
+++ b/generator/generator.py
@@ -423,7 +423,8 @@ class Generator:
         :param pattern: regex pattern (string)
         :return: Model with items which match with regex pattern
         """
-        names = tuple(interface.enums.keys()) + tuple(interface.structs.keys())
+        enum_names = tuple(interface.enums.keys())
+        struct_names = tuple(interface.structs.keys())
 
         if pattern:
             match = {key: OrderedDict() for key in vars(interface).keys()}
@@ -432,8 +433,8 @@ class Generator:
                 if key == 'params':
                     continue
                 match[key].update({name: item for name, item in value.items() if re.match(pattern, item.name)})
-            return Interface(**match), names
-        return interface, names
+            return Interface(**match), enum_names, struct_names
+        return interface, enum_names, struct_names
 
     async def parser(self, source_xml, source_xsd):
         """
@@ -467,18 +468,18 @@ class Generator:
 
         self.env = [args.templates_directory] + [join(args.templates_directory, k) for k in vars(interface).keys()]
 
-        filtered, names = self.filter_pattern(interface, args.regex_pattern)
+        filtered, enum_names, struct_names = self.filter_pattern(interface, args.regex_pattern)
 
         tasks = []
         key_words = self.get_key_words()
 
-        functions_transformer = FunctionsProducer(paths, names, key_words)
+        functions_transformer = FunctionsProducer(paths, enum_names, struct_names, key_words)
         if args.enums and filtered.enums:
             tasks.append(self.process_main(args.skip, args.overwrite, filtered.enums,
                                            EnumsProducer(paths.enum_class, key_words)))
         if args.structs and filtered.structs:
             tasks.append(self.process_main(args.skip, args.overwrite, filtered.structs,
-                                           StructsProducer(paths.struct_class, names, key_words)))
+                                           StructsProducer(paths.struct_class, enum_names, struct_names, key_words)))
         if args.functions and filtered.functions:
             tasks.append(self.process_main(args.skip, args.overwrite, filtered.functions, functions_transformer))
             tasks.append(self.process_function_name(args.skip, args.overwrite, interface.functions,
diff --git a/generator/templates/base_struct_function.h b/generator/templates/base_struct_function.h
index 57fb1a6de..a0c697f64 100644
--- a/generator/templates/base_struct_function.h
+++ b/generator/templates/base_struct_function.h
@@ -29,12 +29,12 @@ NS_ASSUME_NONNULL_BEGIN
  {%- endfor %}
  * @return A {{name}} object
  */
-{%- if c.deprecated %}
+{%- if deprecated or c.deprecated %}
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 {%- endif %}
 - (instancetype)initWith{{c.init}};
-{%- if c.deprecated %}
+{%- if deprecated or c.deprecated %}
 #pragma clang diagnostic pop
 {%- endif %}
 {% endfor -%}
@@ -42,8 +42,15 @@ NS_ASSUME_NONNULL_BEGIN
 {%- block methods %}
 {%- for param in params %}
 {%- include 'description_param.jinja' %}
+{%- if deprecated or param.deprecated %}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- endif %}
 @property ({{'nullable, ' if not param.mandatory}}{{param.modifier}}, nonatomic) {{param.type_sdl}}{{param.origin}}{{' __deprecated' if param.deprecated and param.deprecated is sameas true }};
-{% endfor -%}
+{%- if deprecated or param.deprecated %}
+#pragma clang diagnostic pop
+{%- endif %}
+{% endfor %}
 {%- endblock %}
 @end
 
diff --git a/generator/templates/base_struct_function.m b/generator/templates/base_struct_function.m
index 610a31d90..4c991b1ad 100644
--- a/generator/templates/base_struct_function.m
+++ b/generator/templates/base_struct_function.m
@@ -10,31 +10,30 @@
 {%- endblock %}
 
 NS_ASSUME_NONNULL_BEGIN
-
+{% if deprecated %}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- endif %}
 @implementation {{name}}
+{%- if deprecated %}
+#pragma clang diagnostic pop
+{%- endif %}
 {% block constructors %}
 {%- for c in constructors %}
+{%- if deprecated or c.deprecated %}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- endif %}
 - (instancetype)initWith{{c.init}} {
-{%- if c.deprecated %}
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- if deprecated or c.deprecated %}
+#pragma clang diagnostic pop
 {%- endif %}
     self = [{{ 'self' if c.self else 'super' }} init{{ 'With' + c.self if c.self and c.self is string }}];
-{%- if c.deprecated %}
-    #pragma clang diagnostic pop
-{%- endif %}
     if (!self) {
         return nil;
     }
     {%- for a in c.arguments %}
-    {%- if a.deprecated %}
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    {%- endif %}
     self.{{a.origin}} = {{a.constructor_argument}};
-    {%- if a.deprecated %}
-    #pragma clang diagnostic pop
-    {%- endif %}
     {%- endfor %}
     return self;
 }
@@ -42,23 +41,29 @@ NS_ASSUME_NONNULL_BEGIN
 {% endblock -%}
 {%- block methods %}
 {%- for p in params %}
-{%- if p.deprecated %}
+{%- if deprecated or p.deprecated %}
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 {%- endif %}
 - (void)set{{p.origin|title}}:({{'nullable ' if not p.mandatory}}{{p.type_generic}}{{p.type_sdl|trim}}){{p.origin}} {
+{%- if deprecated or p.deprecated %}
+#pragma clang diagnostic pop
+{%- endif %}
     [self.{{parameters_store}} sdl_setObject:{{p.origin}} forName:SDLRPCParameterName{{p.method_suffix}}];
 }
-
+{% if deprecated or p.deprecated %}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- endif %}
 - ({{'nullable ' if not p.mandatory}}{{p.type_generic}}{{p.type_sdl|trim}}){{p.origin}} {
+{%- if deprecated or p.deprecated %}
+#pragma clang diagnostic pop
+{%- endif %}
     {% if p.mandatory -%}
     NSError *error = nil;
     {% endif -%}
     return [self.{{parameters_store}} sdl_{{p.for_name}}ForName:SDLRPCParameterName{{p.method_suffix}}{{' ofClass:'+p.of_class if p.of_class}} error:{{'&error' if p.mandatory else 'nil'}}];
 }
-{%- if p.deprecated %}
-#pragma clang diagnostic pop
-{%- endif %}
 {% endfor %}
 {%- endblock %}
 @end
diff --git a/generator/templates/enums/template.h b/generator/templates/enums/template.h
index 122fe0f15..a0dea105a 100644
--- a/generator/templates/enums/template.h
+++ b/generator/templates/enums/template.h
@@ -10,6 +10,13 @@
 typedef SDLEnum {{ name }} SDL_SWIFT_ENUM{{ending}};
 {% for param in params %}
 {%- include 'description_param.jinja' %}
-extern {{ name }} const {{ name }}{{param.name}}{{ " __deprecated" if param.deprecated and param.deprecated is sameas true }};
+{% if deprecated or param.deprecated -%}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- endif %}
+extern {{ name }} const {{ name }}{{param.name}}{{ " __deprecated" if param.deprecated and param.deprecated }};
+{% if deprecated or param.deprecated -%}
+#pragma clang diagnostic pop
+{%- endif %}
 {% endfor -%}
 {% endblock -%}
diff --git a/generator/templates/functions/template.m b/generator/templates/functions/template.m
index 6b23240ae..f8d1bc59a 100644
--- a/generator/templates/functions/template.m
+++ b/generator/templates/functions/template.m
@@ -10,8 +10,9 @@
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 - (instancetype)init {
     self = [super initWithName:SDLRPCFunctionName{{origin}}];
-    if (!self) { return nil; }
-
+    if (!self) {
+        return nil;
+    }
     return self;
 }
 #pragma clang diagnostic pop
diff --git a/generator/test/test_functions.py b/generator/test/test_functions.py
index af858d5b8..a271fa23a 100644
--- a/generator/test/test_functions.py
+++ b/generator/test/test_functions.py
@@ -43,8 +43,10 @@ class TestFunctionsProducer(TestCase):
                       function_names='SDLRPCFunctionNames',
                       parameter_names='SDLRPCParameterNames')
 
-        names = ('FileType', 'Language', 'SyncMsgVersion', 'TemplateColorScheme', 'TTSChunk', 'Choice')
-        self.producer = FunctionsProducer(paths, names, key_words)
+        enum_names = ('FileType', 'Language',)
+        struct_names = ('SyncMsgVersion', 'TemplateColorScheme', 'TTSChunk', 'Choice')
+
+        self.producer = FunctionsProducer(paths, enum_names, struct_names, key_words)
 
     def test_process_function_name(self):
         """
diff --git a/generator/test/test_structs.py b/generator/test/test_structs.py
index 9ddd8fef9..beb9e35c5 100644
--- a/generator/test/test_structs.py
+++ b/generator/test/test_structs.py
@@ -29,7 +29,7 @@ class TestStructsProducer(TestCase):
         self.maxDiff = None
         key_words = Generator().get_key_words()
 
-        self.producer = StructsProducer('SDLRPCStruct', ['Image'], key_words)
+        self.producer = StructsProducer('SDLRPCStruct', enum_names=(), struct_names=['Image'], key_words=key_words)
 
     def test_CloudAppProperties(self):
         """
diff --git a/generator/transformers/common_producer.py b/generator/transformers/common_producer.py
index 4719a48e6..d1550c8c2 100644
--- a/generator/transformers/common_producer.py
+++ b/generator/transformers/common_producer.py
@@ -24,9 +24,9 @@ class InterfaceProducerCommon(ABC):
     All Enums/Structs/Functions Producer are inherited from this class and using features of it
     """
 
-    def __init__(self, names=(), key_words=()):
+    def __init__(self, enum_names=(), struct_names=(), key_words=()):
         self.logger = logging.getLogger(self.__class__.__name__)
-        self.names = list(map(lambda e: self.replace_sync(e), names))
+        self.struct_names = tuple(map(lambda e: self.replace_sync(e), struct_names))
         self.key_words = key_words
         self.param_named = namedtuple('param_named',
                                       'origin constructor_argument constructor_prefix deprecated mandatory since '
@@ -34,6 +34,7 @@ class InterfaceProducerCommon(ABC):
                                       'constructor_argument_override')
         self.constructor_named = namedtuple('constructor', 'init self arguments all deprecated')
         self.argument_named = namedtuple('argument', 'origin constructor_argument variable deprecated')
+        self.names = self.struct_names + tuple(map(lambda e: self.replace_sync(e), enum_names))
 
     @property
     @abstractmethod
@@ -110,7 +111,7 @@ class InterfaceProducerCommon(ABC):
         else:
             type_origin, kind = self.evaluate_import(param.param_type)
 
-        if type_origin and (type_origin in self.names or self.title(type_origin) in self.names):
+        if type_origin and any(map(lambda n: type_origin.lower() in n.lower(), self.names)):
             name = 'SDL' + type_origin
             imports['.h'][kind].add(name)
             imports['.m'].add(name)
@@ -170,14 +171,14 @@ class InterfaceProducerCommon(ABC):
             return ''
         return 'nullable '
 
-    @staticmethod
-    def wrap(item):
+    def wrap(self, item):
         """
         Used for wrapping appropriate initiator (constructor) parameter with '@({})'
         :param item: named tup[le with initiator (constructor) parameter
         :return: wrapped parameter
         """
-        if re.match(r'\w*Int\d*|BOOL|float|double', item.type_native):
+        if re.match(r'\w*Int\d+|BOOL|float|double', item.type_native) or \
+                any(map(lambda n: item.type_native.lower() in n.lower(), self.struct_names)):
             return '@({})'.format(item.constructor_argument)
         return item.constructor_argument
 
@@ -204,7 +205,7 @@ class InterfaceProducerCommon(ABC):
                                             param.type_native.strip(), param.constructor_argument)
             init.append(init_str)
         _self = True if 'functions' in self.__class__.__name__.lower() and mandatory else ''
-        return {'init': ' '.join(init), 'self': _self, 'arguments': arguments, 'all': arguments, 'deprecated': False}
+        return {'init': ' '.join(init), 'self': _self, 'arguments': arguments, 'all': arguments}
 
     def extract_constructors(self, data: dict) -> tuple:
         """
@@ -214,6 +215,7 @@ class InterfaceProducerCommon(ABC):
         """
         mandatory = []
         not_mandatory = []
+        deprecated = any([m.deprecated for m in data.values() if getattr(m, 'deprecated', False)])
         for param in data.values():
             if param.mandatory:
                 mandatory.append(param)
@@ -223,15 +225,16 @@ class InterfaceProducerCommon(ABC):
         result = []
         if mandatory:
             mandatory = self.extract_constructor(mandatory, True)
+            mandatory['deprecated'] = deprecated
         else:
             mandatory = OrderedDict()
 
         if not_mandatory:
             not_mandatory = self.extract_constructor(not_mandatory, False)
+            not_mandatory['deprecated'] = deprecated
             if mandatory:
                 not_mandatory['init'] = '{} {}'.format(mandatory['init'], self.minimize_first(not_mandatory['init']))
                 not_mandatory['all'] = mandatory['arguments'] + not_mandatory['arguments']
-                not_mandatory['deprecated'] = any([m.deprecated for m in mandatory if hasattr(m, 'deprecated')])
                 not_mandatory['self'] = re.sub(r'([\w\d]+:)\([\w\d\s<>*]*\)([\w\d]+\s*)', r'\1\2', mandatory['init'])
             result.append(self.constructor_named(**not_mandatory))
 
diff --git a/generator/transformers/functions_producer.py b/generator/transformers/functions_producer.py
index 8eaf5fbc4..f858a8267 100644
--- a/generator/transformers/functions_producer.py
+++ b/generator/transformers/functions_producer.py
@@ -14,8 +14,8 @@ class FunctionsProducer(InterfaceProducerCommon):
     Functions transformer
     """
 
-    def __init__(self, paths, names, key_words):
-        super(FunctionsProducer, self).__init__(names=names, key_words=key_words)
+    def __init__(self, paths, enum_names, struct_names, key_words):
+        super(FunctionsProducer, self).__init__(enum_names=enum_names, struct_names=struct_names, key_words=key_words)
         self._container_name = 'params'
         self.request_class = paths.request_class
         self.response_class = paths.response_class
diff --git a/generator/transformers/structs_producer.py b/generator/transformers/structs_producer.py
index 154d34f81..2c9e0ec64 100644
--- a/generator/transformers/structs_producer.py
+++ b/generator/transformers/structs_producer.py
@@ -14,8 +14,8 @@ class StructsProducer(InterfaceProducerCommon):
     Structs transformer
     """
 
-    def __init__(self, struct_class, enum_names, key_words):
-        super(StructsProducer, self).__init__(names=enum_names, key_words=key_words)
+    def __init__(self, struct_class, enum_names, struct_names, key_words):
+        super(StructsProducer, self).__init__(enum_names=enum_names, struct_names=struct_names, key_words=key_words)
         self._container_name = 'members'
         self.struct_class = struct_class
         self.logger = logging.getLogger(self.__class__.__name__)