External conversion operators are now part of a class' implicit conversions.

AbstractMetaClass::implicitConversions() returns externally declared
conversion operators in addition to its own implicit constructors.

The implicit conversion tests where extended with the new case.

4 files changed, 41 insertions, 5 deletions

diff --git a/abstractmetalang.cpp b/abstractmetalang.cpp
index 94114e3e9..73f617637 100644
--- a/abstractmetalang.cpp
+++ b/abstractmetalang.cpp
@@ -1102,12 +1102,15 @@ AbstractMetaFunctionList AbstractMetaClass::nonVirtualShellFunctions() const
 
 AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const
 {
-    AbstractMetaFunctionList list = queryFunctions(Constructors);
+    if (!hasCloneOperator() && !hasExternalConversionOperators())
+        return AbstractMetaFunctionList();
+
     AbstractMetaFunctionList returned;
-    if (!hasCloneOperator())
-        return returned;
+    AbstractMetaFunctionList list = queryFunctions(Constructors);
+    list.append(externalConversionOperators());
+
     foreach (AbstractMetaFunction *f, list) {
-        if ((f->actualMinimumArgumentCount() == 1 || f->arguments().size() == 1)
+        if ((f->actualMinimumArgumentCount() == 1 || f->arguments().size() == 1 || f->isConversionOperator())
             && !f->isExplicit()
             && !f->isCopyConstructor()
             && !f->isModifiedRemoved()
diff --git a/abstractmetalang.h b/abstractmetalang.h
index 0e60926b5..e0540932d 100644
--- a/abstractmetalang.h
+++ b/abstractmetalang.h
@@ -1422,7 +1422,7 @@ public:
 
     /**
      *   Retrieves all class' operator overloads that meet
-     *   query crieteria defined with the OperatorQueryOption
+     *   query criteria defined with the OperatorQueryOption
      *   enum.
      *   /param query composition of OperatorQueryOption enum values
      *   /return list of operator overload methods that meet the
diff --git a/tests/testimplicitconversions.cpp b/tests/testimplicitconversions.cpp
index 350ec8b6a..fd927db0b 100644
--- a/tests/testimplicitconversions.cpp
+++ b/tests/testimplicitconversions.cpp
@@ -116,6 +116,38 @@ void TestImplicitConversions::testWithAddedCtor()
     QCOMPARE(implicitConvs.count(), 2);
 }
 
+void TestImplicitConversions::testWithExternalConversionOperator()
+{
+    const char* cppCode ="\
+    class A {};\
+    struct B {\
+        operator A() const;\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package=\"Foo\">\
+        <value-type name=\"A\"/>\
+        <value-type name=\"B\"/>\
+        </typesystem>";
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    AbstractMetaClass* classB = classes.findClass("B");
+    AbstractMetaFunctionList implicitConvs = classA->implicitConversions();
+    QCOMPARE(implicitConvs.count(), 1);
+    AbstractMetaFunctionList externalConvOps = classA->externalConversionOperators();
+    QCOMPARE(externalConvOps.count(), 1);
+
+    const AbstractMetaFunction* convOp = 0;
+    foreach(const AbstractMetaFunction* func, classB->functions()) {
+        if (func->isConversionOperator())
+            convOp = func;
+    }
+    QVERIFY(convOp);
+    QCOMPARE(implicitConvs.first(), convOp);
+}
+
 QTEST_APPLESS_MAIN(TestImplicitConversions)
 
 #include "testimplicitconversions.moc"
diff --git a/tests/testimplicitconversions.h b/tests/testimplicitconversions.h
index 68369bc41..69bef4952 100644
--- a/tests/testimplicitconversions.h
+++ b/tests/testimplicitconversions.h
@@ -35,6 +35,7 @@ private slots:
     void testWithPrivateCtors();
     void testWithModifiedVisibility();
     void testWithAddedCtor();
+    void testWithExternalConversionOperator();
 };
 
 #endif