X-Git-Url: https://code.kerkeslager.com/?a=blobdiff_plain;f=normalization.py;h=7ce7488575058f0aefb4318814db33b68fd242f7;hb=5e86faf919c4ee362af47f065112f010c72a7eb0;hp=40e3afdaa1afc275afe26a6aa3f19d4cedf38690;hpb=3a076cfd2c46c9f3b51815facd613445722a340b;p=fur

diff --git a/normalization.py b/normalization.py
index 40e3afd..7ce7488 100644
--- a/normalization.py
+++ b/normalization.py
@@ -17,6 +17,15 @@ NormalIntegerLiteralExpression = collections.namedtuple(
     ],
 )
 
+NormalLambdaExpression = collections.namedtuple(
+    'NormalLambdaExpression',
+    (
+        'name',
+        'argument_name_list',
+        'statement_list',
+    ),
+)
+
 NormalStringLiteralExpression = collections.namedtuple(
     'NormalStringLiteralExpression',
     [
@@ -71,14 +80,6 @@ NormalVariableInitializationStatement = collections.namedtuple(
     ],
 )
 
-NormalVariableReassignmentStatement = collections.namedtuple(
-    'NormalVariableReassignmentStatement',
-    [
-        'variable',
-        'expression',
-    ],
-)
-
 NormalExpressionStatement = collections.namedtuple(
     'NormalExpressionStatement',
     [
@@ -94,8 +95,8 @@ NormalAssignmentStatement = collections.namedtuple(
     ],
 )
 
-NormalIfElseStatement = collections.namedtuple(
-    'NormalIfElseStatement',
+NormalIfElseExpression = collections.namedtuple(
+    'NormalIfElseExpression',
     [
         'condition_expression',
         'if_statement_list',
@@ -103,15 +104,6 @@ NormalIfElseStatement = collections.namedtuple(
     ],
 )
 
-NormalFunctionDefinitionStatement = collections.namedtuple(
-    'NormalFunctionDefinitionStatement',
-    [
-        'name',
-        'argument_name_list',
-        'statement_list',
-    ],
-)
-
 NormalProgram = collections.namedtuple(
     'NormalProgram',
     [
@@ -120,13 +112,30 @@ NormalProgram = collections.namedtuple(
 )
 
 def normalize_integer_literal_expression(counter, expression):
+    return (
+        counter,
+        (),
+        NormalIntegerLiteralExpression(integer=expression.integer),
+    )
+
+def normalize_lambda_expression(counter, expression):
     variable = '${}'.format(counter)
+
+    _, statement_list = normalize_statement_list(
+        0,
+        expression.statement_list,
+    )
+
     return (
         counter + 1,
         (
             NormalVariableInitializationStatement(
                 variable=variable,
-                expression=NormalIntegerLiteralExpression(integer=expression.integer),
+                expression=NormalLambdaExpression(
+                    name=expression.name,
+                    argument_name_list=expression.argument_name_list,
+                    statement_list=statement_list,
+                ),
             ),
         ),
         NormalVariableExpression(variable=variable),
@@ -147,14 +156,6 @@ NormalListAppendStatement = collections.namedtuple(
     ],
 )
 
-NormalListGetExpression = collections.namedtuple(
-    'NormalListGetExpression',
-    [
-        'list_expression',
-        'index_expression',
-    ],
-)
-
 def normalize_list_literal_expression(counter, expression):
     list_variable = '${}'.format(counter)
     counter += 1
@@ -190,36 +191,11 @@ def normalize_list_literal_expression(counter, expression):
         list_expression,
     )
 
-def normalize_list_item_expression(counter, expression):
-    counter, list_prestatements, list_expression = normalize_expression(counter, expression.list_expression)
-    counter, index_prestatements, index_expression = normalize_expression(counter, expression.index_expression)
-
-    result_variable = '${}'.format(counter)
-    result_prestatement = NormalVariableInitializationStatement(
-        variable=result_variable,
-        expression=NormalListGetExpression(
-            list_expression=list_expression,
-            index_expression=index_expression,
-        ),
-    )
-
-    return (
-        counter + 1,
-        list_prestatements + index_prestatements + (result_prestatement,),
-        NormalVariableExpression(variable=result_variable),
-    )
-
 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(
@@ -289,16 +265,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):
@@ -310,21 +280,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,
@@ -334,19 +294,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(
@@ -372,34 +319,23 @@ def normalize_if_expression(counter, expression):
         expression.condition_expression,
     )
 
-    result_variable = '${}'.format(counter)
-    counter += 1
-
     counter, if_statement_list = normalize_statement_list(
         counter,
         expression.if_statement_list,
-        assign_result_to=result_variable,
     )
     counter, else_statement_list = normalize_statement_list(
         counter,
         expression.else_statement_list,
-        assign_result_to=result_variable,
     )
 
     return (
         counter,
-        condition_prestatements + (
-            NormalVariableInitializationStatement(
-                variable=result_variable,
-                expression=NormalVariableExpression(variable='builtin$nil'),
-            ),
-            NormalIfElseStatement(
-                condition_expression=condition_expression,
-                if_statement_list=if_statement_list,
-                else_statement_list=else_statement_list,
-            ),
+        condition_prestatements,
+        NormalIfElseExpression(
+            condition_expression=condition_expression,
+            if_statement_list=if_statement_list,
+            else_statement_list=else_statement_list,
         ),
-        NormalVariableExpression(variable=result_variable),
     )
 
 def normalize_expression(counter, expression):
@@ -407,6 +343,7 @@ def normalize_expression(counter, expression):
         desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
         desugaring.DesugaredIfExpression: normalize_if_expression,
         desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
+        desugaring.DesugaredLambdaExpression: normalize_lambda_expression,
         desugaring.DesugaredListLiteralExpression: normalize_list_literal_expression,
         desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
         desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
@@ -426,22 +363,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 (
@@ -457,15 +378,10 @@ 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)
-def normalize_statement_list(counter, statement_list, **kwargs):
-    assign_result_to = kwargs.pop('assign_result_to', None)
-
-    assert len(kwargs) == 0
-
+def normalize_statement_list(counter, statement_list):
     result_statement_list = []
 
     for statement in statement_list:
@@ -474,19 +390,6 @@ def normalize_statement_list(counter, statement_list, **kwargs):
             result_statement_list.append(s)
         result_statement_list.append(normalized)
 
-    # TODO The way we fix the last statement is really confusing
-    last_statement = result_statement_list[-1]
-
-    if isinstance(last_statement, NormalExpressionStatement) and isinstance(last_statement.expression, NormalVariableExpression):
-        if assign_result_to is not None:
-            result_expression = result_statement_list.pop().expression
-            result_statement_list.append(
-                NormalVariableReassignmentStatement(
-                    variable=assign_result_to,
-                    expression=result_expression,
-                )
-            )
-
     return (
         counter,
         result_statement_list,