Avoid virtual implementations for AddSynthesizedAttributes

src/Compilers/CSharp/Portable/Symbols/Extensions/ReceiverParameterSymbol.cs

@@ -4,6 +4,8 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -37,5 +39,8 @@ internal override ImmutableArray<int> InterpolatedStringHandlerArgumentIndexes
         }
 
         internal override bool HasInterpolatedStringHandlerArgumentError => _underlyingParameter.HasInterpolatedStringHandlerArgumentError;
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenLambdaOrLocalFunctionSymbol.cs

@@ -4,6 +4,7 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
@@ -37,5 +38,9 @@ protected override ImmutableArray<ParameterSymbol> MakeParameters()
         {
             return ImmutableArray<ParameterSymbol>.CastUp(_originalMethod.Parameters.SelectAsArray(static (p, @this) => new RewrittenMethodParameterSymbol(@this, p), this));
         }
+
+        internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+        {
+        }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenMethodSymbol.cs

@@ -4,6 +4,8 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -115,11 +117,23 @@ internal sealed override bool HasAsyncMethodBuilderAttribute(out TypeSymbol? bui
             return _originalMethod.HasAsyncMethodBuilderAttribute(out builderArgument);
         }
 
-        protected class RewrittenMethodParameterSymbol : RewrittenParameterSymbol
+        protected class RewrittenMethodParameterSymbol : RewrittenMethodParameterSymbolBase
+        {
+            internal RewrittenMethodParameterSymbol(RewrittenMethodSymbol containingMethod, ParameterSymbol originalParameter)
+                : base(containingMethod, originalParameter)
+            {
+            }
+
+            internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            {
+            }
+        }
+
+        protected abstract class RewrittenMethodParameterSymbolBase : RewrittenParameterSymbol
         {
             protected readonly RewrittenMethodSymbol _containingMethod;
 
-            public RewrittenMethodParameterSymbol(RewrittenMethodSymbol containingMethod, ParameterSymbol originalParameter) :
+            protected RewrittenMethodParameterSymbolBase(RewrittenMethodSymbol containingMethod, ParameterSymbol originalParameter) :
                 base(originalParameter)
             {
                 _containingMethod = containingMethod;

src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs

@@ -181,7 +181,7 @@ public override string GetDocumentationCommentXml(CultureInfo? preferredCulture
             return result;
         }
 
-        private sealed class ExtensionMetadataMethodParameterSymbol : RewrittenMethodParameterSymbol
+        private sealed class ExtensionMetadataMethodParameterSymbol : RewrittenMethodParameterSymbolBase
         {
             public ExtensionMetadataMethodParameterSymbol(SourceExtensionImplementationMethodSymbol containingMethod, ParameterSymbol sourceParameter) :
                 base(containingMethod, sourceParameter)
@@ -205,8 +205,6 @@ internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, r
                     valueParameter.AddSynthesizedFlowAnalysisAttributes(ref attributes);
                 }
 
-                // Synthesized nullability attributes are context-dependent, so we intentionally do not call base.AddSynthesizedAttributes here
-                // as that would delegate to underlying parameter symbol
                 SourceParameterSymbolBase.AddSynthesizedAttributes(this, moduleBuilder, ref attributes);
             }
 

src/Compilers/CSharp/Portable/Symbols/NativeIntegerTypeSymbol.cs

@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.Collections;
+using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -423,6 +424,9 @@ internal sealed override bool HasAsyncMethodBuilderAttribute(out TypeSymbol? bui
 
         internal override int TryGetOverloadResolutionPriority()
             => UnderlyingMethod.TryGetOverloadResolutionPriority();
+
+        internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 
     internal sealed class NativeIntegerParameterSymbol : WrappedParameterSymbol
@@ -466,6 +470,9 @@ internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, Na
 
         public override int GetHashCode() => _underlyingParameter.GetHashCode();
 
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
+
 #if !DEBUG
         void Cci.IReference.Dispatch(Cci.MetadataVisitor visitor)
         {

src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs

@@ -10,6 +10,7 @@
 using System.Globalization;
 using System.Linq;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -702,6 +703,9 @@ public sealed override int GetHashCode()
             {
                 return Hash.Combine(ContainingSymbol, _underlyingParameter.Ordinal);
             }
+
+            internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+                => throw ExceptionUtilities.Unreachable();
         }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingMethodSymbol.cs

@@ -393,5 +393,8 @@ internal sealed override bool HasAsyncMethodBuilderAttribute(out TypeSymbol buil
             builderArgument = null;
             return false;
         }
+
+        internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingParameterSymbol.cs

@@ -7,6 +7,7 @@
 using System.Diagnostics;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols.Retargeting
 {
@@ -159,6 +160,9 @@ internal sealed override int CallerArgumentExpressionParameterIndex
         {
             get { return _underlyingParameter.CallerArgumentExpressionParameterIndex; }
         }
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 
     internal sealed class RetargetingMethodParameterSymbol : RetargetingParameterSymbol

src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingTypeParameterSymbol.cs

@@ -14,6 +14,8 @@
 using Roslyn.Utilities;
 using System.Diagnostics;
 using System.Globalization;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols.Retargeting
 {
@@ -113,5 +115,8 @@ internal override TypeSymbol GetDeducedBaseType(ConsList<TypeParameterSymbol> in
         {
             get { return null; }
         }
+
+        internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/SubstitutedMethodSymbol.cs

@@ -8,6 +8,7 @@
 using System.Diagnostics;
 using System.Threading;
 using Microsoft.CodeAnalysis.Collections;
+using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -486,5 +487,8 @@ internal sealed override bool HasAsyncMethodBuilderAttribute(out TypeSymbol buil
         {
             return _underlyingMethod.HasAsyncMethodBuilderAttribute(out builderArgument);
         }
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/SubstitutedParameterSymbol.cs

@@ -4,6 +4,8 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -127,5 +129,8 @@ public sealed override int GetHashCode()
         {
             return Roslyn.Utilities.Hash.Combine(ContainingSymbol, _underlyingParameter.Ordinal);
         }
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/SubstitutedTypeParameterSymbol.cs

@@ -9,12 +9,25 @@
 using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
-    internal class SubstitutedTypeParameterSymbol : WrappedTypeParameterSymbol
+    internal sealed class SubstitutedTypeParameterSymbol : SubstitutedTypeParameterSymbolBase
+    {
+        internal SubstitutedTypeParameterSymbol(Symbol newContainer, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal)
+            : base(newContainer, map, substitutedFrom, ordinal)
+        {
+        }
+
+        internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+        {
+        }
+    }
+
+    internal abstract class SubstitutedTypeParameterSymbolBase : WrappedTypeParameterSymbol
     {
         private readonly Symbol _container;
         private readonly TypeMap _map;
@@ -25,7 +38,7 @@ internal class SubstitutedTypeParameterSymbol : WrappedTypeParameterSymbol
         private readonly int _mySequence;
 #endif
 
-        internal SubstitutedTypeParameterSymbol(Symbol newContainer, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal)
+        internal SubstitutedTypeParameterSymbolBase(Symbol newContainer, TypeMap map, TypeParameterSymbol substitutedFrom, int ordinal)
             : base(substitutedFrom)
         {
             _container = newContainer;

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedSubstitutedTypeParameterSymbol.cs

@@ -14,7 +14,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
     /// <summary>
     /// A type parameter for a synthesized class or method.
     /// </summary>
-    internal sealed class SynthesizedSubstitutedTypeParameterSymbol : SubstitutedTypeParameterSymbol
+    internal sealed class SynthesizedSubstitutedTypeParameterSymbol : SubstitutedTypeParameterSymbolBase
     {
         /// <summary>
         /// Indicates whether the synthesized type parameter should keep the original attributes by default
@@ -57,8 +57,6 @@ internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, r
                 }
             }
 
-            base.AddSynthesizedAttributes(moduleBuilder, ref attributes);
-
             if (this.HasUnmanagedTypeConstraint)
             {
                 AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeIsUnmanagedAttribute(this));

src/Compilers/CSharp/Portable/Symbols/TypeMap.cs

@@ -124,7 +124,7 @@ internal TypeMap WithAlphaRename(ImmutableArray<TypeParameterSymbol> oldTypePara
             int ordinal = 0;
             foreach (var tp in oldTypeParameters)
             {
-                var newTp = synthesized ?
+                TypeParameterSymbol newTp = synthesized ?
                     new SynthesizedSubstitutedTypeParameterSymbol(newOwner, result, tp, ordinal, propagateAttributes) :
                     new SubstitutedTypeParameterSymbol(newOwner, result, tp, ordinal);
                 result.Mapping.Add(tp, TypeWithAnnotations.Create(newTp));

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedEventSymbol.cs

@@ -6,6 +6,8 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
@@ -162,5 +164,8 @@ internal override bool HasRuntimeSpecialName
                 return _underlyingEvent.HasRuntimeSpecialName;
             }
         }
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedFieldSymbol.cs

@@ -8,6 +8,8 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -206,5 +208,8 @@ public override bool IsStatic
         }
 
         internal sealed override bool IsRequired => _underlyingField.IsRequired;
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedMethodSymbol.cs

@@ -8,6 +8,8 @@
 using System.Collections.Immutable;
 using System.Globalization;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -364,5 +366,7 @@ internal override bool GenerateDebugInfo
         internal sealed override bool HasUnscopedRefAttribute => UnderlyingMethod.HasUnscopedRefAttribute;
 
         internal sealed override bool UseUpdatedEscapeRules => UnderlyingMethod.UseUpdatedEscapeRules;
+
+        internal abstract override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes);
     }
 }

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedNamedTypeSymbol.cs

@@ -10,6 +10,8 @@
 using System.Globalization;
 using System.Runtime.InteropServices;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -258,5 +260,8 @@ internal override bool GetGuidString(out string guidString)
         {
             return _underlyingType.GetGuidString(out guidString);
         }
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs

@@ -71,10 +71,7 @@ public override ImmutableArray<CSharpAttributeData> GetAttributes()
             return _underlyingParameter.GetAttributes();
         }
 
-        internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
-        {
-            _underlyingParameter.AddSynthesizedAttributes(moduleBuilder, ref attributes);
-        }
+        internal abstract override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes);
 
         internal sealed override ConstantValue? ExplicitDefaultConstantValue
         {

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedPropertySymbol.cs

@@ -8,6 +8,8 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -190,5 +192,8 @@ internal override bool HasRuntimeSpecialName
         }
 
         internal override int TryGetOverloadResolutionPriority() => _underlyingProperty.OverloadResolutionPriority;
+
+        internal sealed override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes)
+            => throw ExceptionUtilities.Unreachable();
     }
 }

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedTypeParameterSymbol.cs

@@ -8,6 +8,8 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -179,5 +181,7 @@ public override ImmutableArray<CSharpAttributeData> GetAttributes()
         {
             return _underlyingTypeParameter.GetAttributes();
         }
+
+        internal abstract override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes);
     }
 }