Modified the AbstractMetaFunction class to have a separated flag to

indicate that it was added by the user or not, instead of using the
AbstractMetaFunction::UserAddedFunction enum value. The old way
prevented the function to be an UserAddedFunction and a
ConstructorFunction at the same time, since this information was
stored as an enum of the AbstractMetaFunction::FunctionType type.
A test case was also added.

Reviewed by Hugo Parente <hugo.lima@openbossa.org>

4 files changed, 46 insertions, 7 deletions

diff --git a/abstractmetabuilder.cpp b/abstractmetabuilder.cpp
index d40efd667..44f03154e 100644
--- a/abstractmetabuilder.cpp
+++ b/abstractmetabuilder.cpp
@@ -1221,6 +1221,10 @@ void AbstractMetaBuilder::traverseFunctions(ScopeModelItem scopeItem, AbstractMe
     // Add the functions added by the typesystem
     foreach (AddedFunction addedFunc, metaClass->typeEntry()->addedFunctions()) {
         AbstractMetaFunction* func = traverseFunction(addedFunc);
+        if (func->name() == metaClass->name())
+            func->setFunctionType(AbstractMetaFunction::ConstructorFunction);
+        else
+            func->setFunctionType(AbstractMetaFunction::NormalFunction);
         func->setDeclaringClass(metaClass);
         func->setImplementingClass(metaClass);
         metaClass->addFunction(func);
@@ -1397,7 +1401,7 @@ AbstractMetaFunction *AbstractMetaBuilder::traverseFunction(const AddedFunction&
     metaFunction->setOriginalName(addedFunc.name());
     int visibility = addedFunc.access() == AddedFunction::Public ? AbstractMetaAttributes::Public : AbstractMetaAttributes::Protected;
     metaFunction->setVisibility(visibility);
-    metaFunction->setFunctionType(AbstractMetaFunction::UserAddedFunction);
+    metaFunction->setUserAdded(true);
     metaFunction->setAttributes(metaFunction->attributes() | AbstractMetaAttributes::Final);
     metaFunction->setType(translateType(addedFunc.returnType()));
 
diff --git a/abstractmetalang.h b/abstractmetalang.h
index 7915ea21b..13e3270a5 100644
--- a/abstractmetalang.h
+++ b/abstractmetalang.h
@@ -743,8 +743,7 @@ public:
         SignalFunction,
         EmptyFunction,
         SlotFunction,
-        GlobalScopeFunction,
-        UserAddedFunction, // Function added by the typesystem
+        GlobalScopeFunction
     };
 
     enum CompareResult {
@@ -774,6 +773,7 @@ public:
             m_constant(false),
             m_invalid(false),
             m_reverse(false),
+            m_userAdded(false),
             m_explicit(false)
     {
     }
@@ -1002,6 +1002,16 @@ public:
         m_constant = constant;
     }
 
+    /// Returns true if the AbstractMetaFunction was added by the user via the type system description.
+    bool isUserAdded() const
+    {
+        return m_userAdded;
+    }
+    void setUserAdded(bool userAdded)
+    {
+        m_userAdded = userAdded;
+    }
+
     QString toString() const
     {
         return m_name;
@@ -1100,6 +1110,7 @@ private:
     uint m_constant                 : 1;
     uint m_invalid                  : 1;
     uint m_reverse                  : 1;
+    uint m_userAdded                : 1;
     uint m_explicit                 : 1;
 };
 
diff --git a/tests/testaddfunction.cpp b/tests/testaddfunction.cpp
index 456b9888c..113fbf47c 100644
--- a/tests/testaddfunction.cpp
+++ b/tests/testaddfunction.cpp
@@ -85,7 +85,8 @@ void TestAddFunction::testAddFunction()
 
     AbstractMetaFunction* addedFunc = classA->functions().last();
     QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Protected));
-    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::UserAddedFunction);
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
+    QVERIFY(addedFunc->isUserAdded());
     QCOMPARE(addedFunc->ownerClass(), classA);
     QCOMPARE(addedFunc->implementingClass(), classA);
     QCOMPARE(addedFunc->declaringClass(), classA);
@@ -103,6 +104,28 @@ void TestAddFunction::testAddFunction()
     QCOMPARE(args[2]->type()->typeEntry(), typeDb->findType("B"));
 }
 
+void TestAddFunction::testAddFunctionConstructor()
+{
+    const char cppCode[] = "struct A { A() {} };";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A'>\
+            <add-function signature='A(int)' />\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().count(), 2); // default and added ctors
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::ConstructorFunction);
+    QCOMPARE(addedFunc->arguments().size(), 1);
+    QVERIFY(addedFunc->isUserAdded());
+    QVERIFY(!addedFunc->type());
+}
+
 void TestAddFunction::testAddFunctionTagDefaultValues()
 {
     const char cppCode[] = "struct A {};";
@@ -119,11 +142,11 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
     QCOMPARE(classA->functions().count(), 2); // default ctor and the added function
     AbstractMetaFunction* addedFunc = classA->functions().last();
     QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
-    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::UserAddedFunction);
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
+    QVERIFY(addedFunc->isUserAdded());
     QVERIFY(!addedFunc->type());
 }
 
-
 void TestAddFunction::testAddFunctionCodeSnippets()
 {
     const char cppCode[] = "struct A {};";
diff --git a/tests/testaddfunction.h b/tests/testaddfunction.h
index a8082a4b5..5600da7dc 100644
--- a/tests/testaddfunction.h
+++ b/tests/testaddfunction.h
@@ -31,9 +31,10 @@ class TestAddFunction : public QObject
 private slots:
     void testParsingFuncNameAndConstness();
     void testAddFunction();
+    void testAddFunctionConstructor();
     void testAddFunctionTagDefaultValues();
     void testAddFunctionCodeSnippets();
     void testFunctionWithoutParenteses();
 };
 
-#endif
\ No newline at end of file
+#endif