ref

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(),