Use semantic lookup instead of assembly references

Replace fragile assembly reference checking with semantic lookup using ContainsDurableSymbols. This checks if an assembly contains any Durable Task types (TaskActivity, ITaskOrchestrator, ActivityTriggerAttribute, OrchestrationTriggerAttribute) by examining the symbol tree, which is more robust and maintainable than checking package references.

Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com>

Author: Copilot

src/Analyzers/Activities/FunctionNotFoundAnalyzer.cs

@@ -360,7 +360,7 @@ static void ScanReferencedAssemblies(
         CancellationToken cancellationToken)
     {
         // Scan all referenced assemblies for activities and orchestrators
-        // Skip system assemblies and assemblies without Durable Task references for performance
+        // Skip system assemblies and assemblies without Durable symbols for performance
         foreach (MetadataReference reference in compilation.References)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -375,7 +375,7 @@ static void ScanReferencedAssemblies(
                 continue;
             }
 
-            if (!ShouldScanAssembly(assembly))
+            if (!ShouldScanAssembly(assembly, knownSymbols))
             {
                 continue;
             }
@@ -409,18 +409,59 @@ static bool IsSystemAssembly(IAssemblySymbol assembly)
         return false;
     }
 
-    static bool ShouldScanAssembly(IAssemblySymbol assembly)
+    static bool ShouldScanAssembly(IAssemblySymbol assembly, KnownTypeSymbols knownSymbols)
     {
-        // Only scan assemblies that reference Durable Task types
-        // This filters out transitive dependencies that don't contain activities/orchestrators
-        foreach (AssemblyIdentity referencedAssembly in assembly.Modules.SelectMany(m => m.ReferencedAssemblies))
+        // Check if assembly contains any Durable Task symbols using semantic lookup
+        // This is more robust than checking assembly references
+        return ContainsDurableSymbols(assembly.GlobalNamespace, knownSymbols);
+    }
+
+    static bool ContainsDurableSymbols(INamespaceSymbol namespaceSymbol, KnownTypeSymbols knownSymbols)
+    {
+        // Check types in this namespace for Durable Task symbols
+        foreach (INamedTypeSymbol typeSymbol in namespaceSymbol.GetTypeMembers())
         {
-            string refName = referencedAssembly.Name;
-            // Check for packages that users directly reference when defining activities/orchestrators
-            // Microsoft.DurableTask.Worker: for non-function scenarios (console apps, etc.)
-            // Microsoft.Azure.Functions.Worker.Extensions.DurableTask: for Azure Functions scenarios
-            if (refName == "Microsoft.DurableTask.Worker" ||
-                refName == "Microsoft.Azure.Functions.Worker.Extensions.DurableTask")
+            // Check if type derives from TaskActivity
+            if (knownSymbols.TaskActivityBase != null && DerivesFrom(typeSymbol, knownSymbols.TaskActivityBase))
+            {
+                return true;
+            }
+
+            // Check if type implements ITaskOrchestrator
+            if (knownSymbols.TaskOrchestratorInterface != null && 
+                ImplementsInterface(typeSymbol, knownSymbols.TaskOrchestratorInterface))
+            {
+                return true;
+            }
+
+            // Check methods for Durable Task attributes
+            foreach (ISymbol member in typeSymbol.GetMembers())
+            {
+                if (member is not IMethodSymbol methodSymbol)
+                {
+                    continue;
+                }
+
+                // Check for ActivityTrigger attribute
+                if (knownSymbols.ActivityTriggerAttribute != null &&
+                    methodSymbol.ContainsAttributeInAnyMethodArguments(knownSymbols.ActivityTriggerAttribute))
+                {
+                    return true;
+                }
+
+                // Check for OrchestrationTrigger attribute
+                if (knownSymbols.FunctionOrchestrationAttribute != null &&
+                    methodSymbol.ContainsAttributeInAnyMethodArguments(knownSymbols.FunctionOrchestrationAttribute))
+                {
+                    return true;
+                }
+            }
+        }
+
+        // Recursively check nested namespaces
+        foreach (INamespaceSymbol nestedNamespace in namespaceSymbol.GetNamespaceMembers())
+        {
+            if (ContainsDurableSymbols(nestedNamespace, knownSymbols))
             {
                 return true;
             }
@@ -429,6 +470,20 @@ static bool ShouldScanAssembly(IAssemblySymbol assembly)
         return false;
     }
 
+    static bool DerivesFrom(INamedTypeSymbol typeSymbol, INamedTypeSymbol baseType)
+    {
+        INamedTypeSymbol? current = typeSymbol.BaseType;
+        while (current != null)
+        {
+            if (SymbolEqualityComparer.Default.Equals(current.OriginalDefinition, baseType))
+            {
+                return true;
+            }
+            current = current.BaseType;
+        }
+        return false;
+    }
+
     static void ScanNamespaceForFunctions(
         INamespaceSymbol namespaceSymbol,
         KnownTypeSymbols knownSymbols,