Fix Firebase binding surface coverage false positives (#154)

Author: AdamEssenmacher

scripts/FirebaseBindingAudit.Tests/BindingSurfaceCoverageBuilderTests.cs

@@ -464,6 +464,53 @@ public interface AuthMarker
         }
     }
 
+    [Fact]
+    public void Build_DoesNotTreatApiDefinitionHelperExportsAsNativeClasses()
+    {
+        var repoRoot = Path.Combine(Path.GetTempPath(), $"firebase-binding-surface-builder-{Guid.NewGuid():N}");
+
+        try
+        {
+            var sourceDirectory = Path.Combine(repoRoot, "source", "Firebase", "Auth");
+            Directory.CreateDirectory(sourceDirectory);
+            File.WriteAllText(
+                Path.Combine(sourceDirectory, "ApiDefinition.cs"),
+                """
+                namespace Firebase.Auth;
+
+                public interface InstallationIdChangedEventArgs
+                {
+                    [Export("kFIRInstallationIDDidChangeNotificationAppNameKey")]
+                    string AppName { get; set; }
+                }
+                """);
+
+            var document = new BindingSurfaceCoverageBuilder(CreateConfiguration()).Build(
+                repoRoot,
+                CreateManifest(),
+                "Auth");
+
+            var surface = Assert.Single(
+                document.Targets.Single().Surfaces,
+                static surface => surface.MemberName == "AppName");
+
+            Assert.Equal("manual-property", surface.Kind);
+            Assert.Null(surface.ObjectiveCName);
+            Assert.Empty(surface.NativeSelectors);
+            Assert.Equal("Export", surface.BindingAttribute);
+            Assert.Equal("kFIRInstallationIDDidChangeNotificationAppNameKey", surface.BindingValue);
+            Assert.True(surface.HasGetter);
+            Assert.False(surface.HasSetter);
+        }
+        finally
+        {
+            if (Directory.Exists(repoRoot))
+            {
+                Directory.Delete(repoRoot, recursive: true);
+            }
+        }
+    }
+
     [Fact]
     public void Build_IncludesImplicitlyPublicInterfaceHelperMembers()
     {

scripts/FirebaseBindingAudit/BindingModel.cs

@@ -327,9 +327,8 @@ private static void AddManualTypeItems(
             {
                 Kind = ToManualMemberKind(member.Kind),
                 ContainerKind = isStatic ? "static class" : containerKind,
-                ObjectiveCName = string.Equals(member.BindingAttribute, "Export", StringComparison.Ordinal) ? typeMatchKey : null,
                 HasGetter = member.HasGetter,
-                HasSetter = member.HasSetter
+                HasSetter = false
             });
         }
     }

scripts/FirebaseBindingAudit/BindingSurfaceCoverage.cs

@@ -967,6 +967,11 @@ private static IReadOnlyList<BindingSurfaceNativeSelector> BuildManualNativeSele
         string? bindingAttribute,
         string? bindingValue)
     {
+        if (string.IsNullOrWhiteSpace(manualItem.ObjectiveCName))
+        {
+            return EmptySelectors;
+        }
+
         if (!string.Equals(bindingAttribute, "Export", StringComparison.Ordinal) ||
             string.IsNullOrWhiteSpace(bindingValue))
         {

tests/E2E/Firebase.Foundation/FirebaseFoundationE2E/FirebaseBindingSurfaceCoverage.cs

@@ -753,11 +753,27 @@ static IReadOnlyList<string> CreateTypeNameCandidates(Type type)
 
             AddTypeNameCandidate(candidates, type.Name);
             AddTypeNameCandidate(candidates, type.FullName);
+            AddTypeNameSuffixCandidates(candidates, type.FullName);
         }
 
         return candidates;
     }
 
+    static void AddTypeNameSuffixCandidates(List<string> candidates, string? typeName)
+    {
+        var normalizedTypeName = NormalizeTypeName(typeName);
+        if (string.IsNullOrWhiteSpace(normalizedTypeName))
+        {
+            return;
+        }
+
+        var parts = normalizedTypeName.Split('.');
+        for (var index = 1; index < parts.Length - 1; index++)
+        {
+            AddTypeNameCandidate(candidates, string.Join('.', parts[index..]));
+        }
+    }
+
     static IEnumerable<string> CreateGenericTypeNameCandidates(Type genericDefinition)
     {
         yield return StripGenericArity(genericDefinition.Name);