From 2d2d346da03df38b2b55201d57d114747c7646f2 Mon Sep 17 00:00:00 2001 From: nub31 Date: Tue, 22 Jul 2025 20:08:51 +0200 Subject: [PATCH] remove generics for now --- example/src/main.nub | 23 +----- src/compiler/NubLang.CLI/Program.cs | 4 - .../Syntax/Parsing/Node/DefinitionSyntax.cs | 35 ++------ .../NubLang/Syntax/Parsing/Node/TypeSyntax.cs | 15 +--- src/compiler/NubLang/Syntax/Parsing/Parser.cs | 80 ++++++------------- 5 files changed, 32 insertions(+), 125 deletions(-) diff --git a/example/src/main.nub b/example/src/main.nub index 68ecaf5..2cce740 100644 --- a/example/src/main.nub +++ b/example/src/main.nub @@ -1,27 +1,6 @@ -struct Box -{ - value: T -} - func main(args: []cstring): i64 { - let box = alloc Box - { - value = "bob" - } - - let box2 = alloc Box - { - value = "bob" - } - - let box3 = alloc Box - { - value = 23 - } - - - c::puts(box.value) + c::puts("test") return 0 } diff --git a/src/compiler/NubLang.CLI/Program.cs b/src/compiler/NubLang.CLI/Program.cs index 67d6ee4..de4b364 100644 --- a/src/compiler/NubLang.CLI/Program.cs +++ b/src/compiler/NubLang.CLI/Program.cs @@ -7,7 +7,6 @@ using NubLang.Generation; using NubLang.Generation.QBE; using NubLang.Syntax.Binding; using NubLang.Syntax.Binding.Node; -using NubLang.Syntax.Generics; using NubLang.Syntax.Parsing; using NubLang.Syntax.Parsing.Node; using NubLang.Syntax.Tokenization; @@ -95,9 +94,6 @@ foreach (var file in options.Files) syntaxTrees[file] = syntaxTree; } -var genericInstantiator = new GenericInstantiator(syntaxTrees.Values); -genericInstantiator.Visit(); - var definitionTable = new DefinitionTable(syntaxTrees.Values); var boundSyntaxTrees = new Dictionary(); diff --git a/src/compiler/NubLang/Syntax/Parsing/Node/DefinitionSyntax.cs b/src/compiler/NubLang/Syntax/Parsing/Node/DefinitionSyntax.cs index f07f51e..0c5aad1 100644 --- a/src/compiler/NubLang/Syntax/Parsing/Node/DefinitionSyntax.cs +++ b/src/compiler/NubLang/Syntax/Parsing/Node/DefinitionSyntax.cs @@ -3,12 +3,7 @@ using NubLang.Syntax.Tokenization; namespace NubLang.Syntax.Parsing.Node; -public record GenericParameter(IReadOnlyList Tokens, string Name) : SyntaxNode(Tokens) -{ - public override IEnumerable GetChildren() => []; -} - -public abstract record DefinitionSyntax(IReadOnlyList Tokens, string Namespace, IReadOnlyList Parameters) : SyntaxNode(Tokens); +public abstract record DefinitionSyntax(IReadOnlyList Tokens, string Namespace) : SyntaxNode(Tokens); public record FuncParameterSyntax(IReadOnlyList Tokens, string Name, TypeSyntax Type) : SyntaxNode(Tokens) { @@ -31,29 +26,19 @@ public record FuncSignatureSyntax(IReadOnlyList Tokens, IReadOnlyList Tokens, string Namespace, IReadOnlyList Parameters, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionSyntax(Tokens, Namespace, Parameters) +public record LocalFuncSyntax(IReadOnlyList Tokens, string Namespace, string Name, FuncSignatureSyntax Signature, BlockSyntax Body) : DefinitionSyntax(Tokens, Namespace) { public override IEnumerable GetChildren() { - foreach (var parameter in Parameters) - { - yield return parameter; - } - yield return Signature; yield return Body; } } -public record ExternFuncSyntax(IReadOnlyList Tokens, string Namespace, IReadOnlyList Parameters, string Name, string CallName, FuncSignatureSyntax Signature) : DefinitionSyntax(Tokens, Namespace, Parameters) +public record ExternFuncSyntax(IReadOnlyList Tokens, string Namespace, string Name, string CallName, FuncSignatureSyntax Signature) : DefinitionSyntax(Tokens, Namespace) { public override IEnumerable GetChildren() { - foreach (var parameter in Parameters) - { - yield return parameter; - } - yield return Signature; } } @@ -79,15 +64,10 @@ public record StructFuncSyntax(IReadOnlyList Tokens, string Name, FuncSig } } -public record StructSyntax(IReadOnlyList Tokens, string Namespace, IReadOnlyList Parameters, string Name, IReadOnlyList Fields, IReadOnlyList Functions) : DefinitionSyntax(Tokens, Namespace, Parameters) +public record StructSyntax(IReadOnlyList Tokens, string Namespace, string Name, IReadOnlyList Fields, IReadOnlyList Functions) : DefinitionSyntax(Tokens, Namespace) { public override IEnumerable GetChildren() { - foreach (var parameter in Parameters) - { - yield return parameter; - } - foreach (var field in Fields) { yield return field; @@ -108,15 +88,10 @@ public record InterfaceFuncSyntax(IReadOnlyList Tokens, string Name, Func } } -public record InterfaceSyntax(IReadOnlyList Tokens, string Namespace, IReadOnlyList Parameters, string Name, IReadOnlyList Functions) : DefinitionSyntax(Tokens, Namespace, Parameters) +public record InterfaceSyntax(IReadOnlyList Tokens, string Namespace, string Name, IReadOnlyList Functions) : DefinitionSyntax(Tokens, Namespace) { public override IEnumerable GetChildren() { - foreach (var parameter in Parameters) - { - yield return parameter; - } - foreach (var func in Functions) { yield return func; diff --git a/src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs b/src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs index 68482df..3d0c9f2 100644 --- a/src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs +++ b/src/compiler/NubLang/Syntax/Parsing/Node/TypeSyntax.cs @@ -29,7 +29,7 @@ public abstract record TypeSyntax(IReadOnlyList Tokens) : SyntaxNode(Toke StringTypeSyntax => "string", PointerTypeSyntax ptr => $"ptr_{ptr.BaseType.MangledName()}", ArrayTypeSyntax arr => $"arr_{arr.BaseType.MangledName()}", - CustomTypeSyntax custom => $"{custom.Namespace}_{custom.Name}_{string.Join("_", custom.Arguments.Select(x => x.MangledName()))}", + CustomTypeSyntax custom => $"{custom.Namespace}_{custom.Name}", FuncTypeSyntax func => $"func_{string.Join("_", func.Parameters.Select(x => x.MangledName()))}_to_{func.ReturnType.MangledName()}", _ => throw new NotSupportedException($"Unknown type syntax: {GetType().Name}") }; @@ -77,18 +77,7 @@ public record StringTypeSyntax(IReadOnlyList Tokens) : TypeSyntax(Tokens) public override IEnumerable GetChildren() => []; } -public record CustomTypeSyntax(IReadOnlyList Tokens, string Namespace, string Name, IReadOnlyList Arguments) : TypeSyntax(Tokens) -{ - public override IEnumerable GetChildren() - { - foreach (var argument in Arguments) - { - yield return argument; - } - } -} - -public record GenericTypeSyntax(IReadOnlyList Tokens, string Name) : TypeSyntax(Tokens) +public record CustomTypeSyntax(IReadOnlyList Tokens, string Namespace, string Name) : TypeSyntax(Tokens) { public override IEnumerable GetChildren() => []; } diff --git a/src/compiler/NubLang/Syntax/Parsing/Parser.cs b/src/compiler/NubLang/Syntax/Parsing/Parser.cs index 8fc227b..bca9931 100644 --- a/src/compiler/NubLang/Syntax/Parsing/Parser.cs +++ b/src/compiler/NubLang/Syntax/Parsing/Parser.cs @@ -12,7 +12,6 @@ public sealed class Parser private readonly IReadOnlyList _tokens; private readonly List _diagnostics = []; - private List _genericParameters = []; private int _tokenIndex; public Parser(IReadOnlyList tokens) @@ -24,7 +23,6 @@ public sealed class Parser public SyntaxTree Parse() { _diagnostics.Clear(); - _genericParameters = []; _tokenIndex = 0; if (TryExpectSymbol(Symbol.Namespace)) @@ -36,40 +34,18 @@ public sealed class Parser while (Peek().HasValue) { - _genericParameters = []; var startIndex = _tokenIndex; try { var keyword = ExpectSymbol(); - var name = ExpectIdentifier(); - - if (TryExpectSymbol(Symbol.LessThan)) - { - while (!TryExpectSymbol(Symbol.GreaterThan)) - { - var argumentStartIndex = _tokenIndex; - var identifier = ExpectIdentifier(); - if (!TryExpectSymbol(Symbol.Comma) && Peek().TryGetValue(out var token) && token is not SymbolToken { Symbol: Symbol.GreaterThan }) - { - _diagnostics.Add(Diagnostic - .Warning("Missing comma between template parameters") - .WithHelp("Add a ',' to separate parameters") - .At(token) - .Build()); - } - - var parameter = new GenericParameter(GetTokens(argumentStartIndex), identifier.Value); - _genericParameters.Add(parameter); - } - } var definition = keyword.Symbol switch { - Symbol.Extern => ParseExtern(startIndex, name, _genericParameters), - Symbol.Func => ParseFunc(startIndex, name, _genericParameters), - Symbol.Struct => ParseStruct(startIndex, name, _genericParameters), - Symbol.Interface => ParseInterface(startIndex, name, _genericParameters), + Symbol.Extern => ParseExtern(startIndex), + Symbol.Func => ParseFunc(startIndex), + Symbol.Struct => ParseStruct(startIndex), + Symbol.Interface => ParseInterface(startIndex), _ => throw new ParseException(Diagnostic .Error($"Expected 'extern', 'func', 'struct', 'trait' or 'impl' but found '{keyword.Symbol}'") .WithHelp("Valid definition keywords are 'extern', 'func', 'struct', 'trait' and 'impl'") @@ -140,18 +116,21 @@ public sealed class Parser return new FuncParameterSyntax(GetTokens(startIndex), name.Value, type); } - private DefinitionSyntax ParseExtern(int startIndex, IdentifierToken name, IReadOnlyList genericParameters) + private DefinitionSyntax ParseExtern(int startIndex) { var keyword = ExpectSymbol(); + return keyword.Symbol switch { - Symbol.Func => ParseExternFunc(startIndex, name, genericParameters), + Symbol.Func => ParseExternFunc(startIndex), _ => throw new ParseException(Diagnostic.Error($"Unexpected symbol {keyword.Symbol} after extern declaration").At(keyword).Build()) }; } - private ExternFuncSyntax ParseExternFunc(int startIndex, IdentifierToken name, IReadOnlyList genericParameters) + private ExternFuncSyntax ParseExternFunc(int startIndex) { + var name = ExpectIdentifier(); + var callName = name.Value; if (TryExpectSymbol(Symbol.Calls)) @@ -161,19 +140,22 @@ public sealed class Parser var signature = ParseFuncSignature(); - return new ExternFuncSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, callName, signature); + return new ExternFuncSyntax(GetTokens(startIndex), _namespace, name.Value, callName, signature); } - private LocalFuncSyntax ParseFunc(int startIndex, IdentifierToken name, IReadOnlyList genericParameters) + private LocalFuncSyntax ParseFunc(int startIndex) { + var name = ExpectIdentifier(); var signature = ParseFuncSignature(); var body = ParseBlock(); - return new LocalFuncSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, signature, body); + return new LocalFuncSyntax(GetTokens(startIndex), _namespace, name.Value, signature, body); } - private DefinitionSyntax ParseStruct(int startIndex, IdentifierToken name, IReadOnlyList genericParameters) + private DefinitionSyntax ParseStruct(int startIndex) { + var name = ExpectIdentifier(); + ExpectSymbol(Symbol.OpenBrace); List fields = []; @@ -188,7 +170,7 @@ public sealed class Parser if (TryExpectSymbol(Symbol.Func)) { var funcName = ExpectIdentifier().Value; - var thisArg = new FuncParameterSyntax([], "this", new CustomTypeSyntax([], _namespace, name.Value, genericParameters.Select(x => new GenericTypeSyntax(x.Tokens, x.Name)).ToList())); + var thisArg = new FuncParameterSyntax([], "this", new CustomTypeSyntax([], _namespace, name.Value)); var funcSignature = ParseFuncSignature(thisArg); var funcBody = ParseBlock(); @@ -211,11 +193,13 @@ public sealed class Parser } } - return new StructSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, fields, funcs); + return new StructSyntax(GetTokens(startIndex), _namespace, name.Value, fields, funcs); } - private InterfaceSyntax ParseInterface(int startIndex, IdentifierToken name, IReadOnlyList genericParameters) + private InterfaceSyntax ParseInterface(int startIndex) { + var name = ExpectIdentifier(); + ExpectSymbol(Symbol.OpenBrace); List functions = []; @@ -232,7 +216,7 @@ public sealed class Parser functions.Add(new InterfaceFuncSyntax(GetTokens(funcStartIndex), funcName, signature)); } - return new InterfaceSyntax(GetTokens(startIndex), _namespace, genericParameters, name.Value, functions); + return new InterfaceSyntax(GetTokens(startIndex), _namespace, name.Value, functions); } private StatementSyntax ParseStatement() @@ -646,12 +630,6 @@ public sealed class Parser if (TryExpectIdentifier(out var name)) { - var genericParameter = _genericParameters.FirstOrDefault(x => x.Name == name.Value); - if (genericParameter != null) - { - return new GenericTypeSyntax(GetTokens(startIndex), genericParameter.Name); - } - return name.Value switch { "void" => new VoidTypeSyntax(GetTokens(startIndex)), @@ -679,17 +657,7 @@ public sealed class Parser @namespace = ExpectIdentifier().Value; } - var parameters = new List(); - - if (TryExpectSymbol(Symbol.LessThan)) - { - while (!TryExpectSymbol(Symbol.GreaterThan)) - { - parameters.Add(ParseType()); - } - } - - return new CustomTypeSyntax(GetTokens(startIndex), @namespace, name.Value, parameters); + return new CustomTypeSyntax(GetTokens(startIndex), @namespace, name.Value); } }