CSharpExpressionPrinter: Recurse into operands (#1745)

* CSharpExpressionPrinter: Recurse into operands

Recursively call `VisitExpression` on the LHS and RHS of a binary
operator expression. This fixes the generation for complex default
parameters involving things other than two enumeration members.

* CSharpSources: Use `const` when possible

Generate `const` instead of `static` members when possible.
This allows generated members to be used when compile-time constants are
required, such as default parameters.

src/Generator/Generators/CSharp/CSharpExpressionPrinter.cs

@@ -61,13 +61,8 @@ namespace CppSharp.Generators.CSharp
                 case StatementClass.BinaryOperator:
                     var binaryOperator = (BinaryOperatorObsolete)expr;
 
-                    var lhsResult = binaryOperator.LHS.String;
-                    if (binaryOperator.LHS.Declaration is Enumeration.Item)
-                        lhsResult = binaryOperator.LHS.Declaration.Visit(typePrinter).Type;
-
-                    var rhsResult = binaryOperator.RHS.String;
-                    if (binaryOperator.RHS.Declaration is Enumeration.Item)
-                        rhsResult = binaryOperator.RHS.Declaration.Visit(typePrinter).Type;
+                    var lhsResult = VisitExpression(binaryOperator.LHS);
+                    var rhsResult = VisitExpression(binaryOperator.RHS);
 
                     return $"{lhsResult} {binaryOperator.OpcodeStr} {rhsResult}";
                 case StatementClass.ConstructorReference:

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -1615,19 +1615,27 @@ internal static bool {Helpers.TryGetNativeToManagedMappingIdentifier}(IntPtr nat
             var variableType = variable.Type.Visit(TypePrinter);
             TypePrinter.PopMarshalKind();
 
-            var signature = $"public static {variableType} {variable.Name}";
+            bool hasInitializer = variable.Initializer != null && !string.IsNullOrWhiteSpace(variable.Initializer.String);
 
-            if (variable.Initializer != null && !string.IsNullOrWhiteSpace(variable.Initializer.String))
-                GeneratePropertyGetterForVariableWithInitializer(variable, signature);
+            if (hasInitializer && variable.QualifiedType.Qualifiers.IsConst &&
+                (variable.Type.Desugar() is BuiltinType || variableType.ToString() == "string"))
+                Write($"public const {variableType} {variable.Name} = {variable.Initializer.String};");
             else
             {
-                using (WriteBlock(signature))
+                var signature = $"public static {variableType} {variable.Name}";
+
+                if (hasInitializer)
+                    GeneratePropertyGetterForVariableWithInitializer(variable, signature);
+                else
                 {
-                    GeneratePropertyGetter(variable, @class);
+                    using (WriteBlock(signature))
+                    {
+                        GeneratePropertyGetter(variable, @class);
 
-                    if (!variable.QualifiedType.Qualifiers.IsConst &&
-                        !(variable.Type.Desugar() is ArrayType))
-                        GeneratePropertySetter(variable, @class);
+                        if (!variable.QualifiedType.Qualifiers.IsConst &&
+                            !(variable.Type.Desugar() is ArrayType))
+                            GeneratePropertySetter(variable, @class);
+                    }
                 }
             }
 

tests/dotnet/Common/Common.cpp

@@ -1278,3 +1278,7 @@ extern "C"
 void DLL_API FunctionWithFlagsAsDefaultParameter(int defaultParam)
 {
 }
+
+void DLL_API FunctionWithConstFlagsAsDefaultParameter(int defaultParam)
+{
+}

tests/dotnet/Common/Common.h

@@ -1569,3 +1569,9 @@ extern "C"
 } // extern "C"
 
 void DLL_API FunctionWithFlagsAsDefaultParameter(int defaultParam = A | B);
+
+const int ConstFlag1 = 1;
+const int ConstFlag2 = 2;
+const int ConstFlag3 = 4;
+
+void DLL_API FunctionWithConstFlagsAsDefaultParameter(int defaultParam = ConstFlag1 | ConstFlag2 | ConstFlag3);