diff --git a/src/Generation/QBE/QBEGenerator.cs b/src/Generation/QBE/QBEGenerator.cs
index 1fe599b..fe7d444 100644
--- a/src/Generation/QBE/QBEGenerator.cs
+++ b/src/Generation/QBE/QBEGenerator.cs
@@ -71,9 +71,9 @@ public static class QBEGenerator
         return _builder.ToString();
     }
 
-    private static Tmp NewTmp()
+    private static string VarName()
     {
-        return new Tmp($"%v{++_variableIndex}");
+        return $"%v{++_variableIndex}";
     }
 
     private static string LabelName()
@@ -389,32 +389,32 @@ public static class QBEGenerator
 
         foreach (var parameter in parameters)
         {
-            var parameterName = new Tmp("%" + parameter.Name);
+            var parameterName = "%" + parameter.Name;
 
             if (parameter.Type is NubPrimitiveType primitiveType)
             {
                 switch (primitiveType.Kind)
                 {
                     case PrimitiveTypeKind.I16:
-                        parameterName = NewTmp();
+                        parameterName = VarName();
                         _builder.AppendLine($"    {parameterName} =w extsh %{parameter.Name}");
                         break;
                     case PrimitiveTypeKind.I8:
-                        parameterName = NewTmp();
+                        parameterName = VarName();
                         _builder.AppendLine($"    {parameterName} =w extsb %{parameter.Name}");
                         break;
                     case PrimitiveTypeKind.U16:
-                        parameterName = NewTmp();
+                        parameterName = VarName();
                         _builder.AppendLine($"    {parameterName} =w extuh %{parameter.Name}");
                         break;
                     case PrimitiveTypeKind.U8:
-                        parameterName = NewTmp();
+                        parameterName = VarName();
                         _builder.AppendLine($"    {parameterName} =w extub %{parameter.Name}");
                         break;
                 }
             }
 
-            parameterVars.Add(new Variable(parameter.Name, parameterName).Assign());
+            parameterVars.Add(new Variable(parameter.Name, new Ident(parameterName, parameter.Type)).Assign());
         }
 
         GenerateBlock(body, parameterVars);
@@ -510,37 +510,29 @@ public static class QBEGenerator
 
     private static void GenerateArrayIndexAssignment(ArrayIndexAssignmentNode arrayIndexAssignment)
     {
-        var array = GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Array);
-        var index = GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Index);
+        var array = Unwrap(GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Array));
+        var index = Unwrap(GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Index));
         GenerateArrayBoundsCheck(array, index);
-        var value = GenerateExpression(arrayIndexAssignment.Value);
+        var value = Unwrap(GenerateExpression(arrayIndexAssignment.Value));
 
         switch (arrayIndexAssignment.ArrayIndexAccess.Array.Type)
         {
             case NubArrayType arrayType:
             {
-                var startName = NewTmp();
-                _builder.AppendLine($"    {startName} =l add {array}, 8");
-
-                var adjustedIndex = NewTmp();
-                _builder.AppendLine($"    {adjustedIndex} =l mul {index}, {SizeOf(arrayType.ElementType)}");
-
-                var pointer = NewTmp();
-                _builder.AppendLine($"    {pointer} =l add {startName}, {adjustedIndex}");
+                var pointer = VarName();
+                _builder.AppendLine($"    {pointer} =l mul {index}, {SizeOf(arrayType.ElementType)}");
+                _builder.AppendLine($"    {pointer} =l add {pointer}, 8");
+                _builder.AppendLine($"    {pointer} =l add {array}, {pointer}");
 
                 GenerateCopy(arrayType.ElementType, value, pointer);
                 break;
             }
             case NubFixedArrayType fixedArrayType:
             {
-                var startName = NewTmp();
-                _builder.AppendLine($"    {startName} =l add {array}, 8");
-
-                var adjustedIndex = NewTmp();
-                _builder.AppendLine($"    {adjustedIndex} =l mul {index}, {SizeOf(fixedArrayType.ElementType)}");
-
-                var pointer = NewTmp();
-                _builder.AppendLine($"    {pointer} =l add {startName}, {adjustedIndex}");
+                var pointer = VarName();
+                _builder.AppendLine($"    {pointer} =l mul {index}, {SizeOf(fixedArrayType.ElementType)}");
+                _builder.AppendLine($"    {pointer} =l add {pointer}, 8");
+                _builder.AppendLine($"    {pointer} =l add {array}, {pointer}");
 
                 GenerateCopy(fixedArrayType.ElementType, value, pointer);
                 break;
@@ -591,8 +583,8 @@ public static class QBEGenerator
 
     private static void GenerateDereferenceAssignment(DereferenceAssignmentNode dereferenceAssignment)
     {
-        var pointer = GenerateExpression(dereferenceAssignment.Dereference.Expression);
-        var value = GenerateExpression(dereferenceAssignment.Value);
+        var pointer = Unwrap(GenerateExpression(dereferenceAssignment.Dereference.Expression));
+        var value = Unwrap(GenerateExpression(dereferenceAssignment.Value));
         GenerateCopy(dereferenceAssignment.Value.Type, value, pointer);
     }
 
@@ -602,7 +594,7 @@ public static class QBEGenerator
         var falseLabel = LabelName();
         var endLabel = LabelName();
 
-        var result = GenerateExpression(ifStatement.Condition);
+        var result = Unwrap(GenerateExpression(ifStatement.Condition));
         _builder.AppendLine($"    jnz {result}, {trueLabel}, {falseLabel}");
         _builder.AppendLine(trueLabel);
         GenerateBlock(ifStatement.Body);
@@ -628,12 +620,12 @@ public static class QBEGenerator
         var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
         var offset = OffsetOf(structDefinition, memberAssignment.MemberAccess.Member);
 
-        var item = GenerateExpression(memberAssignment.MemberAccess.Expression);
-        var pointer = NewTmp();
+        var item = Unwrap(GenerateExpression(memberAssignment.MemberAccess.Expression));
+        var pointer = VarName();
 
         _builder.AppendLine($"    {pointer} =l add {item}, {offset}");
 
-        var value = GenerateExpression(memberAssignment.Value);
+        var value = Unwrap(GenerateExpression(memberAssignment.Value));
 
         GenerateCopy(memberAssignment.Value.Type, value, pointer);
     }
@@ -642,7 +634,7 @@ public static class QBEGenerator
     {
         if (@return.Value.HasValue)
         {
-            var result = GenerateExpression(@return.Value.Value);
+            var result = Unwrap(GenerateExpression(@return.Value.Value));
             _builder.AppendLine($"    ret {result}");
         }
         else
@@ -653,16 +645,16 @@ public static class QBEGenerator
 
     private static void GenerateVariableDeclaration(VariableDeclarationNode variableDeclaration)
     {
-        var generatedName = NewTmp();
-        _builder.AppendLine($"    {generatedName} =l alloc8 {SizeOf(variableDeclaration.Type)}");
-        _variables.Push(new Variable(variableDeclaration.Name, generatedName));
+        var tmp = VarName();
+        _builder.AppendLine($"    {tmp} =l alloc8 {SizeOf(variableDeclaration.Type)}");
+        _variables.Push(new Variable(variableDeclaration.Name, new Ident(tmp, variableDeclaration.Type)));
     }
 
     private static void GenerateVariableAssignment(VariableAssignmentNode variableAssignment)
     {
-        var value = GenerateExpression(variableAssignment.Value);
+        var value = Unwrap(GenerateExpression(variableAssignment.Value));
         var variable = _variables.Single(x => x.Name == variableAssignment.Identifier.Name);
-        GenerateCopy(variableAssignment.Value.Type, value, variable.Tmp);
+        GenerateCopy(variableAssignment.Value.Type, value, variable.Ident.Name);
         variable.Assign();
     }
 
@@ -679,7 +671,7 @@ public static class QBEGenerator
         _builder.AppendLine(iterationLabel);
         GenerateBlock(whileStatement.Body);
         _builder.AppendLine(conditionLabel);
-        var result = GenerateExpression(whileStatement.Condition);
+        var result = Unwrap(GenerateExpression(whileStatement.Condition));
         _builder.AppendLine($"    jnz {result}, {iterationLabel}, {endLabel}");
         _builder.AppendLine(endLabel);
 
@@ -687,7 +679,7 @@ public static class QBEGenerator
         _breakLabels.Pop();
     }
 
-    private static Tmp GenerateExpression(ExpressionNode expression)
+    private static Ident GenerateExpression(ExpressionNode expression)
     {
         return expression switch
         {
@@ -708,19 +700,17 @@ public static class QBEGenerator
         };
     }
 
-    private static Tmp GenerateAnonymousFunc(AnonymousFuncNode anonymousFunc)
+    private static Ident GenerateAnonymousFunc(AnonymousFuncNode anonymousFunc)
     {
         var name = $"$anon_func{++_anonymousFuncIndex}";
         _anonymousFunctions.Enqueue((anonymousFunc, name));
-        var tmp = NewTmp();
-        _builder.AppendLine($"    {NewTmp()} =l {name}");
-        return tmp;
+        return new Ident(name, anonymousFunc.Type, IdentKind.Func);
     }
 
-    private static Tmp GenerateArrayIndexPointer(ArrayIndexAccessNode arrayIndexAccess)
+    private static string GenerateArrayIndexPointer(ArrayIndexAccessNode arrayIndexAccess)
     {
-        var array = GenerateExpression(arrayIndexAccess.Array);
-        var index = GenerateExpression(arrayIndexAccess.Index);
+        var array = Unwrap(GenerateExpression(arrayIndexAccess.Array));
+        var index = Unwrap(GenerateExpression(arrayIndexAccess.Index));
         GenerateArrayBoundsCheck(array, index);
 
         var elementType = arrayIndexAccess.Array.Type switch
@@ -730,55 +720,38 @@ public static class QBEGenerator
             _ => throw new ArgumentOutOfRangeException()
         };
 
-        var firstItemPointerName = NewTmp();
-        _builder.AppendLine($"    {firstItemPointerName} =l add {array}, 8");
-        var offsetPointerName = NewTmp();
-        _builder.AppendLine($"    {offsetPointerName} =l mul {index}, {SizeOf(elementType)}");
-        var resultPointerName = NewTmp();
-        _builder.AppendLine($"    {resultPointerName} =l add {firstItemPointerName}, {offsetPointerName}");
-        return resultPointerName;
+        var pointer = VarName();
+        _builder.AppendLine($"    {pointer} =l mul {index}, {SizeOf(elementType)}");
+        _builder.AppendLine($"    {pointer} =l add {pointer}, 8");
+        _builder.AppendLine($"    {pointer} =l add {array}, {pointer}");
+        return pointer;
     }
 
-    private static Tmp GenerateArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess)
+    private static Ident GenerateArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess)
     {
-        var pointerName = GenerateArrayIndexPointer(arrayIndexAccess);
-
-        var elementType = arrayIndexAccess.Array.Type switch
-        {
-            NubArrayType arrayType => arrayType.ElementType,
-            NubFixedArrayType fixedArrayType => fixedArrayType.ElementType,
-            _ => throw new ArgumentOutOfRangeException()
-        };
-
-        if (SizeOf(elementType) > 8)
-        {
-            return pointerName;
-        }
-        else
-        {
-            var outputName = NewTmp();
-            _builder.AppendLine($"    {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointerName}");
-            return outputName;
-        }
+        var pointer = GenerateArrayIndexPointer(arrayIndexAccess);
+        var outputName = VarName();
+        _builder.AppendLine($"    {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointer}");
+        return new Ident(outputName, arrayIndexAccess.Type);
     }
 
-    private static void GenerateArrayBoundsCheck(Tmp array, Tmp index)
+    private static void GenerateArrayBoundsCheck(string array, string index)
     {
-        var countName = NewTmp();
-        _builder.AppendLine($"    {countName} =l loadl {array}");
+        var count = VarName();
+        _builder.AppendLine($"    {count} =l loadl {array}");
         
-        var isNegativeName = NewTmp();
-        _builder.AppendLine($"    {isNegativeName} =w csltl {index}, 0");
+        var isNegative = VarName();
+        _builder.AppendLine($"    {isNegative} =w csltl {index}, 0");
         
-        var isOobName = NewTmp();
-        _builder.AppendLine($"    {isOobName} =w csgel {index}, {countName}");
+        var isOob = VarName();
+        _builder.AppendLine($"    {isOob} =w csgel {index}, {count}");
         
-        var anyOobName = NewTmp();
-        _builder.AppendLine($"    {anyOobName} =w or {isNegativeName}, {isOobName}");
+        var anyOob = VarName();
+        _builder.AppendLine($"    {anyOob} =w or {isNegative}, {isOob}");
         
         var oobLabel = LabelName();
         var notOobLabel = LabelName();
-        _builder.AppendLine($"    jnz {anyOobName}, {oobLabel}, {notOobLabel}");
+        _builder.AppendLine($"    jnz {anyOob}, {oobLabel}, {notOobLabel}");
         
         _builder.AppendLine(oobLabel);
         _builder.AppendLine($"    call $nub_panic_array_oob()");
@@ -786,39 +759,42 @@ public static class QBEGenerator
         _builder.AppendLine(notOobLabel);
     }
 
-    private static Tmp GenerateArrayInitializer(ArrayInitializerNode arrayInitializer)
+    private static Ident GenerateArrayInitializer(ArrayInitializerNode arrayInitializer)
     {
-        var capacity = GenerateExpression(arrayInitializer.Capacity);
+        var capacity = Unwrap(GenerateExpression(arrayInitializer.Capacity));
         var elementSize = SizeOf(arrayInitializer.ElementType);
-        var capacityInBytes = NewTmp();
+        
+        var capacityInBytes = VarName();
         _builder.AppendLine($"    {capacityInBytes} =l mul {capacity}, {elementSize}");
-        var totalArraySize = NewTmp();
-        _builder.AppendLine($"    {totalArraySize} =l add {capacityInBytes}, 8");
-        var outputName = NewTmp();
-        _builder.AppendLine($"    {outputName} =l alloc8 {totalArraySize}");
-        _builder.AppendLine($"    storel {capacity}, {outputName}");
+        var totalSize = VarName();
+        _builder.AppendLine($"    {totalSize} =l add {capacityInBytes}, 8");
+        
+        var arrayPointer = VarName();
+        _builder.AppendLine($"    {arrayPointer} =l alloc8 {totalSize}");
+        _builder.AppendLine($"    storel {capacity}, {arrayPointer}");
 
-        var dataPtr = NewTmp();
-        _builder.AppendLine($"    {dataPtr} =l add {outputName}, 8");
-        _builder.AppendLine($"    call $nub_memset(l {dataPtr}, w 0, l {capacityInBytes})");
+        var dataPointer = VarName();
+        _builder.AppendLine($"    {dataPointer} =l add {arrayPointer}, 8");
+        _builder.AppendLine($"    call $nub_memset(l {dataPointer}, w 0, l {capacityInBytes})");
 
-        return outputName;
+        return new Ident(arrayPointer, arrayInitializer.Type);
     }
 
-    private static Tmp GenerateDereference(DereferenceNode dereference)
+    private static Ident GenerateDereference(DereferenceNode dereference)
     {
-        var result = GenerateExpression(dereference.Expression);
-        var outputName = NewTmp();
+        var result = Unwrap(GenerateExpression(dereference.Expression));
+        var outputName = VarName();
         _builder.AppendLine($"    {outputName} {QBEAssign(dereference.Type)} {QBELoad(dereference.Type)} {result}");
-        return outputName;
+        return new Ident(outputName, dereference.Type);
     }
 
-    private static Tmp GenerateAddressOf(AddressOfNode addressOf)
+    private static Ident GenerateAddressOf(AddressOfNode addressOf)
     {
         switch (addressOf.Expression)
         {
             case ArrayIndexAccessNode arrayIndexAccess:
-                return GenerateArrayIndexPointer(arrayIndexAccess);
+                var pointer = GenerateArrayIndexPointer(arrayIndexAccess);
+                return new Ident(pointer, addressOf.Type);
             case DereferenceNode dereference:
                 return GenerateExpression(dereference.Expression);
             case IdentifierNode identifier:
@@ -827,19 +803,21 @@ public static class QBEGenerator
                     throw new NotSupportedException("There is nothing to address in another namespace");
                 }
 
-                return _variables.Single(x => x.Name == identifier.Name).Tmp;
+                return _variables.Single(x => x.Name == identifier.Name).Ident;
             case MemberAccessNode memberAccess:
-                return GenerateMemberAccessPointer(memberAccess);
+                var ptr = GenerateMemberAccessPointer(memberAccess);
+                return new Ident(ptr, addressOf.Type);
             default:
                 throw new ArgumentOutOfRangeException();
         }
     }
 
-    private static Tmp GenerateBinaryExpression(BinaryExpressionNode binaryExpression)
+    private static Ident GenerateBinaryExpression(BinaryExpressionNode binaryExpression)
     {
-        var left = GenerateExpression(binaryExpression.Left);
-        var right = GenerateExpression(binaryExpression.Right);
-        var outputName = NewTmp();
+        var left = Unwrap(GenerateExpression(binaryExpression.Left));
+        var right = Unwrap(GenerateExpression(binaryExpression.Right));
+        var outputName = VarName();
+        var output = new Ident(outputName, binaryExpression.Type);
 
         switch (binaryExpression.Operator)
         {
@@ -848,19 +826,19 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =w ceql {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w ceqw {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                 {
                     _builder.AppendLine($"    {outputName} =w ceqw {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -870,19 +848,19 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =w cnel {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w cnew {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                 {
                     _builder.AppendLine($"    {outputName} =w cnew {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -892,19 +870,19 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =w csgtl {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w csgtw {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                 {
                     _builder.AppendLine($"    {outputName} =w csgtw {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -914,19 +892,19 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =w csgel {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w csgew {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                 {
                     _builder.AppendLine($"    {outputName} =w csgew {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -936,19 +914,19 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =w csltl {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w csltw {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                 {
                     _builder.AppendLine($"    {outputName} =w csltw {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -958,19 +936,19 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =w cslel {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w cslew {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                 {
                     _builder.AppendLine($"    {outputName} =w cslew {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -980,13 +958,13 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =l add {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w add {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -996,13 +974,13 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =l sub {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w sub {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -1012,13 +990,13 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =l mul {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w mul {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -1028,13 +1006,13 @@ public static class QBEGenerator
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                 {
                     _builder.AppendLine($"    {outputName} =l div {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                 {
                     _builder.AppendLine($"    {outputName} =w div {left}, {right}");
-                    return outputName;
+                    return output;
                 }
 
                 break;
@@ -1048,11 +1026,11 @@ public static class QBEGenerator
         throw new NotSupportedException($"Binary operator {binaryExpression.Operator} for types {binaryExpression.Left.Type} and {binaryExpression.Right.Type} not supported");
     }
 
-    private static Tmp GenerateIdentifier(IdentifierNode identifier)
+    private static Ident GenerateIdentifier(IdentifierNode identifier)
     {
         if (_definitionTable.LookupFunc(identifier.Namespace.Or(_compilationUnit.Namespace), identifier.Name).TryGetValue(out var func))
         {
-            return new Tmp(FuncName(func));
+            return new Ident(FuncName(func), identifier.Type, IdentKind.Func);
         }
 
         if (!identifier.Namespace.HasValue)
@@ -1060,29 +1038,29 @@ public static class QBEGenerator
             var variable = _variables.Single(v => v.Name == identifier.Name);
             if (IsPointerType(identifier.Type))
             {
-                return variable.Tmp;
+                return variable.Ident;
             }
             else
             {
-                var output = NewTmp();
-                _builder.AppendLine($"    {output} {QBEAssign(identifier.Type)} {QBELoad(identifier.Type)} {variable.Tmp}");
-                return output;   
+                var output = VarName();
+                _builder.AppendLine($"    {output} {QBEAssign(identifier.Type)} {QBELoad(identifier.Type)} {variable.Ident}");
+                return new Ident(output, identifier.Type);
             }
         }
 
         throw new UnreachableException();
     }
 
-    private static Tmp GenerateLiteral(LiteralNode literal)
+    private static Ident GenerateLiteral(LiteralNode literal)
     {
         if (literal.Type.IsInteger)
         {
             switch (literal.Kind)
             {
                 case LiteralKind.Integer:
-                    return new Tmp(literal.Literal);
+                    return new Ident(literal.Literal, literal.Type, IdentKind.Literal);
                 case LiteralKind.Float:
-                    return new Tmp(literal.Literal.Split(".").First());
+                    return new Ident(literal.Literal.Split(".").First(), literal.Type, IdentKind.Literal);
                 default:
                     throw new ArgumentOutOfRangeException();
             }
@@ -1092,35 +1070,35 @@ public static class QBEGenerator
         {
             var value = double.Parse(literal.Literal, CultureInfo.InvariantCulture);
             var bits = BitConverter.DoubleToInt64Bits(value);
-            return new Tmp(bits.ToString());
+            return new Ident(bits.ToString(), literal.Type, IdentKind.Literal);
         }
 
         if (literal.Type.IsFloat32)
         {
             var value = float.Parse(literal.Literal, CultureInfo.InvariantCulture);
             var bits = BitConverter.SingleToInt32Bits(value);
-            return new Tmp(bits.ToString());
+            return new Ident(bits.ToString(), literal.Type, IdentKind.Literal);
         }
 
         switch (literal.Kind)
         {
             case LiteralKind.String:
                 _strings.Add(literal.Literal);
-                return new Tmp($"$string{_strings.Count}");
+                return new Ident($"$string{_strings.Count}", literal.Type, IdentKind.Literal);
             case LiteralKind.Bool:
-                return new Tmp(bool.Parse(literal.Literal) ? "1" : "0");
+                return new Ident(bool.Parse(literal.Literal) ? "1" : "0", literal.Type, IdentKind.Literal);
             default:
                 throw new ArgumentOutOfRangeException();
         }
     }
 
-    private static Tmp GenerateStructInitializer(StructInitializerNode structInitializer)
+    private static Ident GenerateStructInitializer(StructInitializerNode structInitializer)
     {
         var structDefinition = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name).GetValue();
 
-        var structVar = NewTmp();
+        var output = VarName();
         var size = SizeOf(structInitializer.StructType);
-        _builder.AppendLine($"    {structVar} =l alloc8 {size}");
+        _builder.AppendLine($"    {output} =l alloc8 {size}");
 
         foreach (var field in structDefinition.Fields)
         {
@@ -1128,16 +1106,16 @@ public static class QBEGenerator
 
             if (structInitializer.Initializers.TryGetValue(field.Name, out var fieldValue))
             {
-                var value = GenerateExpression(fieldValue);
-                var pointer = NewTmp();
-                _builder.AppendLine($"    {pointer} =l add {structVar}, {offset}");
+                var value = Unwrap(GenerateExpression(fieldValue));
+                var pointer = VarName();
+                _builder.AppendLine($"    {pointer} =l add {output}, {offset}");
                 GenerateCopy(field.Type, value, pointer);
             }
             else if (field.Value.HasValue)
             {
-                var value = GenerateExpression(field.Value.Value);
-                var pointer = NewTmp();
-                _builder.AppendLine($"    {pointer} =l add {structVar}, {offset}");
+                var value = Unwrap(GenerateExpression(field.Value.Value));
+                var pointer = VarName();
+                _builder.AppendLine($"    {pointer} =l add {output}, {offset}");
                 GenerateCopy(field.Type, value, pointer);
             }
             else
@@ -1146,13 +1124,13 @@ public static class QBEGenerator
             }
         }
 
-        return structVar;
+        return new Ident(output, structInitializer.StructType);
     }
 
-    private static Tmp GenerateUnaryExpression(UnaryExpressionNode unaryExpression)
+    private static Ident GenerateUnaryExpression(UnaryExpressionNode unaryExpression)
     {
-        var operand = GenerateExpression(unaryExpression.Operand);
-        var outputName = NewTmp();
+        var operand = Unwrap(GenerateExpression(unaryExpression.Operand));
+        var outputName = VarName();
 
         switch (unaryExpression.Operator)
         {
@@ -1162,16 +1140,16 @@ public static class QBEGenerator
                 {
                     case NubPrimitiveType { Kind: PrimitiveTypeKind.I64 }:
                         _builder.AppendLine($"    {outputName} =l neg {operand}");
-                        return outputName;
+                        return new Ident(outputName, unaryExpression.Type);
                     case NubPrimitiveType { Kind: PrimitiveTypeKind.I32 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.I8 }:
                         _builder.AppendLine($"    {outputName} =w neg {operand}");
-                        return outputName;
+                        return new Ident(outputName, unaryExpression.Type);
                     case NubPrimitiveType { Kind: PrimitiveTypeKind.F64 }:
                         _builder.AppendLine($"    {outputName} =d neg {operand}");
-                        return outputName;
+                        return new Ident(outputName, unaryExpression.Type);
                     case NubPrimitiveType { Kind: PrimitiveTypeKind.F32 }:
                         _builder.AppendLine($"    {outputName} =s neg {operand}");
-                        return outputName;
+                        return new Ident(outputName, unaryExpression.Type);
                 }
 
                 break;
@@ -1182,7 +1160,7 @@ public static class QBEGenerator
                 {
                     case NubPrimitiveType { Kind: PrimitiveTypeKind.Bool }:
                         _builder.AppendLine($"    {outputName} =w xor {operand}, 1");
-                        return outputName;
+                        return new Ident(outputName, unaryExpression.Type);
                 }
 
                 break;
@@ -1196,9 +1174,9 @@ public static class QBEGenerator
         throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported");
     }
 
-    private static Tmp GenerateMemberAccessPointer(MemberAccessNode memberAccess)
+    private static string GenerateMemberAccessPointer(MemberAccessNode memberAccess)
     {
-        var item = GenerateExpression(memberAccess.Expression);
+        var item = Unwrap(GenerateExpression(memberAccess.Expression));
         switch (memberAccess.Expression.Type)
         {
             case NubArrayType:
@@ -1215,7 +1193,7 @@ public static class QBEGenerator
                 var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
                 var offset = OffsetOf(structDefinition, memberAccess.Member);
 
-                var offsetName = NewTmp();
+                var offsetName = VarName();
                 _builder.AppendLine($"    {offsetName} =l add {item}, {offset}");
                 return offsetName;
             }
@@ -1226,40 +1204,33 @@ public static class QBEGenerator
         }
     }
 
-    private static Tmp GenerateMemberAccess(MemberAccessNode memberAccess)
+    private static Ident GenerateMemberAccess(MemberAccessNode memberAccess)
     {
         var pointer = GenerateMemberAccessPointer(memberAccess);
 
-        if (SizeOf(memberAccess.Type) > 8)
-        {
-            return pointer;
-        }
-        else
-        {
-            var outputName = NewTmp();
-            _builder.AppendLine($"    {outputName} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {pointer}");
-            return outputName;
-        }
+        var output = VarName();
+        _builder.AppendLine($"    {output} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {pointer}");
+        return new Ident(output, memberAccess.Type);
     }
 
-    private static Tmp GenerateFixedArrayInitializer(FixedArrayInitializerNode fixedArrayInitializer)
+    private static Ident GenerateFixedArrayInitializer(FixedArrayInitializerNode fixedArrayInitializer)
     {
         var totalSize = SizeOf(fixedArrayInitializer.Type);
-        var outputName = NewTmp();
+        var outputName = VarName();
         _builder.AppendLine($"    {outputName} =l alloc8 {totalSize}");
 
         _builder.AppendLine($"    storel {fixedArrayInitializer.Capacity}, {outputName}");
 
-        var dataPtr = NewTmp();
+        var dataPtr = VarName();
         _builder.AppendLine($"    {dataPtr} =l add {outputName}, 8");
 
         var dataSize = totalSize - 8;
         _builder.AppendLine($"    call $nub_memset(l {dataPtr}, w 0, l {dataSize})");
 
-        return outputName;
+        return new Ident(outputName, fixedArrayInitializer.Type);
     }
 
-    private static Tmp GenerateFuncCall(FuncCallNode funcCall)
+    private static Ident GenerateFuncCall(FuncCallNode funcCall)
     {
         var funcType = (NubFuncType)funcCall.Expression.Type;
 
@@ -1268,7 +1239,7 @@ public static class QBEGenerator
         for (var i = 0; i < funcCall.Parameters.Count; i++)
         {
             var parameter = funcCall.Parameters[i];
-            var result = GenerateExpression(parameter);
+            var result = Unwrap(GenerateExpression(parameter));
 
             var qbeType = parameter.Type switch
             {
@@ -1298,38 +1269,66 @@ public static class QBEGenerator
             parameterStrings.Add($"{qbeType} {result}");
         }
 
-        var funcPointer = GenerateExpression(funcCall.Expression);
+        var funcPointer = Unwrap(GenerateExpression(funcCall.Expression));
 
         if (funcType.ReturnType is not NubVoidType)
         {
-            var outputName = NewTmp();
+            var outputName = VarName();
             _builder.AppendLine($"    {outputName} {QBEAssign(funcCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})");
-            return outputName;
+            return new Ident(outputName, funcCall.Type);
         }
         else
         {
             _builder.AppendLine($"    call {funcPointer}({string.Join(", ", parameterStrings)})");
-            return new Tmp("fuck");
+            return new Ident(string.Empty, funcCall.Type);
         }
     }
 
-    private static void GenerateCopy(NubType type, Tmp source, Tmp destination)
+    private static void GenerateCopy(NubType type, string source, string destinationPtr)
     {
         if (SizeOf(type) > 8)
         {
-            _builder.AppendLine($"    blit {source}, {destination}, {SizeOf(type)}");
+            _builder.AppendLine($"    blit {source}, {destinationPtr}, {SizeOf(type)}");
         }
         else
         {
-            _builder.AppendLine($"    {QBEStore(type)} {source}, {destination}");
+            _builder.AppendLine($"    {QBEStore(type)} {source}, {destinationPtr}");
+        }
+    }
+
+    private static string Unwrap(Ident ident)
+    {
+        if (ident.Type.IsVoid)
+        {
+            throw new InvalidOperationException("Cannot unwrap temporary of void type");
+        }
+        
+        switch (ident.Kind)
+        {
+            case IdentKind.Func:
+            case IdentKind.Literal:
+                return ident.Name;
+            case IdentKind.Variable:
+                if (SizeOf(ident.Type) > 8)
+                {
+                    return ident.Name;
+                }
+                else
+                {
+                    var result = VarName();
+                    _builder.AppendLine($"    {result} {QBEAssign(ident.Type)} {QBELoad(ident.Type)} {ident.Name}");
+                    return result;
+                }
+            default:
+                throw new ArgumentOutOfRangeException();
         }
     }
 }
 
-internal class Variable(string name, Tmp tmp)
+internal class Variable(string name, Ident ident)
 {
-    public string Name { get; init; } = name;
-    public Tmp Tmp { get; init; } = tmp;
+    public string Name { get; } = name;
+    public Ident Ident { get; } = ident;
     public bool Initialized { get; private set; }
 
     public Variable Assign()
@@ -1339,10 +1338,16 @@ internal class Variable(string name, Tmp tmp)
     }
 }
 
-internal record Tmp(string Name)
+internal class Ident(string name, NubType type, IdentKind kind = IdentKind.Variable)
 {
-    public override string ToString()
-    {
-        return Name;
-    }
+    public string Name { get; } = name;
+    public NubType Type { get; } = type;
+    public IdentKind Kind { get; } = kind;
+}
+
+internal enum IdentKind
+{
+    Func,
+    Variable,
+    Literal
 }
\ No newline at end of file
diff --git a/src/Syntax/Typing/NubType.cs b/src/Syntax/Typing/NubType.cs
index 91dac2c..fd1ea4c 100644
--- a/src/Syntax/Typing/NubType.cs
+++ b/src/Syntax/Typing/NubType.cs
@@ -43,6 +43,8 @@ public abstract class NubType
 
     public bool IsNumber => IsFloat32 || IsFloat64 || IsInteger;
 
+    public bool IsVoid => this is NubVoidType;
+
     public abstract override bool Equals(object? obj);
     public abstract override int GetHashCode();
     public abstract override string ToString();