User defined classes

src/Draco.Chr/Constraints/PropagationHistory.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using Draco.Chr.Rules;

src/Draco.Compiler.Cli/Program.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.CommandLine;
-using System.CommandLine.Parsing;
 using System.IO;
 using System.Linq;
 using Draco.Compiler.Api;

src/Draco.Compiler.Tests/EndToEnd/CompilingCodeTests.cs

@@ -999,4 +999,52 @@ func outer(x: int32): int32 {
 
         Assert.Equal(3, result);
     }
+
+    [Fact]
+    public void ClassHelloWorld()
+    {
+        var assembly = CompileToAssembly("""
+            import System.Console;
+
+            class Foo {
+                func bar() {
+                    WriteLine("Hello, World!");
+                }
+            }
+            """);
+
+        var stringWriter = new StringWriter();
+        _ = Invoke<object?>(assembly: assembly, stdout: stringWriter, methodName: "bar", moduleName: "FreeFunctions.Foo");
+
+        Assert.Equal($"Hello, World!{Environment.NewLine}", stringWriter.ToString(), ignoreLineEndingDifferences: true);
+    }
+
+    [Fact]
+    public void InstanceField()
+    {
+        var assembly = CompileToAssembly("""
+            import System.Console;
+
+            func bar(): int32 {
+                var foo = Foo();
+                foo.increment();
+                return foo.get();
+            }
+
+            class Foo {
+                field var i: int32;
+
+                public func increment(this) {
+                    this.i += 1;
+                }
+
+                public func get(this): int32 {
+                    return this.i;
+                }
+            }
+            """);
+
+        var value = Invoke<int>(assembly: assembly, methodName: "bar");
+        Assert.Equal(1, value);
+    }
 }

src/Draco.Compiler.Tests/Services/CodeCompletionTests.cs

@@ -38,13 +38,13 @@ public void TestLocalCompletionGlobalVariable()
     {
         // TODO: Can we get rid of all this filtering by filtering in the completion service?
         var completions = GetCompletionWords("""
-            val global = 5;
+            val globalVar = 5;
             func main(){
                 var local = gl|
             }
             """);
 
-        AssertCompletions(completions, "global");
+        AssertCompletions(completions, "globalVar");
     }
 
     [Fact]
@@ -78,11 +78,11 @@ func main(){
     public void TestGlobalCompletionGlobalVariable()
     {
         var completions = GetCompletionWords("""
-            val global = 5;
+            val globalVar = 5;
             val x = gl|
             """);
 
-        AssertCompletions(completions, "global");
+        AssertCompletions(completions, "globalVar");
     }
 
     [Fact]

src/Draco.Compiler.Tests/Syntax/ParserTests.cs

@@ -1957,7 +1957,7 @@ func foo(@Attr2("this is a parameter") x: int32) {}
             this.T(TokenKind.ParenOpen);
             this.N<SeparatedSyntaxList<ParameterSyntax>>();
             {
-                this.N<ParameterSyntax>();
+                this.N<NormalParameterSyntax>();
                 {
                     this.N<SyntaxList<AttributeSyntax>>();
                     this.N<AttributeSyntax>();
@@ -2088,7 +2088,7 @@ func foo(x: List<>) {}
             this.T(TokenKind.ParenOpen);
             this.N<SeparatedSyntaxList<ParameterSyntax>>();
             {
-                this.N<ParameterSyntax>();
+                this.N<NormalParameterSyntax>();
                 {
                     this.T(TokenKind.Identifier, "x");
                     this.T(TokenKind.Colon);
@@ -2113,4 +2113,37 @@ func foo(x: List<>) {}
             }
         }
     }
+
+    [Fact]
+    public void TestClassDeclaration()
+    {
+        this.ParseDeclaration("""
+            class Foo {
+            }
+            """);
+
+        this.N<ClassDeclarationSyntax>();
+        {
+            this.T(TokenKind.KeywordClass);
+            this.T(TokenKind.Identifier, "Foo");
+            this.N<BlockClassBodySyntax>();
+        }
+    }
+
+    [Fact]
+    public void TestValueClassDeclaration()
+    {
+        this.ParseDeclaration("""
+            value class Foo {
+            }
+            """);
+
+        this.N<ClassDeclarationSyntax>();
+        {
+            this.T(TokenKind.KeywordValue);
+            this.T(TokenKind.KeywordClass);
+            this.T(TokenKind.Identifier, "Foo");
+            this.N<BlockClassBodySyntax>();
+        }
+    }
 }

src/Draco.Compiler/Api/Semantics/SemanticModel.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -194,6 +193,16 @@ public ImmutableArray<ISymbol> GetAllAccessibleSymbols(SyntaxNode? node)
                 .SingleOrDefault(sym => sym.DeclaringSyntax == syntax);
             return symbol;
         }
+        case SourceClassSymbol classSymbol:
+        {
+            // Could be the class itself
+            if (classSymbol.DeclaringSyntax == syntax) return containingSymbol;
+
+            // Search for the corresponding syntax
+            var symbol = classSymbol.Members
+                .SingleOrDefault(sym => sym.DeclaringSyntax == syntax);
+            return symbol;
+        }
         default:
             return null;
         }

src/Draco.Compiler/Api/Services/CodeCompletion/CompletionService.cs

@@ -87,7 +87,7 @@ public ImmutableArray<CompletionItem> GetCompletions(SemanticModel semanticModel
             // Type expression
             NameTypeSyntax => CompletionContext.Type,
             // Parameter name declaration
-            ParameterSyntax => CompletionContext.None,
+            NormalParameterSyntax => CompletionContext.None,
             // Global declaration
             UnexpectedDeclarationSyntax => CompletionContext.Declaration,
             // Declaring identifier

src/Draco.Compiler/Api/Syntax/Extensions/SyntaxNodeTraversalExtensions.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 

src/Draco.Compiler/Api/Syntax/SyntaxFactory.cs

@@ -101,9 +101,9 @@ public static SeparatedSyntaxList<ParameterSyntax> ParameterList(params Paramete
     public static ParameterSyntax Parameter(string name, TypeSyntax type) =>
         Parameter([], name, type);
     public static ParameterSyntax Parameter(IEnumerable<AttributeSyntax> attributes, string name, TypeSyntax type) =>
-        Parameter(SyntaxList(attributes), null, Identifier(name), Colon, type);
+        NormalParameter(SyntaxList(attributes), null, Identifier(name), Colon, type);
     public static ParameterSyntax VariadicParameter(string name, TypeSyntax type) =>
-        Parameter(SyntaxList<AttributeSyntax>(), Ellipsis, Identifier(name), Colon, type);
+        NormalParameter(SyntaxList<AttributeSyntax>(), Ellipsis, Identifier(name), Colon, type);
 
     public static SeparatedSyntaxList<GenericParameterSyntax> GenericParameterList(IEnumerable<GenericParameterSyntax> parameters) =>
         SeparatedSyntaxList(Comma, parameters);
@@ -173,64 +173,126 @@ public static VariableDeclarationSyntax ValDeclaration(
         string name,
         TypeSyntax? type = null,
         ExpressionSyntax? value = null) =>
-        VariableDeclaration([], null, false, false, name, type, value);
+        VariableDeclaration(
+            attributes: [], null,
+            isGlobal: false,
+            isField: false,
+            isMutable: false,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax VarDeclaration(
         string name,
         TypeSyntax? type = null,
-        ExpressionSyntax? value = null) =>
-        VariableDeclaration([], null, false, true, name, type, value);
+        ExpressionSyntax? value = null) => VariableDeclaration(
+            attributes: [],
+            visibility: null,
+            isGlobal: false,
+            isField: false,
+            isMutable: true,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax FieldValDeclaration(
         string name,
         TypeSyntax? type = null,
-        ExpressionSyntax? value = null) =>
-        VariableDeclaration([], null, true, false, name, type, value);
+        ExpressionSyntax? value = null) => VariableDeclaration(
+            attributes: [],
+            visibility: null,
+            isGlobal: false,
+            isField: true,
+            isMutable: false,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax FieldVarDeclaration(
         string name,
         TypeSyntax? type = null,
-        ExpressionSyntax? value = null) =>
-        VariableDeclaration([], null, true, true, name, type, value);
+        ExpressionSyntax? value = null) => VariableDeclaration(
+            attributes: [],
+            visibility: null,
+            isGlobal: false,
+            isField: true,
+            isMutable: true,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax ValDeclaration(
         Visibility? visibility,
         string name,
         TypeSyntax? type = null,
         ExpressionSyntax? value = null) =>
-        VariableDeclaration([], visibility, false, false, name, type, value);
+        VariableDeclaration(
+            attributes: [],
+            visibility: visibility,
+            isGlobal: false,
+            isField: false,
+            isMutable: false,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax VarDeclaration(
         Visibility? visibility,
         string name,
         TypeSyntax? type = null,
         ExpressionSyntax? value = null) =>
-        VariableDeclaration([], visibility, false, true, name, type, value);
+        VariableDeclaration(
+            attributes: [],
+            visibility: visibility,
+            isGlobal: false,
+            isField: false,
+            isMutable: true,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax FieldValDeclaration(
         Visibility? visibility,
         string name,
         TypeSyntax? type = null,
         ExpressionSyntax? value = null) =>
-        VariableDeclaration([], visibility, true, false, name, type, value);
+        VariableDeclaration(
+            attributes: [],
+            visibility: visibility,
+            isGlobal: false,
+            isField: true,
+            isMutable: false,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax FieldVarDeclaration(
         Visibility? visibility,
         string name,
         TypeSyntax? type = null,
         ExpressionSyntax? value = null) =>
-        VariableDeclaration([], visibility, true, true, name, type, value);
+        VariableDeclaration(
+            attributes: [],
+            visibility: visibility,
+            isGlobal: false,
+            isField: true,
+            isMutable: true,
+            name: name,
+            type: type,
+            value: value);
 
     public static VariableDeclarationSyntax VariableDeclaration(
         IEnumerable<AttributeSyntax> attributes,
         Visibility? visibility,
+        bool isGlobal,
         bool isField,
         bool isMutable,
         string name,
         TypeSyntax? type = null,
         ExpressionSyntax? value = null) => VariableDeclaration(
         attributes,
         Visibility(visibility),
+        isGlobal ? TokenKind.KeywordGlobal : null,
         isField ? TokenKind.KeywordField : null,
         isMutable ? TokenKind.KeywordVar : TokenKind.KeywordVal,
         name,

src/Draco.Compiler/Api/Syntax/SyntaxFacts.cs

@@ -157,7 +157,7 @@ _ when IsMissing(node) => false,
             ModuleDeclarationSyntax md => !IsMissing(md.CloseBrace),
             ImportDeclarationSyntax id => !IsMissing(id.Semicolon),
             FunctionDeclarationSyntax fd => IsCompleteEntry(fd.Body),
-            ParameterSyntax p => IsCompleteEntry(p.Type),
+            NormalParameterSyntax p => IsCompleteEntry(p.Type),
             BlockFunctionBodySyntax bfb => !IsMissing(bfb.CloseBrace),
             InlineFunctionBodySyntax ifb => !IsMissing(ifb.Semicolon),
             LabelDeclarationSyntax ld => !IsMissing(ld.Colon),

src/Draco.Compiler/Api/Syntax/SyntaxHighlighter.cs

@@ -140,7 +140,7 @@ or TokenKind.BracketOpen
     private static IEnumerable<HighlightFragment> Identifier(SyntaxToken token, SemanticModel? semanticModel)
     {
         // Make a guess based on syntax
-        if (token.Parent is ParameterSyntax param && param.Name.Equals(token))
+        if (token.Parent is NormalParameterSyntax param && param.Name.Equals(token))
         {
             return Fragment(token, SyntaxColoring.ParameterName);
         }

src/Draco.Compiler/Internal/Binding/BinderCache.cs

@@ -36,7 +36,8 @@ public Binder GetBinder(SyntaxNode syntax)
         CompilationUnitSyntax cu => this.BuildCompilationUnitBinder(cu),
         ScriptEntrySyntax entry => this.BuildScriptEntryBinder(entry),
         ModuleDeclarationSyntax mo => this.BuildModuleBinder(mo),
-        FunctionDeclarationSyntax decl => this.BuildFunctionDeclarationBinder(decl),
+        FunctionDeclarationSyntax funcDecl => this.BuildFunctionDeclarationBinder(funcDecl),
+        ClassDeclarationSyntax classDecl => this.BuildClassDeclarationBinder(classDecl),
         FunctionBodySyntax body => this.BuildFunctionBodyBinder(body),
         BlockExpressionSyntax block => this.BuildLocalBinder(block),
         WhileExpressionSyntax loop => this.BuildLoopBinder(loop),
@@ -94,6 +95,19 @@ private FunctionBinder BuildFunctionDeclarationBinder(FunctionDeclarationSyntax
         return new FunctionBinder(binder, functionSymbol);
     }
 
+    private ClassBinder BuildClassDeclarationBinder(ClassDeclarationSyntax syntax)
+    {
+        Debug.Assert(syntax.Parent is not null);
+        var binder = this.GetBinder(syntax.Parent);
+        // Search for the function in the parents container
+        // For that we unwrap from the injected import layer(s)
+        var parent = UnwrapFromImportBinder(binder);
+        var classSymbol = parent.DeclaredSymbols
+            .OfType<SourceClassSymbol>()
+            .First(member => member.DeclaringSyntax == syntax); // should we shove that in a helper ?
+        return new ClassBinder(binder, classSymbol);
+    }
+
     private Binder BuildFunctionBodyBinder(FunctionBodySyntax syntax)
     {
         Debug.Assert(syntax.Parent is not null);