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>`.