From fca8c9a5ce6b95d993fb505cdec01afe04a7a412 Mon Sep 17 00:00:00 2001
From: Ian Johnson <ianjohnson@mac.mynetworksettings.com>
Date: Tue, 27 Oct 2026 06:49:46 -0400
Subject: [PATCH] Add DM0026 and a code fix that makes the service type
 explicit

ServiceTypeAnalyzer reports [SingletonService], [ScopedService] and
[TransientService] without As = typeof(...). It is off by default. It
computes the inferred type with ServiceTypeInference and passes it to
the code fix in the diagnostic's properties, so the fix writes what the
generator registers and the code fix assembly references only Roslyn.

The code fix is in DependencyModules.CodeFixes, because a generator
assembly must not reference Microsoft.CodeAnalysis.Workspaces (RS1038).
It is packed beside the generator in analyzers/dotnet/cs.

Part of #122. Closes #124.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Agent-Driver-Session: 6b413364-2a61-4a69-81a1-b0d64aba5bf5
---
 DependencyModules.sln                         |  15 +
 scripts/verify-packages.sh                    |  22 +-
 .../DependencyModules.CodeFixes.csproj        |  20 +
 .../ServiceTypeCodeFixProvider.cs             | 167 ++++++++
 .../AnalyzerReleases.Unshipped.md             |   1 +
 .../DependencyModuleDiagnostics.cs            |  17 +
 .../Utilities/ServiceModelUtility.cs          |   2 +-
 .../DependencyModules.SourceGenerator.csproj  |  14 +-
 .../ServiceTypeAnalyzer.cs                    | 265 ++++++++++++
 .../DependencyModules.Tests.csproj            |   2 +
 .../GeneratorTests/CodeFixAssemblyTests.cs    |  69 ++++
 .../GeneratorTests/ServiceTypeCodeFixTests.cs | 386 ++++++++++++++++++
 .../Infrastructure/CodeFixHarness.cs          | 203 +++++++++
 .../Infrastructure/GeneratorTestHarness.cs    |   5 +
 ...icApiTests.SourceGeneratorApi.verified.txt |  10 +
 website/reference/diagnostics.md              |  14 +
 16 files changed, 1209 insertions(+), 3 deletions(-)
 create mode 100644 src/DependencyModules.CodeFixes/DependencyModules.CodeFixes.csproj
 create mode 100644 src/DependencyModules.CodeFixes/ServiceTypeCodeFixProvider.cs
 create mode 100644 src/DependencyModules.SourceGenerator/ServiceTypeAnalyzer.cs
 create mode 100644 tests/DependencyModules.Tests/GeneratorTests/CodeFixAssemblyTests.cs
 create mode 100644 tests/DependencyModules.Tests/GeneratorTests/ServiceTypeCodeFixTests.cs
 create mode 100644 tests/DependencyModules.Tests/Infrastructure/CodeFixHarness.cs

diff --git a/DependencyModules.sln b/DependencyModules.sln
index 61573f4..e9861a1 100644
--- a/DependencyModules.sln
+++ b/DependencyModules.sln
@@ -48,6 +48,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SutProject.NUnitTests", "in
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DependencyModules.xUnit4", "src\DependencyModules.xUnit4\DependencyModules.xUnit4.csproj", "{D1AEA1C9-CD76-4664-956B-706962E78E3D}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DependencyModules.CodeFixes", "src\DependencyModules.CodeFixes\DependencyModules.CodeFixes.csproj", "{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -286,6 +288,18 @@ Global
 		{D1AEA1C9-CD76-4664-956B-706962E78E3D}.Release|x64.Build.0 = Release|Any CPU
 		{D1AEA1C9-CD76-4664-956B-706962E78E3D}.Release|x86.ActiveCfg = Release|Any CPU
 		{D1AEA1C9-CD76-4664-956B-706962E78E3D}.Release|x86.Build.0 = Release|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Debug|x64.Build.0 = Debug|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Debug|x86.Build.0 = Debug|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Release|x64.ActiveCfg = Release|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Release|x64.Build.0 = Release|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Release|x86.ActiveCfg = Release|Any CPU
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -311,5 +325,6 @@ Global
 		{F911E2B7-4D5A-4DC2-9E3E-4B2CFC30CF4E} = {FB161494-E422-4D4E-BA04-3473C2EB13B0}
 		{C3B5B8CE-D219-42C8-A1B8-5C283C053E98} = {DC7C95FE-F58F-4F16-8DFA-87E1B67DCEAE}
 		{D1AEA1C9-CD76-4664-956B-706962E78E3D} = {FB161494-E422-4D4E-BA04-3473C2EB13B0}
+		{1233A4FF-C8EE-4422-A26F-EF18D3FFA0F2} = {FB161494-E422-4D4E-BA04-3473C2EB13B0}
 	EndGlobalSection
 EndGlobal
diff --git a/scripts/verify-packages.sh b/scripts/verify-packages.sh
index ba3327a..de2245d 100755
--- a/scripts/verify-packages.sh
+++ b/scripts/verify-packages.sh
@@ -87,11 +87,15 @@ unzip -Z1 "${FEED}/DependencyModules.SourceGenerator.${VERSION}.nupkg" \
     | grep -qx "analyzers/dotnet/cs/DependencyModules.SourceGenerator.dll" \
     || fail "DependencyModules.SourceGenerator: analyzer assembly is not at analyzers/dotnet/cs/"
 
+unzip -Z1 "${FEED}/DependencyModules.SourceGenerator.${VERSION}.nupkg" \
+    | grep -qx "analyzers/dotnet/cs/DependencyModules.CodeFixes.dll" \
+    || fail "DependencyModules.SourceGenerator: code fix assembly is not at analyzers/dotnet/cs/"
+
 # No lib/. An analyzer that reaches a consumer's output ships compiler machinery to run time.
 unzip -Z1 "${FEED}/DependencyModules.SourceGenerator.${VERSION}.nupkg" | grep -q '^lib/' \
     && fail "DependencyModules.SourceGenerator: ships a lib/ folder, so the analyzer would flow to consumer output"
 
-pass "DependencyModules.SourceGenerator analyzer assembly is at analyzers/dotnet/cs/ with no lib/"
+pass "DependencyModules.SourceGenerator analyzer and code fix assemblies are at analyzers/dotnet/cs/ with no lib/"
 
 # The shipping libraries multi-target. A missing lib/ folder means one TFM quietly stopped being
 # produced, and consumers on it would resolve no assembly at all.
@@ -323,6 +327,22 @@ output="$(dotnet run --project "${APP}/ConsumerApp.csproj" -c Release --no-build
     || fail "unexpected ${TFM} consumer output: ${output}"
 pass "${TFM} resolved a generated registration at run time"
 
+# DM0026 is off by default, so the build above passed with [SingletonService] and no As. Turned on
+# as an error, the packaged analyzer must fail the build. The emitted files go first, because they
+# sit in the project folder and the next build would compile them a second time. A global config
+# rather than .editorconfig: on macOS the temp folder is reached through a symlink, so csc sees
+# source paths that an .editorconfig section never matches.
+rm -rf "${APP}/generated"
+printf 'is_global = true\ndotnet_diagnostic.DM0026.severity = error\n' >"${APP}/.globalconfig"
+dm0026_output="$(dotnet build "${APP}/ConsumerApp.csproj" -c Release --nologo --no-incremental 2>&1)" \
+    && fail "${TFM} consumer built with DM0026 set to error"
+grep -q 'error DM0026' <<<"${dm0026_output}" \
+    || fail "${TFM} consumer failed to build with DM0026 set to error, but not with DM0026:\n${dm0026_output}"
+grep -q 'CS8032' <<<"${dm0026_output}" \
+    && fail "${TFM} consumer could not load an analyzer from the package:\n${dm0026_output}"
+rm "${APP}/.globalconfig"
+pass "${TFM} DM0026 set to error fails the build"
+
 done
 
 echo "==> Building a generator project against DependencyModules.SourceGenerator.Impl"
diff --git a/src/DependencyModules.CodeFixes/DependencyModules.CodeFixes.csproj b/src/DependencyModules.CodeFixes/DependencyModules.CodeFixes.csproj
new file mode 100644
index 0000000..df18975
--- /dev/null
+++ b/src/DependencyModules.CodeFixes/DependencyModules.CodeFixes.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <!--
+        The code fixes for the DM#### diagnostics. Separate from the generator because a code fix
+        needs Microsoft.CodeAnalysis.Workspaces, which a generator assembly must not reference
+        (RS1038). It ships inside the DependencyModules.SourceGenerator package, beside the
+        generator in analyzers/dotnet/cs, and references only assemblies the IDE supplies.
+    -->
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <LangVersion>11</LangVersion>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.10.0" PrivateAssets="all"/>
+    </ItemGroup>
+</Project>
diff --git a/src/DependencyModules.CodeFixes/ServiceTypeCodeFixProvider.cs b/src/DependencyModules.CodeFixes/ServiceTypeCodeFixProvider.cs
new file mode 100644
index 0000000..d9ba9c3
--- /dev/null
+++ b/src/DependencyModules.CodeFixes/ServiceTypeCodeFixProvider.cs
@@ -0,0 +1,167 @@
+using System.Collections.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Simplification;
+
+namespace DependencyModules.CodeFixes;
+
+/// <summary>
+/// Fixes DM0026 by writing <c>As = typeof(...)</c> with the type the generator infers today.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The type comes from the diagnostic's properties, where <c>ServiceTypeAnalyzer</c> put what
+/// <c>ServiceTypeInference</c> returned. This assembly does not compute it, so the fix cannot
+/// drift from what the generator registers. It also does not reference the generator assembly,
+/// so the IDE loads it with nothing beside it to resolve. A diagnostic without the property has no
+/// fix.
+/// </para>
+/// <para>
+/// Only the attribute's argument list changes. Other arguments and their trivia stay, and an
+/// <c>As</c> that is not a <c>typeof(...)</c> has its expression replaced in place.
+/// </para>
+/// </remarks>
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(ServiceTypeCodeFixProvider)), Shared]
+public sealed class ServiceTypeCodeFixProvider : CodeFixProvider
+{
+    // These match DependencyModuleDiagnostics.ServiceTypeNotNamed and the ServiceTypeAnalyzer
+    // property names in the generator assembly.
+    private const string DiagnosticId = "DM0026";
+    private const string ServiceTypeProperty = "ServiceType";
+    private const string ServiceTypeDisplayProperty = "ServiceTypeDisplay";
+
+    private const string EquivalenceKey = "DM0026.MakeServiceTypeExplicit";
+
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } =
+        ImmutableArray.Create(DiagnosticId);
+
+    public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var root = await context
+            .Document.GetSyntaxRootAsync(context.CancellationToken)
+            .ConfigureAwait(false);
+
+        if (root == null)
+        {
+            return;
+        }
+
+        foreach (var diagnostic in context.Diagnostics)
+        {
+            if (
+                !diagnostic.Properties.TryGetValue(ServiceTypeProperty, out var serviceType)
+                || serviceType == null
+                || root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true)
+                    ?.FirstAncestorOrSelf<AttributeSyntax>()
+                    is not { } attribute
+            )
+            {
+                continue;
+            }
+
+            diagnostic.Properties.TryGetValue(ServiceTypeDisplayProperty, out var display);
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    $"Make service type explicit: {display ?? serviceType}",
+                    cancellationToken =>
+                        FixAsync(context.Document, attribute, serviceType, cancellationToken),
+                    EquivalenceKey
+                ),
+                diagnostic
+            );
+        }
+    }
+
+    private static async Task<Document> FixAsync(
+        Document document,
+        AttributeSyntax attribute,
+        string serviceType,
+        CancellationToken cancellationToken
+    )
+    {
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+        var typeOf = SyntaxFactory.TypeOfExpression(
+            SyntaxFactory
+                .ParseTypeName(serviceType)
+                .WithAdditionalAnnotations(Simplifier.Annotation)
+        );
+
+        return document.WithSyntaxRoot(root!.ReplaceNode(attribute, WithAs(attribute, typeOf)));
+    }
+
+    private static AttributeSyntax WithAs(AttributeSyntax attribute, TypeOfExpressionSyntax typeOf)
+    {
+        var argumentList = attribute.ArgumentList;
+
+        var existing = argumentList?.Arguments.FirstOrDefault(argument =>
+            argument.NameEquals?.Name.ToString() == "As"
+        );
+
+        if (existing != null)
+        {
+            return attribute.ReplaceNode(
+                existing.Expression,
+                typeOf.WithTriviaFrom(existing.Expression)
+            );
+        }
+
+        var asArgument = SyntaxFactory.AttributeArgument(
+            SyntaxFactory.NameEquals(
+                SyntaxFactory.IdentifierName("As"),
+                SyntaxFactory.Token(
+                    SyntaxFactory.TriviaList(SyntaxFactory.Space),
+                    SyntaxKind.EqualsToken,
+                    SyntaxFactory.TriviaList(SyntaxFactory.Space)
+                )
+            ),
+            null,
+            typeOf
+        );
+
+        if (argumentList == null)
+        {
+            // Trivia after the name, such as a comment, moves past the new argument list.
+            return attribute
+                .WithName(attribute.Name.WithoutTrailingTrivia())
+                .WithArgumentList(
+                    SyntaxFactory
+                        .AttributeArgumentList(SyntaxFactory.SingletonSeparatedList(asArgument))
+                        .WithTrailingTrivia(attribute.Name.GetTrailingTrivia())
+                );
+        }
+
+        if (argumentList.Arguments.Count == 0)
+        {
+            return attribute.WithArgumentList(
+                argumentList.WithArguments(SyntaxFactory.SingletonSeparatedList(asArgument))
+            );
+        }
+
+        // The last argument's trailing trivia, such as a comment or the line break before the
+        // closing parenthesis, moves after the new argument.
+        var last = argumentList.Arguments.Last();
+
+        var arguments = argumentList
+            .Arguments.Take(argumentList.Arguments.Count - 1)
+            .Append(last.WithoutTrailingTrivia())
+            .Append(asArgument.WithTrailingTrivia(last.GetTrailingTrivia()));
+
+        var separators = argumentList
+            .Arguments.GetSeparators()
+            .Append(
+                SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(SyntaxFactory.Space)
+            );
+
+        return attribute.WithArgumentList(
+            argumentList.WithArguments(SyntaxFactory.SeparatedList(arguments, separators))
+        );
+    }
+}
diff --git a/src/DependencyModules.SourceGenerator.Impl/AnalyzerReleases.Unshipped.md b/src/DependencyModules.SourceGenerator.Impl/AnalyzerReleases.Unshipped.md
index 9f37e58..ef77583 100644
--- a/src/DependencyModules.SourceGenerator.Impl/AnalyzerReleases.Unshipped.md
+++ b/src/DependencyModules.SourceGenerator.Impl/AnalyzerReleases.Unshipped.md
@@ -8,6 +8,7 @@ Rule ID | Category | Severity | Notes
 DM0023 | DependencyModules | Warning | A factory method with a service attribute cannot be called by the generated module.
 DM0024 | DependencyModules | Warning | A cross-wired class declares no interface but inherits one.
 DM0025 | DependencyModules | Warning | A [Decorator] class is not applied.
+DM0026 | DependencyModules | Disabled | A service attribute does not name its service type.
 
 ### Removed Rules
 
diff --git a/src/DependencyModules.SourceGenerator.Impl/DependencyModuleDiagnostics.cs b/src/DependencyModules.SourceGenerator.Impl/DependencyModuleDiagnostics.cs
index 4da5b93..a19bebf 100644
--- a/src/DependencyModules.SourceGenerator.Impl/DependencyModuleDiagnostics.cs
+++ b/src/DependencyModules.SourceGenerator.Impl/DependencyModuleDiagnostics.cs
@@ -456,6 +456,23 @@ public static Diagnostic GeneratorFailureFrom(Exception exception) =>
         isEnabledByDefault: true
     );
 
+    /// <summary>
+    /// Raised by <c>ServiceTypeAnalyzer</c> for a <c>[SingletonService]</c>, <c>[ScopedService]</c>
+    /// or <c>[TransientService]</c> without <c>As = typeof(...)</c>.
+    /// </summary>
+    /// <remarks>
+    /// Off by default, because inference is the documented behaviour. A project that wants every
+    /// registration written out turns it on with <c>dotnet_diagnostic.DM0026.severity</c>.
+    /// </remarks>
+    public static readonly DiagnosticDescriptor ServiceTypeNotNamed = new(
+        id: "DM0026",
+        title: "A service attribute does not name its service type",
+        messageFormat: "[{0}] on '{1}' does not name its service type with As = typeof(...). {2}.",
+        category: Category,
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: false
+    );
+
     /// <summary>
     /// Raised for <c>[CrossWireService]</c> on a generic type.
     /// </summary>
diff --git a/src/DependencyModules.SourceGenerator.Impl/Utilities/ServiceModelUtility.cs b/src/DependencyModules.SourceGenerator.Impl/Utilities/ServiceModelUtility.cs
index 9e54da5..1bd84c3 100644
--- a/src/DependencyModules.SourceGenerator.Impl/Utilities/ServiceModelUtility.cs
+++ b/src/DependencyModules.SourceGenerator.Impl/Utilities/ServiceModelUtility.cs
@@ -454,7 +454,7 @@ ServiceRegistrationModel registrationmodel
         return classTypeDefinition;
     }
 
-    private static ITypeDefinition GetTypeDeclarationDefinition(
+    internal static ITypeDefinition GetTypeDeclarationDefinition(
         TypeDeclarationSyntax typeDeclarationSyntax
     )
     {
diff --git a/src/DependencyModules.SourceGenerator/DependencyModules.SourceGenerator.csproj b/src/DependencyModules.SourceGenerator/DependencyModules.SourceGenerator.csproj
index b9e8ae7..9c1ce09 100644
--- a/src/DependencyModules.SourceGenerator/DependencyModules.SourceGenerator.csproj
+++ b/src/DependencyModules.SourceGenerator/DependencyModules.SourceGenerator.csproj
@@ -12,7 +12,7 @@
         <Description>The source generator of DependencyModules. When you compile, it writes the IServiceCollection registration code for each [DependencyModule] and for the classes with [SingletonService], [ScopedService], [TransientService], or [CrossWireService]. The generated code does not use reflection to find services. Use it with the DependencyModules.Runtime package.</Description>
         <DevelopmentDependency>true</DevelopmentDependency>
         <IncludeBuildOutput>false</IncludeBuildOutput>
-        <!-- Analyzer package: ships a single analyzer assembly and no lib/, which is exactly what NU5128 flags. -->
+        <!-- Analyzer package: ships analyzer assemblies and no lib/, which is exactly what NU5128 flags. -->
         <NoWarn>$(NoWarn);NU5128</NoWarn>
     </PropertyGroup>
 
@@ -49,6 +49,18 @@
         <None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false"/>
     </ItemGroup>
 
+    <!--
+        The code fixes ship beside the generator. Referenced for build order only: this assembly must
+        not reference Microsoft.CodeAnalysis.Workspaces (RS1038), and the package must not depend on
+        a DependencyModules.CodeFixes package.
+    -->
+    <ItemGroup>
+        <ProjectReference Include="../DependencyModules.CodeFixes/DependencyModules.CodeFixes.csproj"
+                          ReferenceOutputAssembly="false" PrivateAssets="all"/>
+        <None Include="../DependencyModules.CodeFixes/$(OutputPath)/DependencyModules.CodeFixes.dll"
+              Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false"/>
+    </ItemGroup>
+
     <ItemGroup>
         <!-- No CopyToOutputDirectory: on a Compile item it copies the *source* to bin, and the
              metadata flows to every project referencing this one. That put 50 files and 428KB of
diff --git a/src/DependencyModules.SourceGenerator/ServiceTypeAnalyzer.cs b/src/DependencyModules.SourceGenerator/ServiceTypeAnalyzer.cs
new file mode 100644
index 0000000..2353083
--- /dev/null
+++ b/src/DependencyModules.SourceGenerator/ServiceTypeAnalyzer.cs
@@ -0,0 +1,265 @@
+using System.Collections.Immutable;
+using System.Text;
+using CSharpAuthor;
+using DependencyModules.SourceGenerator.Impl;
+using DependencyModules.SourceGenerator.Impl.Utilities;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace DependencyModules.SourceGenerator;
+
+/// <summary>
+/// DM0026: a <c>[SingletonService]</c>, <c>[ScopedService]</c> or <c>[TransientService]</c> that
+/// does not name its service type with <c>As = typeof(...)</c>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The attribute is matched by symbol, so an alias and a qualified name are found. <c>As</c> is
+/// matched by its written argument name, the way the generator reads it, so the two agree on which
+/// attributes have one. An <c>As</c> that is not a <c>typeof(...)</c> is reported, because the
+/// generator ignores it and infers the type.
+/// </para>
+/// <para>
+/// The type the generator infers is computed with <see cref="ServiceTypeInference"/> and passed to
+/// the code fix in <see cref="ServiceTypeProperty"/>. It is passed only when <c>typeof</c> of it,
+/// bound at the attribute, reads back as the same type through the generator's <c>As</c> path. A
+/// type that cannot be written there, such as <c>IMap&lt;,int&gt;</c>, gets no fix.
+/// </para>
+/// </remarks>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class ServiceTypeAnalyzer : DiagnosticAnalyzer
+{
+    /// <summary>
+    /// The inferred type, written with <c>global::</c>, when the code fix can write it.
+    /// </summary>
+    public const string ServiceTypeProperty = "ServiceType";
+
+    /// <summary>
+    /// The inferred type as the code fix title shows it.
+    /// </summary>
+    public const string ServiceTypeDisplayProperty = "ServiceTypeDisplay";
+
+    private static readonly ITypeDefinition[] _attributeTypes =
+    {
+        KnownTypes.DependencyModules.Attributes.TransientServiceAttribute,
+        KnownTypes.DependencyModules.Attributes.ScopedServiceAttribute,
+        KnownTypes.DependencyModules.Attributes.SingletonServiceAttribute,
+    };
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
+        ImmutableArray.Create(DependencyModuleDiagnostics.ServiceTypeNotNamed);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+
+        context.RegisterCompilationStartAction(start =>
+        {
+            var attributeTypes = _attributeTypes
+                .Select(type =>
+                    start.Compilation.GetTypeByMetadataName($"{type.Namespace}.{type.Name}")
+                )
+                .Where(type => type != null)
+                .ToImmutableArray();
+
+            if (attributeTypes.IsEmpty)
+            {
+                return;
+            }
+
+            start.RegisterSyntaxNodeAction(
+                nodeContext => Analyze(nodeContext, attributeTypes!),
+                SyntaxKind.ClassDeclaration,
+                SyntaxKind.RecordDeclaration,
+                SyntaxKind.MethodDeclaration
+            );
+        });
+    }
+
+    private static void Analyze(
+        SyntaxNodeAnalysisContext context,
+        ImmutableArray<INamedTypeSymbol> attributeTypes
+    )
+    {
+        var member = (MemberDeclarationSyntax)context.Node;
+
+        foreach (var attribute in member.AttributeLists.SelectMany(list => list.Attributes))
+        {
+            var attributeType = context
+                .SemanticModel.GetSymbolInfo(attribute, context.CancellationToken)
+                .Symbol?.ContainingType;
+
+            if (
+                attributeType == null
+                || !attributeTypes.Contains(attributeType, SymbolEqualityComparer.Default)
+            )
+            {
+                continue;
+            }
+
+            var asArgument = attribute.ArgumentList?.Arguments.FirstOrDefault(argument =>
+                argument.NameEquals?.Name.ToString() == "As"
+            );
+
+            if (asArgument?.Expression is TypeOfExpressionSyntax)
+            {
+                continue;
+            }
+
+            Report(context, member, attribute, asArgument != null);
+        }
+    }
+
+    private static void Report(
+        SyntaxNodeAnalysisContext context,
+        MemberDeclarationSyntax member,
+        AttributeSyntax attribute,
+        bool hasInvalidAs
+    )
+    {
+        var serviceType = InferredServiceType(member, context.SemanticModel);
+        var properties = ImmutableDictionary<string, string?>.Empty;
+        var detail = hasInvalidAs
+            ? "The generator ignores an As that is not typeof(...), so the service type is inferred. "
+            : "";
+
+        if (serviceType == null)
+        {
+            detail += "The service type cannot be determined";
+        }
+        else
+        {
+            var display = serviceType.GetShortName();
+            detail += $"It is registered as '{display}'";
+
+            if (WritableServiceType(attribute, serviceType, context.SemanticModel) is { } written)
+            {
+                properties = properties
+                    .Add(ServiceTypeProperty, written)
+                    .Add(ServiceTypeDisplayProperty, display);
+            }
+        }
+
+        context.ReportDiagnostic(
+            Diagnostic.Create(
+                DependencyModuleDiagnostics.ServiceTypeNotNamed,
+                attribute.GetLocation(),
+                properties,
+                attribute.Name.ToString(),
+                MemberName(member),
+                detail
+            )
+        );
+    }
+
+    /// <summary>
+    /// What the generator registers for this declaration when the attribute has no <c>As</c>.
+    /// </summary>
+    private static ITypeDefinition? InferredServiceType(
+        MemberDeclarationSyntax member,
+        SemanticModel semanticModel
+    )
+    {
+        switch (member)
+        {
+            case TypeDeclarationSyntax type:
+                return ServiceTypeInference.GetServiceType(
+                    ServiceModelUtility.GetTypeDeclarationDefinition(type),
+                    ServiceTypeInference.BaseListSymbols(type, semanticModel)
+                );
+
+            case MethodDeclarationSyntax method:
+                var returnType = method.ReturnType.GetTypeDefinition(
+                    new SyntaxTransformContext(method, semanticModel)
+                );
+
+                return returnType == null
+                    ? null
+                    : ServiceTypeInference.GetServiceType(
+                        returnType,
+                        Enumerable.Empty<INamedTypeSymbol>()
+                    );
+
+            default:
+                return null;
+        }
+    }
+
+    /// <summary>
+    /// <paramref name="serviceType"/> written with <c>global::</c>, when <c>typeof</c> of that text
+    /// at the attribute gives the generator the same service type. Otherwise null.
+    /// </summary>
+    private static string? WritableServiceType(
+        AttributeSyntax attribute,
+        ITypeDefinition serviceType,
+        SemanticModel semanticModel
+    )
+    {
+        // A type parameter of the class binds at the attribute but is CS0416 inside typeof there.
+        if (ContainsTypeParameter(serviceType))
+        {
+            return null;
+        }
+
+        var builder = new StringBuilder();
+        serviceType.WriteTypeName(builder, TypeOutputMode.Global);
+        var written = builder.ToString();
+
+        var typeSyntax = SyntaxFactory.ParseTypeName(written);
+
+        if (typeSyntax.ContainsDiagnostics)
+        {
+            return null;
+        }
+
+        var speculative = SyntaxFactory.Attribute(
+            attribute.Name,
+            SyntaxFactory.AttributeArgumentList(
+                SyntaxFactory.SingletonSeparatedList(
+                    SyntaxFactory.AttributeArgument(
+                        SyntaxFactory.NameEquals("As"),
+                        null,
+                        SyntaxFactory.TypeOfExpression(typeSyntax)
+                    )
+                )
+            )
+        );
+
+        if (
+            !semanticModel.TryGetSpeculativeSemanticModel(
+                attribute.SpanStart,
+                speculative,
+                out var speculativeModel
+            )
+        )
+        {
+            return null;
+        }
+
+        var typeOf = (TypeOfExpressionSyntax)speculative.ArgumentList!.Arguments[0].Expression;
+        var readBack = typeOf.Type.GetTypeDefinition(
+            new SyntaxTransformContext(speculative, speculativeModel)
+        );
+
+        if (readBack is GenericTypeDefinition)
+        {
+            readBack = ServiceTypeInference.ReplaceGenericParametersForRegistration(readBack);
+        }
+
+        return serviceType.Equals(readBack) ? written : null;
+    }
+
+    private static bool ContainsTypeParameter(ITypeDefinition type) =>
+        type is TypeParameterDefinition || type.TypeArguments.Any(ContainsTypeParameter);
+
+    private static string MemberName(MemberDeclarationSyntax member) =>
+        member switch
+        {
+            TypeDeclarationSyntax type => type.Identifier.Text,
+            MethodDeclarationSyntax method => method.Identifier.Text,
+            _ => member.ToString(),
+        };
+}
diff --git a/tests/DependencyModules.Tests/DependencyModules.Tests.csproj b/tests/DependencyModules.Tests/DependencyModules.Tests.csproj
index 314533c..5bc4c5c 100644
--- a/tests/DependencyModules.Tests/DependencyModules.Tests.csproj
+++ b/tests/DependencyModules.Tests/DependencyModules.Tests.csproj
@@ -17,6 +17,7 @@
         <!-- Referenced as a library, not an analyzer: these tests drive the generator directly. -->
         <ProjectReference Include="..\..\src\DependencyModules.SourceGenerator\DependencyModules.SourceGenerator.csproj"
                           OutputItemType="Analyzer" ReferenceOutputAssembly="true"/>
+        <ProjectReference Include="..\..\src\DependencyModules.CodeFixes\DependencyModules.CodeFixes.csproj"/>
         <ProjectReference Include="..\..\src\$(DependencyModulesXunitProject)\$(DependencyModulesXunitProject).csproj"/>
         <!--
           Referenced for the public API snapshot only. This project's own tests run on xUnit; the
@@ -35,6 +36,7 @@
         </PackageReference>
         <PackageReference Include="PublicApiGenerator" Version="11.5.4"/>
         <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.10.0"/>
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.10.0"/>
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0"/>
         <PackageReference Include="xunit.runner.visualstudio" Version="$(XunitRunnerVersion)">
             <PrivateAssets>all</PrivateAssets>
diff --git a/tests/DependencyModules.Tests/GeneratorTests/CodeFixAssemblyTests.cs b/tests/DependencyModules.Tests/GeneratorTests/CodeFixAssemblyTests.cs
new file mode 100644
index 0000000..fe10794
--- /dev/null
+++ b/tests/DependencyModules.Tests/GeneratorTests/CodeFixAssemblyTests.cs
@@ -0,0 +1,69 @@
+using System.Reflection;
+using System.Runtime.Loader;
+using DependencyModules.CodeFixes;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Xunit;
+
+namespace DependencyModules.Tests.GeneratorTests;
+
+/// <summary>
+/// The code fix assembly loads the way an IDE loads it from analyzers/dotnet/cs: Roslyn and the
+/// framework come from the host, and nothing else is there to resolve.
+/// </summary>
+public class CodeFixAssemblyTests
+{
+    [Fact]
+    public void TheCodeFixAssembly_LoadsWithOnlyHostAssemblies()
+    {
+        var context = new HostOnlyLoadContext();
+
+        try
+        {
+            var assembly = context.LoadFromAssemblyPath(
+                typeof(ServiceTypeCodeFixProvider).Assembly.Location
+            );
+
+            var providers = assembly
+                .GetTypes()
+                .Where(type => type.GetCustomAttribute<ExportCodeFixProviderAttribute>() != null)
+                .Select(type => (CodeFixProvider)Activator.CreateInstance(type)!)
+                .ToArray();
+
+            var provider = Assert.Single(providers);
+            Assert.Equal(new[] { "DM0026" }, provider.FixableDiagnosticIds);
+            Assert.NotNull(provider.GetFixAllProvider());
+            Assert.Empty(context.Refused);
+        }
+        finally
+        {
+            context.Unload();
+        }
+    }
+
+    /// <summary>
+    /// Takes Roslyn, System.Composition and the framework from the test host, and refuses the rest,
+    /// such as the generator assembly that sits beside this one in the package.
+    /// </summary>
+    private sealed class HostOnlyLoadContext() : AssemblyLoadContext(isCollectible: true)
+    {
+        public List<string> Refused { get; } = new();
+
+        protected override Assembly? Load(AssemblyName assemblyName)
+        {
+            var name = assemblyName.Name ?? "";
+
+            if (
+                name is "netstandard" or "mscorlib"
+                || name.StartsWith("System.", StringComparison.Ordinal)
+                || name.StartsWith("Microsoft.CodeAnalysis", StringComparison.Ordinal)
+            )
+            {
+                return Default.LoadFromAssemblyName(assemblyName);
+            }
+
+            Refused.Add(name);
+
+            throw new FileNotFoundException($"'{name}' is not supplied by the host.", name);
+        }
+    }
+}
diff --git a/tests/DependencyModules.Tests/GeneratorTests/ServiceTypeCodeFixTests.cs b/tests/DependencyModules.Tests/GeneratorTests/ServiceTypeCodeFixTests.cs
new file mode 100644
index 0000000..039c93c
--- /dev/null
+++ b/tests/DependencyModules.Tests/GeneratorTests/ServiceTypeCodeFixTests.cs
@@ -0,0 +1,386 @@
+using DependencyModules.SourceGenerator.Impl;
+using DependencyModules.Tests.Infrastructure;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace DependencyModules.Tests.GeneratorTests;
+
+/// <summary>
+/// DM0026 and its code fix. Each fix test applies every offered fix and compares the text.
+/// </summary>
+public class ServiceTypeCodeFixTests
+{
+    private const string Preamble = """
+        using System;
+        using System.Collections.Generic;
+        using DependencyModules.Runtime.Attributes;
+        using Single = DependencyModules.Runtime.Attributes.SingletonServiceAttribute;
+
+        namespace TestNamespace;
+
+        public interface IThing;
+
+        public interface IFirst;
+
+        public interface ISecond;
+
+        public interface IRepo<T>;
+
+        [DependencyModule]
+        public partial class TestModule;
+
+        """;
+
+    [Fact]
+    public void TheRuleIsOffByDefault()
+    {
+        Assert.False(DependencyModuleDiagnostics.ServiceTypeNotNamed.IsEnabledByDefault);
+    }
+
+    [Fact]
+    public async Task NotEnabled_ReportsNothing()
+    {
+        var solution = CodeFixHarness.CreateSolution(
+            new[] { new[] { Preamble + "[SingletonService] public class Thing : IThing;" } },
+            severity: null
+        );
+
+        Assert.Empty(await CodeFixHarness.DiagnosticsAsync(solution.Projects.Single()));
+    }
+
+    [Fact]
+    public async Task EnabledAsError_ReportsAnError()
+    {
+        var solution = CodeFixHarness.CreateSolution(
+            new[] { new[] { Preamble + "[SingletonService] public class Thing : IThing;" } },
+            severity: ReportDiagnostic.Error
+        );
+
+        var diagnostic = Assert.Single(
+            await CodeFixHarness.DiagnosticsAsync(solution.Projects.Single())
+        );
+
+        Assert.Equal(DiagnosticSeverity.Error, diagnostic.Severity);
+        Assert.Equal(
+            "[SingletonService] on 'Thing' does not name its service type with As = typeof(...). "
+                + "It is registered as 'IThing'.",
+            diagnostic.GetMessage()
+        );
+    }
+
+    [Theory]
+    [InlineData("[SingletonService(As = typeof(IThing))] public class Thing : IThing;")]
+    [InlineData(
+        "[DependencyModules.Runtime.Attributes.ScopedService(As = typeof(Thing))] public class Thing : IThing;"
+    )]
+    [InlineData("[Single(As = typeof(IThing))] public class Thing : IThing;")]
+    [InlineData("[CrossWireService] public class Thing : IFirst, ISecond;")]
+    [InlineData(
+        "public static class Factories { [TransientService(As = typeof(IThing))] public static Thing Create() => new(); } public class Thing : IThing;"
+    )]
+    public async Task ANamedTypeOrCrossWire_IsNotReported(string source)
+    {
+        var document = CodeFixHarness.CreateDocument(Preamble + source);
+
+        Assert.Empty(await CodeFixHarness.DiagnosticsAsync(document.Project));
+    }
+
+    [Theory]
+    // Concrete only.
+    [InlineData(
+        "[SingletonService] public class Thing;",
+        "[SingletonService(As = typeof(Thing))] public class Thing;"
+    )]
+    [InlineData(
+        "[SingletonService] public record Settings;",
+        "[SingletonService(As = typeof(Settings))] public record Settings;"
+    )]
+    // Multiple interfaces: the first one wins.
+    [InlineData(
+        "[ScopedService] public class Thing : IFirst, ISecond;",
+        "[ScopedService(As = typeof(IFirst))] public class Thing : IFirst, ISecond;"
+    )]
+    // An interface inherited from a base class.
+    [InlineData(
+        "public abstract class ThingBase : IThing; [TransientService] public class Thing : ThingBase;",
+        "public abstract class ThingBase : IThing; [TransientService(As = typeof(IThing))] public class Thing : ThingBase;"
+    )]
+    // A capability interface alone, and beside a role interface.
+    [InlineData(
+        "[SingletonService] public class Thing : IDisposable { public void Dispose() { } }",
+        "[SingletonService(As = typeof(Thing))] public class Thing : IDisposable { public void Dispose() { } }"
+    )]
+    [InlineData(
+        "[SingletonService] public class Thing : IDisposable, IThing { public void Dispose() { } }",
+        "[SingletonService(As = typeof(IThing))] public class Thing : IDisposable, IThing { public void Dispose() { } }"
+    )]
+    // Open and closed generics.
+    [InlineData(
+        "[SingletonService] public class Repo<T> : IRepo<T>;",
+        "[SingletonService(As = typeof(IRepo<>))] public class Repo<T> : IRepo<T>;"
+    )]
+    [InlineData(
+        "[SingletonService] public class Box<T>;",
+        "[SingletonService(As = typeof(Box<>))] public class Box<T>;"
+    )]
+    [InlineData(
+        "[SingletonService] public class IntRepo : IRepo<int>;",
+        "[SingletonService(As = typeof(IRepo<int>))] public class IntRepo : IRepo<int>;"
+    )]
+    // A factory method registers its declared return type.
+    [InlineData(
+        "public class Thing : IThing; public static class Factories { [SingletonService] public static Thing Create() => new(); }",
+        "public class Thing : IThing; public static class Factories { [SingletonService(As = typeof(Thing))] public static Thing Create() => new(); }"
+    )]
+    [InlineData(
+        "public class Thing : IThing; public static class Factories { [ScopedService] public static IThing Create() => new Thing(); }",
+        "public class Thing : IThing; public static class Factories { [ScopedService(As = typeof(IThing))] public static IThing Create() => new Thing(); }"
+    )]
+    // Aliased and qualified attributes.
+    [InlineData(
+        "[Single] public class Thing : IThing;",
+        "[Single(As = typeof(IThing))] public class Thing : IThing;"
+    )]
+    [InlineData(
+        "[global::DependencyModules.Runtime.Attributes.SingletonServiceAttribute] public class Thing : IThing;",
+        "[global::DependencyModules.Runtime.Attributes.SingletonServiceAttribute(As = typeof(IThing))] public class Thing : IThing;"
+    )]
+    // A nested class.
+    [InlineData(
+        "public class Outer { [SingletonService] public class Inner : IThing; }",
+        "public class Outer { [SingletonService(As = typeof(IThing))] public class Inner : IThing; }"
+    )]
+    // An As that is not typeof(...) is replaced in place.
+    [InlineData(
+        "[SingletonService(As = null, Order = 1)] public class Thing : IThing;",
+        "[SingletonService(As = typeof(IThing), Order = 1)] public class Thing : IThing;"
+    )]
+    // Each attribute on a class is fixed.
+    [InlineData(
+        "[SingletonService] [ScopedService(Key = \"k\")] public class Thing : IThing;",
+        "[SingletonService(As = typeof(IThing))] [ScopedService(Key = \"k\", As = typeof(IThing))] public class Thing : IThing;"
+    )]
+    public async Task TheFix_NamesTheInferredType(string before, string after)
+    {
+        var fixedText = await CodeFixHarness.FixEachAsync(
+            CodeFixHarness.CreateDocument(Preamble + before)
+        );
+
+        Assert.Equal(Preamble + after, fixedText);
+    }
+
+    [Theory]
+    [InlineData(
+        """
+            [SingletonService(Key = "k" /* key */, Using = RegistrationType.Try, Realm = typeof(TestModule), Order = 2)] // keep
+            public class Thing : IThing;
+            """,
+        """
+            [SingletonService(Key = "k" /* key */, Using = RegistrationType.Try, Realm = typeof(TestModule), Order = 2, As = typeof(IThing))] // keep
+            public class Thing : IThing;
+            """
+    )]
+    [InlineData(
+        """
+            [SingletonService(
+                Key = "k", // the key
+                Order = 2
+            )]
+            public class Thing : IThing;
+            """,
+        """
+            [SingletonService(
+                Key = "k", // the key
+                Order = 2, As = typeof(IThing)
+            )]
+            public class Thing : IThing;
+            """
+    )]
+    [InlineData(
+        "[SingletonService /* note */] public class Thing : IThing;",
+        "[SingletonService(As = typeof(IThing)) /* note */] public class Thing : IThing;"
+    )]
+    [InlineData(
+        "[SingletonService()] public class Thing : IThing;",
+        "[SingletonService(As = typeof(IThing))] public class Thing : IThing;"
+    )]
+    public async Task TheFix_KeepsOtherArgumentsAndTrivia(string before, string after)
+    {
+        var fixedText = await CodeFixHarness.FixEachAsync(
+            CodeFixHarness.CreateDocument(Preamble + before)
+        );
+
+        Assert.Equal(Preamble + after, fixedText);
+    }
+
+    [Fact]
+    public async Task TheFix_IsTitledWithTheType()
+    {
+        var document = CodeFixHarness.CreateDocument(
+            Preamble + "[SingletonService] public class Repo<T> : IRepo<T>;"
+        );
+        var diagnostic = Assert.Single(await CodeFixHarness.DiagnosticsAsync(document.Project));
+
+        var action = Assert.Single(await CodeFixHarness.ActionsAsync(document, diagnostic));
+
+        Assert.Equal("Make service type explicit: IRepo<>", action.Title);
+    }
+
+    /// <summary>
+    /// The diagnostic still reports when the type cannot be written as typeof(...) at the
+    /// attribute, or cannot be determined at all.
+    /// </summary>
+    [Theory]
+    [InlineData(
+        "public interface IMap<TKey, TValue>; [SingletonService] public class Map<T> : IMap<T, int>;"
+    )]
+    [InlineData("[SingletonService] public class Wrapped<T> : IRepo<List<T>>;")]
+    [InlineData(
+        "public static class Factories { [SingletonService] public static Missing Create() => null!; }"
+    )]
+    public async Task AnUnwritableType_IsReportedWithNoFix(string source)
+    {
+        var document = CodeFixHarness.CreateDocument(Preamble + source);
+        var diagnostic = Assert.Single(await CodeFixHarness.DiagnosticsAsync(document.Project));
+
+        Assert.Empty(await CodeFixHarness.ActionsAsync(document, diagnostic));
+    }
+
+    [Fact]
+    public async Task AnUndeterminedType_SaysSo()
+    {
+        var document = CodeFixHarness.CreateDocument(
+            Preamble
+                + "public static class Factories { [SingletonService(As = null)] public static Missing Create() => null!; }"
+        );
+        var diagnostic = Assert.Single(await CodeFixHarness.DiagnosticsAsync(document.Project));
+
+        Assert.Equal(
+            "[SingletonService] on 'Create' does not name its service type with As = typeof(...). "
+                + "The generator ignores an As that is not typeof(...), so the service type is inferred. "
+                + "The service type cannot be determined.",
+            diagnostic.GetMessage()
+        );
+    }
+
+    [Theory]
+    [InlineData(FixAllScope.Document, 0, 1, 1)]
+    [InlineData(FixAllScope.Project, 0, 0, 1)]
+    [InlineData(FixAllScope.Solution, 0, 0, 0)]
+    public async Task FixAll_FixesItsScope(
+        FixAllScope scope,
+        int leftInFirst,
+        int leftInSecond,
+        int leftInOtherProject
+    )
+    {
+        var solution = CodeFixHarness.CreateSolution(
+            new[]
+            {
+                new[]
+                {
+                    Preamble
+                        + "[SingletonService] public class A1 : IThing; [ScopedService] public class A2;",
+                    "using DependencyModules.Runtime.Attributes; namespace TestNamespace; [TransientService] public class B1 : IFirst;",
+                },
+                new[] { Preamble + "[SingletonService] public class C1 : ISecond;" },
+            }
+        );
+
+        var first = solution.Projects.First().Documents.First();
+
+        var fixedSolution = await CodeFixHarness.FixAllAsync(first, scope);
+
+        var left = new List<int>();
+
+        foreach (var project in fixedSolution.Projects)
+        {
+            var diagnostics = await CodeFixHarness.DiagnosticsAsync(project);
+
+            foreach (var document in project.Documents)
+            {
+                var tree = await document.GetSyntaxTreeAsync();
+                left.Add(diagnostics.Count(diagnostic => diagnostic.Location.SourceTree == tree));
+            }
+        }
+
+        Assert.Equal(new[] { leftInFirst, leftInSecond, leftInOtherProject }, left);
+
+        var firstText = (await fixedSolution.GetDocument(first.Id)!.GetTextAsync()).ToString();
+        Assert.EndsWith(
+            "[SingletonService(As = typeof(IThing))] public class A1 : IThing; "
+                + "[ScopedService(As = typeof(A2))] public class A2;",
+            firstText
+        );
+    }
+
+    /// <summary>
+    /// Generates the module, applies every fix, generates again, and compares what the container
+    /// gets.
+    /// </summary>
+    [Fact]
+    public async Task ApplyingEveryFix_LeavesTheRegistrationsUnchanged()
+    {
+        const string registrations = """
+            [SingletonService] public class Concrete;
+
+            [SingletonService] public record Settings;
+
+            [ScopedService] public class Multiple : IFirst, ISecond;
+
+            public abstract class ThingBase : IThing;
+
+            [TransientService(Key = "inherited")] public class Inherited : ThingBase;
+
+            [SingletonService] public class Disposable : IDisposable { public void Dispose() { } }
+
+            [ScopedService(Key = "role")] public class DisposableThing : IDisposable, IThing { public void Dispose() { } }
+
+            [ScopedService] public class Repo<T> : IRepo<T>;
+
+            [TransientService(Key = "ints")] public class IntRepo : IRepo<int>;
+
+            [Single(Using = RegistrationType.Try, Order = 1)] public class Aliased : ISecond;
+
+            [SingletonService(As = null)] public class InvalidAs : IFirst;
+
+            public class Made : IThing;
+
+            public static class Factories
+            {
+                [SingletonService] public static Made Create() => new();
+
+                [TransientService] public static IThing CreateThing() => new Made();
+            }
+            """;
+
+        var before = Preamble + registrations;
+        var after = await CodeFixHarness.FixEachAsync(CodeFixHarness.CreateDocument(before));
+
+        Assert.Empty(
+            await CodeFixHarness.DiagnosticsAsync(CodeFixHarness.CreateDocument(after).Project)
+        );
+        Assert.Equal(12, after.Split("As = typeof(").Length - 1);
+
+        Assert.Equal(
+            Registrations(GeneratedAssembly.Create(before)),
+            Registrations(GeneratedAssembly.Create(after))
+        );
+    }
+
+    private static IReadOnlyList<string> Registrations(GeneratedAssembly assembly) =>
+        assembly
+            .Services.Where(descriptor => descriptor.ServiceType.Namespace == "TestNamespace")
+            .Select(descriptor =>
+                $"{descriptor.ServiceType.FullName} {descriptor.Lifetime} {descriptor.ServiceKey} "
+                + (
+                    descriptor.IsKeyedService
+                        ? descriptor.KeyedImplementationType?.FullName
+                        : descriptor.ImplementationType?.FullName
+                )
+            )
+            .Order(StringComparer.Ordinal)
+            .ToArray();
+}
diff --git a/tests/DependencyModules.Tests/Infrastructure/CodeFixHarness.cs b/tests/DependencyModules.Tests/Infrastructure/CodeFixHarness.cs
new file mode 100644
index 0000000..4ae3d31
--- /dev/null
+++ b/tests/DependencyModules.Tests/Infrastructure/CodeFixHarness.cs
@@ -0,0 +1,203 @@
+using System.Collections.Immutable;
+using DependencyModules.CodeFixes;
+using DependencyModules.SourceGenerator;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace DependencyModules.Tests.Infrastructure;
+
+/// <summary>
+/// Runs <see cref="ServiceTypeAnalyzer"/> over a workspace and applies
+/// <see cref="ServiceTypeCodeFixProvider"/> the way an IDE does.
+/// </summary>
+public static class CodeFixHarness
+{
+    public const string DiagnosticId = "DM0026";
+
+    /// <summary>
+    /// A solution with one project per entry, each holding its sources in order as
+    /// <c>Test0.cs</c>, <c>Test1.cs</c> and so on.
+    /// </summary>
+    /// <param name="severity">The severity DM0026 is set to, or null to leave its default.</param>
+    public static Solution CreateSolution(
+        IReadOnlyList<IReadOnlyList<string>> projects,
+        ReportDiagnostic? severity = ReportDiagnostic.Warn
+    )
+    {
+        var workspace = new AdhocWorkspace();
+        var solution = workspace.CurrentSolution;
+
+        var options = new CSharpCompilationOptions(
+            OutputKind.DynamicallyLinkedLibrary,
+            nullableContextOptions: NullableContextOptions.Enable
+        );
+
+        if (severity != null)
+        {
+            options = options.WithSpecificDiagnosticOptions(
+                ImmutableDictionary<string, ReportDiagnostic>.Empty.Add(
+                    DiagnosticId,
+                    severity.Value
+                )
+            );
+        }
+
+        for (var projectIndex = 0; projectIndex < projects.Count; projectIndex++)
+        {
+            var projectId = ProjectId.CreateNewId();
+
+            solution = solution
+                .AddProject(projectId, $"Project{projectIndex}", $"Project{projectIndex}", "C#")
+                .WithProjectCompilationOptions(projectId, options)
+                .WithProjectParseOptions(projectId, new CSharpParseOptions(LanguageVersion.Latest))
+                .AddMetadataReferences(projectId, GeneratorTestHarness.MetadataReferences);
+
+            for (var index = 0; index < projects[projectIndex].Count; index++)
+            {
+                solution = solution.AddDocument(
+                    DocumentId.CreateNewId(projectId),
+                    $"Test{index}.cs",
+                    projects[projectIndex][index]
+                );
+            }
+        }
+
+        return solution;
+    }
+
+    public static Document CreateDocument(string source) =>
+        CreateSolution(new[] { new[] { source } }).Projects.Single().Documents.Single();
+
+    /// <summary>
+    /// The DM0026 diagnostics in a project, in source order.
+    /// </summary>
+    public static async Task<ImmutableArray<Diagnostic>> DiagnosticsAsync(Project project)
+    {
+        var compilation = await project.GetCompilationAsync();
+
+        var diagnostics = await compilation!
+            .WithAnalyzers(ImmutableArray.Create<DiagnosticAnalyzer>(new ServiceTypeAnalyzer()))
+            .GetAnalyzerDiagnosticsAsync();
+
+        return diagnostics
+            .Where(diagnostic => diagnostic.Id == DiagnosticId)
+            .OrderBy(diagnostic => diagnostic.Location.SourceTree?.FilePath)
+            .ThenBy(diagnostic => diagnostic.Location.SourceSpan.Start)
+            .ToImmutableArray();
+    }
+
+    /// <summary>
+    /// The code actions offered for one diagnostic.
+    /// </summary>
+    public static async Task<IReadOnlyList<CodeAction>> ActionsAsync(
+        Document document,
+        Diagnostic diagnostic
+    )
+    {
+        var actions = new List<CodeAction>();
+
+        await new ServiceTypeCodeFixProvider().RegisterCodeFixesAsync(
+            new CodeFixContext(
+                document,
+                diagnostic,
+                (action, _) => actions.Add(action),
+                CancellationToken.None
+            )
+        );
+
+        return actions;
+    }
+
+    /// <summary>
+    /// Applies the single fix offered for each DM0026 in the document, one at a time, and returns
+    /// the text.
+    /// </summary>
+    public static async Task<string> FixEachAsync(Document document)
+    {
+        while (true)
+        {
+            var diagnostics = await DiagnosticsAsync(document.Project);
+            var tree = await document.GetSyntaxTreeAsync();
+
+            var fixable = new List<CodeAction>();
+
+            foreach (var diagnostic in diagnostics.Where(d => d.Location.SourceTree == tree))
+            {
+                fixable.AddRange(await ActionsAsync(document, diagnostic));
+            }
+
+            if (fixable.Count == 0)
+            {
+                return (await document.GetTextAsync()).ToString();
+            }
+
+            var solution = await ApplyAsync(fixable[0]);
+            document = solution.GetDocument(document.Id)!;
+        }
+    }
+
+    /// <summary>
+    /// Runs Fix All from <paramref name="document"/> at <paramref name="scope"/>.
+    /// </summary>
+    public static async Task<Solution> FixAllAsync(Document document, FixAllScope scope)
+    {
+        var provider = new ServiceTypeCodeFixProvider();
+
+        var diagnostics = await DiagnosticsAsync(document.Project);
+        var tree = await document.GetSyntaxTreeAsync();
+        var first = diagnostics.First(diagnostic => diagnostic.Location.SourceTree == tree);
+        var action = (await ActionsAsync(document, first)).Single();
+
+        var context = new FixAllContext(
+            document,
+            provider,
+            scope,
+            action.EquivalenceKey,
+            provider.FixableDiagnosticIds,
+            new AnalyzerDiagnosticProvider(),
+            CancellationToken.None
+        );
+
+        var fix = await provider.GetFixAllProvider()!.GetFixAsync(context);
+
+        Assert.NotNull(fix);
+
+        return await ApplyAsync(fix!);
+    }
+
+    private static async Task<Solution> ApplyAsync(CodeAction action)
+    {
+        var operations = await action.GetOperationsAsync(CancellationToken.None);
+
+        return operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
+    }
+
+    private sealed class AnalyzerDiagnosticProvider : FixAllContext.DiagnosticProvider
+    {
+        public override async Task<IEnumerable<Diagnostic>> GetDocumentDiagnosticsAsync(
+            Document document,
+            CancellationToken cancellationToken
+        )
+        {
+            var tree = await document.GetSyntaxTreeAsync(cancellationToken);
+
+            return (await DiagnosticsAsync(document.Project)).Where(diagnostic =>
+                diagnostic.Location.SourceTree == tree
+            );
+        }
+
+        public override Task<IEnumerable<Diagnostic>> GetProjectDiagnosticsAsync(
+            Project project,
+            CancellationToken cancellationToken
+        ) => Task.FromResult(Enumerable.Empty<Diagnostic>());
+
+        public override async Task<IEnumerable<Diagnostic>> GetAllDiagnosticsAsync(
+            Project project,
+            CancellationToken cancellationToken
+        ) => await DiagnosticsAsync(project);
+    }
+}
diff --git a/tests/DependencyModules.Tests/Infrastructure/GeneratorTestHarness.cs b/tests/DependencyModules.Tests/Infrastructure/GeneratorTestHarness.cs
index 3700cc4..aba312c 100644
--- a/tests/DependencyModules.Tests/Infrastructure/GeneratorTestHarness.cs
+++ b/tests/DependencyModules.Tests/Infrastructure/GeneratorTestHarness.cs
@@ -21,6 +21,11 @@ public static class GeneratorTestHarness
         BuildReferences
     );
 
+    /// <summary>
+    /// The references every compilation here is built with.
+    /// </summary>
+    internal static ImmutableArray<MetadataReference> MetadataReferences => References.Value;
+
     /// <summary>
     /// Compiles <paramref name="sources"/>, runs the generator, and returns everything it emitted.
     /// </summary>
diff --git a/tests/DependencyModules.Tests/Snapshots/PublicApiTests.SourceGeneratorApi.verified.txt b/tests/DependencyModules.Tests/Snapshots/PublicApiTests.SourceGeneratorApi.verified.txt
index 22b208a..e0ee74b 100644
--- a/tests/DependencyModules.Tests/Snapshots/PublicApiTests.SourceGeneratorApi.verified.txt
+++ b/tests/DependencyModules.Tests/Snapshots/PublicApiTests.SourceGeneratorApi.verified.txt
@@ -1277,6 +1277,7 @@ namespace DependencyModules.SourceGenerator.Impl
         public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor OpenGenericCannotBeDecorated;
         public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor RegisteredConditionally;
         public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ServiceCannotBeConstructed;
+        public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ServiceTypeNotNamed;
         public static Microsoft.CodeAnalysis.Diagnostic GeneratorFailureFrom(System.Exception exception) { }
     }
     public class DependencyModuleWriter
@@ -2067,6 +2068,15 @@ namespace DependencyModules.SourceGenerator
                 "Left",
                 "Right"})] System.ValueTuple<System.Collections.Immutable.ImmutableArray<System.ValueTuple<DependencyModules.SourceGenerator.Impl.Models.ModuleEntryPointModel, DependencyModules.SourceGenerator.Impl.Models.DependencyModuleConfigurationModel>>, System.Collections.Immutable.ImmutableArray<DependencyModules.SourceGenerator.Impl.Models.ServiceModel>> data, DependencyModules.SourceGenerator.Impl.Models.SyntaxTreeLookup lookup, DependencyModules.SourceGenerator.Impl.Utilities.FileLogger logger) { }
     }
+    [Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer("C#", new string[0])]
+    public sealed class ServiceTypeAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer
+    {
+        public const string ServiceTypeDisplayProperty = "ServiceTypeDisplay";
+        public const string ServiceTypeProperty = "ServiceType";
+        public ServiceTypeAnalyzer() { }
+        public override System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.DiagnosticDescriptor> SupportedDiagnostics { get; }
+        public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) { }
+    }
     [Microsoft.CodeAnalysis.Generator]
     public class SourceGenerator : DependencyModules.SourceGenerator.Impl.BaseSourceGenerator
     {
diff --git a/website/reference/diagnostics.md b/website/reference/diagnostics.md
index 6838f5d..868811f 100644
--- a/website/reference/diagnostics.md
+++ b/website/reference/diagnostics.md
@@ -29,6 +29,7 @@ The generator gives these diagnostics when you compile. Their category is `Depen
 | [DM0023](#dm0023) | Warning | Factory method cannot be called |
 | [DM0024](#dm0024) | Warning | Cross-wired class declares no interface |
 | [DM0025](#dm0025) | Warning | Decorator is not applied |
+| [DM0026](#dm0026) | Off | A service attribute does not name its service type |
 
 The table shows the title of each diagnostic. The compiler shows a message with more information, for example the names of the types.
 
@@ -265,3 +266,16 @@ A class has `[Decorator]`, but the generator cannot apply the decorator. The gen
 - The type parameters of a generic decorator are not the type arguments of the service type in the same sequence.
 
 To correct the problem, correct the cause that the message gives. For example, set `Service` on the attribute, or give the class a `public` constructor.
+
+## DM0026
+
+A `[SingletonService]`, `[ScopedService]`, or `[TransientService]` attribute has no `As = typeof(...)`. The generator then infers the service type from the class. If you add an interface to the class, the service type can change. The generator also ignores an `As` that is not a `typeof(...)` expression, and the analyzer reports it. `[CrossWireService]` does not get DM0026.
+
+DM0026 is off by default. To turn it on, set its severity in an `.editorconfig` file:
+
+```ini
+[*.cs]
+dotnet_diagnostic.DM0026.severity = error
+```
+
+To correct the problem, add `As = typeof(...)` to the attribute. The code fix "Make service type explicit" adds the type that the generator registers now, so the registration does not change. Fix All works for a document, a project, and a solution. The code fix is not available when the type cannot be written in the attribute, for example `IMap<, int>`.