Enum flag operator or is not working

[smitdylan2001]

Describe the bug in detail:
When using flags on enums like the camera depth I cannot use the '|' operator to set the flags.
I get an error
An exception occurred during Udon execution, this UdonBehaviour will be halted.
VRC.Udon.VM.UdonVMException: The VM encountered an error!
Exception Message:
An exception occurred during EXTERN to 'UnityEngineCamera.__set_depthTextureMode__UnityEngineDepthTextureMode__SystemVoid'.
Parameter Addresses: 0x00000007, 0x0000000B

Provide steps/code to reproduce the bug:
Make project
Add the following lines of code to a script on the reference camera on Start or OnEnabled
Camera cam = GetComponent();
cam.depthTextureMode = cam.depthTextureMode | DepthTextureMode.Depth;
Press play
Get error

Expected behavior:
It should not error and set the enum accordingly

[Panthr75]

I'm trying to add support for this for user enums, but just from what I've gathered so far, udon sharp doesn't properly bind any enum operator besides == and !=

[Panthr75]

I was able to get it to work for user enums, and it might also work for built-in enums.

Here's all the changes I made if I remember right...

In ExternSynthesizedOperatorSymbol.cs:

...
namespace UdonSharp.Compiler.Symbols
{
    internal sealed class ExternSynthesizedOperatorSymbol : ExternMethodSymbol
    {
-        private BuiltinOperatorType OperatorType { get; }
+        public BuiltinOperatorType OperatorType { get; }

        public override bool IsStatic => true;

        public override string Name => ExternSignature;

        public ExternSynthesizedOperatorSymbol(BuiltinOperatorType operatorType, TypeSymbol type, AbstractPhaseContext context)
...

In ImportedUdonSharpTypeSymbol.cs:

...
        private static Symbol MakeMethodSymbol(IMethodSymbol methodSymbol, AbstractPhaseContext context)
        {
-            if (methodSymbol.MethodKind == MethodKind.BuiltinOperator &&
-                methodSymbol.Parameters.Length == 2 && 
-                methodSymbol.Parameters[0].Type.TypeKind == TypeKind.Enum &&
-                context.GetTypeSymbol(methodSymbol.ReturnType) == context.GetTypeSymbol(SpecialType.System_Boolean))
-            {
-                TypeSymbol parameterType = context.GetTypeSymbol(methodSymbol.Parameters[0].Type);
-
-                BuiltinOperatorType operatorType;
-                if (methodSymbol.Name == "op_Equality")
-                    operatorType = BuiltinOperatorType.Equality;
-                else
-                    operatorType = BuiltinOperatorType.Inequality;
-                
-                return new ExternSynthesizedOperatorSymbol(operatorType, parameterType.UdonType, context);
-            }
+            if (methodSymbol.ContainingType?.TypeKind == TypeKind.Enum &&
+                methodSymbol.MethodKind == MethodKind.BuiltinOperator)
+            {
+                switch (methodSymbol.MetadataName)
+                {
+                    case WellKnownMemberNames.EqualityOperatorName:
+                        if (methodSymbol.Parameters[0].Type.TypeKind != TypeKind.Enum ||
+                            context.GetTypeSymbol(methodSymbol.ReturnType) != context.GetTypeSymbol(SpecialType.System_Boolean))
+                        {
+                            break;
+                        }
+
+                        return new ExternSynthesizedOperatorSymbol(
+                            BuiltinOperatorType.Equality,
+                            context.GetTypeSymbol(methodSymbol.Parameters[0].Type),
+                            context);
+                    case WellKnownMemberNames.InequalityOperatorName:
+                        if (methodSymbol.Parameters[0].Type.TypeKind != TypeKind.Enum ||
+                            context.GetTypeSymbol(methodSymbol.ReturnType) != context.GetTypeSymbol(SpecialType.System_Boolean))
+                        {
+                           break;
+                        }
+
+                        return new ExternSynthesizedOperatorSymbol(
+                            BuiltinOperatorType.Inequality,
+                            context.GetTypeSymbol(methodSymbol.Parameters[0].Type),
+                            context);
+                    case WellKnownMemberNames.BitwiseAndOperatorName:
+                        if (methodSymbol.Parameters[0].Type.TypeKind != TypeKind.Enum)
+                        {
+                            break;
+                        }
+
+                        return new ExternSynthesizedOperatorSymbol(
+                            BuiltinOperatorType.LogicalAnd,
+                            context.GetTypeSymbol(methodSymbol.Parameters[0].Type),
+                            context);
+                    case WellKnownMemberNames.BitwiseOrOperatorName:
+                        if (methodSymbol.Parameters[0].Type.TypeKind != TypeKind.Enum)
+                        {
+                            break;
+                        }
+
+                        return new ExternSynthesizedOperatorSymbol(
+                            BuiltinOperatorType.LogicalOr,
+                            context.GetTypeSymbol(methodSymbol.Parameters[0].Type),
+                            context);
+                    case WellKnownMemberNames.OnesComplementOperatorName:
+                        if (methodSymbol.Parameters[0].Type.TypeKind != TypeKind.Enum)
+                        {
+                            break;
+                        }
+
+                        return new ExternSynthesizedOperatorSymbol(
+                            BuiltinOperatorType.BitwiseNot,
+                            context.GetTypeSymbol(methodSymbol.Parameters[0].Type),
+                            context);
+                }
+            }

            return new ImportedUdonSharpMethodSymbol(methodSymbol, context);
        }
...

In BoundInvocationExpression

...
        public static BoundInvocationExpression CreateBoundInvocation(AbstractPhaseContext context, SyntaxNode node,
            MethodSymbol symbol, BoundExpression instanceExpression, BoundExpression[] parameterExpressions)
        {
            if (TryCreateShimInvocation(context, node, symbol, instanceExpression, parameterExpressions, out var boundShimInvocation))
                return boundShimInvocation;
            
            if (symbol.IsExtern)
            {
                if (CompilerUdonInterface.IsUdonEvent(symbol) &&
                    symbol.ContainingType == context.GetTypeSymbol(typeof(UdonSharpBehaviour))) // Pass through for making base calls on the U# behaviour type return noop
                    return new BoundUdonSharpBehaviourInvocationExpression(node, symbol, instanceExpression, parameterExpressions);

                if (symbol.IsOperator)
                {
                    // Enum equality/inequality
-                    if (symbol.ContainingType?.IsEnum ?? false)
+                    if ((symbol.ContainingType?.IsEnum ?? false) && symbol is ExternSynthesizedOperatorSymbol opSymbol)
                    {
-                        MethodSymbol objectEqualsMethod = context.GetTypeSymbol(SpecialType.System_Object)
-                            .GetMember<MethodSymbol>("Equals", context);
-                        
-                        var boundEqualsInvocation = CreateBoundInvocation(context, node, objectEqualsMethod, parameterExpressions[0],
-                                new[] {parameterExpressions[1]});
-                        if (symbol.Name == "op_Equality")
-                            return boundEqualsInvocation;
-
-                        MethodSymbol boolNotOperator = new ExternSynthesizedOperatorSymbol(
-                            BuiltinOperatorType.UnaryNegation, context.GetTypeSymbol(SpecialType.System_Boolean),
-                            context);
-
-                        return new BoundExternInvocation(node, context, boolNotOperator, null, new BoundExpression[] {boundEqualsInvocation});
+                        switch (opSymbol.OperatorType)
+                        {
+                            case BuiltinOperatorType.Equality:
+                                // lower operation
+                                if (!symbol.ContainingType.IsExtern) // from user enum
+                                {
+                                    // instead we lower it to call the underlying type's equality operator
+
+                                    ExternTypeSymbol underlyingType = symbol.ContainingType.UdonType;
+
+                                    MethodSymbol underlyingEqualityOperator = underlyingType
+                                        .GetMembers<MethodSymbol>(WellKnownMemberNames.EqualityOperatorName, context)
+                                        .FirstOrDefault(x => x.Parameters.Length == 2 &&
+                                            x.Parameters[0].Type == underlyingType &&
+                                            x.ReturnType == context.GetTypeSymbol(SpecialType.System_Boolean));
+
+                                    if (underlyingEqualityOperator != null)
+                                        return new BoundBuiltinOperatorInvocationExpression(
+                                            node,
+                                            context,
+                                            underlyingEqualityOperator,
+                                            parameterExpressions);
+
+                                    // couldn't get it for some reason, so resort to using object.equals
+                                }
+
+                                return CreateBoundInvocation(
+                                    context,
+                                    node,
+                                    context.GetTypeSymbol(SpecialType.System_Object)
+                                        .GetMember<MethodSymbol>("Equals", context),
+                                    parameterExpressions[0],
+                                    new BoundExpression[] { parameterExpressions[1] });
+
+                            case BuiltinOperatorType.Inequality:
+                                // lower operation
+                                if (!symbol.ContainingType.IsExtern) // from user enum
+                                {
+                                    // instead we lower it to call the underlying type's inequality operator
+
+                                    ExternTypeSymbol underlyingType = symbol.ContainingType.UdonType;
+
+                                    MethodSymbol underlyingInequalityOperator = underlyingType
+                                        .GetMembers<MethodSymbol>(WellKnownMemberNames.InequalityOperatorName, context)
+                                        .FirstOrDefault(x => x.Parameters.Length == 2 &&
+                                            x.Parameters[0].Type == underlyingType &&
+                                            x.ReturnType == context.GetTypeSymbol(SpecialType.System_Boolean));
+
+                                    if (underlyingInequalityOperator != null)
+                                        return new BoundBuiltinOperatorInvocationExpression(
+                                            node,
+                                            context,
+                                            underlyingInequalityOperator,
+                                            parameterExpressions);
+
+                                    // couldn't get it for some reason, so resort to using object.equals
+                                }
+
+                                {
+
+                                    BoundInvocationExpression boundEqualsInvocation = CreateBoundInvocation(
+                                        context,
+                                        node,
+                                        context.GetTypeSymbol(SpecialType.System_Object)
+                                            .GetMember<MethodSymbol>("Equals", context),
+                                        parameterExpressions[0],
+                                        new BoundExpression[] { parameterExpressions[1] });
+
+                                    return new BoundBuiltinOperatorInvocationExpression(
+                                        node,
+                                        context,
+                                        new ExternSynthesizedOperatorSymbol(
+                                            BuiltinOperatorType.UnaryNegation,
+                                            context.GetTypeSymbol(SpecialType.System_Boolean),
+                                            context),
+                                        new BoundExpression[] { boundEqualsInvocation });
+                                }
+
+                            case BuiltinOperatorType.LogicalAnd:
+                                if (symbol.ContainingType.IsExtern) // from outside enum
+                                {
+                                    return new BoundBuiltinOperatorInvocationExpression(
+                                        node,
+                                        context,
+                                        symbol,
+                                        parameterExpressions);
+                                }
+
+                                // lower operation
+                                {
+                                    ExternTypeSymbol underlyingType = symbol.ContainingType.UdonType;
+
+                                    MethodSymbol underlyingOperator = underlyingType
+                                        .GetMembers<MethodSymbol>(WellKnownMemberNames.BitwiseAndOperatorName, context)
+                                        .FirstOrDefault(x => x.Parameters.Length == 2 &&
+                                            x.Parameters[0].Type == underlyingType);
+
+                                    if (underlyingOperator.ReturnType == underlyingType)
+                                    {
+                                        return new BoundBuiltinOperatorInvocationExpression(
+                                            node,
+                                            context,
+                                            underlyingOperator,
+                                            parameterExpressions);
+                                    }
+
+                                    return new BoundCastedEnumOperatorInvocationExpression(
+                                        node,
+                                        context,
+                                        underlyingOperator,
+                                        underlyingType,
+                                        parameterExpressions);
+                                }
+
+                            case BuiltinOperatorType.LogicalOr:
+                                if (symbol.ContainingType.IsExtern) // from outside enum
+                                {
+                                    return new BoundExternInvocation(
+                                        node,
+                                        context,
+                                        symbol,
+                                        instanceExpression,
+                                        parameterExpressions);
+                                }
+
+                                // lower operation
+                                {
+                                    ExternTypeSymbol underlyingType = symbol.ContainingType.UdonType;
+
+                                    MethodSymbol underlyingOperator = underlyingType
+                                        .GetMembers<MethodSymbol>(WellKnownMemberNames.BitwiseOrOperatorName, context)
+                                        .FirstOrDefault(x => x.Parameters.Length == 2 &&
+                                            x.Parameters[0].Type == underlyingType);
+
+                                    if (underlyingOperator.ReturnType == underlyingType)
+                                    {
+                                        return new BoundBuiltinOperatorInvocationExpression(
+                                            node,
+                                            context,
+                                            underlyingOperator,
+                                            parameterExpressions);
+                                    }
+
+                                    return new BoundCastedEnumOperatorInvocationExpression(
+                                        node,
+                                        context,
+                                        underlyingOperator,
+                                        underlyingType,
+                                        parameterExpressions);
+                                }
+                        }
                    }
                    
                    if (node is AssignmentExpressionSyntax)
                        return new BoundCompoundAssignmentExpression(context, node, (BoundAccessExpression) parameterExpressions[0], symbol, parameterExpressions[1]);

                    if (symbol is ExternBuiltinOperatorSymbol externBuiltinOperatorSymbol &&
                        externBuiltinOperatorSymbol.OperatorType == BuiltinOperatorType.BitwiseNot)
                        return new BoundBitwiseNotExpression(node, parameterExpressions[0]);
                    
                    if (parameterExpressions.Length == 2 || symbol.Name == "op_UnaryNegation" || symbol.Name == "op_LogicalNot")
                    {
                        return new BoundBuiltinOperatorInvocationExpression(node, context, symbol, parameterExpressions);
                    }

                    throw new NotSupportedException("Operator expressions must have either 1 or 2 parameters", node.GetLocation());
                }
                
                return new BoundExternInvocation(node, context, symbol, instanceExpression, parameterExpressions);
            }

            if (symbol.IsStatic)
                return new BoundStaticUserMethodInvocation(node, symbol, parameterExpressions);

            if (symbol is UdonSharpBehaviourMethodSymbol udonSharpBehaviourMethodSymbol)
            {
                if (instanceExpression != null && !instanceExpression.IsThis)
                    udonSharpBehaviourMethodSymbol.MarkNeedsReferenceExport();
                
                return new BoundUdonSharpBehaviourInvocationExpression(node, symbol, instanceExpression,
                    parameterExpressions);
            }

            throw new System.NotImplementedException();
        }

...
            context.Module.AddCommentTag("Recursive stack pop end");
        }

+        private sealed class BoundCastedEnumOperatorInvocationExpression : BoundExternInvocation
+        {
+            private readonly ExternTypeSymbol _targetType;
+
+            public BoundCastedEnumOperatorInvocationExpression(
+                SyntaxNode node,
+                AbstractPhaseContext context,
+                MethodSymbol method,
+                ExternTypeSymbol targetType,
+                BoundExpression[] parameterExpressions)
+                : base(node, context, method, null, parameterExpressions)
+            {
+                _targetType = targetType;
+            }
+
+            public override Value EmitValue(EmitContext context)
+            {
+                return context.CastValue(
+                    base.EmitValue(context),
+                    _targetType,
+                    true); // true as we are generally downcasting (i.e. int to byte)
+            }
+        }
+
        private sealed class BoundBuiltinOperatorInvocationExpression : BoundExternInvocation
        {
...