add checks for extra return statements

Author: esblinov

transfunctions/decorators/superfunction.py

@@ -78,19 +78,18 @@ async def async_option(flags: Dict[str, bool], args, kwargs, transformer) -> Non
 
 def superfunction(*args: Callable, tilde_syntax: bool = True):
     def decorator(function):
-        class NoReturns(NodeTransformer):
-            def visit_Return(self, node: Return) -> Optional[Union[AST, List[AST]]]:
-                raise WrongTransfunctionSyntaxError('A superfunction cannot contain a return statement.')
-
         transformer = FunctionTransformer(
             function,
             currentframe().f_back.f_lineno,
             'superfunction',
-            extra_transformers=[
-                #NoReturns(),
-            ],
         )
 
+        if not tilde_syntax:
+            class NoReturns(NodeTransformer):
+                def visit_Return(self, node: Return) -> Optional[Union[AST, List[AST]]]:
+                    raise WrongTransfunctionSyntaxError('A superfunction cannot contain a return statement.')
+            transformer.get_usual_function(addictional_transformers=[NoReturns()])
+
         @wraps(function)
         def wrapper(*args, **kwargs):
             return UsageTracer(args, kwargs, transformer, tilde_syntax)

transfunctions/transformer.py

@@ -12,7 +12,7 @@
 
 
 class FunctionTransformer:
-    def __init__(self, function: Callable, decorator_lineno: int, decorator_name: str, extra_transformers: Optional[List[NodeTransformer]] = None) -> None:
+    def __init__(self, function: Callable, decorator_lineno: int, decorator_name: str) -> None:
         if isinstance(function, type(self)):
             raise DualUseOfDecoratorError(f"You cannot use the '{decorator_name}' decorator twice for the same function.")
         if not isfunction(function):
@@ -25,7 +25,6 @@ def __init__(self, function: Callable, decorator_lineno: int, decorator_name: st
         self.function = function
         self.decorator_lineno = decorator_lineno
         self.decorator_name = decorator_name
-        self.extra_transformers = extra_transformers
         self.base_object = None
         self.cache: Dict[str, Callable] = {}
 
@@ -42,8 +41,8 @@ def is_lambda(function: Callable) -> bool:
         lambda_example = lambda: 0  # noqa: E731
         return isinstance(function, type(lambda_example)) and function.__name__ == lambda_example.__name__
 
-    def get_usual_function(self):
-        return self.extract_context('sync_context')
+    def get_usual_function(self, addictional_transformers: Optional[List[NodeTransformer]] = None):
+        return self.extract_context('sync_context', addictional_transformers=addictional_transformers)
 
     def get_async_function(self):
         original_function = self.function
@@ -106,12 +105,6 @@ def extract_context(self, context_name: str, addictional_transformers: Optional[
         except OSError:
             source_code = dill_getsource(self.function)
 
-        if addictional_transformers is None:
-            addictional_transformers = self.extra_transformers
-        else:
-            if self.extra_transformers is not None:
-                addictional_transformers = addictional_transformers + self.extra_transformers
-
         converted_source_code = self.clear_spaces_from_source_code(source_code)
         tree = parse(converted_source_code)
         original_function = self.function