11 files changed, 9 insertions, 367 deletions
diff --git a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
index 514027242..9f00df6e0 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
@@ -513,7 +513,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
 
     ReportHandler::startProgress("Fixing class inheritance...");
     for (AbstractMetaClass *cls : qAsConst(m_metaClasses)) {
-        if (!cls->isInterface() && !cls->isNamespace()) {
+        if (!cls->isNamespace()) {
             setupInheritance(cls);
             if (!cls->hasVirtualDestructor() && cls->baseClass()
                 && cls->baseClass()->hasVirtualDestructor())
@@ -531,7 +531,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                                   .arg(cls->name());
         } else {
             const bool couldAddDefaultCtors = cls->isConstructible()
-                && !cls->isInterface() && !cls->isNamespace()
+                && !cls->isNamespace()
                 && (cls->attributes() & AbstractMetaAttributes::HasRejectedConstructor) == 0;
             if (couldAddDefaultCtors) {
                 if (!cls->hasConstructors())
@@ -727,12 +727,6 @@ void AbstractMetaBuilderPrivate::addAbstractMetaClass(AbstractMetaClass *cls,
         m_smartPointers << cls;
     } else {
         m_metaClasses << cls;
-        if (cls->typeEntry()->designatedInterface()) {
-            AbstractMetaClass *interface = cls->extractInterface();
-            m_metaClasses << interface;
-            if (ReportHandler::isDebug(ReportHandler::SparseDebug))
-                qCDebug(lcShiboken) << QStringLiteral(" -> interface '%1'").arg(interface->name());
-        }
     }
 }
 
@@ -1432,8 +1426,6 @@ void AbstractMetaBuilderPrivate::applyFunctionModifications(AbstractMetaFunction
 
 bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
 {
-    Q_ASSERT(!metaClass->isInterface());
-
     if (m_setupInheritanceDone.contains(metaClass))
         return true;
 
@@ -1474,7 +1466,6 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
     TypeDatabase* types = TypeDatabase::instance();
 
     int primary = -1;
-    int primaries = 0;
     for (int i = 0; i < baseClasses.size(); ++i) {
 
         if (types->isClassRejected(baseClasses.at(i)))
@@ -1485,10 +1476,8 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
             qCWarning(lcShiboken).noquote().nospace()
                 << QStringLiteral("class '%1' inherits from unknown base class '%2'")
                                   .arg(metaClass->name(), baseClasses.at(i));
-        } else if (!baseClassEntry->designatedInterface()) { // true for primary base class
-            primaries++;
-            primary = i;
         }
+        primary = i;
     }
 
     if (primary >= 0) {
@@ -1515,19 +1504,6 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
             }
 
             setupInheritance(baseClass);
-
-            QString interfaceName = baseClass->isInterface() ? InterfaceTypeEntry::interfaceName(baseClass->name()) : baseClass->name();
-            AbstractMetaClass *iface = AbstractMetaClass::findClass(m_metaClasses, interfaceName);
-            if (!iface) {
-                qCWarning(lcShiboken).noquote().nospace()
-                    << QStringLiteral("unknown interface for '%1': '%2'").arg(metaClass->name(), interfaceName);
-                return false;
-            }
-            metaClass->addInterface(iface);
-
-            const AbstractMetaClassList &interfaces = iface->interfaces();
-            for (AbstractMetaClass* iface : interfaces)
-                metaClass->addInterface(iface);
         }
     }
 
@@ -2060,6 +2036,7 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateType(const AddedFunction:
         qFatal("%s", qPrintable(msg));
     }
 
+    // These are only implicit and should not appear in code...
     auto *metaType = new AbstractMetaType;
     metaType->setTypeEntry(type);
     metaType->setIndirections(typeInfo.indirections);
@@ -2278,14 +2255,6 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateTypeStatic(const TypeInfo
     const TypeEntry *type = types.constFirst();
     const TypeEntry::Type typeEntryType = type->type();
 
-    // These are only implicit and should not appear in code...
-    if (typeEntryType == TypeEntry::InterfaceType) {
-        if (errorMessageIn)
-            *errorMessageIn = msgInterfaceTypeFound(qualifiedName);
-
-        return nullptr;
-    }
-
     QScopedPointer<AbstractMetaType> metaType(new AbstractMetaType);
     metaType->setIndirectionsV(typeInfo.indirectionsV());
     metaType->setReferenceType(typeInfo.referenceType());
@@ -2814,7 +2783,6 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
 
     subclass->setTemplateBaseClass(templateClass);
     subclass->setTemplateBaseClassInstantiations(templateTypes);
-    subclass->setInterfaces(templateClass->interfaces());
     subclass->setBaseClass(templateClass->baseClass());
 
     return true;
@@ -2892,11 +2860,9 @@ void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls)
         QQueue<AbstractMetaClass*> baseClasses;
         if (cls->baseClass())
             baseClasses.enqueue(cls->baseClass());
-        baseClasses << cls->interfaces().toList();
 
         while (!baseClasses.isEmpty()) {
             AbstractMetaClass* currentClass = baseClasses.dequeue();
-            baseClasses << currentClass->interfaces().toList();
             if (currentClass->baseClass())
                 baseClasses.enqueue(currentClass->baseClass());
 
@@ -3092,8 +3058,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
     } else {
         for (int i : qAsConst(unmappedResult)) {
             Q_ASSERT(reverseMap.contains(i));
-            if (!reverseMap[i]->isInterface())
-                result << reverseMap[i];
+            result << reverseMap[i];
         }
     }
 
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index 27f60904c..b1e0cae67 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -84,11 +84,6 @@ const AbstractMetaClass *recurseClassHierarchy(const AbstractMetaClass *klass,
         if (auto r = recurseClassHierarchy(base, pred))
             return r;
     }
-    const auto interfaces = klass->interfaces();
-    for (auto i : interfaces) {
-        if (auto r = recurseClassHierarchy(i, pred))
-            return r;
-    }
     return nullptr;
 }
 
@@ -948,9 +943,6 @@ FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaC
             (implementor == implementingClass() && !mods.isEmpty())) {
                 break;
         }
-        const AbstractMetaClassList &interfaces = implementor->interfaces();
-        for (const AbstractMetaClass *interface : interfaces)
-            mods += this->modifications(interface);
         implementor = implementor->baseClass();
     }
     return mods;
@@ -1365,44 +1357,6 @@ bool AbstractMetaClass::inheritsFrom(const AbstractMetaClass *cls) const
 }
 
 /*******************************************************************************
- * Constructs an interface based on the functions and enums in this
- * class and returns it...
- */
-AbstractMetaClass *AbstractMetaClass::extractInterface()
-{
-    Q_ASSERT(typeEntry()->designatedInterface());
-
-    if (!m_extractedInterface) {
-        auto *iface = new AbstractMetaClass;
-        iface->setAttributes(attributes());
-        iface->setBaseClass(nullptr);
-
-        iface->setTypeEntry(typeEntry()->designatedInterface());
-
-        for (AbstractMetaFunction *function : qAsConst(m_functions)) {
-            if (!function->isConstructor())
-                iface->addFunction(function->copy());
-        }
-
-//         iface->setEnums(enums());
-//         setEnums(AbstractMetaEnumList());
-
-        for (const AbstractMetaField *field : qAsConst(m_fields)) {
-            if (field->isPublic()) {
-                AbstractMetaField *new_field = field->copy();
-                new_field->setEnclosingClass(iface);
-                iface->addField(new_field);
-            }
-        }
-
-        m_extractedInterface = iface;
-        addInterface(iface);
-    }
-
-    return m_extractedInterface;
-}
-
-/*******************************************************************************
  * Returns a list of all the functions with a given name
  */
 AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const
@@ -1424,10 +1378,6 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
 {
     FunctionQueryOptions default_flags = NormalFunctions | Visible | NotRemovedFromTargetLang;
 
-    // Interfaces don't implement functions
-    if (isInterface())
-        default_flags |= ClassImplements;
-
     // Only public functions in final classes
     // default_flags |= isFinal() ? WasPublic : 0;
     FunctionQueryOptions public_flags;
@@ -1616,11 +1566,6 @@ QString AbstractMetaClass::package() const
     return m_typeEntry->targetLangPackage();
 }
 
-bool AbstractMetaClass::isInterface() const
-{
-    return m_typeEntry->isInterface();
-}
-
 bool AbstractMetaClass::isNamespace() const
 {
     return m_typeEntry->isNamespace();
@@ -2147,57 +2092,6 @@ AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
     return queryFunctions(Signals | Visible | NotRemovedFromTargetLang);
 }
 
-/**
- * Adds the specified interface to this class by adding all the
- * functions in the interface to this class.
- */
-void AbstractMetaClass::addInterface(AbstractMetaClass *interface)
-{
-    Q_ASSERT(!m_interfaces.contains(interface));
-    m_interfaces << interface;
-
-    m_isPolymorphic |= interface->isPolymorphic();
-
-    if (m_extractedInterface && m_extractedInterface != interface)
-        m_extractedInterface->addInterface(interface);
-
-
-#if 0
-    const AbstractMetaFunctionList &funcs = interface->functions();
-    for (AbstractMetaFunction *function : funcs)
-    if (!hasFunction(function) && !function->isConstructor()) {
-        AbstractMetaFunction *cpy = function->copy();
-        cpy->setImplementingClass(this);
-
-        // Setup that this function is an interface class.
-        cpy->setInterfaceClass(interface);
-        *cpy += AbstractMetaAttributes::InterfaceFunction;
-
-        // Copy the modifications in interface into the implementing classes.
-        const FunctionModificationList &mods = function->modifications(interface);
-        for (const FunctionModification &mod : mods)
-            m_typeEntry->addFunctionModification(mod);
-
-        // It should be mostly safe to assume that when we implement an interface
-        // we don't "pass on" pure virtual functions to our sublcasses...
-//             *cpy -= AbstractMetaAttributes::Abstract;
-
-        addFunction(cpy);
-    }
-#endif
-
-}
-
-
-void AbstractMetaClass::setInterfaces(const AbstractMetaClassList &interfaces)
-{
-    m_interfaces = interfaces;
-    for (const AbstractMetaClass *interface : interfaces) {
-        if (interface)
-            m_isPolymorphic |= interface->isPolymorphic();
-    }
-}
-
 AbstractMetaField *AbstractMetaClass::findField(const QString &name) const
 {
     return AbstractMetaField::find(m_fields, name);
@@ -2207,10 +2101,6 @@ AbstractMetaEnum *AbstractMetaClass::findEnum(const QString &enumName)
 {
     if (AbstractMetaEnum *e = findByName(m_enums, enumName))
         return e;
-
-    if (typeEntry()->designatedInterface())
-        return extractInterface()->findEnum(enumName);
-
     return nullptr;
 }
 
@@ -2223,10 +2113,6 @@ AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValue
         if (AbstractMetaEnumValue *v = e->findEnumValue(enumValueName))
             return v;
     }
-
-    if (typeEntry()->designatedInterface())
-        return extractInterface()->findEnumValue(enumValueName);
-
     if (baseClass())
         return baseClass()->findEnumValue(enumValueName);
 
@@ -2278,8 +2164,7 @@ void AbstractMetaClass::fixFunctions()
 
     if (superClass)
         superClass->fixFunctions();
-    int iface_idx = 0;
-    while (superClass || iface_idx < interfaces().size()) {
+    while (superClass) {
         // Since we always traverse the complete hierarchy we are only
         // interrested in what each super class implements, not what
         // we may have propagated from their base classes again.
@@ -2294,10 +2179,6 @@ void AbstractMetaClass::fixFunctions()
             superFuncs = superClass->queryFunctions(AbstractMetaClass::ClassImplements);
             AbstractMetaFunctionList virtuals = superClass->queryFunctions(AbstractMetaClass::VirtualInCppFunctions);
             superFuncs += virtuals;
-        } else {
-            superFuncs = interfaces().at(iface_idx)->queryFunctions(AbstractMetaClass::NormalFunctions);
-            AbstractMetaFunctionList virtuals = interfaces().at(iface_idx)->queryFunctions(AbstractMetaClass::VirtualInCppFunctions);
-            superFuncs += virtuals;
         }
 
         QSet<AbstractMetaFunction *> funcsToAdd;
@@ -2428,10 +2309,7 @@ void AbstractMetaClass::fixFunctions()
             funcs.append(copy);
         }
 
-        if (superClass)
-            superClass = superClass->baseClass();
-        else
-            iface_idx++;
+        superClass = superClass->baseClass();
     }
 
     bool hasPrivateConstructors = false;
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index 01e146557..f1d4254b0 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -1295,7 +1295,6 @@ public:
     AbstractMetaClass();
     ~AbstractMetaClass();
 
-    AbstractMetaClass *extractInterface();
     void fixFunctions();
 
     AbstractMetaFunctionList functions() const
@@ -1436,13 +1435,6 @@ public:
     AbstractMetaEnum *findEnum(const QString &enumName);
     AbstractMetaEnumValue *findEnumValue(const QString &enumName);
 
-    AbstractMetaClassList interfaces() const
-    {
-        return m_interfaces;
-    }
-    void addInterface(AbstractMetaClass *interface);
-    void setInterfaces(const AbstractMetaClassList &interface);
-
     QString fullName() const
     {
         return package() + QLatin1Char('.') + name();
@@ -1489,8 +1481,6 @@ public:
 
     QString package() const;
 
-    bool isInterface() const;
-
     bool isNamespace() const;
 
     bool isQObject() const;
@@ -1718,8 +1708,6 @@ private:
     AbstractMetaFunctionList m_functions;
     AbstractMetaFieldList m_fields;
     AbstractMetaEnumList m_enums;
-    AbstractMetaClassList m_interfaces;
-    AbstractMetaClass *m_extractedInterface = nullptr;
     QVector<QPropertySpec *> m_propertySpecs;
     AbstractMetaClassList m_innerClasses;
 
diff --git a/sources/shiboken2/ApiExtractor/messages.cpp b/sources/shiboken2/ApiExtractor/messages.cpp
index fa83b77db..0c29249d3 100644
--- a/sources/shiboken2/ApiExtractor/messages.cpp
+++ b/sources/shiboken2/ApiExtractor/messages.cpp
@@ -131,12 +131,6 @@ QString msgNoEnumTypeConflict(const EnumModelItem &enumItem,
     return result;
 }
 
-QString msgInterfaceTypeFound(const QString &qualifiedName)
-{
-    return QLatin1String("Interface type found for \"") + qualifiedName
-        + QLatin1String("\".");
-}
-
 QString msgAmbiguousVaryingTypesFound(const QString &qualifiedName, const TypeEntries &te)
 {
     QString result = QLatin1String("Ambiguous types of varying types found for \"") + qualifiedName
diff --git a/sources/shiboken2/ApiExtractor/messages.h b/sources/shiboken2/ApiExtractor/messages.h
index 563d412ee..321a4a538 100644
--- a/sources/shiboken2/ApiExtractor/messages.h
+++ b/sources/shiboken2/ApiExtractor/messages.h
@@ -59,7 +59,6 @@ QString msgNoEnumTypeConflict(const EnumModelItem &enumItem,
                               const QString &className,
                               const TypeEntry *t);
 
-QString msgInterfaceTypeFound(const QString &qualifiedName);
 QString msgAmbiguousVaryingTypesFound(const QString &qualifiedName, const TypeEntries &te);
 QString msgAmbiguousTypesFound(const QString &qualifiedName, const TypeEntries &te);
 
diff --git a/sources/shiboken2/ApiExtractor/typedatabase.cpp b/sources/shiboken2/ApiExtractor/typedatabase.cpp
index 258170c13..775ed2f81 100644
--- a/sources/shiboken2/ApiExtractor/typedatabase.cpp
+++ b/sources/shiboken2/ApiExtractor/typedatabase.cpp
@@ -256,7 +256,6 @@ static bool useCppType(const TypeEntry *t)
     case TypeEntry::TemplateArgumentType:
     case TypeEntry::BasicValueType:
     case TypeEntry::ContainerType:
-    case TypeEntry::InterfaceType:
     case TypeEntry::ObjectType:
     case TypeEntry::ArrayType:
     case TypeEntry::CustomType:
@@ -392,7 +391,6 @@ TypeEntry *TypeDatabase::resolveTypeDefEntry(TypedefEntry *typedefEntry,
         switch (e->type()) {
         case TypeEntry::BasicValueType:
         case TypeEntry::ContainerType:
-        case TypeEntry::InterfaceType:
         case TypeEntry::ObjectType:
         case TypeEntry::SmartPointerType:
             source = dynamic_cast<ComplexTypeEntry *>(e);
diff --git a/sources/shiboken2/ApiExtractor/typesystem.cpp b/sources/shiboken2/ApiExtractor/typesystem.cpp
index a29fa6dcf..0ec158ae1 100644
--- a/sources/shiboken2/ApiExtractor/typesystem.cpp
+++ b/sources/shiboken2/ApiExtractor/typesystem.cpp
@@ -1010,11 +1010,6 @@ bool ValueTypeEntry::isValue() const
     return true;
 }
 
-bool ValueTypeEntry::isNativeIdBased() const
-{
-    return true;
-}
-
 TypeEntry *ValueTypeEntry::clone() const
 {
     return new ValueTypeEntry(*this);
@@ -1162,30 +1157,6 @@ void CustomConversion::TargetToNativeConversion::setConversion(const QString& co
     m_d->conversion = conversion;
 }
 
-InterfaceTypeEntry::InterfaceTypeEntry(const QString &entryName, const QVersionNumber &vr,
-                                       const TypeEntry *parent) :
-    ComplexTypeEntry(entryName, InterfaceType, vr, parent)
-{
-}
-
-bool InterfaceTypeEntry::isNativeIdBased() const
-{
-    return true;
-}
-
-QString InterfaceTypeEntry::qualifiedCppName() const
-{
-    const int len = ComplexTypeEntry::qualifiedCppName().length() - interfaceName(QString()).length();
-    return ComplexTypeEntry::qualifiedCppName().left(len);
-}
-
-TypeEntry *InterfaceTypeEntry::clone() const
-{
-    return new InterfaceTypeEntry(*this);
-}
-
-InterfaceTypeEntry::InterfaceTypeEntry(const InterfaceTypeEntry &) = default;
-
 FunctionTypeEntry::FunctionTypeEntry(const QString &entryName, const QString &signature,
                                      const QVersionNumber &vr,
                                      const TypeEntry *parent) :
@@ -1207,16 +1178,6 @@ ObjectTypeEntry::ObjectTypeEntry(const QString &entryName, const QVersionNumber
 {
 }
 
-InterfaceTypeEntry *ObjectTypeEntry::designatedInterface() const
-{
-    return m_interface;
-}
-
-bool ObjectTypeEntry::isNativeIdBased() const
-{
-    return true;
-}
-
 TypeEntry *ObjectTypeEntry::clone() const
 {
     return new ObjectTypeEntry(*this);
diff --git a/sources/shiboken2/ApiExtractor/typesystem.h b/sources/shiboken2/ApiExtractor/typesystem.h
index 544673e4d..790fb95cb 100644
--- a/sources/shiboken2/ApiExtractor/typesystem.h
+++ b/sources/shiboken2/ApiExtractor/typesystem.h
@@ -499,7 +499,6 @@ QDebug operator<<(QDebug d, const AddedFunction::Argument &a);
 QDebug operator<<(QDebug d, const AddedFunction &af);
 #endif
 
-class InterfaceTypeEntry;
 class ObjectTypeEntry;
 
 class DocModification
@@ -564,7 +563,6 @@ public:
         TemplateArgumentType,
         BasicValueType,
         ContainerType,
-        InterfaceType,
         ObjectType,
         NamespaceType,
         ArrayType,
@@ -616,10 +614,6 @@ public:
     {
         return m_type == FlagsType;
     }
-    bool isInterface() const
-    {
-        return m_type == InterfaceType;
-    }
     bool isObject() const
     {
         return m_type == ObjectType;
@@ -741,11 +735,6 @@ public:
 
     QString qualifiedTargetLangName() const;
 
-    virtual InterfaceTypeEntry *designatedInterface() const
-    {
-        return nullptr;
-    }
-
     void setCustomConstructor(const CustomFunction &func)
     {
         m_customConstructor = func;
@@ -773,11 +762,6 @@ public:
         return false;
     }
 
-    virtual bool isNativeIdBased() const
-    {
-        return false;
-    }
-
     CodeSnipList codeSnips() const;
     void setCodeSnips(const CodeSnipList &codeSnips)
     {
@@ -1553,8 +1537,6 @@ public:
 
     bool isValue() const override;
 
-    bool isNativeIdBased() const override;
-
     TypeEntry *clone() const override;
 
 protected:
@@ -1563,39 +1545,6 @@ protected:
     ValueTypeEntry(const ValueTypeEntry &);
 };
 
-class InterfaceTypeEntry : public ComplexTypeEntry
-{
-public:
-    explicit InterfaceTypeEntry(const QString &entryName, const QVersionNumber &vr,
-                                const TypeEntry *parent);
-
-    static QString interfaceName(const QString &name)
-    {
-        return name + QLatin1String("Interface");
-    }
-
-    ObjectTypeEntry *origin() const
-    {
-        return m_origin;
-    }
-    void setOrigin(ObjectTypeEntry *origin)
-    {
-        m_origin = origin;
-    }
-
-    bool isNativeIdBased() const override;
-    QString qualifiedCppName() const override;
-
-    TypeEntry *clone() const override;
-
-protected:
-    InterfaceTypeEntry(const InterfaceTypeEntry &);
-
-private:
-    ObjectTypeEntry *m_origin = nullptr;
-};
-
-
 class FunctionTypeEntry : public TypeEntry
 {
 public:
@@ -1632,21 +1581,10 @@ public:
     explicit ObjectTypeEntry(const QString &entryName, const QVersionNumber &vr,
                              const TypeEntry *parent);
 
-    InterfaceTypeEntry *designatedInterface() const override;
-    void setDesignatedInterface(InterfaceTypeEntry *entry)
-    {
-        m_interface = entry;
-    }
-
-    bool isNativeIdBased() const override;
-
     TypeEntry *clone() const override;
 
 protected:
     ObjectTypeEntry(const ObjectTypeEntry &);
-
-private:
-    InterfaceTypeEntry *m_interface = nullptr;
 };
 
 struct TypeRejection
diff --git a/sources/shiboken2/ApiExtractor/typesystemparser.cpp b/sources/shiboken2/ApiExtractor/typesystemparser.cpp
index 0e28e8602..55b079edd 100644
--- a/sources/shiboken2/ApiExtractor/typesystemparser.cpp
+++ b/sources/shiboken2/ApiExtractor/typesystemparser.cpp
@@ -804,11 +804,6 @@ bool TypeSystemParser::endElement(const QStringRef &localName)
         centry->setFieldModifications(m_contextStack.top()->fieldMods);
         centry->setCodeSnips(m_contextStack.top()->codeSnips);
         centry->setDocModification(m_contextStack.top()->docModifications);
-
-        if (centry->designatedInterface()) {
-            centry->designatedInterface()->setCodeSnips(m_contextStack.top()->codeSnips);
-            centry->designatedInterface()->setFunctionModifications(m_contextStack.top()->functionMods);
-        }
     }
     break;
     case StackElement::AddFunction: {
@@ -1344,40 +1339,6 @@ EnumTypeEntry *
     return entry;
 }
 
-ObjectTypeEntry *
-    TypeSystemParser::parseInterfaceTypeEntry(const QXmlStreamReader &,
-                                     const QString &name, const QVersionNumber &since,
-                                     QXmlStreamAttributes *attributes)
-{
-    if (!checkRootElement())
-        return nullptr;
-    auto *otype = new ObjectTypeEntry(name, since, currentParentTypeEntry());
-    applyCommonAttributes(otype, attributes);
-    QString targetLangName = name;
-    bool generate = true;
-    for (int i = attributes->size() - 1; i >= 0; --i) {
-        const QStringRef name = attributes->at(i).qualifiedName();
-        if (name == targetLangNameAttribute()) {
-            targetLangName = attributes->takeAt(i).value().toString();
-        } else if (name == generateAttribute()) {
-            generate = convertBoolean(attributes->takeAt(i).value(),
-                                      generateAttribute(), true);
-        }
-    }
-
-    auto itype = new InterfaceTypeEntry(InterfaceTypeEntry::interfaceName(targetLangName),
-                                        since, currentParentTypeEntry());
-    itype->setTargetLangName(targetLangName);
-
-    if (generate)
-        itype->setCodeGeneration(m_generate);
-    else
-        itype->setCodeGeneration(TypeEntry::GenerateForSubclass);
-
-    otype->setDesignatedInterface(itype);
-    itype->setOrigin(otype);
-    return otype;
-}
 
 NamespaceTypeEntry *
     TypeSystemParser::parseNamespaceTypeEntry(const QXmlStreamReader &reader,
@@ -1590,9 +1551,6 @@ void TypeSystemParser::applyComplexTypeAttributes(const QXmlStreamReader &reader
     if (ctype->type() != TypeEntry::ContainerType)
         ctype->setTargetLangPackage(package);
 
-    if (InterfaceTypeEntry *di = ctype->designatedInterface())
-        di->setTargetLangPackage(package);
-
     if (generate)
         ctype->setCodeGeneration(m_generate);
     else
@@ -2628,10 +2586,6 @@ bool TypeSystemParser::parseInclude(const QXmlStreamReader &,
         m_error = QLatin1String("Only supported parent tags are primitive-type, complex types or extra-includes");
         return false;
     }
-    if (InterfaceTypeEntry *di = entry->designatedInterface()) {
-        di->setInclude(entry->include());
-        di->setExtraIncludes(entry->extraIncludes());
-    }
     return true;
 }
 
@@ -2881,14 +2835,6 @@ bool TypeSystemParser::startElement(const QXmlStreamReader &reader)
             element->entry = m_currentEnum;
             break;
 
-        case StackElement::InterfaceTypeEntry:
-            if (ObjectTypeEntry *oe = parseInterfaceTypeEntry(reader, name, versionRange.since, &attributes)) {
-                applyComplexTypeAttributes(reader, oe, &attributes);
-                element->entry = oe;
-            } else {
-                return false;
-            }
-            break;
         case StackElement::ValueTypeEntry:
            if (ValueTypeEntry *ve = parseValueTypeEntry(reader, name, versionRange.since, &attributes)) {
                applyComplexTypeAttributes(reader, ve, &attributes);
@@ -2904,6 +2850,7 @@ bool TypeSystemParser::startElement(const QXmlStreamReader &reader)
                 return false;
             break;
         case StackElement::ObjectTypeEntry:
+        case StackElement::InterfaceTypeEntry:
             if (!checkRootElement())
                 return false;
             element->entry = new ObjectTypeEntry(name, versionRange.since, currentParentTypeEntry());
diff --git a/sources/shiboken2/ApiExtractor/typesystemparser.h b/sources/shiboken2/ApiExtractor/typesystemparser.h
index 2e9eb3c9b..b4be2765c 100644
--- a/sources/shiboken2/ApiExtractor/typesystemparser.h
+++ b/sources/shiboken2/ApiExtractor/typesystemparser.h
@@ -188,9 +188,6 @@ private:
                                 const QString &name, const QVersionNumber &since,
                                 QXmlStreamAttributes *attributes);
 
-    ObjectTypeEntry *
-        parseInterfaceTypeEntry(const QXmlStreamReader &, const QString &name,
-                                const QVersionNumber &since, QXmlStreamAttributes *);
     ValueTypeEntry *
         parseValueTypeEntry(const QXmlStreamReader &, const QString &name,
                             const QVersionNumber &since, QXmlStreamAttributes *);
diff --git a/sources/shiboken2/doc/typesystem_specifying_types.rst b/sources/shiboken2/doc/typesystem_specifying_types.rst
index f842adb76..5d086f4d3 100644
--- a/sources/shiboken2/doc/typesystem_specifying_types.rst
+++ b/sources/shiboken2/doc/typesystem_specifying_types.rst
@@ -335,30 +335,7 @@ object-type
 interface-type
 ^^^^^^^^^^^^^^
 
-    The interface-type node indicates that the given class is replaced by an
-    interface pattern when mapping from C++ to the target language. Using the
-    interface-type node implicitly makes the given type an :ref:`object-type`.
-
-    .. code-block:: xml
-
-        <typesystem>
-            <interface-type name="..."
-                since="..."
-                package ="..."
-                default-superclass ="..."
-                revision="..." />
-        </typesystem>
-
-    The **name** attribute is the fully qualified C++ class name. The *optional*
-    **package** attribute can be used to override the package of the type system.
-    If there is no C++ base class, the *optional* **default-superclass** attribute
-    can be used to specify a superclass in the generated target language API, for
-    the given class.
-
-    The *optional*  **since** value is used to specify the API version of this interface.
-
-    The **revision** attribute can be used to specify a revision for each type, easing the
-    production of ABI compatible bindings.
+    This type is deprecated and no longer has any effect. Use object-type instead.
 
 .. _container-type: