Refs working?

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "ref.h": "c"
+    }
+}

compiler/NubLang/Ast/Node.cs

@@ -554,6 +554,16 @@ public class DereferenceNode(List<Token> tokens, NubType type, ExpressionNode ta
     }
 }
 
+public class RefDereferenceNode(List<Token> tokens, NubType type, ExpressionNode target) : LValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Target { get; } = target;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+    }
+}
+
 public class SizeNode(List<Token> tokens, NubType TargetType) : RValueExpressionNode(tokens, new NubIntType(false, 64))
 {
     public NubType TargetType { get; } = TargetType;
@@ -574,6 +584,19 @@ public class CastNode(List<Token> tokens, NubType type, ExpressionNode value) :
     }
 }
 
+public class RefStructInitializerNode(List<Token> tokens, NubType type, Dictionary<IdentifierToken, ExpressionNode> initializers) : RValueExpressionNode(tokens, type)
+{
+    public Dictionary<IdentifierToken, ExpressionNode> Initializers { get; } = initializers;
+
+    public override IEnumerable<Node> Children()
+    {
+        foreach (var initializer in Initializers)
+        {
+            yield return initializer.Value;
+        }
+    }
+}
+
 public class EnumReferenceIntermediateNode(List<Token> tokens, IdentifierToken moduleToken, IdentifierToken nameToken) : IntermediateExpression(tokens)
 {
     public IdentifierToken ModuleToken { get; } = moduleToken;

compiler/NubLang/Ast/NubType.cs

@@ -57,6 +57,15 @@ public sealed class NubPointerType(NubType baseType) : NubType
     public override int GetHashCode() => HashCode.Combine(typeof(NubPointerType), BaseType);
 }
 
+public class NubRefType(NubType baseType) : NubType
+{
+    public NubType BaseType { get; } = baseType;
+
+    public override string ToString() => "&" + BaseType;
+    public override bool Equals(NubType? other) => other is NubRefType;
+    public override int GetHashCode() => HashCode.Combine(typeof(NubRefType));
+}
+
 public class NubFuncType(List<NubType> parameters, NubType returnType) : NubType
 {
     public List<NubType> Parameters { get; } = parameters;

compiler/NubLang/Ast/TypeChecker.cs

@@ -795,15 +795,16 @@ public sealed class TypeChecker
         }
     }
 
-    private DereferenceNode CheckDereference(DereferenceSyntax expression, NubType? _)
+    private ExpressionNode CheckDereference(DereferenceSyntax expression, NubType? _)
     {
         var target = CheckExpression(expression.Target);
-        if (target.Type is not NubPointerType pointerType)
-        {
-            throw new TypeCheckerException(Diagnostic.Error($"Cannot dereference non-pointer type {target.Type}").At(expression).Build());
-        }
 
-        return new DereferenceNode(expression.Tokens, pointerType.BaseType, target);
+        return target.Type switch
+        {
+            NubPointerType pointerType => new DereferenceNode(expression.Tokens, pointerType.BaseType, target),
+            NubRefType refType => new RefDereferenceNode(expression.Tokens, refType.BaseType, target),
+            _ => throw new TypeCheckerException(Diagnostic.Error($"Cannot dereference non-pointer type {target.Type}").At(expression).Build())
+        };
     }
 
     private FuncCallNode CheckFuncCall(FuncCallSyntax expression, NubType? _)
@@ -1019,24 +1020,29 @@ public sealed class TypeChecker
             }
         }
 
-        if (target.Type is NubStructType structType)
+        switch (target.Type)
         {
-            var field = structType.Fields.FirstOrDefault(x => x.Name == expression.MemberToken.Value);
-            if (field == null)
+            case NubStructType structType:
+            {
+                var field = structType.Fields.FirstOrDefault(x => x.Name == expression.MemberToken.Value);
+                if (field == null)
+                {
+                    throw new TypeCheckerException(Diagnostic
+                        .Error($"Struct {target.Type} does not have a field with the name {expression.MemberToken.Value}")
+                        .At(expression)
+                        .Build());
+                }
+
+                return new StructFieldAccessNode(expression.Tokens, field.Type, target, expression.MemberToken);
+            }
+            default:
             {
                 throw new TypeCheckerException(Diagnostic
-                    .Error($"Struct {target.Type} does not have a field with the name {expression.MemberToken.Value}")
+                    .Error($"Cannot access struct member {expression.MemberToken.Value} on type {target.Type}")
                     .At(expression)
                     .Build());
             }
-
-            return new StructFieldAccessNode(expression.Tokens, field.Type, target, expression.MemberToken);
         }
-
-        throw new TypeCheckerException(Diagnostic
-            .Error($"Cannot access struct member {expression.MemberToken.Value} on type {target.Type}")
-            .At(expression)
-            .Build());
     }
 
     private static long CalculateSignedEnumFieldValue(EnumSyntax enumDef, EnumFieldSyntax field)
@@ -1083,7 +1089,7 @@ public sealed class TypeChecker
         throw new UnreachableException();
     }
 
-    private StructInitializerNode CheckStructInitializer(StructInitializerSyntax expression, NubType? expectedType)
+    private ExpressionNode CheckStructInitializer(StructInitializerSyntax expression, NubType? expectedType)
     {
         NubStructType? structType = null;
 
@@ -1097,9 +1103,14 @@ public sealed class TypeChecker
 
             structType = checkedStructType;
         }
-        else if (expectedType is NubStructType expectedStructType)
+        else
         {
-            structType = expectedStructType;
+            structType = expectedType switch
+            {
+                NubStructType expectedStructType => expectedStructType,
+                NubRefType { BaseType: NubStructType expectedStructType } => expectedStructType,
+                _ => structType
+            };
         }
 
         if (structType == null)
@@ -1142,7 +1153,14 @@ public sealed class TypeChecker
                 .Build());
         }
 
-        return new StructInitializerNode(expression.Tokens, structType, initializers);
+        if (expectedType is NubRefType refType && refType.BaseType == structType)
+        {
+            return new RefStructInitializerNode(expression.Tokens, refType, initializers);
+        }
+        else
+        {
+            return new StructInitializerNode(expression.Tokens, structType, initializers);
+        }
     }
 
     private BlockNode CheckBlock(BlockSyntax node)
@@ -1197,6 +1215,7 @@ public sealed class TypeChecker
             SliceTypeSyntax slice => new NubSliceType(ResolveType(slice.BaseType)),
             ConstArrayTypeSyntax arr => new NubConstArrayType(ResolveType(arr.BaseType), arr.Size),
             PointerTypeSyntax ptr => new NubPointerType(ResolveType(ptr.BaseType)),
+            RefTypeSyntax r => new NubRefType(ResolveType(r.BaseType)),
             StringTypeSyntax => new NubStringType(),
             CustomTypeSyntax c => ResolveCustomType(c),
             VoidTypeSyntax => new NubVoidType(),

compiler/NubLang/Generation/CType.cs

@@ -10,15 +10,16 @@ public static class CType
         {
             NubVoidType => "void" + (variableName != null ? $" {variableName}" : ""),
             NubBoolType => "bool" + (variableName != null ? $" {variableName}" : ""),
-            NubIntType intType => CreateIntType(intType, variableName),
-            NubFloatType floatType => CreateFloatType(floatType, variableName),
-            NubPointerType ptr => CreatePointerType(ptr, variableName),
+            NubIntType i => CreateIntType(i, variableName),
+            NubFloatType f => CreateFloatType(f, variableName),
+            NubPointerType p => CreatePointerType(p, variableName),
+            NubRefType r => CreateRefType(r, variableName),
             NubSliceType => "struct nub_slice" + (variableName != null ? $" {variableName}" : ""),
             NubStringType => "struct nub_string" + (variableName != null ? $" {variableName}" : ""),
-            NubConstArrayType arr => CreateConstArrayType(arr, variableName, constArraysAsPointers),
-            NubArrayType arr => CreateArrayType(arr, variableName),
-            NubFuncType fn => CreateFuncType(fn, variableName),
-            NubStructType st => $"struct {st.Module}_{st.Name}_{NameMangler.Mangle(st)}" + (variableName != null ? $" {variableName}" : ""),
+            NubConstArrayType a => CreateConstArrayType(a, variableName, constArraysAsPointers),
+            NubArrayType a => CreateArrayType(a, variableName),
+            NubFuncType f => CreateFuncType(f, variableName),
+            NubStructType s => $"struct {s.Module}_{s.Name}_{NameMangler.Mangle(s)}" + (variableName != null ? $" {variableName}" : ""),
             _ => throw new NotSupportedException($"C type generation not supported for: {type}")
         };
     }
@@ -47,6 +48,12 @@ public static class CType
         return cType + (varName != null ? $" {varName}" : "");
     }
 
+    private static string CreateRefType(NubRefType ptr, string? varName)
+    {
+        var baseType = Create(ptr.BaseType);
+        return baseType + "*" + (varName != null ? $" {varName}" : "");
+    }
+
     private static string CreatePointerType(NubPointerType ptr, string? varName)
     {
         var baseType = Create(ptr.BaseType);

compiler/NubLang/Generation/Generator.cs

@@ -9,9 +9,11 @@ public class Generator
 {
     private readonly CompilationUnit _compilationUnit;
     private readonly IndentedTextWriter _writer;
-    private readonly Stack<List<DeferNode>> _deferStack = [];
+    private readonly Stack<Scope> _scopes = [];
     private int _tmpIndex;
 
+    private Scope Scope => _scopes.Peek();
+
     public Generator(CompilationUnit compilationUnit)
     {
         _compilationUnit = compilationUnit;
@@ -32,6 +34,12 @@ public class Generator
     public string Emit()
     {
         _writer.WriteLine("""
+                          #include <stddef.h>
+
+                          void *rc_alloc(size_t size, void (*destructor)(void *self));
+                          void rc_retain(void *obj);
+                          void rc_release(void *obj);
+
                           struct nub_string
                           {
                               unsigned long long length;
@@ -96,7 +104,18 @@ public class Generator
             _writer.WriteLine("{");
             using (_writer.Indent())
             {
-                EmitBlock(funcNode.Body);
+                using (BeginScope())
+                {
+                    foreach (var parameter in funcNode.Prototype.Parameters)
+                    {
+                        if (parameter.Type is NubRefType)
+                        {
+                            Scope.Defer(() => _writer.WriteLine($"rc_release({parameter.NameToken.Value});"));
+                        }
+                    }
+
+                    EmitBlock(funcNode.Body);
+                }
             }
 
             _writer.WriteLine("}");
@@ -118,7 +137,10 @@ public class Generator
                 _writer.WriteLine("{");
                 using (_writer.Indent())
                 {
-                    EmitBlock(blockNode);
+                    using (BeginScope())
+                    {
+                        EmitBlock(blockNode);
+                    }
                 }
 
                 _writer.WriteLine("}");
@@ -130,7 +152,7 @@ public class Generator
                 EmitContinue(continueNode);
                 break;
             case DeferNode deferNode:
-                EmitDefer(deferNode);
+                Scope.Defer(() => EmitStatement(deferNode.Statement));
                 break;
             case ForConstArrayNode forConstArrayNode:
                 EmitForConstArray(forConstArrayNode);
@@ -170,6 +192,13 @@ public class Generator
     {
         var target = EmitExpression(assignmentNode.Target);
         var value = EmitExpression(assignmentNode.Value);
+
+        if (assignmentNode.Target.Type is NubRefType)
+        {
+            _writer.WriteLine($"rc_retain({value});");
+            _writer.WriteLine($"rc_release({target});");
+        }
+
         _writer.WriteLine($"{target} = {value};");
     }
 
@@ -185,11 +214,6 @@ public class Generator
         _writer.WriteLine("continue;");
     }
 
-    private void EmitDefer(DeferNode deferNode)
-    {
-        _deferStack.Peek().Add(deferNode);
-    }
-
     private void EmitForSlice(ForSliceNode forSliceNode)
     {
         var targetType = (NubSliceType)forSliceNode.Target.Type;
@@ -200,8 +224,11 @@ public class Generator
         _writer.WriteLine("{");
         using (_writer.Indent())
         {
-            _writer.WriteLine($"{CType.Create(targetType.ElementType, forSliceNode.ElementNameToken.Value)} = (({CType.Create(targetType.ElementType)}*){target}.data)[{indexName}];");
-            EmitBlock(forSliceNode.Body);
+            using (BeginScope())
+            {
+                _writer.WriteLine($"{CType.Create(targetType.ElementType, forSliceNode.ElementNameToken.Value)} = (({CType.Create(targetType.ElementType)}*){target}.data)[{indexName}];");
+                EmitBlock(forSliceNode.Body);
+            }
         }
 
         _writer.WriteLine("}");
@@ -217,8 +244,11 @@ public class Generator
         _writer.WriteLine("{");
         using (_writer.Indent())
         {
-            _writer.WriteLine($"{CType.Create(targetType.ElementType, forConstArrayNode.ElementNameToken.Value)} = {target}[{indexName}];");
-            EmitBlock(forConstArrayNode.Body);
+            using (BeginScope())
+            {
+                _writer.WriteLine($"{CType.Create(targetType.ElementType, forConstArrayNode.ElementNameToken.Value)} = {target}[{indexName}];");
+                EmitBlock(forConstArrayNode.Body);
+            }
         }
 
         _writer.WriteLine("}");
@@ -231,7 +261,10 @@ public class Generator
         _writer.WriteLine("{");
         using (_writer.Indent())
         {
-            EmitBlock(ifNode.Body);
+            using (BeginScope())
+            {
+                EmitBlock(ifNode.Body);
+            }
         }
 
         _writer.WriteLine("}");
@@ -244,7 +277,10 @@ public class Generator
                 _writer.WriteLine("{");
                 using (_writer.Indent())
                 {
-                    EmitBlock(elseNode);
+                    using (BeginScope())
+                    {
+                        EmitBlock(elseNode);
+                    }
                 }
 
                 _writer.WriteLine("}");
@@ -256,37 +292,22 @@ public class Generator
     {
         if (returnNode.Value == null)
         {
-            var blockDefers = _deferStack.Peek();
-            for (var i = blockDefers.Count - 1; i >= 0; i--)
-            {
-                EmitStatement(blockDefers[i].Statement);
-            }
-
+            EmitScopeCleanup();
             _writer.WriteLine("return;");
         }
         else
         {
             var returnValue = EmitExpression(returnNode.Value);
-
-            if (_deferStack.Peek().Count != 0)
+            var tmp = NewTmp();
+            _writer.WriteLine($"{CType.Create(returnNode.Value.Type, tmp)} = {returnValue};");
+            if (returnNode.Value.Type is NubRefType)
             {
-                var tmp = NewTmp();
-                _writer.WriteLine($"{CType.Create(returnNode.Value.Type, tmp)} = {returnValue};");
-
-                var blockDefers = _deferStack.Peek();
-                for (var i = blockDefers.Count - 1; i >= 0; i--)
-                {
-                    EmitStatement(blockDefers[i].Statement);
-                }
-
-                EmitLine(returnNode.Tokens.FirstOrDefault());
-                _writer.WriteLine($"return {tmp};");
-            }
-            else
-            {
-                EmitLine(returnNode.Tokens.FirstOrDefault());
-                _writer.WriteLine($"return {returnValue};");
+                _writer.WriteLine($"rc_retain({tmp});");
             }
+
+            EmitScopeCleanup();
+            EmitLine(returnNode.Tokens.FirstOrDefault());
+            _writer.WriteLine($"return {tmp};");
         }
     }
 
@@ -302,6 +323,10 @@ public class Generator
         {
             var value = EmitExpression(variableDeclarationNode.Assignment);
             _writer.WriteLine($"{CType.Create(variableDeclarationNode.Type, variableDeclarationNode.NameToken.Value)} = {value};");
+            if (variableDeclarationNode.Type is NubRefType)
+            {
+                _writer.WriteLine($"rc_retain({variableDeclarationNode.NameToken.Value});");
+            }
         }
         else
         {
@@ -316,7 +341,10 @@ public class Generator
         _writer.WriteLine("{");
         using (_writer.Indent())
         {
-            EmitBlock(whileNode.Body);
+            using (BeginScope())
+            {
+                EmitBlock(whileNode.Body);
+            }
         }
 
         _writer.WriteLine("}");
@@ -345,6 +373,8 @@ public class Generator
             FuncCallNode funcCallNode => EmitFuncCall(funcCallNode),
             FuncIdentifierNode funcIdentifierNode => FuncName(funcIdentifierNode.ModuleToken.Value, funcIdentifierNode.NameToken.Value, funcIdentifierNode.ExternSymbolToken?.Value),
             AddressOfNode addressOfNode => EmitAddressOf(addressOfNode),
+            RefDereferenceNode refDereferenceNode => EmitRefDereference(refDereferenceNode),
+            RefStructInitializerNode refStructInitializerNode => EmitRefStructInitializer(refStructInitializerNode),
             SizeNode sizeBuiltinNode => $"sizeof({CType.Create(sizeBuiltinNode.TargetType)})",
             SliceIndexAccessNode sliceIndexAccessNode => EmitSliceArrayIndexAccess(sliceIndexAccessNode),
             StringLiteralNode stringLiteralNode => EmitStringLiteral(stringLiteralNode),
@@ -479,7 +509,19 @@ public class Generator
     private string EmitFuncCall(FuncCallNode funcCallNode)
     {
         var name = EmitExpression(funcCallNode.Expression);
-        var parameterNames = funcCallNode.Parameters.Select(EmitExpression).ToList();
+
+        var parameterNames = new List<string>();
+        foreach (var parameter in funcCallNode.Parameters)
+        {
+            var result = EmitExpression(parameter);
+            if (parameter.Type is NubRefType)
+            {
+                _writer.WriteLine($"rc_retain({result});");
+            }
+
+            parameterNames.Add(result);
+        }
+
         return $"{name}({string.Join(", ", parameterNames)})";
     }
 
@@ -489,6 +531,38 @@ public class Generator
         return $"&{value}";
     }
 
+    private string EmitRefDereference(RefDereferenceNode refDereferenceNode)
+    {
+        var pointer = EmitExpression(refDereferenceNode.Target);
+        return $"*{pointer}";
+    }
+
+    private string EmitRefStructInitializer(RefStructInitializerNode refStructInitializerNode)
+    {
+        var type = (NubRefType)refStructInitializerNode.Type;
+        var structType = (NubStructType)type.BaseType;
+
+        var tmp = NewTmp();
+        _writer.WriteLine($"{CType.Create(type)} {tmp} = ({CType.Create(type)})rc_alloc(sizeof({CType.Create(structType)}), NULL);");
+
+        var initValues = new List<string>();
+        foreach (var initializer in refStructInitializerNode.Initializers)
+        {
+            var value = EmitExpression(initializer.Value);
+            initValues.Add($".{initializer.Key.Value} = {value}");
+        }
+
+        var initString = initValues.Count == 0
+            ? "0"
+            : string.Join(", ", initValues);
+
+        _writer.WriteLine($"*{tmp} = ({CType.Create(structType)}){{{initString}}};");
+
+        Scope.Defer(() => _writer.WriteLine($"rc_release({tmp});"));
+
+        return tmp;
+    }
+
     private string EmitSliceArrayIndexAccess(SliceIndexAccessNode sliceIndexAccessNode)
     {
         var targetType = (NubSliceType)sliceIndexAccessNode.Target.Type;
@@ -580,17 +654,45 @@ public class Generator
 
     private void EmitBlock(BlockNode blockNode)
     {
-        _deferStack.Push([]);
-
         foreach (var statementNode in blockNode.Statements)
         {
             EmitStatement(statementNode);
         }
+    }
 
-        var blockDefers = _deferStack.Pop();
-        for (var i = blockDefers.Count - 1; i >= 0; i--)
+    private void EmitScopeCleanup()
+    {
+        var deferredStack = Scope.GetDeferred();
+        while (deferredStack.TryPop(out var deferred))
         {
-            EmitStatement(blockDefers[i].Statement);
+            deferred.Invoke();
         }
     }
+
+    private ScopeDisposer BeginScope()
+    {
+        _scopes.Push(new Scope());
+        return new ScopeDisposer(this);
+    }
+
+    private sealed class ScopeDisposer(Generator owner) : IDisposable
+    {
+        public void Dispose()
+        {
+            owner.EmitScopeCleanup();
+            owner._scopes.Pop();
+        }
+    }
+}
+
+public class Scope
+{
+    private readonly List<Action> _deferred = [];
+
+    public void Defer(Action action)
+    {
+        _deferred.Add(action);
+    }
+
+    public Stack<Action> GetDeferred() => new(_deferred);
 }

compiler/NubLang/Syntax/Parser.cs

@@ -716,6 +716,12 @@ public sealed class Parser
             }
         }
 
+        if (TryExpectSymbol(Symbol.Ampersand))
+        {
+            var baseType = ParseType();
+            return new RefTypeSyntax(GetTokens(startIndex), baseType);
+        }
+
         if (TryExpectSymbol(Symbol.Caret))
         {
             var baseType = ParseType();

compiler/NubLang/Syntax/Syntax.cs

@@ -150,4 +150,6 @@ public record ConstArrayTypeSyntax(List<Token> Tokens, TypeSyntax BaseType, ulon
 
 public record CustomTypeSyntax(List<Token> Tokens, IdentifierToken? ModuleToken, IdentifierToken NameToken) : TypeSyntax(Tokens);
 
+public record RefTypeSyntax(List<Token> Tokens, TypeSyntax BaseType) : TypeSyntax(Tokens);
+
 #endregion

examples/playgroud/build.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -euo pipefail
+
+obj=$(nubc main.nub)
+clang $obj ../../runtime/.build/runtime.o -o .build/out

examples/playgroud/main.nub

@@ -0,0 +1,27 @@
+module main
+
+extern "puts" func puts(text: ^i8)
+
+struct Human
+{
+    age: u64
+    name: ^i8
+}
+
+extern "main" func main(argc: i64, argv: [?]^i8): i64
+{
+    let x: &Human = {
+        age = 23
+        name = "test"
+    }
+
+    puts(x^.name)
+
+    test(x)
+
+    return 0
+}
+
+func test(x: &Human)
+{
+}

runtime/.gitignore

@@ -0,0 +1 @@
+.build

runtime/build.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -euo pipefail
+
+mkdir -p .build
+clang -c runtime.c -o .build/runtime.o

runtime/ref.c

@@ -0,0 +1,42 @@
+#include "ref.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+void *rc_alloc(size_t size, void (*destructor)(void *self))
+{
+    printf("rc_alloc %zu bytes\n", size);
+    ref_header *header = malloc(sizeof(ref_header) + size);
+    if (!header)
+    {
+        exit(69);
+    }
+
+    header->ref_count = 0;
+    header->destructor = destructor;
+
+    return (void *)(header + 1);
+}
+
+void rc_retain(void *obj)
+{
+    printf("rc_retain\n");
+    ref_header *header = ((ref_header *)obj) - 1;
+    header->ref_count++;
+}
+
+void rc_release(void *obj)
+{
+    ref_header *header = ((ref_header *)obj) - 1;
+    printf("rc_release\n");
+    if (--header->ref_count <= 0)
+    {
+        if (header->destructor)
+        {
+            header->destructor(obj);
+        }
+
+        free(header);
+        printf("rc_free\n");
+    }
+}

runtime/ref.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stddef.h>
+
+typedef struct
+{
+    int ref_count;
+    void (*destructor)(void *self);
+} ref_header;
+
+void *rc_alloc(size_t size, void (*destructor)(void *self));
+void rc_retain(void *obj);
+void rc_release(void *obj);

runtime/runtime.c

@@ -0,0 +1 @@
+#include "ref.c"