Remove unecessary pushing/popping for function calls

[fur] / normalization.py

diff --git a/normalization.py b/normalization.py
index 9725b5b..5eef1db 100644 (file)
--- a/normalization.py
+++ b/normalization.py
@@ -20,6 +20,7 @@ NormalIntegerLiteralExpression = collections.namedtuple(
 NormalLambdaExpression = collections.namedtuple(
     'NormalLambdaExpression',
     (
+        'name',
         'argument_name_list',
         'statement_list',
     ),
@@ -111,15 +112,6 @@ NormalIfElseStatement = collections.namedtuple(
     ],
 )
 
-NormalFunctionDefinitionStatement = collections.namedtuple(
-    'NormalFunctionDefinitionStatement',
-    [
-        'name',
-        'argument_name_list',
-        'statement_list',
-    ],
-)
-
 NormalProgram = collections.namedtuple(
     'NormalProgram',
     [
@@ -155,6 +147,7 @@ def normalize_lambda_expression(counter, expression):
             NormalVariableInitializationStatement(
                 variable=variable,
                 expression=NormalLambdaExpression(
+                    name=expression.name,
                     argument_name_list=expression.argument_name_list,
                     statement_list=statement_list,
                 ),
@@ -214,16 +207,10 @@ def normalize_list_literal_expression(counter, expression):
     )
 
 def normalize_string_literal_expression(counter, expression):
-    variable = '${}'.format(counter)
     return (
-        counter + 1,
-        (
-            NormalVariableInitializationStatement(
-                variable=variable,
-                expression=NormalStringLiteralExpression(string=expression.string),
-            ),
-        ),
-        NormalVariableExpression(variable=variable),
+        counter,
+        (),
+        NormalStringLiteralExpression(string=expression.string),
     )
 
 NormalStructureLiteralExpression = collections.namedtuple(
@@ -293,16 +280,10 @@ def normalize_structure_literal_expression(counter, expression):
 
 
 def normalize_symbol_expression(counter, expression):
-    variable = '${}'.format(counter)
     return (
-        counter + 1,
-        (
-            NormalVariableInitializationStatement(
-                variable=variable,
-                expression=NormalSymbolExpression(symbol=expression.symbol),
-            ),
-        ),
-        NormalVariableExpression(variable=variable),
+        counter,
+        (),
+        NormalSymbolExpression(symbol=expression.symbol),
     )
 
 def normalize_function_call_expression(counter, expression):
@@ -314,21 +295,11 @@ def normalize_function_call_expression(counter, expression):
         for s in argument_prestatements:
             prestatements.append(s)
 
-        variable = '${}'.format(counter)
-        prestatements.append(
-            NormalVariableInitializationStatement(
-                variable=variable,
-                expression=normalized_argument,
-            )
-        )
         prestatements.append(
             NormalPushStatement(
-                expression=NormalVariableExpression(
-                    variable=variable,
-                ),
+                expression=normalized_argument,
             ),
         )
-        counter += 1
 
     counter, function_prestatements, function_expression = normalize_expression(
         counter,
@@ -338,19 +309,6 @@ def normalize_function_call_expression(counter, expression):
     for ps in function_prestatements:
         prestatements.append(ps)
 
-    if not isinstance(function_expression, NormalVariableExpression):
-        function_variable = '${}'.format(counter)
-
-        prestatements.append(
-            NormalVariableInitializationStatement(
-                variable=function_variable,
-                expression=function_expression,
-            )
-        )
-
-        function_expression = NormalVariableExpression(variable=function_variable)
-        counter += 1
-
     result_variable = '${}'.format(counter)
 
     prestatements.append(
@@ -431,22 +389,6 @@ def normalize_expression_statement(counter, statement):
         NormalExpressionStatement(expression=normalized),
     )
 
-def normalize_function_definition_statement(counter, statement):
-    _, statement_list = normalize_statement_list(
-        0,
-        statement.statement_list,
-        assign_result_to='result',
-    )
-    return (
-        counter,
-        (),
-        NormalFunctionDefinitionStatement(
-            name=statement.name,
-            argument_name_list=statement.argument_name_list,
-            statement_list=statement_list,
-        ),
-    )
-
 def normalize_assignment_statement(counter, statement):
     counter, prestatements, normalized_expression = normalize_expression(counter, statement.expression)
     return (
@@ -462,7 +404,6 @@ def normalize_statement(counter, statement):
     return {
         desugaring.DesugaredAssignmentStatement: normalize_assignment_statement,
         desugaring.DesugaredExpressionStatement: normalize_expression_statement,
-        desugaring.DesugaredFunctionDefinitionStatement: normalize_function_definition_statement,
     }[type(statement)](counter, statement)
 
 @util.force_generator(tuple)