feat: macro event += and -= to :Connect() and :Disconnect() respectively

RobloxCS.Luau/AstUtility.cs

@@ -334,16 +334,16 @@ public static IdentifierName GetNonGenericName(SimpleName simpleName)
                 : simpleName.ToString());
         }
 
-        public static Name CreateName(string text)
+        public static Name CreateName(SyntaxNode node, string text, bool registerIdentifier = false, bool bypassReserved = false)
         {
-            Name expression = new IdentifierName(text);
+            Name name = CreateSimpleName(node, text, registerIdentifier, bypassReserved);
             var pieces = text.Split('.');
             if (pieces.Length <= 0)
-                return expression;
+                return name;
 
             return pieces
                 .Skip(1)
-                .Aggregate(expression, (current, piece) => new QualifiedName(current, new IdentifierName(piece)));
+                .Aggregate(name, (current, piece) => new QualifiedName(current, CreateSimpleName(node, piece)));
         }
 
         public static TNameNode CreateSimpleName<TNameNode>(SyntaxNode node, bool registerIdentifier = false, bool bypassReserved = false) 

RobloxCS.Luau/Macros.cs

@@ -15,13 +15,83 @@ public enum MacroKind
     ObjectMethod,
     IEnumerableMethod,
     ListMethod,
-    DictionaryMethod
+    DictionaryMethod,
+    BitOperation
 }
 
 public class Macro(SemanticModel semanticModel)
 {
     private SemanticModel _semanticModel { get; } = semanticModel;
+
+    public Node? Assignment(Func<SyntaxNode, Node?> visit, AssignmentExpressionSyntax assignment)
+    {
+        var mappedOperator = StandardUtility.GetMappedOperator(assignment.OperatorToken.Text);
+        var bit32MethodName = StandardUtility.GetBit32MethodName(mappedOperator);
+        if (bit32MethodName != null)
+        {
+            var target = (AssignmentTarget)visit(assignment.Left)!;
+            var value = (Expression)visit(assignment.Right)!;
+            var bit32Call = AstUtility.Bit32Call(bit32MethodName, target, value);
+            bit32Call.MarkExpanded(MacroKind.BitOperation);
+
+            return new Assignment(target, AstUtility.Bit32Call(bit32MethodName, target, value));
+        }
+
+        var leftSymbol = _semanticModel.GetSymbolInfo(assignment.Left).Symbol;
+        if (leftSymbol is IEventSymbol eventSymbol)
+        {
+            var symbolMetadata = SymbolMetadataManager.Get(eventSymbol);
+            symbolMetadata.EventConnectionName ??= AstUtility.CreateSimpleName<IdentifierName>(assignment, "conn_" + eventSymbol.Name, registerIdentifier: true);
+
+            var connectionName = symbolMetadata.EventConnectionName;
+            switch (mappedOperator)
+            {
+                case "+=":
+                {
+                    var left = (Expression)visit(assignment.Left)!;
+                    var right = (Expression)visit(assignment.Right)!;
+                    return new Variable(
+                        connectionName,
+                        true,
+                        new Call(
+                            new MemberAccess(left, new IdentifierName("Connect"), ':'),
+                            new ArgumentList([new Argument(right)])
+                        )
+                    );
+                }
+                case "-=":
+                {
+                    return new Call(
+                        new MemberAccess(connectionName, new IdentifierName("Disconnect"), ':'),
+                        new ArgumentList([])
+                    );
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public Expression? BinaryExpression(Func<SyntaxNode, Node?> visit, BinaryExpressionSyntax binaryExpression)
+    {
+        var mappedOperator = StandardUtility.GetMappedOperator(binaryExpression.OperatorToken.Text);
+        var bit32MethodName = StandardUtility.GetBit32MethodName(mappedOperator);
+        if (bit32MethodName != null)
+        {
+            var left = (Expression)visit(binaryExpression.Left)!;
+            var right = (Expression)visit(binaryExpression.Right)!;
+            var bit32Call = AstUtility.Bit32Call(bit32MethodName, left, right);
+            bit32Call.MarkExpanded(MacroKind.BitOperation);
+
+            return bit32Call;
+        }
+
+        return null;
+    }
 
+    /// <summary>
+    /// Takes a C# generic name and expands the name into a macro'd type
+    /// </summary>
     public Name? GenericName(Func<SyntaxNode, Node?> visit, GenericNameSyntax genericName)
     {
         var typeInfo = _semanticModel.GetTypeInfo(genericName);

RobloxCS.Luau/SymbolMetadataManager.cs

@@ -0,0 +1,22 @@
+using Microsoft.CodeAnalysis;
+
+namespace RobloxCS;
+
+public class SymbolMetadata
+{
+    public Luau.IdentifierName? EventConnectionName { get; set; }
+}
+
+public static class SymbolMetadataManager
+{
+    private static readonly Dictionary<ISymbol, SymbolMetadata> _metadata = [];
+
+    public static SymbolMetadata Get(ISymbol symbol)
+    {
+        var metadata = _metadata.GetValueOrDefault(symbol);
+        if (metadata == null)
+            _metadata.Add(symbol, metadata = new SymbolMetadata());
+
+        return metadata;
+    }
+}

RobloxCS/LuauGenerator.cs

@@ -588,16 +588,16 @@ public override Luau.Variable VisitAnonymousObjectMemberDeclarator(AnonymousObje
 
     public override Luau.Node VisitAssignmentExpression(AssignmentExpressionSyntax node)
     {
+        var expanded = _macro.Assignment(Visit, node);
+        if (expanded != null)
+            return expanded;
+
+        var mappedOperator = StandardUtility.GetMappedOperator(node.OperatorToken.Text);
         var name = Visit<Luau.AssignmentTarget>(node.Left);
         var value = Visit<Luau.Expression>(node.Right);
         if (node.IsKind(SyntaxKind.SimpleAssignmentExpression))
             return new Luau.Assignment(name, value);
 
-        var mappedOperator = StandardUtility.GetMappedOperator(node.OperatorToken.Text);
-        var bit32MethodName = StandardUtility.GetBit32MethodName(mappedOperator);
-        if (bit32MethodName != null)
-            return new Luau.Assignment(name, Luau.AstUtility.Bit32Call(bit32MethodName, name, value));
-
         return new Luau.BinaryOperator(name, mappedOperator, value);
     }
 
@@ -687,13 +687,13 @@ public override Luau.Block VisitBlock(BlockSyntax node)
 
     public override Luau.Node VisitBinaryExpression(BinaryExpressionSyntax node)
     {
+        var expanded = _macro.BinaryExpression(Visit, node);
+        if (expanded != null)
+            return expanded;
+
         var left = Visit<Luau.Expression>(node.Left);
         var right = Visit<Luau.Expression>(node.Right);
         var mappedOperator = StandardUtility.GetMappedOperator(node.OperatorToken.Text);
-        var bit32MethodName = StandardUtility.GetBit32MethodName(mappedOperator);
-        if (bit32MethodName != null)
-            return Luau.AstUtility.Bit32Call(bit32MethodName, left, right);
-
         return new Luau.BinaryOperator(left, mappedOperator, right);
     }
 

RobloxCS/README.md

@@ -6,10 +6,13 @@ Key:
 - `?` -> will maybe be added
 
 In no particular order:
+- [ ] disallow method grouping with methods from objects/classes
 - [ ] only generate interface declarations & inherit from interfaces if they have methods with implementations
 - [ ] map `dynamic` to no type at all
 - [ ] a LOT more testing
 	- [ ] generation tests
+    - [ ] luau rendering tests (mostly done)
+    - [ ] utility tests
 - [ ] save navigation (`a?.b?.c`)
 - [ ] macro `ToNumber()`, `ToUInt()`, `ToFloat()`, etc. (defined in Roblox.cs in RobloxCS.Types) to `tonumber()`
 - [ ] prefix increment/decrement (`++a`, `--a`)