dotnet · jcouv · Apr 3, 2025 · Mar 28, 2025 · Apr 2, 2025 · Apr 2, 2025
diff --git a/docs/contributing/Compiler Test Plan.md b/docs/contributing/Compiler Test Plan.md
@@ -80,6 +80,7 @@ This document provides guidance for thinking about language interactions and tes
 - Readonly members on structs (methods, property/indexer accessors, custom event accessors)
 - SkipLocalsInit
 - Method override or explicit implementation with `where T : { class, struct, default }`
+- `extension` blocks
 
 # Code
 - Operators (see Eric's list below)

@@ -2121,7 +2121,7 @@ private BoundExpression BindNonMethod(SimpleNameSyntax node, Symbol symbol, Bind
                         {
                             Error(diagnostics, ErrorCode.ERR_InvalidPrimaryConstructorParameterReference, node, parameter);
                         }
-                        else if (parameter.ContainingSymbol is NamedTypeSymbol { IsExtension: true } &&
+                        else if (parameter.IsExtensionParameter() &&
                                 (InParameterDefaultValue || InAttributeArgument ||
                                  this.ContainingMember() is not { Kind: not SymbolKind.NamedType, IsStatic: false } || // We are not in an instance member
                                  (object)this.ContainingMember().ContainingSymbol != parameter.ContainingSymbol) &&

@@ -74,7 +74,7 @@ internal void ValidateParameterNameConflicts(
                                 diagnostics.Add(ErrorCode.ERR_LocalSameNameAsExtensionTypeParameter, GetLocation(p), name);
                             }
                         }
-                        else if (p.ContainingSymbol is NamedTypeSymbol { IsExtension: true })
+                        else if (p.IsExtensionParameter())
                         {
                             diagnostics.Add(ErrorCode.ERR_TypeParameterSameNameAsExtensionParameter, tp.GetFirstLocationOrNone(), name);
                         }

@@ -107,14 +107,24 @@ public static void ValidateIteratorMethod(CSharpCompilation compilation, MethodS
                 return;
             }
 
-            foreach (var parameter in iterator.Parameters)
+            var parameters = !iterator.IsStatic
+                ? iterator.GetParametersIncludingExtensionParameter()
+                : iterator.Parameters;
+
+            foreach (var parameter in parameters)
             {
+                bool isReceiverParameter = parameter.IsExtensionParameter();
                 if (parameter.RefKind != RefKind.None)
                 {
-                    diagnostics.Add(ErrorCode.ERR_BadIteratorArgType, parameter.GetFirstLocation());
+                    var location = isReceiverParameter
+                        ? ((MethodDeclarationSyntax)iterator.GetNonNullSyntaxNode()).Identifier.GetLocation()
+                        : parameter.GetFirstLocation();
+
+                    diagnostics.Add(ErrorCode.ERR_BadIteratorArgType, location);
                 }
-                else if (parameter.Type.IsPointerOrFunctionPointer())
+                else if (parameter.Type.IsPointerOrFunctionPointer() && !isReceiverParameter)
                 {
+                    // We already reported an error elsewhere if the receiver parameter of an extension is a pointer type.
                     diagnostics.Add(ErrorCode.ERR_UnsafeIteratorArgType, parameter.GetFirstLocation());
                 }
             }

@@ -696,7 +696,9 @@ internal static bool HasInternalAccessTo(this AssemblySymbol fromAssembly, Assem
 
         internal static ErrorCode GetProtectedMemberInSealedTypeError(NamedTypeSymbol containingType)
         {
-            return containingType.TypeKind == TypeKind.Struct ? ErrorCode.ERR_ProtectedInStruct : ErrorCode.WRN_ProtectedInSealed;
+            return containingType.IsExtension ? ErrorCode.ERR_ProtectedInExtension
+                : containingType.TypeKind == TypeKind.Struct ? ErrorCode.ERR_ProtectedInStruct
+                : ErrorCode.WRN_ProtectedInSealed;
         }
     }
 }
@@ -3879,7 +3879,7 @@ private static EffectiveParameters GetEffectiveParametersInNormalForm<TMember>(
             hasAnyRefOmittedArgument = false;
 
             bool isNewExtensionMember = member.GetIsNewExtensionMember();
-            ImmutableArray<ParameterSymbol> parameters = isNewExtensionMember ? GetParametersIncludingReceiver(member) : member.GetParameters();
+            ImmutableArray<ParameterSymbol> parameters = member.GetParametersIncludingExtensionParameter();
 
             // We simulate an extra parameter for vararg methods 
             int parameterCount = parameters.Length + (member.GetIsVararg() ? 1 : 0);
@@ -4040,7 +4040,7 @@ private static EffectiveParameters GetEffectiveParametersInExpandedForm<TMember>
             var types = ArrayBuilder<TypeWithAnnotations>.GetInstance();
             var refs = ArrayBuilder<RefKind>.GetInstance();
             bool anyRef = false;
-            var parameters = member.GetIsNewExtensionMember() ? GetParametersIncludingReceiver(member) : member.GetParameters();
+            var parameters = member.GetParametersIncludingExtensionParameter();
             bool hasAnyRefArg = argumentRefKinds.Any();
             hasAnyRefOmittedArgument = false;
             TypeWithAnnotations paramsIterationType = default;

@@ -895,7 +895,7 @@ private static void ReportMissingRequiredParameter(
             // to required formal parameter 'y'.
 
             TMember badMember = bad.Member;
-            ImmutableArray<ParameterSymbol> parameters = badMember.GetIsNewExtensionMember() ? OverloadResolution.GetParametersIncludingReceiver(badMember) : badMember.GetParameters();
+            ImmutableArray<ParameterSymbol> parameters = badMember.GetParametersIncludingExtensionParameter();
             int badParamIndex = bad.Result.BadParameter;
             string badParamName;
             if (badParamIndex == parameters.Length)
@@ -1115,7 +1115,7 @@ private bool HadBadArguments(
                 // as there is no explicit call to Add method.
 
                 int argumentOffset = arguments.IncludesReceiverAsArgument ? 1 : 0;
-                var parameters = method.GetIsNewExtensionMember() ? OverloadResolution.GetParametersIncludingReceiver(method) : method.GetParameters();
+                var parameters = method.GetParametersIncludingExtensionParameter();
 
                 for (int i = argumentOffset; i < parameters.Length; i++)
                 {
@@ -1170,7 +1170,7 @@ private static void ReportBadArgumentError(
 
             // Early out: if the bad argument is an __arglist parameter then simply report that:
 
-            var parameters = method.GetIsNewExtensionMember() ? OverloadResolution.GetParametersIncludingReceiver(method) : method.GetParameters();
+            var parameters = method.GetParametersIncludingExtensionParameter();
             if (method.GetIsVararg() && parm == parameters.Length)
             {
                 // NOTE: No SymbolDistinguisher required, since one of the arguments is "__arglist".

@@ -55,13 +55,6 @@ public ImmutableArray<int> ToImmutableArray()
             }
         }
 
-        internal static ImmutableArray<ParameterSymbol> GetParametersIncludingReceiver(Symbol symbol)
-        {
-            Debug.Assert(symbol.GetIsNewExtensionMember());
-            // Tracked by https://github.com/dotnet/roslyn/issues/76130 : consider optimizing
-            return [symbol.ContainingType.ExtensionParameter, .. symbol.GetParameters()];
-        }
-
         private static ImmutableArray<TypeWithAnnotations> GetParameterTypesIncludingReceiver(Symbol symbol)
         {
             Debug.Assert(symbol.GetIsNewExtensionMember());
@@ -79,7 +72,7 @@ private static ArgumentAnalysisResult AnalyzeArguments(
             Debug.Assert(arguments != null);
 
             bool isNewExtensionMember = symbol.GetIsNewExtensionMember();
-            ImmutableArray<ParameterSymbol> parameters = isNewExtensionMember ? GetParametersIncludingReceiver(symbol) : symbol.GetParameters();
+            ImmutableArray<ParameterSymbol> parameters = symbol.GetParametersIncludingExtensionParameter();
             bool isVararg = symbol.GetIsVararg();
 
             // The easy out is that we have no named arguments and are in normal form.

@@ -2525,7 +2525,7 @@ A catch() block after a catch (System.Exception e) block can catch non-CLS excep
     <value> The parameter modifier '{0}' cannot be used with '{1}'</value>
   </data>
   <data name="ERR_BadTypeforThis" xml:space="preserve">
-    <value>The first parameter of an extension method cannot be of type '{0}'</value>
+    <value>The receiver parameter of an extension cannot be of type '{0}'</value>
   </data>
   <data name="ERR_BadParamModThis" xml:space="preserve">
     <value>A parameter array cannot be used with 'this' modifier on an extension method</value>
@@ -5914,6 +5914,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_InExtensionMustBeValueType" xml:space="preserve">
     <value>The first 'in' or 'ref readonly' parameter of the extension method '{0}' must be a concrete (non-generic) value type.</value>
   </data>
+  <data name="ERR_InExtensionParameterMustBeValueType" xml:space="preserve">
+    <value>The 'in' or 'ref readonly' receiver parameter of extension must be a concrete (non-generic) value type.</value>
+  </data>
   <data name="ERR_FieldsInRoStruct" xml:space="preserve">
     <value>Instance fields of readonly structs must be readonly.</value>
   </data>
@@ -5932,6 +5935,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_RefExtensionMustBeValueTypeOrConstrainedToOne" xml:space="preserve">
     <value>The first parameter of a 'ref' extension method '{0}' must be a value type or a generic type constrained to struct.</value>
   </data>
+  <data name="ERR_RefExtensionParameterMustBeValueTypeOrConstrainedToOne" xml:space="preserve">
+    <value>The 'ref' receiver parameter of an extension block must be a value type or a generic type constrained to struct.</value>
+  </data>
   <data name="ERR_OutAttrOnInParam" xml:space="preserve">
     <value>An in parameter cannot have the Out attribute.</value>
   </data>
@@ -8134,4 +8140,19 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_PPIgnoredFollowsIf" xml:space="preserve">
     <value>'#:' directives cannot be after '#if' directive</value>
   </data>
+  <data name="ERR_ProtectedInExtension" xml:space="preserve">
+    <value>'{0}': new protected member declared in an extension block</value>
+  </data>
+  <data name="ERR_InstanceMemberWithUnnamedExtensionsParameter" xml:space="preserve">
+    <value>'{0}': cannot declare instance members in an extension block with an unnamed receiver parameter</value>
+  </data>
+  <data name="ERR_InitInExtension" xml:space="preserve">
+    <value>'{0}': cannot declare init-only accessors in an extension block</value>
+  </data>
+  <data name="ERR_ModifierOnUnnamedReceiverParameter" xml:space="preserve">
+    <value>Cannot use modifiers on the unnamed receiver parameter of extension block</value>
+  </data>
+  <data name="ERR_ExtensionTypeNameDisallowed" xml:space="preserve">
+    <value>Types and aliases cannot be named 'extension'.</value>
+  </data>
 </root>
@@ -2390,6 +2390,14 @@ internal enum ErrorCode
         ERR_PPIgnoredNeedsFileBasedProgram = 9298,
         ERR_PPIgnoredFollowsIf = 9299,
 
+        ERR_RefExtensionParameterMustBeValueTypeOrConstrainedToOne = 9300,
+        ERR_InExtensionParameterMustBeValueType = 9301,
+        ERR_ProtectedInExtension = 9302,
+        ERR_InstanceMemberWithUnnamedExtensionsParameter = 9303,
+        ERR_InitInExtension = 9304,
+        ERR_ModifierOnUnnamedReceiverParameter = 9305,
+        ERR_ExtensionTypeNameDisallowed = 9306,
+
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)
         //  2) Add message to CSharpResources.resx

@@ -2506,6 +2506,13 @@ or ErrorCode.ERR_ExpressionTreeContainsExtensionPropertyAccess
                 or ErrorCode.ERR_PPIgnoredFollowsToken
                 or ErrorCode.ERR_PPIgnoredNeedsFileBasedProgram
                 or ErrorCode.ERR_PPIgnoredFollowsIf
+                or ErrorCode.ERR_RefExtensionParameterMustBeValueTypeOrConstrainedToOne
+                or ErrorCode.ERR_InExtensionParameterMustBeValueType
+                or ErrorCode.ERR_ProtectedInExtension
+                or ErrorCode.ERR_InstanceMemberWithUnnamedExtensionsParameter
+                or ErrorCode.ERR_InitInExtension
+                or ErrorCode.ERR_ModifierOnUnnamedReceiverParameter
+                or ErrorCode.ERR_ExtensionTypeNameDisallowed
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

@@ -139,7 +139,7 @@ protected override void GenerateControlFields()
                 // Add a field: bool disposeMode
                 _disposeModeField = F.StateMachineField(boolType, GeneratedNames.MakeDisposeModeFieldName());
 
-                if (_isEnumerable && this.method.Parameters.Any(static p => p.IsSourceParameterWithEnumeratorCancellationAttribute()))
+                if (_isEnumerable && this.method.Parameters.Any(static p => !p.IsExtensionParameterImplementation() && p.HasEnumeratorCancellationAttribute))
                 {
                     // Add a field: CancellationTokenSource combinedTokens
                     _combinedTokensField = F.StateMachineField(
@@ -211,7 +211,8 @@ protected override BoundStatement InitializeParameterField(MethodSymbol getEnume
             {
                 BoundStatement result;
                 if (_combinedTokensField is object &&
-                    parameter.IsSourceParameterWithEnumeratorCancellationAttribute() &&
+                    !parameter.IsExtensionParameterImplementation() &&
+                    parameter.HasEnumeratorCancellationAttribute &&
                     parameter.Type.Equals(F.Compilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken), TypeCompareKind.ConsiderEverything))
                 {
                     // For a parameter of type CancellationToken with [EnumeratorCancellation]

@@ -78,6 +78,29 @@ protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymb
                 if (parameter is { })
                 {
                     checkUnderspecifiedGenericExtension(parameter, ContainingType.TypeParameters, diagnostics);
+
+                    TypeSymbol parameterType = parameter.TypeWithAnnotations.Type;
+                    RefKind parameterRefKind = parameter.RefKind;
+                    SyntaxNode? parameterTypeSyntax = parameterList.Parameters[0].Type;
+                    Debug.Assert(parameterTypeSyntax is not null);
+
+                    if (!parameterType.IsValidExtensionParameterType())
+                    {
+                        diagnostics.Add(ErrorCode.ERR_BadTypeforThis, parameterTypeSyntax, parameterType);
+                    }
+                    else if (parameterRefKind == RefKind.Ref && !parameterType.IsValueType)
+                    {
+                        diagnostics.Add(ErrorCode.ERR_RefExtensionParameterMustBeValueTypeOrConstrainedToOne, parameterTypeSyntax);
+                    }
+                    else if (parameterRefKind is RefKind.In or RefKind.RefReadOnlyParameter && parameterType.TypeKind != TypeKind.Struct)
+                    {
+                        diagnostics.Add(ErrorCode.ERR_InExtensionParameterMustBeValueType, parameterTypeSyntax);
+                    }
+
+                    if (parameter.Name is "" && parameterRefKind != RefKind.None)
+                    {
+                        diagnostics.Add(ErrorCode.ERR_ModifierOnUnnamedReceiverParameter, parameterTypeSyntax);
+                    }
                 }
 
                 if (parameter is { Name: var name } && name != "" &&

@@ -28,6 +28,7 @@ public FunctionPointerParameterSymbol(TypeWithAnnotations typeWithAnnotations, R
         public override int Ordinal { get; }
         public override Symbol ContainingSymbol => _containingSymbol;
         public override ImmutableArray<CustomModifier> RefCustomModifiers { get; }
+        internal override bool HasEnumeratorCancellationAttribute => false;
 
         internal override ScopedKind EffectiveScope
             => ParameterHelpers.IsRefScopedByDefault(this) ? ScopedKind.ScopedRef : ScopedKind.None;

@@ -111,6 +111,17 @@ internal static int GetMemberArityIncludingExtension(this Symbol member)
             return member.GetMemberArity();
         }
 
+        internal static ImmutableArray<ParameterSymbol> GetParametersIncludingExtensionParameter(this Symbol symbol)
+        {
+            // Tracked by https://github.com/dotnet/roslyn/issues/76130 : consider optimizing
+            if (symbol.GetIsNewExtensionMember() && symbol.ContainingType.ExtensionParameter is { } extensionParameter)
+            {
+                return [extensionParameter, .. symbol.GetParameters()];
+            }
+
+            return symbol.GetParameters();
+        }
+
         /// <summary>
         /// For an extension member, we distribute the type arguments between the extension declaration and the member.
         /// Otherwise, we just construct the member with the type arguments.

@@ -934,6 +934,8 @@ public override ImmutableArray<CustomModifier> RefCustomModifiers
             }
         }
 
+        internal sealed override bool HasEnumeratorCancellationAttribute => throw ExceptionUtilities.Unreachable();
+
         internal override bool IsMetadataIn
         {
             get { return (_flags & ParameterAttributes.In) != 0; }

@@ -68,6 +68,11 @@ protected sealed override Symbol OriginalSymbolDefinition
         /// </summary>
         public abstract ImmutableArray<CustomModifier> RefCustomModifiers { get; }
 
+        /// <summary>
+        /// Indicates whether the parameter has the EnumeratorCancellation attribute.
+        /// </summary>
+        internal abstract bool HasEnumeratorCancellationAttribute { get; }
+
         /// <summary>
         /// Describes how the parameter is marshalled when passed to native code.
         /// Null if no specific marshalling information is available for the parameter.

@@ -41,6 +41,8 @@ public SignatureOnlyParameterSymbol(
 
         public override ImmutableArray<CustomModifier> RefCustomModifiers { get { return _refCustomModifiers; } }
 
+        internal override bool HasEnumeratorCancellationAttribute { get { throw ExceptionUtilities.Unreachable(); } }
+
         public override bool IsParamsArray { get { return _isParamsArray; } }
 
         public override bool IsParamsCollection { get { return _isParamsCollection; } }

@@ -125,6 +125,11 @@ public override ImmutableArray<CustomModifier> RefCustomModifiers
             get { return _originalParam.RefCustomModifiers; }
         }
 
+        internal sealed override bool HasEnumeratorCancellationAttribute
+        {
+            get { return _originalParam.HasEnumeratorCancellationAttribute; }
+        }
+
         internal override MarshalPseudoCustomAttributeData MarshallingInformation
         {
             get { return _originalParam.MarshallingInformation; }

@@ -193,7 +193,7 @@ private static FlowAnalysisAnnotations DecodeFlowAnalysisAttributes(ParameterWel
         internal override ImmutableHashSet<string> NotNullIfParameterNotNull
             => GetDecodedWellKnownAttributeData()?.NotNullIfParameterNotNull ?? ImmutableHashSet<string>.Empty;
 
-        internal bool HasEnumeratorCancellationAttribute
+        internal override bool HasEnumeratorCancellationAttribute
         {
             get
             {
-Original file line number
+Diff line change
@@ Expand Up @@
                 }
             }
+            internal sealed override bool HasEnumeratorCancellationAttribute => throw ExceptionUtilities.Unreachable();
             internal override bool IsMetadataIn
             {
                 get { return (_flags & ParameterAttributes.In) != 0; }
@@ Expand Down @@