Merge pull request #281 from tannergooding/main

tannergooding · web-flow · commit ac8b1a737700 · 2021-10-16T13:18:30.000-07:00
Greatly improve the understanding of the `log-potential-typedef-remappings` feature
diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitDecl.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitDecl.cs
@@ -21,6 +21,10 @@ private void VisitDecl(Decl decl)
         {
             if (IsExcluded(decl))
             {
+                if (decl.Kind == CX_DeclKind.CX_DeclKind_Typedef)
+                {
+                    VisitTypedefDecl((TypedefDecl)decl, onlyHandleRemappings: true);
+                }
                 return;
             }
 
@@ -133,7 +137,7 @@ private void VisitDecl(Decl decl)
 
                 case CX_DeclKind.CX_DeclKind_Typedef:
                 {
-                    VisitTypedefDecl((TypedefDecl)decl);
+                    VisitTypedefDecl((TypedefDecl)decl, onlyHandleRemappings: false);
                     break;
                 }
 
@@ -268,7 +272,7 @@ private void VisitEnumConstantDecl(EnumConstantDecl enumConstantDecl)
             var kind = isAnonymousEnum ? ValueKind.Primitive : ValueKind.Enumerator;
             var flags = ValueFlags.Constant;
 
-            if (enumConstantDecl.InitExpr is not null)
+            if ((enumConstantDecl.InitExpr is not null) || isAnonymousEnum)
             {
                 flags |= ValueFlags.Initializer;
             }
@@ -2411,13 +2415,13 @@ private void VisitTypeAliasDecl(TypeAliasDecl typeAliasDecl)
             // Nothing to generate for type alias declarations
         }
 
-        private void VisitTypedefDecl(TypedefDecl typedefDecl)
+        private void VisitTypedefDecl(TypedefDecl typedefDecl, bool onlyHandleRemappings)
         {
-            ForUnderlyingType(typedefDecl, typedefDecl.UnderlyingType);
+            ForUnderlyingType(typedefDecl, typedefDecl.UnderlyingType, onlyHandleRemappings);
 
-            void ForFunctionProtoType(TypedefDecl typedefDecl, FunctionProtoType functionProtoType, Type parentType)
+            void ForFunctionProtoType(TypedefDecl typedefDecl, FunctionProtoType functionProtoType, Type parentType, bool onlyHandleRemappings)
             {
-                if (!_config.ExcludeFnptrCodegen)
+                if (!_config.ExcludeFnptrCodegen || onlyHandleRemappings)
                 {
                     return;
                 }
@@ -2457,43 +2461,43 @@ void ForFunctionProtoType(TypedefDecl typedefDecl, FunctionProtoType functionPro
                 StopUsingOutputBuilder();
             }
 
-            void ForPointeeType(TypedefDecl typedefDecl, Type parentType, Type pointeeType)
+            void ForPointeeType(TypedefDecl typedefDecl, Type parentType, Type pointeeType, bool onlyHandleRemappings)
             {
                 if (pointeeType is AttributedType attributedType)
                 {
-                    ForPointeeType(typedefDecl, attributedType, attributedType.ModifiedType);
+                    ForPointeeType(typedefDecl, attributedType, attributedType.ModifiedType, onlyHandleRemappings);
                 }
                 else if (pointeeType is ElaboratedType elaboratedType)
                 {
-                    ForPointeeType(typedefDecl, elaboratedType, elaboratedType.NamedType);
+                    ForPointeeType(typedefDecl, elaboratedType, elaboratedType.NamedType, onlyHandleRemappings);
                 }
                 else if (pointeeType is FunctionProtoType functionProtoType)
                 {
-                    ForFunctionProtoType(typedefDecl, functionProtoType, parentType);
+                    ForFunctionProtoType(typedefDecl, functionProtoType, parentType, onlyHandleRemappings);
                 }
                 else if (pointeeType is PointerType pointerType)
                 {
-                    ForPointeeType(typedefDecl, pointerType, pointerType.PointeeType);
+                    ForPointeeType(typedefDecl, pointerType, pointerType.PointeeType, onlyHandleRemappings);
                 }
                 else if (pointeeType is TypedefType typedefType)
                 {
-                    ForPointeeType(typedefDecl, typedefType, typedefType.Decl.UnderlyingType);
+                    ForPointeeType(typedefDecl, typedefType, typedefType.Decl.UnderlyingType, onlyHandleRemappings);
                 }
                 else if (pointeeType is not ConstantArrayType and not BuiltinType and not TagType and not TemplateTypeParmType)
                 {
                     AddDiagnostic(DiagnosticLevel.Error, $"Unsupported pointee type: '{pointeeType.TypeClassSpelling}'. Generating bindings may be incomplete.", typedefDecl);
                 }
             }
 
-            void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType)
+            void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType, bool onlyHandleRemappings)
             {
                 if (underlyingType is ArrayType arrayType)
                 {
                     // Nothing to do for array types
                 }
                 else if (underlyingType is AttributedType attributedType)
                 {
-                    ForUnderlyingType(typedefDecl, attributedType.ModifiedType);
+                    ForUnderlyingType(typedefDecl, attributedType.ModifiedType, onlyHandleRemappings);
                 }
                 else if (underlyingType is BuiltinType builtinType)
                 {
@@ -2505,46 +2509,41 @@ void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType)
                 }
                 else if (underlyingType is ElaboratedType elaboratedType)
                 {
-                    ForUnderlyingType(typedefDecl, elaboratedType.NamedType);
+                    ForUnderlyingType(typedefDecl, elaboratedType.NamedType, onlyHandleRemappings);
                 }
                 else if (underlyingType is FunctionProtoType functionProtoType)
                 {
-                    ForFunctionProtoType(typedefDecl, functionProtoType, parentType: null);
+                    ForFunctionProtoType(typedefDecl, functionProtoType, parentType: null, onlyHandleRemappings);
                 }
                 else if (underlyingType is PointerType pointerType)
                 {
-                    ForPointeeType(typedefDecl, parentType: null, pointerType.PointeeType);
+                    ForPointeeType(typedefDecl, parentType: null, pointerType.PointeeType, onlyHandleRemappings);
                 }
                 else if (underlyingType is ReferenceType referenceType)
                 {
-                    ForPointeeType(typedefDecl, parentType: null, referenceType.PointeeType);
+                    ForPointeeType(typedefDecl, parentType: null, referenceType.PointeeType, onlyHandleRemappings);
                 }
                 else if (underlyingType is TagType underlyingTagType)
                 {
-                    // See if there's a potential typedef remapping we want to log
-                    if (_config.LogPotentialTypedefRemappings)
-                    {
-                        var typedefName = typedefDecl.UnderlyingDecl.Name;
-                        var possibleNamesToRemap = new string[] {"_" + typedefName, "_tag" + typedefName, "tag" + typedefName, typedefName + "_tag" };
-                        var underlyingName = underlyingTagType.AsString;
+                    var underlyingName = GetCursorName(underlyingTagType.AsTagDecl);
+                    var typedefName = GetCursorName(typedefDecl);
 
-                        foreach (var possibleNameToRemap in possibleNamesToRemap)
+                    if (underlyingName != typedefName)
+                    {
+                        if (!_validNameRemappings.TryGetValue(underlyingName, out var remappings))
                         {
-                            if (!_config.RemappedNames.ContainsKey(possibleNameToRemap) && !_config.RemappedNames.ContainsKey(possibleNameToRemap + "*"))
-                            {
-                                if (possibleNameToRemap == underlyingName)
-                                {
-                                    AddDiagnostic(DiagnosticLevel.Info, $"Potential remap: {possibleNameToRemap}={typedefName}");
-                                }
-                            }
+                            remappings = new HashSet<string>();
+                            _validNameRemappings[underlyingName] = remappings;
                         }
+
+                        _ = remappings.Add(typedefName);
                     }
                 }
                 else if (underlyingType is TemplateSpecializationType templateSpecializationType)
                 {
                     if (templateSpecializationType.IsTypeAlias)
                     {
-                        ForUnderlyingType(typedefDecl, templateSpecializationType.AliasedType);
+                        ForUnderlyingType(typedefDecl, templateSpecializationType.AliasedType, onlyHandleRemappings);
                     }
                     else
                     {
@@ -2557,7 +2556,7 @@ void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType)
                 }
                 else if (underlyingType is TypedefType typedefType)
                 {
-                    ForUnderlyingType(typedefDecl, typedefType.Decl.UnderlyingType);
+                    ForUnderlyingType(typedefDecl, typedefType.Decl.UnderlyingType, onlyHandleRemappings);
                 }
                 else
                 {
diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitStmt.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitStmt.cs
@@ -2440,7 +2440,7 @@ private void VisitOffsetOfExpr(OffsetOfExpr offsetOfExpr)
             outputBuilder.Write("Marshal.OffsetOf<");
             outputBuilder.Write(GetRemappedTypeName(offsetOfExpr, context: null, offsetOfExpr.TypeSourceInfoType, out var _, skipUsing: false));
             outputBuilder.Write(">(\"");
-            Visit(offsetOfExpr.Referenced);
+            Visit(offsetOfExpr.Referenced ?? offsetOfExpr.CursorChildren[1]);
             outputBuilder.Write("\")");
 
             StopCSharpCode();
diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs
@@ -37,6 +37,8 @@ public sealed partial class PInvokeGenerator : IDisposable
         private readonly Dictionary<NamedDecl, string> _cursorNames;
         private readonly Dictionary<(NamedDecl namedDecl, bool truncateForFunctionParameters), string> _cursorQualifiedNames;
         private readonly Dictionary<(Cursor cursor, Cursor context, Type type), (string typeName, string nativeTypeName)> _typeNames;
+        private readonly Dictionary<string, HashSet<string>> _validNameRemappings;
+        private readonly HashSet<string> _usedRemappings;
 
         private string _filePath;
         private string[] _clangCommandLineArgs;
@@ -90,6 +92,14 @@ public PInvokeGenerator(PInvokeGeneratorConfiguration config, Func<string, Strea
             _cursorNames = new Dictionary<NamedDecl, string>();
             _cursorQualifiedNames = new Dictionary<(NamedDecl, bool), string>();
             _typeNames = new Dictionary<(Cursor, Cursor, Type), (string, string)>();
+            _validNameRemappings = new Dictionary<string, HashSet<string>>() {
+                ["intptr_t"] = new HashSet<string>() { "IntPtr", "nint" },
+                ["ptrdiff_t"] = new HashSet<string>() { "IntPtr", "nint" },
+                ["size_t"] = new HashSet<string>() { "UIntPtr", "nuint" },
+                ["uintptr_t"] = new HashSet<string>() { "UIntPtr", "nuint" },
+                ["_GUID"] = new HashSet<string>() { "Guid" },
+            };
+            _usedRemappings = new HashSet<string>();
         }
 
         ~PInvokeGenerator()
@@ -121,7 +131,7 @@ public void Close()
             {
                 var iidName = foundUuid.Key;
 
-                if (_generatedUuids.Contains(iidName))
+                if (_generatedUuids.Contains(iidName) || _config.ExcludedNames.Contains(iidName))
                 {
                     continue;
                 }
@@ -355,6 +365,121 @@ public void GenerateBindings(TranslationUnit translationUnit, string filePath, s
                 {
                     Visit(translationUnit.TranslationUnitDecl);
                 }
+
+                if (_config.LogPotentialTypedefRemappings)
+                {
+                    foreach (var kvp in _validNameRemappings)
+                    {
+                        var name = kvp.Key;
+                        var remappings = kvp.Value;
+
+                        if (!_config.RemappedNames.TryGetValue(name, out var remappedName))
+                        {
+                            AddDiagnostic(DiagnosticLevel.Info, $"Potential missing remapping '{name}'. {GetFoundRemappingString(name, remappings)}");
+                        }
+                        else if (!remappings.Contains(remappedName) && (name != remappedName) && !_config.ForceRemappedNames.Contains(name))
+                        {
+                            AddDiagnostic(DiagnosticLevel.Info, $"Potential invalid remapping '{name}={remappedName}'. {GetFoundRemappingString(name, remappings)}");
+                        }
+                    }
+
+                    foreach (var name in _usedRemappings)
+                    {
+                        var remappedName = _config.RemappedNames[name];
+
+                        if (!_validNameRemappings.ContainsKey(name) && (name != remappedName) && !_config.ForceRemappedNames.Contains(name))
+                        {
+                            AddDiagnostic(DiagnosticLevel.Info, $"Potential invalid remapping '{name}={remappedName}'. No remappings were found.");
+                        }
+                    }
+
+                    static string GetFoundRemappingString(string name, HashSet<string> remappings)
+                    {
+                        var recommendedRemapping = "";
+
+                        if (remappings.Count == 1)
+                        {
+                            recommendedRemapping = remappings.Single();
+                        }
+
+                        if ((recommendedRemapping == "") && name.StartsWith("_"))
+                        {
+                            var remapping = name[1..];
+
+                            if (remappings.Contains(remapping))
+                            {
+                                recommendedRemapping = remapping;
+                            }
+                        }
+
+                        if ((recommendedRemapping == "") && name.StartsWith("tag"))
+                        {
+                            var remapping = name[3..];
+
+                            if (remappings.Contains(remapping))
+                            {
+                                recommendedRemapping = remapping;
+                            }
+                        }
+
+                        if ((recommendedRemapping == "") && name.EndsWith("_"))
+                        {
+                            var remapping = name[0..^1];
+
+                            if (remappings.Contains(remapping))
+                            {
+                                recommendedRemapping = remapping;
+                            }
+                        }
+
+                        if ((recommendedRemapping == "") && name.EndsWith("tag"))
+                        {
+                            var remapping = name[0..^3];
+
+                            if (remappings.Contains(remapping))
+                            {
+                                recommendedRemapping = remapping;
+                            }
+                        }
+
+                        if (recommendedRemapping == "")
+                        {
+                            var remapping = name.ToUpperInvariant();
+
+                            if (remappings.Contains(remapping))
+                            {
+                                recommendedRemapping = remapping;
+                            }
+                        }
+
+                        var result = "";
+                        var remainingRemappings = (IEnumerable<string>)remappings;
+                        var remainingString = "Found";
+
+                        if (recommendedRemapping != "")
+                        {
+                            result += $"Recommended remapping: '{name}={recommendedRemapping}'.";
+
+                            if (remappings.Count == 1)
+                            {
+                                remainingRemappings = Array.Empty<string>();
+                            }
+                            else
+                            {
+                                result += ' ';
+                                remainingRemappings = remappings.Except(new string[] { recommendedRemapping });
+                                remainingString = "Other";
+                            }
+                        }
+
+                        if (remainingRemappings.Any())
+                        {
+                            result += $"{remainingString} typedefs: {string.Join("; ", remainingRemappings)}";
+                        }
+
+                        return result;
+                    }
+                }
             }
             catch (Exception e)
             {
@@ -1336,20 +1461,29 @@ private string GetRemappedName(string name, Cursor cursor, bool tryRemapOperator
             if (_config.RemappedNames.TryGetValue(name, out var remappedName))
             {
                 wasRemapped = true;
+                _ = _usedRemappings.Add(name);
                 return AddUsingDirectiveIfNeeded(_outputBuilder, remappedName, skipUsing);
             }
 
-            if (name.StartsWith("const ") && _config.RemappedNames.TryGetValue(name[6..], out remappedName))
+            if (name.StartsWith("const "))
             {
-                wasRemapped = true;
-                return AddUsingDirectiveIfNeeded(_outputBuilder, remappedName, skipUsing);
+                var tmpName = name[6..];
+
+                if (_config.RemappedNames.TryGetValue(tmpName, out remappedName))
+                {
+
+                    wasRemapped = true;
+                    _ = _usedRemappings.Add(tmpName);
+                    return AddUsingDirectiveIfNeeded(_outputBuilder, remappedName, skipUsing);
+                }
             }
 
             remappedName = name;
 
             if ((cursor is FunctionDecl functionDecl) && tryRemapOperatorName && TryRemapOperatorName(ref remappedName, functionDecl))
             {
                 wasRemapped = true;
+                // We don't track remapped operators in _usedRemappings
                 return AddUsingDirectiveIfNeeded(_outputBuilder, remappedName, skipUsing);
             }
 
@@ -2607,6 +2741,17 @@ bool IsExcludedByName(Cursor cursor, out bool isExcludedByConflictingDefinition)
                 {
                     return false;
                 }
+
+                if (qualifiedName.Contains("ClangSharpMacro_"))
+                {
+                    qualifiedName = qualifiedName.Replace("ClangSharpMacro_", "");
+                }
+
+                if (name.Contains("ClangSharpMacro_"))
+                {
+                    name = name.Replace("ClangSharpMacro_", "");
+                }
+
                 if (cursor is RecordDecl recordDecl)
                 {
                     if (_config.ExcludeEmptyRecords && IsEmptyRecord(recordDecl))
diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGeneratorConfiguration.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGeneratorConfiguration.cs

Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,10 @@ private void VisitDecl(Decl decl)`
`21`	`21`	`{`
`22`	`22`	`if (IsExcluded(decl))`
`23`	`23`	`{`
	`24`	`+ if (decl.Kind == CX_DeclKind.CX_DeclKind_Typedef)`
	`25`	`+ {`
	`26`	`+ VisitTypedefDecl((TypedefDecl)decl, onlyHandleRemappings: true);`
	`27`	`+ }`
`24`	`28`	`return;`
`25`	`29`	`}`
`26`	`30`
`@@ -133,7 +137,7 @@ private void VisitDecl(Decl decl)`
`133`	`137`
`134`	`138`	`case CX_DeclKind.CX_DeclKind_Typedef:`
`135`	`139`	`{`
`136`		`- VisitTypedefDecl((TypedefDecl)decl);`
	`140`	`+ VisitTypedefDecl((TypedefDecl)decl, onlyHandleRemappings: false);`
`137`	`141`	`break;`
`138`	`142`	`}`
`139`	`143`
`@@ -268,7 +272,7 @@ private void VisitEnumConstantDecl(EnumConstantDecl enumConstantDecl)`
`268`	`272`	`var kind = isAnonymousEnum ? ValueKind.Primitive : ValueKind.Enumerator;`
`269`	`273`	`var flags = ValueFlags.Constant;`
`270`	`274`
`271`		`- if (enumConstantDecl.InitExpr is not null)`
	`275`	`+ if ((enumConstantDecl.InitExpr is not null) \|\| isAnonymousEnum)`
`272`	`276`	`{`
`273`	`277`	`flags \|= ValueFlags.Initializer;`
`274`	`278`	`}`
`@@ -2411,13 +2415,13 @@ private void VisitTypeAliasDecl(TypeAliasDecl typeAliasDecl)`
`2411`	`2415`	`// Nothing to generate for type alias declarations`
`2412`	`2416`	`}`
`2413`	`2417`
`2414`		`- private void VisitTypedefDecl(TypedefDecl typedefDecl)`
	`2418`	`+ private void VisitTypedefDecl(TypedefDecl typedefDecl, bool onlyHandleRemappings)`
`2415`	`2419`	`{`
`2416`		`- ForUnderlyingType(typedefDecl, typedefDecl.UnderlyingType);`
	`2420`	`+ ForUnderlyingType(typedefDecl, typedefDecl.UnderlyingType, onlyHandleRemappings);`
`2417`	`2421`
`2418`		`- void ForFunctionProtoType(TypedefDecl typedefDecl, FunctionProtoType functionProtoType, Type parentType)`
	`2422`	`+ void ForFunctionProtoType(TypedefDecl typedefDecl, FunctionProtoType functionProtoType, Type parentType, bool onlyHandleRemappings)`
`2419`	`2423`	`{`
`2420`		`- if (!_config.ExcludeFnptrCodegen)`
	`2424`	`+ if (!_config.ExcludeFnptrCodegen \|\| onlyHandleRemappings)`
`2421`	`2425`	`{`
`2422`	`2426`	`return;`
`2423`	`2427`	`}`
`@@ -2457,43 +2461,43 @@ void ForFunctionProtoType(TypedefDecl typedefDecl, FunctionProtoType functionPro`
`2457`	`2461`	`StopUsingOutputBuilder();`
`2458`	`2462`	`}`
`2459`	`2463`
`2460`		`- void ForPointeeType(TypedefDecl typedefDecl, Type parentType, Type pointeeType)`
	`2464`	`+ void ForPointeeType(TypedefDecl typedefDecl, Type parentType, Type pointeeType, bool onlyHandleRemappings)`
`2461`	`2465`	`{`
`2462`	`2466`	`if (pointeeType is AttributedType attributedType)`
`2463`	`2467`	`{`
`2464`		`- ForPointeeType(typedefDecl, attributedType, attributedType.ModifiedType);`
	`2468`	`+ ForPointeeType(typedefDecl, attributedType, attributedType.ModifiedType, onlyHandleRemappings);`
`2465`	`2469`	`}`
`2466`	`2470`	`else if (pointeeType is ElaboratedType elaboratedType)`
`2467`	`2471`	`{`
`2468`		`- ForPointeeType(typedefDecl, elaboratedType, elaboratedType.NamedType);`
	`2472`	`+ ForPointeeType(typedefDecl, elaboratedType, elaboratedType.NamedType, onlyHandleRemappings);`
`2469`	`2473`	`}`
`2470`	`2474`	`else if (pointeeType is FunctionProtoType functionProtoType)`
`2471`	`2475`	`{`
`2472`		`- ForFunctionProtoType(typedefDecl, functionProtoType, parentType);`
	`2476`	`+ ForFunctionProtoType(typedefDecl, functionProtoType, parentType, onlyHandleRemappings);`
`2473`	`2477`	`}`
`2474`	`2478`	`else if (pointeeType is PointerType pointerType)`
`2475`	`2479`	`{`
`2476`		`- ForPointeeType(typedefDecl, pointerType, pointerType.PointeeType);`
	`2480`	`+ ForPointeeType(typedefDecl, pointerType, pointerType.PointeeType, onlyHandleRemappings);`
`2477`	`2481`	`}`
`2478`	`2482`	`else if (pointeeType is TypedefType typedefType)`
`2479`	`2483`	`{`
`2480`		`- ForPointeeType(typedefDecl, typedefType, typedefType.Decl.UnderlyingType);`
	`2484`	`+ ForPointeeType(typedefDecl, typedefType, typedefType.Decl.UnderlyingType, onlyHandleRemappings);`
`2481`	`2485`	`}`
`2482`	`2486`	`else if (pointeeType is not ConstantArrayType and not BuiltinType and not TagType and not TemplateTypeParmType)`
`2483`	`2487`	`{`
`2484`	`2488`	`AddDiagnostic(DiagnosticLevel.Error, $"Unsupported pointee type: '{pointeeType.TypeClassSpelling}'. Generating bindings may be incomplete.", typedefDecl);`
`2485`	`2489`	`}`
`2486`	`2490`	`}`
`2487`	`2491`
`2488`		`- void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType)`
	`2492`	`+ void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType, bool onlyHandleRemappings)`
`2489`	`2493`	`{`
`2490`	`2494`	`if (underlyingType is ArrayType arrayType)`
`2491`	`2495`	`{`
`2492`	`2496`	`// Nothing to do for array types`
`2493`	`2497`	`}`
`2494`	`2498`	`else if (underlyingType is AttributedType attributedType)`
`2495`	`2499`	`{`
`2496`		`- ForUnderlyingType(typedefDecl, attributedType.ModifiedType);`
	`2500`	`+ ForUnderlyingType(typedefDecl, attributedType.ModifiedType, onlyHandleRemappings);`
`2497`	`2501`	`}`
`2498`	`2502`	`else if (underlyingType is BuiltinType builtinType)`
`2499`	`2503`	`{`
`@@ -2505,46 +2509,41 @@ void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType)`
`2505`	`2509`	`}`
`2506`	`2510`	`else if (underlyingType is ElaboratedType elaboratedType)`
`2507`	`2511`	`{`
`2508`		`- ForUnderlyingType(typedefDecl, elaboratedType.NamedType);`
	`2512`	`+ ForUnderlyingType(typedefDecl, elaboratedType.NamedType, onlyHandleRemappings);`
`2509`	`2513`	`}`
`2510`	`2514`	`else if (underlyingType is FunctionProtoType functionProtoType)`
`2511`	`2515`	`{`
`2512`		`- ForFunctionProtoType(typedefDecl, functionProtoType, parentType: null);`
	`2516`	`+ ForFunctionProtoType(typedefDecl, functionProtoType, parentType: null, onlyHandleRemappings);`
`2513`	`2517`	`}`
`2514`	`2518`	`else if (underlyingType is PointerType pointerType)`
`2515`	`2519`	`{`
`2516`		`- ForPointeeType(typedefDecl, parentType: null, pointerType.PointeeType);`
	`2520`	`+ ForPointeeType(typedefDecl, parentType: null, pointerType.PointeeType, onlyHandleRemappings);`
`2517`	`2521`	`}`
`2518`	`2522`	`else if (underlyingType is ReferenceType referenceType)`
`2519`	`2523`	`{`
`2520`		`- ForPointeeType(typedefDecl, parentType: null, referenceType.PointeeType);`
	`2524`	`+ ForPointeeType(typedefDecl, parentType: null, referenceType.PointeeType, onlyHandleRemappings);`
`2521`	`2525`	`}`
`2522`	`2526`	`else if (underlyingType is TagType underlyingTagType)`
`2523`	`2527`	`{`
`2524`		`- // See if there's a potential typedef remapping we want to log`
`2525`		`- if (_config.LogPotentialTypedefRemappings)`
`2526`		`- {`
`2527`		`- var typedefName = typedefDecl.UnderlyingDecl.Name;`
`2528`		`- var possibleNamesToRemap = new string[] {"_" + typedefName, "_tag" + typedefName, "tag" + typedefName, typedefName + "_tag" };`
`2529`		`- var underlyingName = underlyingTagType.AsString;`
	`2528`	`+ var underlyingName = GetCursorName(underlyingTagType.AsTagDecl);`
	`2529`	`+ var typedefName = GetCursorName(typedefDecl);`
`2530`	`2530`
`2531`		`- foreach (var possibleNameToRemap in possibleNamesToRemap)`
	`2531`	`+ if (underlyingName != typedefName)`
	`2532`	`+ {`
	`2533`	`+ if (!_validNameRemappings.TryGetValue(underlyingName, out var remappings))`
`2532`	`2534`	`{`
`2533`		`- if (!_config.RemappedNames.ContainsKey(possibleNameToRemap) && !_config.RemappedNames.ContainsKey(possibleNameToRemap + "*"))`
`2534`		`- {`
`2535`		`- if (possibleNameToRemap == underlyingName)`
`2536`		`- {`
`2537`		`- AddDiagnostic(DiagnosticLevel.Info, $"Potential remap: {possibleNameToRemap}={typedefName}");`
`2538`		`- }`
`2539`		`- }`
	`2535`	`+ remappings = new HashSet<string>();`
	`2536`	`+ _validNameRemappings[underlyingName] = remappings;`
`2540`	`2537`	`}`
	`2538`	`+`
	`2539`	`+ _ = remappings.Add(typedefName);`
`2541`	`2540`	`}`
`2542`	`2541`	`}`
`2543`	`2542`	`else if (underlyingType is TemplateSpecializationType templateSpecializationType)`
`2544`	`2543`	`{`
`2545`	`2544`	`if (templateSpecializationType.IsTypeAlias)`
`2546`	`2545`	`{`
`2547`		`- ForUnderlyingType(typedefDecl, templateSpecializationType.AliasedType);`
	`2546`	`+ ForUnderlyingType(typedefDecl, templateSpecializationType.AliasedType, onlyHandleRemappings);`
`2548`	`2547`	`}`
`2549`	`2548`	`else`
`2550`	`2549`	`{`
`@@ -2557,7 +2556,7 @@ void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType)`
`2557`	`2556`	`}`
`2558`	`2557`	`else if (underlyingType is TypedefType typedefType)`
`2559`	`2558`	`{`
`2560`		`- ForUnderlyingType(typedefDecl, typedefType.Decl.UnderlyingType);`
	`2559`	`+ ForUnderlyingType(typedefDecl, typedefType.Decl.UnderlyingType, onlyHandleRemappings);`
`2561`	`2560`	`}`
`2562`	`2561`	`else`
`2563`	`2562`	`{`