[http-client-csharp] Build discriminated base description from discriminated base type, not abstract modifier (#11412)

The discriminator "Please note this is the abstract base class..."
description was only emitted when a model carried the `Abstract`
declaration modifier. Whether a discriminated base type is modeled as
abstract is an implementation detail — downstream emitters (e.g.
provisioning) may not declare it abstract, causing the derived-classes
note to be dropped.

### Changes
- **`ModelProvider`**: Added `IsDiscriminatedBaseType` helper — a model
with a discriminator property but no discriminator value.
- **`BuildDescription`**: Gates the derived-classes note on
`IsDiscriminatedBaseType` instead of the `Abstract` modifier, decoupling
documentation from abstractness.
- **`BuildDeclarationModifiers`**: Reuses the same helper for the
abstract decision, keeping the base emitter's behavior unchanged.
- **Tests**: Added
`DiscriminatedBaseDescriptionIsBuiltEvenWhenNotAbstract`, using a
`ModelProvider` subclass that strips `Abstract` to mimic a downstream
emitter and asserting the note is still built.

```csharp
private bool IsDiscriminatedBaseType =>
    _inputModel.DiscriminatorProperty is not null && _inputModel.DiscriminatorValue is null;
```

<!-- START COPILOT CODING AGENT SUFFIX -->

- Fixes #11397

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: jorgerangel-msft <102122018+jorgerangel-msft@users.noreply.github.com>

Author: Copilot

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Providers/ModelProvider.cs

@@ -27,12 +27,13 @@ protected override FormattableString BuildDescription()
         {
             var description = DocHelpers.GetFormattableDescription(_inputModel.Summary, _inputModel.Doc) ??
                               $"The {Name}.";
-            if (DeclarationModifiers.HasFlag(TypeSignatureModifiers.Abstract))
+            if (_isDiscriminatedBaseType)
             {
                 _derivedModels = BuildDerivedModels();
                 var publicDerivedModels = _derivedModels.Where(m => m.DeclarationModifiers.HasFlag(TypeSignatureModifiers.Public)).ToList();
-                var derivedClassesDescription =
-                    "Please note this is the abstract base class. The derived classes available for instantiation are: ";
+                var derivedClassesDescription = DeclarationModifiers.HasFlag(TypeSignatureModifiers.Abstract)
+                    ? "Please note this is the abstract base class. The derived classes available for instantiation are: "
+                    : "Please note this is the base class. The derived classes available for instantiation are: ";
                 bool addComma = publicDerivedModels.Count > 2;
                 for (int i = 0; i < publicDerivedModels.Count; i++)
                 {
@@ -65,11 +66,15 @@ protected override FormattableString BuildDescription()
         private ModelProvider? _baseModelProvider;
         private ConstructorProvider? _fullConstructor;
         internal PropertyProvider? DiscriminatorProperty { get; private set; }
+
+        private readonly bool _isDiscriminatedBaseType;
+
         private ValueExpression DiscriminatorLiteral => Literal(_inputModel.DiscriminatorValue ?? "");
 
         public ModelProvider(InputModelType inputModel) : base(inputModel)
         {
             _inputModel = inputModel;
+            _isDiscriminatedBaseType = inputModel.DiscriminatorProperty is not null && inputModel.DiscriminatorValue is null;
             _isMultiLevelDiscriminator = ComputeIsMultiLevelDiscriminator();
             _useObjectAdditionalProperties = new Lazy<bool>(ShouldUseObjectAdditionalProperties);
         }
@@ -324,7 +329,7 @@ protected override TypeSignatureModifiers BuildDeclarationModifiers()
                 declarationModifiers |= TypeSignatureModifiers.Internal;
             }
 
-            if (_inputModel.DiscriminatorProperty is not null && _inputModel.DiscriminatorValue is null)
+            if (_isDiscriminatedBaseType)
             {
                 declarationModifiers |= TypeSignatureModifiers.Abstract;
             }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Providers/ModelProviders/DiscriminatorTests.cs

@@ -120,6 +120,34 @@ public void BaseShouldBeAbstract(InputModelType inputModel, string expectedSumma
             Assert.AreEqual(expectedSummary, baseModel.XmlDocs.Summary!.ToDisplayString());
         }
 
+        [TestCase(true, "Please note this is the abstract base class. The derived classes available for instantiation are: <see cref=\"Sample.Models.Cat\"/>, <see cref=\"Sample.Models.Dog\"/>, and <see cref=\"Sample.Models.AnotherAnimal\"/>.")]
+        [TestCase(false, "Please note this is the base class. The derived classes available for instantiation are: <see cref=\"Sample.Models.Cat\"/>, <see cref=\"Sample.Models.Dog\"/>, and <see cref=\"Sample.Models.AnotherAnimal\"/>.")]
+        public void DiscriminatedBaseDescriptionReflectsAbstractness(bool isAbstract, string expectedDescription)
+        {
+            MockHelpers.LoadMockGenerator();
+            // When not abstract, simulate a downstream emitter that does not model the discriminated base type as abstract.
+            var baseModel = isAbstract
+                ? CodeModelGenerator.Instance.TypeFactory.CreateModel(_baseModel)!
+                : new NonAbstractModelProvider(_baseModel);
+            Assert.AreEqual(isAbstract, baseModel.DeclarationModifiers.HasFlag(TypeSignatureModifiers.Abstract));
+
+            // The discriminated base description should reference derived models regardless of abstractness.
+            Assert.IsNotNull(baseModel.XmlDocs.Summary);
+            StringAssert.Contains(expectedDescription, baseModel.XmlDocs.Summary!.ToDisplayString());
+        }
+
+        private class NonAbstractModelProvider : ModelProvider
+        {
+            public NonAbstractModelProvider(InputModelType inputModel) : base(inputModel)
+            {
+            }
+
+            protected override TypeSignatureModifiers BuildDeclarationModifiers()
+            {
+                return base.BuildDeclarationModifiers() & ~TypeSignatureModifiers.Abstract;
+            }
+        }
+
         [Test]
         public void DiscriminatorPropertyShouldBeInternal()
         {