Add generic unt/uint

TODO.txt

@@ -0,0 +1,3 @@
+string formatting
+Dynamic arrays
+C-style arrays

compiler/ModuleGraph.cs

@@ -85,21 +85,21 @@ public class ModuleGraph
                         switch (type)
                         {
                             case Manifest.Module.TypeInfoStruct s:
-                            {
-                                var info = new Module.TypeInfoStruct(Module.DefinitionKind.External, s.Packed);
-                                var fields = s.Fields.Select(x => new Module.TypeInfoStruct.Field(x.Name, x.Type)).ToList();
-                                info.SetFields(fields);
-                                module.AddType(name, info);
-                                break;
-                            }
-                            case Manifest.Module.TypeInfoEnum s:
-                            {
-                                var info = new Module.TypeInfoEnum(Module.DefinitionKind.External);
-                                var variants = s.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Type)).ToList();
-                                info.SetVariants(variants);
-                                module.AddType(name, info);
-                                break;
-                            }
+                                {
+                                    var info = new Module.TypeInfoStruct(Module.DefinitionSource.Imported, s.Exported, s.Packed);
+                                    var fields = s.Fields.Select(x => new Module.TypeInfoStruct.Field(x.Name, x.Type)).ToList();
+                                    info.SetFields(fields);
+                                    module.AddType(name, info);
+                                    break;
+                                }
+                            case Manifest.Module.TypeInfoEnum e:
+                                {
+                                    var info = new Module.TypeInfoEnum(Module.DefinitionSource.Imported, e.Exported);
+                                    var variants = e.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Type)).ToList();
+                                    info.SetVariants(variants);
+                                    module.AddType(name, info);
+                                    break;
+                                }
                             default:
                                 throw new ArgumentOutOfRangeException(nameof(type));
                         }
@@ -107,7 +107,7 @@ public class ModuleGraph
 
                     foreach (var (name, identifier) in manifestModule.Identifiers)
                     {
-                        module.AddIdentifier(name, new Module.IdentifierInfo(Module.DefinitionKind.External, identifier.Type, identifier.MangledName));
+                        module.AddIdentifier(name, new Module.IdentifierInfo(Module.DefinitionSource.Imported, identifier.Exported, identifier.Extern, identifier.Type, identifier.MangledName));
                     }
                 }
             }
@@ -118,14 +118,12 @@ public class ModuleGraph
 
                 foreach (var structDef in ast.Definitions.OfType<NodeDefinitionStruct>())
                 {
-                    var kind = structDef.Exported ? Module.DefinitionKind.Exported : Module.DefinitionKind.Internal;
-                    module.AddType(structDef.Name.Ident, new Module.TypeInfoStruct(kind, structDef.Packed));
+                    module.AddType(structDef.Name.Ident, new Module.TypeInfoStruct(Module.DefinitionSource.Internal, structDef.Exported, structDef.Packed));
                 }
 
                 foreach (var enumDef in ast.Definitions.OfType<NodeDefinitionEnum>())
                 {
-                    var kind = enumDef.Exported ? Module.DefinitionKind.Exported : Module.DefinitionKind.Internal;
-                    module.AddType(enumDef.Name.Ident, new Module.TypeInfoEnum(kind));
+                    module.AddType(enumDef.Name.Ident, new Module.TypeInfoEnum(Module.DefinitionSource.Internal, enumDef.Exported));
                 }
             }
 
@@ -152,7 +150,7 @@ public class ModuleGraph
 
                     if (typeInfo is Module.TypeInfoEnum enumType)
                     {
-                        var variants = enumDef.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name.Ident, ResolveType(v.Type, module.Name))).ToList();
+                        var variants = enumDef.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name.Ident, v.Type == null ? null : ResolveType(v.Type, module.Name))).ToList();
                         enumType.SetVariants(variants);
                     }
                 }
@@ -165,18 +163,32 @@ public class ModuleGraph
                 foreach (var funcDef in ast.Definitions.OfType<NodeDefinitionFunc>())
                 {
                     var parameters = funcDef.Parameters.Select(x => ResolveType(x.Type, module.Name)).ToList();
-                    var returnType = ResolveType(funcDef.ReturnType, module.Name);
+                    var returnType = funcDef.ReturnType == null ? NubTypeVoid.Instance : ResolveType(funcDef.ReturnType, module.Name);
                     var funcType = NubTypeFunc.Get(parameters, returnType);
-                    var kind = funcDef.Exported ? Module.DefinitionKind.Exported : Module.DefinitionKind.Internal;
-                    var info = new Module.IdentifierInfo(kind, funcType, NameMangler.Mangle(module.Name, funcDef.Name.Ident, funcType));
+                    var info = new Module.IdentifierInfo(Module.DefinitionSource.Internal, funcDef.Exported, false, funcType, NameMangler.Mangle(module.Name, funcDef.Name.Ident, funcType));
+                    module.AddIdentifier(funcDef.Name.Ident, info);
+                }
+
+                foreach (var funcDef in ast.Definitions.OfType<NodeDefinitionExternFunc>())
+                {
+                    var parameters = funcDef.Parameters.Select(x => ResolveType(x.Type, module.Name)).ToList();
+                    var returnType = funcDef.ReturnType == null ? NubTypeVoid.Instance : ResolveType(funcDef.ReturnType, module.Name);
+                    var funcType = NubTypeFunc.Get(parameters, returnType);
+                    var info = new Module.IdentifierInfo(Module.DefinitionSource.Internal, funcDef.Exported, true, funcType, funcDef.Name.Ident);
                     module.AddIdentifier(funcDef.Name.Ident, info);
                 }
 
                 foreach (var globalVariable in ast.Definitions.OfType<NodeDefinitionGlobalVariable>())
                 {
                     var type = ResolveType(globalVariable.Type, module.Name);
-                    var kind = globalVariable.Exported ? Module.DefinitionKind.Exported : Module.DefinitionKind.Internal;
-                    var info = new Module.IdentifierInfo(kind, type, NameMangler.Mangle(module.Name, globalVariable.Name.Ident, type));
+                    var info = new Module.IdentifierInfo(Module.DefinitionSource.Internal, globalVariable.Exported, false, type, NameMangler.Mangle(module.Name, globalVariable.Name.Ident, type));
+                    module.AddIdentifier(globalVariable.Name.Ident, info);
+                }
+
+                foreach (var globalVariable in ast.Definitions.OfType<NodeDefinitionExternGlobalVariable>())
+                {
+                    var type = ResolveType(globalVariable.Type, module.Name);
+                    var info = new Module.IdentifierInfo(Module.DefinitionSource.Internal, globalVariable.Exported, true, type, NameMangler.Mangle(module.Name, globalVariable.Name.Ident, type));
                     module.AddIdentifier(globalVariable.Name.Ident, info);
                 }
             }
@@ -198,7 +210,9 @@ public class ModuleGraph
                     NodeTypeSInt type => NubTypeSInt.Get(type.Width),
                     NodeTypeUInt type => NubTypeUInt.Get(type.Width),
                     NodeTypeString => NubTypeString.Instance,
+                    NodeTypeChar => NubTypeChar.Instance,
                     NodeTypeVoid => NubTypeVoid.Instance,
+                    NodeTypeArray type => NubTypeArray.Get(ResolveType(type.ElementType, currentModule)),
                     _ => throw new ArgumentOutOfRangeException(nameof(node))
                 };
             }
@@ -333,7 +347,7 @@ public class Module(string name)
             return false;
         }
 
-        if (searchPrivate || info.Kind is DefinitionKind.External or DefinitionKind.Exported)
+        if (searchPrivate || info.Source == DefinitionSource.Internal)
         {
             customType = info;
             return true;
@@ -352,7 +366,7 @@ public class Module(string name)
             return false;
         }
 
-        if (searchPrivate || info.Kind is DefinitionKind.External or DefinitionKind.Exported)
+        if (searchPrivate || info.Source == DefinitionSource.Internal)
         {
             identifierType = info;
             return true;
@@ -372,26 +386,28 @@ public class Module(string name)
         identifiers.Add(name, info);
     }
 
-    public enum DefinitionKind
+    public enum DefinitionSource
     {
         Internal,
-        Exported,
-        External,
+        Imported,
     }
 
-    public class IdentifierInfo(DefinitionKind kind, NubType type, string mangledName)
+    public class IdentifierInfo(DefinitionSource source, bool exported, bool @extern, NubType type, string mangledName)
     {
-        public DefinitionKind Kind { get; } = kind;
+        public DefinitionSource Source { get; } = source;
+        public bool Exported { get; } = exported;
+        public bool Extern { get; } = @extern;
         public NubType Type { get; } = type;
         public string MangledName { get; } = mangledName;
     }
 
-    public abstract class TypeInfo(DefinitionKind kind)
+    public abstract class TypeInfo(DefinitionSource source, bool exported)
     {
-        public DefinitionKind Kind { get; } = kind;
+        public DefinitionSource Source { get; } = source;
+        public bool Exported { get; } = exported;
     }
 
-    public class TypeInfoStruct(DefinitionKind kind, bool packed) : TypeInfo(kind)
+    public class TypeInfoStruct(DefinitionSource source, bool exported, bool packed) : TypeInfo(source, exported)
     {
         private IReadOnlyList<Field>? fields;
 
@@ -410,7 +426,7 @@ public class Module(string name)
         }
     }
 
-    public class TypeInfoEnum(DefinitionKind kind) : TypeInfo(kind)
+    public class TypeInfoEnum(DefinitionSource source, bool exported) : TypeInfo(source, exported)
     {
         private IReadOnlyList<Variant>? variants;
 
@@ -421,10 +437,10 @@ public class Module(string name)
             this.variants = variants;
         }
 
-        public class Variant(string name, NubType type)
+        public class Variant(string name, NubType? type)
         {
             public string Name { get; } = name;
-            public NubType Type { get; } = type;
+            public NubType? Type { get; } = type;
         }
     }
-}
+}

compiler/NubLib.cs

@@ -70,25 +70,8 @@ public record Manifest(Dictionary<string, Manifest.Module> Modules)
 
         foreach (var module in moduleGraph.GetModules())
         {
-            var types = new Dictionary<string, Module.TypeInfo>();
-            var identifiers = new Dictionary<string, Module.IdentifierInfo>();
-
-            foreach (var (name, typeInfo) in module.GetTypes())
-            {
-                if (typeInfo.Kind == Compiler.Module.DefinitionKind.Exported)
-                {
-                    types.Add(name, ConvertType(typeInfo));
-                }
-            }
-
-            foreach (var (name, identifierInfo) in module.GetIdentifiers())
-            {
-                if (identifierInfo.Kind == Compiler.Module.DefinitionKind.Exported)
-                {
-                    identifiers.Add(name, new Module.IdentifierInfo(identifierInfo.Type, identifierInfo.MangledName));
-                }
-            }
-
+            var types = module.GetTypes().ToDictionary(x => x.Key, x => ConvertType(x.Value));
+            var identifiers = module.GetIdentifiers().ToDictionary(x => x.Key, x => new Module.IdentifierInfo(x.Value.Type, x.Value.Exported, x.Value.Extern, x.Value.MangledName));
             modules[module.Name] = new Module(types, identifiers);
         }
 
@@ -98,8 +81,8 @@ public record Manifest(Dictionary<string, Manifest.Module> Modules)
         {
             return typeInfo switch
             {
-                Compiler.Module.TypeInfoStruct s => new Module.TypeInfoStruct(s.Packed, s.Fields.Select(x => new Module.TypeInfoStruct.Field(x.Name, x.Type)).ToList()),
-                Compiler.Module.TypeInfoEnum e => new Module.TypeInfoEnum(e.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Type)).ToList()),
+                Compiler.Module.TypeInfoStruct s => new Module.TypeInfoStruct(s.Exported, s.Packed, s.Fields.Select(x => new Module.TypeInfoStruct.Field(x.Name, x.Type)).ToList()),
+                Compiler.Module.TypeInfoEnum e => new Module.TypeInfoEnum(e.Exported, e.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Type)).ToList()),
                 _ => throw new ArgumentOutOfRangeException(nameof(typeInfo))
             };
         }
@@ -108,20 +91,20 @@ public record Manifest(Dictionary<string, Manifest.Module> Modules)
 
     public record Module(Dictionary<string, Module.TypeInfo> Types, Dictionary<string, Module.IdentifierInfo> Identifiers)
     {
-        public record IdentifierInfo(NubType Type, string MangledName);
+        public record IdentifierInfo(NubType Type, bool Exported, bool Extern, string MangledName);
 
         [JsonDerivedType(typeof(TypeInfoStruct), "struct")]
         [JsonDerivedType(typeof(TypeInfoEnum), "enum")]
-        public abstract record TypeInfo;
+        public abstract record TypeInfo(bool Exported);
 
-        public record TypeInfoStruct(bool Packed, IReadOnlyList<TypeInfoStruct.Field> Fields) : TypeInfo
+        public record TypeInfoStruct(bool Exported, bool Packed, IReadOnlyList<TypeInfoStruct.Field> Fields) : TypeInfo(Exported)
         {
             public record Field(string Name, NubType Type);
         }
 
-        public record TypeInfoEnum(IReadOnlyList<TypeInfoEnum.Variant> Variants) : TypeInfo
+        public record TypeInfoEnum(bool Exported, IReadOnlyList<TypeInfoEnum.Variant> Variants) : TypeInfo(Exported)
         {
-            public record Variant(string Name, NubType Type);
+            public record Variant(string Name, NubType? Type);
         }
     }
 }

compiler/NubType.cs

@@ -102,6 +102,17 @@ public class NubTypeString : NubType
     public override string ToString() => "string";
 }
 
+public class NubTypeChar : NubType
+{
+    public static readonly NubTypeChar Instance = new();
+
+    private NubTypeChar()
+    {
+    }
+
+    public override string ToString() => "char";
+}
+
 public class NubTypeStruct : NubType
 {
     private static readonly Dictionary<(string Module, string Name), NubTypeStruct> Cache = new();
@@ -256,6 +267,28 @@ public class NubTypeFunc : NubType
     private record Signature(IReadOnlyList<NubType> Parameters, NubType ReturnType);
 }
 
+public class NubTypeArray : NubType
+{
+    private static readonly Dictionary<NubType, NubTypeArray> Cache = new();
+
+    public static NubTypeArray Get(NubType to)
+    {
+        if (!Cache.TryGetValue(to, out var ptr))
+            Cache[to] = ptr = new NubTypeArray(to);
+
+        return ptr;
+    }
+
+    public NubType ElementType { get; }
+
+    private NubTypeArray(NubType elementType)
+    {
+        ElementType = elementType;
+    }
+
+    public override string ToString() => $"[]{ElementType}";
+}
+
 public class TypeEncoder
 {
     public static string Encode(NubType type)
@@ -302,6 +335,10 @@ public class TypeEncoder
                 sb.Append('S');
                 break;
 
+            case NubTypeChar:
+                sb.Append('C');
+                break;
+
             case NubTypePointer p:
                 sb.Append("P(");
                 EncodeType(sb, p.To);
@@ -355,6 +392,12 @@ public class TypeEncoder
                 sb.Append(')');
                 break;
 
+            case NubTypeArray a:
+                sb.Append("A(");
+                EncodeType(sb, a.ElementType);
+                sb.Append(')');
+                break;
+
             default:
                 throw new NotSupportedException(type.GetType().Name);
         }
@@ -392,10 +435,12 @@ public class TypeDecoder
             'U' => DecodeUInt(),
             'I' => DecodeSInt(),
             'S' => NubTypeString.Instance,
+            'C' => NubTypeChar.Instance,
             'P' => DecodePointer(),
             'F' => DecodeFunc(),
             'T' => DecodeStruct(),
             'E' => DecodeEnum(),
+            'A' => DecodeArray(),
             _ => throw new Exception($"'{start}' is not a valid start to a type")
         };
     }
@@ -531,6 +576,14 @@ public class TypeDecoder
         throw new Exception($"Expected 'V' or 'N'");
     }
 
+    private NubTypeArray DecodeArray()
+    {
+        Expect('(');
+        var elementType = DecodeType();
+        Expect(')');
+        return NubTypeArray.Get(elementType);
+    }
+
     private bool TryPeek(out char c)
     {
         if (index >= encoded.Length)

compiler/Parser.cs

@@ -65,40 +65,42 @@ public class Parser
                     Next();
                     modifiers[Keyword.Packed] = keyword;
                     break;
+                case Keyword.Extern:
+                    Next();
+                    modifiers[Keyword.Extern] = keyword;
+                    break;
                 default:
                     goto modifier_done;
             }
         }
 
-        modifier_done:
+    modifier_done:
 
         if (TryExpectKeyword(Keyword.Func))
         {
             var exported = modifiers.Remove(Keyword.Export);
+            var @extern = modifiers.Remove(Keyword.Extern);
 
             foreach (var modifier in modifiers)
                 // todo(nub31): Add to diagnostics instead of throwing
                 throw BasicError("Invalid modifier for function", modifier.Value);
 
             var name = ExpectIdent();
-            var parameters = new List<NodeDefinitionFunc.Param>();
+            var parameters = ParseFuncParameters();
 
-            ExpectSymbol(Symbol.OpenParen);
-            while (!TryExpectSymbol(Symbol.CloseParen))
+            NodeType? returnType = null;
+            if (TryExpectSymbol(Symbol.Colon))
+                returnType = ParseType();
+
+            if (@extern)
             {
-                var paramStartIndex = index;
-                var parameterName = ExpectIdent();
-                ExpectSymbol(Symbol.Colon);
-                var parameterType = ParseType();
-                parameters.Add(new NodeDefinitionFunc.Param(TokensFrom(paramStartIndex), parameterName, parameterType));
+                return new NodeDefinitionExternFunc(TokensFrom(startIndex), exported, name, parameters, returnType);
+            }
+            else
+            {
+                var body = ParseStatement();
+                return new NodeDefinitionFunc(TokensFrom(startIndex), exported, name, parameters, body, returnType);
             }
-
-            ExpectSymbol(Symbol.Colon);
-            var returnType = ParseType();
-
-            var body = ParseStatement();
-
-            return new NodeDefinitionFunc(TokensFrom(startIndex), exported, name, parameters, body, returnType);
         }
 
         if (TryExpectKeyword(Keyword.Struct))
@@ -120,6 +122,7 @@ public class Parser
                 var fieldName = ExpectIdent();
                 ExpectSymbol(Symbol.Colon);
                 var fieldType = ParseType();
+                TryExpectSymbol(Symbol.Comma);
                 fields.Add(new NodeDefinitionStruct.Field(TokensFrom(fieldStartIndex), fieldName, fieldType));
             }
 
@@ -142,8 +145,13 @@ public class Parser
             {
                 var variantsStartIndex = index;
                 var variantName = ExpectIdent();
-                ExpectSymbol(Symbol.Colon);
-                var variantType = ParseType();
+
+                NodeType? variantType = null;
+                if (TryExpectSymbol(Symbol.Colon))
+                    variantType = ParseType();
+
+                TryExpectSymbol(Symbol.Comma);
+
                 variants.Add(new NodeDefinitionEnum.Variant(TokensFrom(variantsStartIndex), variantName, variantType));
             }
 
@@ -168,6 +176,35 @@ public class Parser
         throw BasicError("Not a valid definition", Peek());
     }
 
+    private List<NodeDefinitionFunc.Param> ParseFuncParameters()
+    {
+        var parameters = new List<NodeDefinitionFunc.Param>();
+
+        ExpectSymbol(Symbol.OpenParen);
+
+        while (true)
+        {
+            if (TryExpectSymbol(Symbol.CloseParen))
+                break;
+
+            var startIndex = index;
+
+            var name = ExpectIdent();
+            ExpectSymbol(Symbol.Colon);
+            var type = ParseType();
+
+            parameters.Add(new NodeDefinitionFunc.Param(TokensFrom(startIndex), name, type));
+
+            if (!TryExpectSymbol(Symbol.Comma))
+            {
+                ExpectSymbol(Symbol.CloseParen);
+                break;
+            }
+        }
+
+        return parameters;
+    }
+
     private NodeStatement ParseStatement()
     {
         var startIndex = index;
@@ -183,7 +220,17 @@ public class Parser
 
         if (TryExpectKeyword(Keyword.Return))
         {
-            var value = ParseExpression();
+            NodeExpression? value = null;
+
+            if (Peek() is TokenIdent token && token.Ident == "void")
+            {
+                Next();
+            }
+            else
+            {
+                value = ParseExpression();
+            }
+
             return new NodeStatementReturn(TokensFrom(startIndex), value);
         }
 
@@ -216,8 +263,17 @@ public class Parser
         if (TryExpectKeyword(Keyword.While))
         {
             var condition = ParseExpression();
-            var thenBlock = ParseStatement();
-            return new NodeStatementWhile(TokensFrom(startIndex), condition, thenBlock);
+            var block = ParseStatement();
+            return new NodeStatementWhile(TokensFrom(startIndex), condition, block);
+        }
+
+        if (TryExpectKeyword(Keyword.For))
+        {
+            var variableName = ExpectIdent();
+            ExpectKeyword(Keyword.In);
+            var array = ParseExpression();
+            var block = ParseStatement();
+            return new NodeStatementFor(TokensFrom(startIndex), variableName, array, block);
         }
 
         if (TryExpectKeyword(Keyword.Match))
@@ -229,10 +285,10 @@ public class Parser
             while (!TryExpectSymbol(Symbol.CloseCurly))
             {
                 var caseStartIndex = index;
-                var type = ExpectIdent();
-                var variableName = ExpectIdent();
+                var variant = ExpectIdent();
+                TryExpectIdent(out var variableName);
                 var body = ParseStatement();
-                cases.Add(new NodeStatementMatch.Case(TokensFrom(caseStartIndex), type, variableName, body));
+                cases.Add(new NodeStatementMatch.Case(TokensFrom(caseStartIndex), variant, variableName, body));
             }
 
             return new NodeStatementMatch(TokensFrom(startIndex), target, cases);
@@ -316,6 +372,19 @@ public class Parser
             var target = ParseExpression();
             expr = new NodeExpressionUnary(TokensFrom(startIndex), target, NodeExpressionUnary.Op.Negate);
         }
+        else if (TryExpectSymbol(Symbol.OpenSquare))
+        {
+            var values = new List<NodeExpression>();
+
+            while (!TryExpectSymbol(Symbol.CloseSquare))
+            {
+                var value = ParseExpression();
+                values.Add(value);
+                TryExpectSymbol(Symbol.Comma);
+            }
+
+            expr = new NodeExpressionArrayLiteral(TokensFrom(startIndex), values);
+        }
         else if (TryExpectSymbol(Symbol.OpenCurly))
         {
             var initializers = new List<NodeExpressionStructLiteral.Initializer>();
@@ -358,30 +427,50 @@ public class Parser
 
             expr = new NodeExpressionIdent(TokensFrom(startIndex), sections);
         }
-        else if (TryExpectKeyword(Keyword.Struct))
+        else if (TryExpectKeyword(Keyword.New))
         {
             var type = ParseType();
 
-            var initializers = new List<NodeExpressionStructLiteral.Initializer>();
-
-            ExpectSymbol(Symbol.OpenCurly);
-            while (!TryExpectSymbol(Symbol.CloseCurly))
+            if (type is NodeTypeString)
             {
-                var initializerStartIndex = startIndex;
-                var fieldName = ExpectIdent();
-                ExpectSymbol(Symbol.Equal);
-                var fieldValue = ParseExpression();
-                initializers.Add(new NodeExpressionStructLiteral.Initializer(TokensFrom(initializerStartIndex), fieldName, fieldValue));
+                ExpectSymbol(Symbol.OpenParen);
+                var value = ParseExpression();
+                ExpectSymbol(Symbol.CloseParen);
+
+                expr = new NodeExpressionStringConstructor(TokensFrom(startIndex), value);
             }
+            else if (type is NodeTypeNamed namedType)
+            {
+                if (TryExpectSymbol(Symbol.OpenParen))
+                {
+                    var value = ParseExpression();
+                    ExpectSymbol(Symbol.CloseParen);
 
-            expr = new NodeExpressionStructLiteral(TokensFrom(startIndex), type, initializers);
-        }
-        else if (TryExpectKeyword(Keyword.Enum))
-        {
-            var type = ParseType();
-            var value = ParseExpression();
+                    expr = new NodeExpressionEnumLiteral(TokensFrom(startIndex), namedType, value);
+                }
+                else if (TryExpectSymbol(Symbol.OpenCurly))
+                {
+                    var initializers = new List<NodeExpressionStructLiteral.Initializer>();
+                    while (!TryExpectSymbol(Symbol.CloseCurly))
+                    {
+                        var initializerStartIndex = startIndex;
+                        var fieldName = ExpectIdent();
+                        ExpectSymbol(Symbol.Equal);
+                        var fieldValue = ParseExpression();
+                        initializers.Add(new NodeExpressionStructLiteral.Initializer(TokensFrom(initializerStartIndex), fieldName, fieldValue));
+                    }
 
-            expr = new NodeExpressionEnumLiteral(TokensFrom(startIndex), type, value);
+                    expr = new NodeExpressionStructLiteral(TokensFrom(startIndex), null, initializers);
+                }
+                else
+                {
+                    expr = new NodeExpressionEnumLiteral(TokensFrom(startIndex), namedType, null);
+                }
+            }
+            else
+            {
+                throw BasicError($"Expected named type or string", type);
+            }
         }
         else
         {
@@ -400,7 +489,10 @@ public class Parser
                 var parameters = new List<NodeExpression>();
 
                 while (!TryExpectSymbol(Symbol.CloseParen))
+                {
                     parameters.Add(ParseExpression());
+                    TryExpectSymbol(Symbol.Comma);
+                }
 
                 expr = new NodeExpressionFuncCall(TokensFrom(startIndex), expr, parameters);
             }
@@ -454,6 +546,13 @@ public class Parser
             return new NodeTypeAnonymousStruct(TokensFrom(startIndex), fields);
         }
 
+        if (TryExpectSymbol(Symbol.OpenSquare))
+        {
+            ExpectSymbol(Symbol.CloseSquare);
+            var elementType = ParseType();
+            return new NodeTypeArray(TokensFrom(startIndex), elementType);
+        }
+
         if (TryExpectIdent(out var ident))
         {
             switch (ident.Ident)
@@ -462,8 +561,12 @@ public class Parser
                     return new NodeTypeVoid(TokensFrom(startIndex));
                 case "string":
                     return new NodeTypeString(TokensFrom(startIndex));
+                case "char":
+                    return new NodeTypeChar(TokensFrom(startIndex));
                 case "bool":
                     return new NodeTypeBool(TokensFrom(startIndex));
+                case "int":
+                    return new NodeTypeSInt(TokensFrom(startIndex), 64);
                 case "i8":
                     return new NodeTypeSInt(TokensFrom(startIndex), 8);
                 case "i16":
@@ -472,6 +575,8 @@ public class Parser
                     return new NodeTypeSInt(TokensFrom(startIndex), 32);
                 case "i64":
                     return new NodeTypeSInt(TokensFrom(startIndex), 64);
+                case "uint":
+                    return new NodeTypeUInt(TokensFrom(startIndex), 64);
                 case "u8":
                     return new NodeTypeUInt(TokensFrom(startIndex), 8);
                 case "u16":
@@ -688,6 +793,11 @@ public class Parser
     {
         return new CompileException(Diagnostic.Error(message).At(fileName, ident).Build());
     }
+
+    private CompileException BasicError(string message, Node? node)
+    {
+        return new CompileException(Diagnostic.Error(message).At(fileName, node).Build());
+    }
 }
 
 public class Ast(string fileName, TokenIdent moduleName, List<NodeDefinition> definitions)
@@ -704,13 +814,21 @@ public abstract class Node(List<Token> tokens)
 
 public abstract class NodeDefinition(List<Token> tokens) : Node(tokens);
 
-public class NodeDefinitionFunc(List<Token> tokens, bool exported, TokenIdent name, List<NodeDefinitionFunc.Param> parameters, NodeStatement body, NodeType returnType) : NodeDefinition(tokens)
+public class NodeDefinitionExternFunc(List<Token> tokens, bool exported, TokenIdent name, List<NodeDefinitionFunc.Param> parameters, NodeType? returnType) : NodeDefinition(tokens)
+{
+    public bool Exported { get; } = exported;
+    public TokenIdent Name { get; } = name;
+    public List<NodeDefinitionFunc.Param> Parameters { get; } = parameters;
+    public NodeType? ReturnType { get; } = returnType;
+}
+
+public class NodeDefinitionFunc(List<Token> tokens, bool exported, TokenIdent name, List<NodeDefinitionFunc.Param> parameters, NodeStatement body, NodeType? returnType) : NodeDefinition(tokens)
 {
     public bool Exported { get; } = exported;
     public TokenIdent Name { get; } = name;
     public List<Param> Parameters { get; } = parameters;
     public NodeStatement Body { get; } = body;
-    public NodeType ReturnType { get; } = returnType;
+    public NodeType? ReturnType { get; } = returnType;
 
     public class Param(List<Token> tokens, TokenIdent name, NodeType type) : Node(tokens)
     {
@@ -739,13 +857,20 @@ public class NodeDefinitionEnum(List<Token> tokens, bool exported, TokenIdent na
     public TokenIdent Name { get; } = name;
     public List<Variant> Variants { get; } = variants;
 
-    public class Variant(List<Token> tokens, TokenIdent name, NodeType type) : Node(tokens)
+    public class Variant(List<Token> tokens, TokenIdent name, NodeType? type) : Node(tokens)
     {
         public TokenIdent Name { get; } = name;
-        public NodeType Type { get; } = type;
+        public NodeType? Type { get; } = type;
     }
 }
 
+public class NodeDefinitionExternGlobalVariable(List<Token> tokens, bool exported, TokenIdent name, NodeType type) : NodeDefinition(tokens)
+{
+    public bool Exported { get; } = exported;
+    public TokenIdent Name { get; } = name;
+    public NodeType Type { get; } = type;
+}
+
 public class NodeDefinitionGlobalVariable(List<Token> tokens, bool exported, TokenIdent name, NodeType type) : NodeDefinition(tokens)
 {
     public bool Exported { get; } = exported;
@@ -765,9 +890,9 @@ public class NodeStatementExpression(List<Token> tokens, NodeExpression expressi
     public NodeExpression Expression { get; } = expression;
 }
 
-public class NodeStatementReturn(List<Token> tokens, NodeExpression value) : NodeStatement(tokens)
+public class NodeStatementReturn(List<Token> tokens, NodeExpression? value) : NodeStatement(tokens)
 {
-    public NodeExpression Value { get; } = value;
+    public NodeExpression? Value { get; } = value;
 }
 
 public class NodeStatementVariableDeclaration(List<Token> tokens, TokenIdent name, NodeType? type, NodeExpression value) : NodeStatement(tokens)
@@ -796,15 +921,22 @@ public class NodeStatementWhile(List<Token> tokens, NodeExpression condition, No
     public NodeStatement Body { get; } = body;
 }
 
+public class NodeStatementFor(List<Token> tokens, TokenIdent variableName, NodeExpression array, NodeStatement body) : NodeStatement(tokens)
+{
+    public TokenIdent VariableName { get; } = variableName;
+    public NodeExpression Array { get; } = array;
+    public NodeStatement Body { get; } = body;
+}
+
 public class NodeStatementMatch(List<Token> tokens, NodeExpression target, List<NodeStatementMatch.Case> cases) : NodeStatement(tokens)
 {
     public NodeExpression Target { get; } = target;
     public List<Case> Cases { get; } = cases;
 
-    public class Case(List<Token> tokens, TokenIdent type, TokenIdent variableName, NodeStatement body) : Node(tokens)
+    public class Case(List<Token> tokens, TokenIdent type, TokenIdent? variableName, NodeStatement body) : Node(tokens)
     {
         public TokenIdent Variant { get; } = type;
-        public TokenIdent VariableName { get; } = variableName;
+        public TokenIdent? VariableName { get; } = variableName;
         public NodeStatement Body { get; } = body;
     }
 }
@@ -826,9 +958,9 @@ public class NodeExpressionBoolLiteral(List<Token> tokens, TokenBoolLiteral valu
     public TokenBoolLiteral Value { get; } = value;
 }
 
-public class NodeExpressionStructLiteral(List<Token> tokens, NodeType? type, List<NodeExpressionStructLiteral.Initializer> initializers) : NodeExpression(tokens)
+public class NodeExpressionStructLiteral(List<Token> tokens, NodeTypeNamed? type, List<NodeExpressionStructLiteral.Initializer> initializers) : NodeExpression(tokens)
 {
-    public NodeType? Type { get; } = type;
+    public NodeTypeNamed? Type { get; } = type;
     public List<Initializer> Initializers { get; } = initializers;
 
     public class Initializer(List<Token> tokens, TokenIdent name, NodeExpression value) : Node(tokens)
@@ -838,9 +970,19 @@ public class NodeExpressionStructLiteral(List<Token> tokens, NodeType? type, Lis
     }
 }
 
-public class NodeExpressionEnumLiteral(List<Token> tokens, NodeType type, NodeExpression value) : NodeExpression(tokens)
+public class NodeExpressionEnumLiteral(List<Token> tokens, NodeTypeNamed type, NodeExpression? value) : NodeExpression(tokens)
+{
+    public NodeTypeNamed Type { get; } = type;
+    public NodeExpression? Value { get; } = value;
+}
+
+public class NodeExpressionArrayLiteral(List<Token> tokens, List<NodeExpression> values) : NodeExpression(tokens)
+{
+    public List<NodeExpression> Values { get; } = values;
+}
+
+public class NodeExpressionStringConstructor(List<Token> tokens, NodeExpression value) : NodeExpression(tokens)
 {
-    public NodeType Type { get; } = type;
     public NodeExpression Value { get; } = value;
 }
 
@@ -924,6 +1066,8 @@ public class NodeTypeBool(List<Token> tokens) : NodeType(tokens);
 
 public class NodeTypeString(List<Token> tokens) : NodeType(tokens);
 
+public class NodeTypeChar(List<Token> tokens) : NodeType(tokens);
+
 public class NodeTypeNamed(List<Token> tokens, List<TokenIdent> sections) : NodeType(tokens)
 {
     public List<TokenIdent> Sections { get; } = sections;
@@ -940,6 +1084,11 @@ public class NodeTypeAnonymousStruct(List<Token> tokens, List<NodeTypeAnonymousS
     }
 }
 
+public class NodeTypeArray(List<Token> tokens, NodeType elementType) : NodeType(tokens)
+{
+    public NodeType ElementType { get; } = elementType;
+}
+
 public class NodeTypePointer(List<Token> tokens, NodeType to) : NodeType(tokens)
 {
     public NodeType To { get; } = to;
@@ -949,4 +1098,4 @@ public class NodeTypeFunc(List<Token> tokens, List<NodeType> parameters, NodeTyp
 {
     public List<NodeType> Parameters { get; } = parameters;
     public NodeType ReturnType { get; } = returnType;
-}
+}

compiler/Program.cs

@@ -128,18 +128,36 @@ else
     Directory.CreateDirectory(".build");
 }
 
-var output = Generator.Emit(functions, moduleGraph, compileLib);
-File.WriteAllText(".build/out.c", output);
+string? entryPoint = null;
+
+if (!compileLib)
+{
+    if (!moduleGraph.TryResolveIdentifier("main", "main", true, out var info) || info.Type is not NubTypeFunc entryPointType)
+    {
+        DiagnosticFormatter.Print(Diagnostic.Error("func main::main(): i32 is not defined. If you wanted to compile as a library, specify --type=lib").Build(), Console.Error);
+        return 1;
+    }
+
+    if (!entryPointType.ReturnType.IsAssignableTo(NubTypeSInt.Get(32)))
+    {
+        DiagnosticFormatter.Print(Diagnostic.Error($"Entrypoint must return an i32 (currently '{entryPointType.ReturnType}')").Build(), Console.Error);
+        return 1;
+    }
+
+    entryPoint = info.MangledName;
+}
+
+var outFile = Generator.Emit(functions, moduleGraph, entryPoint);
 
 if (compileLib)
 {
-    Process.Start("gcc", ["-Og", "-fvisibility=hidden", "-fno-builtin", "-c", "-o", ".build/out.o", ".build/out.c", .. archivePaths]).WaitForExit();
+    Process.Start("gcc", ["-Og", "-g", "-Wall", "-Werror", "-c", "-o", ".build/out.o", outFile, .. archivePaths]).WaitForExit();
     Process.Start("ar", ["rcs", ".build/out.a", ".build/out.o"]).WaitForExit();
     NubLib.Pack(".build/out.nublib", ".build/out.a", Manifest.Create(moduleGraph));
 }
 else
 {
-    Process.Start("gcc", ["-Og", "-fvisibility=hidden", "-fno-builtin", "-o", ".build/out", ".build/out.c", .. archivePaths]).WaitForExit();
+    Process.Start("gcc", ["-Og", "-g", "-Wall", "-Werror", "-o", ".build/out", outFile, .. archivePaths]).WaitForExit();
 }
 
 return 0;
@@ -158,4 +176,4 @@ static void CleanDirectory(string dirName)
         CleanDirectory(subdir.FullName);
         subdir.Delete();
     }
-}
+}

compiler/Tokenizer.cs

@@ -77,334 +77,348 @@ public class Tokenizer
             switch (c)
             {
                 case '0' when Peek(1) is 'x':
-                {
-                    Consume();
-                    Consume();
-
-                    var parsed = BigInteger.Zero;
-                    var seenDigit = false;
-
-                    while (TryPeek(out c))
                     {
-                        if (c == '_')
-                        {
-                            Consume();
-                            continue;
-                        }
-
-                        if (!char.IsAsciiHexDigit(c))
-                            break;
-
-                        seenDigit = true;
-                        parsed <<= 4;
-
                         Consume();
-                        parsed += c switch
+                        Consume();
+
+                        var parsed = BigInteger.Zero;
+                        var seenDigit = false;
+
+                        while (TryPeek(out c))
                         {
-                            >= '0' and <= '9' => c - '0',
-                            >= 'a' and <= 'f' => c - 'a' + 10,
-                            >= 'A' and <= 'F' => c - 'A' + 10,
-                            _ => 0
-                        };
+                            if (c == '_')
+                            {
+                                Consume();
+                                continue;
+                            }
+
+                            if (!char.IsAsciiHexDigit(c))
+                                break;
+
+                            seenDigit = true;
+                            parsed <<= 4;
+
+                            Consume();
+                            parsed += c switch
+                            {
+                                >= '0' and <= '9' => c - '0',
+                                >= 'a' and <= 'f' => c - 'a' + 10,
+                                >= 'A' and <= 'F' => c - 'A' + 10,
+                                _ => 0
+                            };
+                        }
+
+                        if (!seenDigit)
+                            throw new CompileException(Diagnostic.Error("Expected hexadecimal digits after 0x").At(fileName, line, startColumn, column - startColumn).Build());
+
+                        return new TokenIntLiteral(line, startColumn, column - startColumn, parsed);
                     }
-
-                    if (!seenDigit)
-                        throw new CompileException(Diagnostic.Error("Expected hexadecimal digits after 0x").At(fileName, line, startColumn, column - startColumn).Build());
-
-                    return new TokenIntLiteral(line, startColumn, column - startColumn, parsed);
-                }
                 case '0' when Peek(1) is 'b':
-                {
-                    Consume();
-                    Consume();
-
-                    var parsed = BigInteger.Zero;
-                    var seenDigit = false;
-
-                    while (TryPeek(out c))
                     {
-                        if (c == '_')
+                        Consume();
+                        Consume();
+
+                        var parsed = BigInteger.Zero;
+                        var seenDigit = false;
+
+                        while (TryPeek(out c))
                         {
-                            Consume();
-                            continue;
+                            if (c == '_')
+                            {
+                                Consume();
+                                continue;
+                            }
+
+                            if (c is not '0' and not '1')
+                                break;
+
+                            seenDigit = true;
+                            parsed <<= 1;
+
+                            if (Consume() == '1')
+                                parsed += BigInteger.One;
                         }
 
-                        if (c is not '0' and not '1')
-                            break;
+                        if (!seenDigit)
+                            throw new CompileException(Diagnostic.Error("Expected binary digits after 0b").At(fileName, line, startColumn, column - startColumn).Build());
 
-                        seenDigit = true;
-                        parsed <<= 1;
-
-                        if (Consume() == '1')
-                            parsed += BigInteger.One;
+                        return new TokenIntLiteral(line, startColumn, column - startColumn, parsed);
                     }
-
-                    if (!seenDigit)
-                        throw new CompileException(Diagnostic.Error("Expected binary digits after 0b").At(fileName, line, startColumn, column - startColumn).Build());
-
-                    return new TokenIntLiteral(line, startColumn, column - startColumn, parsed);
-                }
                 default:
-                {
-                    var parsed = BigInteger.Zero;
-
-                    while (TryPeek(out c))
                     {
-                        if (c == '_')
+                        var parsed = BigInteger.Zero;
+
+                        while (TryPeek(out c))
                         {
-                            Consume();
-                            continue;
+                            if (c == '_')
+                            {
+                                Consume();
+                                continue;
+                            }
+
+                            if (!char.IsDigit(c))
+                                break;
+
+                            parsed *= 10;
+                            parsed += Consume() - '0';
                         }
 
-                        if (!char.IsDigit(c))
-                            break;
-
-                        parsed *= 10;
-                        parsed += Consume() - '0';
+                        return new TokenIntLiteral(line, startColumn, column - startColumn, parsed);
                     }
-
-                    return new TokenIntLiteral(line, startColumn, column - startColumn, parsed);
-                }
             }
         }
 
         switch (c)
         {
             case '"':
-            {
-                Consume();
-                var buf = new StringBuilder();
-
-                while (true)
-                {
-                    if (!TryPeek(out c))
-                        throw new CompileException(Diagnostic.Error("Unterminated string literal").At(fileName, line, column, 0).Build());
-
-                    if (c == '"')
-                        break;
-
-                    if (c == '\n')
-                        throw new CompileException(Diagnostic.Error("Unterminated string literal").At(fileName, line, column, 1).Build());
-
-                    buf.Append(Consume());
-                }
-
-                Consume();
-                return new TokenStringLiteral(line, startColumn, column - startColumn, buf.ToString());
-            }
-
-            case '{':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.OpenCurly);
-            }
-            case '}':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.CloseCurly);
-            }
-            case '(':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.OpenParen);
-            }
-            case ')':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.CloseParen);
-            }
-            case ',':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Comma);
-            }
-            case '.':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Period);
-            }
-            case ':' when Peek(1) is ':':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.ColonColon);
-            }
-            case ':':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Colon);
-            }
-            case '^':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Caret);
-            }
-            case '!' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.BangEqual);
-            }
-            case '!':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Bang);
-            }
-            case '=' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.EqualEqual);
-            }
-            case '=':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Equal);
-            }
-            case '<' when Peek(1) is '<':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThanLessThan);
-            }
-            case '<' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThanEqual);
-            }
-            case '<':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThan);
-            }
-            case '>' when Peek(1) is '>':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.GreaterThanGreaterThan);
-            }
-            case '>' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.GreaterThanEqual);
-            }
-            case '>':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.GreaterThan);
-            }
-            case '+' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PlusEqual);
-            }
-            case '+':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Plus);
-            }
-            case '-' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.MinusEqual);
-            }
-            case '-':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Minus);
-            }
-            case '*' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.StarEqual);
-            }
-            case '*':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Star);
-            }
-            case '/' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.ForwardSlashEqual);
-            }
-            case '/':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.ForwardSlash);
-            }
-            case '%' when Peek(1) is '=':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PercentEqual);
-            }
-            case '%':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Percent);
-            }
-            case '&' when Peek(1) is '&':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.AmpersandAmpersand);
-            }
-            case '&':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Ampersand);
-            }
-            case '|' when Peek(1) is '|':
-            {
-                Consume();
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PipePipe);
-            }
-            case '|':
-            {
-                Consume();
-                return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Pipe);
-            }
-            default:
-            {
-                if (char.IsLetter(c) || c == '_')
                 {
+                    Consume();
                     var buf = new StringBuilder();
 
-                    while (TryPeek(out c) && (char.IsLetterOrDigit(c) || c == '_'))
-                        buf.Append(Consume());
-
-                    var value = buf.ToString();
-
-                    return value switch
+                    while (true)
                     {
-                        "func" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Func),
-                        "struct" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Struct),
-                        "packed" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Packed),
-                        "enum" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Enum),
-                        "match" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Match),
-                        "let" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Let),
-                        "if" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.If),
-                        "else" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Else),
-                        "while" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.While),
-                        "return" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Return),
-                        "module" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Module),
-                        "export" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Export),
-                        "true" => new TokenBoolLiteral(line, startColumn, column - startColumn, true),
-                        "false" => new TokenBoolLiteral(line, startColumn, column - startColumn, false),
-                        _ => new TokenIdent(line, startColumn, column - startColumn, value)
-                    };
+                        if (!TryPeek(out c))
+                            throw new CompileException(Diagnostic.Error("Unterminated string literal").At(fileName, line, column, 0).Build());
+
+                        if (c == '"')
+                            break;
+
+                        if (c == '\n')
+                            throw new CompileException(Diagnostic.Error("Unterminated string literal").At(fileName, line, column, 1).Build());
+
+                        buf.Append(Consume());
+                    }
+
+                    Consume();
+                    return new TokenStringLiteral(line, startColumn, column - startColumn, buf.ToString());
                 }
 
-                throw new CompileException(Diagnostic.Error($"Unexpected character '{c}'").At(fileName, line, column, 1).Build());
-            }
+            case '{':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.OpenCurly);
+                }
+            case '}':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.CloseCurly);
+                }
+            case '[':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.OpenSquare);
+                }
+            case ']':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.CloseSquare);
+                }
+            case '(':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.OpenParen);
+                }
+            case ')':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.CloseParen);
+                }
+            case ',':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Comma);
+                }
+            case '.':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Period);
+                }
+            case ':' when Peek(1) is ':':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.ColonColon);
+                }
+            case ':':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Colon);
+                }
+            case '^':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Caret);
+                }
+            case '!' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.BangEqual);
+                }
+            case '!':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Bang);
+                }
+            case '=' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.EqualEqual);
+                }
+            case '=':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Equal);
+                }
+            case '<' when Peek(1) is '<':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThanLessThan);
+                }
+            case '<' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThanEqual);
+                }
+            case '<':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.LessThan);
+                }
+            case '>' when Peek(1) is '>':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.GreaterThanGreaterThan);
+                }
+            case '>' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.GreaterThanEqual);
+                }
+            case '>':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.GreaterThan);
+                }
+            case '+' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PlusEqual);
+                }
+            case '+':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Plus);
+                }
+            case '-' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.MinusEqual);
+                }
+            case '-':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Minus);
+                }
+            case '*' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.StarEqual);
+                }
+            case '*':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Star);
+                }
+            case '/' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.ForwardSlashEqual);
+                }
+            case '/':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.ForwardSlash);
+                }
+            case '%' when Peek(1) is '=':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PercentEqual);
+                }
+            case '%':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Percent);
+                }
+            case '&' when Peek(1) is '&':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.AmpersandAmpersand);
+                }
+            case '&':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Ampersand);
+                }
+            case '|' when Peek(1) is '|':
+                {
+                    Consume();
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.PipePipe);
+                }
+            case '|':
+                {
+                    Consume();
+                    return new TokenSymbol(line, startColumn, column - startColumn, Symbol.Pipe);
+                }
+            default:
+                {
+                    if (char.IsLetter(c) || c == '_')
+                    {
+                        var buf = new StringBuilder();
+
+                        while (TryPeek(out c) && (char.IsLetterOrDigit(c) || c == '_'))
+                            buf.Append(Consume());
+
+                        var value = buf.ToString();
+
+                        return value switch
+                        {
+                            "func" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Func),
+                            "struct" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Struct),
+                            "packed" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Packed),
+                            "enum" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Enum),
+                            "new" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.New),
+                            "match" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Match),
+                            "let" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Let),
+                            "if" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.If),
+                            "else" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Else),
+                            "while" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.While),
+                            "for" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.For),
+                            "in" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.In),
+                            "return" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Return),
+                            "module" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Module),
+                            "export" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Export),
+                            "extern" => new TokenKeyword(line, startColumn, column - startColumn, Keyword.Extern),
+                            "true" => new TokenBoolLiteral(line, startColumn, column - startColumn, true),
+                            "false" => new TokenBoolLiteral(line, startColumn, column - startColumn, false),
+                            _ => new TokenIdent(line, startColumn, column - startColumn, value)
+                        };
+                    }
+
+                    throw new CompileException(Diagnostic.Error($"Unexpected character '{c}'").At(fileName, line, column, 1).Build());
+                }
         }
     }
 
@@ -495,6 +509,8 @@ public enum Symbol
     CloseCurly,
     OpenParen,
     CloseParen,
+    OpenSquare,
+    CloseSquare,
     Comma,
     Period,
     Colon,
@@ -537,14 +553,18 @@ public enum Keyword
     Struct,
     Packed,
     Enum,
+    New,
     Match,
     Let,
     If,
     Else,
     While,
+    For,
+    In,
     Return,
     Module,
     Export,
+    Extern,
 }
 
 public class TokenKeyword(int line, int column, int length, Keyword keyword) : Token(line, column, length)
@@ -562,6 +582,8 @@ public static class TokenExtensions
             Symbol.CloseCurly => "}",
             Symbol.OpenParen => "(",
             Symbol.CloseParen => ")",
+            Symbol.OpenSquare => "[",
+            Symbol.CloseSquare => "]",
             Symbol.Comma => ",",
             Symbol.Period => ".",
             Symbol.Colon => ":",
@@ -603,14 +625,18 @@ public static class TokenExtensions
             Keyword.Struct => "struct",
             Keyword.Packed => "packed",
             Keyword.Enum => "enum",
+            Keyword.New => "new",
             Keyword.Match => "enum",
             Keyword.Let => "let",
             Keyword.If => "if",
             Keyword.Else => "else",
             Keyword.While => "while",
+            Keyword.For => "for",
+            Keyword.In => "in",
             Keyword.Return => "return",
             Keyword.Module => "module",
             Keyword.Export => "export",
+            Keyword.Extern => "extern",
             _ => throw new ArgumentOutOfRangeException(nameof(symbol), symbol, null)
         };
     }

compiler/TypeChecker.cs

@@ -24,7 +24,7 @@ public class TypeChecker
     private readonly NodeDefinitionFunc function;
     private NubType functionReturnType = null!;
     private readonly ModuleGraph moduleGraph;
-    private readonly Scope scope = new();
+    private readonly Stack<Dictionary<string, NubType>> scopes = new();
 
     private TypedNodeDefinitionFunc? CheckFunction(out List<Diagnostic> diagnostics)
     {
@@ -34,17 +34,24 @@ public class TypeChecker
         var invalidParameter = false;
         TypedNodeStatement? body = null;
 
-        try
+        if (function.ReturnType == null)
         {
-            functionReturnType = ResolveType(function.ReturnType);
+            functionReturnType = NubTypeVoid.Instance;
         }
-        catch (CompileException e)
+        else
         {
-            diagnostics.Add(e.Diagnostic);
-            return null;
+            try
+            {
+                functionReturnType = ResolveType(function.ReturnType);
+            }
+            catch (CompileException e)
+            {
+                diagnostics.Add(e.Diagnostic);
+                return null;
+            }
         }
 
-        using (scope.EnterScope())
+        using (EnterScope())
         {
             foreach (var parameter in function.Parameters)
             {
@@ -53,6 +60,7 @@ public class TypeChecker
                 try
                 {
                     parameterType = ResolveType(parameter.Type);
+                    DeclareLocalIdentifier(parameter.Name, parameterType);
                 }
                 catch (CompileException e)
                 {
@@ -61,7 +69,6 @@ public class TypeChecker
                     continue;
                 }
 
-                scope.DeclareIdentifier(parameter.Name.Ident, parameterType);
                 parameters.Add(new TypedNodeDefinitionFunc.Param(parameter.Tokens, parameter.Name, parameterType));
             }
 
@@ -92,6 +99,7 @@ public class TypeChecker
             NodeStatementReturn statement => CheckStatementReturn(statement),
             NodeStatementVariableDeclaration statement => CheckStatementVariableDeclaration(statement),
             NodeStatementWhile statement => CheckStatementWhile(statement),
+            NodeStatementFor statement => CheckStatementFor(statement),
             NodeStatementMatch statement => CheckStatementMatch(statement),
             _ => throw new ArgumentOutOfRangeException(nameof(node))
         };
@@ -107,7 +115,7 @@ public class TypeChecker
 
     private TypedNodeStatementBlock CheckStatementBlock(NodeStatementBlock statement)
     {
-        using (scope.EnterScope())
+        using (EnterScope())
         {
             var statements = statement.Statements.Select(CheckStatement).ToList();
             return new TypedNodeStatementBlock(statement.Tokens, statements);
@@ -119,20 +127,9 @@ public class TypeChecker
         if (statement.Expression is not NodeExpressionFuncCall funcCall)
             throw BasicError("Expected statement or function call", statement);
 
-        var target = CheckExpression(funcCall.Target, null);
-        if (target.Type is not NubTypeFunc funcType)
-            throw BasicError("Expected a function type", target);
+        var expr = CheckExpressionFuncCall(funcCall, null);
 
-        if (funcType.Parameters.Count != funcCall.Parameters.Count)
-            throw BasicError($"Expected {funcType.Parameters.Count} parameters but got {funcCall.Parameters.Count}", funcCall);
-
-        var parameters = new List<TypedNodeExpression>();
-        for (int i = 0; i < funcCall.Parameters.Count; i++)
-        {
-            parameters.Add(CheckExpression(funcCall.Parameters[i], funcType.Parameters[i]));
-        }
-
-        return new TypedNodeStatementFuncCall(statement.Tokens, target, parameters);
+        return new TypedNodeStatementFuncCall(expr.Tokens, expr.Target, expr.Parameters);
     }
 
     private TypedNodeStatementIf CheckStatementIf(NodeStatementIf statement)
@@ -141,19 +138,40 @@ public class TypeChecker
         if (!condition.Type.IsAssignableTo(NubTypeBool.Instance))
             throw BasicError("Condition part of if statement must be a boolean", condition);
 
-        var thenBlock = CheckStatement(statement.ThenBlock);
-        var elseBlock = statement.ElseBlock == null ? null : CheckStatement(statement.ElseBlock);
+        TypedNodeStatement thenBlock;
+
+        using (EnterScope())
+        {
+            thenBlock = CheckStatement(statement.ThenBlock);
+        }
+
+        TypedNodeStatement? elseBlock;
+
+        using (EnterScope())
+        {
+            elseBlock = statement.ElseBlock == null ? null : CheckStatement(statement.ElseBlock);
+        }
 
         return new TypedNodeStatementIf(statement.Tokens, condition, thenBlock, elseBlock);
     }
 
     private TypedNodeStatementReturn CheckStatementReturn(NodeStatementReturn statement)
     {
-        var value = CheckExpression(statement.Value, functionReturnType);
-        if (!value.Type.IsAssignableTo(functionReturnType))
-            throw BasicError($"Type of returned value ({value.Type}) is not assignable to the return type of the function ({functionReturnType})", value);
+        if (statement.Value == null)
+        {
+            if (functionReturnType is not NubTypeVoid)
+                throw BasicError($"Missing return value. Expected '{functionReturnType}'", statement);
 
-        return new TypedNodeStatementReturn(statement.Tokens, value);
+            return new TypedNodeStatementReturn(statement.Tokens, null);
+        }
+        else
+        {
+            var value = CheckExpression(statement.Value, functionReturnType);
+            if (!value.Type.IsAssignableTo(functionReturnType))
+                throw BasicError($"Type of returned value ({value.Type}) is not assignable to the return type of the function ({functionReturnType})", value);
+
+            return new TypedNodeStatementReturn(statement.Tokens, value);
+        }
     }
 
     private TypedNodeStatementVariableDeclaration CheckStatementVariableDeclaration(NodeStatementVariableDeclaration statement)
@@ -169,7 +187,7 @@ public class TypeChecker
 
         type ??= value.Type;
 
-        scope.DeclareIdentifier(statement.Name.Ident, type);
+        DeclareLocalIdentifier(statement.Name, type);
 
         return new TypedNodeStatementVariableDeclaration(statement.Tokens, statement.Name, type, value);
     }
@@ -180,9 +198,27 @@ public class TypeChecker
         if (!condition.Type.IsAssignableTo(NubTypeBool.Instance))
             throw BasicError("Condition part of if statement must be a boolean", condition);
 
-        var body = CheckStatement(statement.Body);
+        using (EnterScope())
+        {
+            var body = CheckStatement(statement.Body);
+            return new TypedNodeStatementWhile(statement.Tokens, condition, body);
+        }
+    }
 
-        return new TypedNodeStatementWhile(statement.Tokens, condition, body);
+    private TypedNodeStatementFor CheckStatementFor(NodeStatementFor statement)
+    {
+        var array = CheckExpression(statement.Array, null);
+        if (array.Type is not NubTypeArray arrayType)
+            throw BasicError($"Cannot iterate over non-array type '{array.Type}'", statement.Array);
+
+        TypedNodeStatement body;
+        using (EnterScope())
+        {
+            DeclareLocalIdentifier(statement.VariableName, arrayType.ElementType);
+            body = CheckStatement(statement.Body);
+        }
+
+        return new TypedNodeStatementFor(statement.Tokens, statement.VariableName, array, body);
     }
 
     private TypedNodeStatementMatch CheckStatementMatch(NodeStatementMatch statement)
@@ -202,21 +238,30 @@ public class TypeChecker
         var cases = new List<TypedNodeStatementMatch.Case>();
         foreach (var @case in statement.Cases)
         {
-            if (!enumInfo.Variants.Any(x => x.Name == @case.Variant.Ident))
+            var variant = enumInfo.Variants.FirstOrDefault(x => x.Name == @case.Variant.Ident);
+            if (variant == null)
                 throw BasicError($"Enum type'{enumType}' does not have a variant named '{@case.Variant.Ident}'", @case.Variant);
 
             uncoveredCases.Remove(@case.Variant.Ident);
 
-            using (scope.EnterScope())
+            using (EnterScope())
             {
-                scope.DeclareIdentifier(@case.VariableName.Ident, NubTypeEnumVariant.Get(NubTypeEnum.Get(enumType.Module, enumType.Name), @case.Variant.Ident));
+                if (@case.VariableName != null)
+                {
+                    if (variant.Type is null)
+                        throw BasicError("Cannot capture variable for enum variant without type", @case.VariableName);
+
+                    DeclareLocalIdentifier(@case.VariableName, variant.Type);
+                }
+
                 var body = CheckStatement(@case.Body);
+
                 cases.Add(new TypedNodeStatementMatch.Case(@case.Tokens, @case.Variant, @case.VariableName, body));
             }
         }
 
         if (uncoveredCases.Any())
-            throw BasicError($"Match statement does not cover the following cases: {string.Join(", ",  uncoveredCases)}", statement);
+            throw BasicError($"Match statement does not cover the following cases: {string.Join(", ", uncoveredCases)}", statement);
 
         return new TypedNodeStatementMatch(statement.Tokens, target, cases);
     }
@@ -235,6 +280,8 @@ public class TypeChecker
             NodeExpressionStringLiteral expression => CheckExpressionStringLiteral(expression, expectedType),
             NodeExpressionStructLiteral expression => CheckExpressionStructLiteral(expression, expectedType),
             NodeExpressionEnumLiteral expression => CheckExpressionEnumLiteral(expression, expectedType),
+            NodeExpressionStringConstructor expression => CheckExpressionStringConstructor(expression, expectedType),
+            NodeExpressionArrayLiteral expression => CheckExpressionArrayLiteral(expression, expectedType),
             _ => throw new ArgumentOutOfRangeException(nameof(node))
         };
     }
@@ -249,6 +296,24 @@ public class TypeChecker
         switch (expression.Operation)
         {
             case NodeExpressionBinary.Op.Add:
+                {
+                    if (left.Type is NubTypeString)
+                    {
+                        if (right.Type is not NubTypeString)
+                            throw BasicError("Right hand side of string concatination operator must be a string", right);
+
+                        return new TypedNodeExpressionBinary(expression.Tokens, NubTypeString.Instance, left, CheckExpressionBinaryOperation(expression.Operation), right);
+                    }
+
+                    if (left.Type is not NubTypeSInt and not NubTypeUInt)
+                        throw BasicError($"Unsupported type for left hand side arithmetic operation: {left.Type}", left);
+
+                    if (right.Type is not NubTypeSInt and not NubTypeUInt)
+                        throw BasicError($"Unsupported type for right hand side arithmetic operation: {right.Type}", right);
+
+                    type = left.Type;
+                    break;
+                }
             case NodeExpressionBinary.Op.Subtract:
             case NodeExpressionBinary.Op.Multiply:
             case NodeExpressionBinary.Op.Divide:
@@ -383,14 +448,14 @@ public class TypeChecker
     {
         if (expression.Sections.Count == 1)
         {
-            var name = expression.Sections[0].Ident;
+            var name = expression.Sections[0];
 
-            var localType = scope.GetIdentifierType(name);
+            var localType = GetIdentifierType(name.Ident);
             if (localType is not null)
-                return new TypedNodeExpressionLocalIdent(expression.Tokens, localType, name);
+                return new TypedNodeExpressionLocalIdent(expression.Tokens, localType, name.Ident);
 
-            if (moduleGraph.TryResolveIdentifier(currentModule, name, true, out var ident))
-                return new TypedNodeExpressionGlobalIdent(expression.Tokens, ident.Type, currentModule, name);
+            if (moduleGraph.TryResolveIdentifier(currentModule, name.Ident, true, out var ident))
+                return new TypedNodeExpressionGlobalIdent(expression.Tokens, ident.Type, currentModule, name.Ident);
         }
         else if (expression.Sections.Count == 2)
         {
@@ -406,49 +471,71 @@ public class TypeChecker
 
     private TypedNodeExpressionIntLiteral CheckExpressionIntLiteral(NodeExpressionIntLiteral expression, NubType? expectedType)
     {
-        return new TypedNodeExpressionIntLiteral(expression.Tokens, NubTypeSInt.Get(32), expression.Value);
+        NubType? type = null;
+
+        if (expectedType is NubTypeSInt or NubTypeUInt)
+            type = expectedType;
+
+        type ??= NubTypeSInt.Get(32);
+
+        return new TypedNodeExpressionIntLiteral(expression.Tokens, type, expression.Value);
     }
 
-    private TypedNodeExpressionMemberAccess CheckExpressionMemberAccess(NodeExpressionMemberAccess expression, NubType? expectedType)
+    private TypedNodeExpression CheckExpressionMemberAccess(NodeExpressionMemberAccess expression, NubType? expectedType)
     {
         var target = CheckExpression(expression.Target, null);
 
         switch (target.Type)
         {
+            case NubTypeString stringType:
+                {
+                    switch (expression.Name.Ident)
+                    {
+                        case "length":
+                            return new TypedNodeExpressionStringLength(expression.Tokens, NubTypeUInt.Get(64), target);
+                        case "ptr":
+                            return new TypedNodeExpressionStringPointer(expression.Tokens, NubTypePointer.Get(NubTypeChar.Instance), target);
+                        default:
+                            throw BasicError($"'{expression.Name.Ident}' is not a member of type {stringType}", expression.Name);
+                    }
+                }
+            case NubTypeArray arrayType:
+                {
+                    switch (expression.Name.Ident)
+                    {
+                        case "count":
+                            return new TypedNodeExpressionArrayCount(expression.Tokens, NubTypeUInt.Get(64), target);
+                        case "ptr":
+                            return new TypedNodeExpressionArrayPointer(expression.Tokens, NubTypePointer.Get(arrayType.ElementType), target);
+                        default:
+                            throw BasicError($"'{expression.Name.Ident}' is not a member of type {arrayType}", expression.Name);
+                    }
+                }
             case NubTypeStruct structType:
-            {
-                if (!moduleGraph.TryResolveModule(structType.Module, out var module))
-                    throw BasicError($"Module '{structType.Module}' not found", expression.Target);
+                {
+                    if (!moduleGraph.TryResolveModule(structType.Module, out var module))
+                        throw BasicError($"Module '{structType.Module}' not found", expression.Target);
 
-                if (!module.TryResolveType(structType.Name, currentModule == structType.Module, out var typeDef))
-                    throw BasicError($"Type '{structType.Name}' not found in module '{structType.Module}'", expression.Target);
+                    if (!module.TryResolveType(structType.Name, currentModule == structType.Module, out var typeDef))
+                        throw BasicError($"Type '{structType.Name}' not found in module '{structType.Module}'", expression.Target);
 
-                if (typeDef is not Module.TypeInfoStruct structDef)
-                    throw BasicError($"Type '{target.Type}' is not a struct", expression.Target);
+                    if (typeDef is not Module.TypeInfoStruct structDef)
+                        throw BasicError($"Type '{target.Type}' is not a struct", expression.Target);
 
-                var field = structDef.Fields.FirstOrDefault(x => x.Name == expression.Name.Ident);
-                if (field == null)
-                    throw BasicError($"Struct '{target.Type}' does not have a field matching the name '{expression.Name.Ident}'", target);
+                    var field = structDef.Fields.FirstOrDefault(x => x.Name == expression.Name.Ident);
+                    if (field == null)
+                        throw BasicError($"Struct '{target.Type}' does not have a field matching the name '{expression.Name.Ident}'", target);
 
-                return new TypedNodeExpressionMemberAccess(expression.Tokens, field.Type, target, expression.Name);
-            }
-            case NubTypeEnumVariant enumVariantType:
-            {
-                if (!moduleGraph.TryResolveModule(enumVariantType.EnumType.Module, out var module))
-                    throw BasicError($"Module '{enumVariantType.EnumType.Module}' not found", expression.Target);
+                    return new TypedNodeExpressionStructMemberAccess(expression.Tokens, field.Type, target, expression.Name);
+                }
+            case NubTypeAnonymousStruct anonymousStructType:
+                {
+                    var field = anonymousStructType.Fields.FirstOrDefault(x => x.Name == expression.Name.Ident);
+                    if (field == null)
+                        throw BasicError($"Struct '{target.Type}' does not have a field matching the name '{expression.Name.Ident}'", target);
 
-                if (!module.TryResolveType(enumVariantType.EnumType.Name, currentModule == enumVariantType.EnumType.Module, out var typeDef))
-                    throw BasicError($"Type '{enumVariantType.EnumType.Name}' not found in module '{enumVariantType.EnumType.Module}'", expression.Target);
-
-                if (typeDef is not Module.TypeInfoEnum enumDef)
-                    throw BasicError($"Type '{enumVariantType.EnumType.Module}::{enumVariantType.EnumType.Name}' is not an enum", expression.Target);
-
-                var variant = enumDef.Variants.FirstOrDefault(x => x.Name == enumVariantType.Variant);
-                if (variant == null)
-                    throw BasicError($"Type '{target.Type}' does not have a variant named '{enumVariantType.Variant}'", expression.Target);
-
-                return new TypedNodeExpressionMemberAccess(expression.Tokens, variant.Type, target, expression.Name);
-            }
+                    return new TypedNodeExpressionStructMemberAccess(expression.Tokens, field.Type, target, expression.Name);
+                }
             default:
                 throw BasicError($"{target.Type} has no member '{expression.Name.Ident}'", target);
         }
@@ -466,7 +553,11 @@ public class TypeChecker
         var parameters = new List<TypedNodeExpression>();
         for (int i = 0; i < expression.Parameters.Count; i++)
         {
-            parameters.Add(CheckExpression(expression.Parameters[i], funcType.Parameters[i]));
+            var parameter = CheckExpression(expression.Parameters[i], funcType.Parameters[i]);
+            if (!parameter.Type.IsAssignableTo(funcType.Parameters[i]))
+                throw BasicError($"Parameter {i + 1} ({parameter.Type}) does is not assignable to '{funcType.Parameters[i]}'", parameter);
+
+            parameters.Add(parameter);
         }
 
         return new TypedNodeExpressionFuncCall(expression.Tokens, funcType.ReturnType, target, parameters);
@@ -484,7 +575,7 @@ public class TypeChecker
             var type = ResolveType(expression.Type);
             if (type is not NubTypeStruct structType)
                 throw BasicError("Type of struct literal is not a struct", expression);
-            
+
             if (!moduleGraph.TryResolveType(structType.Module, structType.Name, structType.Module == currentModule, out var info))
                 throw BasicError($"Type '{structType}' struct literal not found", expression);
 
@@ -531,7 +622,24 @@ public class TypeChecker
 
             return new TypedNodeExpressionStructLiteral(expression.Tokens, structType, initializers);
         }
-        // todo(nub31): Infer anonymous struct types if expectedType is anonymous struct
+        else if (expectedType is NubTypeAnonymousStruct anonymousStructType)
+        {
+            var initializers = new List<TypedNodeExpressionStructLiteral.Initializer>();
+            foreach (var initializer in expression.Initializers)
+            {
+                var field = anonymousStructType.Fields.FirstOrDefault(x => x.Name == initializer.Name.Ident);
+                if (field == null)
+                    throw BasicError($"Field '{initializer.Name.Ident}' does not exist on anonymous struct '{anonymousStructType}'", initializer.Name);
+
+                var value = CheckExpression(initializer.Value, field.Type);
+                if (!value.Type.IsAssignableTo(field.Type))
+                    throw BasicError($"Type of assignment ({value.Type}) does not match expected type of field '{field.Name}' ({field.Type})", initializer.Name);
+
+                initializers.Add(new TypedNodeExpressionStructLiteral.Initializer(initializer.Tokens, initializer.Name, value));
+            }
+
+            return new TypedNodeExpressionStructLiteral(expression.Tokens, anonymousStructType, initializers);
+        }
         else
         {
             var initializers = new List<TypedNodeExpressionStructLiteral.Initializer>();
@@ -563,10 +671,53 @@ public class TypeChecker
         if (variant == null)
             throw BasicError($"Enum '{variantType.EnumType}' does not have a variant named '{variantType.Variant}'", expression.Type);
 
-        var value = CheckExpression(expression.Value, variant.Type);
+        if (expression.Value == null && variant.Type is not null)
+            throw BasicError($"Enum variant '{variantType}' expects a value of type '{variant.Type}'", expression.Type);
+
+        if (expression.Value != null && variant.Type is null)
+            throw BasicError($"Enum variant '{variantType}' does not expect any data", expression.Value);
+
+        var value = expression.Value == null ? null : CheckExpression(expression.Value, variant.Type);
+
         return new TypedNodeExpressionEnumLiteral(expression.Tokens, type, value);
     }
 
+    private TypedNodeExpressionStringConstructor CheckExpressionStringConstructor(NodeExpressionStringConstructor expression, NubType? expectedType)
+    {
+        var stringPoitnerType = NubTypePointer.Get(NubTypeChar.Instance);
+
+        var value = CheckExpression(expression.Value, stringPoitnerType);
+        if (!value.Type.IsAssignableTo(stringPoitnerType))
+            throw BasicError($"Value of string constructor must be assignable to {stringPoitnerType}", value);
+
+        return new TypedNodeExpressionStringConstructor(expression.Tokens, NubTypeString.Instance, value);
+    }
+
+    private TypedNodeExpressionArrayLiteral CheckExpressionArrayLiteral(NodeExpressionArrayLiteral expression, NubType? expectedType)
+    {
+        NubType? elementType = null;
+        if (expectedType is NubTypeArray arrayType)
+            elementType = arrayType.ElementType;
+
+        var values = new List<TypedNodeExpression>();
+
+        foreach (var value in expression.Values)
+        {
+            var checkedValue = CheckExpression(value, elementType);
+            elementType ??= checkedValue.Type;
+
+            if (!checkedValue.Type.IsAssignableTo(elementType))
+                throw BasicError($"Type '{checkedValue.Type}' is not assignable to type of element '{elementType}'", checkedValue);
+
+            values.Add(checkedValue);
+        }
+
+        if (elementType is null)
+            throw BasicError("Unable to infer type of array element", expression);
+
+        return new TypedNodeExpressionArrayLiteral(expression.Tokens, NubTypeArray.Get(elementType), values);
+    }
+
     private NubType ResolveType(NodeType node)
     {
         return node switch
@@ -580,6 +731,7 @@ public class TypeChecker
             NodeTypeUInt type => NubTypeUInt.Get(type.Width),
             NodeTypeString => NubTypeString.Instance,
             NodeTypeVoid => NubTypeVoid.Instance,
+            NodeTypeArray type => NubTypeArray.Get(ResolveType(type.ElementType)),
             _ => throw new ArgumentOutOfRangeException(nameof(node))
         };
     }
@@ -684,45 +836,44 @@ public class TypeChecker
         return new CompileException(Diagnostic.Error(message).At(fileName, node).Build());
     }
 
-    private sealed class Scope
+    public void DeclareLocalIdentifier(TokenIdent name, NubType type)
     {
-        private readonly Stack<Dictionary<string, NubType>> scopes = new();
+        var existing = GetIdentifierType(name.Ident);
+        if (existing is not null)
+            throw BasicError($"Local identifier '{name.Ident}' is already defined", name);
 
-        public IDisposable EnterScope()
-        {
-            scopes.Push([]);
-            return new ScopeGuard(this);
-        }
+        scopes.Peek().Add(name.Ident, type);
+    }
 
-        public void DeclareIdentifier(string name, NubType type)
+    public NubType? GetIdentifierType(string name)
+    {
+        foreach (var scope in scopes)
         {
-            scopes.Peek().Add(name, type);
-        }
-
-        public NubType? GetIdentifierType(string name)
-        {
-            foreach (var scope in scopes)
+            if (scope.TryGetValue(name, out var type))
             {
-                if (scope.TryGetValue(name, out var type))
-                {
-                    return type;
-                }
+                return type;
             }
-
-            return null;
         }
 
-        private void ExitScope()
-        {
-            scopes.Pop();
-        }
+        return null;
+    }
 
-        private sealed class ScopeGuard(Scope owner) : IDisposable
+    public IDisposable EnterScope()
+    {
+        scopes.Push([]);
+        return new ScopeGuard(this);
+    }
+
+    private void ExitScope()
+    {
+        scopes.Pop();
+    }
+
+    private sealed class ScopeGuard(TypeChecker owner) : IDisposable
+    {
+        public void Dispose()
         {
-            public void Dispose()
-            {
-                owner.ExitScope();
-            }
+            owner.ExitScope();
         }
     }
 }
@@ -769,9 +920,9 @@ public class TypedNodeStatementFuncCall(List<Token> tokens, TypedNodeExpression
     public List<TypedNodeExpression> Parameters { get; } = parameters;
 }
 
-public class TypedNodeStatementReturn(List<Token> tokens, TypedNodeExpression value) : TypedNodeStatement(tokens)
+public class TypedNodeStatementReturn(List<Token> tokens, TypedNodeExpression? value) : TypedNodeStatement(tokens)
 {
-    public TypedNodeExpression Value { get; } = value;
+    public TypedNodeExpression? Value { get; } = value;
 }
 
 public class TypedNodeStatementVariableDeclaration(List<Token> tokens, TokenIdent name, NubType type, TypedNodeExpression value) : TypedNodeStatement(tokens)
@@ -800,15 +951,22 @@ public class TypedNodeStatementWhile(List<Token> tokens, TypedNodeExpression con
     public TypedNodeStatement Body { get; } = body;
 }
 
+public class TypedNodeStatementFor(List<Token> tokens, TokenIdent variableName, TypedNodeExpression array, TypedNodeStatement body) : TypedNodeStatement(tokens)
+{
+    public TokenIdent VariableName { get; } = variableName;
+    public TypedNodeExpression Array { get; } = array;
+    public TypedNodeStatement Body { get; } = body;
+}
+
 public class TypedNodeStatementMatch(List<Token> tokens, TypedNodeExpression target, List<TypedNodeStatementMatch.Case> cases) : TypedNodeStatement(tokens)
 {
     public TypedNodeExpression Target { get; } = target;
     public List<Case> Cases { get; } = cases;
 
-    public class Case(List<Token> tokens, TokenIdent type, TokenIdent variableName, TypedNodeStatement body) : Node(tokens)
+    public class Case(List<Token> tokens, TokenIdent type, TokenIdent? variableName, TypedNodeStatement body) : Node(tokens)
     {
         public TokenIdent Variant { get; } = type;
-        public TokenIdent VariableName { get; } = variableName;
+        public TokenIdent? VariableName { get; } = variableName;
         public TypedNodeStatement Body { get; } = body;
     }
 }
@@ -844,17 +1002,47 @@ public class TypedNodeExpressionStructLiteral(List<Token> tokens, NubType type,
     }
 }
 
-public class TypedNodeExpressionEnumLiteral(List<Token> tokens, NubType type, TypedNodeExpression value) : TypedNodeExpression(tokens, type)
+public class TypedNodeExpressionEnumLiteral(List<Token> tokens, NubType type, TypedNodeExpression? value) : TypedNodeExpression(tokens, type)
+{
+    public TypedNodeExpression? Value { get; } = value;
+}
+
+public class TypedNodeExpressionStringConstructor(List<Token> tokens, NubType type, TypedNodeExpression value) : TypedNodeExpression(tokens, type)
 {
     public TypedNodeExpression Value { get; } = value;
 }
 
-public class TypedNodeExpressionMemberAccess(List<Token> tokens, NubType type, TypedNodeExpression target, TokenIdent name) : TypedNodeExpression(tokens, type)
+public class TypedNodeExpressionArrayLiteral(List<Token> tokens, NubType type, List<TypedNodeExpression> values) : TypedNodeExpression(tokens, type)
+{
+    public List<TypedNodeExpression> Values { get; } = values;
+}
+
+public class TypedNodeExpressionStructMemberAccess(List<Token> tokens, NubType type, TypedNodeExpression target, TokenIdent name) : TypedNodeExpression(tokens, type)
 {
     public TypedNodeExpression Target { get; } = target;
     public TokenIdent Name { get; } = name;
 }
 
+public class TypedNodeExpressionStringLength(List<Token> tokens, NubType type, TypedNodeExpression target) : TypedNodeExpression(tokens, type)
+{
+    public TypedNodeExpression Target { get; } = target;
+}
+
+public class TypedNodeExpressionStringPointer(List<Token> tokens, NubType type, TypedNodeExpression target) : TypedNodeExpression(tokens, type)
+{
+    public TypedNodeExpression Target { get; } = target;
+}
+
+public class TypedNodeExpressionArrayCount(List<Token> tokens, NubType type, TypedNodeExpression target) : TypedNodeExpression(tokens, type)
+{
+    public TypedNodeExpression Target { get; } = target;
+}
+
+public class TypedNodeExpressionArrayPointer(List<Token> tokens, NubType type, TypedNodeExpression target) : TypedNodeExpression(tokens, type)
+{
+    public TypedNodeExpression Target { get; } = target;
+}
+
 public class TypedNodeExpressionFuncCall(List<Token> tokens, NubType type, TypedNodeExpression target, List<TypedNodeExpression> parameters) : TypedNodeExpression(tokens, type)
 {
     public TypedNodeExpression Target { get; } = target;
@@ -915,4 +1103,4 @@ public class TypedNodeExpressionUnary(List<Token> tokens, NubType type, TypedNod
         Negate,
         Invert,
     }
-}
+}

examples/build

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -e
+
+SCRIPT_DIR=$(dirname "$0")
+
+pushd $SCRIPT_DIR
+    pushd ../compiler
+        dotnet build -c Release
+    popd
+
+    pushd core
+        time ../../compiler/bin/Release/net9.0/Compiler sys.nub print.nub --type=lib
+    popd
+
+    pushd program
+        time ../../compiler/bin/Release/net9.0/Compiler main.nub ../core/.build/out.nublib
+    popd
+
+    ./program/.build/out
+popd

examples/build.sh

@@ -1,12 +0,0 @@
-set -e
-
-pushd math
-dotnet run --project ../../compiler math.nub --type=lib
-# pushd .build
-# unzip out.nublib
-# popd
-popd
-
-pushd program
-dotnet run --project ../../compiler main.nub ../math/.build/out.nublib
-popd

examples/core/print.nub

@@ -0,0 +1,10 @@
+module core
+
+export func print(text: string) {
+    sys::write(0, text.ptr, text.length)
+}
+
+export func println(text: string) {
+    print(text)
+    print("\n")
+}

examples/core/sys.nub

@@ -0,0 +1,5 @@
+module sys
+
+export extern func read(fd: u32, buf: ^char, count: u64): i64
+export extern func write(fd: u32, buf: ^char, count: u64): i64
+export extern func open(fileName: ^char, flags: i32, mode: u16): i64

examples/math/math.nub

@@ -1,44 +0,0 @@
-module math
-
-export struct Human {
-    name: string
-    age: i32
-}
-
-export struct Pos {
-    x: i32
-    y: i32
-}
-
-export enum Message {
-    Quit: {}
-    Move: Pos
-}
-
-let x: i32
-
-export func add(a: i32 b: i32): i32
-{
-    let x = "test"
-
-    let msg: Message = enum Message::Move { 
-        x = 10
-        y = 10
-    }
-
-    match msg {
-        Quit q {
-            // quit
-        }
-        Move m {
-            // move
-        }
-    }
-
-    return add_internal(a b)
-}
-
-func add_internal(a: i32 b: i32): i32
-{
-    return a + b
-}

examples/program/main.nub

@@ -1,6 +1,32 @@
 module main
 
-func main(): i32
-{
-    return math::add(1 2)
-}
+struct Human {
+    name: string
+    age: i32
+}
+
+enum Message {
+    Quit
+    Say: string
+}
+
+func main(): i32 {
+
+    let x = new string("test".ptr) + " " + "uwu"
+    core::println(x)
+
+    let messages: []Message = [new Message::Say("first"), new Message::Quit]
+
+    for message in messages {
+        match message {
+            Say msg {
+                core::println(msg)
+            }
+            Quit {
+                core::println("quit")
+            }
+        }
+    }
+
+    return 0
+}

examples/test/test.nub

@@ -1,32 +0,0 @@
-module main
-
-let global: i32
-
-func main(): i32 {
-    let x: i32 = 23
-    x = 24
-    
-    if !true {
-        x = 49
-        return x
-    } else {
-        x = 3
-    }
-    
-    let i: i32 = 0
-    
-    x = 1 + 2 * 34
-    while i < 10 {
-        i = i + 1
-        x = i
-    }
-    
-    let me: test::person = struct test::person { age = 21 name = "Oliver" }
-    
-    x = test::do_something(me.name)
-    test::do_something(me.name)
-
-    main::global = 123
-
-    return main::global
-}

examples/test/test2.nub

@@ -1,10 +0,0 @@
-module test
-
-export packed struct person {
-    age: i32
-    name: string
-}
-
-export func do_something(name: string): i32 {
-    return 3
-}