enforce immutable type params during immutability analysis

src/D2L.CodeStyle.Analyzers/Immutability/ImmutabilityAnalyzer.cs

@@ -294,7 +294,7 @@ Func<int, Location> getArgumentLocation
 					new ImmutabilityQuery(
 						ImmutableTypeKind.Total,
 						argument
-					),
+					) { EnforceImmutableTypeParams = false },
 					getLocation: () => getArgumentLocation( position ),
 					out Diagnostic diagnostic
 				) ) {

src/D2L.CodeStyle.Analyzers/Immutability/ImmutabilityContext.cs

@@ -123,6 +123,7 @@ out Diagnostic diagnostic
 					return info.IsImmutableDefinition(
 						context: this,
 						definition: namedType,
+						enforceImmutableTypeParams: query.EnforceImmutableTypeParams,
 						getLocation: getLocation,
 						out diagnostic
 					);

src/D2L.CodeStyle.Analyzers/Immutability/ImmutabilityQuery.cs

@@ -1,18 +1,10 @@
-#nullable disable
-
 using Microsoft.CodeAnalysis;
 
 namespace D2L.CodeStyle.Analyzers.Immutability {
-	internal readonly struct ImmutabilityQuery {
-		public ImmutabilityQuery(
-			ImmutableTypeKind kind,
-			ITypeSymbol type
-		) {
-			Kind = kind;
-			Type = type;
-		}
-
-		public ImmutableTypeKind Kind { get; }
-		public ITypeSymbol Type { get; }
+	internal readonly record struct ImmutabilityQuery(
+		ImmutableTypeKind Kind,
+		ITypeSymbol Type
+	) {
+		public bool EnforceImmutableTypeParams { get; init; } = true;
 	}
 }

src/D2L.CodeStyle.Analyzers/Immutability/ImmutableDefinitionChecker.cs

@@ -523,13 +523,13 @@ .Symbol is not IMethodSymbol methodSymbol
 				// being anything other than an instance of T.
 				query = new ImmutabilityQuery(
 					ImmutableTypeKind.Instance,
-					type: assignment.AssignedType
+					Type: assignment.AssignedType
 				);
 			} else {
 				// In general we need to handle subtypes.
 				query = new ImmutabilityQuery(
 					ImmutableTypeKind.Total,
-					type: assignment.AssignedType
+					Type: assignment.AssignedType
 				);
 			}
 

src/D2L.CodeStyle.Analyzers/Immutability/ImmutableTypeInfo.cs

@@ -11,29 +11,28 @@ namespace D2L.CodeStyle.Analyzers.Immutability {
 	/// </summary>
 	internal readonly struct ImmutableTypeInfo {
 
-		// a mapping of which type parameters considered necessarily immutable for the
-		// conditionally immutable type to be immutable
-		private readonly ImmutableArray<bool> m_conditionalTypeParameters;
+		private readonly ImmutableArray<(bool RequiresImmutability, bool IsImmutableCondition)> m_typeParameterInfo;
 
 		private ImmutableTypeInfo(
 			ImmutableTypeKind kind,
 			INamedTypeSymbol type,
-			ImmutableArray<bool> conditionalTypeParameters
+			ImmutableArray<(bool RequiresImmutability, bool IsImmutableCondition)> typeParameterInfo
 		) {
 			Kind = kind;
 			Type = type;
-			m_conditionalTypeParameters = conditionalTypeParameters;
+			m_typeParameterInfo = typeParameterInfo;
 		}
 
 		public ImmutableTypeKind Kind { get; }
 
 		public INamedTypeSymbol Type { get; }
 
-		public bool IsConditional => m_conditionalTypeParameters.Length > 0;
+		public bool IsConditional => m_typeParameterInfo.Any( p => p.IsImmutableCondition );
 
 		public bool IsImmutableDefinition(
 			ImmutabilityContext context,
 			INamedTypeSymbol definition,
+			bool enforceImmutableTypeParams,
 			Func<Location> getLocation,
 			out Diagnostic diagnostic
 		) {
@@ -45,9 +44,10 @@ out Diagnostic diagnostic
 
 			var argRelevance = definition
 				.TypeArguments
-				.Zip( m_conditionalTypeParameters, ( a, relevant ) => (a, relevant) );
-			foreach( (ITypeSymbol argument, bool isRelevant) in argRelevance ) {
-				if( !isRelevant ) {
+				.Zip( m_typeParameterInfo, ( a, info ) => (a, info) );
+			foreach( (ITypeSymbol argument, (bool requiresImmutability, bool isImmutableCondition)) in argRelevance ) {
+				bool relevant = isImmutableCondition || ( requiresImmutability && enforceImmutableTypeParams );
+				if( !relevant ) {
 					continue;
 				}
 
@@ -72,31 +72,37 @@ public static ImmutableTypeInfo Create(
 			ImmutableTypeKind kind,
 			INamedTypeSymbol type
 		) {
-			ImmutableArray<bool> immutableTypeParameters = type
+			ImmutableArray<(bool RequiresImmutability, bool IsImmutableCondition)> typeParameterInfo = type
 				.TypeParameters
-				.Select( p => annotationsContext.Objects.OnlyIf.IsDefined( p ) )
+				.Select( p => (
+					annotationsContext.Objects.Immutable.IsDefined( p ),
+					annotationsContext.Objects.OnlyIf.IsDefined( p )
+				) )
 				.ToImmutableArray();
 
 			return new ImmutableTypeInfo(
 				kind: kind,
 				type: type,
-				conditionalTypeParameters: immutableTypeParameters
+				typeParameterInfo: typeParameterInfo
 			);
 		}
 
 		public static ImmutableTypeInfo CreateWithAllConditionalTypeParameters(
 			ImmutableTypeKind kind,
 			INamedTypeSymbol type
 		) {
-			ImmutableArray<bool> immutableTypeParameters = type
+			ImmutableArray<(bool RequiresImmutability, bool IsImmutableCondition)> typeParameterInfo = type
 				.TypeParameters
-				.Select( p => true )
+				.Select( p => (
+					false,
+					true
+				) )
 				.ToImmutableArray();
 
 			return new ImmutableTypeInfo(
 				kind: kind,
 				type: type,
-				conditionalTypeParameters: immutableTypeParameters
+				typeParameterInfo: typeParameterInfo
 			);
 		}
 	}