[Analyzer] compiler warnings and errors are pointing to user code

PawelGerr · PawelGerr · commit 4088f5039479 · 2025-11-08T23:12:34.000+01:00
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Copyright>(c) $([System.DateTime]::Now.Year), Pawel Gerr. All rights reserved.</Copyright>
-    <VersionPrefix>9.6.5</VersionPrefix>
+    <VersionPrefix>9.6.6</VersionPrefix>
     <Authors>Pawel Gerr</Authors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageProjectUrl>https://github.com/PawelGerr/Thinktecture.Runtime.Extensions</PackageProjectUrl>
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Diagnostics/ThinktectureRuntimeExtensionsAnalyzer.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/Diagnostics/ThinktectureRuntimeExtensionsAnalyzer.cs
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/InstanceMemberInfo.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/InstanceMemberInfo.cs
@@ -166,10 +166,10 @@ private static bool IsDisallowingDefaultValue(ITypeSymbol type)
    public Location? GetIdentifierLocation(CancellationToken cancellationToken)
    {
       if (_symbol.Field is not null)
-         return _symbol.Field.GetIdentifier(cancellationToken)?.GetLocation() ?? Location.None;
+         return _symbol.Field.GetFieldLocation(cancellationToken);
 
       if (_symbol.Property is not null)
-         return _symbol.Property.GetIdentifier(cancellationToken)?.GetLocation() ?? Location.None;
+         return _symbol.Property.GetPropertyLocation(PropertyDeclarationSyntaxKind.All, cancellationToken);
 
       return null;
    }
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/JsonSmartEnumCodeGeneratorFactory.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/JsonSmartEnumCodeGeneratorFactory.cs
@@ -17,10 +17,10 @@ protected JsonKeyedSerializerCodeGeneratorFactoryBase(
    public bool MustGenerateCode(KeyedSerializerGeneratorState state)
    {
       if (state.AttributeInfo.HasJsonConverterAttribute
-          || !state.SerializationFrameworks.HasFlag(SerializationFrameworks.SystemTextJson))
+          || !state.SerializationFrameworks.HasSerializationFramework(SerializationFrameworks.SystemTextJson))
          return false;
 
-      var hasObjectFactory = state.AttributeInfo.ObjectFactories.Any(f => f.UseForSerialization.Has(SerializationFrameworks.SystemTextJson));
+      var hasObjectFactory = state.AttributeInfo.ObjectFactories.Any(f => f.UseForSerialization.HasSerializationFramework(SerializationFrameworks.SystemTextJson));
 
       if (_isForObjectFactories)
          return hasObjectFactory;
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedJsonCodeGenerator.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedJsonCodeGenerator.cs
@@ -20,7 +20,7 @@ public override void Generate(CancellationToken cancellationToken)
    {
       var customFactory = _state.AttributeInfo
                                 .ObjectFactories
-                                .FirstOrDefault(f => f.UseForSerialization.Has(SerializationFrameworks.SystemTextJson));
+                                .FirstOrDefault(f => f.UseForSerialization.HasSerializationFramework(SerializationFrameworks.SystemTextJson));
       var keyType = customFactory?.TypeFullyQualified ?? _state.KeyMember?.TypeFullyQualified;
       var isString = customFactory is null
                         ? _state.KeyMember?.SpecialType == SpecialType.System_String
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedMessagePackCodeGenerator.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedMessagePackCodeGenerator.cs
@@ -20,7 +20,7 @@ public override void Generate(CancellationToken cancellationToken)
    {
       var customFactory = _state.AttributeInfo
                                 .ObjectFactories
-                                .FirstOrDefault(f => f.UseForSerialization.Has(SerializationFrameworks.MessagePack));
+                                .FirstOrDefault(f => f.UseForSerialization.HasSerializationFramework(SerializationFrameworks.MessagePack));
       var keyType = customFactory?.TypeFullyQualified ?? _state.KeyMember?.TypeFullyQualified;
 
       _sb.Append(GENERATED_CODE_PREFIX).Append(@"
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedNewtonsoftJsonCodeGenerator.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/KeyedNewtonsoftJsonCodeGenerator.cs
@@ -20,7 +20,7 @@ public override void Generate(CancellationToken cancellationToken)
    {
       var customFactory = _state.AttributeInfo
                                 .ObjectFactories
-                                .FirstOrDefault(f => f.UseForSerialization.Has(SerializationFrameworks.NewtonsoftJson));
+                                .FirstOrDefault(f => f.UseForSerialization.HasSerializationFramework(SerializationFrameworks.NewtonsoftJson));
       var keyType = customFactory?.TypeFullyQualified ?? _state.KeyMember?.TypeFullyQualified;
 
       _sb.Append(GENERATED_CODE_PREFIX).Append(@"
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/MessagePackSmartEnumCodeGeneratorFactory.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/MessagePackSmartEnumCodeGeneratorFactory.cs
@@ -16,10 +16,10 @@ protected MessagePackKeyedSerializerCodeGeneratorFactoryBase(
    public bool MustGenerateCode(KeyedSerializerGeneratorState state)
    {
       if (state.AttributeInfo.HasMessagePackFormatterAttribute
-          || !state.SerializationFrameworks.HasFlag(SerializationFrameworks.MessagePack))
+          || !state.SerializationFrameworks.HasSerializationFramework(SerializationFrameworks.MessagePack))
          return false;
 
-      var hasObjectFactory = state.AttributeInfo.ObjectFactories.Any(f => f.UseForSerialization.Has(SerializationFrameworks.MessagePack));
+      var hasObjectFactory = state.AttributeInfo.ObjectFactories.Any(f => f.UseForSerialization.HasSerializationFramework(SerializationFrameworks.MessagePack));
 
       if (_isForObjectFactories)
          return hasObjectFactory;
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/NewtonsoftJsonSmartEnumCodeGeneratorFactory.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/NewtonsoftJsonSmartEnumCodeGeneratorFactory.cs
@@ -17,10 +17,10 @@ protected NewtonsoftJsonKeyedSerializerCodeGeneratorFactoryBase(
    public bool MustGenerateCode(KeyedSerializerGeneratorState state)
    {
       if (state.AttributeInfo.HasNewtonsoftJsonConverterAttribute
-          || !state.SerializationFrameworks.HasFlag(SerializationFrameworks.NewtonsoftJson))
+          || !state.SerializationFrameworks.HasSerializationFramework(SerializationFrameworks.NewtonsoftJson))
          return false;
 
-      var hasObjectFactory = state.AttributeInfo.ObjectFactories.Any(f => f.UseForSerialization.Has(SerializationFrameworks.NewtonsoftJson));
+      var hasObjectFactory = state.AttributeInfo.ObjectFactories.Any(f => f.UseForSerialization.HasSerializationFramework(SerializationFrameworks.NewtonsoftJson));
 
       if (_isForObjectFactories)
          return hasObjectFactory;
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/PropertyDeclarationSyntaxKind.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/CodeAnalysis/PropertyDeclarationSyntaxKind.cs
@@ -0,0 +1,10 @@
+namespace Thinktecture.CodeAnalysis;
+
+[Flags]
+public enum PropertyDeclarationSyntaxKind
+{
+   Implementation = 1 << 0,
+   DeclarationOnly = 1 << 1,
+
+   All = Implementation | DeclarationOnly
+}
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/AttributeOperationExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/AttributeOperationExtensions.cs
@@ -0,0 +1,15 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Thinktecture;
+
+public static class AttributeOperationExtensions
+{
+   public static Location GetTypeDeclarationLocationFromAttribute(this IAttributeOperation attributeOperation)
+   {
+      var attrSyntax = (AttributeSyntax)attributeOperation.Syntax;
+      var tds = attrSyntax.FirstAncestorOrSelf<TypeDeclarationSyntax>();
+
+      return tds?.Identifier.GetLocation() ?? attrSyntax.GetLocation();
+   }
+}
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/EventSymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/EventSymbolExtensions.cs
@@ -0,0 +1,60 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Thinktecture;
+
+public static class EventSymbolExtensions
+{
+   public static Location GetEventLocation(this IEventSymbol eventSymbol, CancellationToken cancellationToken)
+   {
+      Location? inSourceLocation = null;
+      Location? fallbackLocation = null;
+
+      for (var i = 0; i < eventSymbol.DeclaringSyntaxReferences.Length; i++)
+      {
+         var node = eventSymbol.DeclaringSyntaxReferences[i].GetSyntax(cancellationToken);
+
+         if (node.SyntaxTree is not { } tree || tree.IsGeneratedTree(cancellationToken))
+            continue;
+
+         switch (node)
+         {
+            case EventDeclarationSyntax eds:
+               return eds.Identifier.GetLocation();
+
+            case VariableDeclaratorSyntax vds:
+               // event field syntax: event T E1, E2;
+               return vds.Identifier.GetLocation();
+
+            case EventFieldDeclarationSyntax efds:
+            {
+               for (var j = 0; j < efds.Declaration.Variables.Count; j++)
+               {
+                  var variableSyntax = efds.Declaration.Variables[j];
+
+                  if (StringComparer.Ordinal.Equals(variableSyntax.Identifier.ValueText, eventSymbol.Name))
+                     return variableSyntax.Identifier.GetLocation();
+               }
+
+               return efds.GetLocation();
+            }
+            default:
+            {
+               var location = node.GetLocation();
+
+               if (location.IsInSource)
+               {
+                  inSourceLocation ??= location;
+               }
+               else
+               {
+                  fallbackLocation ??= location;
+               }
+
+               break;
+            }
+         }
+      }
+
+      return inSourceLocation ?? fallbackLocation ?? Location.None;
+   }
+}
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/FieldSymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/FieldSymbolExtensions.cs
@@ -1,22 +1,82 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Thinktecture.CodeAnalysis;
 
 namespace Thinktecture;
 
 public static class FieldSymbolExtensions
 {
-   public static SyntaxToken? GetIdentifier(this IFieldSymbol field, CancellationToken cancellationToken)
+   public static Location GetFieldLocation(this IFieldSymbol field, CancellationToken cancellationToken)
    {
-      if (field.DeclaringSyntaxReferences.IsDefaultOrEmpty)
-         return null;
+      // 1) Synthesized/backing fields: anchor to associated symbol or containing type
+      if (field.IsImplicitlyDeclared)
+      {
+         switch (field.AssociatedSymbol)
+         {
+            case IPropertySymbol property:
+               // Prefer the property’s identifier location in user code
+               return property.GetPropertyLocation(PropertyDeclarationSyntaxKind.All, cancellationToken);
 
-      if (field.DeclaringSyntaxReferences[0].GetSyntax(cancellationToken) is VariableDeclaratorSyntax variableDeclaration)
-         return variableDeclaration.Identifier;
+            case IEventSymbol eventSymbol:
+               // Prefer the event’s identifier location in user code
+               return eventSymbol.GetEventLocation(cancellationToken);
+         }
 
-      return null;
-   }
+         // Enum underlying field "value__" and other synthesized fields: use containing type
+         return field.ContainingType.GetTypeIdentifierLocation(cancellationToken);
+      }
 
-   public static bool IsPropertyBackingField(this IFieldSymbol field)
-   {
-      return field.AssociatedSymbol is IPropertySymbol;
+      // 2) Prefer the exact declarator/identifier in a non-generated tree
+      Location? inSourceLocation = null;
+      Location? fallbackLocation = null;
+
+      for (var i = 0; i < field.DeclaringSyntaxReferences.Length; i++)
+      {
+         var node = field.DeclaringSyntaxReferences[i].GetSyntax(cancellationToken);
+
+         if (node.SyntaxTree is not { } tree || tree.IsGeneratedTree(cancellationToken))
+            continue;
+
+         switch (node)
+         {
+            case VariableDeclaratorSyntax vds:
+               return vds.Identifier.GetLocation();
+
+            case EnumMemberDeclarationSyntax emds:
+               return emds.Identifier.GetLocation();
+
+            // Rare, but handle conservatively
+            case FieldDeclarationSyntax fds:
+            {
+               // When the reference points to the FieldDeclaration, find the matching declarator
+               for (var j = 0; j < fds.Declaration.Variables.Count; j++)
+               {
+                  var variable = fds.Declaration.Variables[j];
+
+                  if (StringComparer.Ordinal.Equals(variable.Identifier.ValueText, field.Name))
+                     return variable.Identifier.GetLocation();
+               }
+
+               // Fallback to whole declaration location
+               return fds.GetLocation();
+            }
+            default:
+            {
+               var location = node.GetLocation();
+
+               if (location.IsInSource)
+               {
+                  inSourceLocation ??= location;
+               }
+               else
+               {
+                  fallbackLocation ??= location;
+               }
+
+               break;
+            }
+         }
+      }
+
+      return inSourceLocation ?? fallbackLocation ?? Location.None;
    }
 }
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/NamedTypeSymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/NamedTypeSymbolExtensions.cs
@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Thinktecture.CodeAnalysis;
 using Thinktecture.CodeAnalysis.SmartEnums;
 
@@ -116,4 +117,36 @@ public static bool HasLowerAccessibility(
 
       return false;
    }
+
+   public static Location GetTypeIdentifierLocation(this INamedTypeSymbol type, CancellationToken cancellationToken)
+   {
+      Location? inSourceLocation = null;
+      Location? fallbackLocation = null;
+
+      for (var i = 0; i < type.DeclaringSyntaxReferences.Length; i++)
+      {
+         var node = type.DeclaringSyntaxReferences[i].GetSyntax(cancellationToken);
+
+         if (node is TypeDeclarationSyntax tds)
+         {
+            if (tds.SyntaxTree.IsGeneratedTree(cancellationToken))
+               continue;
+
+            return tds.Identifier.GetLocation();
+         }
+
+         var location = node.GetLocation();
+
+         if (location.IsInSource)
+         {
+            inSourceLocation ??= location;
+         }
+         else
+         {
+            fallbackLocation ??= location;
+         }
+      }
+
+      return inSourceLocation ?? fallbackLocation ?? Location.None;
+   }
 }
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/PropertyDeclarationSyntaxKindExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/PropertyDeclarationSyntaxKindExtensions.cs
@@ -0,0 +1,11 @@
+using Thinktecture.CodeAnalysis;
+
+namespace Thinktecture;
+
+public static class PropertyDeclarationSyntaxKindExtensions
+{
+   public static bool HasKind(this PropertyDeclarationSyntaxKind kind, PropertyDeclarationSyntaxKind kindToCheckFor)
+   {
+      return (kind & kindToCheckFor) == kindToCheckFor;
+   }
+}
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/PropertySymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/PropertySymbolExtensions.cs
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/SyntaxTreeExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/SyntaxTreeExtensions.cs
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeSymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeSymbolExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -166,10 +166,10 @@ private static bool IsDisallowingDefaultValue(ITypeSymbol type)`
`166`	`166`	`public Location? GetIdentifierLocation(CancellationToken cancellationToken)`
`167`	`167`	`{`
`168`	`168`	`if (_symbol.Field is not null)`
`169`		`- return _symbol.Field.GetIdentifier(cancellationToken)?.GetLocation() ?? Location.None;`
	`169`	`+ return _symbol.Field.GetFieldLocation(cancellationToken);`
`170`	`170`
`171`	`171`	`if (_symbol.Property is not null)`
`172`		`- return _symbol.Property.GetIdentifier(cancellationToken)?.GetLocation() ?? Location.None;`
	`172`	`+ return _symbol.Property.GetPropertyLocation(PropertyDeclarationSyntaxKind.All, cancellationToken);`
`173`	`173`
`174`	`174`	`return null;`
`175`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public override void Generate(CancellationToken cancellationToken)`
`20`	`20`	`{`
`21`	`21`	`var customFactory = _state.AttributeInfo`
`22`	`22`	`.ObjectFactories`
`23`		`- .FirstOrDefault(f => f.UseForSerialization.Has(SerializationFrameworks.SystemTextJson));`
	`23`	`+ .FirstOrDefault(f => f.UseForSerialization.HasSerializationFramework(SerializationFrameworks.SystemTextJson));`
`24`	`24`	`var keyType = customFactory?.TypeFullyQualified ?? _state.KeyMember?.TypeFullyQualified;`
`25`	`25`	`var isString = customFactory is null`
`26`	`26`	`? _state.KeyMember?.SpecialType == SpecialType.System_String`