diff --git a/DataFormats/Provenance/interface/ProductRegistry.h b/DataFormats/Provenance/interface/ProductRegistry.h
index 726b221260e50..1deb4a4a20ad7 100644
--- a/DataFormats/Provenance/interface/ProductRegistry.h
+++ b/DataFormats/Provenance/interface/ProductRegistry.h
@@ -32,7 +32,6 @@ namespace edm {
 
   class ProductResolverIndexHelper;
   class TypeID;
-  class TypeWithDict;
 
   class ProductRegistry {
   public:
@@ -172,12 +171,12 @@ namespace edm {
                                 std::string const* processName);
     void addElementTypesForAliases(std::set<TypeID> const* elementTypesConsumed,
                                    std::map<TypeID, TypeID> const& containedTypeMap,
-                                   std::map<TypeID, std::vector<TypeWithDict>> const& containedTypeToBaseTypesMap);
+                                   std::map<TypeID, std::vector<TypeID>> const& containedTypeToBaseTypesMap);
 
     void checkDictionariesOfConsumedTypes(std::set<TypeID> const* productTypesConsumed,
                                           std::set<TypeID> const* elementTypesConsumed,
                                           std::map<TypeID, TypeID> const& containedTypeMap,
-                                          std::map<TypeID, std::vector<TypeWithDict>>& containedTypeToBaseTypesMap);
+                                          std::map<TypeID, std::vector<TypeID>>& containedTypeToBaseTypesMap);
 
     void checkForDuplicateProcessName(BranchDescription const& desc, std::string const* processName) const;
 
diff --git a/DataFormats/Provenance/interface/ProductResolverIndexHelper.h b/DataFormats/Provenance/interface/ProductResolverIndexHelper.h
index 1b957e6bc85d9..641b66fc54a9a 100644
--- a/DataFormats/Provenance/interface/ProductResolverIndexHelper.h
+++ b/DataFormats/Provenance/interface/ProductResolverIndexHelper.h
@@ -186,7 +186,7 @@ namespace edm {
                                 char const* instance,
                                 char const* process,
                                 TypeID const& containedTypeID,
-                                std::vector<TypeWithDict>* baseTypesOfContainedType);
+                                std::vector<TypeID>* baseTypesOfContainedType);
 
     ProductResolverIndex insert(TypeID const& typeID,
                                 char const* moduleLabel,
diff --git a/DataFormats/Provenance/src/ProductRegistry.cc b/DataFormats/Provenance/src/ProductRegistry.cc
index 04f478c06f4f1..58aee5c5805fc 100644
--- a/DataFormats/Provenance/src/ProductRegistry.cc
+++ b/DataFormats/Provenance/src/ProductRegistry.cc
@@ -297,7 +297,7 @@ namespace edm {
                                                std::set<TypeID> const* elementTypesConsumed,
                                                std::string const* processName) {
     std::map<TypeID, TypeID> containedTypeMap;
-    std::map<TypeID, std::vector<TypeWithDict>> containedTypeToBaseTypesMap;
+    std::map<TypeID, std::vector<TypeID>> containedTypeToBaseTypesMap;
 
     std::vector<std::string> missingDictionaries;
     std::vector<std::string> branchNamesForMissing;
@@ -351,7 +351,7 @@ namespace edm {
         }
         bool hasContainedType = (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID());
 
-        std::vector<TypeWithDict>* baseTypesOfContainedType = nullptr;
+        std::vector<TypeID>* baseTypesOfContainedType = nullptr;
 
         if (!alreadySawThisType) {
           bool alreadyCheckedConstituents = desc.produced() && !desc.transient();
@@ -367,7 +367,7 @@ namespace edm {
           if (hasContainedType) {
             auto iterBaseTypes = containedTypeToBaseTypesMap.find(containedTypeID);
             if (iterBaseTypes == containedTypeToBaseTypesMap.end()) {
-              std::vector<TypeWithDict> baseTypes;
+              std::vector<TypeID> baseTypes;
               if (!public_base_classes(missingDictionaries, containedTypeID, baseTypes)) {
                 branchNamesForMissing.emplace_back(desc.branchName());
                 if (desc.produced()) {
@@ -399,7 +399,7 @@ namespace edm {
           bool containedTypeConsumed =
               hasContainedType && (elementTypesConsumed->find(containedTypeID) != elementTypesConsumed->end());
           if (hasContainedType && !containedTypeConsumed && baseTypesOfContainedType != nullptr) {
-            for (TypeWithDict const& baseType : *baseTypesOfContainedType) {
+            for (TypeID const& baseType : *baseTypesOfContainedType) {
               if (elementTypesConsumed->find(TypeID(baseType.typeInfo())) != elementTypesConsumed->end()) {
                 containedTypeConsumed = true;
                 break;
@@ -466,7 +466,7 @@ namespace edm {
   void ProductRegistry::addElementTypesForAliases(
       std::set<TypeID> const* elementTypesConsumed,
       std::map<TypeID, TypeID> const& containedTypeMap,
-      std::map<TypeID, std::vector<TypeWithDict>> const& containedTypeToBaseTypesMap) {
+      std::map<TypeID, std::vector<TypeID>> const& containedTypeToBaseTypesMap) {
     Transients::AliasToOriginalVector elementAliases;
     for (auto& item : transient_.aliasToOriginal_) {
       auto iterContainedType = containedTypeMap.find(std::get<Transients::kType>(item));
@@ -496,8 +496,7 @@ namespace edm {
       if (iterBaseTypes == containedTypeToBaseTypesMap.end()) {
         continue;
       }
-      for (TypeWithDict const& baseType : iterBaseTypes->second) {
-        TypeID baseTypeID(baseType.typeInfo());
+      for (TypeID const& baseTypeID : iterBaseTypes->second) {
         if (elementTypesConsumed->find(baseTypeID) != elementTypesConsumed->end()) {
           elementAliases.emplace_back(ELEMENT_TYPE,
                                       baseTypeID,
@@ -516,7 +515,7 @@ namespace edm {
       std::set<TypeID> const* productTypesConsumed,
       std::set<TypeID> const* elementTypesConsumed,
       std::map<TypeID, TypeID> const& containedTypeMap,
-      std::map<TypeID, std::vector<TypeWithDict>>& containedTypeToBaseTypesMap) {
+      std::map<TypeID, std::vector<TypeID>>& containedTypeToBaseTypesMap) {
     std::vector<std::string> missingDictionaries;
     std::set<std::string> consumedTypesWithMissingDictionaries;
 
@@ -549,7 +548,7 @@ namespace edm {
             bool hasContainedType = (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID());
             if (hasContainedType) {
               if (containedTypeToBaseTypesMap.find(containedTypeID) == containedTypeToBaseTypesMap.end()) {
-                std::vector<TypeWithDict> bases;
+                std::vector<TypeID> bases;
                 // Run this to check for missing dictionaries, bases is not really used
                 if (!public_base_classes(missingDictionaries, containedTypeID, bases)) {
                   consumedTypesWithMissingDictionaries.emplace(consumedTypeID.className());
@@ -576,7 +575,7 @@ namespace edm {
       consumedTypesWithMissingDictionaries.clear();
       for (auto const& consumedTypeID : *elementTypesConsumed) {
         if (containedTypeToBaseTypesMap.find(consumedTypeID) == containedTypeToBaseTypesMap.end()) {
-          std::vector<TypeWithDict> bases;
+          std::vector<TypeID> bases;
           // Run this to check for missing dictionaries, bases is not really used
           if (!public_base_classes(missingDictionaries, consumedTypeID, bases)) {
             consumedTypesWithMissingDictionaries.emplace(consumedTypeID.className());
diff --git a/DataFormats/Provenance/src/ProductResolverIndexHelper.cc b/DataFormats/Provenance/src/ProductResolverIndexHelper.cc
index 82221e5fa8a6b..aa8f164986f01 100644
--- a/DataFormats/Provenance/src/ProductResolverIndexHelper.cc
+++ b/DataFormats/Provenance/src/ProductResolverIndexHelper.cc
@@ -84,7 +84,7 @@ namespace edm {
       }
       //need to check for inheritance match
       std::vector<std::string> missingDictionaries;
-      std::vector<TypeWithDict> baseTypes;
+      std::vector<TypeID> baseTypes;
       if (!public_base_classes(missingDictionaries, elementType, baseTypes)) {
         return false;
       }
@@ -217,7 +217,7 @@ namespace edm {
                                                           char const* instance,
                                                           char const* process,
                                                           TypeID const& containedTypeID,
-                                                          std::vector<TypeWithDict>* baseTypesOfContainedType) {
+                                                          std::vector<TypeID>* baseTypesOfContainedType) {
     if (!items_) {
       throw Exception(errors::LogicError)
           << "ProductResolverIndexHelper::insert - Attempt to insert more elements after frozen.\n";
@@ -274,8 +274,7 @@ namespace edm {
 
       // Repeat this for all public base classes of the contained type
       if (baseTypesOfContainedType) {
-        for (TypeWithDict const& baseType : *baseTypesOfContainedType) {
-          TypeID baseTypeID(baseType.typeInfo());
+        for (TypeID const& baseTypeID : *baseTypesOfContainedType) {
           Item baseItem(ELEMENT_TYPE, baseTypeID, moduleLabel, instance, process, savedProductIndex);
           iter = items_->find(baseItem);
           if (iter != items_->end()) {
@@ -303,8 +302,8 @@ namespace edm {
                                                           char const* process) {
     TypeID containedTypeID = productholderindexhelper::getContainedType(typeID);
     bool hasContainedType = (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID());
-    std::vector<TypeWithDict> baseTypes;
-    std::vector<TypeWithDict>* baseTypesOfContainedType = &baseTypes;
+    std::vector<TypeID> baseTypes;
+    std::vector<TypeID>* baseTypesOfContainedType = &baseTypes;
     if (hasContainedType) {
       std::vector<std::string> missingDictionaries;
       public_base_classes(missingDictionaries, containedTypeID, baseTypes);
diff --git a/FWCore/Reflection/interface/DictionaryTools.h b/FWCore/Reflection/interface/DictionaryTools.h
index b145ceaa42bdd..71b96cf9f7d82 100644
--- a/FWCore/Reflection/interface/DictionaryTools.h
+++ b/FWCore/Reflection/interface/DictionaryTools.h
@@ -59,7 +59,7 @@ namespace edm {
 
   bool public_base_classes(std::vector<std::string>& missingDictionaries,
                            TypeID const& typeID,
-                           std::vector<TypeWithDict>& baseTypes);
+                           std::vector<TypeID>& baseTypes);
 }  // namespace edm
 
 #endif  // FWCore_Reflection_DictionaryTools_h
diff --git a/FWCore/Reflection/src/DictionaryTools.cc b/FWCore/Reflection/src/DictionaryTools.cc
index d2b6512f79021..a80fe43c32f81 100644
--- a/FWCore/Reflection/src/DictionaryTools.cc
+++ b/FWCore/Reflection/src/DictionaryTools.cc
@@ -318,7 +318,7 @@ namespace edm {
 
   bool public_base_classes(std::vector<std::string>& missingDictionaries,
                            TypeID const& typeID,
-                           std::vector<TypeWithDict>& baseTypes) {
+                           std::vector<TypeID>& baseTypes) {
     if (!checkDictionary(missingDictionaries, typeID)) {
       return false;
     }
@@ -340,13 +340,13 @@ namespace edm {
         returnValue = false;
         continue;
       }
-      TypeWithDict baseType(baseRflxType.typeInfo());
+      TypeID baseType{baseRflxType.typeInfo()};
       // Check to make sure this base appears only once in the
       // inheritance hierarchy.
       if (!search_all(baseTypes, baseType)) {
         // Save the type and recursive look for its base types
         baseTypes.push_back(baseType);
-        if (!public_base_classes(missingDictionaries, TypeID(baseType.typeInfo()), baseTypes)) {
+        if (!public_base_classes(missingDictionaries, baseType, baseTypes)) {
           returnValue = false;
           continue;
         }