Improve filtering of aliases of enum values that map to the very same vk:: enum value.

VulkanHppGenerator.cpp

@@ -1844,7 +1844,7 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
   }
 
   std::string                        enumList, previousEnter, previousLeave;
-  std::set<std::string> valueNames;
+  std::map<std::string, std::string> valueToNameMap;
   for ( auto const & value : enumData.second.values )
   {
     std::string enter, leave;
@@ -1855,8 +1855,8 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
     }
     std::string valueName = generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask, m_tags );
     enumList += "    " + valueName + " = " + value.name + ",\n";
-    assert( valueNames.find( valueName ) == valueNames.end() );
+    assert( valueToNameMap.find( valueName ) == valueToNameMap.end() );
-    valueNames.insert( valueName );
+    valueToNameMap[valueName] = value.name;
 
     previousEnter = enter;
     previousLeave = leave;
@@ -1870,11 +1870,9 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
                              alias.first,
                              enumData.second.isBitmask,
                              m_tags );
-    // make sure to only list alias values that differ from all non-alias values
+    // make sure to only list alias values that differ from all previous values
-    if ( std::find_if( valueNames.begin(),
+    auto valueToNameIt = valueToNameMap.find( aliasName );
-                       valueNames.end(),
+    if ( valueToNameIt == valueToNameMap.end() )
-                       [&aliasName]( std::string const & valueName )
-                       { return aliasName == valueName; } ) == valueNames.end() )
     {
 #if !defined( NDEBUG )
       auto enumIt = std::find_if( enumData.second.values.begin(),
@@ -1898,7 +1896,27 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
       assert( enumIt->extension.empty() || generateProtection( enumIt->extension ).first.empty() );
 #endif
       enumList += "    " + aliasName + " = " + alias.first + ",\n";
+
+      // map the aliasName to the name of the base
+      std::string baseName = findBaseName( alias.second.name, enumData.second.aliases );
+      assert( std::find_if( enumData.second.values.begin(),
+                            enumData.second.values.end(),
+                            [&baseName]( EnumValueData const & evd )
+                            { return evd.name == baseName; } ) != enumData.second.values.end() );
+      valueToNameMap[aliasName] = baseName;
     }
+#if !defined( NDEBUG )
+    else
+    {
+      // verify, that the identical value represents the identical name
+      std::string baseName = findBaseName( alias.second.name, enumData.second.aliases );
+      assert( std::find_if( enumData.second.values.begin(),
+                            enumData.second.values.end(),
+                            [&baseName]( EnumValueData const & evd )
+                            { return evd.name == baseName; } ) != enumData.second.values.end() );
+      assert( baseName == valueToNameIt->second );
+    }
+#endif
   }
   if ( enumList.empty() )
   {
@@ -11231,6 +11249,19 @@ std::string const & VulkanHppGenerator::getVulkanLicenseHeader() const
   return m_vulkanLicenseHeader;
 }
 
+std::string VulkanHppGenerator::findBaseName( std::string                                  aliasName,
+                                              std::map<std::string, EnumAliasData> const & aliases ) const
+{
+  std::string baseName = aliasName;
+  auto        aliasIt  = aliases.find( baseName );
+  while ( aliasIt != aliases.end() )
+  {
+    baseName = aliasIt->second.name;
+    aliasIt  = aliases.find( baseName );
+  }
+  return baseName;
+}
+
 std::string VulkanHppGenerator::generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const
 {
   auto bitmaskBits = m_enums.find( bitmaskIt->second.requirements );

VulkanHppGenerator.hpp

@@ -157,7 +157,7 @@ private:
     void addEnumValue( int line, std::string const & valueName, bool bitpos, std::string const & extension );
 
     std::string                          alias;    // alias for this enum
-    std::map<std::string, EnumAliasData> aliases;
+    std::map<std::string, EnumAliasData> aliases;  // aliases for the values
     std::string                          bitwidth;
     bool                                 isBitmask = false;
     std::vector<EnumValueData>           values;
@@ -996,6 +996,7 @@ private:
   std::vector<size_t>      determineNonConstPointerParamIndices( std::vector<ParamData> const & params ) const;
   std::map<size_t, size_t> determineVectorParamIndicesNew( std::vector<ParamData> const & params ) const;
   void                     distributeSecondLevelCommands( std::set<std::string> const & specialFunctions );
+  std::string findBaseName( std::string aliasName, std::map<std::string, EnumAliasData> const & aliases ) const;
   std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const;
   std::string generateCommand( std::string const & name,
                                CommandData const & commandData,