Refuse a diagnostic catalogue the built-in descriptors weren't allocated from [patch]

README.md

@@ -244,7 +244,7 @@ land in the test project's compile references and collide with the in-box types
 | Name | Type | Description |
 |------|------|-------------|
 | `MetadataFileNames` | `IReadOnlyList<string>` | The metadata files this generator reads, without their directories. Abstract. |
-| `Diagnostics` | `DiagnosticCatalog` | The catalogue this generator's diagnostics are allocated from. Abstract. |
+| `Diagnostics` | `DiagnosticCatalog` | The catalogue this generator's diagnostics are allocated from. `MetadataFileMissing` and `MetadataParseFailed` must both be allocated from it, or `Initialize` throws and the build reports CS8784. Abstract. |
 | `MetadataFileMissing` | `DiagnosticDescriptor` | Reported when a declared file is not in the compilation. Takes the file name. Abstract. |
 | `MetadataParseFailed` | `DiagnosticDescriptor` | Reported when a file cannot be parsed, or when several files of one declared name have different contents (the reason lists their paths, and none is used). Takes the file name and the reason. Abstract. |
 

SourceGeneratorToolkit.Test/GeneratorBaseTests.cs

@@ -120,6 +120,27 @@
 		public override SourceText GetText(System.Threading.CancellationToken cancellationToken = default) => SourceText.From(text);
 	}
 
+	[TestMethod]
+	public void ANullDiagnosticCatalogueIsRefused()
+	{
+		GeneratorRunResult result = Harness.Run(new NullCatalogGenerator());
+
+		Assert.IsInstanceOfType<InvalidOperationException>(result.Exception);
+		StringAssert.Contains(result.Exception.Message, "NullCatalogGenerator.Diagnostics returned null");
+		Assert.AreEqual(0, result.GeneratedSources.Length);
+	}
+
+	[TestMethod]
+	public void ADescriptorFromAnotherCatalogueIsRefused()
+	{
+		GeneratorRunResult result = Harness.Run(new MismatchedCatalogGenerator());
+
+		Assert.IsInstanceOfType<InvalidOperationException>(result.Exception);
+		StringAssert.Contains(result.Exception.Message, "MismatchedCatalogGenerator.MetadataFileMissing (TST001)");
+		StringAssert.Contains(result.Exception.Message, "'Other' catalogue");
+		Assert.AreEqual(0, result.GeneratedSources.Length);
+	}
+
 	[TestMethod]
 	public void AMalformedMetadataFileIsReportedRatherThanSwallowed()
 	{

SourceGeneratorToolkit.Test/TestGenerators.cs

@@ -421,3 +421,38 @@ internal static string WriteThingWithNullableAndNonNullableMembers()
 		return codeBlocker.ToString();
 	}
 }
+
+/// <summary>A second catalogue, so a generator can name one its descriptors weren't allocated from.</summary>
+internal static class OtherDiagnostics
+{
+	internal static DiagnosticCatalog Catalog { get; } = new("OTH", "Other");
+}
+
+/// <summary>Names a null catalogue, which <see cref="GeneratorBase"/> must refuse.</summary>
+internal sealed class NullCatalogGenerator() : GeneratorBase<ThingsMetadata>("things.json")
+{
+	protected override DiagnosticCatalog Diagnostics => null!;
+
+	protected override DiagnosticDescriptor MetadataFileMissing => TestDiagnostics.MetadataFileMissing;
+
+	protected override DiagnosticDescriptor MetadataParseFailed => TestDiagnostics.MetadataParseFailed;
+
+	protected override void Generate(SourceProductionContext context, ThingsMetadata metadata, CodeBlocker codeBlocker) =>
+		context.AddSource("Things.g.cs", "// generated");
+}
+
+/// <summary>
+/// Names a catalogue its descriptors weren't allocated from: the prefix drift
+/// <see cref="DiagnosticCatalog"/> exists to prevent.
+/// </summary>
+internal sealed class MismatchedCatalogGenerator() : GeneratorBase<ThingsMetadata>("things.json")
+{
+	protected override DiagnosticCatalog Diagnostics => OtherDiagnostics.Catalog;
+
+	protected override DiagnosticDescriptor MetadataFileMissing => TestDiagnostics.MetadataFileMissing;
+
+	protected override DiagnosticDescriptor MetadataParseFailed => TestDiagnostics.MetadataParseFailed;
+
+	protected override void Generate(SourceProductionContext context, ThingsMetadata metadata, CodeBlocker codeBlocker) =>
+		context.AddSource("Things.g.cs", "// generated");
+}

SourceGeneratorToolkit/GeneratorBase.cs

@@ -37,6 +37,11 @@ public abstract class GeneratorBase : IIncrementalGenerator
 	/// <summary>
 	/// Gets the catalogue this generator's diagnostics are allocated from.
 	/// </summary>
+	/// <remarks>
+	/// <see cref="MetadataFileMissing"/> and <see cref="MetadataParseFailed"/> must both be allocated
+	/// from it. <see cref="Initialize"/> throws otherwise, so the two diagnostics this base reports
+	/// cannot drift to a prefix other than the one the generator's own tests enumerate.
+	/// </remarks>
 	protected abstract DiagnosticCatalog Diagnostics { get; }
 
 	/// <summary>
@@ -57,8 +62,14 @@ public abstract class GeneratorBase : IIncrementalGenerator
 	protected abstract DiagnosticDescriptor MetadataParseFailed { get; }
 
 	/// <inheritdoc/>
+	/// <exception cref="InvalidOperationException">
+	/// <see cref="Diagnostics"/> is <see langword="null"/>, or <see cref="MetadataFileMissing"/> or
+	/// <see cref="MetadataParseFailed"/> was not allocated from it.
+	/// </exception>
 	public void Initialize(IncrementalGeneratorInitializationContext context)
 	{
+		EnsureCataloged();
+
 		IReadOnlyList<string> wanted = MetadataFileNames;
 
 		IncrementalValueProvider<ImmutableArray<MetadataFile>> metadataFiles = context.AdditionalTextsProvider
@@ -115,6 +126,35 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 		});
 	}
 
+	// A required catalogue that nothing reads looks enforced and isn't: a generator could report its
+	// two built-in diagnostics under a prefix other than the one it releases and tests, which is the
+	// drift DiagnosticCatalog exists to prevent. Thrown from Initialize, the failure reaches the
+	// consumer's build as the driver's CS8784 warning naming this message, and the generator emits
+	// nothing.
+	private void EnsureCataloged()
+	{
+		DiagnosticCatalog catalog = Diagnostics
+			?? throw new InvalidOperationException($"{GetType().Name}.Diagnostics returned null. A generator must name the catalogue its diagnostics are allocated from.");
+
+		EnsureCataloged(catalog, MetadataFileMissing, nameof(MetadataFileMissing));
+		EnsureCataloged(catalog, MetadataParseFailed, nameof(MetadataParseFailed));
+	}
+
+	private void EnsureCataloged(DiagnosticCatalog catalog, DiagnosticDescriptor? descriptor, string member)
+	{
+		if (descriptor is not null && catalog.Descriptors.Any(cataloged => cataloged.Id == descriptor.Id))
+		{
+			return;
+		}
+
+		string cataloged = catalog.Descriptors.Count == 0
+			? "none"
+			: string.Join(", ", catalog.Descriptors.Select(entry => entry.Id));
+		throw new InvalidOperationException(
+			$"{GetType().Name}.{member} ({descriptor?.Id ?? "null"}) was not allocated from {GetType().Name}.Diagnostics, "
+				+ $"the '{catalog.Category}' catalogue (descriptors: {cataloged}). Allocate it from that catalogue.");
+	}
+
 	/// <summary>
 	/// Runs an action with the consumer's language version available to <see cref="WriteFileHeader(CodeBlocker, string?)"/>.
 	/// </summary>