...

compiler/NubLang/Parsing/Parser.cs

@@ -163,10 +163,20 @@ public sealed class Parser
         return new FuncSyntax(GetTokens(startIndex), name.Value, exported, externSymbol, signature, body);
     }
 
-    private StructSyntax ParseStruct(int startIndex, bool exported)
+    private DefinitionSyntax ParseStruct(int startIndex, bool exported)
     {
         var name = ExpectIdentifier();
 
+        var templateArguments = new List<string>();
+        if (TryExpectSymbol(Symbol.LessThan))
+        {
+            while (!TryExpectSymbol(Symbol.GreaterThan))
+            {
+                templateArguments.Add(ExpectIdentifier().Value);
+                TryExpectSymbol(Symbol.Comma);
+            }
+        }
+
         ExpectSymbol(Symbol.OpenBrace);
 
         List<StructFieldSyntax> fields = [];
@@ -207,6 +217,11 @@ public sealed class Parser
             }
         }
 
+        if (templateArguments.Count > 0)
+        {
+            return new StructTemplateSyntax(GetTokens(startIndex), templateArguments, name.Value, exported, fields, funcs);
+        }
+
         return new StructSyntax(GetTokens(startIndex), name.Value, exported, fields, funcs);
     }
 
@@ -462,6 +477,7 @@ public sealed class Parser
                 Symbol.OpenBracket => ParseArrayInitializer(startIndex),
                 Symbol.OpenBrace => new StructInitializerSyntax(GetTokens(startIndex), Optional<TypeSyntax>.Empty(), ParseStructInitializerBody()),
                 Symbol.Struct => ParseStructInitializer(startIndex),
+                Symbol.At => ParseCompilerMacro(startIndex),
                 _ => throw new ParseException(Diagnostic
                     .Error($"Unexpected symbol '{symbolToken.Symbol}' in expression")
                     .WithHelp("Expected '(', '-', '!', '[' or '{'")
@@ -478,6 +494,34 @@ public sealed class Parser
         return ParsePostfixOperators(expr);
     }
 
+    private ExpressionSyntax ParseCompilerMacro(int startIndex)
+    {
+        var name = ExpectIdentifier();
+        ExpectSymbol(Symbol.OpenParen);
+
+        switch (name.Value)
+        {
+            case "size":
+            {
+                var type = ParseType();
+                ExpectSymbol(Symbol.CloseParen);
+                return new SizeCompilerMacroSyntax(GetTokens(startIndex), type);
+            }
+            case "interpret":
+            {
+                var type = ParseType();
+                ExpectSymbol(Symbol.Comma);
+                var expression = ParseExpression();
+                ExpectSymbol(Symbol.CloseParen);
+                return new InterpretCompilerMacroSyntax(GetTokens(startIndex), type, expression);
+            }
+            default:
+            {
+                throw new ParseException(Diagnostic.Error("Unknown compiler macro").At(name).Build());
+            }
+        }
+    }
+
     private ExpressionSyntax ParseIdentifier(int startIndex, IdentifierToken identifier)
     {
         if (TryExpectSymbol(Symbol.DoubleColon))
@@ -612,7 +656,7 @@ public sealed class Parser
         ExpectSymbol(Symbol.OpenBrace);
         return ParseBlock(startIndex);
     }
-    
+
     private BlockSyntax ParseBlock(int startIndex)
     {
         List<StatementSyntax> statements = [];
@@ -699,13 +743,31 @@ public sealed class Parser
                     return new BoolTypeSyntax(GetTokens(startIndex));
                 default:
                 {
+                    var module = _moduleName;
+
                     if (TryExpectSymbol(Symbol.DoubleColon))
                     {
-                        var customTypeName = ExpectIdentifier().Value;
-                        return new CustomTypeSyntax(GetTokens(startIndex), name.Value, customTypeName);
+                        var customTypeName = ExpectIdentifier();
+                        module = name.Value;
+                        name = customTypeName;
                     }
 
-                    return new CustomTypeSyntax(GetTokens(startIndex), _moduleName, name.Value);
+                    var templateParameters = new List<TypeSyntax>();
+                    if (TryExpectSymbol(Symbol.LessThan))
+                    {
+                        while (!TryExpectSymbol(Symbol.GreaterThan))
+                        {
+                            templateParameters.Add(ParseType());
+                            TryExpectSymbol(Symbol.Comma);
+                        }
+                    }
+
+                    if (templateParameters.Count > 0)
+                    {
+                        return new TemplateTypeSyntax(GetTokens(startIndex), templateParameters, module, name.Value);
+                    }
+
+                    return new CustomTypeSyntax(GetTokens(startIndex), module, name.Value);
                 }
             }
         }