Add symbol and structure support

[fur] / normalization.py

diff --git a/normalization.py b/normalization.py
index e6fea77..8248169 100644 (file)
--- a/normalization.py
+++ b/normalization.py
@@ -3,6 +3,13 @@ import collections
 import desugaring
 import util
 
+NormalBuiltinExpression = collections.namedtuple(
+    'NormalBuiltinExpression',
+    (
+        'symbol',
+    ),
+)
+
 NormalVariableExpression = collections.namedtuple(
     'NormalVariableExpression',
     [
@@ -102,6 +109,13 @@ NormalProgram = collections.namedtuple(
     ],
 )
 
+def normalize_builtin_expression(counter, expression):
+    return (
+        counter,
+        (),
+        NormalBuiltinExpression(symbol=expression.symbol),
+    )
+
 def normalize_integer_literal_expression(counter, expression):
     return (
         counter,
@@ -139,14 +153,6 @@ NormalListConstructExpression = collections.namedtuple(
     ],
 )
 
-NormalListAppendStatement = collections.namedtuple(
-    'NormalListAppendStatement',
-    [
-        'list_expression',
-        'item_expression',
-    ],
-)
-
 def normalize_list_literal_expression(counter, expression):
     list_variable = '${}'.format(counter)
     counter += 1
@@ -225,6 +231,13 @@ def normalize_symbol_expression(counter, expression):
         NormalSymbolExpression(symbol=expression.symbol),
     )
 
+def normalize_symbol_literal_expression(counter, expression):
+    return (
+        counter,
+        (),
+        NormalSymbolLiteralExpression(symbol=expression.symbol),
+    )
+
 def normalize_function_call_expression(counter, expression):
     prestatements = []
 
@@ -248,23 +261,14 @@ def normalize_function_call_expression(counter, expression):
     for ps in function_prestatements:
         prestatements.append(ps)
 
-    result_variable = '${}'.format(counter)
-
-    prestatements.append(
-        NormalVariableInitializationStatement(
-            variable=result_variable,
-            expression=NormalFunctionCallExpression(
-                metadata=expression.metadata,
-                function_expression=function_expression,
-                argument_count=len(expression.argument_list),
-            ),
-        )
-    )
-
     return (
-        counter + 1,
+        counter,
         tuple(prestatements),
-        NormalVariableExpression(variable=result_variable),
+        NormalFunctionCallExpression(
+            metadata=expression.metadata,
+            function_expression=function_expression,
+            argument_count=len(expression.argument_list),
+        ),
     )
 
 def normalize_if_expression(counter, expression):
@@ -294,6 +298,7 @@ def normalize_if_expression(counter, expression):
 
 def normalize_expression(counter, expression):
     return {
+        desugaring.DesugaredBuiltinExpression: normalize_builtin_expression,
         desugaring.DesugaredFunctionCallExpression: normalize_function_call_expression,
         desugaring.DesugaredIfExpression: normalize_if_expression,
         desugaring.DesugaredIntegerLiteralExpression: normalize_integer_literal_expression,
@@ -302,6 +307,7 @@ def normalize_expression(counter, expression):
         desugaring.DesugaredStringLiteralExpression: normalize_string_literal_expression,
         desugaring.DesugaredStructureLiteralExpression: normalize_structure_literal_expression,
         desugaring.DesugaredSymbolExpression: normalize_symbol_expression,
+        desugaring.DesugaredSymbolLiteralExpression: normalize_symbol_literal_expression,
     }[type(expression)](counter, expression)
 
 def normalize_expression_statement(counter, statement):