Omsmith/conditional parameters fix (#668)

* move dictionary into ImmutabilityContext.Create

* only consider [OnlyIf] parameters as immutable during definition checking

Co-authored-by: Jacob Parker <jacob@solidangle.ca>

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

@@ -116,6 +116,10 @@ INamedTypeSymbol typeSymbol
 				return;
 			}
 
+			if( Attributes.Objects.ConditionallyImmutable.IsDefined( typeSymbol ) ) {
+				immutabilityContext = immutabilityContext.WithConditionalTypeParametersAsImmutable( typeSymbol );
+			}
+
 			ImmutableDefinitionChecker checker = new ImmutableDefinitionChecker(
 				compilation: ctx.Compilation,
 				diagnosticSink: ctx.ReportDiagnostic,

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

@@ -89,7 +89,7 @@ internal partial class ImmutabilityContext {
 		internal static ImmutabilityContext Create( Compilation compilation ) {
 			ImmutableDictionary<string, IAssemblySymbol> compilationAssmeblies = GetCompilationAssemblies( compilation );
 
-			var builder = ImmutableArray.CreateBuilder<ImmutableTypeInfo>( DefaultExtraTypes.Length );
+			var builder = ImmutableDictionary.CreateBuilder<INamedTypeSymbol, ImmutableTypeInfo>();
 
 			foreach( ( string typeName, string qualifiedAssembly ) in DefaultExtraTypes ) {
 				INamedTypeSymbol type;
@@ -112,10 +112,13 @@ internal partial class ImmutabilityContext {
 					type
 				);
 
-				builder.Add( info );
+				builder.Add( type, info );
 			}
 
-			return new ImmutabilityContext( builder.ToImmutable() );
+			return new ImmutabilityContext(
+				extraImmutableTypes: builder.ToImmutable(),
+				conditionalTypeParamemters: ImmutableHashSet<ITypeParameterSymbol>.Empty
+			);
 		}
 
 		private static ImmutableDictionary<string, IAssemblySymbol> GetCompilationAssemblies( Compilation compilation ) {

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

@@ -17,6 +17,7 @@ namespace D2L.CodeStyle.Analyzers.Immutability {
 	/// </summary>
 	internal sealed partial class ImmutabilityContext {
 		private readonly ImmutableDictionary<INamedTypeSymbol, ImmutableTypeInfo> m_extraImmutableTypes;
+		private readonly ImmutableHashSet<ITypeParameterSymbol> m_conditionalTypeParameters;
 
 		// Hard code this to avoid looking up the ITypeSymbol to include it in m_extraImmutableTypes
 		private static readonly ImmutableHashSet<SpecialType> m_totallyImmutableSpecialTypes = ImmutableHashSet.Create(
@@ -40,12 +41,34 @@ internal sealed partial class ImmutabilityContext {
 			SpecialType.System_ValueType
 		);
 
-		private ImmutabilityContext( IEnumerable<ImmutableTypeInfo> extraImmutableTypes ) {
-			m_extraImmutableTypes = extraImmutableTypes
-				.ToImmutableDictionary(
-					info => info.Type,
-					info => info
-				);
+		private ImmutabilityContext(
+			ImmutableDictionary<INamedTypeSymbol, ImmutableTypeInfo> extraImmutableTypes,
+			ImmutableHashSet<ITypeParameterSymbol> conditionalTypeParamemters
+		) {
+			m_extraImmutableTypes = extraImmutableTypes;
+			m_conditionalTypeParameters = conditionalTypeParamemters;
+		}
+
+		/// <summary>
+		/// This function is intended to provide a new immutability context that considers the conditional type parameters
+		/// of the ConditionallyImmutable type being checked as immutable. It is important this is only used in those cases,
+		/// and not for instance while validating type arguments to an [Immutable] type parameter.
+		/// </summary>
+		/// <param name="type">The ConditionallyImmutable type definition being checked</param>
+		/// <returns></returns>
+		public ImmutabilityContext WithConditionalTypeParametersAsImmutable(
+			INamedTypeSymbol type
+		) {
+			if( !Attributes.Objects.ConditionallyImmutable.IsDefined( type ) ) {
+				throw new InvalidOperationException( $"{nameof( WithConditionalTypeParametersAsImmutable )} should only be called on ConditionallyImmutable types" );
+			}
+
+			var conditionalTypeParameters = type.TypeParameters.Where( p => Attributes.Objects.OnlyIf.IsDefined( p ) );
+
+			return new ImmutabilityContext(
+				extraImmutableTypes: m_extraImmutableTypes,
+				conditionalTypeParamemters: m_conditionalTypeParameters.Union( conditionalTypeParameters )
+			);
 		}
 
 		/// <summary>
@@ -138,6 +161,10 @@ out diagnostic
 						return true;
 					}
 
+					if( type is ITypeParameterSymbol tp && m_conditionalTypeParameters.Contains( tp ) ) {
+						return true;
+					}
+
 					diagnostic = Diagnostic.Create(
 						Diagnostics.TypeParameterIsNotKnownToBeImmutable,
 						getLocation(),
@@ -218,10 +245,6 @@ ITypeSymbol type
 				return ImmutableTypeKind.Total;
 			}
 
-			if( Attributes.Objects.OnlyIf.IsDefined( type ) ) {
-				return ImmutableTypeKind.Total;
-			}
-
 			if ( Attributes.Objects.ImmutableBaseClass.IsDefined( type ) ) {
 				return ImmutableTypeKind.Instance;
 			}