refactor(#127): fix Rider/Unity background generator crashes and caching issues

PereViader · PereViader · commit 8d23f1b315d7 · 2026-06-26T22:03:03.000+02:00
- Convert the `Generate` method to `static` in both Sync and Async source generators. This prevents the incremental compilation delegates from capturing the generator instance, which was breaking Rider's background incremental updates.
- Introduce a 100-iteration depth safety net to all recursive `BaseType` traversal loops in `GetClassData` to prevent infinite analyzer hangs and freezes when typing incomplete or cyclic inheritance hierarchies.
- Add null-safety guards to the `GetNonNullableType`, `FullyQualifyTypeWithoutNullable`, and `IsNullableTypeSymbol` helpers to prevent compiler crashes on unresolved types during background analysis.
diff --git a/ManualDi.Async/ManualDi.Async.Generators/ManualDiSourceGenerator.cs b/ManualDi.Async/ManualDi.Async.Generators/ManualDiSourceGenerator.cs
@@ -23,7 +23,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     GetClassData)
                 .Where(x => x is not null);
 
-            context.RegisterSourceOutput(classData, Generate!);
+            context.RegisterSourceOutput(classData, static (spc, data) => Generate(spc, data!));
         }
 
         private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)
@@ -93,15 +93,17 @@ private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)
                 baseTypesAndInterfaces.Add(i.ToDisplayString());
             }
             var tempBase = symbol.BaseType;
-            while (tempBase != null)
+            int tempBaseDepth = 0;
+            while (tempBase != null && tempBaseDepth++ < 100)
             {
                 baseTypesAndInterfaces.Add(tempBase.ToDisplayString());
                 tempBase = tempBase.BaseType;
             }
 
             INamedTypeSymbol? baseDiSymbol = null;
             var currentBase = symbol.BaseType;
-            while (currentBase != null)
+            int currentBaseDepth = 0;
+            while (currentBase != null && currentBaseDepth++ < 100)
             {
                 if (wellKnownTypes.HasManualDiAttribute(currentBase))
                 {
@@ -121,7 +123,8 @@ private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)
                     baseDiTypesAndInterfaces.Add(i.ToDisplayString());
                 }
                 var tempBaseDi = baseDiSymbol.BaseType;
-                while (tempBaseDi != null)
+                int tempBaseDiDepth = 0;
+                while (tempBaseDi != null && tempBaseDiDepth++ < 100)
                 {
                     baseDiTypesAndInterfaces.Add(tempBaseDi.ToDisplayString());
                     tempBaseDi = tempBaseDi.BaseType;
@@ -394,7 +397,7 @@ private static Resolution CreateResolution(IParameterSymbol parameter, WellKnown
             return new ServiceResolution(typeName, injectId, method, isCyclic);
         }
 
-        private void Generate(SourceProductionContext context, ClassData data)
+        private static void Generate(SourceProductionContext context, ClassData data)
         {
             var stringBuilder = new StringBuilder();
 
@@ -692,8 +695,13 @@ private static string DetermineDependencyMethod(bool isCyclic, bool isNullable)
             }
         }
 
-        private static string FullyQualifyTypeWithoutNullable(ITypeSymbol typeSymbol)
+        private static string FullyQualifyTypeWithoutNullable(ITypeSymbol? typeSymbol)
         {
+            if (typeSymbol is null)
+            {
+                return string.Empty;
+            }
+
             var nonNullableType = GetNonNullableType(typeSymbol);
             if (nonNullableType is not null)
             {
@@ -703,14 +711,24 @@ private static string FullyQualifyTypeWithoutNullable(ITypeSymbol typeSymbol)
             return typeSymbol.ToDisplayString();
         }
 
-        private static bool IsNullableTypeSymbol(ITypeSymbol typeSymbol)
+        private static bool IsNullableTypeSymbol(ITypeSymbol? typeSymbol)
         {
+            if (typeSymbol is null)
+            {
+                return false;
+            }
+
             return typeSymbol.NullableAnnotation is NullableAnnotation.Annotated ||
                    typeSymbol.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
         }
 
-        private static ITypeSymbol? GetNonNullableType(ITypeSymbol typeSymbol)
+        private static ITypeSymbol? GetNonNullableType(ITypeSymbol? typeSymbol)
         {
+            if (typeSymbol is null)
+            {
+                return null;
+            }
+
             if (typeSymbol.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T &&
                 typeSymbol is INamedTypeSymbol namedTypeSymbol)
             {
diff --git a/ManualDi.Sync/ManualDi.Sync.Generators/ManualDiSourceGenerator.cs b/ManualDi.Sync/ManualDi.Sync.Generators/ManualDiSourceGenerator.cs
@@ -23,7 +23,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     GetClassData)
                 .Where(x => x is not null);
 
-            context.RegisterSourceOutput(classData, Generate!);
+            context.RegisterSourceOutput(classData, static (spc, data) => Generate(spc, data!));
         }
 
         private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)
@@ -92,15 +92,17 @@ private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)
                 baseTypesAndInterfaces.Add(i.ToDisplayString());
             }
             var tempBase = symbol.BaseType;
-            while (tempBase != null)
+            int tempBaseDepth = 0;
+            while (tempBase != null && tempBaseDepth++ < 100)
             {
                 baseTypesAndInterfaces.Add(tempBase.ToDisplayString());
                 tempBase = tempBase.BaseType;
             }
 
             INamedTypeSymbol? baseDiSymbol = null;
             var currentBase = symbol.BaseType;
-            while (currentBase != null)
+            int currentBaseDepth = 0;
+            while (currentBase != null && currentBaseDepth++ < 100)
             {
                 if (wellKnownTypes.HasManualDiAttribute(currentBase))
                 {
@@ -120,7 +122,8 @@ private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)
                     baseDiTypesAndInterfaces.Add(i.ToDisplayString());
                 }
                 var tempBaseDi = baseDiSymbol.BaseType;
-                while (tempBaseDi != null)
+                int tempBaseDiDepth = 0;
+                while (tempBaseDi != null && tempBaseDiDepth++ < 100)
                 {
                     baseDiTypesAndInterfaces.Add(tempBaseDi.ToDisplayString());
                     tempBaseDi = tempBaseDi.BaseType;
@@ -374,7 +377,7 @@ private static Resolution CreateResolution(IParameterSymbol parameter, WellKnown
             return new ServiceResolution(typeName, injectId, method);
         }
 
-        private void Generate(SourceProductionContext context, ClassData data)
+        private static void Generate(SourceProductionContext context, ClassData data)
         {
             var stringBuilder = new StringBuilder();
 
@@ -591,8 +594,13 @@ private static void AppendResolution(StringBuilder sb, Resolution resolution)
             }
         }
 
-        private static string FullyQualifyTypeWithoutNullable(ITypeSymbol typeSymbol)
+        private static string FullyQualifyTypeWithoutNullable(ITypeSymbol? typeSymbol)
         {
+            if (typeSymbol is null)
+            {
+                return string.Empty;
+            }
+
             var nonNullableType = GetNonNullableType(typeSymbol);
             if (nonNullableType is not null)
             {
@@ -602,14 +610,24 @@ private static string FullyQualifyTypeWithoutNullable(ITypeSymbol typeSymbol)
             return typeSymbol.ToDisplayString();
         }
 
-        private static bool IsNullableTypeSymbol(ITypeSymbol typeSymbol)
+        private static bool IsNullableTypeSymbol(ITypeSymbol? typeSymbol)
         {
+            if (typeSymbol is null)
+            {
+                return false;
+            }
+
             return typeSymbol.NullableAnnotation is NullableAnnotation.Annotated ||
                    typeSymbol.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;
         }
 
-        private static ITypeSymbol? GetNonNullableType(ITypeSymbol typeSymbol)
+        private static ITypeSymbol? GetNonNullableType(ITypeSymbol? typeSymbol)
         {
+            if (typeSymbol is null)
+            {
+                return null;
+            }
+
             if (typeSymbol.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T &&
                 typeSymbol is INamedTypeSymbol namedTypeSymbol)
             {

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)`
`23`	`23`	`GetClassData)`
`24`	`24`	`.Where(x => x is not null);`
`25`	`25`
`26`		`- context.RegisterSourceOutput(classData, Generate!);`
	`26`	`+ context.RegisterSourceOutput(classData, static (spc, data) => Generate(spc, data!));`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)`
`@@ -93,15 +93,17 @@ private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)`
`93`	`93`	`baseTypesAndInterfaces.Add(i.ToDisplayString());`
`94`	`94`	`}`
`95`	`95`	`var tempBase = symbol.BaseType;`
`96`		`- while (tempBase != null)`
	`96`	`+ int tempBaseDepth = 0;`
	`97`	`+ while (tempBase != null && tempBaseDepth++ < 100)`
`97`	`98`	`{`
`98`	`99`	`baseTypesAndInterfaces.Add(tempBase.ToDisplayString());`
`99`	`100`	`tempBase = tempBase.BaseType;`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`INamedTypeSymbol? baseDiSymbol = null;`
`103`	`104`	`var currentBase = symbol.BaseType;`
`104`		`- while (currentBase != null)`
	`105`	`+ int currentBaseDepth = 0;`
	`106`	`+ while (currentBase != null && currentBaseDepth++ < 100)`
`105`	`107`	`{`
`106`	`108`	`if (wellKnownTypes.HasManualDiAttribute(currentBase))`
`107`	`109`	`{`
`@@ -121,7 +123,8 @@ private static bool IsSyntaxNodeValid(SyntaxNode node, CancellationToken ct)`
`121`	`123`	`baseDiTypesAndInterfaces.Add(i.ToDisplayString());`
`122`	`124`	`}`
`123`	`125`	`var tempBaseDi = baseDiSymbol.BaseType;`
`124`		`- while (tempBaseDi != null)`
	`126`	`+ int tempBaseDiDepth = 0;`
	`127`	`+ while (tempBaseDi != null && tempBaseDiDepth++ < 100)`
`125`	`128`	`{`
`126`	`129`	`baseDiTypesAndInterfaces.Add(tempBaseDi.ToDisplayString());`
`127`	`130`	`tempBaseDi = tempBaseDi.BaseType;`
`@@ -394,7 +397,7 @@ private static Resolution CreateResolution(IParameterSymbol parameter, WellKnown`
`394`	`397`	`return new ServiceResolution(typeName, injectId, method, isCyclic);`
`395`	`398`	`}`
`396`	`399`
`397`		`- private void Generate(SourceProductionContext context, ClassData data)`
	`400`	`+ private static void Generate(SourceProductionContext context, ClassData data)`
`398`	`401`	`{`
`399`	`402`	`var stringBuilder = new StringBuilder();`
`400`	`403`
`@@ -692,8 +695,13 @@ private static string DetermineDependencyMethod(bool isCyclic, bool isNullable)`
`692`	`695`	`}`
`693`	`696`	`}`
`694`	`697`
`695`		`- private static string FullyQualifyTypeWithoutNullable(ITypeSymbol typeSymbol)`
	`698`	`+ private static string FullyQualifyTypeWithoutNullable(ITypeSymbol? typeSymbol)`
`696`	`699`	`{`
	`700`	`+ if (typeSymbol is null)`
	`701`	`+ {`
	`702`	`+ return string.Empty;`
	`703`	`+ }`
	`704`	`+`
`697`	`705`	`var nonNullableType = GetNonNullableType(typeSymbol);`
`698`	`706`	`if (nonNullableType is not null)`
`699`	`707`	`{`
`@@ -703,14 +711,24 @@ private static string FullyQualifyTypeWithoutNullable(ITypeSymbol typeSymbol)`
`703`	`711`	`return typeSymbol.ToDisplayString();`
`704`	`712`	`}`
`705`	`713`
`706`		`- private static bool IsNullableTypeSymbol(ITypeSymbol typeSymbol)`
	`714`	`+ private static bool IsNullableTypeSymbol(ITypeSymbol? typeSymbol)`
`707`	`715`	`{`
	`716`	`+ if (typeSymbol is null)`
	`717`	`+ {`
	`718`	`+ return false;`
	`719`	`+ }`
	`720`	`+`
`708`	`721`	`return typeSymbol.NullableAnnotation is NullableAnnotation.Annotated \|\|`
`709`	`722`	`typeSymbol.OriginalDefinition.SpecialType is SpecialType.System_Nullable_T;`
`710`	`723`	`}`
`711`	`724`
`712`		`- private static ITypeSymbol? GetNonNullableType(ITypeSymbol typeSymbol)`
	`725`	`+ private static ITypeSymbol? GetNonNullableType(ITypeSymbol? typeSymbol)`
`713`	`726`	`{`
	`727`	`+ if (typeSymbol is null)`
	`728`	`+ {`
	`729`	`+ return null;`
	`730`	`+ }`
	`731`	`+`
`714`	`732`	`if (typeSymbol.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T &&`
`715`	`733`	`typeSymbol is INamedTypeSymbol namedTypeSymbol)`
`716`	`734`	`{`