Properly handled enumeration items in default values of parameters.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/AST/ASTVisitor.cs

@@ -400,7 +400,7 @@ namespace CppSharp.AST
                 return false;
 
             foreach (var item in @enum.Items)
-                VisitEnumItem(item);
+                VisitEnumItemDecl(item);
 
             return true;
         }
@@ -413,7 +413,7 @@ namespace CppSharp.AST
             return variable.Type.Visit(this, variable.QualifiedType.Qualifiers);
         }
 
-        public virtual bool VisitEnumItem(Enumeration.Item item)
+        public virtual bool VisitEnumItemDecl(Enumeration.Item item)
         {
             return true;
         }

src/AST/Declaration.cs

@@ -409,6 +409,7 @@ namespace CppSharp.AST
         T VisitTypedefDecl(TypedefDecl typedef);
         T VisitTypeAliasDecl(TypeAlias typeAlias);
         T VisitEnumDecl(Enumeration @enum);
+        T VisitEnumItemDecl(Enumeration.Item item);
         T VisitVariableDecl(Variable variable);
         T VisitClassTemplateDecl(ClassTemplate template);
         T VisitFunctionTemplateDecl(FunctionTemplate template);

src/AST/Enumeration.cs

@@ -39,7 +39,7 @@ namespace CppSharp.AST
 
             public override T Visit<T>(IDeclVisitor<T> visitor)
             {
-                throw new NotImplementedException();
+                return visitor.VisitEnumItemDecl(this);
             }
         }
 

src/Generator.Tests/AST/TestAST.cs

@@ -126,6 +126,11 @@ namespace CppSharp.Generator.Tests.AST
                 throw new System.NotImplementedException();
             }
 
+            public bool VisitEnumItemDecl(Enumeration.Item item)
+            {
+                throw new NotImplementedException();
+            }
+
             public bool VisitVariableDecl(Variable variable)
             {
                 throw new System.NotImplementedException();

src/Generator/Generators/CLI/CLITypePrinter.cs

@@ -404,6 +404,12 @@ namespace CppSharp.Generators.CLI
             return @enum.Name;
         }
 
+        public string VisitEnumItemDecl(Enumeration.Item item)
+        {
+            return string.Format("{0}::{1}",
+                VisitEnumDecl((Enumeration) item.Namespace), VisitDeclaration(item));
+        }
+
         public string VisitVariableDecl(Variable variable)
         {
             throw new NotImplementedException();

src/Generator/Generators/CSharp/CSharpExpressionPrinter.cs

@@ -5,33 +5,22 @@ using Type = CppSharp.AST.Type;
 
 namespace CppSharp.Generators.CSharp
 {
-    public class CSharpExpressionPrinterResult
-    {
-        public string Value;
-
-        public override string ToString()
-        {
-            return Value;
-        }
-    }
-
     public static class CSharpExpressionPrinterExtensions
     {
-        public static CSharpExpressionPrinterResult CSharpValue(this Expression value, CSharpExpressionPrinter printer)
+        public static string CSharpValue(this Expression value, CSharpExpressionPrinter printer)
         {
             return value.Visit(printer);
         }
-
     }
 
-    public class CSharpExpressionPrinter : IExpressionPrinter<CSharpExpressionPrinterResult>
+    public class CSharpExpressionPrinter : IExpressionPrinter<string>
     {
         public CSharpExpressionPrinter(CSharpTypePrinter typePrinter)
         {
             this.typePrinter = typePrinter;
         }
 
-        public CSharpExpressionPrinterResult VisitExpression(Expression expr)
+        public string VisitExpression(Expression expr)
         {
             switch (expr.Class)
             {
@@ -40,32 +29,26 @@ namespace CppSharp.Generators.CSharp
                     switch (callExpr.Declaration.GenerationKind)
                     {
                         case GenerationKind.Generate:
-                            return new CSharpExpressionPrinterResult
-                            {
-                                Value = string.Format("{0}.{1}({2})",
-                                    typePrinter.VisitDeclaration(callExpr.Declaration.Namespace),
-                                    callExpr.Declaration.Name,
-                                    string.Join(", ", callExpr.Arguments.Select(VisitExpression)))
-                            };
+                            return string.Format("{0}.{1}({2})",
+                                typePrinter.VisitDeclaration(callExpr.Declaration.Namespace),
+                                callExpr.Declaration.Name,
+                                string.Join(", ", callExpr.Arguments.Select(VisitExpression)));
                         case GenerationKind.Internal:
                             // a non-ctor can only be internal if it's been converted to a property
                             var property = ((Class) callExpr.Declaration.Namespace).Properties.First(
                                 p => p.GetMethod == callExpr.Declaration);
-                            return new CSharpExpressionPrinterResult
-                            {
-                                Value = string.Format("{0}.{1}",
-                                    typePrinter.VisitDeclaration(callExpr.Declaration.Namespace),
-                                    property.Name)
-                            };
+                            return string.Format("{0}.{1}",
+                                typePrinter.VisitDeclaration(callExpr.Declaration.Namespace),
+                                property.Name);
                         default:
-                            return new CSharpExpressionPrinterResult { Value = expr.String };
+                            return expr.String;
                     }
                 case StatementClass.DeclarationReference:
-                    if (expr.Declaration is Variable)
-                        return new CSharpExpressionPrinterResult { Value = expr.Declaration.Name };
+                    if (expr.Declaration is Variable || expr.Declaration is Enumeration.Item)
+                        return expr.Declaration.Visit(typePrinter).Type;
                     goto default;
                 default:
-                    return new CSharpExpressionPrinterResult { Value = expr.String };
+                    return expr.String;
             }
         }
 

src/Generator/Generators/CSharp/CSharpTextTemplate.cs

@@ -2242,7 +2242,7 @@ namespace CppSharp.Generators.CSharp
                     string.Join(", ",
                         method.Parameters.Where(
                             p => p.Kind == ParameterKind.Regular).Select(
-                                p => p.Ignore ? ExpressionPrinter.VisitExpression(p.DefaultArgument).Value : p.Name)));
+                                p => p.Ignore ? ExpressionPrinter.VisitExpression(p.DefaultArgument) : p.Name)));
             }
 
             if (method.IsPure)
@@ -2328,7 +2328,7 @@ namespace CppSharp.Generators.CSharp
             return p.Type.IsPointerToPrimitiveType() && p.Usage == ParameterUsage.InOut && p.HasDefaultValue
                 ? "ref param" + index++
                 : (( p.Type.TryGetClass(out @class) && @class.IsInterface) ? "param" + index++ 
-                     : ExpressionPrinter.VisitExpression(p.DefaultArgument).Value);
+                     : ExpressionPrinter.VisitExpression(p.DefaultArgument));
         }
 
         private void GenerateOverloadCall(Function function)
@@ -2351,7 +2351,7 @@ namespace CppSharp.Generators.CSharp
                     parameter.HasDefaultValue)
                 {
                     WriteLine("var param{0} = ({1}) {2};",  j++, @class.OriginalClass.OriginalName,
-                        ExpressionPrinter.VisitExpression(parameter.DefaultArgument).Value);
+                        ExpressionPrinter.VisitExpression(parameter.DefaultArgument));
                 }
             }
 

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -642,6 +642,11 @@ namespace CppSharp.Generators.CSharp
             return GetNestedQualifiedName(@enum);
         }
 
+        public CSharpTypePrinterResult VisitEnumItemDecl(Enumeration.Item item)
+        {
+            return VisitDeclaration(item);
+        }
+
         public string GetNestedQualifiedName(Declaration decl)
         {
             var names = new List<string>();
@@ -688,7 +693,7 @@ namespace CppSharp.Generators.CSharp
 
         public CSharpTypePrinterResult VisitVariableDecl(Variable variable)
         {
-            throw new NotImplementedException();
+            return variable.Name;
         }
 
         public CSharpTypePrinterResult VisitClassTemplateDecl(ClassTemplate template)

src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs

@@ -218,6 +218,11 @@ namespace CppSharp.Passes
             return false;
         }
 
+        public bool VisitEnumItemDecl(Enumeration.Item item)
+        {
+            return false;
+        }
+
         public bool VisitVariableDecl(Variable variable)
         {
             return false;

src/Generator/Passes/CleanInvalidDeclNamesPass.cs

@@ -150,9 +150,9 @@ namespace CppSharp.Passes
             return true;
         }
 
-        public override bool VisitEnumItem(Enumeration.Item item)
+        public override bool VisitEnumItemDecl(Enumeration.Item item)
         {
-            if (!base.VisitEnumItem(item))
+            if (!base.VisitEnumItemDecl(item))
                 return false;
 
             item.Name = CheckName(item.Name);

src/Generator/Passes/HandleDefaultParamValuesPass.cs

@@ -245,10 +245,19 @@ namespace CppSharp.Passes
             var enumItem = statement.Declaration as Enumeration.Item;
             if (enumItem != null)
             {
-                result = string.Format("{0}{1}.{2}",
-                    desugared.IsPrimitiveType() ? "(int) " : string.Empty,
-                    new CSharpTypePrinter(Driver).VisitEnumDecl(
-                        (Enumeration) enumItem.Namespace), enumItem.Name);
+                if (desugared.IsPrimitiveType())
+                {
+                    statement.Declaration = null;
+                    result = string.Format("(int) {0}.{1}",
+                        new CSharpTypePrinter(Driver).VisitEnumDecl(
+                            (Enumeration) enumItem.Namespace), enumItem.Name);
+                }
+                else
+                {
+                    result = string.Format("{0}.{1}",
+                        new CSharpTypePrinter(Driver).VisitEnumDecl(
+                            (Enumeration) enumItem.Namespace), enumItem.Name);
+                }
                 return true;
             }
 

src/Generator/Passes/RenamePass.cs

@@ -158,7 +158,7 @@ namespace CppSharp.Passes
                 f => !f.Ignore && f.Parameters.SequenceEqual(function.Parameters, new ParameterComparer()));
         }
 
-        public override bool VisitEnumItem(Enumeration.Item item)
+        public override bool VisitEnumItemDecl(Enumeration.Item item)
         {
             if (!Targets.HasFlag(RenameTargets.EnumItem))
                 return false;

src/Generator/Types/CppTypePrinter.cs

@@ -321,6 +321,11 @@ namespace CppSharp.Types
             return VisitDeclaration(@enum);
         }
 
+        public string VisitEnumItemDecl(Enumeration.Item item)
+        {
+            return VisitDeclaration(item);
+        }
+
         public string VisitVariableDecl(Variable variable)
         {
             return VisitDeclaration(variable);

tests/CSharp/CSharp.cpp

@@ -579,6 +579,10 @@ void MethodsWithDefaultValues::defaultWithDirectIntConstant(int arg)
 {
 }
 
+void MethodsWithDefaultValues::defaultWithEnumInLowerCasedNameSpace(lowerCaseNameSpace::Enum e)
+{
+}
+
 int MethodsWithDefaultValues::getA()
 {
     return m_foo.A;

tests/CSharp/CSharp.h

@@ -345,6 +345,15 @@ public:
     QRect(QPoint p, QSize s);
 };
 
+namespace lowerCaseNameSpace
+{
+    enum class Enum
+    {
+        Item1,
+        Item2
+    };
+}
+
 class DLL_API MethodsWithDefaultValues : public Quux
 {
 public:
@@ -401,6 +410,7 @@ public:
     void defaultWithGetPropertyCall(int f = Foo::getGetPropertyCall());
     void defaultWithIndirectStringConstant(const Foo& arg = Foo(stringConstant));
     void defaultWithDirectIntConstant(int arg = intConstant);
+    void defaultWithEnumInLowerCasedNameSpace(lowerCaseNameSpace::Enum e = lowerCaseNameSpace::Enum::Item2);
     int getA();
 private:
     Foo m_foo;